@node-projects/web-component-designer 0.0.215 → 0.0.217

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

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

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

@@ -1,109 +1,109 @@
-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 {
-    _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, options, designItemsAssignmentList) {
-        for (const d of designItems) {
-            this.internalWrite(indentedTextWriter, d, options, designItemsAssignmentList);
-        }
-    }
-    internalWrite(indentedTextWriter, designItem, options, designItemsAssignmentList) {
-        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, options);
-            this.writeStyles(indentedTextWriter, designItem, options);
-            indentedTextWriter.write('>');
-            let contentSingleTextNode = false;
-            if (designItem.hasChildren) {
-                const children = designItem.children();
-                contentSingleTextNode = designItem.childCount === 1 && designItem.firstChild.nodeType === NodeType.TextNode;
-                if (contentSingleTextNode) {
-                    this.writeTextNode(indentedTextWriter, designItem, false);
-                }
-                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, options, designItemsAssignmentList);
-                        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 (designItemsAssignmentList) {
-            designItemsAssignmentList.set(designItem, { start: start, length: end - start });
-        }
-    }
-    writeTextNode(indentedTextWriter, designItem, indentAndNewline) {
-        let content = DomConverter.normalizeContentValue(designItem.content).trim();
-        if (content) {
-            if (indentAndNewline)
-                this._conditionalyWriteIndent(indentedTextWriter, designItem);
-            indentedTextWriter.write(content);
-            if (indentAndNewline)
-                this._conditionalyWriteNewline(indentedTextWriter, designItem);
-        }
-    }
-}
+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 {
+    _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, options, updatePositions = false) {
+        for (const d of designItems) {
+            this.internalWrite(indentedTextWriter, d, options, updatePositions);
+        }
+    }
+    internalWrite(indentedTextWriter, designItem, options, 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, options);
+            this.writeStyles(indentedTextWriter, designItem, options);
+            indentedTextWriter.write('>');
+            let contentSingleTextNode = false;
+            if (designItem.hasChildren) {
+                const children = designItem.children();
+                contentSingleTextNode = designItem.childCount === 1 && designItem.firstChild.nodeType === NodeType.TextNode;
+                if (contentSingleTextNode) {
+                    this.writeTextNode(indentedTextWriter, designItem, false);
+                }
+                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, options, 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) {
+        let content = DomConverter.normalizeContentValue(designItem.content).trim();
+        if (content) {
+            if (indentAndNewline)
+                this._conditionalyWriteIndent(indentedTextWriter, designItem);
+            indentedTextWriter.write(content);
+            if (indentAndNewline)
+                this._conditionalyWriteNewline(indentedTextWriter, designItem);
+        }
+    }
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,8 +1,8 @@
-//needs InternalBindinsgStorrageService -> keeps bindings
-export class LitTsElementWriterService {
-    write(indentedTextWriter, designItems, rootContainerKeepInline, options, designItemsAssignmentList) {
-        throw new Error('Method not implemented.');
-    }
+//needs InternalBindinsgStorrageService -> keeps bindings
+class LitTsElementWriterService {
+    write(indentedTextWriter, designItems, rootContainerKeepInline, options) {
+        throw new Error('Method not implemented.');
+    }
     static head = `import { html, css, LitElement, CSSResultArray } from 'lit';
 import { property, customElement } from 'lit/decorators.js';
 
@@ -39,5 +39,6 @@ declare global {
   interface HTMLElementTagNameMap {
     '$$elementName': $$className;
   }
-}`;
-}
+}`;
+}
+export { LitTsElementWriterService };

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

@@ -1,27 +1,25 @@
-import { IDesignItem } from '../../item/IDesignItem.js';
-import { IHtmlWriterService } from './IHtmlWriterService.js';
-import { IHtmlWriterOptions } from './IHtmlWriterOptions.js';
-import { IndentedTextWriter } from '../../helper/IndentedTextWriter.js';
-import { IStringPosition } from './IStringPosition.js';
-import { ElementDisplayType } from '../../helper/ElementHelper.js';
-export declare enum ElementContainerType {
-    block = 0,
-    complex = 1
-}
-export interface IWriteContext {
-    options: IHtmlWriterOptions;
-    indentedTextWriter: IndentedTextWriter;
-    lastElementDisplayType: ElementDisplayType | null;
-    containerDisplayType: ElementContainerType;
-    designItemsAssignmentList?: Map<IDesignItem, IStringPosition>;
-}
-export declare class SimpleHtmlWriterService implements IHtmlWriterService {
-    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, options: IHtmlWriterOptions, designItemsAssignmentList?: Map<IDesignItem, IStringPosition>): void;
-}
+import { IDesignItem } from '../../item/IDesignItem.js';
+import { IHtmlWriterService } from './IHtmlWriterService.js';
+import { IHtmlWriterOptions } from './IHtmlWriterOptions.js';
+import { IndentedTextWriter } from '../../helper/IndentedTextWriter.js';
+import { ElementDisplayType } from '../../helper/ElementHelper.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 {
+    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, options: IHtmlWriterOptions): void;
+}

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

@@ -1,93 +1,89 @@
-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';
-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(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);
-        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);
-    }
-}
+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';
+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(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);
+        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) {
+        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);
+    }
+    write(indentedTextWriter, designItems, rootContainerKeepInline, options) {
+        const context = { indentedTextWriter, options, lastElementDisplayType: null, containerDisplayType: ElementContainerType.block };
+        this._writeDesignItemList(ElementDisplayType.inline, context, designItems);
+    }
+}

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

@@ -1,4 +1,4 @@
-import { IDesignItem } from '../../item/IDesignItem.js';
-export interface IIntializationService {
-    init(designItem: IDesignItem): void;
-}
+import { IDesignItem } from '../../item/IDesignItem.js';
+export interface IIntializationService {
+    init(designItem: IDesignItem): void;
+}

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

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

package/dist/elements/services/instanceService/DefaultInstanceService.d.ts

@@ -1,8 +1,8 @@
-import { IInstanceService } from './IInstanceService.js';
-import { IElementDefinition } from '../elementsService/IElementDefinition.js';
-import type { ServiceContainer } from '../ServiceContainer.js';
-import type { InstanceServiceContainer } from '../InstanceServiceContainer.js';
-import { IDesignItem } from '../../item/IDesignItem.js';
-export declare class DefaultInstanceService implements IInstanceService {
-    getElement(definition: IElementDefinition, serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer): Promise<IDesignItem>;
-}
+import { IInstanceService } from './IInstanceService.js';
+import { IElementDefinition } from '../elementsService/IElementDefinition.js';
+import type { ServiceContainer } from '../ServiceContainer.js';
+import type { InstanceServiceContainer } from '../InstanceServiceContainer.js';
+import { IDesignItem } from '../../item/IDesignItem.js';
+export declare class DefaultInstanceService implements IInstanceService {
+    getElement(definition: IElementDefinition, serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer): Promise<IDesignItem>;
+}