@design-core/core 0.0.1 → 0.0.3

package/test/lib/dxf/handleManager.test.js

@@ -0,0 +1,137 @@
+import { HandleManager } from '../../../core/lib/dxf/handleManager.js';
+
+test('Test HandleManager.constructor', () => {
+  const handle = new HandleManager();
+  expect(handle.counter).toBe(10);
+  expect(handle.usedHandles.size).toBe(0);
+});
+
+test('Test HandleManager.next', () => {
+  const handle = new HandleManager();
+  expect(handle.next()).toBe('A');
+  expect(handle.next()).toBe('B');
+  expect(handle.next()).toBe('C');
+  expect(handle.counter).toBe(13);
+  // each allocated handle is tracked in usedHandles
+  expect(handle.usedHandles.has('A')).toBe(true);
+  expect(handle.usedHandles.has('B')).toBe(true);
+  expect(handle.usedHandles.has('C')).toBe(true);
+});
+
+test('Test HandleManager.format', () => {
+  const handle = new HandleManager();
+  expect(handle.format(0)).toBe('0');
+  expect(handle.format(10)).toBe('A');
+  expect(handle.format(15)).toBe('F');
+  expect(handle.format(16)).toBe('10');
+  expect(handle.format(255)).toBe('FF');
+});
+
+test('Test HandleManager.reset', () => {
+  const handle = new HandleManager();
+  handle.next();
+  handle.next();
+  expect(handle.counter).toBe(12);
+  handle.reset();
+  expect(handle.counter).toBe(10);
+  // usedHandles must also be cleared
+  expect(handle.usedHandles.size).toBe(0);
+});
+
+test('Test HandleManager.handseed getter', () => {
+  const handle = new HandleManager();
+  expect(handle.handseed).toBe('A');
+  handle.next();
+  expect(handle.handseed).toBe('B');
+});
+
+test('Test HandleManager.handseed setter', () => {
+  const handle = new HandleManager();
+  handle.handseed = 'FF';
+  expect(handle.counter).toBe(255);
+  expect(handle.next()).toBe('FF');
+  expect(handle.next()).toBe('100');
+});
+
+test('Test HandleManager.handseed setter directly assigns counter, even below current value', () => {
+  const handle = new HandleManager();
+  // Advance the counter, then set handseed to a lower value.
+  // The setter performs a direct assignment with no lower-bound guard.
+  handle.next(); // counter → 11
+  handle.next(); // counter → 12
+  handle.handseed = '5'; // parseInt('5', 16) = 5
+  expect(handle.counter).toBe(5);
+});
+
+test('Test HandleManager.checkHandle coerces numeric handle to string', () => {
+  const handle = new HandleManager();
+  handle.checkHandle(255);
+  // String(255) = '255', which is valid hex (0x255 = 597)
+  expect(handle.usedHandles.has('255')).toBe(true);
+  expect(handle.counter).toBe(598);
+});
+
+test('Test HandleManager.checkHandle advances counter when handle >= counter', () => {
+  const handle = new HandleManager();
+  // counter starts at 10 (0xA); register 0x1F (31) — above counter
+  handle.checkHandle('1F');
+  expect(handle.usedHandles.has('1F')).toBe(true);
+  expect(handle.counter).toBe(32); // 0x1F + 1
+});
+
+test('Test HandleManager.checkHandle does not advance counter when handle < counter', () => {
+  const handle = new HandleManager();
+  handle.next(); // counter → 11 (0xB), 'A' allocated
+  const counterBefore = handle.counter;
+  // Register a handle lower than current counter
+  handle.checkHandle('5');
+  expect(handle.usedHandles.has('5')).toBe(true);
+  expect(handle.counter).toBe(counterBefore); // counter unchanged
+});
+
+test('Test HandleManager.checkHandle ignores undefined and null', () => {
+  const handle = new HandleManager();
+  const counterBefore = handle.counter;
+  handle.checkHandle(undefined);
+  handle.checkHandle(null);
+  expect(handle.counter).toBe(counterBefore);
+  expect(handle.usedHandles.size).toBe(0);
+});
+
+test('Test HandleManager.checkHandle ignores invalid hex strings', () => {
+  const handle = new HandleManager();
+  const counterBefore = handle.counter;
+  handle.checkHandle('XYZ');
+  handle.checkHandle('');
+  expect(handle.counter).toBe(counterBefore);
+  expect(handle.usedHandles.size).toBe(0);
+});
+
+test('Test HandleManager.releaseHandle removes handle from usedHandles', () => {
+  const handle = new HandleManager();
+  const h = handle.next(); // allocates 'A'
+  expect(handle.usedHandles.has('A')).toBe(true);
+  handle.releaseHandle(h);
+  expect(handle.usedHandles.has('A')).toBe(false);
+});
+
+test('Test HandleManager.releaseHandle ignores undefined and null', () => {
+  const handle = new HandleManager();
+  handle.next();
+  const sizeBefore = handle.usedHandles.size;
+  handle.releaseHandle(undefined);
+  handle.releaseHandle(null);
+  expect(handle.usedHandles.size).toBe(sizeBefore);
+});
+
+test('Test HandleManager.releaseHandle allows handle to be re-registered without duplicate error', () => {
+  const handle = new HandleManager();
+  const h = handle.next(); // allocates 'A'
+  handle.releaseHandle(h);
+  // After release the handle is gone, so checkHandle should re-register it cleanly
+  handle.checkHandle(h);
+  // The handle should be back in usedHandles with no duplicate detection
+  expect(handle.usedHandles.has('A')).toBe(true);
+  // Only one entry — no duplication
+  expect(handle.usedHandles.size).toBe(1);
+});

package/test/lib/dxf/sections/blocks.test.js

@@ -1,8 +1,8 @@
-import {Blocks} from '../../../../core/lib/dxf/sections/blocks.js';
-import {DxfIterator} from '../../../../core/lib/dxf/dxfIterator.js';
+import { Blocks } from '../../../../core/lib/dxf/sections/blocks.js';
+import { DxfIterator } from '../../../../core/lib/dxf/dxfIterator.js';
 
 const blockData =
-`2
+  `2
 BLOCKS
   0
 BLOCK
@@ -91,7 +91,7 @@ test('Test blocks.read', () => {
 test('Test blocks.addTable', () => {
   // block without data
   const blockEntity = {};
-  const blockCount = blocks.blocks.length;
+  const itemCount = blocks.blocks.length;
   blocks.addBlock(blockEntity);
-  expect(blocks.blocks.length).toBe(blockCount);
+  expect(blocks.blocks.length).toBe(itemCount);
 });

package/test/lib/dxf/sections/entities.test.js

@@ -1,8 +1,8 @@
-import {Entities} from '../../../../core/lib/dxf/sections/entities.js';
-import {DxfIterator} from '../../../../core/lib/dxf/dxfIterator.js';
+import { Entities } from '../../../../core/lib/dxf/sections/entities.js';
+import { DxfIterator } from '../../../../core/lib/dxf/dxfIterator.js';
 
 const entityData =
-`0
+  `0
 ENTITIES
 0
 CIRCLE
@@ -119,7 +119,7 @@ test('Test Entities.read', () => {
 
 test('Test Entities.addEntity', () => {
   // entity without points
-  const circleEntity = {'0': 'CIRCLE', '40': 100, '8': '0'};
+  const circleEntity = { '0': 'CIRCLE', '40': 100, '8': '0' };
 
   expect(() => {
     entities.addEntity(circleEntity);

package/test/lib/dxf/sections/header.test.js

@@ -1,8 +1,8 @@
-import {Header} from '../../../../core/lib/dxf/sections/header.js';
-import {DxfIterator} from '../../../../core/lib/dxf/dxfIterator.js';
+import { Header } from '../../../../core/lib/dxf/sections/header.js';
+import { DxfIterator } from '../../../../core/lib/dxf/dxfIterator.js';
 
 const headerData =
-`2
+  `2
 HEADER
   9
 $ACADVER
@@ -32,7 +32,15 @@ $EXTMAX
 300
  30
 0.0
+9
+$TEXTSTYLE
+  7
+Standard
   9
+$CLAYER
+  8
+0
+  0
 ENDSEC
 0
 EOF`;
@@ -43,7 +51,7 @@ const header = new Header();
 header.read(iterator);
 
 test('Test Header.read', () => {
-  expect(Object.keys(header)).toHaveLength(5);
+  expect(Object.keys(header)).toHaveLength(6);
   // check the entity type
   expect(header).toHaveProperty('$ACADVER');
   expect(header['$ACADVER']).toHaveProperty('1', 'AC1009');
@@ -59,4 +67,10 @@ test('Test Header.read', () => {
   expect(header['$EXTMIN'].points[0]).toHaveProperty('x', 100);
   expect(header['$EXTMIN'].points[0]).toHaveProperty('y', 100);
   expect(header['$EXTMIN'].points[0]).toHaveProperty('z', 100);
+
+  expect(header).toHaveProperty('$TEXTSTYLE');
+  expect(header['$TEXTSTYLE']).toHaveProperty('7', 'Standard');
+
+  expect(header).toHaveProperty('$CLAYER');
+  expect(header['$CLAYER']).toHaveProperty('8', '0');
 });

package/test/lib/dxf/sections/objects.test.js

@@ -0,0 +1,132 @@
+import { Objects } from '../../../../core/lib/dxf/sections/objects.js';
+import { DxfIterator } from '../../../../core/lib/dxf/dxfIterator.js';
+
+const objectData =
+  `0
+OBJECTS
+0
+DICTIONARY
+5
+27
+100
+AcDbDictionary
+281
+1
+3
+ACAD_GROUP
+350
+26
+0
+DICTIONARY
+5
+26
+100
+AcDbDictionary
+281
+1
+0
+ENDSEC
+0
+EOF`;
+
+const iterator = new DxfIterator();
+iterator.loadFile(objectData);
+const objects = new Objects();
+
+test('Test Objects.read', () => {
+  const readObjects = objects.read(iterator);
+
+  expect(readObjects).toHaveLength(2);
+
+  const rootDictionary = readObjects[0];
+  const groupDictionary = readObjects[1];
+
+  // check the object types
+  expect(rootDictionary).toHaveProperty('0', 'DICTIONARY');
+  expect(groupDictionary).toHaveProperty('0', 'DICTIONARY');
+
+  // check handles
+  expect(rootDictionary).toHaveProperty('5', '27');
+  expect(groupDictionary).toHaveProperty('5', '26');
+
+  // check AcDbDictionary subclass marker
+  expect(rootDictionary).toHaveProperty('100', 'AcDbDictionary');
+  expect(groupDictionary).toHaveProperty('100', 'AcDbDictionary');
+
+  // check duplicate record cloning
+  expect(rootDictionary).toHaveProperty('281', 1);
+  expect(groupDictionary).toHaveProperty('281', 1);
+
+  // check root dictionary entries
+  expect(rootDictionary).toHaveProperty('3', 'ACAD_GROUP');
+  expect(rootDictionary).toHaveProperty('350', '26');
+});
+
+test('Test Objects.read with multiple entries', () => {
+  const multiEntryData =
+    `0
+OBJECTS
+0
+DICTIONARY
+5
+C
+100
+AcDbDictionary
+281
+1
+3
+ACAD_GROUP
+350
+D
+3
+ACAD_LAYOUT
+350
+1A
+3
+ACAD_PLOTSTYLENAME
+350
+E
+0
+DICTIONARY
+5
+D
+100
+AcDbDictionary
+281
+1
+0
+ENDSEC
+0
+EOF`;
+
+  const iter = new DxfIterator();
+  iter.loadFile(multiEntryData);
+  const obj = new Objects();
+  const result = obj.read(iter);
+
+  expect(result).toHaveLength(2);
+
+  const rootDict = result[0];
+
+  // multiple group code 3 values should be arrayed
+  expect(rootDict[3]).toEqual(['ACAD_GROUP', 'ACAD_LAYOUT', 'ACAD_PLOTSTYLENAME']);
+  // multiple group code 350 values should be arrayed
+  expect(rootDict[350]).toEqual(['D', '1A', 'E']);
+});
+
+test('Test Objects.read with empty section', () => {
+  const emptyData =
+    `0
+OBJECTS
+0
+ENDSEC
+0
+EOF`;
+
+  const iter = new DxfIterator();
+  iter.loadFile(emptyData);
+  const obj = new Objects();
+  const result = obj.read(iter);
+
+  expect(result).toHaveLength(0);
+});

package/test/lib/dxf/sections/section.test.js

@@ -1,5 +1,5 @@
-import {Section} from '../../../../core/lib/dxf/sections/section.js';
-import {DxfIterator} from '../../../../core/lib/dxf/dxfIterator.js';
+import { Section } from '../../../../core/lib/dxf/sections/section.js';
+import { DxfIterator } from '../../../../core/lib/dxf/dxfIterator.js';
 
 const section = new Section();
 
@@ -29,7 +29,7 @@ test('Test Section.parseValue', () => {
 
 test('Test Section.parseChild', () => {
   const string =
-`0
+    `0
 CIRCLE
   8
 0
@@ -69,7 +69,7 @@ EOF`;
 
 test('Test Section.parsePoint', () => {
   const string =
-`10
+    `10
   500.0
 20
   500.0
@@ -125,69 +125,69 @@ test('Test Section.parseBoolean', () => {
 
 test('Test Section.getGroupValue', () => {
   // 0-9: String
-  expect(section.getGroupValue({'code': '1', 'value': '1'})).toBe('1');
+  expect(section.getGroupValue({ 'code': '1', 'value': '1' })).toBe('1');
   // 10-39: Double precision 3D point value
   // 40-59: Double precision floating-point value
-  expect(section.getGroupValue({'code': '10', 'value': ' 100.0'})).toBe(100.0);
+  expect(section.getGroupValue({ 'code': '10', 'value': ' 100.0' })).toBe(100.0);
   // 60-79: 16-bit integer value
   // 90-99: 32-bit integer value
-  expect(section.getGroupValue({'code': '60', 'value': ' 100.0'})).toBe(100);
+  expect(section.getGroupValue({ 'code': '60', 'value': ' 100.0' })).toBe(100);
   // 100: String (255-character maximum; less for Unicode strings)
   // 102: String (255-character maximum; less for Unicode strings)
   // 105: String representing hexadecimal (hex) handle value
-  expect(section.getGroupValue({'code': '100', 'value': 'aabbccdd'})).toBe('aabbccdd');
+  expect(section.getGroupValue({ 'code': '100', 'value': 'aabbccdd' })).toBe('aabbccdd');
   // 110-119: Double precision floating-point value
   // 120-129: Double precision floating-point value
   // 130-139: Double precision floating-point value
   // 140-149: Double precision scalar floating-point value
-  expect(section.getGroupValue({'code': '110', 'value': ' 100.0'})).toBe(100.0);
+  expect(section.getGroupValue({ 'code': '110', 'value': ' 100.0' })).toBe(100.0);
   // 160-169: 64-bit integer value
   // 170-179: 16-bit integer value
-  expect(section.getGroupValue({'code': '160', 'value': ' 100.0'})).toBe(100);
+  expect(section.getGroupValue({ 'code': '160', 'value': ' 100.0' })).toBe(100);
   // 210-239: Double-precision floating-point value
-  expect(section.getGroupValue({'code': '210', 'value': ' 100.0'})).toBe(100.0);
+  expect(section.getGroupValue({ 'code': '210', 'value': ' 100.0' })).toBe(100.0);
   // 270-279: 16-bit integer value
   // 280-289: 16-bit integer value
-  expect(section.getGroupValue({'code': '270', 'value': ' 100.0'})).toBe(100);
+  expect(section.getGroupValue({ 'code': '270', 'value': ' 100.0' })).toBe(100);
   // 290-299: Boolean flag value
-  expect(section.getGroupValue({'code': '290', 'value': ' 0'})).toBe(false);
-  expect(section.getGroupValue({'code': '299', 'value': ' 1'})).toBe(true);
+  expect(section.getGroupValue({ 'code': '290', 'value': ' 0' })).toBe(false);
+  expect(section.getGroupValue({ 'code': '299', 'value': ' 1' })).toBe(true);
   // 300-309: Arbitrary text string
   // 330-369: String representing hex object IDs
-  expect(section.getGroupValue({'code': '300', 'value': 'aabbccdd'})).toBe('aabbccdd');
+  expect(section.getGroupValue({ 'code': '300', 'value': 'aabbccdd' })).toBe('aabbccdd');
   // 370-379: 16-bit integer value
   // 380-389: 16-bit integer value
-  expect(section.getGroupValue({'code': '370', 'value': ' 100.0'})).toBe(100);
+  expect(section.getGroupValue({ 'code': '370', 'value': ' 100.0' })).toBe(100);
   // 390-399: String representing hex handle value
-  expect(section.getGroupValue({'code': '390', 'value': 'aabbccdd'})).toBe('aabbccdd');
+  expect(section.getGroupValue({ 'code': '390', 'value': 'aabbccdd' })).toBe('aabbccdd');
   // 400-409: 16-bit integer value
-  expect(section.getGroupValue({'code': '400', 'value': ' 100.0'})).toBe(100);
+  expect(section.getGroupValue({ 'code': '400', 'value': ' 100.0' })).toBe(100);
   // 410-419: String
-  expect(section.getGroupValue({'code': '410', 'value': 'aabbccdd'})).toBe('aabbccdd');
+  expect(section.getGroupValue({ 'code': '410', 'value': 'aabbccdd' })).toBe('aabbccdd');
   // 420-429: 32-bit integer value
-  expect(section.getGroupValue({'code': '420', 'value': ' 100.0'})).toBe(100);
+  expect(section.getGroupValue({ 'code': '420', 'value': ' 100.0' })).toBe(100);
   // 430-439: String
-  expect(section.getGroupValue({'code': '340', 'value': 'aabbccdd'})).toBe('aabbccdd');
+  expect(section.getGroupValue({ 'code': '340', 'value': 'aabbccdd' })).toBe('aabbccdd');
   // 440-449: 32-bit integer value
   // 450-459: Long
-  expect(section.getGroupValue({'code': '440', 'value': ' 100.0'})).toBe(100);
+  expect(section.getGroupValue({ 'code': '440', 'value': ' 100.0' })).toBe(100);
   // 460-469: Double-precision floating-point value
-  expect(section.getGroupValue({'code': '460', 'value': ' 100.0'})).toBe(100.0);
+  expect(section.getGroupValue({ 'code': '460', 'value': ' 100.0' })).toBe(100.0);
   // 470-479: String
   // 480-481: String representing hex handle value
-  expect(section.getGroupValue({'code': '470', 'value': 'aabbccdd'})).toBe('aabbccdd');
+  expect(section.getGroupValue({ 'code': '470', 'value': 'aabbccdd' })).toBe('aabbccdd');
   // 999: Comment (string)
-  expect(section.getGroupValue({'code': '999', 'value': 'comment'})).toBe('comment');
+  expect(section.getGroupValue({ 'code': '999', 'value': 'comment' })).toBe('comment');
   // 1000-1009: String (same limits as indicated with 0-9 code range)
-  expect(section.getGroupValue({'code': '1000', 'value': 'aabbccdd'})).toBe('aabbccdd');
+  expect(section.getGroupValue({ 'code': '1000', 'value': 'aabbccdd' })).toBe('aabbccdd');
   // 1010-1059: Double-precision floating-point value
-  expect(section.getGroupValue({'code': '1010', 'value': ' 100.0'})).toBe(100.0);
+  expect(section.getGroupValue({ 'code': '1010', 'value': ' 100.0' })).toBe(100.0);
   // 1060-1070: 16-bit integer value
   // 1071: 32-bit: integer value
-  expect(section.getGroupValue({'code': '1060', 'value': ' 100.0'})).toBe(100);
+  expect(section.getGroupValue({ 'code': '1060', 'value': ' 100.0' })).toBe(100);
 
   // test for throw on invalid group code
   expect(() => {
-    section.getGroupValue({'code': 'error', 'value': 'error'}); ;
+    section.getGroupValue({ 'code': 'error', 'value': 'error' }); ;
   }).toThrow();
 });

package/test/lib/dxf/sections/tables.test.js

@@ -1,8 +1,8 @@
-import {Tables} from '../../../../core/lib/dxf/sections/tables.js';
-import {DxfIterator} from '../../../../core/lib/dxf/dxfIterator.js';
+import { Tables } from '../../../../core/lib/dxf/sections/tables.js';
+import { DxfIterator } from '../../../../core/lib/dxf/dxfIterator.js';
 
 const tableData =
-`0
+  `0
 TABLES
 0
 TABLE

package/test/lib/entityManager.test.js

@@ -0,0 +1,163 @@
+import { Core } from '../../core/core/core.js';
+import { DesignCore } from '../../core/designCore.js';
+import { Line } from '../../core/entities/line.js';
+import { Circle } from '../../core/entities/circle.js';
+import { Point } from '../../core/entities/point.js';
+
+// initialise core (also activates DesignCore facade)
+new Core();
+
+describe('EntityManager', () => {
+  beforeEach(() => {
+    // reset scene entities before each test
+    DesignCore.Scene.clear();
+  });
+
+  test('create adds a new entity with current layer', () => {
+    const mgr = DesignCore.Scene.entities;
+    const p1 = new Point(0, 0);
+    const p2 = new Point(10, 0);
+
+    mgr.create('Line', { points: [p1, p2] });
+
+    expect(mgr.count()).toBe(1);
+    const ent = mgr.get(0);
+    expect(ent).toBeInstanceOf(Line);
+    expect(ent.layer).toBe(DesignCore.LayerManager.getCstyle());
+  });
+
+  test('add/get/count manage entities correctly', () => {
+    const mgr = DesignCore.Scene.entities;
+    const line = new Line({ points: [new Point(0, 0), new Point(1, 1)] });
+    expect(mgr.count()).toBe(0);
+    mgr.add(line);
+    expect(mgr.count()).toBe(1);
+    expect(mgr.get(0)).toBe(line);
+  });
+
+  test('replace swaps entity at index', () => {
+    const mgr = DesignCore.Scene.entities;
+    const line = new Line({ points: [new Point(0, 0), new Point(1, 1)] });
+    const circle = new Circle({ points: [new Point(5, 5)], radius: 2 });
+    mgr.add(line);
+    expect(mgr.get(0)).toBeInstanceOf(Line);
+    mgr.replace(0, circle);
+    expect(mgr.get(0)).toBe(circle);
+    expect(mgr.get(0)).toBeInstanceOf(Circle);
+  });
+
+  test('remove deletes entity at index', () => {
+    const mgr = DesignCore.Scene.entities;
+    const l1 = new Line({ points: [new Point(0, 0), new Point(1, 0)] });
+    const l2 = new Line({ points: [new Point(0, 1), new Point(1, 1)] });
+    mgr.add(l1);
+    mgr.add(l2);
+    expect(mgr.count()).toBe(2);
+    mgr.remove(0);
+    expect(mgr.count()).toBe(1);
+    expect(mgr.get(0)).toBe(l2);
+  });
+
+  test('remove releases the entity handle from HandleManager', () => {
+    const mgr = DesignCore.Scene.entities;
+    const line = new Line({ points: [new Point(0, 0), new Point(1, 0)] });
+    mgr.add(line);
+    const handle = line.handle;
+    expect(DesignCore.HandleManager.usedHandles.has(handle)).toBe(true);
+    mgr.remove(0);
+    expect(DesignCore.HandleManager.usedHandles.has(handle)).toBe(false);
+  });
+
+  test('remove then re-add (undo) does not produce a duplicate handle', () => {
+    const mgr = DesignCore.Scene.entities;
+    const line = new Line({ points: [new Point(0, 0), new Point(1, 0)] });
+    mgr.add(line);
+    const handle = line.handle;
+    const sizeAfterAdd = DesignCore.HandleManager.usedHandles.size;
+
+    mgr.remove(0);
+    // After remove the handle must be released
+    expect(DesignCore.HandleManager.usedHandles.has(handle)).toBe(false);
+    expect(DesignCore.HandleManager.usedHandles.size).toBe(sizeAfterAdd - 1);
+
+    // Re-add the same entity (simulates undo of a delete)
+    mgr.add(line);
+    expect(line.handle).toBe(handle);
+    expect(DesignCore.HandleManager.usedHandles.has(handle)).toBe(true);
+    // Size must return to what it was after the first add, not grow by one.
+    // If checkHandle silently re-inserted without the prior releaseHandle, the
+    // Set would still show size = sizeAfterAdd (Sets deduplicate), but the
+    // error log would fire. Tracking size across remove → re-add catches the
+    // case where releaseHandle was not called and size never shrank.
+    expect(DesignCore.HandleManager.usedHandles.size).toBe(sizeAfterAdd);
+  });
+
+
+  test('indexOf - test correct index is returned', () => {
+    const mgr = DesignCore.Scene.entities;
+    // Add two lines with the same data
+    const l1 = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+    const l2 = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+    mgr.add(l1);
+    mgr.add(l2);
+    expect(mgr.count()).toBe(2);
+    expect(mgr.indexOf(l1)).toBe(0);
+    expect(mgr.indexOf(l2)).toBe(1);
+  });
+
+  test('find returns indices matching type and property', () => {
+    const mgr = DesignCore.Scene.entities;
+    const l1 = new Line({ points: [new Point(0, 0), new Point(1, 0)], lineWidth: 5 });
+    const l2 = new Line({ points: [new Point(0, 1), new Point(1, 1)], lineWidth: 2 });
+    mgr.add(l1);
+    mgr.add(l2);
+
+    const found = mgr.find('Line', 'lineWidth', 5);
+    expect(found).toEqual([0]);
+
+    const anyFound = mgr.find('ANY', 'lineWidth', 2);
+    expect(anyFound).toEqual([1]);
+  });
+
+  test('findClosest returns index of nearest selectable entity', () => {
+    const mgr = DesignCore.Scene.entities;
+    // two horizontal lines at y=0 and y=10
+    const l1 = new Line({ points: [new Point(0, 0), new Point(100, 0)] });
+    const l2 = new Line({ points: [new Point(0, 10), new Point(100, 10)] });
+    mgr.add(l1);
+    mgr.add(l2);
+
+    // point closer to y=10 line
+    const p = new Point(50, 9.9);
+    const idx = mgr.findClosest(p);
+    expect(idx).toBe(1);
+  });
+
+  test('update applies setProperty for existing keys only', () => {
+    const mgr = DesignCore.Scene.entities;
+    const l = new Line({ points: [new Point(0, 0), new Point(1, 1)] });
+    mgr.add(l);
+
+    const newP1 = new Point(2, 2);
+    const newP2 = new Point(3, 3);
+    mgr.update(0, { points: [newP1, newP2], nonExistent: 123 });
+
+    expect(mgr.get(0).points[0].x).toBe(2);
+    expect(mgr.get(0).points[0].y).toBe(2);
+    expect(mgr.get(0).points[1].x).toBe(3);
+    expect(mgr.get(0).points[1].y).toBe(3);
+    // nonExistent should be ignored
+    expect(mgr.get(0).nonExistent).toBeUndefined();
+  });
+
+  test('count and clear reflect entity storage size', () => {
+    const mgr = DesignCore.Scene.entities;
+    mgr.add(new Line({ points: [new Point(0, 0), new Point(1, 0)] }));
+    mgr.add(new Line({ points: [new Point(0, 1), new Point(1, 1)] }));
+    expect(mgr.count()).toBe(2);
+    mgr.clear();
+    expect(mgr.count()).toBe(0);
+  });
+});
+
+