@node-projects/web-component-designer 0.0.83 → 0.0.87

package/dist/elements/services/propertiesService/services/PolymerPropertiesService.js

@@ -1,10 +1,10 @@
-import { AbstractBasePropertiesService } from './AbstractBasePropertiesService';
-export class PolymerPropertiesService extends AbstractBasePropertiesService {
-    name = "polymer";
-    isHandledElement(designItem) {
-        return designItem.element.constructor.polymerElementVersion != null;
-    }
-    _notifyChangedProperty(designItem, property, value) {
-        designItem.element.set(property.name, value);
-    }
-}
+import { AbstractBasePropertiesService } from './AbstractBasePropertiesService';
+export class PolymerPropertiesService extends AbstractBasePropertiesService {
+    name = "polymer";
+    isHandledElement(designItem) {
+        return designItem.element.constructor.polymerElementVersion != null;
+    }
+    _notifyChangedProperty(designItem, property, value) {
+        designItem.element.set(property.name, value);
+    }
+}

package/dist/elements/services/propertiesService/services/PropertiesHelper.d.ts

@@ -1,6 +1,6 @@
-export declare class PropertiesHelper {
-    static isTypescriptEnum(value: any): boolean;
-    static getTypescriptEnumEntries(value: any): [name: string, value: string | number][];
-    static camelToDashCase(text: string): string;
-    static dashToCamelCase(text: string): string;
-}
+export declare class PropertiesHelper {
+    static isTypescriptEnum(value: any): boolean;
+    static getTypescriptEnumEntries(value: any): [name: string, value: string | number][];
+    static camelToDashCase(text: string): string;
+    static dashToCamelCase(text: string): string;
+}

package/dist/elements/services/propertiesService/services/PropertiesHelper.js

@@ -1,27 +1,27 @@
-export class PropertiesHelper {
-    static isTypescriptEnum(value) {
-        if (value && typeof value === 'object' && value.constructor == Object) {
-            for (let k in value) {
-                const tp = typeof value[k];
-                if (tp !== 'string' && tp !== 'number')
-                    return false;
-            }
-            return true;
-        }
-        return false;
-    }
-    static getTypescriptEnumEntries(value) {
-        let ret = [];
-        for (let k in value) {
-            if (isNaN(k))
-                ret.push([k, value[k]]);
-        }
-        return ret;
-    }
-    static camelToDashCase(text) {
-        return text.replace(/([A-Z])/g, (g) => `-${g[0].toLowerCase()}`);
-    }
-    static dashToCamelCase(text) {
-        return text.replace(/-([a-z])/g, (i) => i[1].toUpperCase());
-    }
-}
+export class PropertiesHelper {
+    static isTypescriptEnum(value) {
+        if (value && typeof value === 'object' && value.constructor == Object) {
+            for (let k in value) {
+                const tp = typeof value[k];
+                if (tp !== 'string' && tp !== 'number')
+                    return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    static getTypescriptEnumEntries(value) {
+        let ret = [];
+        for (let k in value) {
+            if (isNaN(k))
+                ret.push([k, value[k]]);
+        }
+        return ret;
+    }
+    static camelToDashCase(text) {
+        return text.replace(/([A-Z])/g, (g) => `-${g[0].toLowerCase()}`);
+    }
+    static dashToCamelCase(text) {
+        return text.replace(/-([a-z])/g, (i) => i[1].toUpperCase());
+    }
+}

package/dist/elements/services/propertiesService/services/UnkownElementPropertiesService.d.ts

@@ -1,17 +1,17 @@
-import { IPropertiesService } from "../IPropertiesService";
-import { IProperty } from '../IProperty';
-import { IDesignItem } from '../../../item/IDesignItem';
-import { ValueType } from "../ValueType";
-import { BindingTarget } from "../../../item/BindingTarget";
-export declare abstract class UnkownElementPropertiesService implements IPropertiesService {
-    isHandledElement(designItem: IDesignItem): boolean;
-    protected _notifyChangedProperty(designItem: IDesignItem, property: IProperty, value: any): void;
-    getProperty(designItem: IDesignItem, name: string): IProperty;
-    getProperties(designItem: IDesignItem): IProperty[];
-    setValue(designItems: IDesignItem[], property: IProperty, value: any): void;
-    getPropertyTarget(designItem: IDesignItem, property: IProperty): BindingTarget;
-    clearValue(designItems: IDesignItem[], property: IProperty): void;
-    isSet(designItems: IDesignItem[], property: IProperty): ValueType;
-    getValue(designItems: IDesignItem[], property: IProperty): string | boolean;
-    getUnsetValue(designItems: IDesignItem[], property: IProperty): any;
-}
+import { IPropertiesService } from "../IPropertiesService";
+import { IProperty } from '../IProperty';
+import { IDesignItem } from '../../../item/IDesignItem';
+import { ValueType } from "../ValueType";
+import { BindingTarget } from "../../../item/BindingTarget";
+export declare abstract class UnkownElementPropertiesService implements IPropertiesService {
+    isHandledElement(designItem: IDesignItem): boolean;
+    protected _notifyChangedProperty(designItem: IDesignItem, property: IProperty, value: any): void;
+    getProperty(designItem: IDesignItem, name: string): IProperty;
+    getProperties(designItem: IDesignItem): IProperty[];
+    setValue(designItems: IDesignItem[], property: IProperty, value: any): void;
+    getPropertyTarget(designItem: IDesignItem, property: IProperty): BindingTarget;
+    clearValue(designItems: IDesignItem[], property: IProperty): void;
+    isSet(designItems: IDesignItem[], property: IProperty): ValueType;
+    getValue(designItems: IDesignItem[], property: IProperty): string | boolean;
+    getUnsetValue(designItems: IDesignItem[], property: IProperty): any;
+}

package/dist/elements/services/propertiesService/services/UnkownElementPropertiesService.js

@@ -1,99 +1,99 @@
-import { ValueType } from "../ValueType";
-import { PropertiesHelper } from './PropertiesHelper';
-import { BindingTarget } from "../../../item/BindingTarget";
-//@ts-ignore
-export class UnkownElementPropertiesService {
-    isHandledElement(designItem) {
-        return true;
-    }
-    _notifyChangedProperty(designItem, property, value) {
-    }
-    getProperty(designItem, name) {
-        return null;
-    }
-    getProperties(designItem) {
-        return null;
-    }
-    setValue(designItems, property, value) {
-        const attributeName = PropertiesHelper.camelToDashCase(property.name);
-        const cg = designItems[0].openGroup("properties changed", designItems);
-        try {
-            for (let d of designItems) {
-                if (property.type === 'object') {
-                    const json = JSON.stringify(value);
-                    d.attributes.set(attributeName, json);
-                    d.element.setAttribute(attributeName, json);
-                }
-                else if (property.type == 'boolean' && !value) {
-                    d.attributes.delete(attributeName);
-                    d.element.removeAttribute(attributeName);
-                }
-                else if (property.type == 'boolean' && value) {
-                    d.attributes.set(attributeName, "");
-                    d.element.setAttribute(attributeName, "");
-                }
-                else {
-                    d.attributes.set(attributeName, value);
-                    d.element.setAttribute(attributeName, value);
-                }
-                this._notifyChangedProperty(d, property, value);
-            }
-            cg.commit();
-        }
-        catch (err) {
-            console.log(err);
-            cg.undo();
-        }
-    }
-    getPropertyTarget(designItem, property) {
-        return BindingTarget.property;
-    }
-    clearValue(designItems, property) {
-        const attributeName = PropertiesHelper.camelToDashCase(property.name);
-        for (let d of designItems) {
-            d.attributes.delete(attributeName);
-            d.element.removeAttribute(attributeName);
-            d.serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
-                return s.clearBinding(d, property.name, this.getPropertyTarget(d, property));
-            });
-            this._notifyChangedProperty(d, property, undefined);
-        }
-    }
-    isSet(designItems, property) {
-        let all = true;
-        let some = false;
-        if (designItems != null && designItems.length !== 0) {
-            let attributeName = PropertiesHelper.camelToDashCase(property.name);
-            designItems.forEach((x) => {
-                let has = x.attributes.has(attributeName);
-                all = all && has;
-                some = some || has;
-            });
-        }
-        else
-            return ValueType.none;
-        return all ? ValueType.all : some ? ValueType.some : ValueType.none;
-    }
-    getValue(designItems, property) {
-        if (designItems != null && designItems.length !== 0) {
-            let attributeName = PropertiesHelper.camelToDashCase(property.name);
-            if (property.type == 'boolean')
-                return designItems[0].attributes.has(attributeName);
-            let lastValue = designItems[0].attributes.get(attributeName);
-            /*
-            for (const x of designItems) {
-              let value = x.attributes.get(attributeName);
-              if (value != lastValue) {
-                lastValue = null;
-                break;
-              }
-            }
-            */
-            return lastValue;
-        }
-        return null;
-    }
-    getUnsetValue(designItems, property) {
-        return property.defaultValue;
-    }
-}
+import { ValueType } from "../ValueType";
+import { PropertiesHelper } from './PropertiesHelper';
+import { BindingTarget } from "../../../item/BindingTarget";
+//@ts-ignore
+export class UnkownElementPropertiesService {
+    isHandledElement(designItem) {
+        return true;
+    }
+    _notifyChangedProperty(designItem, property, value) {
+    }
+    getProperty(designItem, name) {
+        return null;
+    }
+    getProperties(designItem) {
+        return null;
+    }
+    setValue(designItems, property, value) {
+        const attributeName = PropertiesHelper.camelToDashCase(property.name);
+        const cg = designItems[0].openGroup("properties changed", designItems);
+        try {
+            for (let d of designItems) {
+                if (property.type === 'object') {
+                    const json = JSON.stringify(value);
+                    d.attributes.set(attributeName, json);
+                    d.element.setAttribute(attributeName, json);
+                }
+                else if (property.type == 'boolean' && !value) {
+                    d.attributes.delete(attributeName);
+                    d.element.removeAttribute(attributeName);
+                }
+                else if (property.type == 'boolean' && value) {
+                    d.attributes.set(attributeName, "");
+                    d.element.setAttribute(attributeName, "");
+                }
+                else {
+                    d.attributes.set(attributeName, value);
+                    d.element.setAttribute(attributeName, value);
+                }
+                this._notifyChangedProperty(d, property, value);
+            }
+            cg.commit();
+        }
+        catch (err) {
+            console.log(err);
+            cg.undo();
+        }
+    }
+    getPropertyTarget(designItem, property) {
+        return BindingTarget.property;
+    }
+    clearValue(designItems, property) {
+        const attributeName = PropertiesHelper.camelToDashCase(property.name);
+        for (let d of designItems) {
+            d.attributes.delete(attributeName);
+            d.element.removeAttribute(attributeName);
+            d.serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
+                return s.clearBinding(d, property.name, this.getPropertyTarget(d, property));
+            });
+            this._notifyChangedProperty(d, property, undefined);
+        }
+    }
+    isSet(designItems, property) {
+        let all = true;
+        let some = false;
+        if (designItems != null && designItems.length !== 0) {
+            let attributeName = PropertiesHelper.camelToDashCase(property.name);
+            designItems.forEach((x) => {
+                let has = x.attributes.has(attributeName);
+                all = all && has;
+                some = some || has;
+            });
+        }
+        else
+            return ValueType.none;
+        return all ? ValueType.all : some ? ValueType.some : ValueType.none;
+    }
+    getValue(designItems, property) {
+        if (designItems != null && designItems.length !== 0) {
+            let attributeName = PropertiesHelper.camelToDashCase(property.name);
+            if (property.type == 'boolean')
+                return designItems[0].attributes.has(attributeName);
+            let lastValue = designItems[0].attributes.get(attributeName);
+            /*
+            for (const x of designItems) {
+              let value = x.attributes.get(attributeName);
+              if (value != lastValue) {
+                lastValue = null;
+                break;
+              }
+            }
+            */
+            return lastValue;
+        }
+        return null;
+    }
+    getUnsetValue(designItems, property) {
+        return property.defaultValue;
+    }
+}

package/dist/elements/services/selectionService/ISelectionChangedEvent.d.ts

@@ -1,5 +1,5 @@
-import { IDesignItem } from '../../item/IDesignItem';
-export interface ISelectionChangedEvent {
-    oldSelectedElements: IDesignItem[];
-    selectedElements: IDesignItem[];
-}
+import { IDesignItem } from '../../item/IDesignItem';
+export interface ISelectionChangedEvent {
+    oldSelectedElements: IDesignItem[];
+    selectedElements: IDesignItem[];
+}

package/dist/elements/services/selectionService/ISelectionChangedEvent.js

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

package/dist/elements/services/selectionService/ISelectionService.d.ts

@@ -1,11 +1,11 @@
-import { TypedEvent } from '@node-projects/base-custom-webcomponent';
-import { IDesignItem } from '../../item/IDesignItem';
-import { ISelectionChangedEvent } from './ISelectionChangedEvent';
-export interface ISelectionService {
-    primarySelection: IDesignItem;
-    selectedElements: IDesignItem[];
-    setSelectedElements(designItems: IDesignItem[]): void;
-    clearSelectedElements(): void;
-    isSelected(designItem: IDesignItem): boolean;
-    readonly onSelectionChanged: TypedEvent<ISelectionChangedEvent>;
-}
+import { TypedEvent } from '@node-projects/base-custom-webcomponent';
+import { IDesignItem } from '../../item/IDesignItem';
+import { ISelectionChangedEvent } from './ISelectionChangedEvent';
+export interface ISelectionService {
+    primarySelection: IDesignItem;
+    selectedElements: IDesignItem[];
+    setSelectedElements(designItems: IDesignItem[]): void;
+    clearSelectedElements(): void;
+    isSelected(designItem: IDesignItem): boolean;
+    readonly onSelectionChanged: TypedEvent<ISelectionChangedEvent>;
+}

package/dist/elements/services/selectionService/ISelectionService.js

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

package/dist/elements/services/selectionService/SelectionService.d.ts

@@ -1,12 +1,12 @@
-import { ISelectionService } from './ISelectionService';
-import { IDesignItem } from '../../item/IDesignItem';
-import { ISelectionChangedEvent } from './ISelectionChangedEvent';
-import { TypedEvent } from '@node-projects/base-custom-webcomponent';
-export declare class SelectionService implements ISelectionService {
-    primarySelection: IDesignItem;
-    selectedElements: IDesignItem[];
-    setSelectedElements(designItems: IDesignItem[]): void;
-    clearSelectedElements(): void;
-    isSelected(designItem: IDesignItem): boolean;
-    readonly onSelectionChanged: TypedEvent<ISelectionChangedEvent>;
-}
+import { ISelectionService } from './ISelectionService';
+import { IDesignItem } from '../../item/IDesignItem';
+import { ISelectionChangedEvent } from './ISelectionChangedEvent';
+import { TypedEvent } from '@node-projects/base-custom-webcomponent';
+export declare class SelectionService implements ISelectionService {
+    primarySelection: IDesignItem;
+    selectedElements: IDesignItem[];
+    setSelectedElements(designItems: IDesignItem[]): void;
+    clearSelectedElements(): void;
+    isSelected(designItem: IDesignItem): boolean;
+    readonly onSelectionChanged: TypedEvent<ISelectionChangedEvent>;
+}

package/dist/elements/services/selectionService/SelectionService.js

@@ -1,35 +1,35 @@
-import { TypedEvent } from '@node-projects/base-custom-webcomponent';
-import { NodeType } from '../../item/NodeType';
-export class SelectionService {
-    primarySelection;
-    selectedElements = [];
-    setSelectedElements(designItems) {
-        let oldSelectedElements = this.selectedElements;
-        if (!designItems) {
-            this.selectedElements = [];
-            this.primarySelection = null;
-        }
-        else {
-            let newSelection = [];
-            for (let d of designItems) {
-                while (d && d.nodeType == NodeType.TextNode)
-                    d = d.parent;
-                if (d && d.nodeType == NodeType.Element && d != d.instanceServiceContainer.contentService.rootDesignItem)
-                    newSelection.push(d);
-            }
-            this.selectedElements = newSelection;
-            if (newSelection && newSelection.length > 0)
-                this.primarySelection = newSelection[0];
-            else
-                this.primarySelection = null;
-        }
-        this.onSelectionChanged.emit({ selectedElements: this.selectedElements, oldSelectedElements: oldSelectedElements });
-    }
-    clearSelectedElements() {
-        this.setSelectedElements([]);
-    }
-    isSelected(designItem) {
-        return this.selectedElements.indexOf(designItem) >= 0;
-    }
-    onSelectionChanged = new TypedEvent();
-}
+import { TypedEvent } from '@node-projects/base-custom-webcomponent';
+import { NodeType } from '../../item/NodeType';
+export class SelectionService {
+    primarySelection;
+    selectedElements = [];
+    setSelectedElements(designItems) {
+        let oldSelectedElements = this.selectedElements;
+        if (!designItems) {
+            this.selectedElements = [];
+            this.primarySelection = null;
+        }
+        else {
+            let newSelection = [];
+            for (let d of designItems) {
+                while (d && d.nodeType == NodeType.TextNode)
+                    d = d.parent;
+                if (d && d.nodeType == NodeType.Element && d != d.instanceServiceContainer.contentService.rootDesignItem)
+                    newSelection.push(d);
+            }
+            this.selectedElements = newSelection;
+            if (newSelection && newSelection.length > 0)
+                this.primarySelection = newSelection[0];
+            else
+                this.primarySelection = null;
+        }
+        this.onSelectionChanged.emit({ selectedElements: this.selectedElements, oldSelectedElements: oldSelectedElements });
+    }
+    clearSelectedElements() {
+        this.setSelectedElements([]);
+    }
+    isSelected(designItem) {
+        return this.selectedElements.indexOf(designItem) >= 0;
+    }
+    onSelectionChanged = new TypedEvent();
+}

package/dist/elements/services/treeStructureService/ITreeStructureChangedEvent.d.ts

@@ -1,8 +1,8 @@
-import { IDesignItem } from '../../item/IDesignItem';
-export interface ITreeStructureChangedEvent {
-    action: 'add' | 'move' | 'remove' | 'replace' | 'reset';
-    newItems?: IDesignItem[];
-    newStartingIndex?: number;
-    oldItems?: IDesignItem[];
-    oldStartingIndex?: number;
-}
+import { IDesignItem } from '../../item/IDesignItem';
+export interface ITreeStructureChangedEvent {
+    action: 'add' | 'move' | 'remove' | 'replace' | 'reset';
+    newItems?: IDesignItem[];
+    newStartingIndex?: number;
+    oldItems?: IDesignItem[];
+    oldStartingIndex?: number;
+}

package/dist/elements/services/treeStructureService/ITreeStructureChangedEvent.js

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

package/dist/elements/services/treeStructureService/ITreeStructureService.d.ts

@@ -1,2 +1,2 @@
-export interface ITreeStructureService {
-}
+export interface ITreeStructureService {
+}

package/dist/elements/services/treeStructureService/ITreeStructureService.js

@@ -1,2 +1,2 @@
-export {};
-//maybe this service caches a dictionary designitem -> treeelement?, filled by treeView control?
+export {};
+//maybe this service caches a dictionary designitem -> treeelement?, filled by treeView control?

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

@@ -1,17 +1,17 @@
-import { ITransactionItem } from './ITransactionItem';
-import { IDesignItem } from '../../item/IDesignItem';
-export declare class ChangeGroup implements ITransactionItem {
-    title: string;
-    affectedItems: IDesignItem[];
-    private commitHandler;
-    private abortHandler;
-    constructor(title: string, affectedItems: IDesignItem[], commitHandler: (transactionItem: ITransactionItem) => void, abortHandler: (transactionItem: ITransactionItem) => void);
-    do(): void;
-    undo(): void;
-    commit(): void;
-    abort(): void;
-    mergeWith(other: ITransactionItem): boolean;
-    undoStack: ITransactionItem[];
-    redoStack: ITransactionItem[];
-    execute(item: ITransactionItem): void;
-}
+import { ITransactionItem } from './ITransactionItem';
+import { IDesignItem } from '../../item/IDesignItem';
+export declare class ChangeGroup implements ITransactionItem {
+    title: string;
+    affectedItems: IDesignItem[];
+    private commitHandler;
+    private abortHandler;
+    constructor(title: string, affectedItems: IDesignItem[], commitHandler: (transactionItem: ITransactionItem) => void, abortHandler: (transactionItem: ITransactionItem) => void);
+    do(): void;
+    undo(): void;
+    commit(): void;
+    abort(): void;
+    mergeWith(other: ITransactionItem): boolean;
+    undoStack: ITransactionItem[];
+    redoStack: ITransactionItem[];
+    execute(item: ITransactionItem): void;
+}

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

@@ -1,56 +1,56 @@
-export class ChangeGroup {
-    title;
-    affectedItems;
-    commitHandler;
-    abortHandler;
-    constructor(title, affectedItems, commitHandler, abortHandler) {
-        this.title = title;
-        this.affectedItems = affectedItems;
-        this.commitHandler = commitHandler;
-        this.abortHandler = abortHandler;
-    }
-    do() {
-        let item = null;
-        while (item = this.redoStack.pop()) {
-            try {
-                item.do();
-                this.undoStack.push(item);
-            }
-            catch (err) {
-                throw err;
-            }
-        }
-    }
-    undo() {
-        let item = null;
-        while (item = this.undoStack.pop()) {
-            try {
-                item.undo();
-                this.redoStack.push(item);
-            }
-            catch (err) {
-                throw err;
-            }
-        }
-    }
-    ;
-    commit() {
-        this.commitHandler(this);
-    }
-    abort() {
-        this.abortHandler(this);
-    }
-    mergeWith(other) {
-        return false;
-    }
-    undoStack = [];
-    redoStack = [];
-    execute(item) {
-        item.do();
-        for (let existingItem of this.undoStack) {
-            if (existingItem.mergeWith(item))
-                return;
-        }
-        this.undoStack.push(item);
-    }
-}
+export class ChangeGroup {
+    title;
+    affectedItems;
+    commitHandler;
+    abortHandler;
+    constructor(title, affectedItems, commitHandler, abortHandler) {
+        this.title = title;
+        this.affectedItems = affectedItems;
+        this.commitHandler = commitHandler;
+        this.abortHandler = abortHandler;
+    }
+    do() {
+        let item = null;
+        while (item = this.redoStack.pop()) {
+            try {
+                item.do();
+                this.undoStack.push(item);
+            }
+            catch (err) {
+                throw err;
+            }
+        }
+    }
+    undo() {
+        let item = null;
+        while (item = this.undoStack.pop()) {
+            try {
+                item.undo();
+                this.redoStack.push(item);
+            }
+            catch (err) {
+                throw err;
+            }
+        }
+    }
+    ;
+    commit() {
+        this.commitHandler(this);
+    }
+    abort() {
+        this.abortHandler(this);
+    }
+    mergeWith(other) {
+        return false;
+    }
+    undoStack = [];
+    redoStack = [];
+    execute(item) {
+        item.do();
+        for (let existingItem of this.undoStack) {
+            if (existingItem.mergeWith(item))
+                return;
+        }
+        this.undoStack.push(item);
+    }
+}