perf for attributes + instanceof

Gorash · Gorash · commit 04fcb7e5cf31 · 2020-07-25T11:16:42.000+02:00
diff --git a/packages/plugin-blockquote/src/BlockquoteXmlDomParser.ts b/packages/plugin-blockquote/src/BlockquoteXmlDomParser.ts
@@ -13,7 +13,10 @@ export class BlockquoteXmlDomParser extends AbstractParser<Node> {
 
     async parse(item: Element): Promise<BlockquoteNode[]> {
         const blockquote = new BlockquoteNode();
-        blockquote.modifiers.append(this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (attributes.length) {
+            blockquote.modifiers.append(attributes);
+        }
         const nodes = await this.engine.parse(...item.childNodes);
         blockquote.append(...nodes);
         return [blockquote];
diff --git a/packages/plugin-bold/src/BoldXmlDomParser.ts b/packages/plugin-bold/src/BoldXmlDomParser.ts
@@ -15,7 +15,10 @@ export class BoldXmlDomParser extends FormatXmlDomParser {
      */
     async parse(item: Element): Promise<VNode[]> {
         const bold = new BoldFormat(nodeName(item) as 'B' | 'STRONG');
-        bold.modifiers.append(this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (attributes.length) {
+            bold.modifiers.append(attributes);
+        }
         const children = await this.engine.parse(...item.childNodes);
         this.applyFormat(bold, children);
 
diff --git a/packages/plugin-divider/src/DividerXmlDomParser.ts b/packages/plugin-divider/src/DividerXmlDomParser.ts
@@ -13,7 +13,10 @@ export class DividerXmlDomParser extends AbstractParser<Node> {
 
     async parse(item: Element): Promise<DividerNode[]> {
         const divider = new DividerNode();
-        divider.modifiers.append(this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (attributes.length) {
+            divider.modifiers.append(attributes);
+        }
 
         const nodes = await this.engine.parse(...item.childNodes);
         divider.append(...nodes);
diff --git a/packages/plugin-heading/src/HeadingXmlDomParser.ts b/packages/plugin-heading/src/HeadingXmlDomParser.ts
@@ -15,7 +15,10 @@ export class HeadingXmlDomParser extends AbstractParser<Node> {
 
     async parse(item: Element): Promise<HeadingNode[]> {
         const heading = new HeadingNode({ level: parseInt(nodeName(item)[1], 10) });
-        heading.modifiers.append(this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (attributes.length) {
+            heading.modifiers.append(attributes);
+        }
         const nodes = await this.engine.parse(...item.childNodes);
         heading.append(...nodes);
         return [heading];
diff --git a/packages/plugin-input/src/InputXmlDomParser.ts b/packages/plugin-input/src/InputXmlDomParser.ts
@@ -18,12 +18,14 @@ export class InputXmlDomParser extends AbstractParser<Node> {
             name: item.getAttribute('name'),
             value: item.value,
         });
-        input.modifiers.append(this.engine.parseAttributes(item));
-        const attributes = input.modifiers.find(Attributes);
+        const attributes = this.engine.parseAttributes(item);
         if (attributes) {
             attributes.remove('type'); // type is on input.inputType
             attributes.remove('name'); // type is on input.inputName
         }
+        if (attributes.length) {
+            input.modifiers.append(attributes);
+        }
         const nodes = await this.engine.parse(...item.childNodes);
         input.append(...nodes);
         return [input];
diff --git a/packages/plugin-italic/src/ItalicXmlDomParser.ts b/packages/plugin-italic/src/ItalicXmlDomParser.ts
@@ -15,7 +15,10 @@ export class ItalicXmlDomParser extends FormatXmlDomParser {
      */
     async parse(item: Element): Promise<VNode[]> {
         const italic = new ItalicFormat(nodeName(item) as 'I' | 'EM');
-        italic.modifiers.append(this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (attributes.length) {
+            italic.modifiers.append(attributes);
+        }
         const children = await this.engine.parse(...item.childNodes);
         this.applyFormat(italic, children);
 
diff --git a/packages/plugin-linebreak/src/LineBreakXmlDomParser.ts b/packages/plugin-linebreak/src/LineBreakXmlDomParser.ts
@@ -17,7 +17,10 @@ export class LineBreakXmlDomParser extends AbstractParser<Node> {
             return [];
         }
         const lineBreak = new LineBreakNode();
-        lineBreak.modifiers.append(this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (attributes.length) {
+            lineBreak.modifiers.append(attributes);
+        }
         return [lineBreak];
     }
 
diff --git a/packages/plugin-link/src/LinkFormat.ts b/packages/plugin-link/src/LinkFormat.ts
@@ -22,11 +22,13 @@ export class LinkFormat extends Format {
     }
 
     get target(): string {
-        return this.modifiers.find(Attributes)?.get('target');
+        return this.modifiers.find(Attributes)?.get('target') || '';
     }
 
-    set target(url: string) {
-        this.modifiers.get(Attributes).set('target', url);
+    set target(target: string) {
+        if (target.length) {
+            this.modifiers.get(Attributes).set('target', target);
+        }
     }
 
     //--------------------------------------------------------------------------
diff --git a/packages/plugin-link/src/LinkXmlDomParser.ts b/packages/plugin-link/src/LinkXmlDomParser.ts
@@ -13,7 +13,10 @@ export class LinkXmlDomParser extends FormatXmlDomParser {
         const link = new LinkFormat(item.getAttribute('href'));
         // TODO: Link should not have an `Attributes` modifier outside of XML.
         // In XML context we need to conserve the order of attributes.
-        link.modifiers.replace(Attributes, this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (attributes.length) {
+            link.modifiers.replace(Attributes, attributes);
+        }
         const children = await this.engine.parse(...item.childNodes);
         this.applyFormat(link, children);
 
diff --git a/packages/plugin-link/src/components/LinkComponent.ts b/packages/plugin-link/src/components/LinkComponent.ts
@@ -1,6 +1,4 @@
 import { OwlComponent } from '../../../plugin-owl/src/OwlComponent';
-import { InlineNode } from '../../../plugin-inline/src/InlineNode';
-import { LinkFormat } from '../LinkFormat';
 import { LinkParams } from '../Link';
 import { Layout } from '../../../plugin-layout/src/Layout';
 import { useState } from '@odoo/owl';
diff --git a/packages/plugin-list/src/List.ts b/packages/plugin-list/src/List.ts
@@ -271,7 +271,7 @@ export class List<T extends JWPluginConfig = JWPluginConfig> extends JWPlugin<T>
      */
     indent(params: IndentParams): void {
         const range = params.context.range;
-        const items = range.targetedNodes(node => node.parent?.test(ListNode));
+        const items = range.targetedNodes(node => node.parent instanceof ListNode);
 
         // Do not indent items of a targeted nested list, since they
         // will automatically be indented with their list ancestor.
diff --git a/packages/plugin-list/src/ListXmlDomParser.ts b/packages/plugin-list/src/ListXmlDomParser.ts
@@ -31,7 +31,13 @@ export class ListXmlDomParser extends AbstractParser<Node> {
 
         // Create the list node and parse its children and attributes.
         const list = new ListNode({ listType: type });
-        list.modifiers.append(this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (type === ListType.CHECKLIST) {
+            attributes.classList.remove('checklist');
+        }
+        if (attributes.length) {
+            list.modifiers.append(attributes);
+        }
         const children = await this.engine.parse(...item.childNodes);
         list.append(...children);
 
diff --git a/packages/plugin-paragraph/src/ParagraphXmlDomParser.ts b/packages/plugin-paragraph/src/ParagraphXmlDomParser.ts
@@ -13,7 +13,10 @@ export class ParagraphXmlDomParser extends AbstractParser<Node> {
 
     async parse(item: Element): Promise<ParagraphNode[]> {
         const paragraph = new ParagraphNode();
-        paragraph.modifiers.append(this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (attributes.length) {
+            paragraph.modifiers.append(attributes);
+        }
         const nodes = await this.engine.parse(...item.childNodes);
         paragraph.append(...nodes);
         return [paragraph];
diff --git a/packages/plugin-pre/src/PreSeparatorDomObjectRenderer.ts b/packages/plugin-pre/src/PreSeparatorDomObjectRenderer.ts
@@ -14,7 +14,7 @@ export class PreSeparatorDomObjectRenderer extends NodeRenderer<DomObject> {
 
     predicate = (item: VNode): boolean => {
         const DefaultSeparator = this.engine.editor.configuration.defaults.Separator;
-        return item.is(DefaultSeparator) && !!item.ancestor(PreNode);
+        return item instanceof DefaultSeparator && !!item.ancestor(PreNode);
     };
 
     /**
diff --git a/packages/plugin-pre/src/PreXmlDomParser.ts b/packages/plugin-pre/src/PreXmlDomParser.ts
@@ -13,7 +13,10 @@ export class PreXmlDomParser extends AbstractParser<Node> {
 
     async parse(item: Element): Promise<PreNode[]> {
         const pre = new PreNode();
-        pre.modifiers.append(this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (attributes.length) {
+            pre.modifiers.append(attributes);
+        }
         const children = await this.engine.parse(...item.childNodes);
         pre.append(...children);
         return [pre];
diff --git a/packages/plugin-renderer-dom-object/src/DefaultDomObjectRenderer.ts b/packages/plugin-renderer-dom-object/src/DefaultDomObjectRenderer.ts
@@ -17,7 +17,7 @@ export class DefaultDomObjectRenderer extends NodeRenderer<DomObject> {
                     tag: node.htmlTag,
                     children: await this.engine.renderChildren(node),
                 };
-            } else if (node.test(FragmentNode)) {
+            } else if (node instanceof FragmentNode) {
                 domObject = {
                     children: await this.engine.renderChildren(node),
                 };
diff --git a/packages/plugin-shadow/src/ShadowHtmlDomParser.ts b/packages/plugin-shadow/src/ShadowHtmlDomParser.ts
@@ -28,7 +28,10 @@ export class ShadowHtmlDomParser extends AbstractParser<Node> {
             return [shadow];
         } else {
             const element = new VElement({ htmlTag: nodeName(item) });
-            element.modifiers.append(this.engine.parseAttributes(item));
+            const attributes = this.engine.parseAttributes(item);
+            if (attributes.length) {
+                element.modifiers.append(attributes);
+            }
             element.append(shadow);
             return [element];
         }
diff --git a/packages/plugin-shadow/src/ShadowXmlDomParser.ts b/packages/plugin-shadow/src/ShadowXmlDomParser.ts
@@ -19,7 +19,10 @@ export class ShadowXmlDomParser extends AbstractParser<Node> {
      */
     async parse(item: Element): Promise<VNode[]> {
         const shadow = new ShadowNode();
-        shadow.modifiers.append(this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (attributes.length) {
+            shadow.modifiers.append(attributes);
+        }
         const nodes = await this.engine.parse(...item.childNodes);
         shadow.append(...nodes);
         return [shadow];
diff --git a/packages/plugin-span/src/SpanXmlDomParser.ts b/packages/plugin-span/src/SpanXmlDomParser.ts
@@ -16,7 +16,10 @@ export class SpanXmlDomParser extends FormatXmlDomParser {
      */
     async parse(item: Element): Promise<VNode[]> {
         const span = new SpanFormat(nodeName(item) as 'SPAN' | 'FONT');
-        span.modifiers.append(this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (attributes.length) {
+            span.modifiers.append(attributes);
+        }
         const children = await this.engine.parse(...item.childNodes);
         // Handle empty spans.
         if (!children.length) {
diff --git a/packages/plugin-subscript/src/SubscriptXmlDomParser.ts b/packages/plugin-subscript/src/SubscriptXmlDomParser.ts
@@ -15,7 +15,10 @@ export class SubscriptXmlDomParser extends FormatXmlDomParser {
      */
     async parse(item: Element): Promise<VNode[]> {
         const subscript = new SubscriptFormat();
-        subscript.modifiers.append(this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (attributes.length) {
+            subscript.modifiers.append(attributes);
+        }
         const children = await this.engine.parse(...item.childNodes);
         this.applyFormat(subscript, children);
 
diff --git a/packages/plugin-superscript/src/SuperscriptXmlDomParser.ts b/packages/plugin-superscript/src/SuperscriptXmlDomParser.ts
@@ -15,7 +15,10 @@ export class SuperscriptXmlDomParser extends FormatXmlDomParser {
      */
     async parse(item: Element): Promise<VNode[]> {
         const superscript = new SuperscriptFormat();
-        superscript.modifiers.append(this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (attributes.length) {
+            superscript.modifiers.append(attributes);
+        }
         const children = await this.engine.parse(...item.childNodes);
         this.applyFormat(superscript, children);
 
diff --git a/packages/plugin-table/src/TableCellDomObjectRenderer.ts b/packages/plugin-table/src/TableCellDomObjectRenderer.ts
@@ -22,7 +22,6 @@ export class TableCellDomObjectRenderer extends NodeRenderer<DomObject> {
             attributes: {},
         };
 
-        // Render attributes.
         // Colspan and rowspan are handled differently from other attributes:
         // they are automatically calculated in function of the cell's managed
         // cells. Render them here. If their value is 1 or less, they are
diff --git a/packages/plugin-table/src/TableCellXmlDomParser.ts b/packages/plugin-table/src/TableCellXmlDomParser.ts
@@ -19,7 +19,10 @@ export class TableCellXmlDomParser extends AbstractParser<Node> {
      */
     async parse(item: HTMLTableCellElement): Promise<TableCellNode[]> {
         const cell = new TableCellNode({ header: nodeName(item) === 'TH' });
-        cell.modifiers.append(this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (attributes.length) {
+            cell.modifiers.append(attributes);
+        }
         const children = await this.engine.parse(...item.childNodes);
         cell.append(...children);
         return [cell];
diff --git a/packages/plugin-table/src/TableRowXmlDomParser.ts b/packages/plugin-table/src/TableRowXmlDomParser.ts
@@ -26,7 +26,10 @@ export class TableRowXmlDomParser extends AbstractParser<Node> {
             return this.parseTableSection(item);
         } else if (nodeName(item) === 'TR') {
             const row = new TableRowNode();
-            row.modifiers.append(this.engine.parseAttributes(item));
+            const attributes = this.engine.parseAttributes(item);
+            if (attributes.length) {
+                row.modifiers.append(attributes);
+            }
             const cells = await this.engine.parse(...item.childNodes);
             row.append(...cells);
             return [row];
diff --git a/packages/plugin-table/src/TableXmlDomParser.ts b/packages/plugin-table/src/TableXmlDomParser.ts
@@ -22,7 +22,10 @@ export class TableXmlDomParser extends AbstractParser<Node> {
     async parse(item: HTMLTableElement): Promise<TableNode[]> {
         // Parse the table itself and its attributes.
         const table = new TableNode();
-        table.modifiers.append(this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (attributes.length) {
+            table.modifiers.append(attributes);
+        }
 
         // Parse the contents of the table.
         const children = await this.engine.parse(...item.childNodes);
diff --git a/packages/plugin-theme/src/ThemeXmlDomParser.ts b/packages/plugin-theme/src/ThemeXmlDomParser.ts
@@ -3,7 +3,6 @@ import { AbstractParser } from '../../plugin-parser/src/AbstractParser';
 import { XmlDomParsingEngine } from '../../plugin-xml/src/XmlDomParsingEngine';
 import { ThemeNode } from './ThemeNode';
 import { nodeName } from '../../utils/src/utils';
-import { Attributes } from '../../plugin-xml/src/Attributes';
 
 export class ThemeXmlDomParser extends AbstractParser<Node> {
     static id = XmlDomParsingEngine.id;
@@ -20,8 +19,11 @@ export class ThemeXmlDomParser extends AbstractParser<Node> {
      */
     async parse(item: Element): Promise<VNode[]> {
         const theme = new ThemeNode({ theme: item.getAttribute('name') });
-        theme.modifiers.append(this.engine.parseAttributes(item));
-        theme.modifiers.find(Attributes)?.remove('name');
+        const attributes = this.engine.parseAttributes(item);
+        attributes.classList.remove('name');
+        if (attributes.length) {
+            theme.modifiers.append(attributes);
+        }
         const nodes = await this.engine.parse(...item.childNodes);
         theme.append(...nodes);
         return [theme];
diff --git a/packages/plugin-underline/src/UnderlineXmlDomParser.ts b/packages/plugin-underline/src/UnderlineXmlDomParser.ts
@@ -15,7 +15,10 @@ export class UnderlineXmlDomParser extends FormatXmlDomParser {
      */
     async parse(item: Element): Promise<VNode[]> {
         const underline = new UnderlineFormat();
-        underline.modifiers.append(this.engine.parseAttributes(item));
+        const attributes = this.engine.parseAttributes(item);
+        if (attributes.length) {
+            underline.modifiers.append(attributes);
+        }
         const children = await this.engine.parse(...item.childNodes);
         this.applyFormat(underline, children);
 
diff --git a/packages/plugin-xml/src/Attributes.ts b/packages/plugin-xml/src/Attributes.ts
diff --git a/packages/plugin-xml/src/ClassList.ts b/packages/plugin-xml/src/ClassList.ts
diff --git a/packages/plugin-xml/src/CssStyle.ts b/packages/plugin-xml/src/CssStyle.ts
diff --git a/packages/plugin-xml/src/DefaultXmlDomParser.ts b/packages/plugin-xml/src/DefaultXmlDomParser.ts

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,10 @@ export class LineBreakXmlDomParser extends AbstractParser<Node> {`
`17`	`17`	`return [];`
`18`	`18`	`}`
`19`	`19`	`const lineBreak = new LineBreakNode();`
`20`		`- lineBreak.modifiers.append(this.engine.parseAttributes(item));`
	`20`	`+ const attributes = this.engine.parseAttributes(item);`
	`21`	`+ if (attributes.length) {`
	`22`	`+ lineBreak.modifiers.append(attributes);`
	`23`	`+ }`
`21`	`24`	`return [lineBreak];`
`22`	`25`	`}`
`23`	`26`
Original file line number	Diff line number	Diff line change
`@@ -22,11 +22,13 @@ export class LinkFormat extends Format {`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`get target(): string {`
`25`		`- return this.modifiers.find(Attributes)?.get('target');`
	`25`	`+ return this.modifiers.find(Attributes)?.get('target') \|\| '';`
`26`	`26`	`}`
`27`	`27`
`28`		`- set target(url: string) {`
`29`		`- this.modifiers.get(Attributes).set('target', url);`
	`28`	`+ set target(target: string) {`
	`29`	`+ if (target.length) {`
	`30`	`+ this.modifiers.get(Attributes).set('target', target);`
	`31`	`+ }`
`30`	`32`	`}`
`31`	`33`
`32`	`34`	`//--------------------------------------------------------------------------`