@node-projects/web-component-designer 0.0.256 → 0.0.258

package/dist/elements/item/IDesignItem.d.ts

@@ -52,8 +52,8 @@ export interface IDesignItem {
     getOrCreateDesignItem(node: Node): any;
     openGroup(title: string): ChangeGroup;
     styles(): Iterable<[name: string, value: string]>;
-    getStyle(name: string): any;
-    hasStyle(name: string): any;
+    getStyle(name: string): string;
+    hasStyle(name: string): boolean;
     setStyle(name: string, value?: string | null, important?: boolean): any;
     removeStyle(name: string): any;
     updateStyleInSheetOrLocal(name: string, value?: string | null, important?: boolean): any;
@@ -61,8 +61,8 @@ export interface IDesignItem {
     getStyleFromSheetOrLocalOrComputed(name: string, fallback?: string): any;
     getAllStyles(): IStyleRule[];
     attributes(): Iterable<[name: string, value: string]>;
-    getAttribute(name: string): any;
-    hasAttribute(name: string): any;
+    getAttribute(name: string): string;
+    hasAttribute(name: string): boolean;
     setAttribute(name: string, value?: string | null): any;
     removeAttribute(name: string): any;
     hideAtDesignTime: boolean;

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

@@ -3,7 +3,9 @@ import { IHtmlWriterService } from './IHtmlWriterService.js';
 import { IHtmlWriterOptions } from './IHtmlWriterOptions.js';
 import { ITextWriter } from '../../helper/ITextWriter.js';
 export declare abstract class AbstractHtmlWriterService implements IHtmlWriterService {
-    abstract write(indentedTextWriter: ITextWriter, designItems: IDesignItem[], rootContainerKeepInline: boolean, options: IHtmlWriterOptions, updatePositions?: boolean): any;
-    writeAttributes(indentedTextWriter: ITextWriter, designItem: IDesignItem, options: IHtmlWriterOptions): void;
-    writeStyles(indentedTextWriter: ITextWriter, designItem: IDesignItem, options: IHtmlWriterOptions): void;
+    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

@@ -2,7 +2,16 @@ import { DomConverter } from '../../widgets/designerView/DomConverter.js';
 import { CssCombiner } from '../../helper/CssCombiner.js';
 import { PropertiesHelper } from '../propertiesService/services/PropertiesHelper.js';
 export class AbstractHtmlWriterService {
-    writeAttributes(indentedTextWriter, designItem, options) {
+    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(' ');
@@ -10,13 +19,13 @@ export class AbstractHtmlWriterService {
                     if (a[1] === "")
                         indentedTextWriter.write(a[0]);
                     else {
-                        if (options.parseJsonInAttributes &&
+                        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 (options.jsonWriteMode == 'beauty')
+                                if (this.options.jsonWriteMode == 'beauty')
                                     txt = JSON.stringify(j, null, 2);
                                 else
                                     txt = JSON.stringify(j);
@@ -45,11 +54,11 @@ export class AbstractHtmlWriterService {
             }
         }
     }
-    writeStyles(indentedTextWriter, designItem, options) {
+    writeStyles(indentedTextWriter, designItem) {
         if (designItem.hasStyles) {
             indentedTextWriter.write(' style="');
             let styles = designItem.styles();
-            if (options.compressCssToShorthandProperties)
+            if (this.options.compressCssToShorthandProperties)
                 styles = CssCombiner.combine(new Map(styles));
             for (const s of styles) {
                 if (s[0]) {

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

@@ -7,6 +7,8 @@ declare enum ElementContainerType {
     complex = 1
 }
 export declare class FormatingHtmlWriterService implements IHtmlWriterService {
+    options: IHtmlWriterOptions;
+    constructor(options?: IHtmlWriterOptions);
     private writeAttributes;
     private writeStyles;
     private _writeTextNode;
@@ -16,6 +18,6 @@ export declare class FormatingHtmlWriterService implements IHtmlWriterService {
     private _writeNewlineAndIntend;
     private _writeInternal;
     getContainerType(element: HTMLElement): ElementContainerType;
-    write(indentedTextWriter: IndentedTextWriter, designItems: IDesignItem[], rootContainerKeepInline: boolean, options: IHtmlWriterOptions): void;
+    write(indentedTextWriter: IndentedTextWriter, designItems: IDesignItem[], rootContainerKeepInline: boolean): void;
 }
 export {};

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

@@ -10,6 +10,15 @@ var ElementContainerType;
 })(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()) {
@@ -126,8 +135,8 @@ export class FormatingHtmlWriterService {
             return ElementContainerType.block;
         return ElementContainerType.complex;
     }
-    write(indentedTextWriter, designItems, rootContainerKeepInline, options) {
-        const context = { indentedTextWriter, options, lastElementDisplayType: null, containerDisplayType: ElementContainerType.block };
+    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

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

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

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

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

@@ -1,12 +1,13 @@
 import { IDesignItem } from '../../item/IDesignItem.js';
-import { IHtmlWriterOptions } from './IHtmlWriterOptions.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, options: IHtmlWriterOptions, updatePositions?: boolean): void;
+    write(indentedTextWriter: IndentedTextWriter, designItems: IDesignItem[], rootContainerKeepInline: boolean, updatePositions?: boolean): void;
     private internalWrite;
     private writeTextNode;
 }

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

@@ -3,6 +3,9 @@ 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)) ||
@@ -22,12 +25,12 @@ export class HtmlWriterService extends AbstractHtmlWriterService {
             (designItem.element instanceof SVGElement))
             indentedTextWriter.writeNewline();
     }
-    write(indentedTextWriter, designItems, rootContainerKeepInline, options, updatePositions = false) {
+    write(indentedTextWriter, designItems, rootContainerKeepInline, updatePositions = false) {
         for (const d of designItems) {
-            this.internalWrite(indentedTextWriter, d, options, updatePositions);
+            this.internalWrite(indentedTextWriter, d, updatePositions);
         }
     }
-    internalWrite(indentedTextWriter, designItem, options, updatePositions) {
+    internalWrite(indentedTextWriter, designItem, updatePositions) {
         let start = indentedTextWriter.position;
         let end = indentedTextWriter.position;
         if (designItem.nodeType == NodeType.TextNode) {
@@ -50,8 +53,8 @@ export class HtmlWriterService extends AbstractHtmlWriterService {
             this._conditionalyWriteIndentBefore(indentedTextWriter, designItem);
             start = indentedTextWriter.position;
             indentedTextWriter.write('<' + designItem.name);
-            this.writeAttributes(indentedTextWriter, designItem, options);
-            this.writeStyles(indentedTextWriter, designItem, options);
+            this.writeAttributes(indentedTextWriter, designItem);
+            this.writeStyles(indentedTextWriter, designItem);
             indentedTextWriter.write('>');
             let contentSingleTextNode = false;
             if (designItem.hasChildren) {
@@ -66,7 +69,7 @@ export class HtmlWriterService extends AbstractHtmlWriterService {
                         indentedTextWriter.levelRaise();
                     }
                     for (const c of children) {
-                        this.internalWrite(indentedTextWriter, c, options, updatePositions);
+                        this.internalWrite(indentedTextWriter, c, updatePositions);
                         let childSingleTextNode = c.childCount === 1 && c.firstChild.nodeType === NodeType.TextNode;
                         if (childSingleTextNode)
                             if (!indentedTextWriter.isLastCharNewline())

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 interface IHtmlWriterOptions {
+    beautifyOutput?: boolean;
+    compressCssToShorthandProperties?: boolean;
+    writeDesignerProperties?: boolean;
+    parseJsonInAttributes?: boolean;
+    jsonWriteMode?: 'min' | 'beauty';
 }

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

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

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

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

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

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

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

@@ -1,6 +1,15 @@
 //needs InternalBindinsgStorrageService -> keeps bindings
 export class LitTsElementWriterService {
-    write(indentedTextWriter, designItems, rootContainerKeepInline, options) {
+    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';

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

@@ -1,8 +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 { ElementDisplayType } from '../../helper/ElementHelper.js';
+import { IHtmlWriterOptions } from './IHtmlWriterOptions.js';
 export declare enum ElementContainerType {
     block = 0,
     complex = 1
@@ -14,6 +14,8 @@ export interface IWriteContext {
     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;
@@ -21,5 +23,5 @@ export declare class SimpleHtmlWriterService implements IHtmlWriterService {
     private _writeElementNode;
     private _writeDesignItemList;
     private _writeInternal;
-    write(indentedTextWriter: IndentedTextWriter, designItems: IDesignItem[], rootContainerKeepInline: boolean, options: IHtmlWriterOptions): void;
+    write(indentedTextWriter: IndentedTextWriter, designItems: IDesignItem[], rootContainerKeepInline: boolean): void;
 }

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

@@ -9,6 +9,15 @@ export var ElementContainerType;
     ElementContainerType[ElementContainerType["complex"] = 1] = "complex";
 })(ElementContainerType || (ElementContainerType = {}));
 export class SimpleHtmlWriterService {
+    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()) {
@@ -82,8 +91,8 @@ export class SimpleHtmlWriterService {
         else if (designItem.nodeType === NodeType.Element)
             this._writeElementNode(writeContext, designItem);
     }
-    write(indentedTextWriter, designItems, rootContainerKeepInline, options) {
-        const context = { indentedTextWriter, options, lastElementDisplayType: null, containerDisplayType: ElementContainerType.block };
+    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/propertiesService/services/AbstractPropertiesService.d.ts

@@ -15,7 +15,7 @@ export declare abstract class AbstractPropertiesService implements IPropertiesSe
     getPropertyTarget(designItem: IDesignItem, property: IProperty): BindingTarget;
     clearValue(designItems: IDesignItem[], property: IProperty): void;
     isSet(designItems: IDesignItem[], property: IProperty): ValueType;
-    getValue(designItems: IDesignItem[], property: IProperty): any;
+    getValue(designItems: IDesignItem[], property: IProperty): string | boolean;
     getBinding(designItems: IDesignItem[], property: IProperty): IBinding;
     getUnsetValue(designItems: IDesignItem[], property: IProperty): any;
 }

package/dist/elements/services/propertiesService/services/AttributesPropertiesService.d.ts

@@ -14,7 +14,7 @@ export declare class AttributesPropertiesService implements IPropertiesService {
     getPropertyTarget(designItem: IDesignItem, property: IProperty): BindingTarget;
     clearValue(designItems: IDesignItem[], property: IProperty): void;
     isSet(designItems: IDesignItem[], property: IProperty): ValueType;
-    getValue(designItems: IDesignItem[], property: IProperty): any;
+    getValue(designItems: IDesignItem[], property: IProperty): string;
     getBinding(designItems: IDesignItem[], property: IProperty): IBinding;
     getUnsetValue(designItems: IDesignItem[], property: IProperty): any;
 }

package/dist/elements/services/propertiesService/services/CssCurrentPropertiesService.d.ts

@@ -22,7 +22,7 @@ export declare class CssCurrentPropertiesService extends CommonPropertiesService
     getValue(designItems: IDesignItem[], property: IProperty & {
         styleRule: IStyleRule;
         styleDeclaration: IStyleDeclaration;
-    }): any;
+    }): string | boolean;
     getUnsetValue(designItems: IDesignItem[], property: IProperty & {
         styleRule: IStyleRule;
         styleDeclaration: IStyleDeclaration;

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

@@ -35,8 +35,9 @@ export class DomConverter {
     }
     static ConvertToString(designItems, beautifyOutput, updatePositions = false) {
         let itw = beautifyOutput !== false ? new IndentedTextWriter() : new SimpleTextWriter();
-        let options = { beautifyOutput: beautifyOutput !== false, writeDesignerProperties: true, compressCssToShorthandProperties: true, parseJsonInAttributes: true, jsonWriteMode: 'beauty' };
-        designItems[0].serviceContainer.htmlWriterService.write(itw, designItems, true, options, updatePositions);
+        //todo: check how we could support this beautify here, cause it's now a setting of the writer...
+        //let options: HtmlWriterOptions = { beautifyOutput: beautifyOutput !== false, writeDesignerProperties: true, compressCssToShorthandProperties: true, parseJsonInAttributes: true, jsonWriteMode: 'beauty' };
+        designItems[0].serviceContainer.htmlWriterService.write(itw, designItems, true, updatePositions);
         return itw.getString();
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "description": "A UI designer for Polymer apps",
   "name": "@node-projects/web-component-designer",
-  "version": "0.0.256",
+  "version": "0.0.258",
   "type": "module",
   "main": "./dist/index.js",
   "author": "",