@node-projects/web-component-designer 0.0.289 → 0.0.291

package/dist/elements/helper/NpmPackageHacks.json

@@ -0,0 +1,11 @@
+{
+    "@shoelace-style/shoelace": {
+        "html": "<link rel=\"stylesheet\" media=\"(prefers-color-scheme:light)\" href=\"${baseUrl}dist/themes/light.css\">\n<link rel=\"stylesheet\" media=\"(prefers-color-scheme:dark)\" href=\"${baseUrl}dist/themes/dark.css\" onload=\"document.documentElement.classList.add('sl-theme-dark');\">"
+    },
+    "@microsoft/fast-components": {
+        "script": "let res = await import('@microsoft/fast-components');\nres.provideFASTDesignSystem().register(res.allComponents);"
+    },
+    "@material/web": {
+        "import": "@material/web/all.js"
+    }
+}

package/dist/elements/helper/NpmPackageLoader.d.ts

@@ -6,7 +6,9 @@ export declare class NpmPackageLoader {
     private _dependecies;
     constructor(packageSource?: string);
     static patchCustomElementsRegistryToHandleErrors(): void;
-    loadNpmPackage(pkg: string, serviceContainer?: ServiceContainer, paletteTree?: PaletteTreeView, loadAllImports?: boolean, reportState?: (state: string) => void): Promise<void>;
+    loadNpmPackage(pkg: string, serviceContainer?: ServiceContainer, paletteTree?: PaletteTreeView, loadAllImports?: boolean, reportState?: (state: string) => void): Promise<{
+        html: string;
+    }>;
     loadDependency(dependency: string, version?: string, reportState?: (state: string) => void): Promise<void>;
     addToImportmap(baseUrl: string, packageJsonObj: {
         name?: string;

package/dist/elements/helper/NpmPackageLoader.js

@@ -2,6 +2,19 @@ import { PreDefinedElementsService } from "../services/elementsService/PreDefine
 import { WebcomponentManifestElementsService } from "../services/elementsService/WebcomponentManifestElementsService.js";
 import { WebcomponentManifestPropertiesService } from "../services/propertiesService/services/WebcomponentManifestPropertiesService.js";
 import { removeLeading, removeTrailing } from "./Helper.js";
+//TODO: remove this code when import asserts are supported
+let packageHacks;
+//@ts-ignore
+if (window.importShim) {
+    const packageHacksUrl = import.meta.resolve('./NpmPackageHacks.json');
+    //@ts-ignore
+    packageHacks = await importShim(packageHacksUrl, { assert: { type: 'json' } });
+}
+else
+    //@ts-ignore
+    packageHacks = await import("./NpmPackageHacks.json", { assert: { type: 'json' } });
+if (packageHacks.default)
+    packageHacks = packageHacks.default;
 export class NpmPackageLoader {
     static registryPatchedTohandleErrors;
     //packageSource = '//unpkg.com/';
@@ -121,24 +134,32 @@ export class NpmPackageLoader {
                 //todo: should be retriggered by service container, or changeing list in container
                 paletteTree.loadControls(serviceContainer, serviceContainer.elementsServices);
             }
+            /* Package Hacks */
+            if (packageHacks[pkg]?.import) {
+                import(packageHacks[pkg]?.import);
+            }
+            if (packageHacks[pkg]?.script) {
+                const scriptUrl = URL.createObjectURL(new Blob([packageHacks[pkg]?.script], { type: 'application/javascript' }));
+                import(scriptUrl);
+            }
         }
         else {
             console.warn('npm package: ' + pkg + ' - no custom-elements.json found, only loading javascript module');
-            let customElementsRegistry = window.customElements;
+            let originalCustomElementsRegistry = window.customElements;
             const registry = {};
             const newElements = [];
             registry.define = function (name, constructor, options) {
                 newElements.push(name);
-                customElementsRegistry.define(name, constructor, options);
+                originalCustomElementsRegistry.define(name, constructor, options);
             };
             registry.get = function (name) {
-                return customElementsRegistry.get(name);
+                return originalCustomElementsRegistry.get(name);
             };
             registry.upgrade = function (node) {
-                return customElementsRegistry.upgrade(node);
+                return originalCustomElementsRegistry.upgrade(node);
             };
             registry.whenDefined = function (name) {
-                return customElementsRegistry.whenDefined(name);
+                return originalCustomElementsRegistry.whenDefined(name);
             };
             Object.defineProperty(window, "customElements", {
                 get() {
@@ -160,6 +181,14 @@ export class NpmPackageLoader {
             else {
                 console.warn('npm package: ' + pkg + ' - no entry point in package found.');
             }
+            /* Package Hacks */
+            if (packageHacks[pkg]?.import) {
+                await import(packageHacks[pkg]?.import);
+            }
+            if (packageHacks[pkg]?.script) {
+                const scriptUrl = URL.createObjectURL(new Blob([packageHacks[pkg]?.script], { type: 'application/javascript' }));
+                await import(scriptUrl);
+            }
             if (newElements.length > 0 && serviceContainer && paletteTree) {
                 const elementsCfg = {
                     elements: newElements
@@ -170,12 +199,17 @@ export class NpmPackageLoader {
             }
             Object.defineProperty(window, "customElements", {
                 get() {
-                    return customElementsRegistry;
+                    return originalCustomElementsRegistry;
                 }
             });
         }
         if (reportState)
             reportState(pkg + ": done");
+        let retVal = {};
+        if (packageHacks[pkg]?.html) {
+            retVal.html = (packageHacks[pkg]?.html).replaceAll("${baseUrl}", baseUrl);
+        }
+        return retVal;
     }
     async loadDependency(dependency, version, reportState) {
         if (this._dependecies.has(dependency))
@@ -295,10 +329,10 @@ export class NpmPackageLoader {
                 //Names to use: browser, import, default, node
                 let imp = getImportFlat(packageJsonObj.exports);
                 if (imp) {
-                    importMap.imports[packageJsonObj.name] = baseUrl + removeLeading(removeTrailing(imp, '/'), '.');
+                    importMap.imports[packageJsonObj.name] = baseUrl + removeLeading(removeLeading(imp, '.'), '/');
                 }
                 else if (imp = getImportFlat(packageJsonObj.exports?.['.'])) {
-                    importMap.imports[packageJsonObj.name] = baseUrl + removeLeading(removeTrailing(imp, '/'), '.');
+                    importMap.imports[packageJsonObj.name] = baseUrl + removeLeading(removeLeading(imp, '.'), '/');
                 }
             }
             let mainImport = packageJsonObj.main;
@@ -308,7 +342,7 @@ export class NpmPackageLoader {
                 mainImport = packageJsonObj.unpkg;
             if (!importMap.imports[packageJsonObj.name]) {
                 if (mainImport)
-                    importMap.imports[packageJsonObj.name] = baseUrl + removeTrailing(mainImport, '/');
+                    importMap.imports[packageJsonObj.name] = baseUrl + removeLeading(removeLeading(mainImport, '.'), '/');
                 else
                     console.warn('package: ' + baseUrl + 'no main import found');
             }

package/dist/elements/services/dragDropService/DragDropService.js

@@ -1,5 +1,4 @@
 import { DesignItem } from '../../item/DesignItem.js';
-import { InsertAction } from "../undoService/transactionItems/InsertAction.js";
 import { ExtensionType } from "../../widgets/designerView/extensions/ExtensionType.js";
 import { dragDropFormatNameElementDefinition } from "../../../Constants.js";
 export class DragDropService {
@@ -37,7 +36,6 @@ export class DragDropService {
         let [newContainer] = this.getPossibleContainerForDragDrop(designerCanvas, event);
         if (!newContainer)
             newContainer = designerCanvas.rootDesignItem;
-        //TODO : we need to use container service for adding to element, so also grid and flexbox work correct
         const transferData = event.dataTransfer.getData(dragDropFormatNameElementDefinition);
         const elementDefinition = JSON.parse(transferData);
         const di = await designerCanvas.serviceContainer.forSomeServicesTillResult("instanceService", (service) => service.getElement(elementDefinition, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer));
@@ -50,7 +48,6 @@ export class DragDropService {
         const pos = { x: evCoord.x - containerPos.x, y: evCoord.y - containerPos.y };
         containerService.place(event, designerCanvas, newContainer, { x: 0, y: 0 }, { x: 0, y: 0 }, pos, [di]);
         containerService.finishPlace(event, designerCanvas, newContainer, { x: 0, y: 0 }, { x: 0, y: 0 }, pos, [di]);
-        designerCanvas.instanceServiceContainer.undoService.execute(new InsertAction(newContainer, newContainer.childCount, di));
         requestAnimationFrame(() => {
             designerCanvas.instanceServiceContainer.selectionService.setSelectedElements([di]);
             grp.commit();

package/dist/elements/services/placementService/DefaultPlacementService.js

@@ -121,6 +121,7 @@ export class DefaultPlacementService {
     enterContainer(container, items) {
         let filterdItems = filterChildPlaceItems(items);
         for (let i of filterdItems) {
+            container.insertChild(i);
             if (i.lastContainerSize) {
                 if (!i.hasStyle('width'))
                     i.setStyle('width', i.lastContainerSize.width + 'px');

package/dist/elements/services/placementService/FlexBoxPlacementService.js

@@ -6,6 +6,7 @@ export class FlexBoxPlacementService {
     }
     enterContainer(container, items) {
         for (let i of items) {
+            container.insertChild(i);
             i.removeStyle("position");
             i.removeStyle("left");
             i.removeStyle("top");

package/dist/elements/services/placementService/GridPlacementService.js

@@ -8,6 +8,7 @@ export class GridPlacementService {
     }
     enterContainer(container, items) {
         for (let i of items) {
+            container.insertChild(i);
             i.removeStyle("position");
             i.removeStyle("left");
             i.removeStyle("top");

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

@@ -17,7 +17,7 @@ export class CssCustomPropertiesService extends CommonPropertiesService {
         return { name: name, type: 'string', service: this, propertyType: PropertyType.cssValue };
     }
     getProperties(designItem) {
-        if (!designItem.element.computedStyleMap)
+        if (!designItem?.element?.computedStyleMap)
             return null;
         let rootMap = Array.from(designItem.instanceServiceContainer.designerCanvas.rootDesignItem.element.computedStyleMap()).map(x => x[0]).filter(key => key.startsWith("--"));
         let props = Array.from(designItem.element.computedStyleMap()).map(x => x[0]).filter(key => key.startsWith("--"));

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

@@ -0,0 +1,10 @@
+import { IProperty } from '../IProperty.js';
+import { IDesignItem } from '../../../item/IDesignItem.js';
+import { IPropertyGroup } from '../IPropertyGroup.js';
+import { AbstractPropertiesService } from './AbstractPropertiesService.js';
+import { RefreshMode } from '../IPropertiesService.js';
+export declare class UnkownElementsPropertiesService extends AbstractPropertiesService {
+    getRefreshMode(designItem: IDesignItem): RefreshMode;
+    isHandledElement(designItem: IDesignItem): boolean;
+    getProperties(designItem: IDesignItem): IProperty[] | IPropertyGroup[];
+}

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

@@ -0,0 +1,28 @@
+import { AbstractPropertiesService } from './AbstractPropertiesService.js';
+import { RefreshMode } from '../IPropertiesService.js';
+import { PropertyType } from '../PropertyType.js';
+export class UnkownElementsPropertiesService extends AbstractPropertiesService {
+    getRefreshMode(designItem) {
+        return RefreshMode.full;
+    }
+    isHandledElement(designItem) {
+        return true;
+    }
+    getProperties(designItem) {
+        let list = Object.getOwnPropertyNames(Object.getPrototypeOf(designItem.element));
+        let props = [];
+        for (let p of list) {
+            let desc = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(designItem.element), p);
+            if (desc.get || desc.set) {
+                let v = designItem.element[p];
+                if (typeof v == 'boolean')
+                    props.push({ name: p, type: 'boolean', service: this, propertyType: PropertyType.propertyAndAttribute });
+                else if (typeof v == 'number')
+                    props.push({ name: p, type: 'bonumberolean', service: this, propertyType: PropertyType.propertyAndAttribute });
+                else
+                    props.push({ name: p, type: 'string', service: this, propertyType: PropertyType.propertyAndAttribute });
+            }
+        }
+        return props;
+    }
+}

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

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { IPropertiesService, RefreshMode } from '../IPropertiesService.js';
+import { IProperty } from '../IProperty.js';
+import { IDesignItem } from '../../../item/IDesignItem.js';
+import { ValueType } from '../ValueType.js';
+import { BindingTarget } from '../../../item/BindingTarget.js';
+import { IBinding } from '../../../item/IBinding.js';
+import { IPropertyGroup } from '../IPropertyGroup.js';
+export declare abstract class AbstractPropertiesService implements IPropertiesService {
+    _stylesCache: Map<IDesignItem, Set<string>>;
+    _cacheClearTimer: NodeJS.Timeout;
+    abstract getRefreshMode(designItem: IDesignItem): RefreshMode;
+    abstract isHandledElement(designItem: IDesignItem): boolean;
+    protected _notifyChangedProperty(designItem: IDesignItem, property: IProperty, value: any): void;
+    getProperty(designItem: IDesignItem, name: string): IProperty;
+    getProperties(designItem: IDesignItem): IProperty[] | IPropertyGroup[];
+    setValue(designItems: IDesignItem[], property: IProperty, value: any): void;
+    getPropertyTarget(designItem: IDesignItem, property: IProperty): BindingTarget;
+    clearValue(designItems: IDesignItem[], property: IProperty, clearType: 'all' | 'binding' | 'value'): void;
+    isSet(designItems: IDesignItem[], property: IProperty): ValueType;
+    getValue(designItems: IDesignItem[], property: IProperty): string | boolean;
+    getBinding(designItems: IDesignItem[], property: IProperty): IBinding;
+    getUnsetValue(designItems: IDesignItem[], property: IProperty): any;
+}

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

@@ -0,0 +1,198 @@
+import { ValueType } from '../ValueType.js';
+import { PropertiesHelper } from './PropertiesHelper.js';
+import { BindingTarget } from '../../../item/BindingTarget.js';
+import { PropertyType } from '../PropertyType.js';
+import { NodeType } from '../../../item/NodeType.js';
+export class AbstractPropertiesService {
+    _stylesCache = new Map;
+    _cacheClearTimer;
+    _notifyChangedProperty(designItem, property, value) {
+    }
+    getProperty(designItem, name) {
+        let properties = this.getProperties(designItem);
+        if ('properties' in properties[0]) {
+            return properties.flatMap(x => x.properties).find(x => x.name == name);
+        }
+        else
+            return properties.find(x => x.name == name);
+    }
+    getProperties(designItem) {
+        Object.getOwnPropertyNames(Object.getPrototypeOf(designItem.element));
+    }
+    setValue(designItems, property, value) {
+        const cg = designItems[0].openGroup("property changed: " + property.name + " to " + value);
+        for (let d of designItems) {
+            if (property.propertyType == PropertyType.cssValue) {
+                d.updateStyleInSheetOrLocal(property.name, value);
+                //unkown css property names do not trigger the mutation observer of property grid, 
+                //fixed by assinging stle again to the attribute
+                d.element.setAttribute('style', d.element.getAttribute('style'));
+            }
+            else {
+                let attributeName = property.attributeName;
+                if (!attributeName)
+                    attributeName = PropertiesHelper.camelToDashCase(property.name);
+                if (property.type === 'object') {
+                    const json = JSON.stringify(value);
+                    if (property.propertyType == PropertyType.attribute || property.propertyType == PropertyType.propertyAndAttribute)
+                        d.setAttribute(attributeName, json);
+                    if (property.propertyType == PropertyType.property || property.propertyType == PropertyType.propertyAndAttribute)
+                        d.element[property.name] = value;
+                }
+                else if (property.type == 'boolean' && !value) {
+                    if (property.propertyType == PropertyType.attribute || property.propertyType == PropertyType.propertyAndAttribute)
+                        d.removeAttribute(attributeName);
+                    if (property.propertyType == PropertyType.property || property.propertyType == PropertyType.propertyAndAttribute)
+                        d.element[property.name] = false;
+                }
+                else if (property.type == 'boolean' && value) {
+                    if (property.propertyType == PropertyType.attribute || property.propertyType == PropertyType.propertyAndAttribute)
+                        d.setAttribute(attributeName, "");
+                    if (property.propertyType == PropertyType.property || property.propertyType == PropertyType.propertyAndAttribute)
+                        d.element[property.name] = true;
+                }
+                else {
+                    if (property.propertyType == PropertyType.attribute || property.propertyType == PropertyType.propertyAndAttribute)
+                        d.setAttribute(attributeName, value.toString());
+                    if (property.propertyType == PropertyType.property || property.propertyType == PropertyType.propertyAndAttribute)
+                        d.element[property.name] = value;
+                }
+            }
+            this._notifyChangedProperty(d, property, value);
+        }
+        cg.commit();
+    }
+    getPropertyTarget(designItem, property) {
+        return BindingTarget.property;
+    }
+    clearValue(designItems, property, clearType) {
+        const cg = designItems[0].openGroup("property cleared: " + property.name);
+        for (let d of designItems) {
+            if (clearType != 'binding') {
+                if (property.propertyType == PropertyType.cssValue) {
+                    d.removeStyle(property.name);
+                }
+                else {
+                    let attributeName = property.attributeName;
+                    if (!attributeName)
+                        attributeName = PropertiesHelper.camelToDashCase(property.name);
+                    d.removeAttribute(attributeName);
+                }
+            }
+            if (clearType != 'value') {
+                d.serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
+                    return s.clearBinding(d, property.name, this.getPropertyTarget(d, property));
+                });
+            }
+            this._notifyChangedProperty(d, property, undefined);
+        }
+        cg.commit();
+    }
+    isSet(designItems, property) {
+        let all = true;
+        let some = false;
+        if (designItems != null && designItems.length !== 0) {
+            let attributeName = property.attributeName;
+            if (!attributeName)
+                attributeName = PropertiesHelper.camelToDashCase(property.name);
+            for (let x of designItems) {
+                let has = false;
+                if (property.propertyType == PropertyType.cssValue)
+                    has = x.hasStyle(property.name);
+                else
+                    has = x.hasAttribute(attributeName);
+                all = all && has;
+                some = some || has;
+                if (!all && some)
+                    break;
+            }
+            ;
+            //todo: optimize perf, do not call bindings service for each property. 
+            const bindings = designItems[0].serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
+                return s.getBindings(designItems[0]);
+            });
+            if (property.propertyType == PropertyType.cssValue) {
+                if (bindings && bindings.find(x => x.target == BindingTarget.css && x.targetName == property.name))
+                    return ValueType.bound;
+            }
+            else {
+                if (bindings && bindings.find(x => x.target == BindingTarget.property && x.targetName == property.name))
+                    return ValueType.bound;
+            }
+            if (!all && property.propertyType == PropertyType.cssValue) {
+                let styles = this._stylesCache.get(designItems[0]);
+                if (!styles) {
+                    styles = new Set(designItems[0].getAllStyles().filter(x => x.selector != null).flatMap(x => x.declarations).map(x => x.name));
+                    this._stylesCache.set(designItems[0], styles);
+                    clearTimeout(this._cacheClearTimer);
+                    this._cacheClearTimer = setTimeout(() => this._stylesCache.clear(), 30);
+                }
+                let cssValue = styles.has(property.name);
+                if (cssValue)
+                    return ValueType.fromStylesheet;
+            }
+        }
+        else
+            return ValueType.none;
+        return all ? ValueType.all : some ? ValueType.some : ValueType.none;
+    }
+    getValue(designItems, property) {
+        if (designItems != null && designItems.length !== 0) {
+            if (property.propertyType == PropertyType.cssValue) {
+                let lastValue = designItems[0].getStyle(property.name);
+                for (const d of designItems) {
+                    let value = d.getStyle(property.name);
+                    if (value != lastValue) {
+                        lastValue = null;
+                        break;
+                    }
+                }
+                return lastValue;
+            }
+            else {
+                let attributeName = property.attributeName;
+                if (!attributeName)
+                    attributeName = PropertiesHelper.camelToDashCase(property.name);
+                if (property.type == 'boolean')
+                    return designItems[0].hasAttribute(attributeName);
+                let lastValue = designItems[0].getAttribute(attributeName);
+                /*
+                for (const x of designItems) {
+                  let value = x.attributes.get(attributeName);
+                  if (value != lastValue) {
+                    lastValue = null;
+                    break;
+                  }
+                }
+                */
+                return lastValue;
+            }
+        }
+        return null;
+    }
+    getBinding(designItems, property) {
+        //TODO: optimize perf, do not call bindings service for each property. 
+        const bindings = designItems[0].serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
+            return s.getBindings(designItems[0]);
+        });
+        if (property.propertyType == PropertyType.cssValue) {
+            return bindings.find(x => (x.target == BindingTarget.css) && x.targetName == property.name);
+        }
+        else {
+            return bindings.find(x => (x.target == BindingTarget.property || x.target == BindingTarget.attribute) && x.targetName == property.name);
+        }
+    }
+    getUnsetValue(designItems, property) {
+        if (property.propertyType == PropertyType.cssValue) {
+            if (designItems != null && designItems.length !== 0) {
+                if (designItems[0].nodeType == NodeType.Element) {
+                    let v = window.getComputedStyle(designItems[0].element)[property.name];
+                    return v;
+                }
+            }
+            return null;
+        }
+        else
+            return property.defaultValue;
+    }
+}

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

@@ -34,7 +34,8 @@ export class WebcomponentManifestPropertiesService extends AbstractPropertiesSer
                                     if (declaration.attributes)
                                         pType = declaration.attributes.find(x => x.fieldName == d.name) != null ? PropertyType.propertyAndAttribute : PropertyType.property;
                                     const p = this.manifestClassPropertyTypeToEditorPropertyType(d.type?.text);
-                                    properties.push({ name: d.name, service: this, propertyType: pType, type: p[0], values: p[1], description: d.description });
+                                    if (d.name)
+                                        properties.push({ name: d.name, service: this, propertyType: pType, type: p[0], values: p[1], description: d.description });
                                 }
                             }
                             this._propertiesList[e.name] = properties;

package/dist/elements/widgets/designerView/tools/PointerTool.js

@@ -207,16 +207,18 @@ export class PointerTool {
                     }
                     if (!this._actionStartedDesignItem)
                         return;
+                    if (!this._changeGroup)
+                        this._changeGroup = designerCanvas.rootDesignItem.openGroup("Move Elements");
                     if (event.ctrlKey && !this._copiedItemsInserted) {
+                        this._changeGroup.title = "Copy Elements";
                         this._copiedItemsInserted = true;
-                        if (!this._changeGroup)
-                            this._changeGroup = designerCanvas.rootDesignItem.openGroup("Copy Elements");
                         for (let i = 0; i < this._clonedItems.length; i++) {
                             this._actionStartedDesignItems[i].insertAdjacentElement(this._clonedItems[i], 'beforebegin');
                         }
                         designerCanvas.instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'added', designItems: this._clonedItems });
                     }
                     else if (!event.ctrlKey && this._copiedItemsInserted) {
+                        this._changeGroup.title = "Move Elements";
                         for (let d of this._clonedItems) {
                             d.remove();
                         }
@@ -270,8 +272,6 @@ export class PointerTool {
                                 const newOffset = newContainerService.getElementOffset(newContainerElementDesignItem, this._actionStartedDesignItem);
                                 this._moveItemsOffset = { x: newOffset.x - oldOffset.x + this._moveItemsOffset.x, y: newOffset.y - oldOffset.y + this._moveItemsOffset.y };
                                 currentContainerService.leaveContainer(this._actionStartedDesignItem.parent, this._actionStartedDesignItems);
-                                for (let di of this._actionStartedDesignItems)
-                                    newContainerElementDesignItem._insertChildInternal(di); //todo -> maybe in enter container???
                                 const cp = { x: currentPoint.x - this._moveItemsOffset.x, y: currentPoint.y - this._moveItemsOffset.y };
                                 newContainerService.enterContainer(newContainerElementDesignItem, this._actionStartedDesignItems);
                                 newContainerService.place(event, designerCanvas, this._actionStartedDesignItem.parent, this._initialPoint, this._initialOffset, cp, this._actionStartedDesignItems);

package/dist/index.d.ts

@@ -119,6 +119,7 @@ export * from "./elements/services/propertiesService/services/AbstractProperties
 export * from "./elements/services/propertiesService/services/WebcomponentManifestPropertiesService.js";
 export * from "./elements/services/propertiesService/services/AttributesPropertiesService.js";
 export * from "./elements/services/propertiesService/services/CssCustomPropertiesService.js";
+export * from "./elements/services/propertiesService/services/UnkownElementsPropertiesService.js";
 export * from "./elements/services/propertiesService/PropertyType.js";
 export * from "./elements/services/propertiesService/ValueType.js";
 export * from "./elements/services/propertiesService/PropertyTabsService.js";

package/dist/index.js

@@ -79,6 +79,7 @@ export * from "./elements/services/propertiesService/services/AbstractProperties
 export * from "./elements/services/propertiesService/services/WebcomponentManifestPropertiesService.js";
 export * from "./elements/services/propertiesService/services/AttributesPropertiesService.js";
 export * from "./elements/services/propertiesService/services/CssCustomPropertiesService.js";
+export * from "./elements/services/propertiesService/services/UnkownElementsPropertiesService.js";
 export * from "./elements/services/propertiesService/PropertyType.js";
 export * from "./elements/services/propertiesService/ValueType.js";
 export * from "./elements/services/propertiesService/PropertyTabsService.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "description": "A UI designer for Polymer apps",
   "name": "@node-projects/web-component-designer",
-  "version": "0.0.289",
+  "version": "0.0.291",
   "type": "module",
   "main": "./dist/index.js",
   "author": "",