@design-core/core 0.0.7 → 51.1.0

package/cspell.json

@@ -0,0 +1,323 @@
+{
+    "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",
+        "HATCHDOUBLE",
+        "HATCHSPACING",
+        "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": "51.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();

package/test/dimensions/{baseDimension.test.js → dimensionBase.test.js}

@@ -1,4 +1,4 @@
-import { BaseDimension } from '../../core/dimensions/baseDimension.js';
+import { DimensionBase } from '../../core/dimensions/dimensionBase.js';
 import { Point } from '../../core/entities/point.js';
 import { Core } from '../../core/core/core.js';
 import { Text } from '../../core/entities/text.js';
@@ -9,11 +9,11 @@ import { jest } from '@jest/globals';
 // initialise core
 new Core();
 
-describe('BaseDimension', () => {
+describe('DimensionBase', () => {
   let baseDim;
 
   beforeEach(() => {
-    baseDim = new BaseDimension({});
+    baseDim = new DimensionBase({});
     baseDim.points = [new Point(1, 2, 0), new Point(3, 4, 0)];
   });
 
@@ -164,7 +164,7 @@ describe('BaseDimension', () => {
   });
 
   test('constructor throws on invalid dimType', () => {
-    expect(() => new BaseDimension({ 70: 999 })).toThrow(/Invalid Dimension Type/);
+    expect(() => new DimensionBase({ 70: 999 })).toThrow(/Invalid Dimension Type/);
   });
 
   test('getDimensionValue uses textOverride', () => {
@@ -241,11 +241,11 @@ describe('BaseDimension', () => {
 
   describe('draw()', () => {
     /**
-     * Return a BaseDimension with a stubbed buildDimension() that produces one Line.
-     * @return {BaseDimension}
+     * Return a DimensionBase with a stubbed buildDimension() that produces one Line.
+     * @return {DimensionBase}
      */
     function makeDim() {
-      const dim = new BaseDimension({});
+      const dim = new DimensionBase({});
       dim.points = [new Point(0, 0), new Point(10, 0)];
       dim.buildDimension = jest.fn(() => {
         return [new Line({ points: [new Point(0, 0), new Point(10, 0)] })];
@@ -256,21 +256,21 @@ describe('BaseDimension', () => {
     test('draw() returns the block items array', () => {
       const dim = makeDim();
       const result = dim.draw({});
-      expect(result).toBe(dim.block.items);
+      expect(result).toBe(dim.block.entities);
     });
 
     test('draw() calls refresh() (via buildDimension) when block is empty', () => {
       const dim = makeDim();
-      expect(dim.block.items).toHaveLength(0);
+      expect(dim.block.entities).toHaveLength(0);
       dim.draw({});
       expect(dim.buildDimension).toHaveBeenCalledTimes(1);
-      expect(dim.block.items.length).toBeGreaterThan(0);
+      expect(dim.block.entities.length).toBeGreaterThan(0);
     });
 
     test('draw() does not call refresh() when block already has items', () => {
       const dim = makeDim();
       // pre-populate the block
-      dim.block.addItem(new Line({ points: [new Point(0, 0), new Point(1, 1)] }));
+      dim.block.addEntity(new Line({ points: [new Point(0, 0), new Point(1, 1)] }));
       dim.draw({});
       expect(dim.buildDimension).not.toHaveBeenCalled();
     });
@@ -292,7 +292,7 @@ describe('BaseDimension', () => {
     test('draw() block items have BYBLOCK colour after refresh', () => {
       const dim = makeDim();
       dim.draw({});
-      for (const item of dim.block.items) {
+      for (const item of dim.block.entities) {
         expect(item.entityColour.aci).toBe(0); // BYBLOCK = ACI 0
       }
     });