@node-projects/web-component-designer 0.0.292 → 0.1.0

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

@@ -1,12 +0,0 @@
-import { IElementsService } from './IElementsService.js';
-import { IElementDefinition } from './IElementDefinition.js';
-export declare class JsonFileElementsService implements IElementsService {
-    private _name;
-    get name(): string;
-    private _elementList;
-    private _resolveStored;
-    private _rejectStored;
-    getElements(): Promise<IElementDefinition[]>;
-    constructor(name: string, file: string);
-    private isIElementDefintion;
-}

package/dist/elements/services/elementsService/JsonFileElementsService.js

@@ -1,45 +0,0 @@
-import { LazyLoader } from '@node-projects/base-custom-webcomponent';
-// Reads a Json File and provides the Elements listed there
-export class JsonFileElementsService {
-    _name;
-    get name() { return this._name; }
-    _elementList;
-    _resolveStored;
-    _rejectStored;
-    getElements() {
-        if (this._elementList)
-            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); });
-    }
-    constructor(name, file) {
-        this._name = name;
-        LazyLoader.LoadText(file).then(data => {
-            let parsed = JSON.parse(data);
-            this._elementList = [];
-            parsed.elements.forEach(element => {
-                if (this.isIElementDefintion(element))
-                    this._elementList.push(element);
-                else
-                    this._elementList.push({ tag: element });
-            });
-            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;
-            }
-        });
-    }
-    isIElementDefintion(object) {
-        return object != null && object.tag != null;
-    }
-}

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

@@ -1,11 +0,0 @@
-import { IElementsService } from './IElementsService.js';
-import { IElementsJson } from './IElementsJson.js';
-import { IElementDefinition } from './IElementDefinition.js';
-export declare class PreDefinedElementsService implements IElementsService {
-    private _name;
-    get name(): string;
-    private _elementList;
-    getElements(): Promise<IElementDefinition[]>;
-    constructor(name: string, data: IElementsJson);
-    private isIElementDefintion;
-}

package/dist/elements/services/elementsService/PreDefinedElementsService.js

@@ -1,21 +0,0 @@
-export class PreDefinedElementsService {
-    _name;
-    get name() { return this._name; }
-    _elementList;
-    getElements() {
-        return Promise.resolve(this._elementList);
-    }
-    constructor(name, data) {
-        this._name = name;
-        this._elementList = [];
-        data.elements.forEach(element => {
-            if (this.isIElementDefintion(element))
-                this._elementList.push(element);
-            else
-                this._elementList.push({ tag: element });
-        });
-    }
-    isIElementDefintion(object) {
-        return object != null && object.tag != null;
-    }
-}

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

@@ -1,13 +0,0 @@
-import { IElementDefinition } from "./IElementDefinition.js";
-import { IElementsService } from "./IElementsService.js";
-export declare class WebcomponentManifestElementsService implements IElementsService {
-    private _name;
-    get name(): string;
-    private _importPrefix;
-    private _elementList;
-    private _resolveStored;
-    private _rejectStored;
-    constructor(name: string, importPrefix: string, manifest: any);
-    private _parseManifest;
-    getElements(): Promise<IElementDefinition[]>;
-}

package/dist/elements/services/elementsService/WebcomponentManifestElementsService.js

@@ -1,45 +0,0 @@
-import { removeLeading, removeTrailing } from "../../helper/Helper.js";
-export class WebcomponentManifestElementsService {
-    _name;
-    get name() { return this._name; }
-    _importPrefix;
-    _elementList;
-    _resolveStored;
-    _rejectStored;
-    constructor(name, importPrefix, manifest) {
-        this._name = name;
-        this._importPrefix = importPrefix;
-        this._parseManifest(manifest);
-    }
-    _parseManifest(manifest) {
-        this._elementList = [];
-        for (let m of manifest.modules) {
-            for (let e of m.exports) {
-                if (e.kind == 'custom-element-definition') {
-                    let elDef = { tag: e.name, import: removeTrailing(this._importPrefix, '/') + '/' + removeLeading(e.declaration.module, '/'), defaultWidth: "200px", defaultHeight: "200px", className: e.declaration.name };
-                    this._elementList.push(elDef);
-                }
-            }
-            for (let d of m.declarations) {
-                if (d.tagName) {
-                    let elDef = { tag: d.tagName, import: removeTrailing(this._importPrefix, '/') + '/' + removeLeading(m.path, '/'), defaultWidth: "200px", defaultHeight: "200px", className: d.name };
-                    this._elementList.push(elDef);
-                }
-            }
-            if (this._resolveStored) {
-                this._resolveStored.forEach(x => x(this._elementList));
-                this._resolveStored = null;
-                this._rejectStored = null;
-            }
-        }
-    }
-    async getElements() {
-        if (this._elementList)
-            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); });
-    }
-}

package/dist/elements/services/eventsService/EventsService.d.ts

@@ -1,49 +0,0 @@
-import { IDesignItem } from "../../item/IDesignItem.js";
-import { IEvent } from "./IEvent.js";
-import { IEventsService } from "./IEventsService.js";
-export declare class EventsService implements IEventsService {
-    constructor();
-    protected _allEvents: IEvent[];
-    protected _windowEvents: {
-        name: string;
-        propertyName: string;
-        eventObjectName: string;
-    }[];
-    protected _allElements: IEvent[];
-    protected _focusableEvents: {
-        name: string;
-        propertyName: string;
-        eventObjectName: string;
-    }[];
-    protected _form: {
-        name: string;
-        propertyName: string;
-        eventObjectName: string;
-    }[];
-    protected _simpleMouseEvents: IEvent[];
-    protected _mouseEvents: {
-        name: string;
-        propertyName: string;
-        eventObjectName: string;
-    }[];
-    protected _pointerEvents: IEvent[];
-    protected _touchEvents: IEvent[];
-    protected _dragEvents: {
-        name: string;
-        propertyName: string;
-        eventObjectName: string;
-    }[];
-    protected _clipboard: {
-        name: string;
-        propertyName: string;
-        eventObjectName: string;
-    }[];
-    protected _details: {
-        name: string;
-        propertyName: string;
-        eventObjectName: string;
-    }[];
-    isHandledElement(designItem: IDesignItem): boolean;
-    getPossibleEvents(designItem: IDesignItem): IEvent[];
-    getEvent(name: string): IEvent;
-}

package/dist/elements/services/eventsService/EventsService.js

@@ -1,103 +0,0 @@
-export class EventsService {
-    constructor() {
-        this._allEvents = [...this._windowEvents, ...this._form, ...this._simpleMouseEvents, ...this._mouseEvents, ...this._pointerEvents, ...this._touchEvents, ...this._allElements, ...this._focusableEvents, ...this._dragEvents, ...this._clipboard, ...this._dragEvents];
-    }
-    _allEvents;
-    _windowEvents = [
-        { name: "afterprint", propertyName: "onafterprint", eventObjectName: "Event" },
-        { name: "beforeprint", propertyName: "onbeforeprint", eventObjectName: "Event" },
-        { name: "beforeunload", propertyName: "onbeforeunload", eventObjectName: "Event" },
-        { name: "error", propertyName: "onerror", eventObjectName: "Event" },
-        { name: "load", propertyName: "onload", eventObjectName: "Event" },
-        { name: "hashchange", propertyName: "onhashchange", eventObjectName: "Event" },
-        { name: "message", propertyName: "onmessage", eventObjectName: "Event" },
-        { name: "offline", propertyName: "onoffline", eventObjectName: "Event" },
-        { name: "online", propertyName: "ononline", eventObjectName: "Event" },
-        { name: "pageshow", propertyName: "onpageshow", eventObjectName: "Event" },
-        { name: "popstate", propertyName: "onpopstate", eventObjectName: "Event" },
-        { name: "resize", propertyName: "onresize", eventObjectName: "Event" },
-        { name: "storage", propertyName: "onstorage", eventObjectName: "Event" },
-        { name: "unload", propertyName: "onunload", eventObjectName: "Event" }
-    ];
-    _allElements = [
-        { name: "contextmenu", propertyName: "oncontextmenu", eventObjectName: "PointerEvent" }
-    ];
-    _focusableEvents = [
-        { name: "blur", propertyName: "onblur", eventObjectName: "FocusEvent" },
-        { name: "focus", propertyName: "onfocus", eventObjectName: "FocusEvent" },
-        { name: "keydown", propertyName: "onkeydown", eventObjectName: "KeyboardEvent" },
-        { name: "keyup", propertyName: "onkeyup", eventObjectName: "KeyboardEvent" }
-    ];
-    _form = [
-        { name: "beforeinput", propertyName: "onbeforeinput", eventObjectName: "InputEvent" },
-        { name: "input", propertyName: "oninput", eventObjectName: "InputEvent" },
-        { name: "change", propertyName: "onchange", eventObjectName: "Event" },
-        { name: "invalid", propertyName: "oninvalid", eventObjectName: "Event" },
-        { name: "reset", propertyName: "onreset", eventObjectName: "Event" },
-        { name: "select", propertyName: "onselect", eventObjectName: "Event" },
-        { name: "submit", propertyName: "onsubmit", eventObjectName: "SubmitEvent" }
-    ];
-    _simpleMouseEvents = [
-        { name: "click", propertyName: "onclick", eventObjectName: "PointerEvent" },
-        { name: "dblclick", propertyName: "ondblclick", eventObjectName: "MouseEvent" },
-        { name: "wheel", propertyName: "onwheel", eventObjectName: "WheelEvent" },
-        { name: "scroll", propertyName: "onscroll", eventObjectName: "Event" },
-    ];
-    _mouseEvents = [
-        { name: "mousedown", propertyName: "onmousedown", eventObjectName: "MouseEvent" },
-        { name: "mouseup", propertyName: "onmouseup", eventObjectName: "MouseEvent" },
-        { name: "mousemove", propertyName: "onmousemove", eventObjectName: "MouseEvent" },
-        { name: "mouseover", propertyName: "onmouseover", eventObjectName: "MouseEvent" },
-        { name: "mouseout", propertyName: "onmouseout", eventObjectName: "MouseEvent" }
-    ];
-    _pointerEvents = [
-        { name: "pointerdown", propertyName: "onpointerdown", eventObjectName: "PointerEvent" },
-        { name: "pointerup", propertyName: "onpointerup", eventObjectName: "PointerEvent" },
-        { name: "pointerenter", propertyName: "onpointerenter", eventObjectName: "PointerEvent" },
-        { name: "pointerleave", propertyName: "onpointerleave", eventObjectName: "PointerEvent" },
-        { name: "pointermove", propertyName: "onpointermove", eventObjectName: "PointerEvent" },
-        { name: "pointerover", propertyName: "onpointerover", eventObjectName: "PointerEvent" },
-        { name: "pointerout", propertyName: "onpointerout", eventObjectName: "PointerEvent" },
-        { name: "pointercancel", propertyName: "onpointercancel", eventObjectName: "PointerEvent" }
-    ];
-    _touchEvents = [
-        { name: "touchstart", propertyName: "ontouchstart", eventObjectName: "TouchEvent" },
-        { name: "touchend", propertyName: "ontouchend", eventObjectName: "TouchEvent" },
-        { name: "touchmove", propertyName: "ontouchmove", eventObjectName: "TouchEvent" },
-        { name: "touchcancel", propertyName: "ontouchcancel", eventObjectName: "TouchEvent" }
-    ];
-    _dragEvents = [
-        { name: "drag", propertyName: "ondrag", eventObjectName: "DragEvent" },
-        { name: "dragend", propertyName: "ondragend", eventObjectName: "DragEvent" },
-        { name: "dragenter", propertyName: "ondragenter", eventObjectName: "DragEvent" },
-        { name: "dragleave", propertyName: "ondragleave", eventObjectName: "DragEvent" },
-        { name: "dragover", propertyName: "ondragover", eventObjectName: "DragEvent" },
-        { name: "dragstart", propertyName: "ondragstart", eventObjectName: "DragEvent" },
-        { name: "drop", propertyName: "ondrop", eventObjectName: "DragEvent" }
-    ];
-    _clipboard = [
-        { name: "copy", propertyName: "oncopy", eventObjectName: "ClipboardEvent" },
-        { name: "cut", propertyName: "oncut", eventObjectName: "ClipboardEvent" },
-        { name: "paste", propertyName: "onpaste", eventObjectName: "ClipboardEvent" }
-    ];
-    _details = [
-        { name: "toggle", propertyName: "ontoggle", eventObjectName: "Event" }
-    ];
-    isHandledElement(designItem) {
-        return true;
-    }
-    getPossibleEvents(designItem) {
-        if (designItem.element instanceof HTMLInputElement ||
-            designItem.element instanceof HTMLTextAreaElement ||
-            designItem.element instanceof HTMLSelectElement) {
-            let events = [...this._form, ...this._simpleMouseEvents, ...this._pointerEvents, ...this._allElements, ...this._focusableEvents];
-            return events;
-        }
-        let events = [...this._simpleMouseEvents, ...this._pointerEvents, ...this._allElements, ...this._focusableEvents];
-        return events;
-    }
-    getEvent(name) {
-        let evt = this._allEvents.find(x => x.name == name);
-        return evt ?? { name, propertyName: 'on' + name, eventObjectName: 'Event' };
-    }
-}

package/dist/elements/services/eventsService/IEvent.d.ts

@@ -1,5 +0,0 @@
-export interface IEvent {
-    name: string;
-    propertyName?: string;
-    eventObjectName?: string;
-}

package/dist/elements/services/eventsService/IEvent.js

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

package/dist/elements/services/eventsService/IEventsService copy.d.ts

@@ -1,2 +0,0 @@
-export interface IEventsService {
-}

package/dist/elements/services/eventsService/IEventsService copy.js

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

package/dist/elements/services/eventsService/IEventsService.d.ts

@@ -1,7 +0,0 @@
-import { IDesignItem } from "../../item/IDesignItem.js";
-import { IEvent } from "./IEvent.js";
-export interface IEventsService {
-    isHandledElement(designItem: IDesignItem): boolean;
-    getPossibleEvents(designItem: IDesignItem): IEvent[];
-    getEvent(name: string): IEvent;
-}

package/dist/elements/services/eventsService/IEventsService.js

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

package/dist/elements/services/htmlParserService/BaseCustomWebcomponentParserService.d.ts

@@ -1,11 +0,0 @@
-import { InstanceServiceContainer } from '../InstanceServiceContainer.js';
-import { ServiceContainer } from '../ServiceContainer.js';
-import { IHtmlParserService } from './IHtmlParserService.js';
-import { IDesignItem } from '../../item/IDesignItem.js';
-export declare class BaseCustomWebcomponentParserService implements IHtmlParserService {
-    private htmlParser;
-    constructor(htmlParser: IHtmlParserService);
-    parse(code: string, serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer, parseSnippet: boolean): Promise<IDesignItem[]>;
-    writeBack(code: string, html: string, css: string, newLineCrLf: boolean): string;
-    private parseTypescriptFile;
-}

package/dist/elements/services/htmlParserService/BaseCustomWebcomponentParserService.js

@@ -1,90 +0,0 @@
-function* findAllNodesOfKind(node, kind) {
-    if (node.kind == kind)
-        yield node;
-    for (const c of node.getChildren())
-        yield* findAllNodesOfKind(c, kind);
-}
-export class BaseCustomWebcomponentParserService {
-    htmlParser;
-    constructor(htmlParser) {
-        this.htmlParser = htmlParser;
-    }
-    async parse(code, serviceContainer, instanceServiceContainer, parseSnippet) {
-        const sourceFile = this.parseTypescriptFile(code);
-        let htmlCode = "";
-        let cssStyle = "";
-        //@ts-ignore
-        const nodes = findAllNodesOfKind(sourceFile, ts.SyntaxKind.TaggedTemplateExpression);
-        for (let nd of nodes) {
-            if (nd.tag.escapedText == 'html' && nd.parent.name.escapedText == "template")
-                htmlCode = nd.template.rawText;
-            if (nd.tag.escapedText == 'css' && nd.parent.name.escapedText == "style")
-                cssStyle = nd.template.rawText;
-        }
-        if (cssStyle)
-            instanceServiceContainer.stylesheetService.setStylesheets([{ name: 'css', content: cssStyle }]);
-        return this.htmlParser.parse(htmlCode, serviceContainer, instanceServiceContainer, parseSnippet);
-    }
-    writeBack(code, html, css, newLineCrLf) {
-        const sourceFile = this.parseTypescriptFile(code);
-        const transformTemplateLiterals = (context) => (rootNode) => {
-            function visit(node) {
-                //@ts-ignore
-                if (ts.isTemplateLiteral(node) &&
-                    //@ts-ignore
-                    ts.isTaggedTemplateExpression(node.parent) &&
-                    node.parent.tag.escapedText == 'html' &&
-                    node.parent.parent.name.escapedText == "template") {
-                    //@ts-ignore
-                    return ts.factory.createNoSubstitutionTemplateLiteral(html.replaceAll('\n', '\r\n'), html.replaceAll('\n', '\r\n'));
-                }
-                else if (css &&
-                    //@ts-ignore
-                    ts.isTemplateLiteral(node) &&
-                    //@ts-ignore
-                    ts.isTaggedTemplateExpression(node.parent) &&
-                    node.parent.tag.escapedText == 'css' &&
-                    node.parent.parent.name.escapedText == "style") {
-                    //@ts-ignore
-                    return ts.factory.createNoSubstitutionTemplateLiteral(css.replaceAll('\n', '\r\n'), css.replaceAll('\n', '\r\n'));
-                }
-                //@ts-ignore
-                return ts.visitEachChild(node, visit, context);
-            }
-            //@ts-ignore
-            return ts.visitNode(rootNode, visit);
-        };
-        //@ts-ignore
-        let transformed = ts.transform(sourceFile, [transformTemplateLiterals]).transformed[0];
-        //@ts-ignore
-        const printer = ts.createPrinter({ newLine: newLineCrLf ? ts.NewLineKind.CarriageReturnLineFeed : ts.NewLineKind.LineFeed });
-        //@ts-ignore
-        const result = printer.printNode(ts.EmitHint.Unspecified, transformed, transformed);
-        return result;
-    }
-    parseTypescriptFile(code) {
-        const compilerHost = {
-            fileExists: () => true,
-            getCanonicalFileName: filename => filename,
-            getCurrentDirectory: () => '',
-            getDefaultLibFileName: () => 'lib.d.ts',
-            getNewLine: () => '\n',
-            getSourceFile: filename => {
-                //@ts-ignore
-                return ts.createSourceFile(filename, code, ts.ScriptTarget.Latest, true);
-            },
-            readFile: () => null,
-            useCaseSensitiveFileNames: () => true,
-            writeFile: () => null,
-        };
-        const filename = 'aa.ts';
-        //@ts-ignore
-        const program = ts.createProgram([filename], {
-            noResolve: true,
-            //@ts-ignore
-            target: ts.ScriptTarget.Latest,
-        }, compilerHost);
-        const sourceFile = program.getSourceFile(filename);
-        return sourceFile;
-    }
-}

package/dist/elements/services/htmlParserService/DefaultHtmlParserService.d.ts

@@ -1,9 +0,0 @@
-import { InstanceServiceContainer } from '../InstanceServiceContainer.js';
-import { ServiceContainer } from '../ServiceContainer.js';
-import { IHtmlParserService } from './IHtmlParserService.js';
-import { IDesignItem } from '../../item/IDesignItem.js';
-export declare class DefaultHtmlParserService implements IHtmlParserService {
-    parse(html: string, serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer, parseSnippet: boolean): Promise<IDesignItem[]>;
-    createDesignItems(elements: NodeListOf<ChildNode> | Node[] | HTMLCollection | HTMLElement[], serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer): IDesignItem[];
-    private _createDesignItemsRecursive;
-}

package/dist/elements/services/htmlParserService/DefaultHtmlParserService.js

@@ -1,18 +0,0 @@
-import { DesignItem } from '../../item/DesignItem.js';
-export class DefaultHtmlParserService {
-    async parse(html, serviceContainer, instanceServiceContainer, parseSnippet) {
-        const parser = new DOMParser();
-        const doc = parser.parseFromString(html, 'text/html');
-        return this.createDesignItems(doc.body.childNodes, serviceContainer, instanceServiceContainer);
-    }
-    createDesignItems(elements, serviceContainer, instanceServiceContainer) {
-        let res = [];
-        for (let el of elements) {
-            res.push(this._createDesignItemsRecursive(el, serviceContainer, instanceServiceContainer));
-        }
-        return res;
-    }
-    _createDesignItemsRecursive(node, serviceContainer, instanceServiceContainer) {
-        return DesignItem.createDesignItemFromInstance(node, serviceContainer, instanceServiceContainer);
-    }
-}

package/dist/elements/services/htmlParserService/IHtmlParserService.d.ts

@@ -1,7 +0,0 @@
-import { IService } from '../IService.js';
-import type { ServiceContainer } from '../ServiceContainer.js';
-import type { InstanceServiceContainer } from '../InstanceServiceContainer.js';
-import { IDesignItem } from '../../item/IDesignItem.js';
-export interface IHtmlParserService extends IService {
-    parse(html: string, serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer, parseSnippet: boolean): Promise<IDesignItem[]>;
-}

package/dist/elements/services/htmlParserService/IHtmlParserService.js

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

package/dist/elements/services/htmlParserService/LitElementParserService.d.ts

@@ -1,12 +0,0 @@
-import { InstanceServiceContainer } from '../InstanceServiceContainer.js';
-import { ServiceContainer } from '../ServiceContainer.js';
-import { IHtmlParserService } from './IHtmlParserService.js';
-import { IDesignItem } from '../../item/IDesignItem.js';
-export declare class LitElementParserService implements IHtmlParserService {
-    private _parserUrl;
-    private _esprimaUrl;
-    constructor(parserUrl?: string, esprimaUrl?: string);
-    parse(module: string, serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer, parseSnippet: boolean): Promise<IDesignItem[]>;
-    private _parseDiv;
-    _createDesignItemsRecursive(item: any, serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer, namespace: string): IDesignItem;
-}

package/dist/elements/services/htmlParserService/LitElementParserService.js

@@ -1,91 +0,0 @@
-import { DesignItem } from '../../item/DesignItem.js';
-import { CssAttributeParser } from '../../helper/CssAttributeParser.js';
-import { newElementFromString } from '../../helper/ElementHelper.js';
-// Alternative Parser, cause when you use the Browser, it instanciates the CusomElements, and some Elemnts remove
-// attributes from their DOM, so you loose Data
-export class LitElementParserService {
-    _parserUrl;
-    _esprimaUrl;
-    constructor(parserUrl = '../../../../../node-html-parser-esm/dist/index.js', esprimaUrl = '../../../../../esprima-next/dist/esm/esprima.js') {
-        this._parserUrl = parserUrl;
-        this._esprimaUrl = esprimaUrl;
-    }
-    async parse(module, serviceContainer, instanceServiceContainer, parseSnippet) {
-        let esprima = await import(this._esprimaUrl);
-        const parsedModule = esprima.parseModule(module);
-        const classDecl = parsedModule.body.find(x => x.type == esprima.Syntax.ClassDeclaration);
-        const renderMethod = classDecl.body.body.find(x => x.type == esprima.Syntax.MethodDefinition && x.key.name == 'render');
-        const renderMethodStatement = renderMethod.value.body.body[0];
-        const taggedTemplate = renderMethodStatement.argument;
-        const templateLiteral = taggedTemplate.quasi;
-        const html = templateLiteral.quasis.map(x => x.value.raw).join();
-        //@ts-ignore
-        let parser = await import(this._parserUrl);
-        const parsed = parser.parse(html, { comment: true });
-        let designItems = [];
-        for (let p of parsed.childNodes) {
-            let di = this._createDesignItemsRecursive(p, serviceContainer, instanceServiceContainer, null);
-            if (di != null)
-                designItems.push(di);
-            else
-                console.warn("NodeHtmlParserService - could not parse element", p);
-        }
-        return designItems;
-    }
-    _parseDiv = document.createElement("div");
-    _createDesignItemsRecursive(item, serviceContainer, instanceServiceContainer, namespace) {
-        let designItem = null;
-        if (item.nodeType == 1) {
-            let element;
-            let manualCreatedElement = false;
-            if (!namespace)
-                element = newElementFromString('<' + item.rawTagName + ' ' + item.rawAttrs + '></' + item.rawTagName + '>'); // some custom elements only parse attributes during constructor call 
-            if (!element) {
-                if (namespace)
-                    element = document.createElementNS(namespace, item.rawTagName);
-                else
-                    element = document.createElement(item.rawTagName);
-                manualCreatedElement = true;
-            }
-            designItem = DesignItem.GetOrCreateDesignItem(element, item, serviceContainer, instanceServiceContainer);
-            let style = '';
-            let attr = item.attributes;
-            for (let a in attr) {
-                if (a !== 'style') {
-                    designItem._withoutUndoSetAttribute(a, attr[a]);
-                    if (manualCreatedElement) {
-                        element.setAttribute(a, attr[a]);
-                    }
-                }
-                else {
-                    style = attr[a];
-                }
-            }
-            if ((element instanceof HTMLElement || element instanceof SVGElement) && style) {
-                let styleParser = new CssAttributeParser();
-                styleParser.parse(style);
-                for (let s of styleParser.entries) {
-                    designItem._withoutUndoSetStyle(s.name, s.value);
-                    if (manualCreatedElement) {
-                        element.style[s.name] = s.value;
-                    }
-                }
-            }
-            element.draggable = false; //even if it should be true, for better designer exp.
-            for (let c of item.childNodes) {
-                let di = this._createDesignItemsRecursive(c, serviceContainer, instanceServiceContainer, element instanceof SVGElement ? 'http://www.w3.org/2000/svg' : null);
-                designItem._insertChildInternal(di);
-            }
-        }
-        else if (item.nodeType == 3) {
-            this._parseDiv.innerHTML = item.rawText;
-            let element = this._parseDiv.childNodes[0];
-            designItem = DesignItem.GetOrCreateDesignItem(element, item, serviceContainer, instanceServiceContainer);
-        }
-        else if (item.nodeType == 8) {
-            let element = document.createComment(item.rawText);
-            designItem = DesignItem.GetOrCreateDesignItem(element, item, serviceContainer, instanceServiceContainer);
-        }
-        return designItem;
-    }
-}

package/dist/elements/services/htmlParserService/NodeHtmlParserService.d.ts

@@ -1,11 +0,0 @@
-import { InstanceServiceContainer } from '../InstanceServiceContainer.js';
-import { ServiceContainer } from '../ServiceContainer.js';
-import { IHtmlParserService } from './IHtmlParserService.js';
-import { IDesignItem } from '../../item/IDesignItem.js';
-export declare class NodeHtmlParserService implements IHtmlParserService {
-    private _parserUrl;
-    constructor(parserUrl?: string);
-    parse(html: string, serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer, parseSnippet: boolean): Promise<IDesignItem[]>;
-    private _parseDiv;
-    _createDesignItemsRecursive(item: any, serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer, namespace: string, snippet: boolean): IDesignItem;
-}