@node-projects/web-component-designer 0.0.216 → 0.0.217

package/dist/elements/widgets/designerView/tools/RectangleSelectorTool.d.ts

@@ -1,12 +1,12 @@
-import { ServiceContainer } from '../../../services/ServiceContainer.js';
-import { IDesignerCanvas } from '../IDesignerCanvas.js';
-import { ITool } from './ITool.js';
-export declare class RectangleSelectorTool implements ITool {
-    cursor: string;
-    private _rect;
-    private _initialPoint;
-    activated(serviceContainer: ServiceContainer): void;
-    pointerEventHandler(designerCanvas: IDesignerCanvas, event: PointerEvent, currentElement: Element): void;
-    keyboardEventHandler(designerCanvas: IDesignerCanvas, event: KeyboardEvent, currentElement: Element): void;
-    dispose(): void;
-}
+import { ServiceContainer } from '../../../services/ServiceContainer.js';
+import { IDesignerCanvas } from '../IDesignerCanvas.js';
+import { ITool } from './ITool.js';
+export declare class RectangleSelectorTool implements ITool {
+    cursor: string;
+    private _rect;
+    private _initialPoint;
+    activated(serviceContainer: ServiceContainer): void;
+    pointerEventHandler(designerCanvas: IDesignerCanvas, event: PointerEvent, currentElement: Element): void;
+    keyboardEventHandler(designerCanvas: IDesignerCanvas, event: KeyboardEvent, currentElement: Element): void;
+    dispose(): void;
+}

package/dist/elements/widgets/designerView/tools/RectangleSelectorTool.js

@@ -1,86 +1,86 @@
-import { EventNames } from '../../../../enums/EventNames.js';
-import { DesignItem } from '../../../item/DesignItem.js';
-import { OverlayLayer } from '../extensions/OverlayLayer.js';
-export class RectangleSelectorTool {
-    cursor = 'progress';
-    _rect;
-    _initialPoint;
-    activated(serviceContainer) {
-    }
-    pointerEventHandler(designerCanvas, event, currentElement) {
-        const currentPoint = designerCanvas.getNormalizedEventCoordinates(event);
-        switch (event.type) {
-            case EventNames.PointerDown:
-                event.target.setPointerCapture(event.pointerId);
-                designerCanvas.captureActiveTool(this);
-                this._initialPoint = currentPoint;
-                if (!this._rect)
-                    this._rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
-                this._rect.setAttribute('class', 'svg-selector');
-                this._rect.setAttribute('x', (this._initialPoint.x * designerCanvas.scaleFactor));
-                this._rect.setAttribute('y', (this._initialPoint.y * designerCanvas.scaleFactor));
-                this._rect.setAttribute('width', 0);
-                this._rect.setAttribute('height', 0);
-                this._rect.style.strokeWidth = '' + (1 / designerCanvas.scaleFactor);
-                this._rect.style.strokeDasharray = '' + (2 / designerCanvas.scaleFactor);
-                designerCanvas.overlayLayer.addOverlay(this._rect, OverlayLayer.Foregorund);
-                break;
-            case EventNames.PointerMove:
-                if (this._initialPoint) {
-                    let w = currentPoint.x - this._initialPoint.x;
-                    let h = currentPoint.y - this._initialPoint.y;
-                    if (w >= 0) {
-                        this._rect.setAttribute('x', this._initialPoint.x);
-                        this._rect.setAttribute('width', w);
-                    }
-                    else {
-                        this._rect.setAttribute('x', currentPoint.x);
-                        this._rect.setAttribute('width', (-1 * w));
-                    }
-                    if (h >= 0) {
-                        this._rect.setAttribute('y', this._initialPoint.y);
-                        this._rect.setAttribute('height', h);
-                    }
-                    else {
-                        this._rect.setAttribute('y', currentPoint.y);
-                        this._rect.setAttribute('height', (-1 * h));
-                    }
-                }
-                break;
-            case EventNames.PointerUp:
-                event.target.releasePointerCapture(event.pointerId);
-                designerCanvas.releaseActiveTool();
-                const elements = designerCanvas.rootDesignItem.element.querySelectorAll('*');
-                const inSelectionElements = [];
-                let point = designerCanvas.overlayLayer.createPoint();
-                for (let e of elements) {
-                    let elementRect = designerCanvas.getNormalizedElementCoordinates(e);
-                    point.x = elementRect.x;
-                    point.y = elementRect.y;
-                    const p1 = this._rect.isPointInFill(point);
-                    point.x = elementRect.x + elementRect.width;
-                    point.y = elementRect.y;
-                    const p2 = p1 && this._rect.isPointInFill(point);
-                    point.x = elementRect.x;
-                    point.y = elementRect.y + elementRect.height;
-                    const p3 = p2 && this._rect.isPointInFill(point);
-                    point.x = elementRect.x + elementRect.width;
-                    point.y = elementRect.y + elementRect.height;
-                    const p4 = p3 && this._rect.isPointInFill(point);
-                    if (p4) {
-                        const desItem = DesignItem.GetOrCreateDesignItem(e, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
-                        inSelectionElements.push(desItem);
-                    }
-                }
-                designerCanvas.overlayLayer.removeOverlay(this._rect);
-                this._rect = null;
-                this._initialPoint = null;
-                designerCanvas.instanceServiceContainer.selectionService.setSelectedElements(inSelectionElements);
-                designerCanvas.serviceContainer.globalContext.finishedWithTool(this);
-                break;
-        }
-    }
-    keyboardEventHandler(designerCanvas, event, currentElement) { }
-    dispose() {
-    }
-}
+import { EventNames } from '../../../../enums/EventNames.js';
+import { DesignItem } from '../../../item/DesignItem.js';
+import { OverlayLayer } from '../extensions/OverlayLayer.js';
+export class RectangleSelectorTool {
+    cursor = 'progress';
+    _rect;
+    _initialPoint;
+    activated(serviceContainer) {
+    }
+    pointerEventHandler(designerCanvas, event, currentElement) {
+        const currentPoint = designerCanvas.getNormalizedEventCoordinates(event);
+        switch (event.type) {
+            case EventNames.PointerDown:
+                event.target.setPointerCapture(event.pointerId);
+                designerCanvas.captureActiveTool(this);
+                this._initialPoint = currentPoint;
+                if (!this._rect)
+                    this._rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+                this._rect.setAttribute('class', 'svg-selector');
+                this._rect.setAttribute('x', (this._initialPoint.x * designerCanvas.scaleFactor));
+                this._rect.setAttribute('y', (this._initialPoint.y * designerCanvas.scaleFactor));
+                this._rect.setAttribute('width', 0);
+                this._rect.setAttribute('height', 0);
+                this._rect.style.strokeWidth = '' + (1 / designerCanvas.scaleFactor);
+                this._rect.style.strokeDasharray = '' + (2 / designerCanvas.scaleFactor);
+                designerCanvas.overlayLayer.addOverlay(this._rect, OverlayLayer.Foregorund);
+                break;
+            case EventNames.PointerMove:
+                if (this._initialPoint) {
+                    let w = currentPoint.x - this._initialPoint.x;
+                    let h = currentPoint.y - this._initialPoint.y;
+                    if (w >= 0) {
+                        this._rect.setAttribute('x', this._initialPoint.x);
+                        this._rect.setAttribute('width', w);
+                    }
+                    else {
+                        this._rect.setAttribute('x', currentPoint.x);
+                        this._rect.setAttribute('width', (-1 * w));
+                    }
+                    if (h >= 0) {
+                        this._rect.setAttribute('y', this._initialPoint.y);
+                        this._rect.setAttribute('height', h);
+                    }
+                    else {
+                        this._rect.setAttribute('y', currentPoint.y);
+                        this._rect.setAttribute('height', (-1 * h));
+                    }
+                }
+                break;
+            case EventNames.PointerUp:
+                event.target.releasePointerCapture(event.pointerId);
+                designerCanvas.releaseActiveTool();
+                const elements = designerCanvas.rootDesignItem.element.querySelectorAll('*');
+                const inSelectionElements = [];
+                let point = designerCanvas.overlayLayer.createPoint();
+                for (let e of elements) {
+                    let elementRect = designerCanvas.getNormalizedElementCoordinates(e);
+                    point.x = elementRect.x;
+                    point.y = elementRect.y;
+                    const p1 = this._rect.isPointInFill(point);
+                    point.x = elementRect.x + elementRect.width;
+                    point.y = elementRect.y;
+                    const p2 = p1 && this._rect.isPointInFill(point);
+                    point.x = elementRect.x;
+                    point.y = elementRect.y + elementRect.height;
+                    const p3 = p2 && this._rect.isPointInFill(point);
+                    point.x = elementRect.x + elementRect.width;
+                    point.y = elementRect.y + elementRect.height;
+                    const p4 = p3 && this._rect.isPointInFill(point);
+                    if (p4) {
+                        const desItem = DesignItem.GetOrCreateDesignItem(e, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
+                        inSelectionElements.push(desItem);
+                    }
+                }
+                designerCanvas.overlayLayer.removeOverlay(this._rect);
+                this._rect = null;
+                this._initialPoint = null;
+                designerCanvas.instanceServiceContainer.selectionService.setSelectedElements(inSelectionElements);
+                designerCanvas.serviceContainer.globalContext.finishedWithTool(this);
+                break;
+        }
+    }
+    keyboardEventHandler(designerCanvas, event, currentElement) { }
+    dispose() {
+    }
+}

package/dist/elements/widgets/designerView/tools/TextTool.d.ts

@@ -1,14 +1,14 @@
-import { ServiceContainer } from '../../../services/ServiceContainer.js';
-import { IDesignerCanvas } from '../IDesignerCanvas.js';
-import { ITool } from './ITool.js';
-export declare class TextTool implements ITool {
-    private _textEditExtensions;
-    constructor(editExistingText?: boolean);
-    activated(serviceContainer: ServiceContainer): void;
-    dispose(): void;
-    readonly cursor = "text";
-    private _textCreated;
-    private _editExistingText;
-    pointerEventHandler(designerCanvas: IDesignerCanvas, event: PointerEvent, currentElement: Element): void;
-    keyboardEventHandler(designerCanvas: IDesignerCanvas, event: KeyboardEvent, currentElement: Element): void;
-}
+import { ServiceContainer } from '../../../services/ServiceContainer.js';
+import { IDesignerCanvas } from '../IDesignerCanvas.js';
+import { ITool } from './ITool.js';
+export declare class TextTool implements ITool {
+    private _textEditExtensions;
+    constructor(editExistingText?: boolean);
+    activated(serviceContainer: ServiceContainer): void;
+    dispose(): void;
+    readonly cursor = "text";
+    private _textCreated;
+    private _editExistingText;
+    pointerEventHandler(designerCanvas: IDesignerCanvas, event: PointerEvent, currentElement: Element): void;
+    keyboardEventHandler(designerCanvas: IDesignerCanvas, event: KeyboardEvent, currentElement: Element): void;
+}

package/dist/elements/widgets/designerView/tools/TextTool.js

@@ -1,51 +1,51 @@
-import { EventNames } from '../../../../enums/EventNames.js';
-import { DesignItem } from '../../../item/DesignItem.js';
-import { InsertAction } from '../../../services/undoService/transactionItems/InsertAction.js';
-import { ExtensionType } from '../extensions/ExtensionType.js';
-export class TextTool {
-    _textEditExtensions;
-    constructor(editExistingText) {
-        if (editExistingText)
-            this._editExistingText = true;
-    }
-    activated(serviceContainer) {
-        this._textCreated = false;
-    }
-    dispose() {
-    }
-    cursor = 'text';
-    _textCreated = false;
-    _editExistingText = false;
-    pointerEventHandler(designerCanvas, event, currentElement) {
-        const currentPoint = designerCanvas.getNormalizedEventCoordinates(event);
-        switch (event.type) {
-            case EventNames.PointerDown:
-                if (!this._textCreated && !this._editExistingText) {
-                    this._textCreated = true;
-                    const span = document.createElement('span');
-                    const di = DesignItem.createDesignItemFromInstance(span, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
-                    di.setStyle('position', 'absolute');
-                    di.setStyle('left', currentPoint.x + 'px');
-                    di.setStyle('top', currentPoint.y + 'px');
-                    designerCanvas.instanceServiceContainer.undoService.execute(new InsertAction(designerCanvas.rootDesignItem, designerCanvas.rootDesignItem.childCount, di));
-                    //todo: Maybe we could also remove the eatEvents property
-                    //TODO - don't apply doubleclick extension (maybe it is not the doubleclick one) - apply edit text extesion directly
-                    //should we configure the editTextExtension anywhere??
-                    this._textEditExtensions = designerCanvas.extensionManager.applyExtension(di, ExtensionType.Doubleclick, event);
-                    setTimeout(() => { span.focus(); }, 50);
-                }
-                else {
-                    for (let e of this._textEditExtensions) {
-                        if (e.handlesPointerEvent) {
-                            const ret = e.handlesPointerEvent(designerCanvas, event, currentElement);
-                            if (!ret) {
-                                designerCanvas.serviceContainer.globalContext.finishedWithTool(this);
-                            }
-                        }
-                    }
-                }
-                break;
-        }
-    }
-    keyboardEventHandler(designerCanvas, event, currentElement) { }
-}
+import { EventNames } from '../../../../enums/EventNames.js';
+import { DesignItem } from '../../../item/DesignItem.js';
+import { InsertAction } from '../../../services/undoService/transactionItems/InsertAction.js';
+import { ExtensionType } from '../extensions/ExtensionType.js';
+export class TextTool {
+    _textEditExtensions;
+    constructor(editExistingText) {
+        if (editExistingText)
+            this._editExistingText = true;
+    }
+    activated(serviceContainer) {
+        this._textCreated = false;
+    }
+    dispose() {
+    }
+    cursor = 'text';
+    _textCreated = false;
+    _editExistingText = false;
+    pointerEventHandler(designerCanvas, event, currentElement) {
+        const currentPoint = designerCanvas.getNormalizedEventCoordinates(event);
+        switch (event.type) {
+            case EventNames.PointerDown:
+                if (!this._textCreated && !this._editExistingText) {
+                    this._textCreated = true;
+                    const span = document.createElement('span');
+                    const di = DesignItem.createDesignItemFromInstance(span, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
+                    di.setStyle('position', 'absolute');
+                    di.setStyle('left', currentPoint.x + 'px');
+                    di.setStyle('top', currentPoint.y + 'px');
+                    designerCanvas.instanceServiceContainer.undoService.execute(new InsertAction(designerCanvas.rootDesignItem, designerCanvas.rootDesignItem.childCount, di));
+                    //todo: Maybe we could also remove the eatEvents property
+                    //TODO - don't apply doubleclick extension (maybe it is not the doubleclick one) - apply edit text extesion directly
+                    //should we configure the editTextExtension anywhere??
+                    this._textEditExtensions = designerCanvas.extensionManager.applyExtension(di, ExtensionType.Doubleclick, event);
+                    setTimeout(() => { span.focus(); }, 50);
+                }
+                else {
+                    for (let e of this._textEditExtensions) {
+                        if (e.handlesPointerEvent) {
+                            const ret = e.handlesPointerEvent(designerCanvas, event, currentElement);
+                            if (!ret) {
+                                designerCanvas.serviceContainer.globalContext.finishedWithTool(this);
+                            }
+                        }
+                    }
+                }
+                break;
+        }
+    }
+    keyboardEventHandler(designerCanvas, event, currentElement) { }
+}

package/dist/elements/widgets/designerView/tools/ZoomTool.d.ts

@@ -1,17 +1,17 @@
-import { ServiceContainer } from '../../../services/ServiceContainer.js';
-import { IDesignerCanvas } from '../IDesignerCanvas.js';
-import { ITool } from './ITool.js';
-export declare class ZoomTool implements ITool {
-    cursor: string;
-    private _rect;
-    private _startPoint;
-    private _endPoint;
-    private _pointerMovementTolerance;
-    private _zoomStepSize;
-    activated(serviceContainer: ServiceContainer): void;
-    pointerEventHandler(designerCanvas: IDesignerCanvas, event: PointerEvent, currentElement: Element): void;
-    private _zoomOnto;
-    private _isPositionEqual;
-    keyboardEventHandler(designerCanvas: IDesignerCanvas, event: KeyboardEvent, currentElement: Element): void;
-    dispose(): void;
-}
+import { ServiceContainer } from '../../../services/ServiceContainer.js';
+import { IDesignerCanvas } from '../IDesignerCanvas.js';
+import { ITool } from './ITool.js';
+export declare class ZoomTool implements ITool {
+    cursor: string;
+    private _rect;
+    private _startPoint;
+    private _endPoint;
+    private _pointerMovementTolerance;
+    private _zoomStepSize;
+    activated(serviceContainer: ServiceContainer): void;
+    pointerEventHandler(designerCanvas: IDesignerCanvas, event: PointerEvent, currentElement: Element): void;
+    private _zoomOnto;
+    private _isPositionEqual;
+    keyboardEventHandler(designerCanvas: IDesignerCanvas, event: KeyboardEvent, currentElement: Element): void;
+    dispose(): void;
+}

package/dist/elements/widgets/designerView/tools/ZoomTool.js

@@ -1,82 +1,82 @@
-import { EventNames } from '../../../../enums/EventNames.js';
-import { OverlayLayer } from '../extensions/OverlayLayer.js';
-export class ZoomTool {
-    cursor = 'zoom-in';
-    _rect;
-    _startPoint;
-    _endPoint;
-    _pointerMovementTolerance = 5;
-    _zoomStepSize = 0.2; //number x 100 = Scale in percent
-    activated(serviceContainer) {
-    }
-    pointerEventHandler(designerCanvas, event, currentElement) {
-        const eventPoint = designerCanvas.getNormalizedEventCoordinates(event);
-        switch (event.type) {
-            case EventNames.PointerDown:
-                this._startPoint = eventPoint;
-                if (!this._rect)
-                    this._rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
-                this._rect.setAttribute('class', 'svg-selector');
-                this._rect.setAttribute('x', (this._startPoint.x * designerCanvas.zoomFactor));
-                this._rect.setAttribute('y', (this._startPoint.y * designerCanvas.zoomFactor));
-                this._rect.setAttribute('width', 0);
-                this._rect.setAttribute('height', 0);
-                this._rect.style.strokeWidth = '' + (1 / designerCanvas.scaleFactor);
-                this._rect.style.strokeDasharray = '' + (2 / designerCanvas.scaleFactor);
-                designerCanvas.overlayLayer.addOverlay(this._rect, OverlayLayer.Foregorund);
-                break;
-            case EventNames.PointerMove:
-                if (this._startPoint) {
-                    let width = eventPoint.x - this._startPoint.x;
-                    let height = eventPoint.y - this._startPoint.y;
-                    if (width >= 0) {
-                        this._rect.setAttribute('x', this._startPoint.x);
-                        this._rect.setAttribute('width', width);
-                    }
-                    else {
-                        this._rect.setAttribute('x', eventPoint.x);
-                        this._rect.setAttribute('width', (-1 * width));
-                    }
-                    if (height >= 0) {
-                        this._rect.setAttribute('y', this._startPoint.y);
-                        this._rect.setAttribute('height', height);
-                    }
-                    else {
-                        this._rect.setAttribute('y', eventPoint.y);
-                        this._rect.setAttribute('height', (-1 * height));
-                    }
-                }
-                break;
-            case EventNames.PointerUp:
-                this._endPoint = eventPoint;
-                let isLeftClick = event.button == 0;
-                switch (event.button) {
-                    case 0: //Left-Click
-                    case 2: //Right-Click
-                        this._zoomOnto(isLeftClick, this._startPoint, this._endPoint, designerCanvas);
-                        break;
-                }
-                designerCanvas.overlayLayer.removeOverlay(this._rect);
-                this._rect = null;
-                this._startPoint = null;
-                break;
-        }
-    }
-    _zoomOnto(isZoomInto, startPoint, endPoint, designerCanvas) {
-        if (this._isPositionEqual(startPoint, endPoint)) {
-            const oldZoom = designerCanvas.zoomFactor;
-            const newZoom = isZoomInto ? oldZoom + this._zoomStepSize : oldZoom - this._zoomStepSize;
-            designerCanvas.zoomTowardsPoint(endPoint, newZoom);
-        }
-        else {
-            designerCanvas.zoomOntoRectangle(startPoint, endPoint);
-        }
-    }
-    _isPositionEqual(startPoint, endPoint) {
-        let tolerance = this._pointerMovementTolerance;
-        return Math.abs(startPoint.x - endPoint.x) <= tolerance && Math.abs(startPoint.y - endPoint.y) <= tolerance;
-    }
-    keyboardEventHandler(designerCanvas, event, currentElement) { }
-    dispose() {
-    }
-}
+import { EventNames } from '../../../../enums/EventNames.js';
+import { OverlayLayer } from '../extensions/OverlayLayer.js';
+export class ZoomTool {
+    cursor = 'zoom-in';
+    _rect;
+    _startPoint;
+    _endPoint;
+    _pointerMovementTolerance = 5;
+    _zoomStepSize = 0.2; //number x 100 = Scale in percent
+    activated(serviceContainer) {
+    }
+    pointerEventHandler(designerCanvas, event, currentElement) {
+        const eventPoint = designerCanvas.getNormalizedEventCoordinates(event);
+        switch (event.type) {
+            case EventNames.PointerDown:
+                this._startPoint = eventPoint;
+                if (!this._rect)
+                    this._rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+                this._rect.setAttribute('class', 'svg-selector');
+                this._rect.setAttribute('x', (this._startPoint.x * designerCanvas.zoomFactor));
+                this._rect.setAttribute('y', (this._startPoint.y * designerCanvas.zoomFactor));
+                this._rect.setAttribute('width', 0);
+                this._rect.setAttribute('height', 0);
+                this._rect.style.strokeWidth = '' + (1 / designerCanvas.scaleFactor);
+                this._rect.style.strokeDasharray = '' + (2 / designerCanvas.scaleFactor);
+                designerCanvas.overlayLayer.addOverlay(this._rect, OverlayLayer.Foregorund);
+                break;
+            case EventNames.PointerMove:
+                if (this._startPoint) {
+                    let width = eventPoint.x - this._startPoint.x;
+                    let height = eventPoint.y - this._startPoint.y;
+                    if (width >= 0) {
+                        this._rect.setAttribute('x', this._startPoint.x);
+                        this._rect.setAttribute('width', width);
+                    }
+                    else {
+                        this._rect.setAttribute('x', eventPoint.x);
+                        this._rect.setAttribute('width', (-1 * width));
+                    }
+                    if (height >= 0) {
+                        this._rect.setAttribute('y', this._startPoint.y);
+                        this._rect.setAttribute('height', height);
+                    }
+                    else {
+                        this._rect.setAttribute('y', eventPoint.y);
+                        this._rect.setAttribute('height', (-1 * height));
+                    }
+                }
+                break;
+            case EventNames.PointerUp:
+                this._endPoint = eventPoint;
+                let isLeftClick = event.button == 0;
+                switch (event.button) {
+                    case 0: //Left-Click
+                    case 2: //Right-Click
+                        this._zoomOnto(isLeftClick, this._startPoint, this._endPoint, designerCanvas);
+                        break;
+                }
+                designerCanvas.overlayLayer.removeOverlay(this._rect);
+                this._rect = null;
+                this._startPoint = null;
+                break;
+        }
+    }
+    _zoomOnto(isZoomInto, startPoint, endPoint, designerCanvas) {
+        if (this._isPositionEqual(startPoint, endPoint)) {
+            const oldZoom = designerCanvas.zoomFactor;
+            const newZoom = isZoomInto ? oldZoom + this._zoomStepSize : oldZoom - this._zoomStepSize;
+            designerCanvas.zoomTowardsPoint(endPoint, newZoom);
+        }
+        else {
+            designerCanvas.zoomOntoRectangle(startPoint, endPoint);
+        }
+    }
+    _isPositionEqual(startPoint, endPoint) {
+        let tolerance = this._pointerMovementTolerance;
+        return Math.abs(startPoint.x - endPoint.x) <= tolerance && Math.abs(startPoint.y - endPoint.y) <= tolerance;
+    }
+    keyboardEventHandler(designerCanvas, event, currentElement) { }
+    dispose() {
+    }
+}

package/dist/elements/widgets/designerView/tools/toolBar/DesignerToolbar.d.ts

@@ -1,19 +1,19 @@
-import { BaseCustomWebComponentConstructorAppend } from "@node-projects/base-custom-webcomponent";
-import { ServiceContainer } from "../../../../services/ServiceContainer.js";
-import { DesignerView } from "../../designerView.js";
-import { DesignerToolbarButton } from './DesignerToolbarButton.js';
-export declare class DesignerToolbar extends BaseCustomWebComponentConstructorAppend {
-    static readonly style: CSSStyleSheet;
-    static readonly template: HTMLTemplateElement;
-    private _toolButtonsElem;
-    private _serviceContainer;
-    private _popupContainer;
-    private _designerView;
-    constructor();
-    initialize(serviceContainer: ServiceContainer, designerView: DesignerView): void;
-    showPopup(designerToolbarButton: DesignerToolbarButton): void;
-    setTool(tool: string): void;
-    setStrokeColor(color: string): void;
-    setFillBrush(color: string): void;
-    setStrokeThickness(input: string): void;
-}
+import { BaseCustomWebComponentConstructorAppend } from "@node-projects/base-custom-webcomponent";
+import { ServiceContainer } from "../../../../services/ServiceContainer.js";
+import { DesignerView } from "../../designerView.js";
+import { DesignerToolbarButton } from './DesignerToolbarButton.js';
+export declare class DesignerToolbar extends BaseCustomWebComponentConstructorAppend {
+    static readonly style: CSSStyleSheet;
+    static readonly template: HTMLTemplateElement;
+    private _toolButtonsElem;
+    private _serviceContainer;
+    private _popupContainer;
+    private _designerView;
+    constructor();
+    initialize(serviceContainer: ServiceContainer, designerView: DesignerView): void;
+    showPopup(designerToolbarButton: DesignerToolbarButton): void;
+    setTool(tool: string): void;
+    setStrokeColor(color: string): void;
+    setFillBrush(color: string): void;
+    setStrokeThickness(input: string): void;
+}