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

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

@@ -1,4 +0,0 @@
-export declare enum BindingMode {
-    oneWay = "oneWay",
-    twoWay = "twoWay"
-}

package/dist/elements/item/BindingMode.js

@@ -1,5 +0,0 @@
-export var BindingMode;
-(function (BindingMode) {
-    BindingMode["oneWay"] = "oneWay";
-    BindingMode["twoWay"] = "twoWay";
-})(BindingMode || (BindingMode = {}));

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

@@ -1,8 +0,0 @@
-export declare enum BindingTarget {
-    property = "property",
-    attribute = "attribute",
-    class = "class",
-    css = "css",
-    event = "event",
-    content = "content"
-}

package/dist/elements/item/BindingTarget.js

@@ -1,9 +0,0 @@
-export var BindingTarget;
-(function (BindingTarget) {
-    BindingTarget["property"] = "property";
-    BindingTarget["attribute"] = "attribute";
-    BindingTarget["class"] = "class";
-    BindingTarget["css"] = "css";
-    BindingTarget["event"] = "event";
-    BindingTarget["content"] = "content"; //innertext or html... mhmmm
-})(BindingTarget || (BindingTarget = {}));

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

@@ -1,96 +0,0 @@
-/// <reference types="node" />
-import { ServiceContainer } from '../services/ServiceContainer.js';
-import { IDesignItem } from './IDesignItem.js';
-import { InstanceServiceContainer } from '../services/InstanceServiceContainer.js';
-import { ChangeGroup } from '../services/undoService/ChangeGroup.js';
-import { NodeType } from './NodeType.js';
-import { ExtensionType } from '../widgets/designerView/extensions/ExtensionType.js';
-import { IDesignerExtension } from '../widgets/designerView/extensions/IDesignerExtension.js';
-import { ISize } from '../../interfaces/ISize.js';
-import { IDesignerExtensionProvider } from '../widgets/designerView/extensions/IDesignerExtensionProvider.js';
-import { IStyleRule } from '../services/stylesheetService/IStylesheetService.js';
-import { TypedEvent } from '@node-projects/base-custom-webcomponent';
-import { IPlacementService } from '../services/placementService/IPlacementService.js';
-export declare class DesignItem implements IDesignItem {
-    lastContainerSize: ISize;
-    parsedNode: any;
-    node: Node;
-    serviceContainer: ServiceContainer;
-    instanceServiceContainer: InstanceServiceContainer;
-    appliedDesignerExtensions: Map<ExtensionType, IDesignerExtension[]>;
-    shouldAppliedDesignerExtensions: Map<ExtensionType, IDesignerExtensionProvider[]>;
-    nodeReplaced: TypedEvent<void>;
-    clone(): Promise<IDesignItem>;
-    allMatching(selectors: string): Generator<IDesignItem, void, undefined>;
-    replaceNode(newNode: Node): void;
-    get nodeType(): NodeType;
-    private _attributes;
-    get hasAttributes(): boolean;
-    hasAttribute(name: string): boolean;
-    getAttribute(name: string): string;
-    attributes(): Generator<[string, string], void, unknown>;
-    _withoutUndoSetAttribute(name: string, value: string): void;
-    _withoutUndoRemoveAttribute(name: string): void;
-    _reparseSpecialAttributes(name: string): void;
-    private _styles;
-    get hasStyles(): boolean;
-    hasStyle(name: string): boolean;
-    getStyle(name: string): string;
-    styles(): Generator<[string, string], void, unknown>;
-    _withoutUndoSetStyle(name: string, value: string): void;
-    _withoutUndoRemoveStyle(name: string): void;
-    private static _designItemMap;
-    get element(): Element;
-    get name(): string;
-    get id(): string;
-    set id(value: string);
-    get isRootItem(): boolean;
-    _childArray: IDesignItem[];
-    get hasChildren(): boolean;
-    children(): IterableIterator<IDesignItem>;
-    get childCount(): number;
-    get firstChild(): IDesignItem;
-    private _parent;
-    get parent(): IDesignItem;
-    indexOf(designItem: IDesignItem): number;
-    insertAdjacentElement(designItem: IDesignItem, where: InsertPosition): void;
-    insertChild(designItem: IDesignItem, index?: number): void;
-    removeChild(designItem: IDesignItem): void;
-    remove(): void;
-    clearChildren(): void;
-    get hasContent(): boolean;
-    get content(): string;
-    set content(value: string);
-    get innerHTML(): string;
-    set innerHTML(value: string);
-    get isEmptyTextNode(): boolean;
-    get hideAtDesignTime(): boolean;
-    set hideAtDesignTime(value: boolean);
-    get hideAtRunTime(): boolean;
-    set hideAtRunTime(value: boolean);
-    get lockAtDesignTime(): boolean;
-    set lockAtDesignTime(value: boolean);
-    static createDesignItemFromInstance(node: Node, serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer): DesignItem;
-    updateChildrenFromNodesChildren(): void;
-    constructor(node: Node, parsedNode: any, serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer);
-    openGroup(title: string): ChangeGroup;
-    getOrCreateDesignItem(node: Node): IDesignItem;
-    static GetOrCreateDesignItem(node: Node, parsedNode: any, serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer): IDesignItem;
-    static GetDesignItem(node: Node): IDesignItem;
-    setStyle(name: string, value?: string | null, important?: boolean): void;
-    removeStyle(name: string): void;
-    updateStyleInSheetOrLocal(name: string, value?: string | null, important?: boolean): void;
-    getStyleFromSheetOrLocal(name: string, fallback?: string): string;
-    getStyleFromSheetOrLocalOrComputed(name: string, fallback?: string): string;
-    getComputedStyle(name: string, fallback?: string): string;
-    _stylesCache: IStyleRule[];
-    _cacheClearTimer: NodeJS.Timeout;
-    getAllStyles(): IStyleRule[];
-    setAttribute(name: string, value?: string | null): void;
-    removeAttribute(name: string): void;
-    _insertChildInternal(designItem: IDesignItem, index?: number): void;
-    _removeChildInternal(designItem: IDesignItem): void;
-    _refreshIfStyleSheet(): void;
-    getPlacementService(style?: CSSStyleDeclaration): IPlacementService;
-    static createDesignItemFromImageBlob(serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer, data: Blob): Promise<IDesignItem>;
-}

package/dist/elements/item/DesignItem.js

@@ -1,513 +0,0 @@
-import { CssStyleChangeAction } from '../services/undoService/transactionItems/CssStyleChangeAction.js';
-import { NodeType } from './NodeType.js';
-import { AttributeChangeAction } from '../services/undoService/transactionItems/AttributeChangeAction.js';
-import { ExtensionType } from '../widgets/designerView/extensions/ExtensionType.js';
-import { CssAttributeParser } from '../helper/CssAttributeParser.js';
-import { PropertiesHelper } from '../services/propertiesService/services/PropertiesHelper.js';
-import { InsertChildAction } from '../services/undoService/transactionItems/InsertChildAction.js';
-import { DomConverter } from '../widgets/designerView/DomConverter.js';
-import { DeleteAction } from '../services/undoService/transactionItems/DeleteAction.js';
-import { enableStylesheetService } from '../widgets/designerView/extensions/buttons/StylesheetServiceDesignViewConfigButtons.js';
-import { AbstractStylesheetService } from '../services/stylesheetService/AbstractStylesheetService.js';
-import { TypedEvent, cssFromString } from '@node-projects/base-custom-webcomponent';
-import { TextContentChangeAction } from '../services/undoService/transactionItems/TextContentChangeAction.js';
-const hideAtDesignTimeAttributeName = 'node-projects-hide-at-design-time';
-const hideAtRunTimeAttributeName = 'node-projects-hide-at-run-time';
-const lockAtDesignTimeAttributeName = 'node-projects-lock-at-design-time';
-export class DesignItem {
-    lastContainerSize;
-    parsedNode;
-    node;
-    serviceContainer;
-    instanceServiceContainer;
-    appliedDesignerExtensions = new Map();
-    shouldAppliedDesignerExtensions = new Map();
-    nodeReplaced = new TypedEvent;
-    async clone() {
-        try {
-            const html = DomConverter.ConvertToString([this], false);
-            const parsed = await this.serviceContainer.htmlParserService.parse(html, this.serviceContainer, this.instanceServiceContainer, true);
-            return parsed[0];
-        }
-        catch (err) {
-            //TODO: clone service for design item, maybe refactor copy&paste to use this also...
-            console.warn("could not clone design item.", this);
-        }
-        return null;
-    }
-    *allMatching(selectors) {
-        if (this.hasChildren) {
-            for (let d of this.children()) {
-                if (d.nodeType == NodeType.Element && d.element.matches(selectors))
-                    yield d;
-                yield* d.allMatching(selectors);
-            }
-        }
-    }
-    replaceNode(newNode) {
-        DesignItem._designItemMap.delete(this.node);
-        DesignItem._designItemMap.set(newNode, this);
-        this.node = newNode;
-        this.nodeReplaced.emit();
-    }
-    get nodeType() {
-        if (this.node instanceof Comment)
-            return NodeType.Comment;
-        if (this.node instanceof Text)
-            return NodeType.TextNode;
-        return NodeType.Element;
-    }
-    _attributes;
-    get hasAttributes() {
-        return this._attributes.size > 0;
-    }
-    hasAttribute(name) {
-        return this._attributes.has(name);
-    }
-    getAttribute(name) {
-        return this._attributes.get(name);
-    }
-    *attributes() {
-        for (let s of this._attributes) {
-            yield s;
-        }
-    }
-    _withoutUndoSetAttribute(name, value) {
-        this._attributes.set(name, value);
-        this._reparseSpecialAttributes(name);
-    }
-    _withoutUndoRemoveAttribute(name) {
-        this._attributes.delete(name);
-        this._reparseSpecialAttributes(name);
-    }
-    _reparseSpecialAttributes(name) {
-        if (name == hideAtDesignTimeAttributeName) {
-            if (this.element instanceof HTMLElement || this.element instanceof SVGElement) {
-                if (!this._attributes.has(hideAtDesignTimeAttributeName))
-                    this.element.style.display = this._styles.get('display') ?? "";
-                else
-                    this.element.style.display = 'none';
-            }
-        }
-        else if (name == hideAtRunTimeAttributeName) {
-            if (this.element instanceof HTMLElement || this.element instanceof SVGElement) {
-                if (!this._attributes.has(hideAtRunTimeAttributeName))
-                    this.element.style.opacity = this._styles.get('opacity') ?? "";
-                else
-                    this.element.style.opacity = '0.3';
-            }
-        }
-        else if (name == lockAtDesignTimeAttributeName) {
-            if (this.element instanceof HTMLElement || this.element instanceof SVGElement) {
-                if (!this._attributes.has(lockAtDesignTimeAttributeName))
-                    this.element.style.pointerEvents = 'auto';
-                else
-                    this.element.style.pointerEvents = 'none';
-            }
-        }
-    }
-    _styles;
-    get hasStyles() {
-        return this._styles.size > 0;
-    }
-    hasStyle(name) {
-        let nm = PropertiesHelper.camelToDashCase(name);
-        return this._styles.has(nm);
-    }
-    getStyle(name) {
-        let nm = PropertiesHelper.camelToDashCase(name);
-        return this._styles.get(nm);
-    }
-    *styles() {
-        for (let s of this._styles) {
-            yield s;
-        }
-    }
-    _withoutUndoSetStyle(name, value) {
-        let nm = PropertiesHelper.camelToDashCase(name);
-        this._styles.set(nm, value);
-    }
-    _withoutUndoRemoveStyle(name) {
-        let nm = PropertiesHelper.camelToDashCase(name);
-        this._styles.delete(nm);
-    }
-    static _designItemMap = new WeakMap();
-    get element() {
-        return this.node;
-    }
-    get name() {
-        return this.element.localName;
-    }
-    get id() {
-        return this.element.id;
-    }
-    set id(value) {
-        this.element.id = value;
-        this.setAttribute("id", value);
-    }
-    get isRootItem() {
-        return this.instanceServiceContainer.contentService.rootDesignItem === this;
-    }
-    _childArray = [];
-    get hasChildren() {
-        return this._childArray.length > 0;
-    }
-    *children() {
-        for (const e of this._childArray) {
-            yield e;
-        }
-    }
-    get childCount() {
-        return this._childArray.length;
-    }
-    get firstChild() {
-        return this._childArray[0];
-    }
-    _parent;
-    get parent() {
-        return this._parent;
-    }
-    indexOf(designItem) {
-        return this._childArray.indexOf(designItem);
-    }
-    insertAdjacentElement(designItem, where) {
-        let action;
-        if (where == 'afterbegin') {
-            action = new InsertChildAction(designItem, this, 0);
-        }
-        else if (where == 'beforeend') {
-            action = new InsertChildAction(designItem, this, this._childArray.length);
-        }
-        else if (where == 'beforebegin') {
-            action = new InsertChildAction(designItem, this.parent, this.parent.indexOf(this));
-        }
-        else if (where == 'afterend') {
-            action = new InsertChildAction(designItem, this.parent, this.parent.indexOf(this) + 1);
-        }
-        this.instanceServiceContainer.undoService.execute(action);
-    }
-    insertChild(designItem, index) {
-        const action = new InsertChildAction(designItem, this, index);
-        this.instanceServiceContainer.undoService.execute(action);
-    }
-    removeChild(designItem) {
-        const action = new DeleteAction([designItem]);
-        this.instanceServiceContainer.undoService.execute(action);
-    }
-    remove() {
-        const action = new DeleteAction([this]);
-        this.instanceServiceContainer.undoService.execute(action);
-    }
-    clearChildren() {
-        for (let i = this._childArray.length - 1; i >= 0; i--) {
-            let di = this._childArray[i];
-            di.remove();
-        }
-    }
-    //abstract text content to own property. so only change via designer api will use it.
-    get hasContent() {
-        return this.nodeType == NodeType.TextNode || (this.nodeType == NodeType.Comment && this.element.textContent != "") || (this._childArray.length === 0 && this.content !== null);
-    }
-    get content() {
-        if (!this.hasChildren)
-            return this.node.textContent;
-        else
-            return this._childArray.map(x => x.content).join();
-    }
-    set content(value) {
-        const grp = this.openGroup('set content');
-        this.clearChildren();
-        let t = document.createTextNode(value);
-        let di = DesignItem.GetOrCreateDesignItem(t, t, this.serviceContainer, this.instanceServiceContainer);
-        if (this.nodeType == NodeType.TextNode) {
-            const idx = this.parent.indexOf(this);
-            const parent = this.parent;
-            this.remove();
-            parent.insertChild(di, idx);
-        }
-        else if (this.nodeType == NodeType.Comment) {
-            const action = new TextContentChangeAction(this, value, this.content);
-            this.instanceServiceContainer.undoService.execute(action);
-        }
-        else
-            this.insertChild(di);
-        grp.commit();
-    }
-    get innerHTML() {
-        return this.element.innerHTML;
-    }
-    set innerHTML(value) {
-        if (this.nodeType != NodeType.TextNode) {
-            const grp = this.openGroup('set innerHTML');
-            const range = document.createRange();
-            range.selectNode(document.body);
-            const fragment = range.createContextualFragment(value);
-            for (const n of fragment.childNodes) {
-                let di = DesignItem.GetOrCreateDesignItem(n, n, this.serviceContainer, this.instanceServiceContainer);
-                this.insertChild(di);
-            }
-            grp.commit();
-        }
-    }
-    get isEmptyTextNode() {
-        return this.nodeType === NodeType.TextNode && this.content?.trim() == '';
-    }
-    get hideAtDesignTime() {
-        return this.hasAttribute(hideAtDesignTimeAttributeName);
-    }
-    set hideAtDesignTime(value) {
-        if (value)
-            this.setAttribute(hideAtDesignTimeAttributeName, "");
-        else
-            this.removeAttribute(hideAtDesignTimeAttributeName);
-    }
-    get hideAtRunTime() {
-        return this.hasAttribute(hideAtRunTimeAttributeName);
-    }
-    set hideAtRunTime(value) {
-        if (value)
-            this.setAttribute(hideAtRunTimeAttributeName, "");
-        else
-            this.removeAttribute(hideAtRunTimeAttributeName);
-    }
-    get lockAtDesignTime() {
-        return this.hasAttribute(lockAtDesignTimeAttributeName);
-    }
-    set lockAtDesignTime(value) {
-        if (value)
-            this.setAttribute(lockAtDesignTimeAttributeName, "");
-        else
-            this.removeAttribute(lockAtDesignTimeAttributeName);
-    }
-    static createDesignItemFromInstance(node, serviceContainer, instanceServiceContainer) {
-        let designItem = new DesignItem(node, node, serviceContainer, instanceServiceContainer);
-        if (designItem.nodeType == NodeType.Element) {
-            for (let a of designItem.element.attributes) {
-                if (a.name !== 'style') {
-                    designItem._attributes.set(a.name, a.value);
-                }
-            }
-            if (node instanceof HTMLElement || node instanceof SVGElement) {
-                const cssParser = new CssAttributeParser();
-                const st = node.getAttribute("style");
-                if (st) {
-                    cssParser.parse(st);
-                    for (let e of cssParser.entries) {
-                        designItem._styles.set(e.name, e.value);
-                    }
-                }
-                if (!designItem.lockAtDesignTime) {
-                    requestAnimationFrame(() => node.style.pointerEvents = 'auto');
-                }
-                else
-                    node.style.pointerEvents = 'none';
-            }
-            node.draggable = false; //even if it should be true, for better designer exp.
-        }
-        designItem.updateChildrenFromNodesChildren();
-        return designItem;
-    }
-    updateChildrenFromNodesChildren() {
-        this._childArray = [];
-        if (this.nodeType == NodeType.Element) {
-            for (const c of this.element.childNodes) {
-                const di = DesignItem.createDesignItemFromInstance(c, this.serviceContainer, this.instanceServiceContainer);
-                this._childArray.push(di);
-                di._parent = this;
-            }
-        }
-        this._refreshIfStyleSheet();
-    }
-    constructor(node, parsedNode, serviceContainer, instanceServiceContainer) {
-        this.node = node;
-        this.parsedNode = parsedNode;
-        this.serviceContainer = serviceContainer;
-        this.instanceServiceContainer = instanceServiceContainer;
-        this._attributes = new Map();
-        this._styles = new Map();
-        DesignItem._designItemMap.set(node, this);
-    }
-    openGroup(title) {
-        return this.instanceServiceContainer.undoService.openGroup(title);
-    }
-    getOrCreateDesignItem(node) {
-        return DesignItem.GetOrCreateDesignItem(node, node, this.serviceContainer, this.instanceServiceContainer);
-    }
-    static GetOrCreateDesignItem(node, parsedNode, serviceContainer, instanceServiceContainer) {
-        if (!node)
-            return null;
-        let designItem = DesignItem._designItemMap.get(node);
-        if (!designItem) {
-            let dis = serviceContainer.designItemService;
-            if (dis)
-                designItem = dis.createDesignItem(node, parsedNode, serviceContainer, instanceServiceContainer);
-            else
-                designItem = new DesignItem(node, parsedNode, serviceContainer, instanceServiceContainer);
-        }
-        return designItem;
-    }
-    static GetDesignItem(node) {
-        if (!node)
-            return null;
-        let designItem = DesignItem._designItemMap.get(node);
-        return designItem;
-    }
-    setStyle(name, value, important) {
-        let nm = PropertiesHelper.camelToDashCase(name);
-        if (this.isRootItem)
-            throw 'not allowed to set style on root item';
-        const action = new CssStyleChangeAction(this, nm, value, this._styles.get(nm));
-        this.instanceServiceContainer.undoService.execute(action);
-    }
-    removeStyle(name) {
-        let nm = PropertiesHelper.camelToDashCase(name);
-        const action = new CssStyleChangeAction(this, nm, '', this._styles.get(nm));
-        this.instanceServiceContainer.undoService.execute(action);
-    }
-    updateStyleInSheetOrLocal(name, value, important) {
-        let nm = PropertiesHelper.camelToDashCase(name);
-        // Pre-sorted by specificity
-        let declarations = this.instanceServiceContainer.stylesheetService?.getDeclarations(this, nm);
-        if (this.hasStyle(name) || this.instanceServiceContainer.designContext.extensionOptions[enableStylesheetService] === false || !declarations?.length) {
-            // Set style locally
-            if (this.getStyle(nm) != value) {
-                this.setStyle(nm, value);
-            }
-            else if (value == null) {
-                this.removeStyle(nm);
-            }
-        }
-        else {
-            this.instanceServiceContainer.stylesheetService.updateDeclarationValue(declarations[0], value, false);
-        }
-    }
-    getStyleFromSheetOrLocal(name, fallback = null) {
-        let nm = PropertiesHelper.camelToDashCase(name);
-        if (this.hasStyle(name))
-            // Get style locally
-            return this.getStyle(nm);
-        // Pre-sorted by specificity
-        let decls = this.instanceServiceContainer.stylesheetService?.getDeclarations(this, nm);
-        if (decls && decls.length > 0)
-            return decls[0].value;
-        return null;
-    }
-    getStyleFromSheetOrLocalOrComputed(name, fallback = null) {
-        let value = this.getStyleFromSheetOrLocal(name);
-        if (!value) {
-            value = getComputedStyle(this.element).getPropertyValue(name);
-        }
-        return value ?? fallback;
-    }
-    getComputedStyle(name, fallback = null) {
-        let value = this.getStyleFromSheetOrLocal(name);
-        if (!value) {
-            value = getComputedStyle(this.element).getPropertyValue(name);
-        }
-        return value ?? fallback;
-    }
-    _stylesCache = null;
-    _cacheClearTimer;
-    getAllStyles() {
-        let styles = this._stylesCache;
-        if (styles)
-            return styles;
-        if (this.nodeType != NodeType.Element)
-            return [];
-        const localStyles = [...this._styles.entries()].map(x => ({ name: x[0], value: x[1], important: false, parent: null }));
-        if (this.instanceServiceContainer.stylesheetService) {
-            try {
-                const rules = this.instanceServiceContainer.stylesheetService?.getAppliedRules(this);
-                if (rules) {
-                    return [{ selector: null, declarations: localStyles, specificity: -1 }, ...rules];
-                }
-            }
-            catch (err) { }
-        }
-        styles = [{ selector: null, declarations: localStyles, specificity: -1 }];
-        this._stylesCache = styles;
-        clearTimeout(this._cacheClearTimer);
-        this._cacheClearTimer = setTimeout(() => this._stylesCache = null, 30);
-        return styles;
-    }
-    setAttribute(name, value) {
-        if (this.isRootItem)
-            throw 'not allowed to set attribute on root item';
-        const action = new AttributeChangeAction(this, name, value, this._attributes.get(name));
-        this.instanceServiceContainer.undoService.execute(action);
-    }
-    removeAttribute(name) {
-        const action = new AttributeChangeAction(this, name, null, this._attributes.get(name));
-        this.instanceServiceContainer.undoService.execute(action);
-    }
-    // Internal implementations wich don't use undo/redo
-    _insertChildInternal(designItem, index) {
-        if (designItem.parent && this.instanceServiceContainer.selectionService.primarySelection == designItem) {
-            designItem.instanceServiceContainer.designerCanvas.extensionManager.removeExtension(designItem.parent, ExtensionType.PrimarySelectionContainer);
-            designItem.instanceServiceContainer.designerCanvas.extensionManager.removeExtension(designItem.parent, ExtensionType.PrimarySelectionContainerAndCanBeEntered);
-        }
-        if (designItem.parent) {
-            designItem.parent._removeChildInternal(designItem);
-        }
-        if (index == null || this._childArray.length == 0 || index >= this._childArray.length) {
-            this._childArray.push(designItem);
-            this.element.appendChild(designItem.node);
-        }
-        else {
-            let el = this._childArray[index];
-            this.node.insertBefore(designItem.node, el.element);
-            this._childArray.splice(index, 0, designItem);
-        }
-        designItem._parent = this;
-        //todo: is this still needed???
-        if (this.instanceServiceContainer.selectionService.primarySelection == designItem) {
-            designItem.instanceServiceContainer.designerCanvas.extensionManager.applyExtension(designItem.parent, ExtensionType.PrimarySelectionContainer);
-            if (designItem.getPlacementService().isEnterableContainer(this))
-                designItem.instanceServiceContainer.designerCanvas.extensionManager.applyExtension(designItem.parent, ExtensionType.PrimarySelectionContainerAndCanBeEntered);
-        }
-        this._refreshIfStyleSheet();
-    }
-    _removeChildInternal(designItem) {
-        if (designItem.parent && this.instanceServiceContainer.selectionService.primarySelection == designItem) {
-            designItem.instanceServiceContainer.designerCanvas.extensionManager.removeExtension(designItem.parent, ExtensionType.PrimarySelectionContainer);
-            designItem.instanceServiceContainer.designerCanvas.extensionManager.removeExtension(designItem.parent, ExtensionType.PrimarySelectionAndCanBeEntered);
-        }
-        designItem.instanceServiceContainer.designerCanvas.extensionManager.removeExtensions([designItem], true);
-        const index = this._childArray.indexOf(designItem);
-        if (index > -1) {
-            this._childArray.splice(index, 1);
-            designItem.element.remove();
-            designItem._parent = null;
-        }
-        this._refreshIfStyleSheet();
-    }
-    _refreshIfStyleSheet() {
-        if (this.name == 'style' || this.parent?.name == 'style') {
-            //Update Stylesheetservice with sheet info
-            //Patch this sheetdata
-            const realContent = this._childArray.reduce((a, b) => a + b.content, '');
-            this.node.textContent = AbstractStylesheetService.buildPatchedStyleSheet([cssFromString(realContent)]);
-            this.instanceServiceContainer.designerCanvas.lazyTriggerReparseDocumentStylesheets();
-        }
-        else if (this.name == 'link') {
-        }
-    }
-    getPlacementService(style) {
-        if (this.nodeType != NodeType.Element)
-            return null;
-        style ??= getComputedStyle(this.element);
-        return this.serviceContainer.getLastServiceWhere('containerService', x => x.serviceForContainer(this, style));
-    }
-    static createDesignItemFromImageBlob(serviceContainer, instanceServiceContainer, data) {
-        return new Promise(resolve => {
-            let reader = new FileReader();
-            reader.onloadend = () => {
-                const img = document.createElement('img');
-                img.src = reader.result;
-                const di = DesignItem.createDesignItemFromInstance(img, serviceContainer, instanceServiceContainer);
-                return resolve(di);
-            };
-            reader.readAsDataURL(data);
-        });
-    }
-}

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

@@ -1,15 +0,0 @@
-import { BindingMode } from './BindingMode.js';
-import { BindingTarget } from './BindingTarget.js';
-export interface IBinding {
-    targetName?: string;
-    target?: BindingTarget;
-    rawName?: string;
-    rawValue?: string;
-    type?: string;
-    expression?: string;
-    bindableObjectNames?: string[];
-    mode?: BindingMode;
-    invert?: boolean;
-    changedEvents?: string[];
-    nullSafe?: boolean;
-}

package/dist/elements/item/IBinding.js

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