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

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

@@ -1,89 +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 NodeHtmlParserService {
-    _parserUrl;
-    constructor(parserUrl = '../../../../../node-html-parser-esm/dist/index.js') {
-        this._parserUrl = parserUrl;
-    }
-    async parse(html, serviceContainer, instanceServiceContainer, parseSnippet) {
-        //@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, parseSnippet);
-            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, snippet) {
-        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);
-            if (!snippet && instanceServiceContainer.designItemDocumentPositionService)
-                instanceServiceContainer.designItemDocumentPositionService.setPosition(designItem, { start: item.range[0], length: item.range[1] - item.range[0] });
-            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;
-                    }
-                }
-            }
-            if (!designItem.lockAtDesignTime && element.style)
-                element.style.pointerEvents = 'auto';
-            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, snippet);
-                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);
-            if (!snippet && instanceServiceContainer.designItemDocumentPositionService)
-                instanceServiceContainer.designItemDocumentPositionService.setPosition(designItem, { start: item.range[0], length: item.range[1] - item.range[0] });
-        }
-        else if (item.nodeType == 8) {
-            let element = document.createComment(item.rawText);
-            designItem = DesignItem.GetOrCreateDesignItem(element, item, serviceContainer, instanceServiceContainer);
-            if (!snippet && instanceServiceContainer.designItemDocumentPositionService)
-                instanceServiceContainer.designItemDocumentPositionService.setPosition(designItem, { start: item.range[0], length: item.range[1] - item.range[0] });
-        }
-        return designItem;
-    }
-}

package/dist/elements/services/htmlParserService/VueParserService.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 VueParserService implements IHtmlParserService {
-    private htmlParser;
-    constructor(htmlParser: IHtmlParserService);
-    parse(code: string, serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer, parseSnippet: boolean): Promise<IDesignItem[]>;
-}

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

@@ -1,10 +0,0 @@
-export class VueParserService {
-    htmlParser;
-    constructor(htmlParser) {
-        this.htmlParser = htmlParser;
-    }
-    async parse(code, serviceContainer, instanceServiceContainer, parseSnippet) {
-        const parsed = await this.htmlParser.parse(code, serviceContainer, instanceServiceContainer, parseSnippet);
-        return [parsed.find(x => x.name == 'template')];
-    }
-}

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

@@ -1,11 +0,0 @@
-import { IDesignItem } from '../../item/IDesignItem.js';
-import { IHtmlWriterService } from './IHtmlWriterService.js';
-import { IHtmlWriterOptions } from './IHtmlWriterOptions.js';
-import { ITextWriter } from '../../helper/ITextWriter.js';
-export declare abstract class AbstractHtmlWriterService implements IHtmlWriterService {
-    options: IHtmlWriterOptions;
-    constructor(options?: IHtmlWriterOptions);
-    abstract write(indentedTextWriter: ITextWriter, designItems: IDesignItem[], rootContainerKeepInline: boolean, updatePositions?: boolean): any;
-    writeAttributes(indentedTextWriter: ITextWriter, designItem: IDesignItem): void;
-    writeStyles(indentedTextWriter: ITextWriter, designItem: IDesignItem): void;
-}

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

@@ -1,71 +0,0 @@
-import { DomConverter } from '../../widgets/designerView/DomConverter.js';
-import { CssCombiner } from '../../helper/CssCombiner.js';
-import { PropertiesHelper } from '../propertiesService/services/PropertiesHelper.js';
-export class AbstractHtmlWriterService {
-    options;
-    constructor(options) {
-        this.options = options ?? {};
-        this.options.beautifyOutput ??= true;
-        this.options.compressCssToShorthandProperties ??= true;
-        this.options.writeDesignerProperties ??= true;
-        this.options.parseJsonInAttributes ??= true;
-        this.options.jsonWriteMode ??= 'min';
-    }
-    writeAttributes(indentedTextWriter, designItem) {
-        if (designItem.hasAttributes) {
-            for (const a of designItem.attributes()) {
-                indentedTextWriter.write(' ');
-                if (typeof a[1] === 'string') {
-                    if (a[1] === "")
-                        indentedTextWriter.write(a[0]);
-                    else {
-                        if (this.options.parseJsonInAttributes &&
-                            ((a[1].startsWith('{') && !a[1].startsWith('{{') && a[1].endsWith('}')) ||
-                                (a[1].startsWith('[') && !a[1].startsWith('[[') && a[1].endsWith(']')))) {
-                            try {
-                                let j = JSON.parse(a[1]);
-                                let txt;
-                                if (this.options.jsonWriteMode == 'beauty')
-                                    txt = JSON.stringify(j, null, 2);
-                                else
-                                    txt = JSON.stringify(j);
-                                indentedTextWriter.write(a[0] + '=\'' + DomConverter.normalizeAttributeValue(txt, true) + '\'');
-                                continue;
-                            }
-                            catch { }
-                        }
-                        const content = DomConverter.normalizeAttributeValue(a[1]);
-                        if (content.indexOf('"')) {
-                            const contentSingle = DomConverter.normalizeAttributeValue(a[1], true);
-                            if (contentSingle.length < content.length)
-                                indentedTextWriter.write(a[0] + '=\'' + contentSingle + '\'');
-                            else
-                                indentedTextWriter.write(a[0] + '="' + content + '"');
-                        }
-                        else
-                            indentedTextWriter.write(a[0] + '="' + content + '"');
-                    }
-                }
-                else if (!a[1])
-                    indentedTextWriter.write(a[0]);
-                else {
-                    //TODO: writing of bindings, really ???
-                }
-            }
-        }
-    }
-    writeStyles(indentedTextWriter, designItem) {
-        if (designItem.hasStyles) {
-            indentedTextWriter.write(' style="');
-            let styles = designItem.styles();
-            if (this.options.compressCssToShorthandProperties)
-                styles = CssCombiner.combine(new Map(styles));
-            for (const s of styles) {
-                if (s[0]) {
-                    indentedTextWriter.write(PropertiesHelper.camelToDashCase(s[0]) + ':' + DomConverter.normalizeAttributeValue(s[1]) + ';');
-                }
-            }
-            indentedTextWriter.write('"');
-        }
-    }
-}

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

@@ -1,23 +0,0 @@
-import { IDesignItem } from '../../item/IDesignItem.js';
-import { IHtmlWriterService } from './IHtmlWriterService.js';
-import { IHtmlWriterOptions } from './IHtmlWriterOptions.js';
-import { IndentedTextWriter } from '../../helper/IndentedTextWriter.js';
-declare enum ElementContainerType {
-    block = 0,
-    complex = 1
-}
-export declare class FormatingHtmlWriterService implements IHtmlWriterService {
-    options: IHtmlWriterOptions;
-    constructor(options?: IHtmlWriterOptions);
-    private writeAttributes;
-    private writeStyles;
-    private _writeTextNode;
-    private _writeCommentNode;
-    private _writeElementNode;
-    private _writeDesignItemList;
-    private _writeNewlineAndIntend;
-    private _writeInternal;
-    getContainerType(element: HTMLElement): ElementContainerType;
-    write(indentedTextWriter: IndentedTextWriter, designItems: IDesignItem[], rootContainerKeepInline: boolean): void;
-}
-export {};

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

@@ -1,142 +0,0 @@
-import { DomConverter } from '../../widgets/designerView/DomConverter.js';
-import { CssCombiner } from '../../helper/CssCombiner.js';
-import { NodeType } from '../../item/NodeType.js';
-import { PropertiesHelper } from '../propertiesService/services/PropertiesHelper.js';
-import { ElementDisplayType, getElementDisplaytype } from '../../helper/ElementHelper.js';
-var ElementContainerType;
-(function (ElementContainerType) {
-    ElementContainerType[ElementContainerType["block"] = 0] = "block";
-    ElementContainerType[ElementContainerType["complex"] = 1] = "complex";
-})(ElementContainerType || (ElementContainerType = {}));
-// const defaultDisplayNoneContainerDisplayType: ElementContainerType = ElementContainerType.complex;
-export class FormatingHtmlWriterService {
-    options;
-    constructor(options) {
-        this.options = options ?? {};
-        this.options.beautifyOutput ??= true;
-        this.options.compressCssToShorthandProperties ??= true;
-        this.options.writeDesignerProperties ??= true;
-        this.options.parseJsonInAttributes ??= true;
-        this.options.jsonWriteMode ??= 'min';
-    }
-    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(new Map(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).trim();
-        if (content) {
-            writeContext.indentedTextWriter.write(content);
-        }
-    }
-    _writeCommentNode(writeContext, designItem) {
-        writeContext.indentedTextWriter.write('<!--' + designItem.content + '-->');
-    }
-    _writeElementNode(writeContext, designItem) {
-        //    const cs = getComputedStyle(designItem.element);
-        //cs.whiteSpace === 'pre'
-        //isInPre
-        //is in inline?
-        const currentElementDisplayType = getElementDisplaytype(designItem.element);
-        writeContext.lastElementDisplayType = currentElementDisplayType;
-        writeContext.indentedTextWriter.write('<' + designItem.name);
-        this.writeAttributes(writeContext, designItem);
-        this.writeStyles(writeContext, designItem);
-        writeContext.indentedTextWriter.write('>');
-        let contentSingleTextNode = false;
-        if (designItem.hasChildren) {
-            const children = designItem.children();
-            contentSingleTextNode = designItem.childCount === 1 && designItem.firstChild.nodeType === NodeType.TextNode;
-            if (contentSingleTextNode) {
-                this._writeInternal(writeContext, designItem.firstChild);
-            }
-            else {
-                let previousContainerDisplayType = writeContext.containerDisplayType;
-                writeContext.containerDisplayType = this.getContainerType(designItem.element);
-                writeContext.indentedTextWriter.levelRaise();
-                this._writeDesignItemList(currentElementDisplayType, writeContext, children);
-                writeContext.indentedTextWriter.levelShrink();
-                writeContext.containerDisplayType = previousContainerDisplayType;
-            }
-        }
-        else if (designItem.hasContent) {
-            writeContext.indentedTextWriter.write(DomConverter.normalizeContentValue(designItem.content));
-        }
-        if (!DomConverter.IsSelfClosingElement(designItem.name)) {
-            if (currentElementDisplayType === ElementDisplayType.block && designItem.hasChildren && !contentSingleTextNode) {
-                this._writeNewlineAndIntend(writeContext);
-            }
-            //write newline & intend ???
-            writeContext.indentedTextWriter.write('</' + designItem.name + '>');
-            if (currentElementDisplayType !== ElementDisplayType.none) {
-                writeContext.lastElementDisplayType = currentElementDisplayType;
-            }
-        }
-    }
-    _writeDesignItemList(currentElementDisplayType, writeContext, children) {
-        for (const c of children) {
-            if (writeContext.lastElementDisplayType == null) {
-                //first entry, do nothing
-            }
-            else if (writeContext.containerDisplayType === ElementContainerType.complex)
-                this._writeNewlineAndIntend(writeContext);
-            else if (writeContext.lastElementDisplayType !== ElementDisplayType.inline /*|| currentElementDisplayType !== ElementDisplayType.inline*/)
-                this._writeNewlineAndIntend(writeContext);
-            this._writeInternal(writeContext, c);
-        }
-    }
-    _writeNewlineAndIntend(writeContext) {
-        writeContext.indentedTextWriter.writeNewline();
-        writeContext.indentedTextWriter.writeIndent();
-    }
-    _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 });
-        }
-    }
-    getContainerType(element) {
-        const display = window.getComputedStyle(element).display;
-        if (display === 'block' || display === "inline-block" || display == '')
-            return ElementContainerType.block;
-        return ElementContainerType.complex;
-    }
-    write(indentedTextWriter, designItems, rootContainerKeepInline) {
-        const context = { indentedTextWriter, options: this.options, lastElementDisplayType: null, containerDisplayType: ElementContainerType.block };
-        this._writeDesignItemList(ElementDisplayType.inline, context, designItems);
-    }
-}

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

@@ -1,7 +0,0 @@
-export declare class HtmlWriterOptions {
-    beautifyOutput: boolean;
-    compressCssToShorthandProperties: boolean;
-    writeDesignerProperties: boolean;
-    parseJsonInAttributes: boolean;
-    jsonWriteMode: 'min' | 'beauty';
-}

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

@@ -1,7 +0,0 @@
-export class HtmlWriterOptions {
-    beautifyOutput = true;
-    compressCssToShorthandProperties = true;
-    writeDesignerProperties = true;
-    parseJsonInAttributes = true;
-    jsonWriteMode = 'min';
-}

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

@@ -1,13 +0,0 @@
-import { IDesignItem } from '../../item/IDesignItem.js';
-import { IndentedTextWriter } from '../../helper/IndentedTextWriter.js';
-import { AbstractHtmlWriterService } from './AbstractHtmlWriterService.js';
-import { IHtmlWriterOptions } from './IHtmlWriterOptions.js';
-export declare class HtmlWriterService extends AbstractHtmlWriterService {
-    constructor(options?: IHtmlWriterOptions);
-    private _conditionalyWriteIndent;
-    private _conditionalyWriteIndentBefore;
-    private _conditionalyWriteNewline;
-    write(indentedTextWriter: IndentedTextWriter, designItems: IDesignItem[], rootContainerKeepInline: boolean, updatePositions?: boolean): void;
-    private internalWrite;
-    private writeTextNode;
-}

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

@@ -1,116 +0,0 @@
-import { DomConverter } from '../../widgets/designerView/DomConverter.js';
-import { NodeType } from '../../item/NodeType.js';
-import { isEmptyTextNode, isInline, isInlineAfter } from '../../helper/ElementHelper.js';
-import { AbstractHtmlWriterService } from './AbstractHtmlWriterService.js';
-export class HtmlWriterService extends AbstractHtmlWriterService {
-    constructor(options) {
-        super(options);
-    }
-    _conditionalyWriteIndent(indentedTextWriter, designItem) {
-        if ((designItem.element instanceof HTMLElement && !isInlineAfter(designItem.element)) ||
-            (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))) ||
-            (designItem.element instanceof SVGElement))
-            indentedTextWriter.writeIndent();
-    }
-    _conditionalyWriteIndentBefore(indentedTextWriter, designItem) {
-        if ((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))) ||
-            (designItem.element instanceof SVGElement))
-            indentedTextWriter.writeIndent();
-    }
-    _conditionalyWriteNewline(indentedTextWriter, designItem) {
-        if ((designItem.element instanceof HTMLElement && !isInlineAfter(designItem.element)) ||
-            (designItem.element.nextElementSibling instanceof HTMLElement && !isInline(designItem.element.nextElementSibling)) ||
-            (designItem.element instanceof SVGElement))
-            indentedTextWriter.writeNewline();
-    }
-    write(indentedTextWriter, designItems, rootContainerKeepInline, updatePositions = false) {
-        for (const d of designItems) {
-            this.internalWrite(indentedTextWriter, d, updatePositions);
-        }
-    }
-    //todo special case for style/script nodes, keep whitespace
-    internalWrite(indentedTextWriter, designItem, updatePositions) {
-        let start = indentedTextWriter.position;
-        let end = indentedTextWriter.position;
-        if (designItem.nodeType == NodeType.TextNode) {
-            if (isEmptyTextNode(designItem.element) &&
-                ((designItem.element.previousSibling instanceof HTMLElement && !isInlineAfter(designItem.element.previousSibling)) ||
-                    (designItem.element.nextSibling instanceof HTMLElement && !isInline(designItem.element.nextSibling)))) {
-            }
-            else
-                this.writeTextNode(indentedTextWriter, designItem, true);
-            end = indentedTextWriter.position;
-        }
-        else if (designItem.nodeType == NodeType.Comment) {
-            this._conditionalyWriteIndent(indentedTextWriter, designItem);
-            start = indentedTextWriter.position;
-            indentedTextWriter.write('<!--' + designItem.content + '-->');
-            end = indentedTextWriter.position;
-            this._conditionalyWriteNewline(indentedTextWriter, designItem);
-        }
-        else {
-            this._conditionalyWriteIndentBefore(indentedTextWriter, designItem);
-            start = indentedTextWriter.position;
-            indentedTextWriter.write('<' + designItem.name);
-            this.writeAttributes(indentedTextWriter, designItem);
-            this.writeStyles(indentedTextWriter, designItem);
-            indentedTextWriter.write('>');
-            let contentSingleTextNode = false;
-            if (designItem.hasChildren) {
-                const children = designItem.children();
-                contentSingleTextNode = designItem.childCount === 1 && designItem.firstChild.nodeType === NodeType.TextNode;
-                if (contentSingleTextNode) {
-                    const notrim = designItem.name == 'script' || designItem.name == 'style' || designItem.name == 'pre';
-                    this.writeTextNode(indentedTextWriter, designItem, false, !notrim);
-                }
-                else {
-                    if (designItem.element instanceof HTMLElement && !isInlineAfter(designItem.element) || (designItem.element instanceof SVGElement)) {
-                        indentedTextWriter.writeNewline();
-                        indentedTextWriter.levelRaise();
-                    }
-                    for (const c of children) {
-                        this.internalWrite(indentedTextWriter, c, updatePositions);
-                        let childSingleTextNode = c.childCount === 1 && c.firstChild.nodeType === NodeType.TextNode;
-                        if (childSingleTextNode)
-                            if (!indentedTextWriter.isLastCharNewline())
-                                this._conditionalyWriteNewline(indentedTextWriter, c);
-                    }
-                    if (designItem.element instanceof HTMLElement && !isInlineAfter(designItem.element) || (designItem.element instanceof SVGElement)) {
-                        indentedTextWriter.levelShrink();
-                        if (!indentedTextWriter.isLastCharNewline())
-                            indentedTextWriter.writeNewline();
-                        indentedTextWriter.writeIndent();
-                    }
-                }
-            }
-            else if (designItem.hasContent) {
-                indentedTextWriter.write(DomConverter.normalizeContentValue(designItem.content));
-                //this._conditionalyWriteNewline(indentedTextWriter, designItem);
-            }
-            end = indentedTextWriter.position;
-            if (!DomConverter.IsSelfClosingElement(designItem.name))
-                indentedTextWriter.write('</' + designItem.name + '>');
-            end = indentedTextWriter.position;
-            //if (!contentSingleTextNode)
-            if (!indentedTextWriter.isLastCharNewline() && (!designItem.parent || !isInlineAfter(designItem.parent.element)))
-                this._conditionalyWriteNewline(indentedTextWriter, designItem);
-        }
-        if (updatePositions && designItem.instanceServiceContainer.designItemDocumentPositionService) {
-            designItem.instanceServiceContainer.designItemDocumentPositionService.setPosition(designItem, { start: start, length: end - start });
-        }
-    }
-    writeTextNode(indentedTextWriter, designItem, indentAndNewline, trim = true) {
-        let content = DomConverter.normalizeContentValue(designItem.content);
-        if (trim)
-            content = content.trim();
-        if (content) {
-            if (indentAndNewline)
-                this._conditionalyWriteIndent(indentedTextWriter, designItem);
-            indentedTextWriter.write(content);
-            if (indentAndNewline)
-                this._conditionalyWriteNewline(indentedTextWriter, designItem);
-        }
-    }
-}

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

@@ -1,7 +0,0 @@
-export interface IHtmlWriterOptions {
-    beautifyOutput?: boolean;
-    compressCssToShorthandProperties?: boolean;
-    writeDesignerProperties?: boolean;
-    parseJsonInAttributes?: boolean;
-    jsonWriteMode?: 'min' | 'beauty';
-}

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

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

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

@@ -1,7 +0,0 @@
-import { IDesignItem } from '../../item/IDesignItem.js';
-import { ITextWriter } from '../../helper/ITextWriter.js';
-import { IHtmlWriterOptions } from './IHtmlWriterOptions.js';
-export interface IHtmlWriterService {
-    options: IHtmlWriterOptions;
-    write(textWriter: ITextWriter, designItems: IDesignItem[], rootContainerKeepInline: boolean, updatePositions?: boolean): any;
-}

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

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

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

@@ -1,4 +0,0 @@
-export interface IStringPosition {
-    start: number;
-    length: number;
-}

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

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

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

@@ -1,10 +0,0 @@
-import { IDesignItem } from '../../item/IDesignItem.js';
-import { IHtmlWriterService } from './IHtmlWriterService.js';
-import { IndentedTextWriter } from '../../helper/IndentedTextWriter.js';
-import { IHtmlWriterOptions } from './IHtmlWriterOptions.js';
-export declare class LitTsElementWriterService implements IHtmlWriterService {
-    options: IHtmlWriterOptions;
-    constructor(options?: IHtmlWriterOptions);
-    write(indentedTextWriter: IndentedTextWriter, designItems: IDesignItem[], rootContainerKeepInline: boolean): void;
-    static head: string;
-}

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

@@ -1,52 +0,0 @@
-//needs InternalBindinsgStorrageService -> keeps bindings
-export class LitTsElementWriterService {
-    options;
-    constructor(options) {
-        this.options = options ?? {};
-        this.options.beautifyOutput ??= true;
-        this.options.compressCssToShorthandProperties ??= true;
-        this.options.writeDesignerProperties ??= true;
-        this.options.parseJsonInAttributes ??= true;
-        this.options.jsonWriteMode ??= 'min';
-    }
-    write(indentedTextWriter, designItems, rootContainerKeepInline) {
-        throw new Error('Method not implemented.');
-    }
-    static head = `import { html, css, LitElement, CSSResultArray } from 'lit';
-import { property, customElement } from 'lit/decorators.js';
-
-@customElement('$$elementName')
-class $$className extends LitElement {
-  static get styles(): CSSResultArray {
-    return [
-      css\`
-$$css
-      \`,
-    ];
-  }
-
-  //@property({ type: String }) btnStyle: QingButtonStyle = '';
-  //@property({ type: Boolean, reflect: true }) selected = false;
-
-  //private buttonElement: HTMLButtonElement | null = null;
-
-  /*firstUpdated() {
-    if (!this.shadowRoot) {
-      throw new Error('Unexpected undefined shadowRoot');
-    }
-    this.buttonElement = this.shadowRoot.querySelector('button');
-  }*/
-
-  render() {
-    return html\`$$html\`;
-  }
-}
-
-export default $$className;
-
-declare global {
-  interface HTMLElementTagNameMap {
-    '$$elementName': $$className;
-  }
-}`;
-}

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

@@ -1,27 +0,0 @@
-import { IDesignItem } from '../../item/IDesignItem.js';
-import { IHtmlWriterService } from './IHtmlWriterService.js';
-import { IndentedTextWriter } from '../../helper/IndentedTextWriter.js';
-import { ElementDisplayType } from '../../helper/ElementHelper.js';
-import { IHtmlWriterOptions } from './IHtmlWriterOptions.js';
-export declare enum ElementContainerType {
-    block = 0,
-    complex = 1
-}
-export interface IWriteContext {
-    options: IHtmlWriterOptions;
-    indentedTextWriter: IndentedTextWriter;
-    lastElementDisplayType: ElementDisplayType | null;
-    containerDisplayType: ElementContainerType;
-}
-export declare class SimpleHtmlWriterService implements IHtmlWriterService {
-    options: IHtmlWriterOptions;
-    constructor(options?: IHtmlWriterOptions);
-    protected writeAttributes(writeContext: IWriteContext, designItem: IDesignItem): void;
-    protected writeStyles(writeContext: IWriteContext, designItem: IDesignItem): void;
-    private _writeTextNode;
-    private _writeCommentNode;
-    private _writeElementNode;
-    private _writeDesignItemList;
-    private _writeInternal;
-    write(indentedTextWriter: IndentedTextWriter, designItems: IDesignItem[], rootContainerKeepInline: boolean): void;
-}