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

package/dist/elements/widgets/codeView/code-view-ace.js

@@ -1,134 +0,0 @@
-import { BaseCustomWebComponentLazyAppend, css, TypedEvent } from '@node-projects/base-custom-webcomponent';
-import { CommandType } from '../../../commandHandling/CommandType.js';
-class CodeViewAceCompleter {
-    getCompletions(editor, session, pos, prefix, callback) {
-        if (prefix.length === 0) {
-            callback(null, []);
-            return;
-        }
-        let wordList = ['t-t', 'visu-conveyor']; //TODO: get word list from custom elements 
-        {
-            callback(null, wordList.map((w) => {
-                return { name: w, value: w, score: 1, meta: "tag" };
-            }));
-        }
-    }
-}
-export class CodeViewAce extends BaseCustomWebComponentLazyAppend {
-    canvasElement;
-    elementsToPackages;
-    code;
-    onTextChanged = new TypedEvent();
-    _aceEditor;
-    _editor;
-    static style = css `
-    :host {
-      display: block;
-      height: 100%;
-      width: 100%;
-    }
-    `;
-    constructor() {
-        super();
-        this._restoreCachedInititalValues();
-        this.style.display = 'block';
-        this._editor = document.createElement("div");
-        this._editor.style.height = '100%';
-        this._editor.style.width = '100%';
-        this.shadowRoot.appendChild(this._editor);
-    }
-    dispose() {
-        this._aceEditor?.destroy();
-    }
-    executeCommand(command) {
-        switch (command.type) {
-            case CommandType.undo:
-                this._aceEditor.execCommand('undo');
-                break;
-            case CommandType.redo:
-                this._aceEditor.execCommand('redo');
-                break;
-            case CommandType.copy:
-                let text = this._aceEditor.getCopyText();
-                this._aceEditor.execCommand("copy");
-                navigator.clipboard.writeText(text);
-                break;
-            case CommandType.paste:
-                navigator.clipboard.readText().then(text => {
-                    this._aceEditor.execCommand("paste", text);
-                });
-                break;
-            case CommandType.cut:
-                text = this._aceEditor.getCopyText();
-                this._aceEditor.execCommand("cut");
-                navigator.clipboard.writeText(text);
-                break;
-            case CommandType.delete:
-                this._aceEditor.execCommand("delete");
-                break;
-        }
-    }
-    canExecuteCommand(command) {
-        switch (command.type) {
-            case CommandType.undo:
-            case CommandType.redo:
-            case CommandType.copy:
-            case CommandType.paste:
-            case CommandType.cut:
-            case CommandType.delete:
-                return true;
-        }
-        return false;
-    }
-    focusEditor() {
-        requestAnimationFrame(() => {
-            this.focus();
-            this._aceEditor.focus();
-        });
-    }
-    oneTimeSetup() {
-        //@ts-ignore
-        let langTools = ace.require("ace/ext/language_tools");
-        langTools.addCompleter(new CodeViewAceCompleter());
-    }
-    ready() {
-        //@ts-ignore
-        this._aceEditor = ace.edit(this._editor, {
-            theme: "ace/theme/chrome",
-            mode: "ace/mode/html",
-            value: "",
-            autoScrollEditorIntoView: true,
-            fontSize: "14px",
-            showPrintMargin: false,
-            displayIndentGuides: true,
-            enableBasicAutocompletion: true,
-            enableSnippets: true,
-            enableLiveAutocompletion: true
-        });
-        //own snippet completer: http://plnkr.co/edit/6MVntVmXYUbjR0DI82Cr?p=preview
-        this._aceEditor.renderer.attachToShadowRoot();
-        let observer = new MutationObserver((m) => {
-            this._aceEditor.setAutoScrollEditorIntoView(false);
-            this._aceEditor.setAutoScrollEditorIntoView(true);
-        });
-        let config = { attributes: true, childList: true, characterData: true };
-        observer.observe(this.shadowRoot.querySelector('.ace_content'), config);
-        this._aceEditor.on('change', () => this.onTextChanged.emit(this._aceEditor.getValue()));
-    }
-    update(code) {
-        this._aceEditor.setValue(code);
-        this._aceEditor.clearSelection();
-    }
-    getText() {
-        return this._aceEditor.getValue();
-    }
-    setSelection(position) {
-        let point1 = this._aceEditor.session.getDocument().indexToPosition(position.start, 0);
-        let point2 = this._aceEditor.session.getDocument().indexToPosition(position.start + position.length, 0);
-        //@ts-ignore
-        this._aceEditor.selection.setRange({ start: point1, end: point2 });
-        //@ts-ignore
-        this._aceEditor.scrollToLine(point1.row);
-    }
-}
-customElements.define('node-projects-code-view-ace', CodeViewAce);

package/dist/elements/widgets/codeView/code-view-code-mirror.d.ts

@@ -1,25 +0,0 @@
-import { BaseCustomWebComponentLazyAppend, TypedEvent } from '@node-projects/base-custom-webcomponent';
-import { ICodeView } from './ICodeView.js';
-import { IStringPosition } from '../../services/htmlWriterService/IStringPosition.js';
-import { IUiCommand } from '../../../commandHandling/IUiCommand.js';
-import { IDisposable } from '../../../interfaces/IDisposable.js';
-export declare class CodeViewCodeMirror extends BaseCustomWebComponentLazyAppend implements ICodeView, IDisposable {
-    canvasElement: HTMLElement;
-    elementsToPackages: Map<string, string>;
-    code: string;
-    onTextChanged: TypedEvent<string>;
-    mode: string;
-    private _codeMirrorEditor;
-    private _editor;
-    static readonly style: CSSStyleSheet;
-    static readonly template: HTMLTemplateElement;
-    constructor();
-    dispose(): void;
-    executeCommand(command: IUiCommand): void;
-    canExecuteCommand(command: IUiCommand): boolean;
-    focusEditor(): void;
-    ready(): void;
-    update(code: any): void;
-    getText(): string;
-    setSelection(position: IStringPosition): void;
-}

package/dist/elements/widgets/codeView/code-view-code-mirror.js

@@ -1,117 +0,0 @@
-import { BaseCustomWebComponentLazyAppend, css, html, TypedEvent } from '@node-projects/base-custom-webcomponent';
-import { CommandType } from '../../../commandHandling/CommandType.js';
-export class CodeViewCodeMirror extends BaseCustomWebComponentLazyAppend {
-    canvasElement;
-    elementsToPackages;
-    code;
-    onTextChanged = new TypedEvent();
-    mode = 'xml';
-    _codeMirrorEditor;
-    _editor;
-    static style = css `
-    :host {
-      display: block;
-      height: 100%;
-      width: 100%;
-    }`;
-    static template = html `
-    <div  style="width: 100%; height: 100%; overflow: auto;">
-      <div id="textarea"></div>
-    </div>`;
-    constructor() {
-        super();
-        this._restoreCachedInititalValues();
-        //@ts-ignore
-        if (window.importShim) {
-            //@ts-ignore
-            importShim("codemirror/lib/codemirror.css", { assert: { type: 'css' } }).then(x => this.shadowRoot.adoptedStyleSheets = [x.default, ...this.shadowRoot.adoptedStyleSheets]);
-            //@ts-ignore
-            importShim("codemirror/addon/fold/foldgutter.css", { assert: { type: 'css' } }).then(x => this.shadowRoot.adoptedStyleSheets = [x.default, ...this.shadowRoot.adoptedStyleSheets]);
-        }
-        else {
-            //@ts-ignore
-            import("codemirror/lib/codemirror.css", { assert: { type: 'css' } }).then(x => this.shadowRoot.adoptedStyleSheets = [x.default, ...this.shadowRoot.adoptedStyleSheets]);
-            //@ts-ignore
-            import("codemirror/addon/fold/foldgutter.css", { assert: { type: 'css' } }).then(x => this.shadowRoot.adoptedStyleSheets = [x.default, ...this.shadowRoot.adoptedStyleSheets]);
-        }
-        this.style.display = 'block';
-        this._editor = this._getDomElement('textarea');
-    }
-    dispose() {
-    }
-    executeCommand(command) {
-        switch (command.type) {
-            case CommandType.undo:
-                this._codeMirrorEditor.undo();
-                break;
-            case CommandType.redo:
-                this._codeMirrorEditor.redo();
-                break;
-            case CommandType.copy:
-                const text = this._codeMirrorEditor.getSelection();
-                navigator.clipboard.writeText(text);
-                break;
-            case CommandType.paste:
-                navigator.clipboard.readText().then(text => {
-                    this._codeMirrorEditor.replaceSelection(text);
-                });
-                break;
-            case CommandType.cut:
-                const textc = this._codeMirrorEditor.getSelection();
-                navigator.clipboard.writeText(textc);
-                this._codeMirrorEditor.replaceSelection('');
-                break;
-            case CommandType.delete:
-                this._codeMirrorEditor.replaceSelection('');
-                break;
-        }
-    }
-    canExecuteCommand(command) {
-        switch (command.type) {
-            case CommandType.undo:
-            case CommandType.redo:
-            case CommandType.copy:
-            case CommandType.paste:
-            case CommandType.cut:
-            case CommandType.delete:
-                return true;
-        }
-        return false;
-    }
-    focusEditor() {
-        requestAnimationFrame(() => {
-            this.focus();
-            this._codeMirrorEditor.focus();
-        });
-    }
-    ready() {
-        const config = {
-            tabSize: 3,
-            lineNumbers: true,
-            mode: this.mode,
-            //@ts-ignore
-            htmlMode: true,
-            lineWrapping: true,
-            //@ts-ignore
-            extraKeys: { "Ctrl-Q": function (cm) { cm.foldCode(cm.getCursor()); } },
-            foldGutter: true,
-            gutters: ["CodeMirror-linenumbers", "CodeMirror-foldgutter"]
-        };
-        //@ts-ignore
-        this._codeMirrorEditor = CodeMirror(this._editor, config);
-        this._codeMirrorEditor.setSize('100%', '100%');
-        this._codeMirrorEditor.on('change', () => this.onTextChanged.emit(this._codeMirrorEditor.getValue()));
-    }
-    update(code) {
-        this._codeMirrorEditor.setValue(code);
-    }
-    getText() {
-        return this._codeMirrorEditor.getValue();
-    }
-    setSelection(position) {
-        let point1 = this._codeMirrorEditor.posFromIndex(position.start);
-        let point2 = this._codeMirrorEditor.posFromIndex(position.start + position.length);
-        this._codeMirrorEditor.setSelection(point1, point2);
-    }
-}
-customElements.define('node-projects-code-view-code-mirror', CodeViewCodeMirror);

package/dist/elements/widgets/codeView/code-view-monaco.d.ts

@@ -1,37 +0,0 @@
-import { BaseCustomWebComponentLazyAppend, TypedEvent } from '@node-projects/base-custom-webcomponent';
-import { ICodeView } from './ICodeView.js';
-import { IActivateable } from '../../../interfaces/IActivateable.js';
-import { IStringPosition } from '../../services/htmlWriterService/IStringPosition.js';
-import { IUiCommandHandler } from '../../../commandHandling/IUiCommandHandler.js';
-import { IUiCommand } from '../../../commandHandling/IUiCommand.js';
-export declare class CodeViewMonaco extends BaseCustomWebComponentLazyAppend implements ICodeView, IActivateable, IUiCommandHandler {
-    private static _initalized;
-    dispose(): void;
-    canvasElement: HTMLElement;
-    elementsToPackages: Map<string, string>;
-    code: string;
-    onTextChanged: TypedEvent<string>;
-    language: string;
-    private _theme;
-    get theme(): string;
-    set theme(value: string);
-    static readonly properties: {
-        code: StringConstructor;
-        language: StringConstructor;
-        theme: StringConstructor;
-    };
-    private _monacoEditor;
-    private _editor;
-    static readonly style: CSSStyleSheet;
-    static readonly template: HTMLTemplateElement;
-    executeCommand(command: IUiCommand): void;
-    canExecuteCommand(command: IUiCommand): boolean;
-    static initMonacoEditor(): Promise<void>;
-    constructor();
-    ready(): Promise<void>;
-    focusEditor(): void;
-    activated(): void;
-    update(code: any): void;
-    getText(): any;
-    setSelection(position: IStringPosition): void;
-}

package/dist/elements/widgets/codeView/code-view-monaco.js

@@ -1,197 +0,0 @@
-import { BaseCustomWebComponentLazyAppend, css, html, TypedEvent } from '@node-projects/base-custom-webcomponent';
-import { CommandType } from '../../../commandHandling/CommandType.js';
-export class CodeViewMonaco extends BaseCustomWebComponentLazyAppend {
-    static _initalized;
-    dispose() {
-        this._monacoEditor?.dispose();
-    }
-    canvasElement;
-    elementsToPackages;
-    code;
-    onTextChanged = new TypedEvent();
-    language = 'html';
-    _theme = 'webComponentDesignerTheme';
-    get theme() {
-        return this._theme;
-    }
-    set theme(value) {
-        this._theme = value;
-        //@ts-ignore
-        monaco.editor.setTheme(value);
-    }
-    static properties = {
-        code: String,
-        language: String,
-        theme: String
-    };
-    //@ts-ignore
-    _monacoEditor;
-    _editor;
-    static style = css `
-    :host {
-      display: block;
-      height: 100%;
-      width: 100%;
-    }
-    `;
-    static template = html `
-      <div id="container" style="overflow: hidden; width: 100%; height: 100%; position: absolute;"></div>
-  `;
-    executeCommand(command) {
-        switch (command.type) {
-            case CommandType.undo:
-                this._monacoEditor.trigger('source', 'undo', null);
-                break;
-            case CommandType.redo:
-                this._monacoEditor.trigger('source', 'redo', null);
-                break;
-            case CommandType.copy:
-                this._monacoEditor.trigger('source', 'editor.action.clipboardCopyAction', null);
-                break;
-            case CommandType.paste:
-                this._monacoEditor.trigger('source', 'editor.action.clipboardPasteAction', null);
-                break;
-            case CommandType.cut:
-                break;
-            case CommandType.delete:
-                break;
-        }
-    }
-    canExecuteCommand(command) {
-        switch (command.type) {
-            case CommandType.undo:
-            case CommandType.redo:
-            case CommandType.copy:
-            case CommandType.paste:
-            case CommandType.cut:
-            case CommandType.delete:
-                return true;
-        }
-        return false;
-    }
-    static initMonacoEditor() {
-        return new Promise(async (resolve) => {
-            if (!CodeViewMonaco._initalized) {
-                CodeViewMonaco._initalized = true;
-                //@ts-ignore
-                require.config({ paths: { 'vs': 'node_modules/monaco-editor/min/vs' } });
-                //@ts-ignore
-                require(['vs/editor/editor.main'], () => {
-                    //@ts-ignore
-                    monaco.editor.defineTheme('webComponentDesignerTheme', {
-                        base: 'vs',
-                        inherit: true,
-                        //@ts-ignore
-                        rules: [{ background: 'EDF9FA' }],
-                        colors: {
-                            'editor.selectionBackground': '#add6ff',
-                            'editor.inactiveSelectionBackground': '#add6ff'
-                        }
-                    });
-                    //@ts-ignore
-                    monaco.editor.setTheme('webComponentDesignerTheme');
-                    resolve();
-                });
-            }
-            else {
-                resolve();
-            }
-        });
-    }
-    constructor() {
-        super();
-        this._restoreCachedInititalValues();
-    }
-    async ready() {
-        this._parseAttributesToProperties();
-        let style;
-        //@ts-ignore
-        if (window.importShim)
-            //@ts-ignore
-            style = await importShim("monaco-editor/min/vs/editor/editor.main.css", { assert: { type: 'css' } });
-        else
-            //@ts-ignore
-            style = await import("monaco-editor/min/vs/editor/editor.main.css", { assert: { type: 'css' } });
-        this.shadowRoot.adoptedStyleSheets = [style.default, this.constructor.style];
-        this._editor = this._getDomElement('container');
-        await CodeViewMonaco.initMonacoEditor();
-        const resizeObserver = new ResizeObserver(() => {
-            if (this._editor.offsetWidth > 0) {
-                //@ts-ignore
-                this._monacoEditor = monaco.editor.create(this._editor, {
-                    automaticLayout: true,
-                    wordWrapColumn: 1000,
-                    //wordWrap: 'wordWrapColumn',
-                    fontLigatures: '',
-                    value: this.code,
-                    language: this.language,
-                    minimap: {
-                        size: 'fill'
-                    },
-                    fixedOverflowWidgets: true,
-                    scrollbar: {
-                        useShadows: false,
-                        verticalHasArrows: true,
-                        horizontalHasArrows: true,
-                        vertical: 'visible',
-                        horizontal: 'visible'
-                    }
-                });
-                //@ts-ignore
-                monaco.editor.setTheme(this.theme);
-                let changeContentListener = this._monacoEditor.getModel().onDidChangeContent(e => {
-                    this.onTextChanged.emit(this._monacoEditor.getValue());
-                });
-                this._monacoEditor.onDidChangeModel(e => {
-                    changeContentListener.dispose();
-                    changeContentListener = this._monacoEditor.getModel().onDidChangeContent(e => {
-                        this.onTextChanged.emit(this._monacoEditor.getValue());
-                    });
-                });
-                this._monacoEditor.focus();
-                resizeObserver.disconnect();
-            }
-            ;
-        });
-        resizeObserver.observe(this._editor);
-    }
-    focusEditor() {
-        requestAnimationFrame(() => {
-            this.focus();
-            if (this._monacoEditor)
-                this._monacoEditor.focus();
-        });
-    }
-    activated() {
-        if (this._monacoEditor)
-            if (this._monacoEditor)
-                this._monacoEditor.layout();
-    }
-    update(code) {
-        this.code = code;
-        if (this._monacoEditor) {
-            if (this._monacoEditor)
-                this._monacoEditor.setValue(code);
-            //@ts-ignore
-            monaco.editor.setModelLanguage(this._monacoEditor.getModel(), this.language);
-            //@ts-ignore
-            monaco.editor.setTheme(this.theme);
-        }
-    }
-    getText() {
-        return this._monacoEditor.getValue();
-    }
-    setSelection(position) {
-        if (this._monacoEditor) {
-            let model = this._monacoEditor.getModel();
-            let point1 = model.getPositionAt(position.start);
-            let point2 = model.getPositionAt(position.start + position.length);
-            setTimeout(() => {
-                this._monacoEditor.setSelection({ startLineNumber: point1.lineNumber, startColumn: point1.column, endLineNumber: point2.lineNumber, endColumn: point2.column });
-                //@ts-ignore
-                this._monacoEditor.revealRangeInCenterIfOutsideViewport(new monaco.Range(point1.lineNumber, point1.column, point2.lineNumber, point2.column), 1);
-            }, 50);
-        }
-    }
-}
-customElements.define('node-projects-code-view-monaco', CodeViewMonaco);

package/dist/elements/widgets/designerView/extensions/EditText/EditTextWithStyloExtension.d.ts

@@ -1,23 +0,0 @@
-import { IDesignItem } from '../../../../item/IDesignItem.js';
-import { IDesignerCanvas } from '../../IDesignerCanvas.js';
-import { AbstractExtension } from "../AbstractExtension.js";
-import { IExtensionManager } from '../IExtensionManger.js';
-import { handlesPointerEvent } from './EditTextExtension.js';
-export declare class EditTextWithStyloExtension extends AbstractExtension implements handlesPointerEvent {
-    private _contentEditedBound;
-    private _blurBound;
-    private static template;
-    private _resizeObserver;
-    private _rect1;
-    private _rect2;
-    private _rect3;
-    private _rect4;
-    private _foreignObject;
-    constructor(extensionManager: IExtensionManager, designerView: IDesignerCanvas, extendedItem: IDesignItem);
-    extend(): void;
-    private _drawClickOverlayRects;
-    handlesPointerEvent(designerCanvas: IDesignerCanvas, event: PointerEvent, currentElement: Element): boolean;
-    refresh(): void;
-    dispose(): void;
-    _clickOutside(e: any): void;
-}

package/dist/elements/widgets/designerView/extensions/EditText/EditTextWithStyloExtension.js

@@ -1,87 +0,0 @@
-import { html } from "@node-projects/base-custom-webcomponent";
-import { TextTool } from '../../tools/TextTool.js';
-import { AbstractExtension } from "../AbstractExtension.js";
-import { ExtensionType } from "../ExtensionType.js";
-import { OverlayLayer } from "../OverlayLayer.js";
-export class EditTextWithStyloExtension extends AbstractExtension {
-    _contentEditedBound;
-    _blurBound;
-    static template = html `
-    <stylo-editor></stylo-editor>
-  `;
-    _resizeObserver;
-    _rect1;
-    _rect2;
-    _rect3;
-    _rect4;
-    _foreignObject;
-    constructor(extensionManager, designerView, extendedItem) {
-        super(extensionManager, designerView, extendedItem);
-        import('@papyrs/stylo/dist/esm/loader.js').then(d => d.defineCustomElements());
-    }
-    extend() {
-        this.extendedItem.instanceServiceContainer.selectionService.clearSelectedElements();
-        this.extendedItem.element.setAttribute('contenteditable', 'true');
-        this.extendedItem.element.addEventListener('input', this._contentEditedBound);
-        this.extendedItem.element.addEventListener('blur', this._blurBound);
-        this.extendedItem.element.focus();
-        this.designerCanvas.eatEvents = this.extendedItem.element;
-        this.designerCanvas.serviceContainer.globalContext.tool = new TextTool(true);
-        const elements = EditTextWithStyloExtension.template.content.cloneNode(true);
-        const foreignObject = document.createElementNS('http://www.w3.org/2000/svg', 'foreignObject');
-        this._foreignObject = foreignObject;
-        foreignObject.setAttribute('x', '0');
-        foreignObject.setAttribute('y', '0');
-        foreignObject.setAttribute('width', '100%');
-        foreignObject.setAttribute('height', '100%');
-        foreignObject.appendChild(elements);
-        this._addOverlay(foreignObject, OverlayLayer.Foregorund);
-        this._drawClickOverlayRects();
-        this._rect1.addEventListener('pointerdown', (e) => this._clickOutside(e));
-        this._rect2.addEventListener('pointerdown', (e) => this._clickOutside(e));
-        this._rect3.addEventListener('pointerdown', (e) => this._clickOutside(e));
-        this._rect4.addEventListener('pointerdown', (e) => this._clickOutside(e));
-        requestAnimationFrame(() => {
-            const stylo = foreignObject.querySelector('stylo-editor');
-            //@ts-ignore
-            stylo.containerRef = this.extendedItem.element;
-            //@ts-ignore
-            stylo.config = {
-                dontInjectHeadCss: true
-            };
-        });
-        this.designerCanvas.clickOverlay.style.pointerEvents = 'none';
-        this._resizeObserver = new ResizeObserver(() => this._drawClickOverlayRects());
-        this._resizeObserver.observe(this.extendedItem.element);
-    }
-    _drawClickOverlayRects() {
-        const normalized = this.designerCanvas.getNormalizedElementCoordinates(this.extendedItem.element);
-        this._rect1 = this._drawRect(0, 0, this.designerCanvas.containerBoundingRect.width, normalized.y, 'svg-transparent', this._rect1, OverlayLayer.Normal);
-        this._rect2 = this._drawRect(0, 0, normalized.x, this.designerCanvas.containerBoundingRect.height, 'svg-transparent', this._rect2, OverlayLayer.Normal);
-        this._rect3 = this._drawRect(normalized.x + normalized.width, 0, this.designerCanvas.containerBoundingRect.width, this.designerCanvas.containerBoundingRect.height, 'svg-transparent', this._rect3, OverlayLayer.Normal);
-        this._rect4 = this._drawRect(0, normalized.y + normalized.height, this.designerCanvas.containerBoundingRect.width, this.designerCanvas.containerBoundingRect.height, 'svg-transparent', this._rect4, OverlayLayer.Normal);
-    }
-    handlesPointerEvent(designerCanvas, event, currentElement) {
-        let p = event.composedPath();
-        const stylo = this._foreignObject.querySelector('stylo-editor');
-        return p.indexOf(stylo) >= 0;
-    }
-    refresh() {
-        this.dispose();
-    }
-    dispose() {
-        this._resizeObserver.disconnect();
-        this._removeAllOverlays();
-        this.extendedItem.element.removeAttribute('contenteditable');
-        this.designerCanvas.eatEvents = null;
-        this.extendedItem.updateChildrenFromNodesChildren();
-        this.designerCanvas.clickOverlay.style.pointerEvents = 'auto';
-    }
-    _clickOutside(e) {
-        this.extendedItem.innerHTML = this.extendedItem.element.innerHTML;
-        //TODO: the extension should remove itself, not the doubleclick extensions
-        //      cause the extension could be applied in another way
-        //maybe also the removal is maybe not desired (for example if it's permanet extension)
-        this.extensionManager.removeExtension(this.extendedItem, ExtensionType.Doubleclick);
-    }
-}

package/dist/elements/widgets/designerView/extensions/EditText/EditTextWithStyloExtensionProvider.d.ts

@@ -1,10 +0,0 @@
-import { IDesignerExtensionProvider } from '../IDesignerExtensionProvider.js';
-import { IDesignItem } from '../../../../item/IDesignItem.js';
-import { IDesignerCanvas } from '../../IDesignerCanvas.js';
-import { IDesignerExtension } from '../IDesignerExtension.js';
-import { IExtensionManager } from '../IExtensionManger.js';
-export declare class EditTextWithStyloExtensionProvider implements IDesignerExtensionProvider {
-    shouldExtend(extensionManager: IExtensionManager, designerView: IDesignerCanvas, designItem: IDesignItem): boolean;
-    getExtension(extensionManager: IExtensionManager, designerView: IDesignerCanvas, designItem: IDesignItem): IDesignerExtension;
-    readonly style: CSSStyleSheet;
-}

package/dist/elements/widgets/designerView/extensions/EditText/EditTextWithStyloExtensionProvider.js

@@ -1,15 +0,0 @@
-import { EditTextWithStyloExtension } from "./EditTextWithStyloExtension.js";
-import { css } from "@node-projects/base-custom-webcomponent";
-export class EditTextWithStyloExtensionProvider {
-    shouldExtend(extensionManager, designerView, designItem) {
-        if (designItem.name === 'button' || designItem.name === 'input')
-            return false;
-        return true;
-    }
-    getExtension(extensionManager, designerView, designItem) {
-        return new EditTextWithStyloExtension(extensionManager, designerView, designItem);
-    }
-    style = css `
-  .svg-transparent { stroke: none; fill: transparent; pointer-events: all; }
-`;
-}

package/dist/elements/widgets/miniatureView/html-2-canvas-miniature-view.d.ts

@@ -1,10 +0,0 @@
-import { BaseCustomWebComponentLazyAppend } from '@node-projects/base-custom-webcomponent';
-import { IDesignerCanvas } from '../designerView/IDesignerCanvas.js';
-import { IMiniatureView } from './IMiniatureView.js';
-export declare class Html2CanvasMiniatureView extends BaseCustomWebComponentLazyAppend implements IMiniatureView {
-    static readonly style: CSSStyleSheet;
-    static readonly template: HTMLTemplateElement;
-    private _imgdiv;
-    constructor();
-    reRender(designerView: IDesignerCanvas): void;
-}