@node-projects/web-component-designer 0.0.76 → 0.0.80

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

@@ -0,0 +1,93 @@
+import { DomConverter } from '../../widgets/designerView/DomConverter';
+import { CssCombiner } from '../../helper/CssCombiner';
+import { NodeType } from '../../item/NodeType';
+import { PropertiesHelper } from '../propertiesService/services/PropertiesHelper';
+import { ElementDisplayType, getElementDisplaytype } from '../../helper/ElementHelper.js';
+export var ElementContainerType;
+(function (ElementContainerType) {
+    ElementContainerType[ElementContainerType["block"] = 0] = "block";
+    ElementContainerType[ElementContainerType["complex"] = 1] = "complex";
+})(ElementContainerType || (ElementContainerType = {}));
+export class SimpleHtmlWriterService {
+    writeAttributes(writeContext, designItem) {
+        if (designItem.hasAttributes) {
+            for (const a of designItem.attributes) {
+                writeContext.indentedTextWriter.write(' ');
+                if (typeof a[1] === 'string') {
+                    if (a[1] === "")
+                        writeContext.indentedTextWriter.write(a[0]);
+                    else
+                        writeContext.indentedTextWriter.write(a[0] + '="' + DomConverter.normalizeAttributeValue(a[1]) + '"');
+                }
+                else if (!a[1])
+                    writeContext.indentedTextWriter.write(a[0]);
+                else {
+                }
+            }
+        }
+    }
+    writeStyles(writeContext, designItem) {
+        if (designItem.hasStyles) {
+            writeContext.indentedTextWriter.write(' style="');
+            let styles = designItem.styles;
+            if (writeContext.options.compressCssToShorthandProperties)
+                styles = CssCombiner.combine(styles);
+            for (const s of styles) {
+                if (s[0]) {
+                    writeContext.indentedTextWriter.write(PropertiesHelper.camelToDashCase(s[0]) + ':' + DomConverter.normalizeAttributeValue(s[1]) + ';');
+                }
+            }
+            writeContext.indentedTextWriter.write('"');
+        }
+    }
+    _writeTextNode(writeContext, designItem) {
+        writeContext.lastElementDisplayType = ElementDisplayType.inline;
+        let content = DomConverter.normalizeContentValue(designItem.content);
+        writeContext.indentedTextWriter.write(content);
+    }
+    _writeCommentNode(writeContext, designItem) {
+        writeContext.indentedTextWriter.write('<!--' + designItem.content + '-->');
+    }
+    _writeElementNode(writeContext, designItem) {
+        const currentElementDisplayType = getElementDisplaytype(designItem.element);
+        writeContext.lastElementDisplayType = currentElementDisplayType;
+        writeContext.indentedTextWriter.write('<' + designItem.name);
+        this.writeAttributes(writeContext, designItem);
+        this.writeStyles(writeContext, designItem);
+        writeContext.indentedTextWriter.write('>');
+        if (designItem.hasChildren) {
+            const children = designItem.children();
+            this._writeDesignItemList(currentElementDisplayType, writeContext, children);
+        }
+        else if (designItem.hasContent) {
+            writeContext.indentedTextWriter.write(DomConverter.normalizeContentValue(designItem.content));
+        }
+        if (!DomConverter.IsSelfClosingElement(designItem.name)) {
+            writeContext.indentedTextWriter.write('</' + designItem.name + '>');
+            if (currentElementDisplayType !== ElementDisplayType.none) {
+                writeContext.lastElementDisplayType = currentElementDisplayType;
+            }
+        }
+    }
+    _writeDesignItemList(currentElementDisplayType, writeContext, children) {
+        for (const c of children) {
+            this._writeInternal(writeContext, c);
+        }
+    }
+    _writeInternal(writeContext, designItem) {
+        const start = writeContext.indentedTextWriter.position;
+        if (designItem.nodeType === NodeType.TextNode)
+            this._writeTextNode(writeContext, designItem);
+        else if (designItem.nodeType === NodeType.Comment)
+            this._writeCommentNode(writeContext, designItem);
+        else if (designItem.nodeType === NodeType.Element)
+            this._writeElementNode(writeContext, designItem);
+        if (writeContext.designItemsAssignmentList) {
+            writeContext.designItemsAssignmentList.set(designItem, { start: start, length: writeContext.indentedTextWriter.position - start - 1 });
+        }
+    }
+    write(indentedTextWriter, designItems, rootContainerKeepInline, options, designItemsAssignmentList) {
+        const context = { indentedTextWriter, options, lastElementDisplayType: null, containerDisplayType: ElementContainerType.block, designItemsAssignmentList };
+        this._writeDesignItemList(ElementDisplayType.inline, context, designItems);
+    }
+}

package/dist/elements/services/initializationService/DefaultIntializationService.d.ts

@@ -0,0 +1,6 @@
+import { IDesignItem } from '../../item/IDesignItem';
+import { IIntializationService } from './IIntializationService';
+export declare class DefaultIntializationService implements IIntializationService {
+    init(designItem: IDesignItem): void;
+    initializeIframe(iframe: HTMLIFrameElement): void;
+}

package/dist/elements/services/initializationService/DefaultIntializationService.js

@@ -0,0 +1,22 @@
+export class DefaultIntializationService {
+    init(designItem) {
+        if (designItem.name == 'iframe') {
+            this.initializeIframe(designItem.element);
+        }
+    }
+    initializeIframe(iframe) {
+        iframe.contentDocument.body.style.pointerEvents = 'none';
+        function cloneIframeEvent(event) {
+            var clRect = iframe.getBoundingClientRect();
+            let data = { ...event };
+            data.clientX = event.clientX + clRect.left;
+            data.clientY = event.clientY + clRect.top;
+            var evt = new PointerEvent(event.type, data); //new CustomEvent('pointerdown', {bubbles: true, cancelable: false});
+            iframe.dispatchEvent(evt);
+        }
+        iframe.contentWindow.addEventListener('pointerdown', cloneIframeEvent);
+        iframe.contentWindow.addEventListener('pointermove', cloneIframeEvent);
+        iframe.contentWindow.addEventListener('pointerup', cloneIframeEvent);
+    }
+    ;
+}

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

@@ -13,7 +13,9 @@ export declare class WebcomponentManifestParserService extends UnkownElementProp
     private _propertiesList;
     private _resolveStored;
     private _rejectStored;
-    constructor(name: string, file: string);
+    private _importPrefix;
+    constructor(name: string, fileOrObject: string | object, importPrefix?: string);
+    private _parseManifest;
     private manifestClassPropertyTypeToEditorPropertyType;
     getElements(): Promise<IElementDefinition[]>;
     isHandledElement(designItem: IDesignItem): boolean;

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

@@ -9,43 +9,55 @@ export class WebcomponentManifestParserService extends UnkownElementPropertiesSe
     _propertiesList;
     _resolveStored;
     _rejectStored;
-    constructor(name, file) {
+    _importPrefix = '';
+    constructor(name, fileOrObject, importPrefix = '') {
         super();
         this._name = name;
-        let path = file.split('/').slice(0, -1).join('/');
-        import(file, { assert: { type: 'json' } }).then(module => {
-            this._packageData = module.default;
-            this._elementList = [];
-            this._propertiesList = {};
-            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, import: path + '/' + e.declaration.module });
-                        let properties = [];
-                        let declaration = m.declarations.find(x => x.name == e.declaration.name);
-                        for (let d of declaration.members) {
-                            if (d.kind == 'field') {
-                                let pType = PropertyType.property;
+        this._importPrefix = importPrefix;
+        if (typeof fileOrObject === 'string') {
+            this._importPrefix = this._importPrefix ?? fileOrObject.split('/').slice(0, -1).join('/');
+            import(fileOrObject, { assert: { type: 'json' } }).then(module => {
+                this._packageData = module.default;
+                this._parseManifest();
+            }).catch(err => {
+                if (this._rejectStored) {
+                    this._rejectStored.forEach(x => x(err));
+                    this._resolveStored = null;
+                    this._rejectStored = null;
+                }
+            });
+        }
+        else {
+            this._packageData = fileOrObject;
+            this._parseManifest();
+        }
+    }
+    _parseManifest() {
+        this._elementList = [];
+        this._propertiesList = {};
+        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, import: this._importPrefix + '/' + e.declaration.module });
+                    let properties = [];
+                    let declaration = m.declarations.find(x => x.name == e.declaration.name);
+                    for (let d of declaration.members) {
+                        if (d.kind == 'field') {
+                            let pType = PropertyType.property;
+                            if (declaration.attributes)
                                 pType = declaration.attributes.find(x => x.fieldName == d.name) != null ? PropertyType.propertyAndAttribute : PropertyType.property;
-                                properties.push({ name: d.name, service: this, propertyType: pType, type: this.manifestClassPropertyTypeToEditorPropertyType(d.type?.text) });
-                            }
+                            properties.push({ name: d.name, service: this, propertyType: pType, type: this.manifestClassPropertyTypeToEditorPropertyType(d.type?.text) });
                         }
-                        this._propertiesList[e.name] = properties;
                     }
-                }
-                if (this._resolveStored) {
-                    this._resolveStored.forEach(x => x(this._elementList));
-                    this._resolveStored = null;
-                    this._rejectStored = null;
+                    this._propertiesList[e.name] = properties;
                 }
             }
-        }).catch(err => {
-            if (this._rejectStored) {
-                this._rejectStored.forEach(x => x(err));
+            if (this._resolveStored) {
+                this._resolveStored.forEach(x => x(this._elementList));
                 this._resolveStored = null;
                 this._rejectStored = null;
             }
-        });
+        }
     }
     manifestClassPropertyTypeToEditorPropertyType(type) {
         if (type) {

package/dist/elements/widgets/codeView/code-view-ace.js

@@ -95,7 +95,7 @@ export class CodeViewAce extends BaseCustomWebComponentLazyAppend {
         this._aceEditor = ace.edit(this._editor, {
             theme: "ace/theme/chrome",
             mode: "ace/mode/html",
-            value: "test",
+            value: "",
             autoScrollEditorIntoView: true,
             fontSize: "14px",
             showPrintMargin: false,

package/dist/elements/widgets/demoView/IDemoView.d.ts

@@ -1,5 +1,5 @@
 import { InstanceServiceContainer } from '../../services/InstanceServiceContainer';
 import { ServiceContainer } from '../../services/ServiceContainer';
 export interface IDemoView {
-    display(serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer, code: string): any;
+    display(serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer, code: string, style: string): any;
 }

package/dist/elements/widgets/demoView/demoView.d.ts

@@ -7,5 +7,5 @@ export declare class DemoView extends BaseCustomWebComponentLazyAppend implement
     private _loading;
     static readonly style: CSSStyleSheet;
     constructor();
-    display(serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer, code: string): Promise<void>;
+    display(serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer, code: string, style: string): Promise<void>;
 }

package/dist/elements/widgets/demoView/demoView.js

@@ -29,9 +29,9 @@ export class DemoView extends BaseCustomWebComponentLazyAppend {
         this._loading.textContent = '🛀 Hold on, loading...';
         this.shadowRoot.appendChild(this._loading);
     }
-    async display(serviceContainer, instanceServiceContainer, code) {
+    async display(serviceContainer, instanceServiceContainer, code, style) {
         this._loading.hidden = false;
-        await serviceContainer.demoProviderService.provideDemo(this._placeholder, serviceContainer, instanceServiceContainer, code);
+        await serviceContainer.demoProviderService.provideDemo(this._placeholder, serviceContainer, instanceServiceContainer, code, style);
         this._loading.hidden = true;
     }
 }

package/dist/elements/widgets/designerView/DomConverter.js

@@ -19,7 +19,6 @@ export class DomConverter {
             tag === 'col' ||
             tag === 'embed' ||
             tag === 'hr' ||
-            tag === 'iframe' ||
             tag === 'img' ||
             tag === 'input' ||
             tag === 'keygen' ||
@@ -33,12 +32,7 @@ export class DomConverter {
     static ConvertToString(designItems, designItemsAssignmentList) {
         let itw = new IndentedTextWriter();
         let options = { beautifyOutput: true, writeDesignerProperties: true, compressCssToShorthandProperties: true };
-        for (let d of designItems) {
-            d.serviceContainer.forSomeServicesTillResult('htmlWriterService', (s) => {
-                if (s.canWrite(d))
-                    s.write(itw, d, options, designItemsAssignmentList);
-            });
-        }
+        designItems[0].serviceContainer.htmlWriterService.write(itw, designItems, true, options, designItemsAssignmentList);
         return itw.getString();
     }
 }

package/dist/elements/widgets/designerView/extensions/PathExtension.d.ts

@@ -2,6 +2,7 @@ import { IDesignItem } from "../../../item/IDesignItem";
 import { IDesignerCanvas } from "../IDesignerCanvas";
 import { AbstractExtension } from "./AbstractExtension";
 import "../../../helper/PathDataPolyfill";
+import { IPoint } from "../../../../interfaces/IPoint";
 import { IExtensionManager } from "./IExtensionManger";
 import { PathData } from "../../../helper/PathDataPolyfill";
 export declare class PathExtension extends AbstractExtension {
@@ -14,9 +15,10 @@ export declare class PathExtension extends AbstractExtension {
     constructor(extensionManager: IExtensionManager, designerView: IDesignerCanvas, extendedItem: IDesignItem);
     extend(): void;
     pointerEvent(event: PointerEvent, circle: SVGCircleElement, p: PathData, index: number): void;
-    _drawPath(path: PathData[], index: number): void;
+    _drawPath(path: PathData[], index: number): string;
     _drawPathCircle(x: number, y: number, p: PathData, index: number): void;
     _drawPathLine(x1: number, y1: number, x2: number, y2: number): void;
+    _drawHelpLine(pStart: IPoint, pEnd: IPoint): void;
     refresh(): void;
     dispose(): void;
 }

package/dist/elements/widgets/designerView/extensions/PathExtension.js

@@ -83,9 +83,27 @@ export class PathExtension extends AbstractExtension {
                     const cy = event.y - this._lastPos.y + this._circlePos.y;
                     const dx = cx - this._circlePos.x;
                     const dy = cy - this._circlePos.y;
-                    p.values[index] = this._originalPathPoint.x + dx;
-                    p.values[index + 1] = this._originalPathPoint.y + dy;
-                    this._drawPath(this._pathdata, index);
+                    if (event.shiftKey) {
+                        if (Math.abs(dx) >= Math.abs(dy)) {
+                            p.values[index] = this._originalPathPoint.x + dx;
+                            circle.setAttribute("cx", (this._circlePos.x + dx).toString());
+                            p.values[index + 1] = this._originalPathPoint.y;
+                            circle.setAttribute("cy", (this._circlePos.y).toString());
+                        }
+                        else {
+                            p.values[index] = this._originalPathPoint.x;
+                            circle.setAttribute("cx", (this._circlePos.x).toString());
+                            p.values[index + 1] = this._originalPathPoint.y + dy;
+                            circle.setAttribute("cy", (this._circlePos.y + dy).toString());
+                        }
+                    }
+                    else {
+                        p.values[index] = this._originalPathPoint.x + dx;
+                        p.values[index + 1] = this._originalPathPoint.y + dy;
+                        circle.setAttribute("cx", (this._circlePos.x + dx).toString());
+                        circle.setAttribute("cy", (this._circlePos.y + dy).toString());
+                    }
+                    this.extendedItem.element.setAttribute("d", this._drawPath(this._pathdata, index));
                 }
                 break;
             case EventNames.PointerUp:
@@ -93,15 +111,42 @@ export class PathExtension extends AbstractExtension {
                 this._startPos = null;
                 this._circlePos = null;
                 this._lastPos = null;
+                this.extendedItem.setAttribute('d', this._drawPath(this._pathdata, index));
                 break;
         }
     }
     _drawPath(path, index) {
         let pathD = "";
         for (let p of path) {
-            pathD += p.type + p.values[index] + " " + p.values[index + 1];
+            switch (p.type) {
+                case 'M':
+                    pathD += p.type + p.values[0] + " " + p.values[1];
+                    break;
+                case 'L':
+                    pathD += p.type + p.values[0] + " " + p.values[1];
+                    break;
+                case 'H':
+                    break;
+                case 'V':
+                    break;
+                case 'Z':
+                    break;
+                case 'C':
+                case 'c':
+                    pathD += p.type + p.values[0] + " " + p.values[1] + " " + p.values[2] + " " + p.values[3] + " " + p.values[4] + " " + p.values[5];
+                    break;
+                case 'S':
+                    break;
+                case 'Q':
+                    break;
+                case 'T':
+                    break;
+                case 'A':
+                    break;
+            }
         }
-        this.extendedItem.setAttribute("d", pathD);
+        return pathD;
+        console.log(pathD);
     }
     _drawPathCircle(x, y, p, index) {
         let circle = this._drawCircle(this._parentRect.x - this.designerCanvas.containerBoundingRect.x + x, this._parentRect.y - this.designerCanvas.containerBoundingRect.y + y, 3, 'svg-path');
@@ -112,6 +157,15 @@ export class PathExtension extends AbstractExtension {
     _drawPathLine(x1, y1, x2, y2) {
         this._drawLine(this._parentRect.x - this.designerCanvas.containerBoundingRect.x + x1, this._parentRect.y - this.designerCanvas.containerBoundingRect.y + y1, this._parentRect.x - this.designerCanvas.containerBoundingRect.x + x2, this._parentRect.y - this.designerCanvas.containerBoundingRect.y + y2, 'svg-path-line');
     }
+    _drawHelpLine(pStart, pEnd) {
+        let line;
+        line.setAttribute("stroke", "yellow");
+        line.setAttribute("stroke-width", "2");
+        line.setAttribute("x1", pStart.x.toString());
+        line.setAttribute("y1", pStart.y.toString());
+        line.setAttribute("x2", pEnd.x.toString());
+        line.setAttribute("y2", pEnd.y.toString());
+    }
     refresh() {
         this._removeAllOverlays();
         this.extend();

package/dist/elements/widgets/designerView/overlayLayerView.js

@@ -67,8 +67,7 @@ export class OverlayLayerView extends BaseCustomWebComponentConstructorAppend {
     }
     removeOverlay(element) {
         try {
-            if (element)
-                element.parentElement.removeChild(element);
+            element?.parentElement?.removeChild(element);
         }
         catch (err) {
             console.error(err);

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

@@ -80,6 +80,7 @@ export class DrawEllipsisTool {
                 svg.style.position = 'absolute';
                 svg.style.width = (rect.width + 2 * offset) + 'px';
                 svg.style.height = (rect.height + 2 * offset) + 'px';
+                svg.style.overflow = 'visible';
                 this._path = null;
                 const di = DesignItem.createDesignItemFromInstance(svg, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
                 designerCanvas.instanceServiceContainer.undoService.execute(new InsertAction(designerCanvas.rootDesignItem, designerCanvas.rootDesignItem.childCount, di));

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

@@ -65,6 +65,7 @@ export class DrawLineTool {
                 svg.style.position = 'absolute';
                 svg.style.width = (rect.width + 2 * offset) + 'px';
                 svg.style.height = (rect.height + 2 * offset) + 'px';
+                svg.style.overflow = 'visible';
                 this._path = null;
                 const di = DesignItem.createDesignItemFromInstance(svg, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
                 designerCanvas.instanceServiceContainer.undoService.execute(new InsertAction(designerCanvas.rootDesignItem, designerCanvas.rootDesignItem.childCount, di));

package/dist/elements/widgets/designerView/tools/DrawPathTool.d.ts

@@ -11,7 +11,6 @@ export declare class DrawPathTool implements ITool {
     private _pointerMoved;
     private _eventStarted;
     private _lastPoint;
-    private _savedPoint;
     private _startPoint;
     constructor();
     activated(serviceContainer: ServiceContainer): void;

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

@@ -12,8 +12,7 @@ export class DrawPathTool {
     _dragMode = false;
     _pointerMoved = false;
     _eventStarted = false;
-    _lastPoint = { x: 0, y: 0 };
-    _savedPoint = { x: 0, y: 0 };
+    _lastPoint;
     _startPoint = { x: 0, y: 0 };
     constructor() {
     }
@@ -38,10 +37,12 @@ export class DrawPathTool {
                     designerCanvas.overlayLayer.addOverlay(this._path, OverlayLayer.Foregorund);
                     this._startPoint = currentPoint;
                 }
-                if (this._lastPoint.x === currentPoint.x && this._lastPoint.y === currentPoint.y && !this._samePoint) {
+                if (this._lastPoint != null && this._lastPoint.x === currentPoint.x && this._lastPoint.y === currentPoint.y && !this._samePoint) {
                     this._samePoint = true;
                 }
-                this._lastPoint = currentPoint;
+                if (this._lastPoint == null) {
+                    this._lastPoint = currentPoint;
+                }
                 break;
             case EventNames.PointerMove:
                 if (this._eventStarted) {
@@ -57,8 +58,9 @@ export class DrawPathTool {
                 else { // shows line preview
                     if (this._path) {
                         let straightLine = currentPoint;
-                        if (event.shiftKey)
-                            straightLine = straightenLine(this._savedPoint, currentPoint);
+                        if (event.shiftKey) {
+                            straightLine = straightenLine(this._lastPoint, currentPoint);
+                        }
                         this._path.setAttribute("d", this._pathD + "L" + straightLine.x + " " + straightLine.y);
                     }
                 }
@@ -71,15 +73,16 @@ export class DrawPathTool {
                 if (this._p2pMode && !this._samePoint && this._startPoint.x != currentPoint.x && this._startPoint.y != currentPoint.y) {
                     if (this._path) {
                         if (event.shiftKey) {
-                            let straightLine = straightenLine(this._savedPoint, currentPoint);
+                            let straightLine = straightenLine(this._lastPoint, currentPoint);
                             this._pathD += "L" + straightLine.x + " " + straightLine.y;
                             this._path.setAttribute("d", this._pathD);
+                            this._lastPoint = straightLine;
                         }
                         else {
                             this._pathD += "L" + currentPoint.x + " " + currentPoint.y;
                             this._path.setAttribute("d", this._pathD);
+                            this._lastPoint = currentPoint;
                         }
-                        this._savedPoint = currentPoint;
                     }
                 }
                 if (this._samePoint && this._p2pMode || this._dragMode && !this._p2pMode) {
@@ -101,6 +104,7 @@ export class DrawPathTool {
                     svg.style.position = 'absolute';
                     svg.style.width = (rect.width + 2 * offset) + 'px';
                     svg.style.height = (rect.height + 2 * offset) + 'px';
+                    svg.style.overflow = 'visible';
                     //designerView.rootDesignItem.element.appendChild(svg);
                     this._path = null;
                     this._pathD = null;

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

@@ -95,6 +95,7 @@ export class DrawRectTool {
                 svg.style.position = 'absolute';
                 svg.style.width = (rect.width + 2 * offset) + 'px';
                 svg.style.height = (rect.height + 2 * offset) + 'px';
+                svg.style.overflow = 'visible';
                 this._path = null;
                 const di = DesignItem.createDesignItemFromInstance(svg, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
                 designerCanvas.instanceServiceContainer.undoService.execute(new InsertAction(designerCanvas.rootDesignItem, designerCanvas.rootDesignItem.childCount, di));

package/dist/index.d.ts

@@ -45,7 +45,9 @@ export * from "./elements/services/elementsService/JsonFileElementsService.js";
 export * from "./elements/services/elementsService/PreDefinedElementsService.js";
 export type { IHtmlWriterService } from "./elements/services/htmlWriterService/IHtmlWriterService.js";
 export type { IHtmlWriterOptions } from "./elements/services/htmlWriterService/IHtmlWriterOptions.js";
+export * from "./elements/services/htmlWriterService/FormatingHtmlWriterService.js";
 export * from "./elements/services/htmlWriterService/HtmlWriterService.js";
+export * from "./elements/services/htmlWriterService/LitTsElementWriterService.js";
 export * from "./elements/services/htmlParserService/DefaultHtmlParserService.js";
 export * from "./elements/services/htmlParserService/NodeHtmlParserService.js";
 export type { IHtmlParserService } from "./elements/services/htmlParserService/IHtmlParserService.js";
@@ -177,3 +179,4 @@ export type { IPoint } from "./interfaces/IPoint.js";
 export type { IRect } from "./interfaces/IRect.js";
 export type { ISize } from "./interfaces/ISize.js";
 export type { ICommandHandler } from "./interfaces/ICommandHandler.js";
+export * from './Constants.js';

package/dist/index.js

@@ -26,7 +26,9 @@ export * from "./elements/services/demoProviderService/DemoProviderService.js";
 export * from "./elements/services/dragDropService/DragDropService.js";
 export * from "./elements/services/elementsService/JsonFileElementsService.js";
 export * from "./elements/services/elementsService/PreDefinedElementsService.js";
+export * from "./elements/services/htmlWriterService/FormatingHtmlWriterService.js";
 export * from "./elements/services/htmlWriterService/HtmlWriterService.js";
+export * from "./elements/services/htmlWriterService/LitTsElementWriterService.js";
 export * from "./elements/services/htmlParserService/DefaultHtmlParserService.js";
 export * from "./elements/services/htmlParserService/NodeHtmlParserService.js";
 export * from "./elements/services/instanceService/DefaultInstanceService.js";
@@ -126,3 +128,4 @@ export * from "./elements/widgets/codeView/code-view-code-mirror.js";
 export * from "./elements/documentContainer.js";
 export * from "./enums/EventNames.js";
 export * from "./enums/PointerActionType.js";
+export * from './Constants.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "description": "A UI designer for Polymer apps",
   "name": "@node-projects/web-component-designer",
-  "version": "0.0.76",
+  "version": "0.0.80",
   "type": "module",
   "main": "./dist/index.js",
   "author": "",
@@ -13,7 +13,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@node-projects/base-custom-webcomponent": "^0.4.0",
+    "@node-projects/base-custom-webcomponent": "^0.4.1",
     "construct-style-sheets-polyfill": "^3.0.5"
   },
   "devDependencies": {
@@ -25,9 +25,9 @@
     "ace-builds": "^1.4.13",
     "codemirror": "^5.65.0",
     "custom-elements-manifest": "^1.0.0",
-    "esprima-next": "^5.7.0",
+    "esprima-next": "^5.8.1",
     "html2canvas": "*",
-    "jest": "^27.4.5",
+    "jest": "^27.4.7",
     "jquery": "^3.6.0",
     "jquery.fancytree": "^2.38.0",
     "monaco-editor": "^0.31.1",

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

@@ -1,26 +0,0 @@
-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;
-}