@design-core/core 0.0.1 → 0.0.3

package/core/tools/distance.js

@@ -1,28 +1,47 @@
-import {Strings} from '../lib/strings.js';
-import {Tool} from './tool.js';
-import {Input, PromptOptions} from '../lib/inputManager.js';
-import {Logging} from '../lib/logging.js';
+import { Strings } from '../lib/strings.js';
+import { Utils } from '../lib/utils.js';
+import { Tool } from './tool.js';
+import { Input, PromptOptions } from '../lib/inputManager.js';
+import { Logging } from '../lib/logging.js';
 
-import {DesignCore} from '../designCore.js';
+import { DesignCore } from '../designCore.js';
 
+/**
+ * Distance Command Class
+ * @extends Tool
+ */
 export class Distance extends Tool {
+  /** Create a Distance command */
   constructor() {
     super();
   }
 
+  /**
+   * Register the command
+   * @return {Object}
+   * command = name of the command
+   * shortcut = shortcut for the command
+   * type = type to group command in toolbars (omitted if not shown)
+   */
   static register() {
-    const command = {command: 'Distance', shortcut: 'DI'}; // , type: 'Tool'};
+    const command = { command: 'Distance', shortcut: 'DI' }; // , type: 'Tool'};
     return command;
   }
 
+  /**
+   * Execute method
+   * executes the workflow, requesting input required to perform the command
+   */
   async execute() {
     try {
       const op = new PromptOptions(Strings.Input.START, [Input.Type.POINT]);
       const pt1 = await DesignCore.Scene.inputManager.requestInput(op);
+      if (pt1 === undefined) return;
       this.points.push(pt1);
 
       const op2 = new PromptOptions(Strings.Input.END, [Input.Type.POINT]);
       const pt2 = await DesignCore.Scene.inputManager.requestInput(op2);
+      if (pt2 === undefined) return;
       this.points.push(pt2);
 
       DesignCore.Scene.inputManager.executeCommand();
@@ -31,15 +50,24 @@ export class Distance extends Tool {
     }
   }
 
+  /**
+   * Preview the command during execution
+   */
   preview() {
     // TODO: Draw a preview of the measurement
   }
 
+  /**
+   * Perform the command
+   */
   action() {
+    const dx = this.points[1].x - this.points[0].x;
+    const dy = this.points[1].y - this.points[0].y;
     const length = this.points[0].distance(this.points[1]).toFixed(1);
-    const x = (this.points[1].x - this.points[0].x).toFixed(1);
-    const y = (this.points[1].y - this.points[0].y).toFixed(1);
-    const di = (`${Strings.Strings.LENGTH}: ${length} ΔX: ${x} ΔY: ${y}`);
+    const angle = Utils.radians2degrees(this.points[0].angle(this.points[1])).toFixed(1);
+    const x = dx.toFixed(1);
+    const y = dy.toFixed(1);
+    const di = (`${Strings.Strings.LENGTH}: ${length} Angle: ${angle}${Strings.Symbol.DEGREE} ${Strings.Symbol.DELTA}X: ${x} ${Strings.Symbol.DELTA}Y: ${y}`);
     DesignCore.Core.notify(di);
   }
 }

package/core/tools/erase.js

@@ -1,44 +1,74 @@
-import {Strings} from '../lib/strings.js';
-import {Tool} from './tool.js';
-import {Input, PromptOptions} from '../lib/inputManager.js';
-import {Logging} from '../lib/logging.js';
+import { Strings } from '../lib/strings.js';
+import { Tool } from './tool.js';
+import { Input, PromptOptions } from '../lib/inputManager.js';
+import { Logging } from '../lib/logging.js';
+import { RemoveState } from '../lib/stateManager.js';
 
-import {DesignCore} from '../designCore.js';
+import { DesignCore } from '../designCore.js';
 
+/**
+ * Erase Command Class
+ * @extends Tool
+ */
 export class Erase extends Tool {
+  /** Create an Erase command */
   constructor() {
     super();
   }
 
+  /**
+   * Register the command
+   * @return {Object}
+   * command = name of the command
+   * shortcut = shortcut for the command
+   * type = type to group command in toolbars (omitted if not shown)
+   */
   static register() {
-    const command = {command: 'Erase', shortcut: 'E', type: 'Tool'};
+    const command = { command: 'Erase', shortcut: 'E', type: 'Tool' };
     return command;
   }
 
+  /**
+   * Execute method
+   * executes the workflow, requesting input required to perform the command
+   */
   async execute() {
     try {
       const op = new PromptOptions(Strings.Input.SELECTIONSET, [Input.Type.SELECTIONSET]);
 
       if (!DesignCore.Scene.selectionManager.selectionSet.selectionSet.length) {
-        await DesignCore.Scene.inputManager.requestInput(op);
+        const result = await DesignCore.Scene.inputManager.requestInput(op);
+        if (result === undefined) return;
       }
 
       DesignCore.Scene.inputManager.executeCommand();
-    } catch (error) {
+    } catch (err) {
       Logging.instance.error(`${this.type} - ${err}`);
     }
   }
 
+  /**
+   * Preview the command during execution
+   */
+  preview() {
+    // No Preview
+  }
+
+  /**
+   * Perform the command
+   */
   action() {
     // get a copy of the selection set
     const selections = DesignCore.Scene.selectionManager.selectionSet.selectionSet.slice();
-    // sort the selection in descending order
-    selections.sort((a, b)=>b-a);
 
-    // delete each of the selections from the scene items
-    // This is done in descending order to preserve the indices i.e if index 1 is deleted, index 2 becomes index 1
+    const stateChanges = [];
+
     for (let i = 0; i < selections.length; i++) {
-      DesignCore.Scene.items.splice((selections[i]), 1);
+      const stateChange = new RemoveState(DesignCore.Scene.entities.get(selections[i]));
+      stateChanges.push(stateChange);
     }
+
+    // delete each of the selections from the scene items
+    DesignCore.Scene.commit(stateChanges);
   }
 }

package/core/tools/explode.js

@@ -0,0 +1,117 @@
+import { Utils } from '../lib/utils.js';
+import { Strings } from '../lib/strings.js';
+import { Tool } from './tool.js';
+import { Input, PromptOptions } from '../lib/inputManager.js';
+import { Logging } from '../lib/logging.js';
+import { Insert } from '../entities/insert.js';
+import { Point } from '../entities/point.js';
+import { AddState, RemoveState } from '../lib/stateManager.js';
+
+import { DesignCore } from '../designCore.js';
+
+/**
+ * Explode Command Class
+ * @extends Tool
+ */
+export class Explode extends Tool {
+  /** Create an Explode command */
+  constructor() {
+    super();
+  }
+
+  /**
+   * Register the command
+   * @return {Object}
+   * command = name of the command
+   * shortcut = shortcut for the command
+   * type = type to group command in toolbars (omitted if not shown)
+   */
+  static register() {
+    const command = { command: 'Explode', shortcut: 'X' };
+    return command;
+  }
+
+  /**
+   * Execute method
+   * executes the workflow, requesting input required to perform the command
+   */
+  async execute() {
+    try {
+      const op = new PromptOptions(Strings.Input.SELECTIONSET, [Input.Type.SELECTIONSET]);
+
+      if (!DesignCore.Scene.selectionManager.selectionSet.selectionSet.length) {
+        const result = await DesignCore.Scene.inputManager.requestInput(op);
+        if (result === undefined) return;
+      }
+
+      DesignCore.Scene.inputManager.executeCommand();
+    } catch (err) {
+      Logging.instance.error(`${this.type} - ${err}`);
+    }
+  }
+
+  /**
+   * Preview the command during execution
+   */
+  preview() {
+    // No Preview
+  }
+
+  /**
+   * Perform the command
+   */
+  action() {
+    // count how many items couldn't be exploded
+    let counter = 0;
+    // get a copy of the selection set
+    const selections = DesignCore.Scene.selectionManager.selectionSet.selectionSet.slice();
+    // sort the selection in descending order
+    selections.sort((a, b) => b - a);
+
+    const stateChanges = [];
+
+    for (let i = 0; i < selections.length; i++) {
+      const insert = DesignCore.Scene.entities.get(selections[i]);
+
+      // check the selected item in an insert
+      if (!(insert instanceof Insert)) {
+        counter++;
+        continue;
+      }
+
+      // check the insert has a block and
+      // check the block has items
+      if (insert.block === undefined || insert.block.items.length == 0) {
+        counter++;
+        continue;
+      }
+
+      const insertPoint = insert.points[0];
+      const block = insert.block;
+      const blockItems = block.items;
+
+      const rotation = Utils.degrees2radians(insert.rotation);
+      const origin = new Point(0, 0);
+
+      blockItems.forEach((blockItem) => {
+        const copyofitem = Utils.cloneObject(blockItem);
+        const points = copyofitem.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).rotate(origin, rotation).add(insertPoint));
+        copyofitem.setProperty('points', points);
+        const stateChange = new AddState(copyofitem);
+        stateChanges.push(stateChange);
+      });
+
+      const stateChangeRemove = new RemoveState(insert);
+      stateChanges.push(stateChangeRemove);
+    }
+
+
+    // add the exploded items to the scene
+    DesignCore.Scene.commit(stateChanges);
+
+
+    if (counter) {
+      DesignCore.Core.notify(`${this.type} - ${counter} ${Strings.Strings.ITEMS} ${Strings.Message.CANNOTBEACTIONED}`);
+    }
+  };
+}

package/core/tools/extend.js

@@ -1,72 +1,111 @@
-import {Intersection} from '../lib/intersect.js';
-import {Strings} from '../lib/strings.js';
-import {Tool} from './tool.js';
-import {Input, PromptOptions} from '../lib/inputManager.js';
-import {Logging} from '../lib/logging.js';
+import { Intersection } from '../lib/intersect.js';
+import { Strings } from '../lib/strings.js';
+import { Tool } from './tool.js';
+import { Input, PromptOptions } from '../lib/inputManager.js';
+import { Logging } from '../lib/logging.js';
 
-import {DesignCore} from '../designCore.js';
+import { DesignCore } from '../designCore.js';
 
+/**
+ * Extend Command Class
+ * @extends Tool
+ */
 export class Extend extends Tool {
+  /** Create an Extend command */
   constructor() {
     super();
-    this.selectedIndex;
+    this.selectedItem = null;
+    this.selectedBoundaryItems = [];
   }
 
+  /**
+   * Register the command
+   * @return {Object}
+   * command = name of the command
+   * shortcut = shortcut for the command
+   * type = type to group command in toolbars (omitted if not shown)
+   */
   static register() {
-    const command = {command: 'Extend', shortcut: 'EX', type: 'Tool'};
+    const command = { command: 'Extend', shortcut: 'EX', type: 'Tool' };
     return command;
   }
 
+  /**
+   * Execute method
+   * executes the workflow, requesting input required to perform the command
+   */
   async execute() {
     try {
       const op = new PromptOptions(Strings.Input.BOUNDARY, [Input.Type.SELECTIONSET]);
 
       if (!DesignCore.Scene.selectionManager.selectionSet.selectionSet.length) {
-        await DesignCore.Scene.inputManager.requestInput(op);
+        const boundary = await DesignCore.Scene.inputManager.requestInput(op);
+        if (boundary === undefined) return;
+      }
+
+      // add all selected items to boundary items
+      for (let i = 0; i < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
+        const boundaryItem = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]);
+        this.selectedBoundaryItems.push(boundaryItem);
       }
 
       const op2 = new PromptOptions(Strings.Input.SELECT, [Input.Type.SINGLESELECTION]);
       while (true) {
         const selection = await DesignCore.Scene.inputManager.requestInput(op2);
-        this.selectedIndex = selection.selectedItemIndex;
+        if (selection === undefined) break;
+        this.selectedItem = DesignCore.Scene.entities.get(selection.selectedItemIndex);
+        DesignCore.Scene.selectionManager.removeLastSelection();
         DesignCore.Scene.inputManager.actionCommand();
       }
-    } catch (error) {
+
+      DesignCore.Scene.inputManager.executeCommand();
+    } catch (err) {
       Logging.instance.error(`${this.type} - ${err}`);
     }
   }
 
-  action() {
-    const item = this.selectedIndex;
+  /**
+   * Preview the command during execution
+   */
+  preview() {
+    // No Preview
+  }
 
-    if (item !== undefined) {
+  /**
+   * Perform the command
+   */
+  action() {
+    if (this.selectedItem && this.selectedBoundaryItems.length) {
       const intersectPoints = [];
-      let extendItem;
 
-      for (let i = 0; i <DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
-        if (DesignCore.Scene.selectionManager.selectionSet.selectionSet[i] !== item) {
-          const boundaryItem = DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]];
-          extendItem = DesignCore.Scene.items[item];
-
-          const functionName = 'intersect' + boundaryItem.type + extendItem.type;
-          const intersect = Intersection[functionName](boundaryItem.intersectPoints(), extendItem.intersectPoints(), true);
-
-          if (intersect.points.length) {
-            for (let point = 0; point < intersect.points.length; point++) {
-              intersectPoints.push(intersect.points[point]);
+      for (const boundaryItem of this.selectedBoundaryItems) {
+        if (boundaryItem !== this.selectedItem) {
+          try {
+            const intersect = Intersection.intersectPolylinePolyline(boundaryItem.toPolylinePoints(), this.selectedItem.toPolylinePoints(), true);
+            if (intersect.points.length) {
+              for (let point = 0; point < intersect.points.length; point++) {
+                intersectPoints.push(intersect.points[point]);
+              }
             }
+          } catch {
+            Logging.instance.warn(`${this.constructor.name}: Error intersecting between ${boundaryItem.type} and ${this.selectedItem.type}`);
+            continue;
           }
         }
       }
 
-      if (intersectPoints) {
-        extendItem.extend(intersectPoints);
+      if (intersectPoints.length) {
+        const stateChanges = this.selectedItem.extend(intersectPoints);
+        if (stateChanges?.length) {
+          DesignCore.Scene.commit(stateChanges);
+        }
+      } else {
+        DesignCore.Core.notify(`${this.type} - ${this.selectedItem.type} ${Strings.Message.NOEXTEND}`);
       }
-
-      // remove item from selection set and reset the selectedIndex
-      DesignCore.Scene.selectionManager.removeFromSelectionSet(this.selectedIndex);
-      this.selectedIndex = undefined;
     }
+
+    // reset selected item
+    this.selectedItem = null;
   }
 }