@node-projects/web-component-designer 0.0.82 → 0.0.86

package/dist/elements/services/undoService/ITransactionItem.d.ts

@@ -1,8 +1,8 @@
-import { IDesignItem } from "../../item/IDesignItem";
-export interface ITransactionItem {
-    title?: string;
-    readonly affectedItems?: IDesignItem[];
-    do: () => void;
-    undo: () => void;
-    mergeWith(other: ITransactionItem): boolean;
-}
+import { IDesignItem } from "../../item/IDesignItem";
+export interface ITransactionItem {
+    title?: string;
+    readonly affectedItems?: IDesignItem[];
+    do: () => void;
+    undo: () => void;
+    mergeWith(other: ITransactionItem): boolean;
+}

package/dist/elements/services/undoService/ITransactionItem.js

@@ -1,2 +1,2 @@
-;
-export {};
+;
+export {};

package/dist/elements/services/undoService/IUndoService.d.ts

@@ -1,13 +1,13 @@
-import { IService } from '../IService';
-import { ChangeGroup } from './ChangeGroup';
-import { ITransactionItem } from './ITransactionItem';
-import { IDesignItem } from '../../item/IDesignItem';
-export interface IUndoService extends IService {
-    openGroup(title: string, affectedItems?: IDesignItem[]): ChangeGroup;
-    execute(item: ITransactionItem): void;
-    canUndo(): boolean;
-    canRedo(): boolean;
-    clear(): any;
-    undo(): any;
-    redo(): any;
-}
+import { IService } from '../IService';
+import { ChangeGroup } from './ChangeGroup';
+import { ITransactionItem } from './ITransactionItem';
+import { IDesignItem } from '../../item/IDesignItem';
+export interface IUndoService extends IService {
+    openGroup(title: string, affectedItems?: IDesignItem[]): ChangeGroup;
+    execute(item: ITransactionItem): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    clear(): any;
+    undo(): any;
+    redo(): any;
+}

package/dist/elements/services/undoService/IUndoService.js

@@ -1 +1 @@
-export {};
+export {};

package/dist/elements/services/undoService/UndoService.d.ts

@@ -1,21 +1,21 @@
-import { ITransactionItem } from './ITransactionItem.js';
-import { ChangeGroup } from "./ChangeGroup.js";
-import { IUndoService } from './IUndoService.js';
-import { IDesignItem } from '../../item/IDesignItem';
-import { IDesignerCanvas } from '../../widgets/designerView/IDesignerCanvas.js';
-export declare class UndoService implements IUndoService {
-    private _undoStack;
-    private _redoStack;
-    private _transactionStack;
-    private _designerCanvas;
-    constructor(designerCanvas?: IDesignerCanvas);
-    openGroup(title: string, affectedItems: IDesignItem[]): ChangeGroup;
-    private commitTransactionItem;
-    private abortTransactionItem;
-    execute(item: ITransactionItem): void;
-    clear(): void;
-    undo(): void;
-    redo(): void;
-    canUndo(): boolean;
-    canRedo(): boolean;
-}
+import { ITransactionItem } from './ITransactionItem.js';
+import { ChangeGroup } from "./ChangeGroup.js";
+import { IUndoService } from './IUndoService.js';
+import { IDesignItem } from '../../item/IDesignItem';
+import { IDesignerCanvas } from '../../widgets/designerView/IDesignerCanvas.js';
+export declare class UndoService implements IUndoService {
+    private _undoStack;
+    private _redoStack;
+    private _transactionStack;
+    private _designerCanvas;
+    constructor(designerCanvas?: IDesignerCanvas);
+    openGroup(title: string, affectedItems: IDesignItem[]): ChangeGroup;
+    private commitTransactionItem;
+    private abortTransactionItem;
+    execute(item: ITransactionItem): void;
+    clear(): void;
+    undo(): void;
+    redo(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+}

package/dist/elements/services/undoService/UndoService.js

@@ -1,92 +1,92 @@
-import { ChangeGroup } from "./ChangeGroup.js";
-/*
- * Manages a stack of available undo/redo actions
- */
-export class UndoService {
-    _undoStack = [];
-    _redoStack = [];
-    _transactionStack = [];
-    _designerCanvas;
-    constructor(designerCanvas) {
-        this._designerCanvas = designerCanvas;
-    }
-    openGroup(title, affectedItems) {
-        let t = new ChangeGroup(title, affectedItems, (t) => this.commitTransactionItem(t), (t) => this.abortTransactionItem(t));
-        this._transactionStack.push(t);
-        return t;
-    }
-    commitTransactionItem(transactionItem) {
-        let itm = this._transactionStack.pop();
-        if (itm !== transactionItem) {
-            this.clear();
-            throw "UndoService - Commited Transation was not the last";
-        }
-        if (itm.undoStack.length)
-            this._undoStack.push(itm);
-    }
-    abortTransactionItem(transactionItem) {
-        let itm = this._transactionStack.pop();
-        if (itm !== transactionItem) {
-            this.clear();
-            throw "UndoService - Aborted Transation was not the last";
-        }
-        itm.undo();
-    }
-    execute(item) {
-        if (this._transactionStack.length == 0) {
-            item.do();
-            this._undoStack.push(item);
-            this._redoStack = [];
-        }
-        else {
-            this._transactionStack[this._transactionStack.length - 1].execute(item);
-        }
-        this._designerCanvas.extensionManager.refreshAllExtensions(item.affectedItems);
-        this._designerCanvas.onContentChanged.emit();
-    }
-    clear() {
-        this._undoStack = [];
-        this._redoStack = [];
-        this._transactionStack = [];
-    }
-    undo() {
-        if (!this.canUndo())
-            return;
-        if (this._transactionStack.length != 0)
-            throw "Cannot Undo while transaction is running";
-        let item = this._undoStack.pop();
-        try {
-            item.undo();
-            this._redoStack.push(item);
-        }
-        catch (err) {
-            this.clear();
-            throw err;
-        }
-        this._designerCanvas.extensionManager.refreshAllExtensions(item.affectedItems);
-        this._designerCanvas.onContentChanged.emit();
-    }
-    redo() {
-        if (!this.canRedo())
-            return;
-        if (this._transactionStack.length != 0)
-            throw "Cannot Redo while transaction is running";
-        let item = this._redoStack.pop();
-        try {
-            item.do();
-            this._undoStack.push(item);
-        }
-        catch (err) {
-            this.clear();
-            throw err;
-        }
-        this._designerCanvas.extensionManager.refreshAllExtensions(item.affectedItems);
-        this._designerCanvas.onContentChanged.emit();
-    }
-    canUndo() {
-        return this._undoStack.length > 0;
-    }
-    canRedo() {
-        return this._redoStack.length > 0;
-    }
-}
+import { ChangeGroup } from "./ChangeGroup.js";
+/*
+ * Manages a stack of available undo/redo actions
+ */
+export class UndoService {
+    _undoStack = [];
+    _redoStack = [];
+    _transactionStack = [];
+    _designerCanvas;
+    constructor(designerCanvas) {
+        this._designerCanvas = designerCanvas;
+    }
+    openGroup(title, affectedItems) {
+        let t = new ChangeGroup(title, affectedItems, (t) => this.commitTransactionItem(t), (t) => this.abortTransactionItem(t));
+        this._transactionStack.push(t);
+        return t;
+    }
+    commitTransactionItem(transactionItem) {
+        let itm = this._transactionStack.pop();
+        if (itm !== transactionItem) {
+            this.clear();
+            throw "UndoService - Commited Transation was not the last";
+        }
+        if (itm.undoStack.length)
+            this._undoStack.push(itm);
+    }
+    abortTransactionItem(transactionItem) {
+        let itm = this._transactionStack.pop();
+        if (itm !== transactionItem) {
+            this.clear();
+            throw "UndoService - Aborted Transation was not the last";
+        }
+        itm.undo();
+    }
+    execute(item) {
+        if (this._transactionStack.length == 0) {
+            item.do();
+            this._undoStack.push(item);
+            this._redoStack = [];
+        }
+        else {
+            this._transactionStack[this._transactionStack.length - 1].execute(item);
+        }
+        this._designerCanvas.extensionManager.refreshAllExtensions(item.affectedItems);
+        this._designerCanvas.onContentChanged.emit();
+    }
+    clear() {
+        this._undoStack = [];
+        this._redoStack = [];
+        this._transactionStack = [];
+    }
+    undo() {
+        if (!this.canUndo())
+            return;
+        if (this._transactionStack.length != 0)
+            throw "Cannot Undo while transaction is running";
+        let item = this._undoStack.pop();
+        try {
+            item.undo();
+            this._redoStack.push(item);
+        }
+        catch (err) {
+            this.clear();
+            throw err;
+        }
+        this._designerCanvas.extensionManager.refreshAllExtensions(item.affectedItems);
+        this._designerCanvas.onContentChanged.emit();
+    }
+    redo() {
+        if (!this.canRedo())
+            return;
+        if (this._transactionStack.length != 0)
+            throw "Cannot Redo while transaction is running";
+        let item = this._redoStack.pop();
+        try {
+            item.do();
+            this._undoStack.push(item);
+        }
+        catch (err) {
+            this.clear();
+            throw err;
+        }
+        this._designerCanvas.extensionManager.refreshAllExtensions(item.affectedItems);
+        this._designerCanvas.onContentChanged.emit();
+    }
+    canUndo() {
+        return this._undoStack.length > 0;
+    }
+    canRedo() {
+        return this._redoStack.length > 0;
+    }
+}

package/dist/elements/services/undoService/transactionItems/AttributeChangeAction.d.ts

@@ -1,15 +1,15 @@
-import { ITransactionItem } from '../ITransactionItem';
-import { IDesignItem } from '../../../item/IDesignItem';
-import { IBinding } from '../../../item/IBinding.js';
-export declare class AttributeChangeAction implements ITransactionItem {
-    constructor(designItem: IDesignItem, name: string, newValue: string | IBinding | null, oldValue: string | IBinding | null);
-    title?: string;
-    get affectedItems(): IDesignItem[];
-    undo(): void;
-    do(): void;
-    designItem: IDesignItem;
-    name: string;
-    newValue: any;
-    oldValue: any;
-    mergeWith(other: ITransactionItem): boolean;
-}
+import { ITransactionItem } from '../ITransactionItem';
+import { IDesignItem } from '../../../item/IDesignItem';
+import { IBinding } from '../../../item/IBinding.js';
+export declare class AttributeChangeAction implements ITransactionItem {
+    constructor(designItem: IDesignItem, name: string, newValue: string | IBinding | null, oldValue: string | IBinding | null);
+    title?: string;
+    get affectedItems(): IDesignItem[];
+    undo(): void;
+    do(): void;
+    designItem: IDesignItem;
+    name: string;
+    newValue: any;
+    oldValue: any;
+    mergeWith(other: ITransactionItem): boolean;
+}

package/dist/elements/services/undoService/transactionItems/AttributeChangeAction.js

@@ -1,70 +1,70 @@
-export class AttributeChangeAction {
-    constructor(designItem, name, newValue, oldValue) {
-        this.title = "Change Attribute";
-        this.designItem = designItem;
-        this.name = name;
-        this.newValue = newValue;
-        this.oldValue = oldValue;
-    }
-    title;
-    get affectedItems() {
-        return [this.designItem];
-    }
-    undo() {
-        if (this.oldValue == null) {
-            this.designItem.attributes.delete(this.name);
-            try {
-                this.designItem.element.removeAttribute(this.name);
-            }
-            catch (e) {
-                console.warn(e);
-            }
-        }
-        else {
-            this.designItem.attributes.set(this.name, this.oldValue);
-            if (this.name != "draggable") {
-                try {
-                    if (typeof this.oldValue === 'string')
-                        this.designItem.element.setAttribute(this.name, this.oldValue);
-                }
-                catch (e) {
-                    console.warn(e);
-                }
-            }
-        }
-    }
-    do() {
-        if (this.newValue == null) {
-            this.designItem.attributes.delete(this.name);
-            try {
-                this.designItem.element.removeAttribute(this.name);
-            }
-            catch (e) {
-                console.warn(e);
-            }
-        }
-        else {
-            this.designItem.attributes.set(this.name, this.newValue);
-            if (this.name != "draggable") {
-                try {
-                    if (typeof this.newValue === 'string')
-                        this.designItem.element.setAttribute(this.name, this.newValue);
-                }
-                catch (e) {
-                    console.warn(e);
-                }
-            }
-        }
-    }
-    designItem;
-    name;
-    newValue;
-    oldValue;
-    mergeWith(other) {
-        if (other instanceof AttributeChangeAction && this.designItem === other.designItem && this.name === other.name) {
-            this.newValue = other.newValue;
-            return true;
-        }
-        return false;
-    }
-}
+export class AttributeChangeAction {
+    constructor(designItem, name, newValue, oldValue) {
+        this.title = "Change Attribute";
+        this.designItem = designItem;
+        this.name = name;
+        this.newValue = newValue;
+        this.oldValue = oldValue;
+    }
+    title;
+    get affectedItems() {
+        return [this.designItem];
+    }
+    undo() {
+        if (this.oldValue == null) {
+            this.designItem.attributes.delete(this.name);
+            try {
+                this.designItem.element.removeAttribute(this.name);
+            }
+            catch (e) {
+                console.warn(e);
+            }
+        }
+        else {
+            this.designItem.attributes.set(this.name, this.oldValue);
+            if (this.name != "draggable") {
+                try {
+                    if (typeof this.oldValue === 'string')
+                        this.designItem.element.setAttribute(this.name, this.oldValue);
+                }
+                catch (e) {
+                    console.warn(e);
+                }
+            }
+        }
+    }
+    do() {
+        if (this.newValue == null) {
+            this.designItem.attributes.delete(this.name);
+            try {
+                this.designItem.element.removeAttribute(this.name);
+            }
+            catch (e) {
+                console.warn(e);
+            }
+        }
+        else {
+            this.designItem.attributes.set(this.name, this.newValue);
+            if (this.name != "draggable") {
+                try {
+                    if (typeof this.newValue === 'string')
+                        this.designItem.element.setAttribute(this.name, this.newValue);
+                }
+                catch (e) {
+                    console.warn(e);
+                }
+            }
+        }
+    }
+    designItem;
+    name;
+    newValue;
+    oldValue;
+    mergeWith(other) {
+        if (other instanceof AttributeChangeAction && this.designItem === other.designItem && this.name === other.name) {
+            this.newValue = other.newValue;
+            return true;
+        }
+        return false;
+    }
+}

package/dist/elements/services/undoService/transactionItems/CssStyleChangeAction.d.ts

@@ -1,14 +1,14 @@
-import { ITransactionItem } from '../ITransactionItem';
-import { IDesignItem } from '../../../item/IDesignItem';
-export declare class CssStyleChangeAction implements ITransactionItem {
-    constructor(designItem: IDesignItem, name: string, newValue: any, oldValue: any);
-    title?: string;
-    get affectedItems(): IDesignItem[];
-    undo(): void;
-    do(): void;
-    designItem: IDesignItem;
-    name: string;
-    newValue: any;
-    oldValue: any;
-    mergeWith(other: ITransactionItem): boolean;
-}
+import { ITransactionItem } from '../ITransactionItem';
+import { IDesignItem } from '../../../item/IDesignItem';
+export declare class CssStyleChangeAction implements ITransactionItem {
+    constructor(designItem: IDesignItem, name: string, newValue: any, oldValue: any);
+    title?: string;
+    get affectedItems(): IDesignItem[];
+    undo(): void;
+    do(): void;
+    designItem: IDesignItem;
+    name: string;
+    newValue: any;
+    oldValue: any;
+    mergeWith(other: ITransactionItem): boolean;
+}

package/dist/elements/services/undoService/transactionItems/CssStyleChangeAction.js

@@ -1,44 +1,44 @@
-export class CssStyleChangeAction {
-    constructor(designItem, name, newValue, oldValue) {
-        this.title = "Change CSS Style";
-        this.designItem = designItem;
-        this.name = name;
-        this.newValue = newValue;
-        this.oldValue = oldValue;
-    }
-    title;
-    get affectedItems() {
-        return [this.designItem];
-    }
-    undo() {
-        if (this.oldValue === '' || this.oldValue == null) {
-            this.designItem.styles.delete(this.name);
-            this.designItem.element.style[this.name] = '';
-        }
-        else {
-            this.designItem.styles.set(this.name, this.oldValue);
-            this.designItem.element.style[this.name] = this.oldValue;
-        }
-    }
-    do() {
-        if (this.newValue === '' || this.newValue == null) {
-            this.designItem.styles.delete(this.name);
-            this.designItem.element.style[this.name] = '';
-        }
-        else {
-            this.designItem.styles.set(this.name, this.newValue);
-            this.designItem.element.style[this.name] = this.newValue;
-        }
-    }
-    designItem;
-    name;
-    newValue;
-    oldValue;
-    mergeWith(other) {
-        if (other instanceof CssStyleChangeAction && this.designItem === other.designItem && this.name === other.name) {
-            this.newValue = other.newValue;
-            return true;
-        }
-        return false;
-    }
-}
+export class CssStyleChangeAction {
+    constructor(designItem, name, newValue, oldValue) {
+        this.title = "Change CSS Style";
+        this.designItem = designItem;
+        this.name = name;
+        this.newValue = newValue;
+        this.oldValue = oldValue;
+    }
+    title;
+    get affectedItems() {
+        return [this.designItem];
+    }
+    undo() {
+        if (this.oldValue === '' || this.oldValue == null) {
+            this.designItem.styles.delete(this.name);
+            this.designItem.element.style[this.name] = '';
+        }
+        else {
+            this.designItem.styles.set(this.name, this.oldValue);
+            this.designItem.element.style[this.name] = this.oldValue;
+        }
+    }
+    do() {
+        if (this.newValue === '' || this.newValue == null) {
+            this.designItem.styles.delete(this.name);
+            this.designItem.element.style[this.name] = '';
+        }
+        else {
+            this.designItem.styles.set(this.name, this.newValue);
+            this.designItem.element.style[this.name] = this.newValue;
+        }
+    }
+    designItem;
+    name;
+    newValue;
+    oldValue;
+    mergeWith(other) {
+        if (other instanceof CssStyleChangeAction && this.designItem === other.designItem && this.name === other.name) {
+            this.newValue = other.newValue;
+            return true;
+        }
+        return false;
+    }
+}

package/dist/elements/services/undoService/transactionItems/DeleteAction.d.ts

@@ -1,13 +1,13 @@
-import { ITransactionItem } from '../ITransactionItem';
-import { IDesignItem } from '../../../item/IDesignItem';
-export declare class DeleteAction implements ITransactionItem {
-    constructor(deletedItems: IDesignItem[]);
-    title?: string;
-    get affectedItems(): IDesignItem[];
-    undo(): void;
-    do(): void;
-    deletedItems: IDesignItem[];
-    private _parentItems;
-    private _parentIndexes;
-    mergeWith(other: ITransactionItem): boolean;
-}
+import { ITransactionItem } from '../ITransactionItem';
+import { IDesignItem } from '../../../item/IDesignItem';
+export declare class DeleteAction implements ITransactionItem {
+    constructor(deletedItems: IDesignItem[]);
+    title?: string;
+    get affectedItems(): IDesignItem[];
+    undo(): void;
+    do(): void;
+    deletedItems: IDesignItem[];
+    private _parentItems;
+    private _parentIndexes;
+    mergeWith(other: ITransactionItem): boolean;
+}