imp

Author: Gorash

packages/core/src/JWEditor.ts

@@ -11,6 +11,7 @@ import { AtomicNode } from './VNodes/AtomicNode';
 import { SeparatorNode } from './VNodes/SeparatorNode';
 import { Memory } from './Memory/Memory';
 import { makeVersionable, markNotVersionable } from './Memory/Versionable';
+import { VersionableArray } from './Memory/VersionableArray';
 
 export enum Mode {
     CONFIGURATION = 'configuration',
@@ -61,7 +62,7 @@ export class JWEditor {
     };
     memory: Memory;
     memoryID = 0;
-    private memoryInfo: { commandNames: string[] };
+    memoryInfo: { commandNames: string[] };
     selection = new VSelection();
     loaders: Record<string, Loader> = {};
     private mutex = Promise.resolve();
@@ -323,9 +324,7 @@ export class JWEditor {
         if (isFrozen) {
             // Switch to the next memory slice (unfreeze the memory).
             this.memory.switchTo(this.memoryID.toString());
-            const commandNames = [];
-            markNotVersionable(commandNames);
-            this.memoryInfo.commandNames = commandNames;
+            this.memoryInfo.commandNames = new VersionableArray();
         }
         await callback();
         if (isFrozen) {

packages/plugin-dom-layout/src/ActionableDomObjectRenderer.ts

@@ -71,11 +71,11 @@ export class ActionableDomObjectRenderer extends AbstractRenderer<DomObject> {
      * @param element
      */
     protected _updateActionables(): void {
-        const pathChanges = this.engine.editor.memory.getChangedVersionables();
-        for (const [n, p] of pathChanges) {
-            console.log(n.name, p);
+        const commandNames = this.engine.editor.memoryInfo.commandNames;
+        if (commandNames.length === 1 && commandNames.includes('insertText')) {
+            // By default the actionable buttons are not update for a text insertion.
+            return;
         }
-
         for (const [aactionable, element] of this.actionableNodes) {
             const editor = this.engine.editor;
             const select = !!aactionable.selected(editor);

packages/plugin-dom-layout/src/ActionableGroupSelectItemDomObjectRenderer.ts

@@ -122,6 +122,11 @@ export class ActionableGroupSelectItemDomObjectRenderer extends AbstractRenderer
      * @param element
      */
     protected _updateActionables(): void {
+        const commandNames = this.engine.editor.memoryInfo.commandNames;
+        if (commandNames.length === 1 && commandNames.includes('insertText')) {
+            // By default the actionable buttons are not update for a text insertion.
+            return;
+        }
         for (const [aactionable, element] of this.actionableNodes) {
             const editor = this.engine.editor;
             const select = aactionable.selected(editor);

packages/plugin-dom-layout/src/DomLayout.ts

@@ -153,31 +153,51 @@ export class DomLayout<T extends DomLayoutConfig = DomLayoutConfig> extends JWPl
     private async _redraw(): Promise<void> {
         const layout = this.dependencies.get(Layout);
         const domLayoutEngine = layout.engines.dom as DomLayoutEngine;
-        const pathChanges = this.editor.memory.getChangedVersionables();
+        const pathChanges = new Map(this.editor.memory.getChangedVersionables());
         if (pathChanges.size) {
             const nodes = [];
-            for (const [root, paths] of pathChanges) {
+            // for (const [root] of pathChanges) {
+            //     if (
+            //         !(root instanceof AbstractNode) ||
+            //         root === this.editor.selection.anchor ||
+            //         root === this.editor.selection.focus
+            //     ) {
+            //         // Filter not VNode changes and selection change.
+            //         pathChanges.delete(root);
+            //     }
+            // }
+            let removedNode = false;
+            for (const [root] of pathChanges) {
                 if (root instanceof AbstractNode) {
-                    if (!nodes.includes(root)) {
-                        nodes.push(root);
+                    nodes.push(root);
+                    if (!root.parent) {
+                        removedNode = true;
                     }
-                    if (paths.find(path => path[0] === 'childVNodes')) {
-                        // Need to force redrawing of children if remove a child.
-                        for (const node of [...nodes]) {
-                            if (node instanceof ContainerNode) {
-                                for (const child of node.childVNodes) {
-                                    const index = nodes.indexOf(child);
-                                    if (index !== -1) {
-                                        nodes.splice(index, 1);
+                }
+            }
+            if (removedNode) {
+                // Need to force redrawing of children if remove a child.
+                for (const [root, paths] of pathChanges) {
+                    if (root instanceof AbstractNode) {
+                        if (paths.find(path => path[0] === 'childVNodes')) {
+                            for (const node of [...nodes]) {
+                                if (node instanceof ContainerNode) {
+                                    for (const child of node.childVNodes) {
+                                        const index = nodes.indexOf(child);
+                                        if (index !== -1) {
+                                            nodes.splice(index, 1);
+                                        }
+                                        nodes.push(child);
                                     }
-                                    nodes.push(child);
                                 }
                             }
                         }
                     }
                 }
             }
-            console.log(nodes.map(n => n.name).filter(g => g.length > 1));
+
+            console.log(pathChanges);
+            console.log(nodes.map(n => n.name));
             await domLayoutEngine.redraw(nodes);
         }
     }