@design-core/core 0.0.1 → 0.0.3

package/core/tools/chamferFilletBase.js

@@ -0,0 +1,162 @@
+import { Tool } from './tool.js';
+import { Strings } from '../lib/strings.js';
+import { Constants } from '../lib/constants.js';
+import { BasePolyline } from '../entities/basePolyline.js';
+import { RemoveState, UpdateState } from '../lib/stateManager.js';
+import { CornerEntity } from './cornerEntity.js';
+import { Intersection } from '../lib/intersect.js';
+
+import { DesignCore } from '../designCore.js';
+
+/**
+ * ChamferFilletBase Class
+ * Base class for Chamfer and Fillet commands, providing shared entity selection
+ * state, segment resolution, and sharp-trim logic.
+ * @extends Tool
+ */
+export class ChamferFilletBase extends Tool {
+  /** Create a ChamferFilletBase command */
+  constructor() {
+    super();
+    this.firstPick = new CornerEntity();
+    this.secondPick = new CornerEntity();
+    // Shared corner geometry computed by resolveCornerGeometry() before action()
+    // If the lines form a cross there are four possible locations.
+    // The click points are used to determine which corner to operate on.
+    this.intersectionPoint = null;
+  }
+
+  /**
+   * Compute the corner geometry shared by Fillet and Chamfer and store it on the instance.
+   * Validates that both resolved segments are Lines, finds the virtual intersection
+   * of the two infinite lines, and derives click-side directions and kept endpoints.
+   * Returns false and notifies the user on any invalid configuration.
+   * @param {string} noEntityMsg - message shown when a resolved segment is not a Line
+   * @return {boolean}
+   */
+  resolveCornerGeometry(noEntityMsg) {
+    if (!this.firstPick.resolveEndpoints()) {
+      DesignCore.Core.notify(`${this.type} - ${this.firstPick.entity.type} ${noEntityMsg}`);
+      return false;
+    }
+    if (!this.secondPick.resolveEndpoints()) {
+      DesignCore.Core.notify(`${this.type} - ${this.secondPick.entity.type} ${noEntityMsg}`);
+      return false;
+    }
+
+    const result = Intersection.intersectSegmentSegment(
+        this.firstPick.lineStart, this.firstPick.lineEnd,
+        this.secondPick.lineStart, this.secondPick.lineEnd,
+        true, true,
+    );
+
+    // Reject parallel, collinear, or overlapping segments — no unique corner exists.
+    const status = result.status;
+    if (status === Intersection.Status.PARALLEL ||
+        status === Intersection.Status.OVERLAPPING ||
+        status === Intersection.Status.COINCIDENT) {
+      DesignCore.Core.notify(`${this.type} - ${Strings.Error.ERROR}:${Strings.Error.PARALLELLINES}`);
+      return false;
+    }
+
+    // Guard against near-parallel directions that pass the status check but
+    // produce an unreliable intersection point far from both segments.
+    const dir1 = this.firstPick.lineEnd.subtract(this.firstPick.lineStart);
+    const dir2 = this.secondPick.lineEnd.subtract(this.secondPick.lineStart);
+    const cross = dir1.cross(dir2);
+    const len1 = dir1.length();
+    const len2 = dir2.length();
+    if (len1 === 0 || len2 === 0 || Math.abs(cross) / (len1 * len2) < Constants.Tolerance.EPSILON) {
+      DesignCore.Core.notify(`${this.type} - ${Strings.Error.ERROR}:${Strings.Error.PARALLELLINES}`);
+      return false;
+    }
+
+    this.intersectionPoint = result.points[0] || null;
+
+    if (!this.intersectionPoint) {
+      DesignCore.Core.notify(`${this.type} - ${Strings.Error.ERROR}:${Strings.Error.PARALLELLINES}`);
+      return false;
+    }
+
+    if (this.firstPick.clickDistance(this.intersectionPoint) < Constants.Tolerance.EPSILON ||
+        this.secondPick.clickDistance(this.intersectionPoint) < Constants.Tolerance.EPSILON) {
+      DesignCore.Core.notify(`${this.type} - ${Strings.Error.SELECTION}`);
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Trim both entities to the sharp intersection point with no arc or chamfer line.
+   * Handles Line+Line, Polyline+Polyline (same entity), and Line+Polyline cases.
+   * Reads geometry from instance fields set by resolveCornerGeometry().
+   * @return {Array} - array of state changes to be committed by the caller
+   */
+  applySharpTrim() {
+    const firstIsPolyline = this.firstPick.entity instanceof BasePolyline;
+    const secondIsPolyline = this.secondPick.entity instanceof BasePolyline;
+
+    // Line + Line: trim both lines to the intersection point.
+    if (!firstIsPolyline && !secondIsPolyline) {
+      return [
+        new UpdateState(this.firstPick.entity, { points: [this.firstPick.lineKeptEnd(this.intersectionPoint), this.intersectionPoint] }),
+        new UpdateState(this.secondPick.entity, { points: [this.secondPick.lineKeptEnd(this.intersectionPoint), this.intersectionPoint] }),
+      ];
+    }
+
+    // Polyline + Polyline (same entity): replace the shared corner vertex (or open endpoints)
+    // with the intersection point.
+    if (firstIsPolyline && secondIsPolyline && this.firstPick.entity === this.secondPick.entity) {
+      const lastIdx = this.firstPick.entity.points.length - 1;
+      const segDiff = Math.abs(this.firstPick.segmentIndex - this.secondPick.segmentIndex);
+      const isOpenEnds = !this.firstPick.entity.flags.hasFlag(1) && segDiff !== 1 && (
+        (this.firstPick.segmentIndex === 1 && this.secondPick.segmentIndex === lastIdx) ||
+        (this.firstPick.segmentIndex === lastIdx && this.secondPick.segmentIndex === 1)
+      );
+
+      const newPoints = this.firstPick.entity.points.map((p) => p.clone());
+
+      if (isOpenEnds) {
+        newPoints[0] = this.intersectionPoint.clone();
+        newPoints[lastIdx] = this.intersectionPoint.clone();
+      } else {
+        const closeSegIdx = this.firstPick.entity.points.length;
+        const seg1 = this.firstPick.segmentIndex;
+        const seg2 = this.secondPick.segmentIndex;
+        const isClosingWrap = (seg1 === closeSegIdx && seg2 === 1) || (seg2 === closeSegIdx && seg1 === 1);
+        const cornerIdx = isClosingWrap ? 0 : Math.min(seg1, seg2);
+        newPoints.splice(cornerIdx, 1, this.intersectionPoint.clone());
+      }
+      return [new UpdateState(this.firstPick.entity, { points: newPoints })];
+    }
+
+    // Line + Polyline (or Polyline + Line): consume the line into the polyline.
+    const poly = firstIsPolyline ? this.firstPick : this.secondPick;
+    const line = firstIsPolyline ? this.secondPick : this.firstPick;
+    const polySegIdx = poly.segmentIndex;
+    const keepStart = poly.keepStart(this.intersectionPoint);
+    let newPoints;
+    if (keepStart) {
+      // Keep the polyline points up to (not including) the selected segment start,
+      // trim to the intersection and append the kept end of the line.
+      newPoints = [
+        ...poly.entity.points.slice(0, polySegIdx).map((p) => p.clone()),
+        this.intersectionPoint.clone(),
+        line.lineKeptEnd(this.intersectionPoint).clone(),
+      ];
+    } else {
+      // Keep the polyline points from the selected segment start onwards,
+      // prepending the kept end of the line and the intersection.
+      newPoints = [
+        line.lineKeptEnd(this.intersectionPoint).clone(),
+        this.intersectionPoint.clone(),
+        ...poly.entity.points.slice(polySegIdx).map((p) => p.clone()),
+      ];
+    }
+    return [
+      new RemoveState(line.entity),
+      new UpdateState(poly.entity, { points: newPoints }),
+    ];
+  }
+}

package/core/tools/copy.js

@@ -1,21 +1,39 @@
-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 {DesignCore} from '../designCore.js';
-
+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 { Point } from '../entities/point.js';
+import { AddState } from '../lib/stateManager.js';
+
+import { DesignCore } from '../designCore.js';
+
+/**
+ * Copy Command Class
+ * @extends Tool
+ */
 export class Copy extends Tool {
+  /** Create a Copy 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: 'Copy', shortcut: 'CO', type: 'Tool'};
+    const command = { command: 'Copy', shortcut: 'CO', 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]);
@@ -26,60 +44,70 @@ export class Copy extends Tool {
 
       const op2 = new PromptOptions(Strings.Input.BASEPOINT, [Input.Type.POINT]);
       const pt1 = await DesignCore.Scene.inputManager.requestInput(op2);
+      if (pt1 === undefined) return;
       this.points.push(pt1);
 
-      const op3 = new PromptOptions(Strings.Input.DESTINATION, [Input.Type.POINT, Input.Type.NUMBER]);
-      const pt2 = await DesignCore.Scene.inputManager.requestInput(op3);
+      const op3 = new PromptOptions(Strings.Input.DESTINATION, [Input.Type.POINT, Input.Type.DYNAMIC]);
+      while (true) {
+        // Reset to just the base point
+        this.points = [this.points[0]];
+
+        // Anchor inputPoint to the base point so DYNAMIC (distance) input always
+        // projects relative to it, not relative to the last copied position.
+        DesignCore.Scene.inputManager.inputPoint = this.points[0];
 
-      if (Input.getType(pt2) === Input.Type.POINT) {
-        this.points.push(pt2);
-      } else if (Input.getType(pt2) === Input.Type.NUMBER) {
-        const basePoint = this.points.at(-1);
-        const angle = Utils.degrees2radians(DesignCore.Mouse.inputAngle());
-        const point = basePoint.project(angle, pt2);
-        this.points.push(point);
+        const pt2 = await DesignCore.Scene.inputManager.requestInput(op3);
+        if (pt2 === undefined) break;
+        this.points[1] = pt2;
+        DesignCore.Scene.inputManager.actionCommand();
       }
 
       DesignCore.Scene.inputManager.executeCommand();
-    } catch (error) {
+    } catch (err) {
       Logging.instance.error(`${this.type} - ${err}`);
     }
   }
 
+  /**
+   * Preview the command during execution
+   */
   preview() {
     if (this.points.length >= 1) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
 
       // Draw a line
       const points = [this.points.at(-1), mousePoint];
+      DesignCore.Scene.tempEntities.create('Line', { points: points });
 
-      DesignCore.Scene.createTempItem('Line', {points: points});
+      const delta = mousePoint.subtract(this.lastMousePoint || this.points[0]);
+      this.lastMousePoint = mousePoint;
 
-      const xDelta = mousePoint.x - this.points[0].x;
-      const yDelta = mousePoint.y - this.points[0].y;
-
-      for (let i = 0; i <DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
-        for (let j = 0; j <DesignCore.Scene.selectionManager.selectedItems[i].points.length; j++) {
-          DesignCore.Scene.selectionManager.selectedItems[i].points[j].x = DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].points[j].x + xDelta;
-          DesignCore.Scene.selectionManager.selectedItems[i].points[j].y = DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].points[j].y + yDelta;
-        }
+      for (let i = 0; i < DesignCore.Scene.selectionManager.selectedItems.length; i++) {
+        const item = DesignCore.Scene.selectionManager.selectedItems[i];
+        const offsetPoints = item.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).add(delta));
+        item.setProperty('points', offsetPoints);
       }
     }
   }
 
+  /**
+   * Perform the command
+   */
   action() {
-    const xDelta = this.points[1].x - this.points[0].x;
-    const yDelta = this.points[1].y - this.points[0].y;
-
-    for (let i = 0; i <DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
-      const copyofitem = Utils.cloneObject(DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]]);
-
-      for (let j = 0; j < copyofitem.points.length; j++) {
-        copyofitem.points[j].x = DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].points[j].x + xDelta;
-        copyofitem.points[j].y = DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].points[j].y + yDelta;
-      }
-
-      DesignCore.Scene.items.push(copyofitem);
+    // points[1] is cleared before each destination prompt
+    // executeCommand() calls action() - guard on missing points and duplication
+    if (!this.points[1]) return;
+    const delta = this.points[1].subtract(this.points[0]);
+    const stateChanges = [];
+
+    for (let i = 0; i < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
+      const copyofitem = Utils.cloneObject(DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]));
+      const offsetPoints = copyofitem.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).add(delta));
+      copyofitem.setProperty('points', offsetPoints);
+      const stateChange = new AddState(copyofitem);
+      stateChanges.push(stateChange);
     }
+
+    DesignCore.Scene.commit(stateChanges);
   };
 }

package/core/tools/copybase.js

@@ -0,0 +1,65 @@
+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';
+
+/**
+ * Copybase Command Class
+ * @extends Tool
+ */
+export class Copybase extends Tool {
+  /** Create a Copybase 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: 'Copybase', shortcut: 'COPYBASE' };
+    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 op1 = new PromptOptions(Strings.Input.BASEPOINT, [Input.Type.POINT]);
+      const pt0 = await DesignCore.Scene.inputManager.requestInput(op1);
+      this.points.push(pt0);
+
+      DesignCore.Scene.inputManager.executeCommand();
+    } catch (err) {
+      Logging.instance.error(`${this.type} - ${err}`);
+    }
+  }
+
+
+  /**
+   * Perform the command
+   */
+  action() {
+    // generate clipboard data from selected items
+    const selectedItems = DesignCore.Scene.selectionManager.selectedItems;
+
+    // create clipboard data
+    DesignCore.Clipboard.Entities = selectedItems;
+    // set base point
+    DesignCore.Clipboard.BasePoint = this.points[0];
+  }
+}

package/core/tools/copyclip.js

@@ -0,0 +1,59 @@
+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';
+
+/**
+ * Copyclip Command Class
+ * @extends Tool
+ */
+export class Copyclip extends Tool {
+  /** Create a Copyclip 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: 'Copyclip', shortcut: 'COPYCLIP' };
+    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);
+      }
+
+      DesignCore.Scene.inputManager.executeCommand();
+    } catch (err) {
+      Logging.instance.error(`${this.type} - ${err}`);
+    }
+  }
+
+
+  /**
+   * Perform the command
+   */
+  action() {
+    // generate clipboard data from selected items
+    const selectedItems = DesignCore.Scene.selectionManager.selectedItems;
+
+    // create clipboard data
+    DesignCore.Clipboard.Entities = selectedItems;
+  }
+}

package/core/tools/cornerEntity.js

@@ -0,0 +1,138 @@
+import { Line } from '../entities/line.js';
+import { BasePolyline } from '../entities/basePolyline.js';
+
+import { DesignCore } from '../designCore.js';
+
+/**
+ * CornerEntity
+ * Holds the per-side state for one of the two entities involved in a Chamfer or Fillet operation.
+ */
+export class CornerEntity {
+  /** Create a CornerEntity */
+  constructor() {
+    // Set during execute() when the user selects an entity
+    this.entity = null;
+    this.clickPoint = null;
+    // For polyline selections: the resolved Line segment and its 1-based index
+    this.segment = null;
+    this.segmentIndex = null;
+    // Geometry set by resolveCornerGeometry() before action()
+    this.lineStart = null;
+    this.lineEnd = null;
+  }
+  /**
+   * The direction vector of the line segment (lineEnd − lineStart).
+   * @return {Point}
+   */
+  get direction() {
+    return this.lineEnd.subtract(this.lineStart);
+  }
+
+  /**
+   * The active line segment: the resolved polyline segment, or the entity itself for a plain Line.
+   * @return {Line|null}
+   */
+  get activeSeg() {
+    return this.segment ?? this.entity;
+  }
+
+  /**
+   * Validate that the active segment is a Line and populate lineStart and lineEnd from it.
+   * Returns false if the active segment is not a Line.
+   * @return {boolean}
+   */
+  resolveEndpoints() {
+    if (!(this.activeSeg instanceof Line)) return false;
+    this.lineStart = this.activeSeg.points[0];
+    this.lineEnd = this.activeSeg.points[1];
+    return true;
+  }
+
+  /**
+   * Set the entity and click point, then resolve the polyline segment.
+   * For polylines, populates segment and segmentIndex from the closest segment.
+   * For plain Lines, segment and segmentIndex are cleared to null.
+   * Returns false and notifies the user if the closest polyline segment is an arc.
+   * @param {object} entity - the selected entity
+   * @param {Point} clickPoint - the point where the user clicked
+   * @param {string} arcSegmentErrorMsg - notification string shown when the segment is an arc
+   * @return {boolean}
+   */
+  setPick(entity, clickPoint, arcSegmentErrorMsg) {
+    this.entity = entity;
+    this.clickPoint = clickPoint;
+    if (!(this.entity instanceof BasePolyline)) {
+      this.segment = null;
+      this.segmentIndex = null;
+      return true;
+    }
+    const index = this.entity.getClosestSegmentIndex(this.clickPoint);
+    const segment = this.entity.getClosestSegment(this.clickPoint);
+    if (!(segment instanceof Line)) {
+      DesignCore.Core.notify(arcSegmentErrorMsg);
+      return false;
+    }
+    this.segment = segment;
+    this.segmentIndex = index;
+    return true;
+  }
+
+  /**
+   * The perpendicular foot of clickPoint onto the line defined by lineStart/lineEnd.
+   * @return {Point}
+   */
+  get #clickOnLine() {
+    return this.clickPoint.perpendicular(this.lineStart, this.lineEnd);
+  }
+
+  /**
+   * Distance from the perpendicular foot to the intersection point.
+   * A value below Constants.Tolerance.EPSILON indicates an ambiguous corner.
+   * @param {Point} intersectionPoint - the corner intersection point
+   * @return {number}
+   */
+  clickDistance(intersectionPoint) {
+    return this.#clickOnLine.distance(intersectionPoint);
+  }
+
+  /**
+   * Vector from the intersection point toward the perpendicular foot (i.e. toward the click side).
+   * @param {Point} intersectionPoint - the corner intersection point
+   * @return {Point}
+   */
+  clickDir(intersectionPoint) {
+    return this.#clickOnLine.subtract(intersectionPoint);
+  }
+
+  /**
+   * Unit vector in the clickDir direction.
+   * @param {Point} intersectionPoint - the corner intersection point
+   * @return {Point}
+   */
+  clickUnit(intersectionPoint) {
+    return this.clickDir(intersectionPoint).normalise();
+  }
+
+  /**
+   * The line endpoint on the same side of the intersection as the click.
+   * @param {Point} intersectionPoint - the corner intersection point
+   * @return {Point}
+   */
+  lineKeptEnd(intersectionPoint) {
+    const dir = this.clickDir(intersectionPoint);
+    return dir.dot(this.lineStart.subtract(intersectionPoint)) >= dir.dot(this.lineEnd.subtract(intersectionPoint)) ?
+      this.lineStart : this.lineEnd;
+  }
+
+  /**
+   * Determine whether the start of the polyline segment should be kept when trimming.
+   * @param {Point} intersectionPoint - the corner intersection point
+   * @return {boolean}
+   */
+  keepStart(intersectionPoint) {
+    const segStart = this.entity.points[this.segmentIndex - 1];
+    const segEnd = this.entity.points[this.segmentIndex % this.entity.points.length];
+    const dir = this.clickDir(intersectionPoint);
+    return dir.dot(segStart.subtract(intersectionPoint)) >= dir.dot(segEnd.subtract(intersectionPoint));
+  }
+}

package/core/tools/cutclip.js

@@ -0,0 +1,72 @@
+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';
+
+/**
+ * Cutclip Command Class
+ * @extends Tool
+ */
+export class Cutclip extends Tool {
+  /** Create a Cutclip 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: 'Cutclip', shortcut: 'CUTCLIP' };
+    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);
+      }
+
+      DesignCore.Scene.inputManager.executeCommand();
+    } catch (err) {
+      Logging.instance.error(`${this.type} - ${err}`);
+    }
+  }
+
+
+  /**
+   * Perform the command
+   */
+  action() {
+    // generate clipboard data from selected items
+    const selectedItems = DesignCore.Scene.selectionManager.selectedItems;
+
+    // create clipboard data
+    DesignCore.Clipboard.Entities = selectedItems;
+    // get a copy of the selection set
+    const selections = DesignCore.Scene.selectionManager.selectionSet.selectionSet.slice();
+    // create state changes for each of the selections
+    const stateChanges = [];
+
+    for (let i = 0; i < selections.length; i++) {
+      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);
+  }
+}