[IMP] *: improved performance of plugins using memory

Author: Gorash

packages/core/src/VNodes/AbstractNode.ts

@@ -1,4 +1,4 @@
-import { VNode, RelativePosition, Predicate, Typeguard, isLeaf } from './VNode';
+import { VNode, RelativePosition, Predicate, isLeaf } from './VNode';
 import {
     Constructor,
     nodeLength,
@@ -143,20 +143,6 @@ export abstract class AbstractNode extends EventMixin {
     get length(): number {
         return this.children().length;
     }
-    /**
-     * Return whether this node is an instance of the given VNode class.
-     *
-     * @param predicate The subclass of VNode to test this node against.
-     */
-    is<T extends VNode>(predicate: Constructor<T> | Typeguard<T>): this is T;
-    is(predicate: Predicate): false;
-    is(predicate: Predicate): boolean {
-        if (AbstractNode.isConstructor(predicate)) {
-            return this instanceof predicate;
-        } else {
-            return predicate(this as VNode);
-        }
-    }
     /**
      * Test this node against the given predicate.
      *
@@ -730,6 +716,7 @@ export abstract class AbstractNode extends EventMixin {
         return __repr;
     }
 }
+
 export interface AbstractNode {
     constructor: new <T extends Constructor<VNode>>(...args: ConstructorParameters<T>) => this;
 }

packages/core/src/VNodes/ContainerNode.ts

@@ -16,15 +16,19 @@ export class ContainerNode extends AbstractNode {
     children<T extends VNode>(predicate?: Predicate<T>): T[];
     children(predicate?: Predicate): VNode[];
     children(predicate?: Predicate): VNode[] {
-        return this.childVNodes.filter(child => {
-            return child.tangible && child.test(predicate);
+        const children: VNode[] = [];
+        this.childVNodes.forEach(child => {
+            if (child.tangible && (!predicate || child.test(predicate))) {
+                children.push(child);
+            }
         });
+        return children;
     }
     /**
      * See {@link AbstractNode.hasChildren}.
      */
     hasChildren(): boolean {
-        return this.children().length > 0;
+        return !!this.childVNodes.find(child => child.tangible);
     }
     /**
      * See {@link AbstractNode.nthChild}.
@@ -39,7 +43,7 @@ export class ContainerNode extends AbstractNode {
     firstChild(predicate?: Predicate): VNode;
     firstChild(predicate?: Predicate): VNode {
         let child = this.childVNodes[0];
-        while (child && !(child.tangible && child.test(predicate))) {
+        while (child && !(child.tangible && (!predicate || child.test(predicate)))) {
             child = child.nextSibling();
         }
         return child;
@@ -51,7 +55,7 @@ export class ContainerNode extends AbstractNode {
     lastChild(predicate?: Predicate): VNode;
     lastChild(predicate?: Predicate): VNode {
         let child = this.childVNodes[this.childVNodes.length - 1];
-        while (child && !(child.tangible && child.test(predicate))) {
+        while (child && !(child.tangible && (!predicate || child.test(predicate)))) {
             child = child.previousSibling();
         }
         return child;
@@ -63,7 +67,7 @@ export class ContainerNode extends AbstractNode {
     firstLeaf(predicate?: Predicate): VNode;
     firstLeaf(predicate?: Predicate): VNode {
         const isValidLeaf = (node: VNode): boolean => {
-            return isLeaf(node) && node.test(predicate);
+            return isLeaf(node) && (!predicate || node.test(predicate));
         };
         if (isValidLeaf(this)) {
             return this;
@@ -78,7 +82,7 @@ export class ContainerNode extends AbstractNode {
     lastLeaf(predicate?: Predicate): VNode;
     lastLeaf(predicate?: Predicate): VNode {
         const isValidLeaf = (node: VNode): boolean => {
-            return isLeaf(node) && node.test(predicate);
+            return isLeaf(node) && (!predicate || node.test(predicate));
         };
         if (isValidLeaf(this)) {
             return this;
@@ -93,7 +97,7 @@ export class ContainerNode extends AbstractNode {
     firstDescendant(predicate?: Predicate): VNode;
     firstDescendant(predicate?: Predicate): VNode {
         let firstDescendant = this.firstChild();
-        while (firstDescendant && !firstDescendant.test(predicate)) {
+        while (firstDescendant && predicate && !firstDescendant.test(predicate)) {
             firstDescendant = this._descendantAfter(firstDescendant);
         }
         return firstDescendant;
@@ -108,7 +112,7 @@ export class ContainerNode extends AbstractNode {
         while (lastDescendant && lastDescendant.hasChildren()) {
             lastDescendant = lastDescendant.lastChild();
         }
-        while (lastDescendant && !lastDescendant.test(predicate)) {
+        while (lastDescendant && predicate && !lastDescendant.test(predicate)) {
             lastDescendant = this._descendantBefore(lastDescendant);
         }
         return lastDescendant;
@@ -123,7 +127,7 @@ export class ContainerNode extends AbstractNode {
         const stack = [...this.childVNodes];
         while (stack.length) {
             const node = stack.shift();
-            if (node.tangible && node.test(predicate)) {
+            if (node.tangible && (!predicate || node.test(predicate))) {
                 descendants.push(node);
             }
             if (node instanceof ContainerNode) {
@@ -226,9 +230,11 @@ export class ContainerNode extends AbstractNode {
             return this;
         }
         const duplicate = this.clone();
-        const index = child.parent.childVNodes.indexOf(child);
-        while (this.childVNodes.length > index) {
-            duplicate.append(this.childVNodes[index]);
+        const index = this.childVNodes.indexOf(child);
+        const children = this.childVNodes.splice(index);
+        duplicate.childVNodes.push(...children);
+        for (const child of children) {
+            child.parent = duplicate;
         }
         this.after(duplicate);
         return duplicate;

packages/core/src/VRange.ts

@@ -240,7 +240,7 @@ export class VRange {
         } else if (position === RelativePosition.AFTER) {
             reference = reference.lastLeaf();
         }
-        if (reference.is(ContainerNode) && !reference.hasChildren()) {
+        if (reference instanceof ContainerNode && !reference.hasChildren()) {
             reference.prepend(this.start);
         } else if (position === RelativePosition.AFTER && reference !== this.end) {
             // We check that `reference` isn't `this.end` to avoid a backward
@@ -266,7 +266,7 @@ export class VRange {
         } else if (position === RelativePosition.AFTER) {
             reference = reference.lastLeaf();
         }
-        if (reference.is(ContainerNode) && !reference.hasChildren()) {
+        if (reference instanceof ContainerNode && !reference.hasChildren()) {
             reference.append(this.end);
         } else if (position === RelativePosition.BEFORE && reference !== this.start) {
             // We check that `reference` isn't `this.start` to avoid a backward
@@ -366,7 +366,7 @@ export class VRange {
     empty(): void {
         const removableNodes = this.selectedNodes(node => {
             // TODO: Replace Table check with complex table selection support.
-            return this.mode.is(node, RuleProperty.EDITABLE) && !node.is(TableCellNode);
+            return this.mode.is(node, RuleProperty.EDITABLE) && !(node instanceof TableCellNode);
         });
         // Remove selected nodes without touching the start range's ancestors.
         const startAncestors = this.start.ancestors();

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];

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);
 

packages/plugin-char/src/Char.ts

@@ -50,10 +50,18 @@ export class Char<T extends JWPluginConfig = JWPluginConfig> extends JWPlugin<T>
         let modifiers = inline.getCurrentModifiers(range);
         // Ony preserved modifiers are applied at the start of a container.
         const previousSibling = range.start.previousSibling();
-        if (!previousSibling) {
-            modifiers = new Modifiers(...modifiers.filter(mod => mod.preserve));
+        if (!previousSibling && modifiers) {
+            const preservedModifiers = modifiers.filter(mod => mod.preserve);
+            if (preservedModifiers.length) {
+                modifiers = new Modifiers(...preservedModifiers);
+            } else {
+                modifiers = null;
+            }
         }
         if (params.formats) {
+            if (!modifiers) {
+                modifiers = new Modifiers();
+            }
             modifiers.set(...params.formats.map(format => format.clone()));
         }
         const style = inline.getCurrentStyle(range);
@@ -64,17 +72,20 @@ export class Char<T extends JWPluginConfig = JWPluginConfig> extends JWPlugin<T>
         // Split the text into CHAR nodes and insert them at the range.
         const characters = text.split('');
         const charNodes = characters.map(char => {
-            return new CharNode({ char: char, modifiers: modifiers.clone() });
+            if (modifiers) {
+                return new CharNode({ char: char, modifiers: modifiers.clone() });
+            } else {
+                return new CharNode({ char: char });
+            }
         });
         charNodes.forEach(charNode => {
-            if (style.length) {
+            if (style?.length) {
                 charNode.modifiers.get(Attributes).style = style;
             }
             range.start.before(charNode);
         });
         if (params.select && charNodes.length) {
             this.editor.selection.select(charNodes[0], charNodes[charNodes.length - 1]);
         }
-        inline.resetCache();
     }
 }

packages/plugin-char/src/CharDomObjectRenderer.ts

@@ -43,11 +43,11 @@ export class CharDomObjectRenderer extends NodeRenderer<DomObject> {
         // Render block edge spaces as non-breakable space (otherwise browsers
         // won't render them).
         const previous = charNodes[0].previousSibling();
-        if (!previous || !previous.is(InlineNode)) {
+        if (!previous || !(previous instanceof InlineNode)) {
             texts[0] = texts[0].replace(/^ /g, '\u00A0');
         }
         const next = charNodes[charNodes.length - 1].nextSibling();
-        if (!next || !next.is(InlineNode)) {
+        if (!next || !(next instanceof InlineNode)) {
             texts[texts.length - 1] = texts[texts.length - 1].replace(/^ /g, '\u00A0');
         }
         const textObject = { text: texts.join('') };

packages/plugin-color/src/Color.ts

@@ -109,7 +109,7 @@ export class Color<T extends ColorConfig = ColorConfig> extends JWPlugin<T> {
                 // Uncolor the children and their formats as well.
                 for (const child of node.children()) {
                     child.modifiers.find(Attributes)?.style.remove(this.styleName);
-                    if (child.is(InlineNode)) {
+                    if (child instanceof InlineNode) {
                         for (const format of child.modifiers.filter(Format)) {
                             format.modifiers.find(Attributes)?.style.remove(this.styleName);
                         }

packages/plugin-devtools/src/components/InfoComponent.ts

@@ -50,9 +50,9 @@ export class InfoComponent extends OwlComponent<{}> {
     propRepr(vNode: VNode, propName: string): string {
         let prop = vNode[propName];
         if (propName === 'atomic') {
-            if (vNode.is(AtomicNode)) {
+            if (vNode instanceof AtomicNode) {
                 return 'true';
-            } else if (vNode.is(ContainerNode)) {
+            } else if (vNode instanceof ContainerNode) {
                 return 'false';
             } else {
                 return '?';

packages/plugin-devtools/src/components/InspectorComponent.ts

@@ -222,7 +222,7 @@ export class InspectorComponent extends OwlComponent<InspectorComponentProps> {
             nodes = this.domEngine.getNodes(node);
             node = node.parentNode;
         }
-        if (nodes.length && nodes[0].is(CharNode) && nodes[caretPosition.offset]) {
+        if (nodes[0] instanceof CharNode && nodes[caretPosition.offset]) {
             return [nodes[caretPosition.offset]];
         }
         return nodes;