@node-projects/web-component-designer 0.0.184 → 0.0.186

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

@@ -0,0 +1,4 @@
+export declare function copyTextToClipboard(text: any): Promise<void>;
+export declare function copyToClipboard(items: [format: string, data: string][]): Promise<void>;
+export declare function getTextFromClipboard(): Promise<string>;
+export declare function getFromClipboard(): Promise<ClipboardItems>;

package/dist/elements/helper/ClipboardHelper.js

@@ -0,0 +1,84 @@
+export async function copyTextToClipboard(text) {
+    copyToClipboard(['text/plain', text]);
+}
+export async function copyToClipboard(items) {
+    if (navigator.clipboard) {
+        try {
+            let data = [];
+            for (let n of items) {
+                data.push(new ClipboardItem({ [n[0]]: new Blob([n[1]], { type: n[0] }) }));
+            }
+            await navigator.clipboard.write(data);
+        }
+        catch (err) {
+            await navigator.clipboard.writeText(items[0][1]);
+        }
+        console.info('Copy to clipboard successful');
+    }
+    else {
+        const textArea = document.createElement('textarea');
+        textArea.style.position = 'fixed';
+        textArea.style.top = '0';
+        textArea.style.left = '0';
+        textArea.style.width = '2em';
+        textArea.style.height = '2em';
+        textArea.style.padding = '0';
+        textArea.style.border = 'none';
+        textArea.style.outline = 'none';
+        textArea.style.boxShadow = 'none';
+        textArea.style.background = 'transparent';
+        textArea.value = items[0][1];
+        document.body.appendChild(textArea);
+        textArea.select();
+        try {
+            document.execCommand('copy');
+        }
+        catch (err) {
+            try {
+                document.execCommand('copy');
+            }
+            catch (err) {
+                console.error(err);
+            }
+        }
+        document.body.removeChild(textArea);
+    }
+}
+export async function getTextFromClipboard() {
+    if (navigator.clipboard) {
+        return new Promise(async (resolve, reject) => {
+            const clipText = await navigator.clipboard.readText();
+            resolve(clipText);
+        });
+    }
+    else {
+        return new Promise(async (resolve, reject) => {
+            const textArea = document.createElement('textarea');
+            textArea.style.position = 'fixed';
+            textArea.style.top = '0';
+            textArea.style.left = '0';
+            textArea.style.width = '2em';
+            textArea.style.height = '2em';
+            textArea.style.padding = '0';
+            textArea.style.border = 'none';
+            textArea.style.outline = 'none';
+            textArea.style.boxShadow = 'none';
+            textArea.style.background = 'transparent';
+            document.body.appendChild(textArea);
+            textArea.focus();
+            textArea.select();
+            document.execCommand('paste');
+            let value = textArea.value;
+            document.body.removeChild(textArea);
+            resolve(value);
+        });
+    }
+}
+export async function getFromClipboard() {
+    if (navigator.clipboard) {
+        return await navigator.clipboard.read();
+    }
+    else {
+        return null;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { ServiceContainer } from "../services/ServiceContainer.js";
+import { PaletteTreeView } from "../widgets/paletteView/paletteTreeView.js";
+export declare class NpmPackageLoader {
+    private static registryPatchedTohandleErrors;
+    private _packageSource;
+    private _dependecies;
+    constructor(packageSource?: string);
+    static patchCustomElementsRegistryToHandleErrors(): void;
+    loadNpmPackage(pkg: string, serviceContainer: ServiceContainer, paletteTree: PaletteTreeView, reportState?: (state: string) => void): Promise<void>;
+    loadDependency(dependency: string, version?: string, reportState?: (state: string) => void): Promise<void>;
+    addToImportmap(baseUrl: string, packageJsonObj: {
+        name?: string;
+        module?: string;
+        main?: string;
+        exports?: Record<string, string>;
+    }): Promise<void>;
+}

package/dist/elements/helper/NpmPackageLoader.js

@@ -0,0 +1,207 @@
+import { PreDefinedElementsService } from "../services/elementsService/PreDefinedElementsService.js";
+import { WebcomponentManifestElementsService } from "../services/elementsService/WebcomponentManifestElementsService.js";
+import { WebcomponentManifestPropertiesService } from "../services/propertiesService/services/WebcomponentManifestPropertiesService.js";
+import { removeLeading, removeTrailing } from "./Helper.js";
+export class NpmPackageLoader {
+    static registryPatchedTohandleErrors;
+    //packageSource = '//unpkg.com/';
+    _packageSource;
+    _dependecies = new Map();
+    constructor(packageSource = '//cdn.jsdelivr.net/npm/') {
+        this._packageSource = packageSource;
+        NpmPackageLoader.patchCustomElementsRegistryToHandleErrors();
+    }
+    static patchCustomElementsRegistryToHandleErrors() {
+        if (!NpmPackageLoader.registryPatchedTohandleErrors) {
+            NpmPackageLoader.registryPatchedTohandleErrors = true;
+            let customElementsRegistry = window.customElements;
+            const registry = {};
+            registry.define = function (name, constructor, options) {
+                try {
+                    customElementsRegistry.define(name, constructor, options);
+                }
+                catch (err) {
+                    console.warn(err);
+                }
+            };
+            registry.get = function (name) {
+                return customElementsRegistry.get(name);
+            };
+            registry.upgrade = function (node) {
+                return customElementsRegistry.upgrade(node);
+            };
+            registry.whenDefined = function (name) {
+                return customElementsRegistry.whenDefined(name);
+            };
+            Object.defineProperty(window, "customElements", {
+                get() {
+                    return registry;
+                }
+            });
+        }
+    }
+    //TODO: remove paletteTree form params. elements should be added to serviceconatiner, and the container should notify
+    async loadNpmPackage(pkg, serviceContainer, paletteTree, reportState) {
+        const baseUrl = window.location.protocol + this._packageSource + pkg + '/';
+        const packageJsonUrl = baseUrl + 'package.json';
+        if (reportState)
+            reportState(pkg + ": loading package.json");
+        const packageJson = await fetch(packageJsonUrl);
+        const packageJsonObj = await packageJson.json();
+        this.addToImportmap(baseUrl, packageJsonObj);
+        const depPromises = [];
+        if (packageJsonObj.dependencies) {
+            for (let d in packageJsonObj.dependencies) {
+                depPromises.push(this.loadDependency(d, packageJsonObj.dependencies[d]));
+            }
+        }
+        await Promise.all(depPromises);
+        let customElementsUrl = baseUrl + 'custom-elements.json';
+        let elementsRootPath = baseUrl;
+        if (packageJsonObj.customElements) {
+            customElementsUrl = baseUrl + removeTrailing(packageJsonObj.customElements, '/');
+            if (customElementsUrl.includes('/')) {
+                let idx = customElementsUrl.lastIndexOf('/');
+                elementsRootPath = customElementsUrl.substring(0, idx + 1);
+            }
+        }
+        let webComponentDesignerUrl = baseUrl + 'web-component-designer.json';
+        if (packageJsonObj.webComponentDesigner) {
+            webComponentDesignerUrl = baseUrl + removeLeading(packageJsonObj.webComponentDesigner, '/');
+        }
+        if (reportState)
+            reportState(pkg + ": loading custom-elements.json");
+        let customElementsJson = await fetch(customElementsUrl);
+        if (!customElementsJson.ok && packageJsonObj.homepage) {
+            try {
+                const url = new URL(packageJsonObj.homepage);
+                const newurl = 'https://raw.githubusercontent.com/' + url.pathname + '/master/custom-elements.json';
+                customElementsJson = await fetch(newurl);
+                console.warn("custom-elements.json was missing from npm package, but was loaded from github as a fallback.");
+            }
+            catch (err) {
+                console.warn("github custom elments json fallback", err);
+            }
+        }
+        fetch(webComponentDesignerUrl).then(async (x) => {
+            if (x.ok) {
+                const webComponentDesignerJson = await x.json();
+                if (webComponentDesignerJson.services) {
+                    for (let o in webComponentDesignerJson.services) {
+                        for (let s of webComponentDesignerJson.services[o]) {
+                            if (s.startsWith('./'))
+                                s = s.substring(2);
+                            //@ts-ignore
+                            const classDefinition = (await importShim(baseUrl + s)).default;
+                            //@ts-ignore
+                            serviceContainer.register(o, new classDefinition());
+                        }
+                    }
+                }
+            }
+        });
+        if (customElementsJson.ok) {
+            const customElementsJsonObj = await customElementsJson.json();
+            let elements = new WebcomponentManifestElementsService(packageJsonObj.name, elementsRootPath, customElementsJsonObj);
+            serviceContainer.register('elementsService', elements);
+            let properties = new WebcomponentManifestPropertiesService(packageJsonObj.name, customElementsJsonObj);
+            serviceContainer.register('propertyService', properties);
+            if (window.location.search.includes("loadAllImports")) {
+                for (let e of await elements.getElements()) {
+                    //@ts-ignore
+                    importShim(e.import);
+                }
+            }
+            //todo: should be retriggered by service container, or changeing list in container
+            paletteTree.loadControls(serviceContainer, serviceContainer.elementsServices);
+        }
+        else {
+            console.warn('npm package: ' + pkg + ' - no custom-elements.json found, only loading javascript module');
+            let customElementsRegistry = window.customElements;
+            const registry = {};
+            const newElements = [];
+            registry.define = function (name, constructor, options) {
+                newElements.push(name);
+                customElementsRegistry.define(name, constructor, options);
+            };
+            registry.get = function (name) {
+                return customElementsRegistry.get(name);
+            };
+            registry.upgrade = function (node) {
+                return customElementsRegistry.upgrade(node);
+            };
+            registry.whenDefined = function (name) {
+                return customElementsRegistry.whenDefined(name);
+            };
+            Object.defineProperty(window, "customElements", {
+                get() {
+                    return registry;
+                }
+            });
+            if (packageJsonObj.module) {
+                //@ts-ignore
+                await importShim(baseUrl + removeLeading(packageJsonObj.module, '/'));
+            }
+            else if (packageJsonObj.main) {
+                //@ts-ignore
+                await importShim(baseUrl + removeLeading(packageJsonObj.main, '/'));
+            }
+            else if (packageJsonObj.unpkg) {
+                //@ts-ignore
+                await importShim(baseUrl + removeLeading(packageJsonObj.unpkg, '/'));
+            }
+            else {
+                console.warn('npm package: ' + pkg + ' - no entry point in package found.');
+            }
+            if (newElements.length > 0) {
+                const elementsCfg = {
+                    elements: newElements
+                };
+                let elService = new PreDefinedElementsService(pkg, elementsCfg);
+                serviceContainer.register('elementsService', elService);
+                paletteTree.loadControls(serviceContainer, serviceContainer.elementsServices);
+            }
+            Object.defineProperty(window, "customElements", {
+                get() {
+                    return customElementsRegistry;
+                }
+            });
+        }
+        if (reportState)
+            reportState(pkg + ": done");
+    }
+    async loadDependency(dependency, version, reportState) {
+        if (this._dependecies.has(dependency))
+            return;
+        this._dependecies.set(dependency, true);
+        if (dependency.startsWith('@types')) {
+            console.warn('ignoring wrong dependency: ', dependency);
+            return;
+        }
+        if (reportState)
+            reportState(dependency + ": loading dependency: " + dependency);
+        const baseUrl = window.location.protocol + this._packageSource + dependency + '/';
+        const packageJsonUrl = baseUrl + 'package.json';
+        const packageJson = await fetch(packageJsonUrl);
+        const packageJsonObj = await packageJson.json();
+        const depPromises = [];
+        if (packageJsonObj.dependencies) {
+            for (let d in packageJsonObj.dependencies) {
+                depPromises.push(this.loadDependency(d, packageJsonObj.dependencies[d]));
+            }
+        }
+        await Promise.all(depPromises);
+        this.addToImportmap(baseUrl, packageJsonObj);
+    }
+    async addToImportmap(baseUrl, packageJsonObj) {
+        //todo - use exports of package.json for importMap
+        const importMap = { imports: {}, scopes: {} };
+        let mainImport = packageJsonObj.main;
+        if (packageJsonObj.module)
+            mainImport = packageJsonObj.module;
+        importMap.imports[packageJsonObj.name] = baseUrl + removeTrailing(mainImport, '/');
+        importMap.imports[packageJsonObj.name + '/'] = baseUrl;
+        //@ts-ignore
+        importShim.addImportMap(importMap);
+    }
+}

package/dist/elements/services/copyPasteService/CopyPasteService.js

@@ -1,32 +1,32 @@
 import { DomConverter } from "../../widgets/designerView/DomConverter.js";
+import { copyToClipboard, getFromClipboard, getTextFromClipboard } from "../../helper/ClipboardHelper.js";
 export const positionsJsonMime = 'web text/positions';
 export class CopyPasteService {
     async copyItems(designItems) {
         const copyText = DomConverter.ConvertToString(designItems, null, false);
-        try {
-            const positions = designItems.map(x => x.instanceServiceContainer.designerCanvas.getNormalizedElementCoordinates(x.element));
-            const data = [new ClipboardItem({ ["text/html"]: new Blob([copyText], { type: 'text/html' }), [positionsJsonMime]: new Blob([JSON.stringify(positions)], { type: positionsJsonMime }) })];
-            await navigator.clipboard.write(data);
-        }
-        catch (err) {
-            await navigator.clipboard.writeText(copyText);
-        }
+        const positions = designItems.map(x => x.instanceServiceContainer.designerCanvas.getNormalizedElementCoordinates(x.element));
+        copyToClipboard([["text/html", copyText], [positionsJsonMime, JSON.stringify(positions)]]);
     }
     async getPasteItems(serviceContainer, instanceServiceContainer) {
-        const items = await navigator.clipboard.read();
         let html = '';
-        try {
-            html = await (await items[0].getType('text/html'))?.text();
-        }
-        catch { }
-        if (!html)
-            html = await (await items[0].getType('text/plain'))?.text();
         let positions = null;
-        try {
-            let positionsJson = await (await items[0].getType(positionsJsonMime))?.text();
-            positions = JSON.parse(positionsJson);
+        const items = await getFromClipboard();
+        if (items != null) {
+            try {
+                html = await (await items[0].getType('text/html'))?.text();
+            }
+            catch { }
+            if (!html)
+                html = await (await items[0].getType('text/plain'))?.text();
+            try {
+                let positionsJson = await (await items[0].getType(positionsJsonMime))?.text();
+                positions = JSON.parse(positionsJson);
+            }
+            catch { }
+        }
+        else {
+            html = await getTextFromClipboard();
         }
-        catch { }
         const parserService = serviceContainer.htmlParserService;
         return [await parserService.parse(html, serviceContainer, instanceServiceContainer), positions];
     }

package/dist/elements/services/designerAddons/IDesignerAddonJson.d.ts

@@ -0,0 +1,6 @@
+export interface IDesignerAddonJson {
+    services: Record<string, string>;
+    components: Record<string, {
+        stylesheets: string[];
+    }>;
+}

package/dist/elements/services/manifestParsers/WebcomponentManifestParserService.js

@@ -52,7 +52,7 @@ export class WebcomponentManifestParserService extends AbstractPropertiesService
                             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] });
+                            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/services/propertiesService/services/WebcomponentManifestPropertiesService.js

@@ -34,7 +34,7 @@ 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] });
+                                    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/index.d.ts

@@ -7,10 +7,12 @@ export * from "./elements/helper/ElementHelper.js";
 export * from "./elements/helper/IndentedTextWriter.js";
 export * from "./elements/helper/PathDataPolyfill.js";
 export * from "./elements/helper/Screenshot.js";
+export * from "./elements/helper/ClipboardHelper.js";
 export * from "./elements/loader/OldCustomElementsManifestLoader.js";
 export * from "./elements/helper/w3color.js";
 export * from "./elements/helper/contextMenu/ContextMenu.js";
 export * from "./elements/helper/Helper.js";
+export * from "./elements/helper/NpmPackageLoader.js";
 export type { IContextMenuItem } from "./elements/helper/contextMenu/IContextMenuItem.js";
 export * from "./elements/item/DesignItem.js";
 export type { IDesignItem } from "./elements/item/IDesignItem.js";

package/dist/index.js

@@ -7,10 +7,12 @@ export * from "./elements/helper/ElementHelper.js";
 export * from "./elements/helper/IndentedTextWriter.js";
 export * from "./elements/helper/PathDataPolyfill.js";
 export * from "./elements/helper/Screenshot.js";
+export * from "./elements/helper/ClipboardHelper.js";
 export * from "./elements/loader/OldCustomElementsManifestLoader.js";
 export * from "./elements/helper/w3color.js";
 export * from "./elements/helper/contextMenu/ContextMenu.js";
 export * from "./elements/helper/Helper.js";
+export * from "./elements/helper/NpmPackageLoader.js";
 export * from "./elements/item/DesignItem.js";
 export * from "./elements/item/BindingMode.js";
 export * from "./elements/item/BindingTarget.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "description": "A UI designer for Polymer apps",
   "name": "@node-projects/web-component-designer",
-  "version": "0.0.184",
+  "version": "0.0.186",
   "type": "module",
   "main": "./dist/index.js",
   "author": "",
@@ -14,7 +14,6 @@
   },
   "dependencies": {
     "@node-projects/base-custom-webcomponent": "^0.10.9",
-    "@types/node": "^18.11.18",
     "construct-style-sheets-polyfill": "^3.1.0"
   },
   "devDependencies": {
@@ -23,19 +22,20 @@
     "@node-projects/node-html-parser-esm": "^2.5.1",
     "@papyrs/stylo": "^0.0.42",
     "@types/codemirror": "^5.60.7",
-    "@types/css-tree": "^2.0.1",
+    "@types/css-tree": "^2.3.0",
     "@types/jquery": "^3.5.16",
     "@types/jquery.fancytree": "0.0.7",
+    "@types/node": "^18.13.0",
     "ace-builds": "^1.15.0",
     "codemirror": "^6.0.1",
     "css-tree": "^2.3.1",
     "esprima-next": "^5.8.4",
     "html2canvas": "*",
-    "jest": "^29.4.1",
+    "jest": "^29.4.2",
     "jquery": "^3.6.3",
-    "jquery.fancytree": "^2.38.2",
-    "mdn-data": "^2.0.30",
-    "monaco-editor": "^0.34.1",
+    "jquery.fancytree": "^2.38.3",
+    "mdn-data": "^2.0.31",
+    "monaco-editor": "^0.35.0",
     "ts-jest": "^29.0.5",
     "typescript": "^4.9.5",
     "typescript-lit-html-plugin": "^0.9.0"

package/dist/elements/controls/ThicknessEditor copy.d.ts

@@ -1,33 +0,0 @@
-import { BaseCustomWebComponentConstructorAppend, TypedEvent } from '@node-projects/base-custom-webcomponent';
-export declare type ThicknessEditorValueChangedEventArgs = {
-    newValue?: string;
-    oldValue?: string;
-};
-export declare class ThicknessEditor extends BaseCustomWebComponentConstructorAppend {
-    static readonly style: CSSStyleSheet;
-    static readonly template: HTMLTemplateElement;
-    private _leftInput;
-    private _topInput;
-    private _rightInput;
-    private _bottomInput;
-    private _valueLeft;
-    get valueLeft(): string;
-    set valueLeft(value: string);
-    valueLeftChanged: TypedEvent<ThicknessEditorValueChangedEventArgs>;
-    private _valueTop;
-    get valueTop(): string;
-    set valueTop(value: string);
-    valueTopChanged: TypedEvent<ThicknessEditorValueChangedEventArgs>;
-    private _valueRight;
-    get valueRight(): string;
-    set valueRight(value: string);
-    valueRightChanged: TypedEvent<ThicknessEditorValueChangedEventArgs>;
-    private _valueBottom;
-    get valueBottom(): string;
-    set valueBottom(value: string);
-    valueBottomChanged: TypedEvent<ThicknessEditorValueChangedEventArgs>;
-    property: string;
-    unsetValue: string;
-    _updateValue(): void;
-    ready(): void;
-}

package/dist/elements/controls/ThicknessEditor copy.js

@@ -1,145 +0,0 @@
-import { BaseCustomWebComponentConstructorAppend, css, html, TypedEvent } from '@node-projects/base-custom-webcomponent';
-export class ThicknessEditor extends BaseCustomWebComponentConstructorAppend {
-    static style = css `
-  :host {
-    margin: 4px;
-    margin-left: auto;
-    margin-right: auto;
-  }
-  #container {
-    display: grid;
-    grid-template-columns: minmax(30px, 40px) minmax(30px, 60px) minmax(30px, 40px);
-    grid-template-rows: auto;
-    grid-template-areas: 
-          "  .   top     ."
-          "left middle right"
-          "  .  bottom   .";
-    column-gap: 2px;
-    row-gap: 2px;
-  }
-  input {
-    width: 20px;
-    text-align: center;
-    font-size: 10px;
-    height: 20px;
-    padding: 0;
-  }
-  #left {
-    grid-area: left;
-    justify-self: end;
-  }
-  #top {
-    grid-area: top;
-    align-self: end;
-    justify-self: center;
-  }
-  #right {
-    grid-area: right;
-    justify-self: start;
-  }
-  #bottom {
-    grid-area: bottom;
-    align-self: start;
-    justify-self: center;
-  }
-  #rect {
-    grid-area: middle;
-    border: 1px solid black;
-    background: lightgray;
-  }
-  `;
-    static template = html `
-    <div id="container">
-      <input id="left">
-      <input id="top">
-      <input id="right">
-      <input id="bottom">
-      <div id="rect"></div>
-    </div>
-  `;
-    _leftInput;
-    _topInput;
-    _rightInput;
-    _bottomInput;
-    _valueLeft;
-    get valueLeft() {
-        return this._valueLeft;
-    }
-    set valueLeft(value) {
-        const oldValue = this._valueLeft;
-        this._valueLeft = value;
-        if (oldValue !== value) {
-            this._updateValue();
-            this.valueLeftChanged.emit({ newValue: value, oldValue: oldValue });
-        }
-    }
-    valueLeftChanged = new TypedEvent();
-    _valueTop;
-    get valueTop() {
-        return this._valueTop;
-    }
-    set valueTop(value) {
-        const oldValue = this._valueTop;
-        this._valueTop = value;
-        if (oldValue !== value) {
-            this._updateValue();
-            this.valueTopChanged.emit({ newValue: value, oldValue: oldValue });
-        }
-    }
-    valueTopChanged = new TypedEvent();
-    _valueRight;
-    get valueRight() {
-        return this._valueRight;
-    }
-    set valueRight(value) {
-        const oldValue = this._valueRight;
-        this._valueRight = value;
-        if (oldValue !== value) {
-            this._updateValue();
-            this.valueRightChanged.emit({ newValue: value, oldValue: oldValue });
-        }
-    }
-    valueRightChanged = new TypedEvent();
-    _valueBottom;
-    get valueBottom() {
-        return this._valueBottom;
-    }
-    set valueBottom(value) {
-        const oldValue = this._valueBottom;
-        this._valueBottom = value;
-        if (oldValue !== value) {
-            this._updateValue();
-            this.valueBottomChanged.emit({ newValue: value, oldValue: oldValue });
-        }
-    }
-    valueBottomChanged = new TypedEvent();
-    property;
-    unsetValue;
-    _updateValue() {
-        this._leftInput.value = this.valueLeft;
-        this._topInput.value = this.valueTop;
-        this._rightInput.value = this.valueRight;
-        this._bottomInput.value = this._valueBottom;
-    }
-    ready() {
-        this._parseAttributesToProperties();
-        this._leftInput = this._getDomElement('left');
-        this._topInput = this._getDomElement('top');
-        this._rightInput = this._getDomElement('right');
-        this._bottomInput = this._getDomElement('bottom');
-        this._leftInput.onkeyup = (e) => { if (e.key === 'Enter')
-            this._valueLeft = this._leftInput.value; };
-        this._topInput.onkeyup = (e) => { if (e.key === 'Enter')
-            this._valueTop = this._topInput.value; };
-        this._rightInput.onkeyup = (e) => { if (e.key === 'Enter')
-            this._valueRight = this._rightInput.value; };
-        this._bottomInput.onkeyup = (e) => { if (e.key === 'Enter')
-            this._valueBottom = this._bottomInput.value; };
-        this._leftInput.onblur = (e) => this._valueLeft = this._leftInput.value;
-        this._topInput.onblur = (e) => this._valueTop = this._topInput.value;
-        this._rightInput.onblur = (e) => this._valueRight = this._rightInput.value;
-        this._bottomInput.onblur = (e) => this._valueBottom = this._bottomInput.value;
-        this._updateValue();
-    }
-}
-customElements.define('node-projects-thickness-editor', ThicknessEditor);

package/dist/elements/helper/IndentedTextWriter copy.d.ts

@@ -1,14 +0,0 @@
-export declare class IndentedTextWriter {
-    private _textHolder;
-    readonly indent: number;
-    level: number;
-    get position(): number;
-    isLastCharNewline(): boolean;
-    levelRaise(): void;
-    levelShrink(): void;
-    write(text: string): void;
-    writeLine(text: string): void;
-    writeIndent(): void;
-    writeNewline(): void;
-    getString(): string;
-}