@node-projects/web-component-designer 0.0.135 → 0.0.137

package/config/elements-native.json

@@ -3,6 +3,8 @@
   [
     "div",
     "input",
+    "textarea",
+    "select",
     {"tag" : "button", "defaultWidth": "80px", "defaultHeight": "30px", "defaultContent": "Button" },
     "img",
     "iframe",

package/dist/elements/controls/MetricsEditor.d.ts

@@ -0,0 +1,14 @@
+import { BaseCustomWebComponentConstructorAppend } from '@node-projects/base-custom-webcomponent';
+export declare type ThicknessEditorValueChangedEventArgs = {
+    newValue?: string;
+    oldValue?: string;
+};
+export declare class MetricsEditor extends BaseCustomWebComponentConstructorAppend {
+    static readonly style: CSSStyleSheet;
+    static readonly template: HTMLTemplateElement;
+    property: string;
+    unsetValue: string;
+    _updateValue(): void;
+    ready(): void;
+    onDoubleClick(event: PointerEvent): void;
+}

package/dist/elements/controls/MetricsEditor.js

@@ -0,0 +1,120 @@
+import { BaseCustomWebComponentConstructorAppend, css, html } from '@node-projects/base-custom-webcomponent';
+export class MetricsEditor extends BaseCustomWebComponentConstructorAppend {
+    static style = css `
+:host {
+  justify-content: center;
+  display: flex;
+  margin: 10px;
+  line-height: 12px;
+}
+
+* { 
+  font-size: 12px;
+  font-family: monospace;
+  color: black;
+}
+
+.top {
+  display: inline-block;
+}
+.left {
+  display: inline-block;
+  vertical-align: middle;
+}
+.right {
+  display: inline-block;
+  vertical-align: middle;
+}
+.bottom {
+  display: inline-block;
+}
+
+div.ct {
+  width:280px;height:180px;
+}
+
+div span {
+  font-size: 10px;
+  position: absolute;
+  top: 0;
+  left: 0; 
+}
+
+div.ct {
+  position: relative;
+  background: white;
+  display: inline-block;
+  border: dotted 1px gray;
+  text-align: center;
+  vertical-align: middle;
+}
+
+div.ct > div.ct {
+  left: 0;
+  top: 0;
+  background: #F9CC9F;
+  width: calc(100% - 20px);
+  height: calc(100% - 26px);
+  border-style: dashed;
+}
+
+div.ct > div.ct > div.ct {
+  background: #FEDC9B;
+  border-style: solid;
+}
+
+div.ct > div.ct > div.ct > div.ct {
+  background: #C4Cf8C;
+  border-style: dashed;
+}
+
+div.ct > div.ct > div.ct > div.ct > div.ct {
+  background: #8Cb6C2;
+  border-style: solid;
+  display: inline-flex;
+  justify-content: center;
+  align-items: center;
+}`;
+    static template = html `
+  <div class="ct"><span>position</span>
+  <div class="top">-</div><br><div class="left">-</div><div class="ct"><span>margin</span>
+  <div id="testdiv" [contentEditable]="contentEditable"  @dblclick="onDoubleClick" class="top">-</div><br><div class="left">-</div><div class="ct"><span>border</span>
+  <div class="top">-</div><br><div class="left">-</div><div class="ct"><span>padding</span>
+  <div class="top">-</div><br><div class="left">-</div><div class="ct" style="font-size:6px"><div class="left">-</div>
+  x
+  <div class="right">-</div>
+  </div><div class="right">-</div><br><div class="bottom">-</div></div><div class="right">-</div><br><div class="bottom">-</div></div><div class="right">-</div><br><div class="bottom">-</div></div><div class="right">-</div><br><div class="bottom">-</div></div>
+  `;
+    property;
+    unsetValue;
+    //private _root: HTMLDivElement;
+    //private _contentEditable: HTMLDivElement;
+    _updateValue() {
+    }
+    ready() {
+        //this._root = this._getDomElement<HTMLDivElement>("testdiv");
+        this._parseAttributesToProperties();
+        this._updateValue();
+        this._assignEvents();
+    }
+    onDoubleClick(event) {
+        let element = this._getDomElement("testdiv");
+        // contentEditable setzten
+        element.setAttribute("contentEditable", "");
+        // - rausnehmen
+        element.innerHTML = "-";
+        // Input auswerten
+        //Input in div schreiben
+        // contentEditable false setzen mit EnterTaste
+        element.onkeydown = (e) => {
+            if (e.key == "Enter") {
+                let _input = element.innerHTML;
+                //let value = document.createElement("input");
+                element.style.marginTop = _input;
+                element.removeAttribute("contentEditable");
+                element.innerHTML = "-";
+            }
+        };
+    }
+}
+customElements.define('node-projects-metrics-editor', MetricsEditor);

package/dist/elements/controls/ThicknessEditor copy.d.ts

@@ -0,0 +1,33 @@
+import { BaseCustomWebComponentConstructorAppend, TypedEvent } from '@node-projects/base-custom-webcomponent';
+export declare type ThicknessEditorValueChangedEventArgs = {
+    newValue?: string;
+    oldValue?: string;
+};
+export declare class ThicknessEditor extends BaseCustomWebComponentConstructorAppend {
+    static readonly style: CSSStyleSheet;
+    static readonly template: HTMLTemplateElement;
+    private _leftInput;
+    private _topInput;
+    private _rightInput;
+    private _bottomInput;
+    private _valueLeft;
+    get valueLeft(): string;
+    set valueLeft(value: string);
+    valueLeftChanged: TypedEvent<ThicknessEditorValueChangedEventArgs>;
+    private _valueTop;
+    get valueTop(): string;
+    set valueTop(value: string);
+    valueTopChanged: TypedEvent<ThicknessEditorValueChangedEventArgs>;
+    private _valueRight;
+    get valueRight(): string;
+    set valueRight(value: string);
+    valueRightChanged: TypedEvent<ThicknessEditorValueChangedEventArgs>;
+    private _valueBottom;
+    get valueBottom(): string;
+    set valueBottom(value: string);
+    valueBottomChanged: TypedEvent<ThicknessEditorValueChangedEventArgs>;
+    property: string;
+    unsetValue: string;
+    _updateValue(): void;
+    ready(): void;
+}

package/dist/elements/controls/ThicknessEditor copy.js

@@ -0,0 +1,145 @@
+import { BaseCustomWebComponentConstructorAppend, css, html, TypedEvent } from '@node-projects/base-custom-webcomponent';
+export class ThicknessEditor extends BaseCustomWebComponentConstructorAppend {
+    static style = css `
+  :host {
+    margin: 4px;
+    margin-left: auto;
+    margin-right: auto;
+  }
+  #container {
+    display: grid;
+    grid-template-columns: minmax(30px, 40px) minmax(30px, 60px) minmax(30px, 40px);
+    grid-template-rows: auto;
+    grid-template-areas: 
+          "  .   top     ."
+          "left middle right"
+          "  .  bottom   .";
+    column-gap: 2px;
+    row-gap: 2px;
+  }
+  input {
+    width: 20px;
+    text-align: center;
+    font-size: 10px;
+    height: 20px;
+    padding: 0;
+  }
+  #left {
+    grid-area: left;
+    justify-self: end;
+  }
+  #top {
+    grid-area: top;
+    align-self: end;
+    justify-self: center;
+  }
+  #right {
+    grid-area: right;
+    justify-self: start;
+  }
+  #bottom {
+    grid-area: bottom;
+    align-self: start;
+    justify-self: center;
+  }
+  #rect {
+    grid-area: middle;
+    border: 1px solid black;
+    background: lightgray;
+  }
+  `;
+    static template = html `
+    <div id="container">
+      <input id="left">
+      <input id="top">
+      <input id="right">
+      <input id="bottom">
+      <div id="rect"></div>
+    </div>
+  `;
+    _leftInput;
+    _topInput;
+    _rightInput;
+    _bottomInput;
+    _valueLeft;
+    get valueLeft() {
+        return this._valueLeft;
+    }
+    set valueLeft(value) {
+        const oldValue = this._valueLeft;
+        this._valueLeft = value;
+        if (oldValue !== value) {
+            this._updateValue();
+            this.valueLeftChanged.emit({ newValue: value, oldValue: oldValue });
+        }
+    }
+    valueLeftChanged = new TypedEvent();
+    _valueTop;
+    get valueTop() {
+        return this._valueTop;
+    }
+    set valueTop(value) {
+        const oldValue = this._valueTop;
+        this._valueTop = value;
+        if (oldValue !== value) {
+            this._updateValue();
+            this.valueTopChanged.emit({ newValue: value, oldValue: oldValue });
+        }
+    }
+    valueTopChanged = new TypedEvent();
+    _valueRight;
+    get valueRight() {
+        return this._valueRight;
+    }
+    set valueRight(value) {
+        const oldValue = this._valueRight;
+        this._valueRight = value;
+        if (oldValue !== value) {
+            this._updateValue();
+            this.valueRightChanged.emit({ newValue: value, oldValue: oldValue });
+        }
+    }
+    valueRightChanged = new TypedEvent();
+    _valueBottom;
+    get valueBottom() {
+        return this._valueBottom;
+    }
+    set valueBottom(value) {
+        const oldValue = this._valueBottom;
+        this._valueBottom = value;
+        if (oldValue !== value) {
+            this._updateValue();
+            this.valueBottomChanged.emit({ newValue: value, oldValue: oldValue });
+        }
+    }
+    valueBottomChanged = new TypedEvent();
+    property;
+    unsetValue;
+    _updateValue() {
+        this._leftInput.value = this.valueLeft;
+        this._topInput.value = this.valueTop;
+        this._rightInput.value = this.valueRight;
+        this._bottomInput.value = this._valueBottom;
+    }
+    ready() {
+        this._parseAttributesToProperties();
+        this._leftInput = this._getDomElement('left');
+        this._topInput = this._getDomElement('top');
+        this._rightInput = this._getDomElement('right');
+        this._bottomInput = this._getDomElement('bottom');
+        this._leftInput.onkeyup = (e) => { if (e.key === 'Enter')
+            this._valueLeft = this._leftInput.value; };
+        this._topInput.onkeyup = (e) => { if (e.key === 'Enter')
+            this._valueTop = this._topInput.value; };
+        this._rightInput.onkeyup = (e) => { if (e.key === 'Enter')
+            this._valueRight = this._rightInput.value; };
+        this._bottomInput.onkeyup = (e) => { if (e.key === 'Enter')
+            this._valueBottom = this._bottomInput.value; };
+        this._leftInput.onblur = (e) => this._valueLeft = this._leftInput.value;
+        this._topInput.onblur = (e) => this._valueTop = this._topInput.value;
+        this._rightInput.onblur = (e) => this._valueRight = this._rightInput.value;
+        this._bottomInput.onblur = (e) => this._valueBottom = this._bottomInput.value;
+        this._updateValue();
+    }
+}
+customElements.define('node-projects-thickness-editor', ThicknessEditor);

package/dist/elements/helper/Screenshot.js

@@ -21,7 +21,8 @@ export class Screenshot {
             Screenshot._video = document.createElement("video");
             const gdmOptions = {
                 video: {
-                    cursor: "never"
+                    cursor: "never",
+                    displaySurface: 'browser'
                 },
                 audio: false
             };

package/dist/elements/services/DefaultServiceBootstrap.js

@@ -2,6 +2,7 @@ import { ServiceContainer } from './ServiceContainer.js';
 import { PolymerPropertiesService } from './propertiesService/services/PolymerPropertiesService.js';
 import { LitElementPropertiesService } from './propertiesService/services/LitElementPropertiesService.js';
 import { NativeElementsPropertiesService } from './propertiesService/services/NativeElementsPropertiesService.js';
+import { SVGElementsPropertiesService } from './propertiesService/services/SVGElementsPropertiesService.js';
 import { DefaultInstanceService } from './instanceService/DefaultInstanceService.js';
 import { DefaultEditorTypesService } from './propertiesService/DefaultEditorTypesService.js';
 import { BaseCustomWebComponentPropertiesService } from './propertiesService/services/BaseCustomWebComponentPropertiesService.js';
@@ -67,13 +68,16 @@ import { GrayOutDragOverContainerExtensionProvider } from '../widgets/designerVi
 import { LineExtensionProvider } from '../widgets/designerView/extensions/svg/LineExtensionProvider.js';
 import { RectExtentionProvider } from '../widgets/designerView/extensions/svg/RectExtensionProvider.js';
 import { EllipsisExtensionProvider } from '../widgets/designerView/extensions/svg/EllipsisExtensionProvider.js';
+import { PropertyGroupsService } from './propertiesService/PropertyGroupsService.js';
 export function createDefaultServiceContainer() {
     let serviceContainer = new ServiceContainer();
     serviceContainer.register("propertyService", new PolymerPropertiesService());
     serviceContainer.register("propertyService", new LitElementPropertiesService());
     serviceContainer.register("propertyService", new NativeElementsPropertiesService());
+    serviceContainer.register("propertyService", new SVGElementsPropertiesService());
     serviceContainer.register("propertyService", new Lit2PropertiesService());
     serviceContainer.register("propertyService", new BaseCustomWebComponentPropertiesService());
+    serviceContainer.register("propertyGroupsService", new PropertyGroupsService());
     serviceContainer.register("instanceService", new DefaultInstanceService());
     serviceContainer.register("editorTypesService", new DefaultEditorTypesService());
     serviceContainer.register("htmlWriterService", new HtmlWriterService());

package/dist/elements/services/ServiceContainer.d.ts

@@ -32,6 +32,7 @@ import { IProperty } from "./propertiesService/IProperty.js";
 import { IDesignItem } from "../item/IDesignItem.js";
 import { IBinding } from "../item/IBinding";
 import { BindingTarget } from "../item/BindingTarget";
+import { IPropertyGroupsService } from "./propertiesService/IPropertyGroupsService";
 interface ServiceNameMap {
     "propertyService": IPropertiesService;
     "containerService": IPlacementService;
@@ -51,6 +52,7 @@ interface ServiceNameMap {
     "modelCommandService": IModelCommandService;
     "demoProviderService": IDemoProviderService;
     "elementInteractionService": IElementInteractionService;
+    "propertyGroupsService": IPropertyGroupsService;
 }
 export declare class ServiceContainer extends BaseServiceContainer<ServiceNameMap> {
     readonly config: {
@@ -71,6 +73,7 @@ export declare class ServiceContainer extends BaseServiceContainer<ServiceNameMa
     get bindableObjectDragDropService(): IBindableObjectDragDropService;
     get elementInteractionServices(): IElementInteractionService[];
     get propertiesServices(): IPropertiesService[];
+    get propertyGroupService(): IPropertyGroupsService;
     get containerServices(): IPlacementService[];
     get snaplinesProviderService(): ISnaplinesProviderService;
     get elementsServices(): IElementsService[];

package/dist/elements/services/ServiceContainer.js

@@ -37,6 +37,9 @@ export class ServiceContainer extends BaseServiceContainer {
     get propertiesServices() {
         return this.getServices('propertyService');
     }
+    get propertyGroupService() {
+        return this.getLastService('propertyGroupsService');
+    }
     get containerServices() {
         return this.getServices('containerService');
     }

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

@@ -59,7 +59,7 @@ export class HtmlWriterService extends AbstractHtmlWriterService {
                         let childSingleTextNode = c.childCount === 1 && c.firstChild.nodeType === NodeType.TextNode;
                         if (childSingleTextNode)
                             if (!indentedTextWriter.isLastCharNewline())
-                                indentedTextWriter.writeNewline();
+                                this._conditionalyWriteNewline(indentedTextWriter, c);
                     }
                     if (designItem.element instanceof HTMLElement && !isInline(designItem.element) || (designItem.element instanceof SVGElement)) {
                         indentedTextWriter.levelShrink();

package/dist/elements/services/propertiesService/DefaultEditorTypesService.js

@@ -7,6 +7,7 @@ import { TextPropertyEditor } from './propertyEditors/TextPropertyEditor';
 import { BooleanPropertyEditor } from './propertyEditors/BooleanPropertyEditor';
 import { ImageButtonListPropertyEditor } from './propertyEditors/ImageButtonListPropertyEditor';
 import { ThicknessPropertyEditor } from "./propertyEditors/ThicknessPropertyEditor.js";
+import { MetricsPropertyEditor } from "./propertyEditors/MetricsPropertyEditor";
 export class DefaultEditorTypesService {
     getEditorForProperty(property) {
         if (property.createEditor)
@@ -48,6 +49,10 @@ export class DefaultEditorTypesService {
                 {
                     return new ThicknessPropertyEditor(property);
                 }
+            case "metrics":
+                {
+                    return new MetricsPropertyEditor(property);
+                }
             case "css-length":
             case "string":
             default:

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

@@ -5,6 +5,7 @@ import { ValueType } from './ValueType';
 import { BindingTarget } from '../../item/BindingTarget';
 import { IBinding } from '../../item/IBinding';
 export interface IPropertiesService extends IService {
+    listNeedsRefresh(designItem: IDesignItem): boolean;
     isHandledElement(designItem: IDesignItem): boolean;
     getProperties(designItem: IDesignItem): IProperty[];
     getProperty(designItem: IDesignItem, name: string): IProperty;

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

@@ -6,7 +6,7 @@ export interface IProperty {
     propertyName?: string;
     attributeName?: string;
     description?: string;
-    type?: 'json' | 'color' | 'date' | 'number' | 'list' | 'enum' | 'boolean' | 'img-lis' | 'thickness' | 'css-length' | 'string' | string;
+    type?: 'addNew' | 'json' | 'color' | 'date' | 'number' | 'list' | 'enum' | 'boolean' | 'img-lis' | 'thickness' | 'css-length' | 'string' | string;
     default?: any;
     min?: number;
     max?: number;

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

@@ -0,0 +1,8 @@
+import { IDesignItem } from "../../item/IDesignItem";
+import { IPropertiesService } from "./IPropertiesService";
+export interface IPropertyGroupsService {
+    getPropertygroups(designItems: IDesignItem[]): {
+        name: string;
+        propertiesService: IPropertiesService;
+    }[];
+}

package/dist/elements/services/propertiesService/IPropertyGroupsService.js

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

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

@@ -0,0 +1,11 @@
+import { IDesignItem } from "../../item/IDesignItem";
+import { IPropertiesService } from "./IPropertiesService";
+import { IPropertyGroupsService } from "./IPropertyGroupsService";
+export declare class PropertyGroupsService implements IPropertyGroupsService {
+    private _pgList;
+    private _svgPgList;
+    getPropertygroups(designItems: IDesignItem[]): {
+        name: string;
+        propertiesService: IPropertiesService;
+    }[];
+}

package/dist/elements/services/propertiesService/PropertyGroupsService.js

@@ -0,0 +1,28 @@
+import { AttributesPropertiesService } from "./services/AttributesPropertiesService";
+import { CommonPropertiesService } from "./services/CommonPropertiesService";
+import { CssPropertiesService } from "./services/CssPropertiesService";
+export class PropertyGroupsService {
+    _pgList = [
+        { name: 'properties', propertiesService: null },
+        { name: 'attributes', propertiesService: new AttributesPropertiesService() },
+        { name: 'common', propertiesService: new CommonPropertiesService() },
+        { name: 'styles', propertiesService: new CssPropertiesService("styles") },
+        { name: 'layout', propertiesService: new CssPropertiesService("layout") },
+        { name: 'flex', propertiesService: new CssPropertiesService("flex") },
+        { name: 'grid', propertiesService: new CssPropertiesService("grid") },
+    ];
+    _svgPgList = [
+        { name: 'properties', propertiesService: null },
+        { name: 'attributes', propertiesService: new AttributesPropertiesService() },
+        { name: 'styles', propertiesService: new CssPropertiesService("styles") },
+        { name: 'layout', propertiesService: new CssPropertiesService("layout") },
+    ];
+    getPropertygroups(designItems) {
+        if (designItems == null || designItems.length == 0)
+            return [];
+        this._pgList[0].propertiesService = designItems[0].serviceContainer.getLastServiceWhere('propertyService', x => x.isHandledElement(designItems[0]));
+        if (designItems[0] instanceof SVGElement)
+            return this._svgPgList;
+        return this._pgList;
+    }
+}

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

@@ -2,5 +2,7 @@ export declare enum PropertyType {
     property = "property",
     attribute = "attribute",
     propertyAndAttribute = "propertyAndAttribute",
-    cssValue = "cssvalue"
+    cssValue = "cssvalue",
+    complex = "complex",
+    add = "add"
 }

package/dist/elements/services/propertiesService/PropertyType.js

@@ -4,4 +4,6 @@ export var PropertyType;
     PropertyType["attribute"] = "attribute";
     PropertyType["propertyAndAttribute"] = "propertyAndAttribute";
     PropertyType["cssValue"] = "cssvalue";
+    PropertyType["complex"] = "complex";
+    PropertyType["add"] = "add"; // editor allows to add a new one
 })(PropertyType || (PropertyType = {}));

package/dist/elements/services/propertiesService/propertyEditors/MetricsEditor.js

@@ -0,0 +1 @@
+"use strict";

package/dist/elements/services/propertiesService/propertyEditors/MetricsPropertyEditor.d.ts

@@ -0,0 +1,8 @@
+import { IProperty } from "../IProperty";
+import { BasePropertyEditor } from './BasePropertyEditor';
+import { ValueType } from "../ValueType";
+import { MetricsEditor } from "../../../controls/MetricsEditor";
+export declare class MetricsPropertyEditor extends BasePropertyEditor<MetricsEditor> {
+    constructor(property: IProperty);
+    refreshValue(valueType: ValueType, value: any): void;
+}

package/dist/elements/services/propertiesService/propertyEditors/MetricsPropertyEditor.js

@@ -0,0 +1,14 @@
+import { BasePropertyEditor } from './BasePropertyEditor';
+import { MetricsEditor } from "../../../controls/MetricsEditor";
+export class MetricsPropertyEditor extends BasePropertyEditor {
+    constructor(property) {
+        super(property);
+        const selector = new MetricsEditor();
+        selector.property = property.name;
+        //selector.valueLeftChanged.on((e) => this._valueChanged(e.newValue));
+        this.element = selector;
+    }
+    refreshValue(valueType, value) {
+        //this.element.valueLeft = value;
+    }
+}

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

@@ -6,6 +6,7 @@ import { IBinding } from "../../../item/IBinding.js";
 import { BindingTarget } from "../../../item/BindingTarget";
 export declare class AttributesPropertiesService implements IPropertiesService {
     name: string;
+    listNeedsRefresh(designItem: IDesignItem): boolean;
     isHandledElement(designItem: IDesignItem): boolean;
     getProperty(designItem: IDesignItem, name: string): IProperty;
     getProperties(designItem: IDesignItem): IProperty[];

package/dist/elements/services/propertiesService/services/AttributesPropertiesService.js

@@ -3,6 +3,9 @@ import { BindingTarget } from "../../../item/BindingTarget";
 import { PropertyType } from "../PropertyType";
 export class AttributesPropertiesService {
     name = "attributes";
+    listNeedsRefresh(designItem) {
+        return true;
+    }
     isHandledElement(designItem) {
         return true;
     }
@@ -15,6 +18,7 @@ export class AttributesPropertiesService {
             for (let a of designItem.attributes.keys()) {
                 p.push({ name: a, type: 'string', service: this, propertyType: PropertyType.propertyAndAttribute });
             }
+            p.push({ name: '', type: 'addNew', service: this, propertyType: PropertyType.complex });
             return p;
         }
         return null;

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

@@ -5,6 +5,7 @@ import { ValueType } from "../ValueType";
 import { BindingTarget } from "../../../item/BindingTarget";
 import { IBinding } from "../../../item/IBinding";
 export declare class CommonPropertiesService implements IPropertiesService {
+    listNeedsRefresh(designItem: IDesignItem): boolean;
     private commonProperties;
     name: string;
     isHandledElement(designItem: IDesignItem): boolean;

package/dist/elements/services/propertiesService/services/CommonPropertiesService.js

@@ -2,6 +2,9 @@ import { ValueType } from "../ValueType";
 import { BindingTarget } from "../../../item/BindingTarget";
 import { PropertyType } from "../PropertyType";
 export class CommonPropertiesService {
+    listNeedsRefresh(designItem) {
+        return false;
+    }
     //@ts-ignore
     commonProperties = [
         {

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

@@ -5,12 +5,12 @@ import { ValueType } from '../ValueType';
 import { BindingTarget } from '../../../item/BindingTarget.js';
 import { IBinding } from '../../../item/IBinding';
 export declare class CssPropertiesService implements IPropertiesService {
-    private styles;
-    private alignment;
-    private grid;
-    private flex;
-    name: 'set-styles' | 'alignment' | 'styles' | 'grid' | 'flex';
-    constructor(name: 'set-styles' | 'alignment' | 'styles' | 'grid' | 'flex');
+    listNeedsRefresh(designItem: IDesignItem): boolean;
+    layout: IProperty[];
+    grid: IProperty[];
+    flex: IProperty[];
+    name: 'styles' | 'layout' | 'grid' | 'flex';
+    constructor(name: 'styles' | 'layout' | 'grid' | 'flex');
     isHandledElement(designItem: IDesignItem): boolean;
     getProperty(designItem: IDesignItem, name: string): IProperty;
     getProperties(designItem: IDesignItem): IProperty[];