@node-projects/web-component-designer 0.0.73 → 0.0.77

package/README.md

@@ -1,6 +1,6 @@
 # web-component-designer
 
-## Caution - this is a preview Version, a RC is planed for Q3/2021
+## Caution - this is a preview Version, a RC is planed for January 2022
 
 A HTML WebComponent for Designing Webcomponents and HTML Pages.
 
@@ -81,4 +81,4 @@ Your addition to your index.html should look like this:
 The Library uses Images from the Chrome Dev Tools, see
 https://github.com/ChromeDevTools/devtools-frontend/tree/main/front_end/Images/src
 and
-https://github.com/ChromeDevTools/devtools-frontend/blob/main/LICENSE
+https://github.com/ChromeDevTools/devtools-frontend/blob/main/LICENSE

package/dist/elements/documentContainer.d.ts

@@ -13,6 +13,9 @@ export declare class DocumentContainer extends BaseCustomWebComponentLazyAppend
     codeView: ICodeView & HTMLElement;
     demoView: IDemoView & HTMLElement;
     additionalData: any;
+    private _additionalStyle;
+    set additionalStyleString(style: string);
+    get additionalStyleString(): string;
     private _serviceContainer;
     private _content;
     private _tabControl;

package/dist/elements/documentContainer.js

@@ -1,4 +1,4 @@
-import { BaseCustomWebComponentLazyAppend, css, debounce } from "@node-projects/base-custom-webcomponent";
+import { BaseCustomWebComponentLazyAppend, css, cssFromString, debounce } from "@node-projects/base-custom-webcomponent";
 import { DesignerTabControl } from "./controls/DesignerTabControl";
 import { DesignerView } from "./widgets/designerView/designerView";
 import { SimpleSplitView } from './controls/SimpleSplitView';
@@ -7,6 +7,16 @@ export class DocumentContainer extends BaseCustomWebComponentLazyAppend {
     codeView;
     demoView;
     additionalData;
+    _additionalStyle;
+    set additionalStyleString(style) {
+        this._additionalStyle = style;
+        this.designerView.additionalStyle = cssFromString(style);
+    }
+    ;
+    get additionalStyleString() {
+        return this._additionalStyle;
+    }
+    ;
     _serviceContainer;
     _content = '';
     _tabControl;

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

@@ -1,2 +1,3 @@
 export declare function newElementFromString(text: any): Element;
 export declare function isInline(element: HTMLElement): boolean;
+export declare function isEmptyTextNode(node: Node): boolean;

package/dist/elements/helper/ElementHelper.js

@@ -7,3 +7,6 @@ export function newElementFromString(text) {
 export function isInline(element) {
     return element != null && window.getComputedStyle(element).display.startsWith('inline');
 }
+export function isEmptyTextNode(node) {
+    return node.textContent.trim() == '' && node.textContent.indexOf('\xa0' /* &nbsp; */) < 0;
+}

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

@@ -3,6 +3,7 @@ export declare class IndentedTextWriter {
     readonly indent: number;
     level: number;
     get position(): number;
+    isLastCharNewline(): boolean;
     levelRaise(): void;
     levelShrink(): void;
     write(text: string): void;

package/dist/elements/helper/IndentedTextWriter.js

@@ -5,6 +5,9 @@ export class IndentedTextWriter {
     get position() {
         return this._textHolder.length;
     }
+    isLastCharNewline() {
+        return this._textHolder[this._textHolder.length - 1] === '\n';
+    }
     levelRaise() {
         this.level++;
     }

package/dist/elements/services/BaseServiceContainer.d.ts

@@ -4,6 +4,7 @@ export declare class BaseServiceContainer<NameMap> {
     getLastService<K extends keyof NameMap>(service: K): NameMap[K];
     getServices<K extends keyof NameMap>(service: K): NameMap[K][];
     register<K extends keyof NameMap>(name: K, service: NameMap[K]): void;
+    registerMultiple<K extends keyof NameMap>(names: K[], service: NameMap[K]): void;
     forSomeServicesTillResult<K extends keyof NameMap, Y>(service: K, callback: (service: NameMap[K]) => Y): Y;
     getLastServiceWhere<K extends keyof NameMap, Y>(service: K, callback: (service: NameMap[K]) => Y): NameMap[K];
 }

package/dist/elements/services/BaseServiceContainer.js

@@ -14,6 +14,13 @@ export class BaseServiceContainer {
             this._services.set(name, []);
         this._services.get(name).push(service);
     }
+    registerMultiple(names, service) {
+        for (const name of names) {
+            if (!this._services.has(name))
+                this._services.set(name, []);
+            this._services.get(name).push(service);
+        }
+    }
     forSomeServicesTillResult(service, callback) {
         let services = this.getServices(service);
         if (services == null) {

package/dist/elements/services/demoProviderService/DemoProviderService.js

@@ -21,7 +21,7 @@ export class DemoProviderService {
             }
             doc.write("document.body.style.display='';");
             doc.write('</script>');
-            doc.write('<body style="display:none">' + code + '</body>');
+            doc.write('<body style="display:none; width: 100%; height: 100%; margin: 0; padding: 0; position: absolute;">' + code + '</body>');
             doc.close();
         });
     }

package/dist/elements/services/elementsService/IElementDefinition.d.ts

@@ -1,3 +1,4 @@
+import { IBinding } from "../../item/IBinding";
 export interface IElementDefinition {
     tag: string;
     name?: string;
@@ -28,4 +29,5 @@ export interface IElementDefinition {
      * If none, the DrawElementTool is used
      */
     tool?: string;
+    defaultBinding?: IBinding;
 }

package/dist/elements/services/elementsService/IElementsJson.d.ts

@@ -1,4 +1,5 @@
 import { IElementDefinition } from './IElementDefinition';
 export interface IElementsJson {
+    "imports"?: string[];
     "elements": (string | IElementDefinition)[];
 }

package/dist/elements/services/htmlWriterService/HtmlWriterService copy.d.ts

@@ -0,0 +1,12 @@
+import { IDesignItem } from '../../item/IDesignItem';
+import { IHtmlWriterService } from './IHtmlWriterService';
+import { IHtmlWriterOptions } from './IHtmlWriterOptions';
+import { IndentedTextWriter } from '../../helper/IndentedTextWriter';
+import { IStringPosition } from './IStringPosition';
+export declare class HtmlWriterService implements IHtmlWriterService {
+    canWrite(designItem: IDesignItem): boolean;
+    private _conditionalyWriteIndent;
+    private _conditionalyWriteNewline;
+    write(indentedTextWriter: IndentedTextWriter, designItem: IDesignItem, options: IHtmlWriterOptions, designItemsAssignmentList?: Map<IDesignItem, IStringPosition>): void;
+    private writeTextNode;
+}

package/dist/elements/services/htmlWriterService/HtmlWriterService copy.js

@@ -0,0 +1,103 @@
+import { DomConverter } from '../../widgets/designerView/DomConverter';
+import { CssCombiner } from '../../helper/CssCombiner';
+import { NodeType } from '../../item/NodeType';
+import { PropertiesHelper } from '../propertiesService/services/PropertiesHelper';
+import { isInline } from '../../helper/ElementHelper.js';
+export class HtmlWriterService {
+    canWrite(designItem) {
+        return true;
+    }
+    _conditionalyWriteIndent(indentedTextWriter, designItem) {
+        if ((designItem.element instanceof HTMLElement && !isInline(designItem.element)) ||
+            (designItem.element.previousElementSibling instanceof HTMLElement && !isInline(designItem.element.previousElementSibling)))
+            indentedTextWriter.writeIndent();
+    }
+    _conditionalyWriteNewline(indentedTextWriter, designItem) {
+        if ((designItem.element instanceof HTMLElement && !isInline(designItem.element)) ||
+            (designItem.element.nextElementSibling instanceof HTMLElement && !isInline(designItem.element.nextElementSibling)))
+            indentedTextWriter.writeNewline();
+    }
+    write(indentedTextWriter, designItem, options, designItemsAssignmentList) {
+        let start = indentedTextWriter.position;
+        if (designItem.nodeType == NodeType.TextNode) {
+            this.writeTextNode(indentedTextWriter, designItem, true);
+        }
+        else if (designItem.nodeType == NodeType.Comment) {
+            this._conditionalyWriteIndent(indentedTextWriter, designItem);
+            indentedTextWriter.write('<!--' + designItem.content + '-->');
+            this._conditionalyWriteNewline(indentedTextWriter, designItem);
+        }
+        else {
+            this._conditionalyWriteIndent(indentedTextWriter, designItem);
+            indentedTextWriter.write('<' + designItem.name);
+            if (designItem.hasAttributes) {
+                for (const a of designItem.attributes) {
+                    indentedTextWriter.write(' ');
+                    if (typeof a[1] === 'string') {
+                        if (a[1] === "")
+                            indentedTextWriter.write(a[0]);
+                        else
+                            indentedTextWriter.write(a[0] + '="' + DomConverter.normalizeAttributeValue(a[1]) + '"');
+                    }
+                    else if (!a[1])
+                        indentedTextWriter.write(a[0]);
+                    else {
+                        //TODO: writing of bindings
+                    }
+                }
+            }
+            if (designItem.hasStyles) {
+                indentedTextWriter.write(' style="');
+                let styles = designItem.styles;
+                if (options.compressCssToShorthandProperties)
+                    styles = CssCombiner.combine(styles);
+                for (const s of styles) {
+                    if (s[0]) {
+                        indentedTextWriter.write(PropertiesHelper.camelToDashCase(s[0]) + ':' + DomConverter.normalizeAttributeValue(s[1]) + ';');
+                    }
+                }
+                indentedTextWriter.write('"');
+            }
+            indentedTextWriter.write('>');
+            if (designItem.hasChildren) {
+                const children = designItem.children();
+                const singleTextNode = designItem.childCount === 1 && designItem.firstChild.nodeType === NodeType.TextNode;
+                if (singleTextNode) {
+                    this.writeTextNode(indentedTextWriter, designItem, false);
+                }
+                else {
+                    indentedTextWriter.writeNewline();
+                    indentedTextWriter.levelRaise();
+                    for (const c of children) {
+                        c.serviceContainer.forSomeServicesTillResult('htmlWriterService', (s) => {
+                            if (s.canWrite(c)) {
+                                s.write(indentedTextWriter, c, options, designItemsAssignmentList);
+                            }
+                        });
+                    }
+                    indentedTextWriter.levelShrink();
+                    indentedTextWriter.writeIndent();
+                }
+            }
+            else if (designItem.hasContent) {
+                indentedTextWriter.write(DomConverter.normalizeContentValue(designItem.content));
+            }
+            if (!DomConverter.IsSelfClosingElement(designItem.name))
+                indentedTextWriter.write('</' + designItem.name + '>');
+            this._conditionalyWriteNewline(indentedTextWriter, designItem);
+        }
+        if (designItemsAssignmentList) {
+            designItemsAssignmentList.set(designItem, { start: start, length: indentedTextWriter.position - start - 1 });
+        }
+    }
+    writeTextNode(indentedTextWriter, designItem, indentAndNewline) {
+        let content = DomConverter.normalizeContentValue(designItem.content).trim();
+        if (content) {
+            if (indentAndNewline)
+                this._conditionalyWriteIndent(indentedTextWriter, designItem);
+            indentedTextWriter.write(content);
+            if (indentAndNewline)
+                this._conditionalyWriteNewline(indentedTextWriter, designItem);
+        }
+    }
+}

package/dist/elements/services/htmlWriterService/HtmlWriterService.js

@@ -2,14 +2,15 @@ import { DomConverter } from '../../widgets/designerView/DomConverter';
 import { CssCombiner } from '../../helper/CssCombiner';
 import { NodeType } from '../../item/NodeType';
 import { PropertiesHelper } from '../propertiesService/services/PropertiesHelper';
-import { isInline } from '../../helper/ElementHelper.js';
+import { isEmptyTextNode, isInline } from '../../helper/ElementHelper.js';
 export class HtmlWriterService {
     canWrite(designItem) {
         return true;
     }
     _conditionalyWriteIndent(indentedTextWriter, designItem) {
         if ((designItem.element instanceof HTMLElement && !isInline(designItem.element)) ||
-            (designItem.element.previousElementSibling instanceof HTMLElement && !isInline(designItem.element.previousElementSibling)))
+            (designItem.element.previousElementSibling instanceof HTMLElement && !isInline(designItem.element.previousElementSibling)) ||
+            (designItem.element.previousElementSibling == null && !isInline(designItem.element.parentElement) && (designItem.element.previousSibling == null || isEmptyTextNode(designItem.element.previousSibling))))
             indentedTextWriter.writeIndent();
     }
     _conditionalyWriteNewline(indentedTextWriter, designItem) {
@@ -20,7 +21,12 @@ export class HtmlWriterService {
     write(indentedTextWriter, designItem, options, designItemsAssignmentList) {
         let start = indentedTextWriter.position;
         if (designItem.nodeType == NodeType.TextNode) {
-            this.writeTextNode(indentedTextWriter, designItem, true);
+            if (isEmptyTextNode(designItem.element) &&
+                ((designItem.element.previousSibling instanceof HTMLElement && !isInline(designItem.element.previousSibling)) ||
+                    (designItem.element.nextSibling instanceof HTMLElement && !isInline(designItem.element.nextSibling)))) {
+            }
+            else
+                this.writeTextNode(indentedTextWriter, designItem, true);
         }
         else if (designItem.nodeType == NodeType.Comment) {
             this._conditionalyWriteIndent(indentedTextWriter, designItem);
@@ -59,24 +65,34 @@ export class HtmlWriterService {
                 indentedTextWriter.write('"');
             }
             indentedTextWriter.write('>');
+            let contentSingleTextNode = false;
             if (designItem.hasChildren) {
                 const children = designItem.children();
-                const singleTextNode = designItem.childCount === 1 && designItem.firstChild.nodeType === NodeType.TextNode;
-                if (singleTextNode) {
+                contentSingleTextNode = designItem.childCount === 1 && designItem.firstChild.nodeType === NodeType.TextNode;
+                if (contentSingleTextNode) {
                     this.writeTextNode(indentedTextWriter, designItem, false);
                 }
                 else {
-                    indentedTextWriter.writeNewline();
-                    indentedTextWriter.levelRaise();
+                    if (designItem.element instanceof HTMLElement && !isInline(designItem.element)) {
+                        indentedTextWriter.writeNewline();
+                        indentedTextWriter.levelRaise();
+                    }
                     for (const c of children) {
                         c.serviceContainer.forSomeServicesTillResult('htmlWriterService', (s) => {
                             if (s.canWrite(c)) {
                                 s.write(indentedTextWriter, c, options, designItemsAssignmentList);
                             }
                         });
+                        let childSingleTextNode = c.childCount === 1 && c.firstChild.nodeType === NodeType.TextNode;
+                        if (childSingleTextNode)
+                            indentedTextWriter.writeNewline();
+                    }
+                    if (designItem.element instanceof HTMLElement && !isInline(designItem.element)) {
+                        indentedTextWriter.levelShrink();
+                        if (!indentedTextWriter.isLastCharNewline())
+                            indentedTextWriter.writeNewline();
+                        indentedTextWriter.writeIndent();
                     }
-                    indentedTextWriter.levelShrink();
-                    indentedTextWriter.writeIndent();
                 }
             }
             else if (designItem.hasContent) {
@@ -84,7 +100,8 @@ export class HtmlWriterService {
             }
             if (!DomConverter.IsSelfClosingElement(designItem.name))
                 indentedTextWriter.write('</' + designItem.name + '>');
-            this._conditionalyWriteNewline(indentedTextWriter, designItem);
+            if (!contentSingleTextNode)
+                this._conditionalyWriteNewline(indentedTextWriter, designItem);
         }
         if (designItemsAssignmentList) {
             designItemsAssignmentList.set(designItem, { start: start, length: indentedTextWriter.position - start - 1 });

package/dist/elements/services/htmlWriterService/LitElementWriterService.d.ts

@@ -0,0 +1,12 @@
+import { IDesignItem } from '../../item/IDesignItem';
+import { IHtmlWriterService } from './IHtmlWriterService';
+import { IHtmlWriterOptions } from './IHtmlWriterOptions';
+import { IndentedTextWriter } from '../../helper/IndentedTextWriter';
+import { IStringPosition } from './IStringPosition';
+export declare class HtmlWriterService implements IHtmlWriterService {
+    canWrite(designItem: IDesignItem): boolean;
+    private _conditionalyWriteIndent;
+    private _conditionalyWriteNewline;
+    write(indentedTextWriter: IndentedTextWriter, designItem: IDesignItem, options: IHtmlWriterOptions, designItemsAssignmentList?: Map<IDesignItem, IStringPosition>): void;
+    private writeTextNode;
+}

package/dist/elements/services/htmlWriterService/LitElementWriterService.js

@@ -0,0 +1,107 @@
+import { DomConverter } from '../../widgets/designerView/DomConverter';
+import { CssCombiner } from '../../helper/CssCombiner';
+import { NodeType } from '../../item/NodeType';
+import { PropertiesHelper } from '../propertiesService/services/PropertiesHelper';
+import { isInline } from '../../helper/ElementHelper.js';
+//todo :
+//write style...
+//needs InternalBindinsgStorrageService -> keeps bindings
+export class HtmlWriterService {
+    canWrite(designItem) {
+        return true;
+    }
+    _conditionalyWriteIndent(indentedTextWriter, designItem) {
+        if ((designItem.element instanceof HTMLElement && !isInline(designItem.element)) ||
+            (designItem.element.previousElementSibling instanceof HTMLElement && !isInline(designItem.element.previousElementSibling)))
+            indentedTextWriter.writeIndent();
+    }
+    _conditionalyWriteNewline(indentedTextWriter, designItem) {
+        if ((designItem.element instanceof HTMLElement && !isInline(designItem.element)) ||
+            (designItem.element.nextElementSibling instanceof HTMLElement && !isInline(designItem.element.nextElementSibling)))
+            indentedTextWriter.writeNewline();
+    }
+    write(indentedTextWriter, designItem, options, designItemsAssignmentList) {
+        let start = indentedTextWriter.position;
+        if (designItem.nodeType == NodeType.TextNode) {
+            this._conditionalyWriteIndent(indentedTextWriter, designItem);
+            this.writeTextNode(indentedTextWriter, designItem, true);
+        }
+        else if (designItem.nodeType == NodeType.Comment) {
+            this._conditionalyWriteIndent(indentedTextWriter, designItem);
+            indentedTextWriter.write('<!--' + designItem.content + '-->');
+            this._conditionalyWriteNewline(indentedTextWriter, designItem);
+        }
+        else {
+            this._conditionalyWriteIndent(indentedTextWriter, designItem);
+            indentedTextWriter.write('<' + designItem.name);
+            if (designItem.hasAttributes) {
+                for (const a of designItem.attributes) {
+                    indentedTextWriter.write(' ');
+                    if (typeof a[1] === 'string') {
+                        if (a[1] === "")
+                            indentedTextWriter.write(a[0]);
+                        else
+                            indentedTextWriter.write(a[0] + '="' + DomConverter.normalizeAttributeValue(a[1]) + '"');
+                    }
+                    else if (!a[1])
+                        indentedTextWriter.write(a[0]);
+                    else {
+                        //TODO: writing of bindings
+                    }
+                }
+            }
+            if (designItem.hasStyles) {
+                indentedTextWriter.write(' style="');
+                let styles = designItem.styles;
+                if (options.compressCssToShorthandProperties)
+                    styles = CssCombiner.combine(styles);
+                for (const s of styles) {
+                    if (s[0]) {
+                        indentedTextWriter.write(PropertiesHelper.camelToDashCase(s[0]) + ':' + DomConverter.normalizeAttributeValue(s[1]) + ';');
+                    }
+                }
+                indentedTextWriter.write('"');
+            }
+            indentedTextWriter.write('>');
+            if (designItem.hasChildren) {
+                const children = designItem.children();
+                const singleTextNode = designItem.childCount === 1 && designItem.firstChild.nodeType === NodeType.TextNode;
+                if (singleTextNode) {
+                    this.writeTextNode(indentedTextWriter, designItem, false);
+                }
+                else {
+                    indentedTextWriter.writeNewline();
+                    indentedTextWriter.levelRaise();
+                    for (const c of children) {
+                        c.serviceContainer.forSomeServicesTillResult('htmlWriterService', (s) => {
+                            if (s.canWrite(c)) {
+                                s.write(indentedTextWriter, c, options, designItemsAssignmentList);
+                            }
+                        });
+                    }
+                    indentedTextWriter.levelShrink();
+                    indentedTextWriter.writeIndent();
+                }
+            }
+            else if (designItem.hasContent) {
+                indentedTextWriter.write(DomConverter.normalizeContentValue(designItem.content));
+            }
+            if (!DomConverter.IsSelfClosingElement(designItem.name))
+                indentedTextWriter.write('</' + designItem.name + '>');
+            this._conditionalyWriteNewline(indentedTextWriter, designItem);
+        }
+        if (designItemsAssignmentList) {
+            designItemsAssignmentList.set(designItem, { start: start, length: indentedTextWriter.position - start - 1 });
+        }
+    }
+    writeTextNode(indentedTextWriter, designItem, indentAndNewline) {
+        let content = DomConverter.normalizeContentValue(designItem.content).trim();
+        if (content) {
+            if (indentAndNewline)
+                this._conditionalyWriteIndent(indentedTextWriter, designItem);
+            indentedTextWriter.write(content);
+            if (indentAndNewline)
+                this._conditionalyWriteNewline(indentedTextWriter, designItem);
+        }
+    }
+}

package/dist/elements/services/instanceService/DefaultInstanceService.js

@@ -53,7 +53,7 @@ export class DefaultInstanceService {
         if (definition.defaultProperties) {
             let propertiesService = null;
             if (definition.type) {
-                propertiesService = serviceContainer.getLastServiceWhere('propertyService', (x) => x.name == definition.type);
+                propertiesService = serviceContainer.getLastServiceWhere('propertyService', (x) => x.isHandledElement(designItem));
             }
             let properties = propertiesService.getProperties(designItem);
             for (let a in definition.defaultProperties) {

package/dist/elements/services/manifestLoaders/WebcomponentManifestParserService.d.ts

@@ -0,0 +1,26 @@
+import { IDesignItem } from "../../..";
+import { BindingTarget } from "../../item/BindingTarget";
+import { IElementDefinition } from "../elementsService/IElementDefinition";
+import { IElementsService } from "../elementsService/IElementsService";
+import { IPropertiesService } from "../propertiesService/IPropertiesService";
+import { IProperty } from "../propertiesService/IProperty";
+import { ValueType } from "../propertiesService/ValueType";
+export declare class WebcomponentManifestParserService implements IElementsService, IPropertiesService {
+    private _name;
+    get name(): string;
+    private _packageData;
+    private _elementList;
+    private _resolveStored;
+    private _rejectStored;
+    constructor(name: string, file: string);
+    getElements(): Promise<IElementDefinition[]>;
+    isHandledElement(designItem: IDesignItem): boolean;
+    getProperties(designItem: IDesignItem): IProperty[];
+    getProperty(designItem: IDesignItem, name: string): IProperty;
+    getPropertyTarget(designItem: IDesignItem, property: IProperty): BindingTarget;
+    setValue(designItems: IDesignItem[], property: IProperty, value: any): void;
+    clearValue(designItems: IDesignItem[], property: IProperty): void;
+    isSet(designItems: IDesignItem[], property: IProperty): ValueType;
+    getValue(designItems: IDesignItem[], property: IProperty): void;
+    getUnsetValue(designItems: IDesignItem[], property: IProperty): void;
+}

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

@@ -0,0 +1,69 @@
+export class WebcomponentManifestParserService {
+    _name;
+    get name() { return this._name; }
+    _packageData;
+    _elementList;
+    _resolveStored;
+    _rejectStored;
+    constructor(name, file) {
+        this._name = name;
+        import(file, { assert: { type: 'json' } }).then(module => {
+            this._packageData = module.default;
+            this._elementList = [];
+            for (let m of this._packageData.modules) {
+                for (let e of m.exports) {
+                    if (e.kind == 'custom-element-definition') {
+                        this._elementList.push({ tag: e.name });
+                    }
+                }
+                if (this._resolveStored) {
+                    this._resolveStored.forEach(x => x(this._elementList));
+                    this._resolveStored = null;
+                    this._rejectStored = null;
+                }
+            }
+        }).catch(err => {
+            if (this._rejectStored) {
+                this._rejectStored.forEach(x => x(err));
+                this._resolveStored = null;
+                this._rejectStored = null;
+            }
+        });
+    }
+    async getElements() {
+        if (this._packageData)
+            return Promise.resolve(this._elementList);
+        if (!this._resolveStored) {
+            this._resolveStored = [];
+            this._rejectStored = [];
+        }
+        return new Promise((resolve, reject) => { this._resolveStored.push(resolve); this._rejectStored.push(reject); });
+    }
+    isHandledElement(designItem) {
+        throw new Error("Method not implemented.");
+    }
+    getProperties(designItem) {
+        throw new Error("Method not implemented.");
+    }
+    getProperty(designItem, name) {
+        throw new Error("Method not implemented.");
+    }
+    getPropertyTarget(designItem, property) {
+        throw new Error("Method not implemented.");
+    }
+    setValue(designItems, property, value) {
+        throw new Error("Method not implemented.");
+    }
+    clearValue(designItems, property) {
+        throw new Error("Method not implemented.");
+    }
+    isSet(designItems, property) {
+        throw new Error("Method not implemented.");
+    }
+    getValue(designItems, property) {
+        throw new Error("Method not implemented.");
+    }
+    getUnsetValue(designItems, property) {
+        throw new Error("Method not implemented.");
+    }
+}

package/dist/elements/services/manifestParsers/WebcomponentManifestParserService.d.ts

@@ -0,0 +1,23 @@
+import { BindingTarget } from "../../item/BindingTarget";
+import { IElementDefinition } from "../elementsService/IElementDefinition";
+import { IElementsService } from "../elementsService/IElementsService";
+import { IPropertiesService } from "../propertiesService/IPropertiesService";
+import { IProperty } from "../propertiesService/IProperty";
+import { IDesignItem } from "../../item/IDesignItem";
+import { UnkownElementPropertiesService } from "../propertiesService/services/UnkownElementPropertiesService";
+export declare class WebcomponentManifestParserService extends UnkownElementPropertiesService implements IElementsService, IPropertiesService {
+    private _name;
+    get name(): string;
+    private _packageData;
+    private _elementList;
+    private _propertiesList;
+    private _resolveStored;
+    private _rejectStored;
+    constructor(name: string, file: string);
+    private manifestClassPropertyTypeToEditorPropertyType;
+    getElements(): Promise<IElementDefinition[]>;
+    isHandledElement(designItem: IDesignItem): boolean;
+    getProperties(designItem: IDesignItem): IProperty[];
+    getProperty(designItem: IDesignItem, name: string): IProperty;
+    getPropertyTarget(designItem: IDesignItem, property: IProperty): BindingTarget;
+}