@node-projects/web-component-designer 0.0.91 → 0.0.92

package/dist/elements/widgets/designerView/extensions/ExtensionManager.js

@@ -1,245 +1,245 @@
-import { DesignItem } from "../../../item/DesignItem";
-import { ExtensionType } from './ExtensionType';
-export class ExtensionManager {
-    designerCanvas;
-    constructor(designerCanvas) {
-        this.designerCanvas = designerCanvas;
-        designerCanvas.instanceServiceContainer.selectionService.onSelectionChanged.on(this._selectedElementsChanged.bind(this));
-        designerCanvas.instanceServiceContainer.contentService.onContentChanged.on(this._contentChanged.bind(this));
-    }
-    _contentChanged(contentChanged) {
-        requestAnimationFrame(() => {
-            switch (contentChanged.changeType) {
-                case 'added':
-                    this.applyExtensions(contentChanged.designItems, ExtensionType.Permanent, true);
-                    break;
-                case 'moved':
-                    this.refreshExtensions(contentChanged.designItems, ExtensionType.Permanent);
-                    break;
-                case 'parsed':
-                    this.applyExtensions(Array.from(this.designerCanvas.rootDesignItem.children()), ExtensionType.Permanent, true);
-                    break;
-                case 'removed':
-                    this.removeExtensions(contentChanged.designItems, ExtensionType.Permanent);
-                    break;
-            }
-        });
-    }
-    _selectedElementsChanged(selectionChangedEvent) {
-        if (selectionChangedEvent.oldSelectedElements && selectionChangedEvent.oldSelectedElements.length) {
-            if (selectionChangedEvent.oldSelectedElements[0].parent) {
-                const primaryContainer = DesignItem.GetOrCreateDesignItem(selectionChangedEvent.oldSelectedElements[0].parent.element, this.designerCanvas.serviceContainer, this.designerCanvas.instanceServiceContainer);
-                this.removeExtension(primaryContainer, ExtensionType.PrimarySelectionContainer);
-                this.removeExtension(selectionChangedEvent.oldSelectedElements[0], ExtensionType.PrimarySelection);
-                this.removeExtensions(selectionChangedEvent.oldSelectedElements, ExtensionType.Selection);
-            }
-        }
-        if (selectionChangedEvent.selectedElements && selectionChangedEvent.selectedElements.length) {
-            this.applyExtensions(selectionChangedEvent.selectedElements, ExtensionType.Selection);
-            this.applyExtension(selectionChangedEvent.selectedElements[0], ExtensionType.PrimarySelection);
-            const primaryContainer = DesignItem.GetOrCreateDesignItem(selectionChangedEvent.selectedElements[0].parent.element, this.designerCanvas.serviceContainer, this.designerCanvas.instanceServiceContainer);
-            this.applyExtension(primaryContainer, ExtensionType.PrimarySelectionContainer);
-        }
-        this.refreshExtensions(selectionChangedEvent.selectedElements);
-    }
-    applyExtension(designItem, extensionType, recursive = false) {
-        if (designItem) {
-            const extProv = this.designerCanvas.serviceContainer.designerExtensions.get(extensionType);
-            if (extProv) {
-                for (let e of extProv) {
-                    if (e.shouldExtend(this, this.designerCanvas, designItem)) {
-                        let appE = designItem.appliedDesignerExtensions.get(extensionType);
-                        if (!appE)
-                            appE = [];
-                        const ext = e.getExtension(this, this.designerCanvas, designItem);
-                        try {
-                            ext.extend();
-                        }
-                        catch (err) {
-                            console.error(err);
-                        }
-                        appE.push(ext);
-                        designItem.appliedDesignerExtensions.set(extensionType, appE);
-                    }
-                }
-            }
-            if (recursive) {
-                for (const d of designItem.children()) {
-                    this.applyExtension(d, extensionType, recursive);
-                }
-            }
-        }
-    }
-    applyExtensions(designItems, extensionType, recursive = false) {
-        if (designItems) {
-            const extProv = this.designerCanvas.serviceContainer.designerExtensions.get(extensionType);
-            if (extProv) {
-                for (let e of extProv) {
-                    for (let i of designItems) {
-                        if (e.shouldExtend(this, this.designerCanvas, i)) {
-                            let appE = i.appliedDesignerExtensions.get(extensionType);
-                            if (!appE)
-                                appE = [];
-                            const ext = e.getExtension(this, this.designerCanvas, i);
-                            try {
-                                ext.extend();
-                            }
-                            catch (err) {
-                                console.error(err);
-                            }
-                            appE.push(ext);
-                            i.appliedDesignerExtensions.set(extensionType, appE);
-                        }
-                    }
-                }
-            }
-            if (recursive) {
-                for (const d of designItems) {
-                    this.applyExtensions(Array.from(d.children()), extensionType, recursive);
-                }
-            }
-        }
-    }
-    removeExtension(designItem, extensionType) {
-        if (designItem) {
-            if (extensionType) {
-                let exts = designItem.appliedDesignerExtensions.get(extensionType);
-                if (exts) {
-                    for (let e of exts) {
-                        try {
-                            e.dispose();
-                        }
-                        catch (err) {
-                            console.error(err);
-                        }
-                    }
-                    designItem.appliedDesignerExtensions.delete(extensionType);
-                }
-            }
-            else {
-                for (let appE of designItem.appliedDesignerExtensions) {
-                    for (let e of appE[1]) {
-                        try {
-                            e.dispose();
-                        }
-                        catch (err) {
-                            console.error(err);
-                        }
-                    }
-                }
-                designItem.appliedDesignerExtensions.clear();
-            }
-        }
-    }
-    removeExtensions(designItems, extensionType) {
-        if (designItems) {
-            if (extensionType) {
-                for (let i of designItems) {
-                    let exts = i.appliedDesignerExtensions.get(extensionType);
-                    if (exts) {
-                        for (let e of exts) {
-                            try {
-                                e.dispose();
-                            }
-                            catch (err) {
-                                console.error(err);
-                            }
-                        }
-                        i.appliedDesignerExtensions.delete(extensionType);
-                    }
-                }
-            }
-            else {
-                for (let i of designItems) {
-                    for (let appE of i.appliedDesignerExtensions) {
-                        for (let e of appE[1]) {
-                            try {
-                                e.dispose();
-                            }
-                            catch (err) {
-                                console.error(err);
-                            }
-                        }
-                    }
-                    i.appliedDesignerExtensions.clear();
-                }
-            }
-        }
-    }
-    refreshExtension(designItem, extensionType) {
-        if (designItem) {
-            if (extensionType) {
-                let exts = designItem.appliedDesignerExtensions.get(extensionType);
-                if (exts) {
-                    for (let e of exts) {
-                        try {
-                            e.refresh();
-                        }
-                        catch (err) {
-                            console.error(err);
-                        }
-                    }
-                }
-            }
-            else {
-                for (let appE of designItem.appliedDesignerExtensions) {
-                    for (let e of appE[1]) {
-                        try {
-                            e.refresh();
-                        }
-                        catch (err) {
-                            console.error(err);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    refreshExtensions(designItems, extensionType) {
-        if (designItems) {
-            if (extensionType) {
-                for (let i of designItems) {
-                    let exts = i.appliedDesignerExtensions.get(extensionType);
-                    if (exts) {
-                        for (let e of exts) {
-                            try {
-                                e.refresh();
-                            }
-                            catch (err) {
-                                console.error(err);
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                for (let i of designItems) {
-                    for (let appE of i.appliedDesignerExtensions) {
-                        for (let e of appE[1]) {
-                            try {
-                                e.refresh();
-                            }
-                            catch (err) {
-                                console.error(err);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    refreshAllExtensions(designItems) {
-        if (designItems) {
-            this.refreshExtensions(designItems, ExtensionType.Permanent);
-            this.refreshExtensions(designItems, ExtensionType.Selection);
-            this.refreshExtensions(designItems, ExtensionType.PrimarySelection);
-            this.refreshExtensions(designItems, ExtensionType.PrimarySelectionContainer);
-            this.refreshExtensions(designItems, ExtensionType.MouseOver);
-            this.refreshExtensions(designItems, ExtensionType.OnlyOneItemSelected);
-            this.refreshExtensions(designItems, ExtensionType.MultipleItemsSelected);
-            this.refreshExtensions(designItems, ExtensionType.ContainerDragOver);
-            this.refreshExtensions(designItems, ExtensionType.ContainerDrag);
-            this.refreshExtensions(designItems, ExtensionType.Doubleclick);
-        }
-    }
-}
+import { DesignItem } from "../../../item/DesignItem";
+import { ExtensionType } from './ExtensionType';
+export class ExtensionManager {
+    designerCanvas;
+    constructor(designerCanvas) {
+        this.designerCanvas = designerCanvas;
+        designerCanvas.instanceServiceContainer.selectionService.onSelectionChanged.on(this._selectedElementsChanged.bind(this));
+        designerCanvas.instanceServiceContainer.contentService.onContentChanged.on(this._contentChanged.bind(this));
+    }
+    _contentChanged(contentChanged) {
+        requestAnimationFrame(() => {
+            switch (contentChanged.changeType) {
+                case 'added':
+                    this.applyExtensions(contentChanged.designItems, ExtensionType.Permanent, true);
+                    break;
+                case 'moved':
+                    this.refreshExtensions(contentChanged.designItems, ExtensionType.Permanent);
+                    break;
+                case 'parsed':
+                    this.applyExtensions(Array.from(this.designerCanvas.rootDesignItem.children()), ExtensionType.Permanent, true);
+                    break;
+                case 'removed':
+                    this.removeExtensions(contentChanged.designItems, ExtensionType.Permanent);
+                    break;
+            }
+        });
+    }
+    _selectedElementsChanged(selectionChangedEvent) {
+        if (selectionChangedEvent.oldSelectedElements && selectionChangedEvent.oldSelectedElements.length) {
+            if (selectionChangedEvent.oldSelectedElements[0].parent) {
+                const primaryContainer = DesignItem.GetOrCreateDesignItem(selectionChangedEvent.oldSelectedElements[0].parent.element, this.designerCanvas.serviceContainer, this.designerCanvas.instanceServiceContainer);
+                this.removeExtension(primaryContainer, ExtensionType.PrimarySelectionContainer);
+                this.removeExtension(selectionChangedEvent.oldSelectedElements[0], ExtensionType.PrimarySelection);
+                this.removeExtensions(selectionChangedEvent.oldSelectedElements, ExtensionType.Selection);
+            }
+        }
+        if (selectionChangedEvent.selectedElements && selectionChangedEvent.selectedElements.length) {
+            this.applyExtensions(selectionChangedEvent.selectedElements, ExtensionType.Selection);
+            this.applyExtension(selectionChangedEvent.selectedElements[0], ExtensionType.PrimarySelection);
+            const primaryContainer = DesignItem.GetOrCreateDesignItem(selectionChangedEvent.selectedElements[0].parent.element, this.designerCanvas.serviceContainer, this.designerCanvas.instanceServiceContainer);
+            this.applyExtension(primaryContainer, ExtensionType.PrimarySelectionContainer);
+        }
+        this.refreshExtensions(selectionChangedEvent.selectedElements);
+    }
+    applyExtension(designItem, extensionType, recursive = false) {
+        if (designItem) {
+            const extProv = this.designerCanvas.serviceContainer.designerExtensions.get(extensionType);
+            if (extProv) {
+                for (let e of extProv) {
+                    if (e.shouldExtend(this, this.designerCanvas, designItem)) {
+                        let appE = designItem.appliedDesignerExtensions.get(extensionType);
+                        if (!appE)
+                            appE = [];
+                        const ext = e.getExtension(this, this.designerCanvas, designItem);
+                        try {
+                            ext.extend();
+                        }
+                        catch (err) {
+                            console.error(err);
+                        }
+                        appE.push(ext);
+                        designItem.appliedDesignerExtensions.set(extensionType, appE);
+                    }
+                }
+            }
+            if (recursive) {
+                for (const d of designItem.children()) {
+                    this.applyExtension(d, extensionType, recursive);
+                }
+            }
+        }
+    }
+    applyExtensions(designItems, extensionType, recursive = false) {
+        if (designItems) {
+            const extProv = this.designerCanvas.serviceContainer.designerExtensions.get(extensionType);
+            if (extProv) {
+                for (let e of extProv) {
+                    for (let i of designItems) {
+                        if (e.shouldExtend(this, this.designerCanvas, i)) {
+                            let appE = i.appliedDesignerExtensions.get(extensionType);
+                            if (!appE)
+                                appE = [];
+                            const ext = e.getExtension(this, this.designerCanvas, i);
+                            try {
+                                ext.extend();
+                            }
+                            catch (err) {
+                                console.error(err);
+                            }
+                            appE.push(ext);
+                            i.appliedDesignerExtensions.set(extensionType, appE);
+                        }
+                    }
+                }
+            }
+            if (recursive) {
+                for (const d of designItems) {
+                    this.applyExtensions(Array.from(d.children()), extensionType, recursive);
+                }
+            }
+        }
+    }
+    removeExtension(designItem, extensionType) {
+        if (designItem) {
+            if (extensionType) {
+                let exts = designItem.appliedDesignerExtensions.get(extensionType);
+                if (exts) {
+                    for (let e of exts) {
+                        try {
+                            e.dispose();
+                        }
+                        catch (err) {
+                            console.error(err);
+                        }
+                    }
+                    designItem.appliedDesignerExtensions.delete(extensionType);
+                }
+            }
+            else {
+                for (let appE of designItem.appliedDesignerExtensions) {
+                    for (let e of appE[1]) {
+                        try {
+                            e.dispose();
+                        }
+                        catch (err) {
+                            console.error(err);
+                        }
+                    }
+                }
+                designItem.appliedDesignerExtensions.clear();
+            }
+        }
+    }
+    removeExtensions(designItems, extensionType) {
+        if (designItems) {
+            if (extensionType) {
+                for (let i of designItems) {
+                    let exts = i.appliedDesignerExtensions.get(extensionType);
+                    if (exts) {
+                        for (let e of exts) {
+                            try {
+                                e.dispose();
+                            }
+                            catch (err) {
+                                console.error(err);
+                            }
+                        }
+                        i.appliedDesignerExtensions.delete(extensionType);
+                    }
+                }
+            }
+            else {
+                for (let i of designItems) {
+                    for (let appE of i.appliedDesignerExtensions) {
+                        for (let e of appE[1]) {
+                            try {
+                                e.dispose();
+                            }
+                            catch (err) {
+                                console.error(err);
+                            }
+                        }
+                    }
+                    i.appliedDesignerExtensions.clear();
+                }
+            }
+        }
+    }
+    refreshExtension(designItem, extensionType) {
+        if (designItem) {
+            if (extensionType) {
+                let exts = designItem.appliedDesignerExtensions.get(extensionType);
+                if (exts) {
+                    for (let e of exts) {
+                        try {
+                            e.refresh();
+                        }
+                        catch (err) {
+                            console.error(err);
+                        }
+                    }
+                }
+            }
+            else {
+                for (let appE of designItem.appliedDesignerExtensions) {
+                    for (let e of appE[1]) {
+                        try {
+                            e.refresh();
+                        }
+                        catch (err) {
+                            console.error(err);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    refreshExtensions(designItems, extensionType) {
+        if (designItems) {
+            if (extensionType) {
+                for (let i of designItems) {
+                    let exts = i.appliedDesignerExtensions.get(extensionType);
+                    if (exts) {
+                        for (let e of exts) {
+                            try {
+                                e.refresh();
+                            }
+                            catch (err) {
+                                console.error(err);
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                for (let i of designItems) {
+                    for (let appE of i.appliedDesignerExtensions) {
+                        for (let e of appE[1]) {
+                            try {
+                                e.refresh();
+                            }
+                            catch (err) {
+                                console.error(err);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    refreshAllExtensions(designItems) {
+        if (designItems) {
+            this.refreshExtensions(designItems, ExtensionType.Permanent);
+            this.refreshExtensions(designItems, ExtensionType.Selection);
+            this.refreshExtensions(designItems, ExtensionType.PrimarySelection);
+            this.refreshExtensions(designItems, ExtensionType.PrimarySelectionContainer);
+            this.refreshExtensions(designItems, ExtensionType.MouseOver);
+            this.refreshExtensions(designItems, ExtensionType.OnlyOneItemSelected);
+            this.refreshExtensions(designItems, ExtensionType.MultipleItemsSelected);
+            this.refreshExtensions(designItems, ExtensionType.ContainerDragOver);
+            this.refreshExtensions(designItems, ExtensionType.ContainerDrag);
+            this.refreshExtensions(designItems, ExtensionType.Doubleclick);
+        }
+    }
+}

package/dist/elements/widgets/designerView/extensions/ExtensionType.d.ts

@@ -1,18 +1,18 @@
-export declare enum ExtensionType {
-    Permanent = 1,
-    Selection = 2,
-    PrimarySelection = 4,
-    PrimarySelectionContainer = 8,
-    MouseOver = 16,
-    OnlyOneItemSelected = 32,
-    MultipleItemsSelected = 64,
-    /**
-     * Extension for the Container wich the dragged element is draged over.
-     */
-    ContainerDragOver = 128,
-    /**
-     * Extension for the Current Container wich the dragged element is contained.
-     */
-    ContainerDrag = 256,
-    Doubleclick = 512
-}
+export declare enum ExtensionType {
+    Permanent = 1,
+    Selection = 2,
+    PrimarySelection = 4,
+    PrimarySelectionContainer = 8,
+    MouseOver = 16,
+    OnlyOneItemSelected = 32,
+    MultipleItemsSelected = 64,
+    /**
+     * Extension for the Container wich the dragged element is draged over.
+     */
+    ContainerDragOver = 128,
+    /**
+     * Extension for the Current Container wich the dragged element is contained.
+     */
+    ContainerDrag = 256,
+    Doubleclick = 512
+}

package/dist/elements/widgets/designerView/extensions/ExtensionType.js

@@ -1,19 +1,19 @@
-export var ExtensionType;
-(function (ExtensionType) {
-    ExtensionType[ExtensionType["Permanent"] = 1] = "Permanent";
-    ExtensionType[ExtensionType["Selection"] = 2] = "Selection";
-    ExtensionType[ExtensionType["PrimarySelection"] = 4] = "PrimarySelection";
-    ExtensionType[ExtensionType["PrimarySelectionContainer"] = 8] = "PrimarySelectionContainer";
-    ExtensionType[ExtensionType["MouseOver"] = 16] = "MouseOver";
-    ExtensionType[ExtensionType["OnlyOneItemSelected"] = 32] = "OnlyOneItemSelected";
-    ExtensionType[ExtensionType["MultipleItemsSelected"] = 64] = "MultipleItemsSelected";
-    /**
-     * Extension for the Container wich the dragged element is draged over.
-     */
-    ExtensionType[ExtensionType["ContainerDragOver"] = 128] = "ContainerDragOver";
-    /**
-     * Extension for the Current Container wich the dragged element is contained.
-     */
-    ExtensionType[ExtensionType["ContainerDrag"] = 256] = "ContainerDrag";
-    ExtensionType[ExtensionType["Doubleclick"] = 512] = "Doubleclick";
-})(ExtensionType || (ExtensionType = {}));
+export var ExtensionType;
+(function (ExtensionType) {
+    ExtensionType[ExtensionType["Permanent"] = 1] = "Permanent";
+    ExtensionType[ExtensionType["Selection"] = 2] = "Selection";
+    ExtensionType[ExtensionType["PrimarySelection"] = 4] = "PrimarySelection";
+    ExtensionType[ExtensionType["PrimarySelectionContainer"] = 8] = "PrimarySelectionContainer";
+    ExtensionType[ExtensionType["MouseOver"] = 16] = "MouseOver";
+    ExtensionType[ExtensionType["OnlyOneItemSelected"] = 32] = "OnlyOneItemSelected";
+    ExtensionType[ExtensionType["MultipleItemsSelected"] = 64] = "MultipleItemsSelected";
+    /**
+     * Extension for the Container wich the dragged element is draged over.
+     */
+    ExtensionType[ExtensionType["ContainerDragOver"] = 128] = "ContainerDragOver";
+    /**
+     * Extension for the Current Container wich the dragged element is contained.
+     */
+    ExtensionType[ExtensionType["ContainerDrag"] = 256] = "ContainerDrag";
+    ExtensionType[ExtensionType["Doubleclick"] = 512] = "Doubleclick";
+})(ExtensionType || (ExtensionType = {}));

package/dist/elements/widgets/designerView/extensions/GrayOutExtension.d.ts

@@ -1,13 +1,13 @@
-import { IRect } from "../../../../interfaces/IRect";
-import { IDesignItem } from "../../../item/IDesignItem";
-import { IDesignerCanvas } from "../IDesignerCanvas";
-import { AbstractExtension } from "./AbstractExtension";
-import { IExtensionManager } from "./IExtensionManger";
-export declare class GrayOutExtension extends AbstractExtension {
-    private _path;
-    constructor(extensionManager: IExtensionManager, designerView: IDesignerCanvas, extendedItem: IDesignItem);
-    extend(): void;
-    refresh(): void;
-    drawGrayOut(rect: IRect): void;
-    dispose(): void;
-}
+import { IRect } from "../../../../interfaces/IRect";
+import { IDesignItem } from "../../../item/IDesignItem";
+import { IDesignerCanvas } from "../IDesignerCanvas";
+import { AbstractExtension } from "./AbstractExtension";
+import { IExtensionManager } from "./IExtensionManger";
+export declare class GrayOutExtension extends AbstractExtension {
+    private _path;
+    constructor(extensionManager: IExtensionManager, designerView: IDesignerCanvas, extendedItem: IDesignItem);
+    extend(): void;
+    refresh(): void;
+    drawGrayOut(rect: IRect): void;
+    dispose(): void;
+}