@design-core/core 0.0.7 → 50.1.0

package/core/tools/trim.js

@@ -20,7 +20,7 @@ export class Trim extends Tool {
   /** Create a Trim command */
   constructor() {
     super();
-    this.selectedItem = null;
+    this.selectedEntity = null;
     this.selectedBoundaryItems = [];
   }
 
@@ -49,7 +49,7 @@ export class Trim extends Tool {
         if (boundary === undefined) return;
       }
 
-      // add all selected items to boundary items
+      // add all selected entities 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);
@@ -59,7 +59,7 @@ export class Trim extends Tool {
       while (true) {
         const selection = await DesignCore.Scene.inputManager.requestInput(selectOp);
         if (selection === undefined) break;
-        this.selectedItem = DesignCore.Scene.entities.get(selection.selectedItemIndex);
+        this.selectedEntity = DesignCore.Scene.entities.get(selection.selectedEntityIndex);
         DesignCore.Scene.selectionManager.removeLastSelection();
         DesignCore.Scene.inputManager.actionCommand();
       }
@@ -103,26 +103,26 @@ export class Trim extends Tool {
    * Perform the command
    */
   action() {
-    if (this.selectedItem && this.selectedBoundaryItems.length) {
-      if (typeof this.selectedItem.fromPolylinePoints !== 'function') {
-        DesignCore.Core.notify(`${this.type} - ${this.selectedItem.type} ${Strings.Message.NOTRIM}`);
-        this.selectedItem = null;
+    if (this.selectedEntity && this.selectedBoundaryItems.length) {
+      if (typeof this.selectedEntity.fromPolylinePoints !== 'function') {
+        DesignCore.Core.notify(`${this.type} - ${this.selectedEntity.type} ${Strings.Message.NOTRIM}`);
+        this.selectedEntity = null;
         return;
       }
 
-      const intersectPoints = this.#collectIntersectPoints(this.selectedItem);
+      const intersectPoints = this.#collectIntersectPoints(this.selectedEntity);
 
       if (intersectPoints.length) {
-        const stateChanges = this.#trimEntity(this.selectedItem, intersectPoints);
+        const stateChanges = this.#trimEntity(this.selectedEntity, intersectPoints);
         if (stateChanges?.length) {
           DesignCore.Scene.commit(stateChanges);
         }
       } else {
-        DesignCore.Core.notify(`${this.type} - ${this.selectedItem.type} ${Strings.Message.NOTRIM}`);
+        DesignCore.Core.notify(`${this.type} - ${this.selectedEntity.type} ${Strings.Message.NOTRIM}`);
       }
     }
 
-    this.selectedItem = null;
+    this.selectedEntity = null;
   }
 
   /**
@@ -150,7 +150,7 @@ export class Trim extends Tool {
    * surrounding the mouse position. Operates entirely in polyline-point space
    * via entity.toPolylinePoints() / entity.fromPolylinePoints(), so it works
    * for any entity that implements that protocol (Line, Arc, Circle,
-   * BasePolyline, and future entities such as Spline or Ellipse).
+   * PolylineBase, and future entities such as Spline or Ellipse).
    * @param {Object} entity
    * @param {Array}  intersectPoints
    * @return {Array}
@@ -296,10 +296,10 @@ export class Trim extends Tool {
     if (fromLoc.segmentIndex === toLoc.segmentIndex) {
       const startPoint = fromLoc.point.clone();
       if (fromSegStart.bulge !== 0 && fromSegStart.bulge !== undefined) {
-        const center = fromSegStart.bulgeCentrePoint(fromSegEnd);
+        const centre = fromSegStart.bulgeCentrePoint(fromSegEnd);
         const direction = fromSegStart.bulge > 0 ? 1 : -1;
-        const startAngle = center.angle(fromLoc.point);
-        const endAngle = center.angle(toLoc.point);
+        const startAngle = centre.angle(fromLoc.point);
+        const endAngle = centre.angle(toLoc.point);
         const includedAngle = ((endAngle - startAngle) * direction + 4 * Math.PI) % (2 * Math.PI);
         startPoint.bulge = Math.tan(includedAngle / 4) * direction;
       }

package/cspell.json

@@ -0,0 +1,321 @@
+{
+    "version": "0.2",
+    "language": "en-GB",
+    "ignorePaths": [
+        "node_modules",
+        "_build",
+        "coverage",
+        "*.lock",
+        "package-lock.json",
+        "test/**"
+    ],
+    "ignoreRegExpList": [
+        "[0-9a-fA-F]{6,}"
+    ],
+    "words": [
+        "acad",
+        "ACADVER",
+        "autocad",
+        "ARCALIGNEDTEXT",
+        "ARCHTICK",
+        "arcpoints",
+        "ARCSIDE",
+        "arctext",
+        "ASME",
+        "AABB",
+        "basepoint",
+        "bbox",
+        "bboxes",
+        "bitmasked",
+        "byblock",
+        "bylayer",
+        "CANNOSCALE",
+        "CHARACTERSPACING",
+        "CHILDENTITIES",
+        "clayer",
+        "copybase",
+        "copyclip",
+        "cutclip",
+        "pasteclip",
+        "defpoints",
+        "dedup",
+        "DECIMALPLACES",
+        "DESTINATIONSET",
+        "dimstyle",
+        "dimstyles",
+        "dimline",
+        "DIMENSIONSTYLE",
+        "DIMADEC",
+        "DIMALI",
+        "DIMALT",
+        "DIMALTD",
+        "DIMALTF",
+        "DIMALTMZF",
+        "DIMALTMZS",
+        "DIMALTRND",
+        "DIMALTTD",
+        "DIMALTTZ",
+        "DIMALTU",
+        "DIMALTZ",
+        "DIMANG",
+        "DIMANNO",
+        "DIMAPOST",
+        "DIMARCSYM",
+        "DIMASO",
+        "DIMASSOC",
+        "DIMASZ",
+        "DIMATFIT",
+        "DIMAUNIT",
+        "DIMAZIN",
+        "DIMBLK",
+        "DIMCEN",
+        "DIMCENSTYL",
+        "DIMCENVALUE",
+        "DIMCLRD",
+        "DIMCLRE",
+        "DIMCLRT",
+        "DIMCONSTRAINTICON",
+        "DIMDEC",
+        "DIMDIA",
+        "DIMDLE",
+        "DIMDLI",
+        "DIMDSEP",
+        "DIMEXE",
+        "DIMEXO",
+        "DIMFIT",
+        "DIMFRAC",
+        "DIMFXL",
+        "DIMFXLON",
+        "DIMGAP",
+        "DIMJOGANG",
+        "DIMJUST",
+        "DIMLDRBLK",
+        "DIMLFAC",
+        "DIMLIM",
+        "DIMLIN",
+        "DIMLTEX",
+        "DIMLTYPE",
+        "DIMLUNIT",
+        "DIMLWD",
+        "DIMLWE",
+        "DIMMZF",
+        "DIMMZS",
+        "DIMPOST",
+        "DIMRAD",
+        "DIMRND",
+        "DIMROT",
+        "DIMSAH",
+        "DIMSCALE",
+        "DIMSD",
+        "DIMSE",
+        "DIMSHO",
+        "DIMSOXD",
+        "DIMTAD",
+        "DIMTDEC",
+        "DIMTFAC",
+        "DIMTFILL",
+        "DIMTFILLCLR",
+        "DIMTIH",
+        "DIMTIX",
+        "DIMTM",
+        "DIMTMOVE",
+        "DIMTOFL",
+        "DIMTOH",
+        "DIMTOL",
+        "DIMTOLJ",
+        "DIMTP",
+        "DIMTSZ",
+        "DIMTVP",
+        "DIMTXSTY",
+        "DIMTXT",
+        "DIMTXTDIRECTION",
+        "DIMTZIN",
+        "DIMUNIT",
+        "DIMUPT",
+        "DIMZIN",
+        "drawgrid",
+        "endblk",
+        "endsec",
+        "endsnap",
+        "EXTMAX",
+        "EXTMIN",
+        "FILLETRAD",
+        "FONTNAME",
+        "groupcode",
+        "groupcodes",
+        "groupvalue",
+        "handseed",
+        "HORIZONTALALIGNMENT",
+        "INSBASE",
+        "inputprompt",
+        "isopair",
+        "itemname",
+        "keypresses",
+        "lerp",
+        "LINEARDIMANGLE",
+        "linetype",
+        "linetypes",
+        "lineweight",
+        "ltscale",
+        "ltype",
+        "ltypes",
+        "lwpoly",
+        "lwpolyline",
+        "MLEADER",
+        "MLEADERSCALE",
+        "multileader",
+        "nearestsnap",
+        "midsnap",
+        "nodesnap",
+        "tangentsnap",
+        "quadrantsnap",
+        "perpendicularsnap",
+        "centresnap",
+        "NOCHAMFER",
+        "NOFILLET",
+        "NONCONSECUTIVESEGMENTS",
+        "NOREDO",
+        "NOTRIM",
+        "NOUNDO",
+        "OFFSETFROMARC",
+        "OFFSETFROMLEFT",
+        "OFFSETFROMRIGHT",
+        "Paperspace",
+        "PATTERNNAME",
+        "PLOTSTYLENAME",
+        "plottable",
+        "polarangle",
+        "polyface",
+        "postsuffix",
+        "preselection",
+        "RADIUSTOOLARGE",
+        "REFERENCELENGTH",
+        "RRGGBB",
+        "rubberbandcolour",
+        "SCALEFACTOR",
+        "selectedchild",
+        "SELECTIONSET",
+        "SEQEND",
+        "SINGLESELECTION",
+        "solidfill",
+        "standardflags",
+        "startxref",
+        "STYLENAME",
+        "TEXTALIGNMENT",
+        "TEXTORIENTATION",
+        "TEXTOVERRIDE",
+        "TEXTREVERSED",
+        "TEXTSIZE",
+        "TEXTSTYLE",
+        "THROUGHPOINT",
+        "truecolour",
+        "TRIMMODE",
+        "UCSICON",
+        "uncloseable",
+        "undrawn",
+        "UNKNOWNCOMMAND",
+        "unrecognised",
+        "VERTICALALIGNMENT",
+        "vport",
+        "WIDTHFACTOR",
+        "xgridmax",
+        "xgridmin",
+        "ygridmax",
+        "ygridmin",
+        "ZEROLENGTH",
+        "accentcolour",
+        "Alignedtext",
+        "BADINPUT",
+        "BLOCKNAME",
+        "boundingbox",
+        "BOXBLANK",
+        "BOXFILLED",
+        "BRELM",
+        "BRSTD",
+        "BRSTONE",
+        "canvasbackgroundcolour",
+        "CANNOTBEACTIONED",
+        "CANNOTBEDELETED",
+        "CANNOTBERENAMED",
+        "CHAMFERA",
+        "CHAMFERB",
+        "CHAMFERC",
+        "CHAMFERD",
+        "CHAMMODE",
+        "checkitems",
+        "CLOSEDBLANK",
+        "CONC",
+        "counterclockwise",
+        "cstyle",
+        "CSTYLEDELETE",
+        "currentstyle",
+        "DASHDOT",
+        "DATUMBLANK",
+        "DATUMFILLED",
+        "Degen",
+        "deleteblock",
+        "DOLMIT",
+        "DOTBLANK",
+        "DOTSMALL",
+        "Elec",
+        "ENDTAB",
+        "ERASESOURCE",
+        "Extline",
+        "FILEOPEN",
+        "fontbackwards",
+        "fontupsidedown",
+        "Gradians",
+        "gridcolour",
+        "gridlines",
+        "HBONE",
+        "INSUL",
+        "INVALIDBOUNDARY",
+        "INVALIDCLIPBOARD",
+        "INVALIDDXFFORMAT",
+        "INVALIDFILE",
+        "INVALIDGROUPCODE",
+        "INVALIDINTERSECTTYPE",
+        "INVALIDNUMBER",
+        "INVALIDPOINT",
+        "INVALIDTYPE",
+        "LAYERNAME",
+        "LEADERLENGTH",
+        "LWDEFAULT",
+        "MAXVALUE",
+        "midp",
+        "MINVALUE",
+        "MIRRORFIRST",
+        "MIRRORSECOND",
+        "MUDST",
+        "nendobj",
+        "NEWLENGTH",
+        "NEXTPOINT",
+        "NOEXTEND",
+        "nonexistent",
+        "NOTACOMMAND",
+        "NOTAPATTERN",
+        "NOTIMPLEMENTED",
+        "Offscreen",
+        "OFFSETDIST",
+        "PARALLELLINES",
+        "PARQ",
+        "PLAST",
+        "PLASTI",
+        "readblocks",
+        "renameitem",
+        "roundtrip",
+        "RROOF",
+        "RSHKE",
+        "SACNCR",
+        "Segs",
+        "TRIANG",
+        "underflowed",
+        "unminified",
+        "UNSUPPORTEDENTITIES",
+        "UPSIDEDOWN",
+        "Viewmode",
+        "xref",
+        "GOST",
+        "quot"
+    ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@design-core/core",
-  "version": "0.0.7",
+  "version": "50.1.0",
   "type": "module",
   "scripts": {
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"

package/test/dimensions/alignedDimension.test.js

@@ -13,14 +13,14 @@ const scenarios = [
 
   { desc: 'Aligned dimension from point selection',
     input: [new Point(), new Point(10, 0), new Point(5, 5)],
-    selectedItems: [],
+    selectedEntities: [],
     expectedDimType: 1,
     dimensionValue: 10,
   },
 ];
 
 test.each(scenarios)('Dimension.execute handles $desc', async (scenario) => {
-  const { input, selectedItems, expectedDimType, dimensionValue } = scenario;
+  const { input, selectedEntities, expectedDimType, dimensionValue } = scenario;
 
   await withMockInput(DesignCore.Scene, input, async () => {
     const dim = new AlignedDimension();
@@ -37,7 +37,7 @@ test.each(scenarios)('Dimension.execute handles $desc', async (scenario) => {
         expect(Number(entity.getProperty('string'))).toBeCloseTo(dimensionValue);
       }
     }
-  }, { selectedItems });
+  }, { selectedEntities });
 });
 
 test('constructor sets default properties', () => {

package/test/dimensions/angularDimension.test.js

@@ -18,35 +18,35 @@ const scenarios = [
 
   { desc: 'Angular dimension from line selection - 45 degrees',
     input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(5, 5)],
-    selectedItems: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
+    selectedEntities: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
     expectedDimType: 2,
     dimensionValue: 45,
     dimensionEntities: 5,
   },
   { desc: 'Angular dimension from line selection - 135 degrees',
     input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(-5, 5)],
-    selectedItems: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
+    selectedEntities: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
     expectedDimType: 2,
     dimensionValue: 135,
     dimensionEntities: 6,
   },
   { desc: 'Angular dimension from line selection - 45 degrees',
     input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(-5, -5)],
-    selectedItems: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
+    selectedEntities: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
     expectedDimType: 2,
     dimensionValue: 45,
     dimensionEntities: 7,
   },
   { desc: 'Angular dimension from line selection - 135 degrees',
     input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(5, -5)],
-    selectedItems: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
+    selectedEntities: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
     expectedDimType: 2,
     dimensionValue: 135,
     dimensionEntities: 6,
   },
   { desc: 'Angular dimension from polyline selection - 45 degrees',
     input: [new SingleSelection(0, new Point(5, 0)), new SingleSelection(1, new Point(5, 5)), new Point(5, 5)],
-    selectedItems: [new Polyline({ points: [new Point(0, 0), new Point(10, 0)] }), new Polyline({ points: [new Point(0, 0), new Point(10, 10)] })],
+    selectedEntities: [new Polyline({ points: [new Point(0, 0), new Point(10, 0)] }), new Polyline({ points: [new Point(0, 0), new Point(10, 10)] })],
     expectedDimType: 2,
     dimensionValue: 45,
     dimensionEntities: 5,
@@ -54,7 +54,7 @@ const scenarios = [
 ];
 
 test.each(scenarios)('Dimension.execute handles $desc', async (scenario) => {
-  const { input, selectedItems, expectedDimType, dimensionValue, dimensionEntities } = scenario;
+  const { input, selectedEntities, expectedDimType, dimensionValue, dimensionEntities } = scenario;
 
   await withMockInput(DesignCore.Scene, input, async () => {
     const dim = new AngularDimension();
@@ -74,7 +74,7 @@ test.each(scenarios)('Dimension.execute handles $desc', async (scenario) => {
         expect(entity.getProperty('string')).toContain('°');
       }
     }
-  }, { selectedItems });
+  }, { selectedEntities });
 });
 
 test('constructor sets default properties', () => {

package/test/dimensions/diametricDimension.test.js

@@ -17,28 +17,28 @@ const scenarios = [
 
   { desc: 'Diametric dimension from circle selection - Text outside circle',
     input: [new SingleSelection(0, new Point()), new Point(20, 0)],
-    selectedItems: [new Circle({ points: [new Point(0, 0), new Point(10, 0)] })],
+    selectedEntities: [new Circle({ points: [new Point(0, 0), new Point(10, 0)] })],
     expectedDimType: 3,
     dimensionValue: 20,
     dimensionEntities: 6,
   },
   { desc: 'Diametric dimension from circle selection - Text inside circle',
     input: [new SingleSelection(0, new Point()), new Point(0, 0)],
-    selectedItems: [new Circle({ points: [new Point(0, 0), new Point(10, 0)] })],
+    selectedEntities: [new Circle({ points: [new Point(0, 0), new Point(10, 0)] })],
     expectedDimType: 3,
     dimensionValue: 20,
     dimensionEntities: 5,
   },
   { desc: 'Diametric dimension from arc selection',
     input: [new SingleSelection(0, new Point()), new Point(20, 10)],
-    selectedItems: [new Arc({ points: [new Point(0, 0), new Point(20, 0), new Point(20, 20)] })],
+    selectedEntities: [new Arc({ points: [new Point(0, 0), new Point(20, 0), new Point(20, 20)] })],
     expectedDimType: 3,
     dimensionValue: 40,
     dimensionEntities: 6,
   },
   { desc: 'Diametric dimension from polyline selection',
     input: [new SingleSelection(0, new Point(30, 10)), new Point(30, 10)],
-    selectedItems: [new Polyline({ points: [new Point(0, 0), new Point(20, 0, 1), new Point(20, 20)] })],
+    selectedEntities: [new Polyline({ points: [new Point(0, 0), new Point(20, 0, 1), new Point(20, 20)] })],
     expectedDimType: 3,
     dimensionValue: 20,
     dimensionEntities: 6,
@@ -46,7 +46,7 @@ const scenarios = [
 ];
 
 test.each(scenarios)('DiametricDimension.execute handles $desc', async (scenario) => {
-  const { input, selectedItems, expectedDimType, dimensionValue, dimensionEntities } = scenario;
+  const { input, selectedEntities, expectedDimType, dimensionValue, dimensionEntities } = scenario;
 
   await withMockInput(DesignCore.Scene, input, async () => {
     const dim = new DiametricDimension();
@@ -66,7 +66,7 @@ test.each(scenarios)('DiametricDimension.execute handles $desc', async (scenario
         expect(entity.getProperty('string')).toContain('Ø');
       }
     }
-  }, { selectedItems });
+  }, { selectedEntities });
 });
 
 test('constructor sets default properties', () => {
@@ -77,14 +77,14 @@ test('constructor sets default properties', () => {
 
 
 test('getPointsFromSelection returns correct sequenced points', () => {
-  const center = new Point(0, 0);
+  const centre = new Point(0, 0);
   const textPos = new Point(10, 0);
   // Mock item with getRadius
-  const item = { points: [center], getRadius: () => 10 };
+  const item = { points: [centre], getRadius: () => 10 };
   const result = DiametricDimension.getPointsFromSelection([item], textPos);
   expect(Array.isArray(result)).toBe(true);
   expect(result.length).toBe(3);
-  expect(result[0].sequence).toBe(10); // center
+  expect(result[0].sequence).toBe(10); // centre
   expect(result[1].sequence).toBe(15); // radius point
   expect(result[2].sequence).toBe(11); // text position
 });

package/test/dimensions/dimension.test.js

@@ -18,61 +18,61 @@ const scenarios = [
 
   { desc: 'Rotated dimension from line selection',
     input: [new SingleSelection(0, new Point()), new Point(5, 5)],
-    selectedItems: [new Line({ points: [new Point(), new Point(10, 0)] })],
+    selectedEntities: [new Line({ points: [new Point(), new Point(10, 0)] })],
     expectedDimType: 0,
   },
   { desc: 'Aligned dimension from line selection',
     input: [new SingleSelection(0, new Point()), new Point(6.5, 3.5)],
-    selectedItems: [new Line({ points: [new Point(), new Point(10, 10)] })],
+    selectedEntities: [new Line({ points: [new Point(), new Point(10, 10)] })],
     expectedDimType: 1,
   },
   { desc: 'Rotated dimension from point selection',
     input: [new Point(), new Point(10, 0), new Point(5, 5)],
-    selectedItems: [],
+    selectedEntities: [],
     expectedDimType: 0,
   },
   { desc: 'Diametric dimension from circle selection',
     input: [new SingleSelection(0, new Point()), new Point(20, 10)],
-    selectedItems: [new Circle({ points: [new Point(), new Point(10, 0)] })],
+    selectedEntities: [new Circle({ points: [new Point(), new Point(10, 0)] })],
     expectedDimType: 3,
   },
   { desc: 'Radial dimension from arc selection',
     input: [new SingleSelection(0, new Point()), new Point(20, 10)],
-    selectedItems: [new Arc({ points: [new Point(), new Point(10, 0), new Point(10, 10)] })],
+    selectedEntities: [new Arc({ points: [new Point(), new Point(10, 0), new Point(10, 10)] })],
     expectedDimType: 4,
   },
   { desc: 'Angular dimension from line selection',
     input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(5, 5)],
-    selectedItems: [new Line({ points: [new Point(), new Point(10, 0)] }), new Line({ points: [new Point(), new Point(10, 10)] })],
+    selectedEntities: [new Line({ points: [new Point(), new Point(10, 0)] }), new Line({ points: [new Point(), new Point(10, 10)] })],
     expectedDimType: 2,
   },
   { desc: 'Aligned dimension from polyline selection',
     input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(5, 5)],
-    selectedItems: [new Polyline({ points: [new Point(), new Point(10, 0)] })],
+    selectedEntities: [new Polyline({ points: [new Point(), new Point(10, 0)] })],
     expectedDimType: 1,
   },
   { desc: 'Radial dimension from polyline selection',
     input: [new SingleSelection(0, new Point(16, 5)), new Point(20, 5)],
-    selectedItems: [new Polyline({ points: [new Point(), new Point(10, 0, 1), new Point(10, 10)] })],
+    selectedEntities: [new Polyline({ points: [new Point(), new Point(10, 0, 1), new Point(10, 10)] })],
     expectedDimType: 4,
   },
   { desc: 'Angular dimension from polyline selection',
     input: [new SingleSelection(0, new Point(5, 0)), new SingleSelection(1, new Point(5, 5)), new Point(5, 5)],
-    selectedItems: [new Polyline({ points: [new Point(), new Point(10, 0)] }), new Polyline({ points: [new Point(), new Point(10, 10)] })],
+    selectedEntities: [new Polyline({ points: [new Point(), new Point(10, 0)] }), new Polyline({ points: [new Point(), new Point(10, 10)] })],
     expectedDimType: 2,
   },
 
 ];
 
 test.each(scenarios)('Dimension.execute handles $desc', async (scenario) => {
-  const { input, selectedItems, expectedDimType } = scenario;
+  const { input, selectedEntities, expectedDimType } = scenario;
 
   await withMockInput(DesignCore.Scene, input, async () => {
     const dim = new Dimension();
     await dim.execute();
 
     expect(dim.dimType.getBaseDimType()).toBe(expectedDimType);
-  }, { selectedItems });
+  }, { selectedEntities });
 });
 
 test('constructor instantiates correct dimension type', () => {
@@ -95,7 +95,7 @@ test('get linear dimension type', () => {
 
 test('preview calls createTempItem with correct args', () => {
   const dim = new Dimension({ 70: 1 });
-  dim.selectedItems = [1];
+  dim.selectedEntities = [1];
   dim.points = [{}, {}];
   // Should not throw
   expect(() => dim.preview()).not.toThrow();