@acorex/platform 18.0.15 → 18.0.16

package/esm2022/layout/designer/lib/designer/shared/command.mjs

@@ -0,0 +1,185 @@
+import { computed, Injectable, signal } from "@angular/core";
+import { cloneDeep, merge } from "lodash-es";
+import * as i0 from "@angular/core";
+// AddWidgetCommand
+export class AddWidgetCommand {
+    constructor(widget, parent, previousSelection) {
+        this.widget = widget;
+        this.parent = parent;
+        this.previousSelection = previousSelection;
+    }
+    execute() {
+        this.parent.children = this.parent.children || [];
+        this.parent.children.push(this.widget);
+    }
+    undo() {
+        this.parent.children = this.parent.children || [];
+        const index = this.parent.children.indexOf(this.widget);
+        if (index > -1) {
+            this.parent.children.splice(index, 1);
+        }
+    }
+    description() {
+        return `Added widget ${this.widget.name}`;
+    }
+    icon() {
+        return `fa-solid fa-square-plus`;
+    }
+    getExecutionSelection() {
+        return this.widget; // After executing, select the newly added widget
+    }
+    getUndoSelection() {
+        return this.previousSelection; // After undo, select the previously selected widget
+    }
+}
+export class RemoveWidgetCommand {
+    constructor(widget, parent, previousSelection) {
+        this.widget = widget;
+        this.parent = parent;
+        this.previousSelection = previousSelection;
+        parent.children = parent.children || [];
+        this.index = parent.children.indexOf(widget); // Capture the index for undo purposes
+    }
+    execute() {
+        this.parent.children = this.parent.children || [];
+        this.index = this.parent.children.indexOf(this.widget); // Re-assert the index in case it has changed
+        this.parent.children.splice(this.index, 1);
+    }
+    undo() {
+        this.parent.children = this.parent.children || [];
+        this.parent.children.splice(this.index, 0, this.widget); // Reinsert at the original index
+    }
+    description() {
+        return `Removed widget ${this.widget.name}`;
+    }
+    icon() {
+        return `fa-solid fa-square-minus`;
+    }
+    getExecutionSelection() {
+        return this.previousSelection; // Typically the parent or a nearby sibling could be focused
+    }
+    getUndoSelection() {
+        return this.widget; // Select the widget itself when the operation is undone
+    }
+}
+export class UpdateWidgetCommand {
+    constructor(widget, values, previousSelection) {
+        this.widget = widget;
+        this.newState = merge(cloneDeep(widget), values);
+        this.previousSelection = previousSelection;
+        this.previousState = cloneDeep(widget);
+    }
+    execute() {
+        merge(this.widget, this.newState);
+    }
+    undo() {
+        this.deepPruneAndRestore(this.widget, this.previousState);
+    }
+    description() {
+        return `Updated widget ${this.widget.name}`;
+    }
+    icon() {
+        return `fa-solid fa-pen-to-square`;
+    }
+    getExecutionSelection() {
+        return this.widget; // Focus the widget after it's updated
+    }
+    getUndoSelection() {
+        return this.previousSelection; // Restore the focus to where it was before the update
+    }
+    deepPruneAndRestore(current, original) {
+        Object.keys(current).forEach(key => {
+            if (original.hasOwnProperty(key)) {
+                if (typeof current[key] === 'object' && current[key] !== null && !(current[key] instanceof Array)) {
+                    this.deepPruneAndRestore(current[key], original[key]);
+                }
+            }
+            else {
+                delete current[key]; // Remove properties not present in original
+            }
+        });
+        // Restore the original properties
+        merge(current, original);
+    }
+}
+export class CommandManager {
+    constructor() {
+        this.undoStack = signal([]);
+        this.currentIndex = signal(-1);
+        this.selectedNode = signal(null);
+        this.canUndo = computed(() => this.currentIndex() >= 0);
+        this.canRedo = computed(() => this.currentIndex() < this.undoStack().length - 1);
+        this.history = computed(() => this.undoStack().map((cmd, index) => ({
+            description: cmd.description(),
+            icon: cmd.icon(),
+            isPast: this.currentIndex() > index,
+            isFuture: this.currentIndex() < index,
+            isCurrent: this.currentIndex() == index
+        })));
+    }
+    executeCommand(command) {
+        // Check if the currentIndex is not at the end of the undoStack
+        if (this.currentIndex() !== this.undoStack().length - 1) {
+            // Remove all commands beyond the current index to discard the "future" commands
+            const newUndoStack = this.undoStack().slice(0, this.currentIndex() + 1);
+            this.undoStack.set(newUndoStack);
+        }
+        command.execute();
+        this.undoStack.set([...this.undoStack(), command]); // Add the new command to the stack
+        this.currentIndex.set(this.undoStack().length - 1); // Update currentIndex to the end of the stack
+        this.selectedNode.set(command.getExecutionSelection()); // Update the selected node
+    }
+    undo() {
+        if (this.currentIndex() >= 0) {
+            const command = this.undoStack()[this.currentIndex()];
+            command.undo();
+            this.currentIndex.set(this.currentIndex() - 1);
+            if (this.currentIndex() >= 0) {
+                this.selectedNode.set(this.undoStack()[this.currentIndex()].getUndoSelection());
+            }
+            else {
+                this.selectedNode.set(null); // No selection if all commands are undone
+            }
+        }
+    }
+    redo() {
+        if (this.currentIndex() < this.undoStack().length - 1) {
+            this.currentIndex.set(this.currentIndex() + 1);
+            const command = this.undoStack()[this.currentIndex()];
+            command.execute();
+            this.selectedNode.set(command.getExecutionSelection());
+        }
+    }
+    goToCommand(index) {
+        if (index < 0 || index >= this.undoStack().length || index === this.currentIndex()) {
+            return; // Out of bounds or already at the desired index
+        }
+        if (index > this.currentIndex()) {
+            // Need to redo until reaching the desired index
+            while (this.currentIndex() < index) {
+                this.redo();
+            }
+        }
+        else {
+            // Need to undo until reaching the desired index
+            while (this.currentIndex() > index) {
+                this.undo();
+            }
+        }
+        // Optionally update any UI components or state here
+        this.selectedNode.set(this.undoStack()[this.currentIndex()].getExecutionSelection());
+    }
+    clear() {
+        this.undoStack.set([]);
+        this.currentIndex.set(-1);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: CommandManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: CommandManager, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: CommandManager, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"command.js","sourceRoot":"","sources":["../../../../../../../../../libs/platform/layout/designer/src/lib/designer/shared/command.ts"],"names":[],"mappings":"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","sourcesContent":["import { AXPWidgetNode } from \"@acorex/platform/layout/builder\";\nimport { computed, Injectable, signal } from \"@angular/core\";\nimport { cloneDeep, merge } from \"lodash-es\";\n\n// Command interface\nexport interface Command {\n    execute(): void;\n    undo(): void;\n    description(): string;\n    icon(): string;\n    getExecutionSelection(): AXPWidgetNode;  // Node to select after execution\n    getUndoSelection(): AXPWidgetNode;       // Node to select after undo\n}\n\n// AddWidgetCommand\nexport class AddWidgetCommand implements Command {\n    private widget: AXPWidgetNode;\n    private parent: AXPWidgetNode;\n    private previousSelection: AXPWidgetNode;\n\n    constructor(widget: AXPWidgetNode, parent: AXPWidgetNode, previousSelection: AXPWidgetNode) {\n        this.widget = widget;\n        this.parent = parent;\n        this.previousSelection = previousSelection;\n    }\n\n    execute() {\n        this.parent.children = this.parent.children || [];\n        this.parent.children.push(this.widget);\n    }\n\n    undo() {\n        this.parent.children = this.parent.children || [];\n        const index = this.parent.children.indexOf(this.widget);\n        if (index > -1) {\n            this.parent.children.splice(index, 1);\n        }\n    }\n\n    description() {\n        return `Added widget ${this.widget.name}`;\n    }\n\n    icon() {\n        return `fa-solid fa-square-plus`;\n    }\n\n    getExecutionSelection() {\n        return this.widget;  // After executing, select the newly added widget\n    }\n\n    getUndoSelection() {\n        return this.previousSelection;  // After undo, select the previously selected widget\n    }\n}\n\n\nexport class RemoveWidgetCommand implements Command {\n    private widget: AXPWidgetNode;\n    private parent: AXPWidgetNode;\n    private previousSelection: AXPWidgetNode;\n    private index: number;\n\n    constructor(widget: AXPWidgetNode, parent: AXPWidgetNode, previousSelection: AXPWidgetNode) {\n        this.widget = widget;\n        this.parent = parent;\n        this.previousSelection = previousSelection;\n        parent.children = parent.children || [];\n        this.index = parent.children.indexOf(widget);  // Capture the index for undo purposes\n    }\n\n    execute() {\n        this.parent.children = this.parent.children || [];\n        this.index = this.parent.children.indexOf(this.widget);  // Re-assert the index in case it has changed\n        this.parent.children.splice(this.index, 1);\n    }\n\n    undo() {\n        this.parent.children = this.parent.children || [];\n        this.parent.children.splice(this.index, 0, this.widget);  // Reinsert at the original index\n    }\n\n    description() {\n        return `Removed widget ${this.widget.name}`;\n    }\n\n    icon() {\n        return `fa-solid fa-square-minus`;\n    }\n\n    getExecutionSelection() {\n        return this.previousSelection;  // Typically the parent or a nearby sibling could be focused\n    }\n\n    getUndoSelection() {\n        return this.widget;  // Select the widget itself when the operation is undone\n    }\n}\n\nexport class UpdateWidgetCommand implements Command {\n    private widget: AXPWidgetNode;\n    private previousState: AXPWidgetNode;\n    private newState: AXPWidgetNode;\n    private previousSelection: AXPWidgetNode;\n\n    constructor(widget: AXPWidgetNode, values: Partial<AXPWidgetNode>, previousSelection: AXPWidgetNode) {\n        this.widget = widget;\n        this.newState = merge(cloneDeep(widget), values);\n        this.previousSelection = previousSelection;\n        this.previousState = cloneDeep(widget);\n    }\n\n    execute() {\n        merge(this.widget, this.newState)\n    }\n\n    undo() {\n        this.deepPruneAndRestore(this.widget, this.previousState);\n    }\n\n    description() {\n        return `Updated widget ${this.widget.name}`;\n    }\n\n    icon() {\n        return `fa-solid fa-pen-to-square`;\n    }\n\n    getExecutionSelection() {\n        return this.widget;  // Focus the widget after it's updated\n    }\n\n    getUndoSelection() {\n        return this.previousSelection;  // Restore the focus to where it was before the update\n    }\n\n    private deepPruneAndRestore(current: any, original: any) {\n        Object.keys(current).forEach(key => {\n            if (original.hasOwnProperty(key)) {\n                if (typeof current[key] === 'object' && current[key] !== null && !(current[key] instanceof Array)) {\n                    this.deepPruneAndRestore(current[key], original[key]);\n                }\n            } else {\n                delete current[key];  // Remove properties not present in original\n            }\n        });\n\n        // Restore the original properties\n        merge(current, original);\n    }\n}\n\n\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class CommandManager {\n    private undoStack = signal<Command[]>([]);\n    private currentIndex = signal<number>(-1);\n    public readonly selectedNode = signal<AXPWidgetNode | null>(null);\n\n    public canUndo = computed(() => this.currentIndex() >= 0)\n    public canRedo = computed(() => this.currentIndex() < this.undoStack().length - 1)\n\n    executeCommand(command: Command) {\n        // Check if the currentIndex is not at the end of the undoStack\n        if (this.currentIndex() !== this.undoStack().length - 1) {\n            // Remove all commands beyond the current index to discard the \"future\" commands\n            const newUndoStack = this.undoStack().slice(0, this.currentIndex() + 1);\n            this.undoStack.set(newUndoStack);\n        }\n\n        command.execute();\n        this.undoStack.set([...this.undoStack(), command]); // Add the new command to the stack\n        this.currentIndex.set(this.undoStack().length - 1); // Update currentIndex to the end of the stack\n        this.selectedNode.set(command.getExecutionSelection()); // Update the selected node\n    }\n\n    undo() {\n        if (this.currentIndex() >= 0) {\n            const command = this.undoStack()[this.currentIndex()];\n            command.undo();\n            this.currentIndex.set(this.currentIndex() - 1);\n            if (this.currentIndex() >= 0) {\n                this.selectedNode.set(this.undoStack()[this.currentIndex()].getUndoSelection());\n            } else {\n                this.selectedNode.set(null); // No selection if all commands are undone\n            }\n        }\n    }\n\n    redo() {\n        if (this.currentIndex() < this.undoStack().length - 1) {\n            this.currentIndex.set(this.currentIndex() + 1);\n            const command = this.undoStack()[this.currentIndex()];\n            command.execute();\n            this.selectedNode.set(command.getExecutionSelection());\n        }\n    }\n\n    goToCommand(index: number) {\n        if (index < 0 || index >= this.undoStack().length || index === this.currentIndex()) {\n            return;  // Out of bounds or already at the desired index\n        }\n\n        if (index > this.currentIndex()) {\n            // Need to redo until reaching the desired index\n            while (this.currentIndex() < index) {\n                this.redo();\n            }\n        } else {\n            // Need to undo until reaching the desired index\n            while (this.currentIndex() > index) {\n                this.undo();\n            }\n        }\n\n        // Optionally update any UI components or state here\n        this.selectedNode.set(this.undoStack()[this.currentIndex()].getExecutionSelection());\n    }\n\n    public history = computed(() => this.undoStack().map((cmd, index) => (\n        {\n            description: cmd.description(),\n            icon: cmd.icon(),\n            isPast: this.currentIndex() > index,\n            isFuture: this.currentIndex() < index,\n            isCurrent: this.currentIndex() == index\n        }\n    )))\n\n\n    public clear() {\n        this.undoStack.set([]);\n        this.currentIndex.set(-1);\n    }\n}"]}

package/esm2022/layout/designer/lib/designer/shared/designer-connector.service.mjs

@@ -0,0 +1,10 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class AXPDesignerConnectorAbstract {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPDesignerConnectorAbstract, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPDesignerConnectorAbstract }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPDesignerConnectorAbstract, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzaWduZXItY29ubmVjdG9yLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3BsYXRmb3JtL2xheW91dC9kZXNpZ25lci9zcmMvbGliL2Rlc2lnbmVyL3NoYXJlZC9kZXNpZ25lci1jb25uZWN0b3Iuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQU8zQyxNQUFNLE9BQWdCLDRCQUE0Qjs4R0FBNUIsNEJBQTRCO2tIQUE1Qiw0QkFBNEI7OzJGQUE1Qiw0QkFBNEI7a0JBRGpELFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBWFBXaWRnZXREYXRhU291cmNlLCBBWFBXaWRnZXROb2RlIH0gZnJvbSBcIkBhY29yZXgvcGxhdGZvcm0vbGF5b3V0L2J1aWxkZXJcIjtcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgQVhQRGVzaWduZXJEYXRhU291cmNlTmFtZSB9IGZyb20gXCIuL2Rlc2lnbmVyLnR5cHNcIjtcblxuXG5cblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEFYUERlc2lnbmVyQ29ubmVjdG9yQWJzdHJhY3Q8VCA9IHN0cmluZz4ge1xuXG4gICAgcHVibGljIGFic3RyYWN0IHNhdmUoKTogUHJvbWlzZTxhbnk+O1xuXG4gICAgcHVibGljIGFic3RyYWN0IGxvYWQoaWQ6IFQpOiBQcm9taXNlPEFYUFdpZGdldE5vZGU+O1xuXG4gICAgcHVibGljIGFic3RyYWN0IGdldERhdGFTb3VyY2VzTmFtZXMoKTogUHJvbWlzZTxBWFBEZXNpZ25lckRhdGFTb3VyY2VOYW1lW10+O1xuXG4gICAgcHVibGljIGFic3RyYWN0IGdldERhdGFTb3VyY2UobmFtZTogc3RyaW5nKTogUHJvbWlzZTxBWFBXaWRnZXREYXRhU291cmNlIHwgdW5kZWZpbmVkPjtcblxufSJdfQ==