@node-projects/web-component-designer 0.0.96 → 0.0.97

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

@@ -1,35 +1,35 @@
-import { DomHelper } from '@node-projects/base-custom-webcomponent/dist/DomHelper';
-export class DeleteAction {
-    constructor(deletedItems) {
-        this.title = "Delete Items";
-        this.deletedItems = deletedItems;
-    }
-    title;
-    get affectedItems() {
-        return this.deletedItems;
-    }
-    undo() {
-        for (let n = 0; n < this.deletedItems.length; n++) {
-            this._parentItems[n]._insertChildInternal(this.deletedItems[n], this._parentIndexes[n]);
-        }
-        this.affectedItems[0].instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'added', designItems: this.deletedItems });
-    }
-    do() {
-        this._parentItems = [];
-        this._parentIndexes = [];
-        for (let n = 0; n < this.deletedItems.length; n++) {
-            this._parentItems.push(this.deletedItems[n].parent);
-            this._parentIndexes.push(DomHelper.nodeIndex(this.deletedItems[n].element));
-        }
-        for (let n = 0; n < this.deletedItems.length; n++) {
-            this.deletedItems[n].remove();
-        }
-        this.affectedItems[0].instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'removed', designItems: this.deletedItems });
-    }
-    deletedItems;
-    _parentItems;
-    _parentIndexes;
-    mergeWith(other) {
-        return false;
-    }
-}
+import { DomHelper } from '@node-projects/base-custom-webcomponent/dist/DomHelper';
+export class DeleteAction {
+    constructor(deletedItems) {
+        this.title = "Delete Items";
+        this.deletedItems = deletedItems;
+    }
+    title;
+    get affectedItems() {
+        return this.deletedItems;
+    }
+    undo() {
+        for (let n = 0; n < this.deletedItems.length; n++) {
+            this._parentItems[n]._insertChildInternal(this.deletedItems[n], this._parentIndexes[n]);
+        }
+        this.affectedItems[0].instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'added', designItems: this.deletedItems });
+    }
+    do() {
+        this._parentItems = [];
+        this._parentIndexes = [];
+        for (let n = 0; n < this.deletedItems.length; n++) {
+            this._parentItems.push(this.deletedItems[n].parent);
+            this._parentIndexes.push(DomHelper.nodeIndex(this.deletedItems[n].element));
+        }
+        for (let n = 0; n < this.deletedItems.length; n++) {
+            this.deletedItems[n].remove();
+        }
+        this.affectedItems[0].instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'removed', designItems: this.deletedItems });
+    }
+    deletedItems;
+    _parentItems;
+    _parentIndexes;
+    mergeWith(other) {
+        return false;
+    }
+}

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

@@ -1,13 +1,13 @@
-import { ITransactionItem } from '../ITransactionItem';
-import { IDesignItem } from '../../../item/IDesignItem';
-export declare class InsertAction implements ITransactionItem {
-    constructor(designItem: IDesignItem, index: number, newItem: IDesignItem);
-    title?: string;
-    get affectedItems(): IDesignItem[];
-    undo(): void;
-    do(): void;
-    designItem: IDesignItem;
-    index: number;
-    newItem: IDesignItem;
-    mergeWith(other: ITransactionItem): boolean;
-}
+import { ITransactionItem } from '../ITransactionItem';
+import { IDesignItem } from '../../../item/IDesignItem';
+export declare class InsertAction implements ITransactionItem {
+    constructor(designItem: IDesignItem, index: number, newItem: IDesignItem);
+    title?: string;
+    get affectedItems(): IDesignItem[];
+    undo(): void;
+    do(): void;
+    designItem: IDesignItem;
+    index: number;
+    newItem: IDesignItem;
+    mergeWith(other: ITransactionItem): boolean;
+}

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

@@ -1,26 +1,26 @@
-export class InsertAction {
-    constructor(designItem, index, newItem) {
-        this.title = "Insert Item";
-        this.designItem = designItem;
-        this.index = index;
-        this.newItem = newItem;
-    }
-    title;
-    get affectedItems() {
-        return [this.designItem];
-    }
-    undo() {
-        this.newItem.element.remove();
-        this.affectedItems[0].instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'removed', designItems: [this.newItem] });
-    }
-    do() {
-        this.designItem._insertChildInternal(this.newItem, this.index);
-        this.affectedItems[0].instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'added', designItems: [this.newItem] });
-    }
-    designItem;
-    index;
-    newItem;
-    mergeWith(other) {
-        return false;
-    }
-}
+export class InsertAction {
+    constructor(designItem, index, newItem) {
+        this.title = "Insert Item";
+        this.designItem = designItem;
+        this.index = index;
+        this.newItem = newItem;
+    }
+    title;
+    get affectedItems() {
+        return [this.designItem];
+    }
+    undo() {
+        this.newItem.element.remove();
+        this.affectedItems[0].instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'removed', designItems: [this.newItem] });
+    }
+    do() {
+        this.designItem._insertChildInternal(this.newItem, this.index);
+        this.affectedItems[0].instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'added', designItems: [this.newItem] });
+    }
+    designItem;
+    index;
+    newItem;
+    mergeWith(other) {
+        return false;
+    }
+}

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

@@ -1,16 +1,16 @@
-import { ITransactionItem } from '../ITransactionItem';
-import { IDesignItem } from '../../../item/IDesignItem';
-export declare class InsertChildAction implements ITransactionItem {
-    constructor(designItem: IDesignItem, newParent: IDesignItem, newIndex: number);
-    title?: string;
-    get affectedItems(): IDesignItem[];
-    undo(): void;
-    do(): void;
-    designItem: IDesignItem;
-    newParent: IDesignItem;
-    newIndex: number;
-    oldParent: IDesignItem;
-    oldIndex: number;
-    newItem: IDesignItem;
-    mergeWith(other: ITransactionItem): boolean;
-}
+import { ITransactionItem } from '../ITransactionItem';
+import { IDesignItem } from '../../../item/IDesignItem';
+export declare class InsertChildAction implements ITransactionItem {
+    constructor(designItem: IDesignItem, newParent: IDesignItem, newIndex: number);
+    title?: string;
+    get affectedItems(): IDesignItem[];
+    undo(): void;
+    do(): void;
+    designItem: IDesignItem;
+    newParent: IDesignItem;
+    newIndex: number;
+    oldParent: IDesignItem;
+    oldIndex: number;
+    newItem: IDesignItem;
+    mergeWith(other: ITransactionItem): boolean;
+}

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

@@ -1,31 +1,31 @@
-export class InsertChildAction {
-    constructor(designItem, newParent, newIndex) {
-        this.title = "Move Item";
-        this.designItem = designItem;
-        this.newParent = newParent;
-        this.newIndex = newIndex;
-    }
-    title;
-    get affectedItems() {
-        return [this.designItem, this.newParent, this.oldParent];
-    }
-    undo() {
-        this.oldParent._insertChildInternal(this.designItem, this.newIndex);
-        this.affectedItems[0].instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'moved', designItems: [this.designItem] });
-    }
-    do() {
-        this.oldParent = this.designItem.parent;
-        this.oldIndex = this.designItem.parent.indexOf(this.designItem);
-        this.newParent._insertChildInternal(this.designItem, this.newIndex);
-        this.affectedItems[0].instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'moved', designItems: [this.designItem] });
-    }
-    designItem;
-    newParent;
-    newIndex;
-    oldParent;
-    oldIndex;
-    newItem;
-    mergeWith(other) {
-        return false;
-    }
-}
+export class InsertChildAction {
+    constructor(designItem, newParent, newIndex) {
+        this.title = "Move Item";
+        this.designItem = designItem;
+        this.newParent = newParent;
+        this.newIndex = newIndex;
+    }
+    title;
+    get affectedItems() {
+        return [this.designItem, this.newParent, this.oldParent];
+    }
+    undo() {
+        this.oldParent._insertChildInternal(this.designItem, this.newIndex);
+        this.affectedItems[0].instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'moved', designItems: [this.designItem] });
+    }
+    do() {
+        this.oldParent = this.designItem.parent;
+        this.oldIndex = this.designItem.parent.indexOf(this.designItem);
+        this.newParent._insertChildInternal(this.designItem, this.newIndex);
+        this.affectedItems[0].instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'moved', designItems: [this.designItem] });
+    }
+    designItem;
+    newParent;
+    newIndex;
+    oldParent;
+    oldIndex;
+    newItem;
+    mergeWith(other) {
+        return false;
+    }
+}

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

@@ -0,0 +1,16 @@
+import { ITransactionItem } from '../ITransactionItem';
+import { IDesignItem } from '../../../item/IDesignItem';
+export declare class MoveElementInDomAction implements ITransactionItem {
+    constructor(designItem: IDesignItem, newTarget: IDesignItem, newPosition: InsertPosition, oldTarget: IDesignItem, oldPosition: InsertPosition);
+    title?: string;
+    get affectedItems(): IDesignItem[];
+    undo(): void;
+    do(): void;
+    designItem: IDesignItem;
+    newTarget: IDesignItem;
+    newPosition: InsertPosition;
+    oldTarget: IDesignItem;
+    oldPosition: InsertPosition;
+    newItem: IDesignItem;
+    mergeWith(other: ITransactionItem): boolean;
+}

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

@@ -0,0 +1,31 @@
+export class MoveElementInDomAction {
+    constructor(designItem, newTarget, newPosition, oldTarget, oldPosition) {
+        this.title = "Move Item";
+        this.designItem = designItem;
+        this.newTarget = newTarget;
+        this.newPosition = newPosition;
+        this.oldTarget = oldTarget;
+        this.oldPosition = oldPosition;
+    }
+    title;
+    get affectedItems() {
+        return [this.designItem, this.newTarget, this.oldTarget];
+    }
+    undo() {
+        this.oldTarget.element.insertAdjacentElement(this.oldPosition, this.designItem.element);
+        this.affectedItems[0].instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'moved', designItems: [this.designItem] });
+    }
+    do() {
+        this.newTarget.element.insertAdjacentElement(this.newPosition, this.designItem.element);
+        this.affectedItems[0].instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'moved', designItems: [this.designItem] });
+    }
+    designItem;
+    newTarget;
+    newPosition;
+    oldTarget;
+    oldPosition;
+    newItem;
+    mergeWith(other) {
+        return false;
+    }
+}

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

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

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

@@ -1,36 +1,36 @@
-export class PropertyChangeAction {
-    constructor(designItem, property, newValue, oldValue) {
-        this.title = "Change Property";
-        this.designItem = designItem;
-        this.property = property;
-        this.newValue = newValue;
-        this.oldValue = oldValue;
-    }
-    title;
-    get affectedItems() {
-        return [this.designItem];
-    }
-    undo() {
-        if (this.oldValue == null)
-            this.property.service.clearValue([this.designItem], this.property);
-        else
-            this.property.service.setValue([this.designItem], this.property, this.oldValue);
-    }
-    do() {
-        if (this.newValue == null)
-            this.property.service.clearValue([this.designItem], this.property);
-        else
-            this.property.service.setValue([this.designItem], this.property, this.newValue);
-    }
-    designItem;
-    property;
-    newValue;
-    oldValue;
-    mergeWith(other) {
-        if (other instanceof PropertyChangeAction && this.designItem === other.designItem && this.property === other.property) {
-            this.newValue = other.newValue;
-            return true;
-        }
-        return false;
-    }
-}
+export class PropertyChangeAction {
+    constructor(designItem, property, newValue, oldValue) {
+        this.title = "Change Property";
+        this.designItem = designItem;
+        this.property = property;
+        this.newValue = newValue;
+        this.oldValue = oldValue;
+    }
+    title;
+    get affectedItems() {
+        return [this.designItem];
+    }
+    undo() {
+        if (this.oldValue == null)
+            this.property.service.clearValue([this.designItem], this.property);
+        else
+            this.property.service.setValue([this.designItem], this.property, this.oldValue);
+    }
+    do() {
+        if (this.newValue == null)
+            this.property.service.clearValue([this.designItem], this.property);
+        else
+            this.property.service.setValue([this.designItem], this.property, this.newValue);
+    }
+    designItem;
+    property;
+    newValue;
+    oldValue;
+    mergeWith(other) {
+        if (other instanceof PropertyChangeAction && this.designItem === other.designItem && this.property === other.property) {
+            this.newValue = other.newValue;
+            return true;
+        }
+        return false;
+    }
+}

package/dist/elements/widgets/bindableObjectsBrowser/IBindableObjectsBrowser.d.ts

@@ -1,3 +1,3 @@
-export interface IBindableObjectsBrowser {
-    showObject(name: string): any;
-}
+export interface IBindableObjectsBrowser {
+    showObject(name: string): any;
+}

package/dist/elements/widgets/bindableObjectsBrowser/IBindableObjectsBrowser.js

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

package/dist/elements/widgets/bindableObjectsBrowser/bindable-objects-browser.d.ts

@@ -1,10 +1,10 @@
-import { BaseCustomWebComponentLazyAppend } from '@node-projects/base-custom-webcomponent';
-import { ServiceContainer } from '../../services/ServiceContainer.js';
-export declare class BindableObjectsBrowser extends BaseCustomWebComponentLazyAppend {
-    private _treeDiv;
-    private _tree;
-    static readonly style: CSSStyleSheet;
-    constructor();
-    initialize(serviceContainer: ServiceContainer): Promise<void>;
-    private lazyLoad;
-}
+import { BaseCustomWebComponentLazyAppend } from '@node-projects/base-custom-webcomponent';
+import { ServiceContainer } from '../../services/ServiceContainer.js';
+export declare class BindableObjectsBrowser extends BaseCustomWebComponentLazyAppend {
+    private _treeDiv;
+    private _tree;
+    static readonly style: CSSStyleSheet;
+    constructor();
+    initialize(serviceContainer: ServiceContainer): Promise<void>;
+    private lazyLoad;
+}

package/dist/elements/widgets/bindableObjectsBrowser/bindable-objects-browser.js

@@ -1,8 +1,8 @@
-import { BaseCustomWebComponentLazyAppend, css } from '@node-projects/base-custom-webcomponent';
-import { dragDropFormatNameBindingObject } from '../../../Constants.js';
-export class BindableObjectsBrowser extends BaseCustomWebComponentLazyAppend {
-    _treeDiv;
-    _tree;
+import { BaseCustomWebComponentLazyAppend, css } from '@node-projects/base-custom-webcomponent';
+import { dragDropFormatNameBindingObject } from '../../../Constants.js';
+export class BindableObjectsBrowser extends BaseCustomWebComponentLazyAppend {
+    _treeDiv;
+    _tree;
     static style = css `
       span.drag-source {
         border: 1px solid grey;
@@ -26,76 +26,76 @@ export class BindableObjectsBrowser extends BaseCustomWebComponentLazyAppend {
       #tree ul:focus {
         outline: none;
       }
-    `;
-    constructor() {
-        super();
-        this._restoreCachedInititalValues();
-        //@ts-ignore
-        import("jquery.fancytree/dist/skin-win8/ui.fancytree.css", { assert: { type: 'css' } }).then(x => this.shadowRoot.adoptedStyleSheets = [x.default, this.constructor.style]);
-        this._treeDiv = document.createElement('div');
-        this._treeDiv.style.height = '100%';
-        this._treeDiv.style.overflow = 'auto';
-        this._treeDiv.setAttribute('id', 'tree');
-        this.shadowRoot.appendChild(this._treeDiv);
-        $(this._treeDiv).fancytree({
-            icon: false,
-            extensions: ['dnd5'],
-            quicksearch: true,
-            source: [],
-            lazyLoad: this.lazyLoad,
-            dnd5: {
-                dropMarkerParent: this.shadowRoot,
-                preventRecursion: true,
-                preventVoidMoves: false,
-                dropMarkerOffsetX: -24,
-                dropMarkerInsertOffsetX: -16,
-                dragStart: (node, data) => {
-                    data.effectAllowed = "all";
-                    data.dataTransfer.setData(dragDropFormatNameBindingObject, JSON.stringify(node.data.bindable));
-                    data.dropEffect = "copy";
-                    return true;
-                },
-                dragEnter: (node, data) => {
-                    return false;
-                }
-            }
-        });
-        this._tree = $.ui.fancytree.getTree(this._treeDiv);
-        this._treeDiv.children[0].classList.add('fancytree-connectors');
-    }
-    async initialize(serviceContainer) {
-        let rootNode = this._tree.getRootNode();
-        rootNode.removeChildren();
-        const services = serviceContainer.bindableObjectsServices;
-        for (const s of services) {
-            const newNode = rootNode.addChildren({
-                title: s.name,
-                folder: true,
-                lazy: true,
-                data: {
-                    service: s
-                }
-            });
-            rootNode.addNode(newNode);
-        }
-    }
-    lazyLoad(event, data) {
-        data.result = new Promise(async (resolve) => {
-            const service = data.node.data.service;
-            const bindable = data.node.data.bindable;
-            let children;
-            if (bindable?.children)
-                children = bindable.children;
-            else
-                children = await service.getBindableObjects(bindable);
-            resolve(children.map(x => ({
-                service,
-                title: x.name,
-                bindable: x,
-                folder: x.children !== false,
-                lazy: x.children !== false
-            })));
-        });
-    }
-}
-customElements.define('node-projects-bindable-objects-browser', BindableObjectsBrowser);
+    `;
+    constructor() {
+        super();
+        this._restoreCachedInititalValues();
+        //@ts-ignore
+        import("jquery.fancytree/dist/skin-win8/ui.fancytree.css", { assert: { type: 'css' } }).then(x => this.shadowRoot.adoptedStyleSheets = [x.default, this.constructor.style]);
+        this._treeDiv = document.createElement('div');
+        this._treeDiv.style.height = '100%';
+        this._treeDiv.style.overflow = 'auto';
+        this._treeDiv.setAttribute('id', 'tree');
+        this.shadowRoot.appendChild(this._treeDiv);
+        $(this._treeDiv).fancytree({
+            icon: false,
+            extensions: ['dnd5'],
+            quicksearch: true,
+            source: [],
+            lazyLoad: this.lazyLoad,
+            dnd5: {
+                dropMarkerParent: this.shadowRoot,
+                preventRecursion: true,
+                preventVoidMoves: false,
+                dropMarkerOffsetX: -24,
+                dropMarkerInsertOffsetX: -16,
+                dragStart: (node, data) => {
+                    data.effectAllowed = "all";
+                    data.dataTransfer.setData(dragDropFormatNameBindingObject, JSON.stringify(node.data.bindable));
+                    data.dropEffect = "copy";
+                    return true;
+                },
+                dragEnter: (node, data) => {
+                    return false;
+                }
+            }
+        });
+        this._tree = $.ui.fancytree.getTree(this._treeDiv);
+        this._treeDiv.children[0].classList.add('fancytree-connectors');
+    }
+    async initialize(serviceContainer) {
+        let rootNode = this._tree.getRootNode();
+        rootNode.removeChildren();
+        const services = serviceContainer.bindableObjectsServices;
+        for (const s of services) {
+            const newNode = rootNode.addChildren({
+                title: s.name,
+                folder: true,
+                lazy: true,
+                data: {
+                    service: s
+                }
+            });
+            rootNode.addNode(newNode);
+        }
+    }
+    lazyLoad(event, data) {
+        data.result = new Promise(async (resolve) => {
+            const service = data.node.data.service;
+            const bindable = data.node.data.bindable;
+            let children;
+            if (bindable?.children)
+                children = bindable.children;
+            else
+                children = await service.getBindableObjects(bindable);
+            resolve(children.map(x => ({
+                service,
+                title: x.name,
+                bindable: x,
+                folder: x.children !== false,
+                lazy: x.children !== false
+            })));
+        });
+    }
+}
+customElements.define('node-projects-bindable-objects-browser', BindableObjectsBrowser);

package/dist/elements/widgets/bindings/BindingsEditor.d.ts

@@ -1,17 +1,17 @@
-import { BaseCustomWebComponentConstructorAppend } from '@node-projects/base-custom-webcomponent';
-export declare enum targetType {
-    'property' = "property",
-    'style' = "style",
-    'attribute' = "attribute",
-    'event' = "event"
-}
-export declare enum valueType {
-    'string' = "string",
-    'number' = "number",
-    'boolean' = "boolean"
-}
-export declare class BindingsEditor extends BaseCustomWebComponentConstructorAppend {
-    static readonly style: CSSStyleSheet;
-    static readonly template: HTMLTemplateElement;
-    constructor(targetType: targetType);
-}
+import { BaseCustomWebComponentConstructorAppend } from '@node-projects/base-custom-webcomponent';
+export declare enum targetType {
+    'property' = "property",
+    'style' = "style",
+    'attribute' = "attribute",
+    'event' = "event"
+}
+export declare enum valueType {
+    'string' = "string",
+    'number' = "number",
+    'boolean' = "boolean"
+}
+export declare class BindingsEditor extends BaseCustomWebComponentConstructorAppend {
+    static readonly style: CSSStyleSheet;
+    static readonly template: HTMLTemplateElement;
+    constructor(targetType: targetType);
+}