@node-projects/web-component-designer 0.0.91 → 0.0.94

package/dist/elements/services/manifestParsers/WebcomponentManifestParserService.d.ts

@@ -1,25 +1,25 @@
-import { BindingTarget } from "../../item/BindingTarget";
-import { IElementDefinition } from "../elementsService/IElementDefinition";
-import { IElementsService } from "../elementsService/IElementsService";
-import { IPropertiesService } from "../propertiesService/IPropertiesService";
-import { IProperty } from "../propertiesService/IProperty";
-import { IDesignItem } from "../../item/IDesignItem";
-import { UnkownElementPropertiesService } from "../propertiesService/services/UnkownElementPropertiesService";
-export declare class WebcomponentManifestParserService extends UnkownElementPropertiesService implements IElementsService, IPropertiesService {
-    private _name;
-    get name(): string;
-    private _packageData;
-    private _elementList;
-    private _propertiesList;
-    private _resolveStored;
-    private _rejectStored;
-    private _importPrefix;
-    constructor(name: string, fileOrObject: string | object, importPrefix?: string);
-    private _parseManifest;
-    private manifestClassPropertyTypeToEditorPropertyType;
-    getElements(): Promise<IElementDefinition[]>;
-    isHandledElement(designItem: IDesignItem): boolean;
-    getProperties(designItem: IDesignItem): IProperty[];
-    getProperty(designItem: IDesignItem, name: string): IProperty;
-    getPropertyTarget(designItem: IDesignItem, property: IProperty): BindingTarget;
-}
+import { BindingTarget } from "../../item/BindingTarget";
+import { IElementDefinition } from "../elementsService/IElementDefinition";
+import { IElementsService } from "../elementsService/IElementsService";
+import { IPropertiesService } from "../propertiesService/IPropertiesService";
+import { IProperty } from "../propertiesService/IProperty";
+import { IDesignItem } from "../../item/IDesignItem";
+import { UnkownElementPropertiesService } from "../propertiesService/services/UnkownElementPropertiesService";
+export declare class WebcomponentManifestParserService extends UnkownElementPropertiesService implements IElementsService, IPropertiesService {
+    private _name;
+    get name(): string;
+    private _packageData;
+    private _elementList;
+    private _propertiesList;
+    private _resolveStored;
+    private _rejectStored;
+    private _importPrefix;
+    constructor(name: string, fileOrObject: string | object, importPrefix?: string);
+    private _parseManifest;
+    private manifestClassPropertyTypeToEditorPropertyType;
+    getElements(): Promise<IElementDefinition[]>;
+    isHandledElement(designItem: IDesignItem): boolean;
+    getProperties(designItem: IDesignItem): IProperty[];
+    getProperty(designItem: IDesignItem, name: string): IProperty;
+    getPropertyTarget(designItem: IDesignItem, property: IProperty): BindingTarget;
+}

package/dist/elements/services/manifestParsers/WebcomponentManifestParserService.js

@@ -1,94 +1,94 @@
-import { BindingTarget } from "../../item/BindingTarget";
-import { PropertyType } from "../propertiesService/PropertyType";
-import { UnkownElementPropertiesService } from "../propertiesService/services/UnkownElementPropertiesService";
-export class WebcomponentManifestParserService extends UnkownElementPropertiesService {
-    _name;
-    get name() { return this._name; }
-    _packageData;
-    _elementList;
-    _propertiesList;
-    _resolveStored;
-    _rejectStored;
-    _importPrefix = '';
-    constructor(name, fileOrObject, importPrefix = '') {
-        super();
-        this._name = name;
-        this._importPrefix = importPrefix;
-        if (typeof fileOrObject === 'string') {
-            this._importPrefix = this._importPrefix ?? fileOrObject.split('/').slice(0, -1).join('/');
-            import(fileOrObject, { assert: { type: 'json' } }).then(module => {
-                this._packageData = module.default;
-                this._parseManifest();
-            }).catch(err => {
-                if (this._rejectStored) {
-                    this._rejectStored.forEach(x => x(err));
-                    this._resolveStored = null;
-                    this._rejectStored = null;
-                }
-            });
-        }
-        else {
-            this._packageData = fileOrObject;
-            this._parseManifest();
-        }
-    }
-    _parseManifest() {
-        this._elementList = [];
-        this._propertiesList = {};
-        for (let m of this._packageData.modules) {
-            for (let e of m.exports) {
-                if (e.kind == 'custom-element-definition') {
-                    this._elementList.push({ tag: e.name, import: this._importPrefix + '/' + e.declaration.module });
-                    let properties = [];
-                    let declaration = m.declarations.find(x => x.name == e.declaration.name);
-                    for (let d of declaration.members) {
-                        if (d.kind == 'field') {
-                            let pType = PropertyType.property;
-                            if (declaration.attributes)
-                                pType = declaration.attributes.find(x => x.fieldName == d.name) != null ? PropertyType.propertyAndAttribute : PropertyType.property;
-                            properties.push({ name: d.name, service: this, propertyType: pType, type: this.manifestClassPropertyTypeToEditorPropertyType(d.type?.text) });
-                        }
-                    }
-                    this._propertiesList[e.name] = properties;
-                }
-            }
-            if (this._resolveStored) {
-                this._resolveStored.forEach(x => x(this._elementList));
-                this._resolveStored = null;
-                this._rejectStored = null;
-            }
-        }
-    }
-    manifestClassPropertyTypeToEditorPropertyType(type) {
-        if (type) {
-            if (type.toLowerCase() === 'boolean')
-                return 'boolean';
-            if (type.toLowerCase() === 'number')
-                return 'number';
-        }
-        return type;
-    }
-    async getElements() {
-        if (this._packageData)
-            return Promise.resolve(this._elementList);
-        if (!this._resolveStored) {
-            this._resolveStored = [];
-            this._rejectStored = [];
-        }
-        return new Promise((resolve, reject) => { this._resolveStored.push(resolve); this._rejectStored.push(reject); });
-    }
-    isHandledElement(designItem) {
-        if (this._elementList)
-            return this._elementList.find(x => x.tag == designItem.name) != null;
-        return false;
-    }
-    getProperties(designItem) {
-        return this._propertiesList[designItem.name];
-    }
-    getProperty(designItem, name) {
-        return this._propertiesList[designItem.name].find(x => x.name == name);
-    }
-    getPropertyTarget(designItem, property) {
-        return this._propertiesList[designItem.name].find(x => x.name == property.name).propertyType == PropertyType.attribute ? BindingTarget.attribute : BindingTarget.property;
-    }
-}
+import { BindingTarget } from "../../item/BindingTarget";
+import { PropertyType } from "../propertiesService/PropertyType";
+import { UnkownElementPropertiesService } from "../propertiesService/services/UnkownElementPropertiesService";
+export class WebcomponentManifestParserService extends UnkownElementPropertiesService {
+    _name;
+    get name() { return this._name; }
+    _packageData;
+    _elementList;
+    _propertiesList;
+    _resolveStored;
+    _rejectStored;
+    _importPrefix = '';
+    constructor(name, fileOrObject, importPrefix = '') {
+        super();
+        this._name = name;
+        this._importPrefix = importPrefix;
+        if (typeof fileOrObject === 'string') {
+            this._importPrefix = this._importPrefix ?? fileOrObject.split('/').slice(0, -1).join('/');
+            import(fileOrObject, { assert: { type: 'json' } }).then(module => {
+                this._packageData = module.default;
+                this._parseManifest();
+            }).catch(err => {
+                if (this._rejectStored) {
+                    this._rejectStored.forEach(x => x(err));
+                    this._resolveStored = null;
+                    this._rejectStored = null;
+                }
+            });
+        }
+        else {
+            this._packageData = fileOrObject;
+            this._parseManifest();
+        }
+    }
+    _parseManifest() {
+        this._elementList = [];
+        this._propertiesList = {};
+        for (let m of this._packageData.modules) {
+            for (let e of m.exports) {
+                if (e.kind == 'custom-element-definition') {
+                    this._elementList.push({ tag: e.name, import: this._importPrefix + '/' + e.declaration.module });
+                    let properties = [];
+                    let declaration = m.declarations.find(x => x.name == e.declaration.name);
+                    for (let d of declaration.members) {
+                        if (d.kind == 'field') {
+                            let pType = PropertyType.property;
+                            if (declaration.attributes)
+                                pType = declaration.attributes.find(x => x.fieldName == d.name) != null ? PropertyType.propertyAndAttribute : PropertyType.property;
+                            properties.push({ name: d.name, service: this, propertyType: pType, type: this.manifestClassPropertyTypeToEditorPropertyType(d.type?.text) });
+                        }
+                    }
+                    this._propertiesList[e.name] = properties;
+                }
+            }
+            if (this._resolveStored) {
+                this._resolveStored.forEach(x => x(this._elementList));
+                this._resolveStored = null;
+                this._rejectStored = null;
+            }
+        }
+    }
+    manifestClassPropertyTypeToEditorPropertyType(type) {
+        if (type) {
+            if (type.toLowerCase() === 'boolean')
+                return 'boolean';
+            if (type.toLowerCase() === 'number')
+                return 'number';
+        }
+        return type;
+    }
+    async getElements() {
+        if (this._packageData)
+            return Promise.resolve(this._elementList);
+        if (!this._resolveStored) {
+            this._resolveStored = [];
+            this._rejectStored = [];
+        }
+        return new Promise((resolve, reject) => { this._resolveStored.push(resolve); this._rejectStored.push(reject); });
+    }
+    isHandledElement(designItem) {
+        if (this._elementList)
+            return this._elementList.find(x => x.tag == designItem.name) != null;
+        return false;
+    }
+    getProperties(designItem) {
+        return this._propertiesList[designItem.name];
+    }
+    getProperty(designItem, name) {
+        return this._propertiesList[designItem.name].find(x => x.name == name);
+    }
+    getPropertyTarget(designItem, property) {
+        return this._propertiesList[designItem.name].find(x => x.name == property.name).propertyType == PropertyType.attribute ? BindingTarget.attribute : BindingTarget.property;
+    }
+}

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>;
+}

package/dist/elements/services/modelCommandService/DefaultModelCommandService.js

@@ -1,76 +1,126 @@
-import { CommandType } from "../../../commandHandling/CommandType.js";
-import { ArrangeHelper } from "../../helper/ArrangeHelper.js";
-import { Orientation } from "../../../enums/Orientation.js";
-export class DefaultModelCommandService {
-    canExecuteCommand(designerCanvas, command) {
-        if (command.type == CommandType.moveBackward ||
-            command.type == CommandType.moveForward ||
-            command.type == CommandType.moveToBack ||
-            command.type == CommandType.moveToFront)
-            return designerCanvas.instanceServiceContainer.selectionService.primarySelection != null;
-        if (command.type == CommandType.arrangeBottom ||
-            command.type == CommandType.arrangeCenter ||
-            command.type == CommandType.arrangeLeft ||
-            command.type == CommandType.arrangeMiddle ||
-            command.type == CommandType.arrangeRight ||
-            command.type == CommandType.arrangeTop ||
-            command.type == CommandType.unifyHeight ||
-            command.type == CommandType.unifyWidth)
-            return designerCanvas.instanceServiceContainer.selectionService.selectedElements.length > 1;
-        return null;
-    }
-    async executeCommand(designerCanvas, command) {
-        let sel = designerCanvas.instanceServiceContainer.selectionService.primarySelection;
-        if (command.type == CommandType.moveBackward) {
-            let idx = sel.parent.indexOf(sel) - 1;
-            if (idx >= 0)
-                sel.parent.insertChild(sel, idx);
-        }
-        else if (command.type == CommandType.moveForward) {
-            let idx = sel.parent.indexOf(sel) + 1;
-            if (idx < sel.parent.childCount)
-                sel.parent.insertChild(sel, idx);
-        }
-        else if (command.type == CommandType.moveToBack)
-            sel.parent.insertChild(sel, 0);
-        else if (command.type == CommandType.moveToFront)
-            sel.parent.insertChild(sel);
-        else if (command.type == CommandType.arrangeTop) {
-            ArrangeHelper.arrangeElements(Orientation.TOP, designerCanvas);
-        }
-        else if (command.type == CommandType.arrangeRight) {
-            ArrangeHelper.arrangeElements(Orientation.RIGHT, designerCanvas);
-        }
-        else if (command.type == CommandType.arrangeLeft) {
-            ArrangeHelper.arrangeElements(Orientation.LEFT, designerCanvas);
-        }
-        else if (command.type == CommandType.arrangeBottom) {
-            ArrangeHelper.arrangeElements(Orientation.BOTTOM, designerCanvas);
-        }
-        else if (command.type == CommandType.arrangeCenter) {
-            ArrangeHelper.arrangeElements(Orientation.HORIZONTAL_CENTER, designerCanvas);
-        }
-        else if (command.type == CommandType.arrangeMiddle) {
-            ArrangeHelper.arrangeElements(Orientation.VERTICAL_CENTER, designerCanvas);
-        }
-        else if (command.type == CommandType.unifyHeight) {
-            const grp = designerCanvas.instanceServiceContainer.selectionService.primarySelection.openGroup('unifyHeight');
-            const height = designerCanvas.instanceServiceContainer.selectionService.primarySelection.styles.get('height');
-            for (let s of designerCanvas.instanceServiceContainer.selectionService.selectedElements) {
-                s.setStyle('height', height);
-            }
-            grp.commit();
-        }
-        else if (command.type == CommandType.unifyWidth) {
-            const grp = designerCanvas.instanceServiceContainer.selectionService.primarySelection.openGroup('unifyWidth');
-            const width = designerCanvas.instanceServiceContainer.selectionService.primarySelection.styles.get('width');
-            for (let s of designerCanvas.instanceServiceContainer.selectionService.selectedElements) {
-                s.setStyle('width', width);
-            }
-            grp.commit();
-        }
-        else
-            return null;
-        return true;
-    }
-}
+import { CommandType } from "../../../commandHandling/CommandType.js";
+import { ArrangeHelper } from "../../helper/ArrangeHelper.js";
+import { Orientation } from "../../../enums/Orientation.js";
+export class DefaultModelCommandService {
+    canExecuteCommand(designerCanvas, command) {
+        if (command.type == CommandType.moveBackward ||
+            command.type == CommandType.moveForward ||
+            command.type == CommandType.moveToBack ||
+            command.type == CommandType.moveToFront)
+            return designerCanvas.instanceServiceContainer.selectionService.primarySelection != null;
+        if (command.type == CommandType.arrangeBottom ||
+            command.type == CommandType.arrangeCenter ||
+            command.type == CommandType.arrangeLeft ||
+            command.type == CommandType.arrangeMiddle ||
+            command.type == CommandType.arrangeRight ||
+            command.type == CommandType.arrangeTop ||
+            command.type == CommandType.unifyHeight ||
+            command.type == CommandType.unifyWidth)
+            return designerCanvas.instanceServiceContainer.selectionService.selectedElements.length > 1;
+        return null;
+    }
+    async executeCommand(designerCanvas, command) {
+        let sel = designerCanvas.instanceServiceContainer.selectionService.primarySelection;
+        if (command.type == CommandType.moveBackward) {
+            let idx = sel.parent.indexOf(sel) - 1;
+            if (idx >= 0)
+                sel.parent.insertChild(sel, idx);
+        }
+        else if (command.type == CommandType.moveForward) {
+            let idx = sel.parent.indexOf(sel) + 1;
+            if (idx < sel.parent.childCount)
+                sel.parent.insertChild(sel, idx);
+        }
+        else if (command.type == CommandType.moveToBack)
+            sel.parent.insertChild(sel, 0);
+        else if (command.type == CommandType.moveToFront)
+            sel.parent.insertChild(sel);
+        else if (command.type == CommandType.arrangeTop) {
+            ArrangeHelper.arrangeElements(Orientation.TOP, designerCanvas);
+        }
+        else if (command.type == CommandType.arrangeRight) {
+            ArrangeHelper.arrangeElements(Orientation.RIGHT, designerCanvas);
+        }
+        else if (command.type == CommandType.arrangeLeft) {
+            ArrangeHelper.arrangeElements(Orientation.LEFT, designerCanvas);
+        }
+        else if (command.type == CommandType.arrangeBottom) {
+            ArrangeHelper.arrangeElements(Orientation.BOTTOM, designerCanvas);
+        }
+        else if (command.type == CommandType.arrangeCenter) {
+            ArrangeHelper.arrangeElements(Orientation.HORIZONTAL_CENTER, designerCanvas);
+        }
+        else if (command.type == CommandType.arrangeMiddle) {
+            ArrangeHelper.arrangeElements(Orientation.VERTICAL_CENTER, designerCanvas);
+        }
+        else if (command.type == CommandType.unifyHeight) {
+            const grp = designerCanvas.instanceServiceContainer.selectionService.primarySelection.openGroup('unifyHeight');
+            const height = designerCanvas.instanceServiceContainer.selectionService.primarySelection.styles.get('height');
+            for (let s of designerCanvas.instanceServiceContainer.selectionService.selectedElements) {
+                s.setStyle('height', height);
+            }
+            grp.commit();
+        }
+        else if (command.type == CommandType.unifyWidth) {
+            const grp = designerCanvas.instanceServiceContainer.selectionService.primarySelection.openGroup('unifyWidth');
+            const width = designerCanvas.instanceServiceContainer.selectionService.primarySelection.styles.get('width');
+            for (let s of designerCanvas.instanceServiceContainer.selectionService.selectedElements) {
+                s.setStyle('width', width);
+            }
+            grp.commit();
+        }
+        else if (command.type == CommandType.rotateCounterClockwise) {
+            const grp = designerCanvas.instanceServiceContainer.selectionService.primarySelection.openGroup('rotateCounterClockwise');
+            var trf = designerCanvas.instanceServiceContainer.selectionService.primarySelection.styles.get('transform');
+            let degree = 0;
+            let rotation = "";
+            if (trf != null) {
+                try {
+                    if (trf.includes('-'))
+                        degree = parseInt(trf.match(/\d+/)[0]) * -1;
+                    else
+                        degree = parseInt(trf.match(/\d+/)[0]);
+                    rotation = "rotate(" + (degree - 90) + "deg)";
+                }
+                catch {
+                    rotation = "rotate(-90deg)";
+                }
+            }
+            else {
+                rotation = "rotate(-90deg)";
+            }
+            for (let s of designerCanvas.instanceServiceContainer.selectionService.selectedElements) {
+                s.setStyle('transform', rotation);
+            }
+            grp.commit();
+        }
+        else if (command.type == CommandType.rotateClockwise) {
+            const grp = designerCanvas.instanceServiceContainer.selectionService.primarySelection.openGroup('rotateClockwise');
+            var trf = designerCanvas.instanceServiceContainer.selectionService.primarySelection.styles.get('transform');
+            let degree = 0;
+            let rotation = "";
+            if (trf != null) {
+                try {
+                    if (trf.includes('-'))
+                        degree = parseInt(trf.match(/\d+/)[0]) * -1;
+                    else
+                        degree = parseInt(trf.match(/\d+/)[0]);
+                    rotation = "rotate(" + (degree + 90) + "deg)";
+                }
+                catch {
+                    rotation = "rotate(90deg)";
+                }
+            }
+            else {
+                rotation = "rotate(90deg)";
+            }
+            for (let s of designerCanvas.instanceServiceContainer.selectionService.selectedElements) {
+                s.setStyle('transform', rotation);
+            }
+            grp.commit();
+        }
+        else
+            return null;
+        return true;
+    }
+}

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

@@ -1,7 +1,7 @@
-import { IUiCommand } from '../../../commandHandling/IUiCommand.js';
-import { IDesignerCanvas } from '../../widgets/designerView/IDesignerCanvas.js';
-import { IService } from '../IService';
-export interface IModelCommandService extends IService {
-    canExecuteCommand(designerCanvas: IDesignerCanvas, command: IUiCommand): boolean | null;
-    executeCommand(designerCanvas: IDesignerCanvas, command: IUiCommand): any;
-}
+import { IUiCommand } from '../../../commandHandling/IUiCommand.js';
+import { IDesignerCanvas } from '../../widgets/designerView/IDesignerCanvas.js';
+import { IService } from '../IService';
+export interface IModelCommandService extends IService {
+    canExecuteCommand(designerCanvas: IDesignerCanvas, command: IUiCommand): boolean | null;
+    executeCommand(designerCanvas: IDesignerCanvas, command: IUiCommand): any;
+}

package/dist/elements/services/modelCommandService/IModelCommandService.js

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

package/dist/elements/services/placementService/DefaultPlacementService.d.ts

@@ -1,16 +1,16 @@
-import type { IPoint } from '../../../interfaces/IPoint.js';
-import type { IPlacementService } from './IPlacementService.js';
-import type { IDesignItem } from '../../item/IDesignItem.js';
-import { IPlacementView } from '../../widgets/designerView/IPlacementView.js';
-export declare class DefaultPlacementService implements IPlacementService {
-    serviceForContainer(container: IDesignItem, containerStyle: CSSStyleDeclaration): boolean;
-    canEnter(container: IDesignItem, items: IDesignItem[]): boolean;
-    canLeave(container: IDesignItem, items: IDesignItem[]): boolean;
-    getElementOffset(container: IDesignItem, designItem?: IDesignItem): IPoint;
-    private calculateTrack;
-    placePoint(event: MouseEvent, placementView: IPlacementView, container: IDesignItem, startPoint: IPoint, offsetInControl: IPoint, newPoint: IPoint, items: IDesignItem[]): IPoint;
-    place(event: MouseEvent, placementView: IPlacementView, container: IDesignItem, startPoint: IPoint, offsetInControl: IPoint, newPoint: IPoint, items: IDesignItem[]): void;
-    enterContainer(container: IDesignItem, items: IDesignItem[]): void;
-    leaveContainer(container: IDesignItem, items: IDesignItem[]): void;
-    finishPlace(event: MouseEvent, placementView: IPlacementView, container: IDesignItem, startPoint: IPoint, offsetInControl: IPoint, newPoint: IPoint, items: IDesignItem[]): void;
-}
+import type { IPoint } from '../../../interfaces/IPoint.js';
+import type { IPlacementService } from './IPlacementService.js';
+import type { IDesignItem } from '../../item/IDesignItem.js';
+import { IPlacementView } from '../../widgets/designerView/IPlacementView.js';
+export declare class DefaultPlacementService implements IPlacementService {
+    serviceForContainer(container: IDesignItem, containerStyle: CSSStyleDeclaration): boolean;
+    canEnter(container: IDesignItem, items: IDesignItem[]): boolean;
+    canLeave(container: IDesignItem, items: IDesignItem[]): boolean;
+    getElementOffset(container: IDesignItem, designItem?: IDesignItem): IPoint;
+    private calculateTrack;
+    placePoint(event: MouseEvent, placementView: IPlacementView, container: IDesignItem, startPoint: IPoint, offsetInControl: IPoint, newPoint: IPoint, items: IDesignItem[]): IPoint;
+    place(event: MouseEvent, placementView: IPlacementView, container: IDesignItem, startPoint: IPoint, offsetInControl: IPoint, newPoint: IPoint, items: IDesignItem[]): void;
+    enterContainer(container: IDesignItem, items: IDesignItem[]): void;
+    leaveContainer(container: IDesignItem, items: IDesignItem[]): void;
+    finishPlace(event: MouseEvent, placementView: IPlacementView, container: IDesignItem, startPoint: IPoint, offsetInControl: IPoint, newPoint: IPoint, items: IDesignItem[]): void;
+}