@node-projects/web-component-designer 0.0.66 → 0.0.67

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

@@ -1,103 +1,103 @@
-import { DomConverter } from '../../widgets/designerView/DomConverter';
-import { CssCombiner } from '../../helper/CssCombiner';
-import { NodeType } from '../../item/NodeType';
-import { PropertiesHelper } from '../propertiesService/services/PropertiesHelper';
-import { isInline } from '../../helper/ElementHelper.js';
-export class HtmlWriterService {
-    canWrite(designItem) {
-        return true;
-    }
-    _conditionalyWriteIndent(indentedTextWriter, designItem) {
-        if ((designItem.element instanceof HTMLElement && !isInline(designItem.element)) ||
-            (designItem.element.previousElementSibling instanceof HTMLElement && !isInline(designItem.element.previousElementSibling)))
-            indentedTextWriter.writeIndent();
-    }
-    _conditionalyWriteNewline(indentedTextWriter, designItem) {
-        if ((designItem.element instanceof HTMLElement && !isInline(designItem.element)) ||
-            (designItem.element.nextElementSibling instanceof HTMLElement && !isInline(designItem.element.nextElementSibling)))
-            indentedTextWriter.writeNewline();
-    }
-    write(indentedTextWriter, designItem, options, designItemsAssignmentList) {
-        let start = indentedTextWriter.position;
-        if (designItem.nodeType == NodeType.TextNode) {
-            this.writeTextNode(indentedTextWriter, designItem, true);
-        }
-        else if (designItem.nodeType == NodeType.Comment) {
-            this._conditionalyWriteIndent(indentedTextWriter, designItem);
-            indentedTextWriter.write('<!--' + designItem.content + '-->');
-            this._conditionalyWriteNewline(indentedTextWriter, designItem);
-        }
-        else {
-            this._conditionalyWriteIndent(indentedTextWriter, designItem);
-            indentedTextWriter.write('<' + designItem.name);
-            if (designItem.hasAttributes) {
-                for (const a of designItem.attributes) {
-                    indentedTextWriter.write(' ');
-                    if (typeof a[1] === 'string') {
-                        if (a[1] === "")
-                            indentedTextWriter.write(a[0]);
-                        else
-                            indentedTextWriter.write(a[0] + '="' + DomConverter.normalizeAttributeValue(a[1]) + '"');
-                    }
-                    else if (!a[1])
-                        indentedTextWriter.write(a[0]);
-                    else {
-                        //TODO: writing of bindings
-                    }
-                }
-            }
-            if (designItem.hasStyles) {
-                indentedTextWriter.write(' style="');
-                let styles = designItem.styles;
-                if (options.compressCssToShorthandProperties)
-                    styles = CssCombiner.combine(styles);
-                for (const s of styles) {
-                    if (s[0]) {
-                        indentedTextWriter.write(PropertiesHelper.camelToDashCase(s[0]) + ':' + DomConverter.normalizeAttributeValue(s[1]) + ';');
-                    }
-                }
-                indentedTextWriter.write('"');
-            }
-            indentedTextWriter.write('>');
-            if (designItem.hasChildren) {
-                const children = designItem.children();
-                const singleTextNode = designItem.childCount === 1 && designItem.firstChild.nodeType === NodeType.TextNode;
-                if (singleTextNode) {
-                    this.writeTextNode(indentedTextWriter, designItem, false);
-                }
-                else {
-                    indentedTextWriter.writeNewline();
-                    indentedTextWriter.levelRaise();
-                    for (const c of children) {
-                        c.serviceContainer.forSomeServicesTillResult('htmlWriterService', (s) => {
-                            if (s.canWrite(c)) {
-                                s.write(indentedTextWriter, c, options, designItemsAssignmentList);
-                            }
-                        });
-                    }
-                    indentedTextWriter.levelShrink();
-                    indentedTextWriter.writeIndent();
-                }
-            }
-            else if (designItem.hasContent) {
-                indentedTextWriter.write(DomConverter.normalizeContentValue(designItem.content));
-            }
-            if (!DomConverter.IsSelfClosingElement(designItem.name))
-                indentedTextWriter.write('</' + designItem.name + '>');
-            this._conditionalyWriteNewline(indentedTextWriter, designItem);
-        }
-        if (designItemsAssignmentList) {
-            designItemsAssignmentList.set(designItem, { start: start, length: indentedTextWriter.position - start - 1 });
-        }
-    }
-    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';
+import { CssCombiner } from '../../helper/CssCombiner';
+import { NodeType } from '../../item/NodeType';
+import { PropertiesHelper } from '../propertiesService/services/PropertiesHelper';
+import { isInline } from '../../helper/ElementHelper.js';
+export class HtmlWriterService {
+    canWrite(designItem) {
+        return true;
+    }
+    _conditionalyWriteIndent(indentedTextWriter, designItem) {
+        if ((designItem.element instanceof HTMLElement && !isInline(designItem.element)) ||
+            (designItem.element.previousElementSibling instanceof HTMLElement && !isInline(designItem.element.previousElementSibling)))
+            indentedTextWriter.writeIndent();
+    }
+    _conditionalyWriteNewline(indentedTextWriter, designItem) {
+        if ((designItem.element instanceof HTMLElement && !isInline(designItem.element)) ||
+            (designItem.element.nextElementSibling instanceof HTMLElement && !isInline(designItem.element.nextElementSibling)))
+            indentedTextWriter.writeNewline();
+    }
+    write(indentedTextWriter, designItem, options, designItemsAssignmentList) {
+        let start = indentedTextWriter.position;
+        if (designItem.nodeType == NodeType.TextNode) {
+            this.writeTextNode(indentedTextWriter, designItem, true);
+        }
+        else if (designItem.nodeType == NodeType.Comment) {
+            this._conditionalyWriteIndent(indentedTextWriter, designItem);
+            indentedTextWriter.write('<!--' + designItem.content + '-->');
+            this._conditionalyWriteNewline(indentedTextWriter, designItem);
+        }
+        else {
+            this._conditionalyWriteIndent(indentedTextWriter, designItem);
+            indentedTextWriter.write('<' + designItem.name);
+            if (designItem.hasAttributes) {
+                for (const a of designItem.attributes) {
+                    indentedTextWriter.write(' ');
+                    if (typeof a[1] === 'string') {
+                        if (a[1] === "")
+                            indentedTextWriter.write(a[0]);
+                        else
+                            indentedTextWriter.write(a[0] + '="' + DomConverter.normalizeAttributeValue(a[1]) + '"');
+                    }
+                    else if (!a[1])
+                        indentedTextWriter.write(a[0]);
+                    else {
+                        //TODO: writing of bindings
+                    }
+                }
+            }
+            if (designItem.hasStyles) {
+                indentedTextWriter.write(' style="');
+                let styles = designItem.styles;
+                if (options.compressCssToShorthandProperties)
+                    styles = CssCombiner.combine(styles);
+                for (const s of styles) {
+                    if (s[0]) {
+                        indentedTextWriter.write(PropertiesHelper.camelToDashCase(s[0]) + ':' + DomConverter.normalizeAttributeValue(s[1]) + ';');
+                    }
+                }
+                indentedTextWriter.write('"');
+            }
+            indentedTextWriter.write('>');
+            if (designItem.hasChildren) {
+                const children = designItem.children();
+                const singleTextNode = designItem.childCount === 1 && designItem.firstChild.nodeType === NodeType.TextNode;
+                if (singleTextNode) {
+                    this.writeTextNode(indentedTextWriter, designItem, false);
+                }
+                else {
+                    indentedTextWriter.writeNewline();
+                    indentedTextWriter.levelRaise();
+                    for (const c of children) {
+                        c.serviceContainer.forSomeServicesTillResult('htmlWriterService', (s) => {
+                            if (s.canWrite(c)) {
+                                s.write(indentedTextWriter, c, options, designItemsAssignmentList);
+                            }
+                        });
+                    }
+                    indentedTextWriter.levelShrink();
+                    indentedTextWriter.writeIndent();
+                }
+            }
+            else if (designItem.hasContent) {
+                indentedTextWriter.write(DomConverter.normalizeContentValue(designItem.content));
+            }
+            if (!DomConverter.IsSelfClosingElement(designItem.name))
+                indentedTextWriter.write('</' + designItem.name + '>');
+            this._conditionalyWriteNewline(indentedTextWriter, designItem);
+        }
+        if (designItemsAssignmentList) {
+            designItemsAssignmentList.set(designItem, { start: start, length: indentedTextWriter.position - start - 1 });
+        }
+    }
+    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,5 +1,5 @@
-export declare class IHtmlWriterOptions {
-    beautifyOutput: boolean;
-    compressCssToShorthandProperties: boolean;
-    writeDesignerProperties: boolean;
-}
+export declare class IHtmlWriterOptions {
+    beautifyOutput: boolean;
+    compressCssToShorthandProperties: boolean;
+    writeDesignerProperties: boolean;
+}

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

@@ -1,5 +1,5 @@
-export class IHtmlWriterOptions {
-    beautifyOutput;
-    compressCssToShorthandProperties;
-    writeDesignerProperties;
-}
+export class IHtmlWriterOptions {
+    beautifyOutput;
+    compressCssToShorthandProperties;
+    writeDesignerProperties;
+}

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

@@ -1,8 +1,8 @@
-import { IDesignItem } from '../../item/IDesignItem';
-import { IHtmlWriterOptions } from './IHtmlWriterOptions';
-import { IndentedTextWriter } from '../../helper/IndentedTextWriter';
-import { IStringPosition } from './IStringPosition';
-export interface IHtmlWriterService {
-    canWrite(designItem: IDesignItem): boolean;
-    write(indentedTextWriter: IndentedTextWriter, designItem: IDesignItem, options: IHtmlWriterOptions, designItemsAssignmentList?: Map<IDesignItem, IStringPosition>): any;
-}
+import { IDesignItem } from '../../item/IDesignItem';
+import { IHtmlWriterOptions } from './IHtmlWriterOptions';
+import { IndentedTextWriter } from '../../helper/IndentedTextWriter';
+import { IStringPosition } from './IStringPosition';
+export interface IHtmlWriterService {
+    canWrite(designItem: IDesignItem): boolean;
+    write(indentedTextWriter: IndentedTextWriter, designItem: IDesignItem, options: IHtmlWriterOptions, designItemsAssignmentList?: Map<IDesignItem, IStringPosition>): 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/initializationService/IIntializationService.d.ts

@@ -1,4 +1,4 @@
-import { IDesignItem } from '../../item/IDesignItem';
-export interface IIntializationService {
-    init(designItem: IDesignItem): void;
-}
+import { IDesignItem } from '../../item/IDesignItem';
+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';
-import { IElementDefinition } from '../elementsService/IElementDefinition';
-import type { ServiceContainer } from '../ServiceContainer';
-import type { InstanceServiceContainer } from '../InstanceServiceContainer';
-import { IDesignItem } from '../../item/IDesignItem';
-export declare class DefaultInstanceService implements IInstanceService {
-    getElement(definition: IElementDefinition, serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer): Promise<IDesignItem>;
-}
+import { IInstanceService } from './IInstanceService';
+import { IElementDefinition } from '../elementsService/IElementDefinition';
+import type { ServiceContainer } from '../ServiceContainer';
+import type { InstanceServiceContainer } from '../InstanceServiceContainer';
+import { IDesignItem } from '../../item/IDesignItem';
+export declare class DefaultInstanceService implements IInstanceService {
+    getElement(definition: IElementDefinition, serviceContainer: ServiceContainer, instanceServiceContainer: InstanceServiceContainer): Promise<IDesignItem>;
+}

package/dist/elements/services/instanceService/DefaultInstanceService.js

@@ -1,67 +1,67 @@
-import { DesignItem } from '../../item/DesignItem';
-import { encodeXMLChars } from '../../helper/XmlHelper';
-import { newElementFromString } from '../../helper/ElementHelper';
-export class DefaultInstanceService {
-    async getElement(definition, serviceContainer, instanceServiceContainer) {
-        if (definition.import) {
-            let importUri = definition.import;
-            if (importUri[0] === '.')
-                importUri = (window.location.origin + window.location.pathname).split('/').slice(0, -1).join('/') + '/' + importUri;
-            import(importUri).then(() => {
-                //TODO: refresh all extensions
-            }); //removed await here, feels better to not wait for the elemnt is loaded, maybe this needs to be configurable
-            if (instanceServiceContainer.designContext.imports.indexOf(importUri) <= 0)
-                instanceServiceContainer.designContext.imports.push(importUri);
-        }
-        let attr = '';
-        if (definition.defaultAttributes) {
-            for (let a in definition.defaultAttributes) {
-                let value = definition.defaultAttributes[a];
-                try {
-                    if (typeof value === 'object')
-                        attr += ' ' + a + '="' + encodeXMLChars(JSON.stringify(definition.defaultAttributes[a])) + '"';
-                    else
-                        attr += ' ' + a + '="' + encodeXMLChars(definition.defaultAttributes[a]) + '"';
-                }
-                catch (e) {
-                    console.warn(e);
-                }
-            }
-        }
-        const elementString = '<' + definition.tag + attr + '></' + definition.tag + '>';
-        const element = newElementFromString(elementString);
-        if (!definition.doNotSetInNodeProjectsDesignerViewOnInstance)
-            element._inNodeProjectsDesignerView = true;
-        if (definition.defaultWidth)
-            element.style.width = definition.defaultWidth;
-        if (definition.defaultHeight)
-            element.style.height = definition.defaultHeight;
-        element.style.position = 'absolute';
-        if (definition.defaultStyles) {
-            for (let s in definition.defaultStyles)
-                element.style[s] = definition.defaultStyles[s];
-        }
-        if (definition.defaultContent) {
-            if (typeof definition.defaultContent === "string") {
-                element.innerHTML = definition.defaultContent;
-            }
-            else {
-                element.appendChild(definition.defaultContent);
-            }
-        }
-        let designItem = DesignItem.createDesignItemFromInstance(element, serviceContainer, instanceServiceContainer);
-        if (definition.defaultProperties) {
-            let propertiesService = null;
-            if (definition.type) {
-                propertiesService = serviceContainer.getLastServiceWhere('propertyService', (x) => x.name == definition.type);
-            }
-            let properties = propertiesService.getProperties(designItem);
-            for (let a in definition.defaultProperties) {
-                let value = definition.defaultProperties[a];
-                let p = properties.find(x => x.name == a);
-                propertiesService.setValue([designItem], p, value);
-            }
-        }
-        return designItem;
-    }
-}
+import { DesignItem } from '../../item/DesignItem';
+import { encodeXMLChars } from '../../helper/XmlHelper';
+import { newElementFromString } from '../../helper/ElementHelper';
+export class DefaultInstanceService {
+    async getElement(definition, serviceContainer, instanceServiceContainer) {
+        if (definition.import) {
+            let importUri = definition.import;
+            if (importUri[0] === '.')
+                importUri = (window.location.origin + window.location.pathname).split('/').slice(0, -1).join('/') + '/' + importUri;
+            import(importUri).then(() => {
+                //TODO: refresh all extensions
+            }); //removed await here, feels better to not wait for the elemnt is loaded, maybe this needs to be configurable
+            if (instanceServiceContainer.designContext.imports.indexOf(importUri) <= 0)
+                instanceServiceContainer.designContext.imports.push(importUri);
+        }
+        let attr = '';
+        if (definition.defaultAttributes) {
+            for (let a in definition.defaultAttributes) {
+                let value = definition.defaultAttributes[a];
+                try {
+                    if (typeof value === 'object')
+                        attr += ' ' + a + '="' + encodeXMLChars(JSON.stringify(definition.defaultAttributes[a])) + '"';
+                    else
+                        attr += ' ' + a + '="' + encodeXMLChars(definition.defaultAttributes[a]) + '"';
+                }
+                catch (e) {
+                    console.warn(e);
+                }
+            }
+        }
+        const elementString = '<' + definition.tag + attr + '></' + definition.tag + '>';
+        const element = newElementFromString(elementString);
+        if (!definition.doNotSetInNodeProjectsDesignerViewOnInstance)
+            element._inNodeProjectsDesignerView = true;
+        if (definition.defaultWidth)
+            element.style.width = definition.defaultWidth;
+        if (definition.defaultHeight)
+            element.style.height = definition.defaultHeight;
+        element.style.position = 'absolute';
+        if (definition.defaultStyles) {
+            for (let s in definition.defaultStyles)
+                element.style[s] = definition.defaultStyles[s];
+        }
+        if (definition.defaultContent) {
+            if (typeof definition.defaultContent === "string") {
+                element.innerHTML = definition.defaultContent;
+            }
+            else {
+                element.appendChild(definition.defaultContent);
+            }
+        }
+        let designItem = DesignItem.createDesignItemFromInstance(element, serviceContainer, instanceServiceContainer);
+        if (definition.defaultProperties) {
+            let propertiesService = null;
+            if (definition.type) {
+                propertiesService = serviceContainer.getLastServiceWhere('propertyService', (x) => x.name == definition.type);
+            }
+            let properties = propertiesService.getProperties(designItem);
+            for (let a in definition.defaultProperties) {
+                let value = definition.defaultProperties[a];
+                let p = properties.find(x => x.name == a);
+                propertiesService.setValue([designItem], p, value);
+            }
+        }
+        return designItem;
+    }
+}

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

@@ -1,3 +1,3 @@
-export interface IDesignerInstance {
-    _inNodeProjectsDesignerView: boolean;
-}
+export interface IDesignerInstance {
+    _inNodeProjectsDesignerView: boolean;
+}

package/dist/elements/services/instanceService/IDesignerInstance.js

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

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

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

package/dist/elements/services/instanceService/IInstanceService.js

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

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

@@ -1,4 +1,4 @@
-import { IDesignItem } from "../../item/IDesignItem.js";
-export interface IPrepareElementsForDesignerService {
-    prepareElementsForDesigner(designItem: IDesignItem): any;
-}
+import { IDesignItem } from "../../item/IDesignItem.js";
+export interface IPrepareElementsForDesignerService {
+    prepareElementsForDesigner(designItem: IDesignItem): any;
+}

package/dist/elements/services/instanceService/IPrepareElementsForDesignerService.js

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

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

@@ -1,6 +1,6 @@
-import { IDesignItem } from "../../item/IDesignItem.js";
-import { IPrepareElementsForDesignerService } from "./IPrepareElementsForDesignerService.js";
-export declare class PrepareElementsForDesignerService implements IPrepareElementsForDesignerService {
-    prepareElementsForDesigner(designItem: IDesignItem): void;
-    private _prepareElementsForDesigner;
-}
+import { IDesignItem } from "../../item/IDesignItem.js";
+import { IPrepareElementsForDesignerService } from "./IPrepareElementsForDesignerService.js";
+export declare class PrepareElementsForDesignerService implements IPrepareElementsForDesignerService {
+    prepareElementsForDesigner(designItem: IDesignItem): void;
+    private _prepareElementsForDesigner;
+}

package/dist/elements/services/instanceService/PrepareElementsForDesignerService.js

@@ -1,32 +1,32 @@
-export class PrepareElementsForDesignerService {
-    prepareElementsForDesigner(designItem) {
-        if (designItem !== designItem.instanceServiceContainer.contentService.rootDesignItem)
-            this._prepareElementsForDesigner([designItem.element], true);
-        this._prepareElementsForDesigner(designItem.element.querySelectorAll('*'), true);
-    }
-    _prepareElementsForDesigner(elements, rootElements) {
-        for (let el of elements) {
-            if (el.shadowRoot) {
-                this._prepareElementsForDesigner((el.shadowRoot).querySelectorAll('*'), false);
-            }
-            if (el instanceof HTMLElement) {
-                el.onclick = null;
-                el.onmousedown = null;
-                el.onmouseup = null;
-                if (!rootElements)
-                    el.style.pointerEvents = 'none';
-            }
-            if (el instanceof HTMLImageElement) {
-                el.draggable = false;
-            }
-            else if (el instanceof HTMLInputElement) {
-                el.onmousedown = (e) => e.preventDefault();
-                //const ip = el;
-                //el.onclick = (e) => { if (ip.type == 'checkbox') ip.checked = !ip.checked };
-            }
-            else if (el instanceof HTMLSelectElement) {
-                el.onmousedown = (e) => e.preventDefault();
-            }
-        }
-    }
-}
+export class PrepareElementsForDesignerService {
+    prepareElementsForDesigner(designItem) {
+        if (designItem !== designItem.instanceServiceContainer.contentService.rootDesignItem)
+            this._prepareElementsForDesigner([designItem.element], true);
+        this._prepareElementsForDesigner(designItem.element.querySelectorAll('*'), true);
+    }
+    _prepareElementsForDesigner(elements, rootElements) {
+        for (let el of elements) {
+            if (el.shadowRoot) {
+                this._prepareElementsForDesigner((el.shadowRoot).querySelectorAll('*'), false);
+            }
+            if (el instanceof HTMLElement) {
+                el.onclick = null;
+                el.onmousedown = null;
+                el.onmouseup = null;
+                if (!rootElements)
+                    el.style.pointerEvents = 'none';
+            }
+            if (el instanceof HTMLImageElement) {
+                el.draggable = false;
+            }
+            else if (el instanceof HTMLInputElement) {
+                el.onmousedown = (e) => e.preventDefault();
+                //const ip = el;
+                //el.onclick = (e) => { if (ip.type == 'checkbox') ip.checked = !ip.checked };
+            }
+            else if (el instanceof HTMLSelectElement) {
+                el.onmousedown = (e) => e.preventDefault();
+            }
+        }
+    }
+}

package/dist/elements/services/modelCommandService/DefaultModelCommandService.d.ts

@@ -1,7 +1,7 @@
-import { IUiCommand } from "../../../commandHandling/IUiCommand.js";
-import { IDesignerCanvas } from "../../widgets/designerView/IDesignerCanvas.js";
-import { IModelCommandService } from "./IModelCommandService.js";
-export declare class DefaultModelCommandService implements IModelCommandService {
-    canExecuteCommand(designerCanvas: IDesignerCanvas, command: IUiCommand): boolean;
-    executeCommand(designerCanvas: IDesignerCanvas, command: IUiCommand): Promise<boolean>;
-}
+import { IUiCommand } from "../../../commandHandling/IUiCommand.js";
+import { IDesignerCanvas } from "../../widgets/designerView/IDesignerCanvas.js";
+import { IModelCommandService } from "./IModelCommandService.js";
+export declare class DefaultModelCommandService implements IModelCommandService {
+    canExecuteCommand(designerCanvas: IDesignerCanvas, command: IUiCommand): boolean;
+    executeCommand(designerCanvas: IDesignerCanvas, command: IUiCommand): Promise<boolean>;
+}