@design-core/core 51.2.0 → 52.2.0

package/test/tables/tableManagerBase.test.js

@@ -1,5 +1,7 @@
 import { Core } from '../../core/core/core.js';
 import { TableManagerBase } from '../../core/tables/tableManagerBase.js';
+import { DesignCore } from '../../core/designCore.js';
+import { Point } from '../../core/entities/point.js';
 
 // initialise core
 new Core();
@@ -192,3 +194,168 @@ test('Test tableManagerBase.updateItem', () => {
   tableManagerBase.updateItem(0, 'textHeight', 20);
   expect(tableManagerBase.getItemByIndex(0).textHeight).toBe(20);
 });
+
+describe('tableManagerBase deleteItem return contract', () => {
+  beforeEach(() => {
+    tableManagerBase.items = [{ name: 'itemOne' }, { name: 'Standard' }];
+    tableManagerBase.indelibleItems = ['Standard'];
+  });
+
+  test('returns the spliced array containing the deleted item', () => {
+    const deleted = tableManagerBase.deleteItem(0);
+
+    expect(Array.isArray(deleted)).toBe(true);
+    expect(deleted).toEqual([{ name: 'itemOne' }]);
+    expect(tableManagerBase.itemExists('itemOne')).toBe(false);
+  });
+
+  test('returns undefined for an invalid index', () => {
+    expect(tableManagerBase.deleteItem(10)).toBeUndefined();
+    expect(tableManagerBase.itemCount()).toBe(2);
+  });
+
+  test('returns undefined and keeps indelible items, ignoring case', () => {
+    tableManagerBase.indelibleItems = ['STANDARD'];
+
+    expect(tableManagerBase.deleteItem(1, false)).toBeUndefined();
+    expect(tableManagerBase.itemExists('Standard')).toBe(true);
+  });
+
+  test('invalidates the name lookup cache', () => {
+    expect(tableManagerBase.getItemByName('itemOne')).toBeDefined();
+
+    tableManagerBase.deleteItem(0);
+
+    expect(tableManagerBase.getItemByName('itemOne')).toBeUndefined();
+  });
+});
+
+describe('tableManagerBase lookups', () => {
+  beforeEach(() => {
+    tableManagerBase.items = [{ name: 'itemOne' }, { name: 'itemTwo' }];
+  });
+
+  test('getItemIndex is case-insensitive and returns -1 when missing', () => {
+    expect(tableManagerBase.getItemIndex('ITEMTWO')).toBe(1);
+    expect(tableManagerBase.getItemIndex('missing')).toBe(-1);
+  });
+
+  test('itemExists and getItemByName are case-insensitive', () => {
+    expect(tableManagerBase.itemExists('ITEMONE')).toBe(true);
+    expect(tableManagerBase.getItemByName('itemone').name).toBe('itemOne');
+  });
+
+  test('getItemByName cache is refreshed after addItem and rename', () => {
+    expect(tableManagerBase.getItemByName('itemOne')).toBeDefined();
+
+    tableManagerBase.addItem({ name: 'itemThree' });
+    expect(tableManagerBase.getItemByName('itemThree')).toBeDefined();
+
+    tableManagerBase.renameItem(0, 'itemRenamed');
+    expect(tableManagerBase.getItemByName('itemOne')).toBeUndefined();
+    expect(tableManagerBase.getItemByName('itemRenamed')).toBeDefined();
+  });
+
+  test('clearItems removes all items', () => {
+    tableManagerBase.clearItems();
+
+    expect(tableManagerBase.itemCount()).toBe(0);
+    expect(tableManagerBase.getItemByName('itemOne')).toBeUndefined();
+  });
+
+  test('addItem returns the existing item when not overwriting', () => {
+    const existing = tableManagerBase.getItemByName('itemOne');
+
+    expect(tableManagerBase.addItem({ name: 'ITEMONE' })).toBe(existing);
+  });
+});
+
+describe('tableManagerBase renameItem', () => {
+  beforeEach(() => {
+    tableManagerBase.items = [{ name: 'itemOne' }, { name: 'itemTwo' }, { name: 'Standard' }];
+    tableManagerBase.indelibleItems = ['Standard'];
+  });
+
+  test('returns the new name', () => {
+    expect(tableManagerBase.renameItem(0, 'renamed')).toBe('renamed');
+  });
+
+  test('returns undefined when the name is unchanged apart from case', () => {
+    expect(tableManagerBase.renameItem(0, 'ITEMONE')).toBeUndefined();
+    expect(tableManagerBase.getItemByIndex(0).name).toBe('itemOne');
+  });
+
+  test('cannot rename an indelible item', () => {
+    expect(tableManagerBase.renameItem(2, 'other')).toBeUndefined();
+    expect(tableManagerBase.getItemByIndex(2).name).toBe('Standard');
+  });
+
+  test('makes a clashing name unique', () => {
+    expect(tableManagerBase.renameItem(0, 'itemTwo')).toBe('itemTwo_1');
+  });
+});
+
+describe('tableManagerBase scene references', () => {
+  const originalProperty = tableManagerBase.itemProperty;
+
+  const addLine = (layer) => {
+    const line = DesignCore.Scene.addEntity('Line', { points: [new Point(), new Point(10, 10)], layer: layer });
+    return line;
+  };
+
+  beforeEach(() => {
+    tableManagerBase.itemProperty = 'layer';
+    tableManagerBase.items = [{ name: 'itemOne' }, { name: 'itemTwo' }];
+    tableManagerBase.indelibleItems = [];
+    while (DesignCore.Scene.entities.count() > 0) {
+      DesignCore.Scene.entities.remove(0);
+    }
+  });
+
+  afterAll(() => {
+    tableManagerBase.itemProperty = originalProperty;
+  });
+
+  test('updateSceneItem renames references through the property API', () => {
+    addLine('itemOne');
+    addLine('itemTwo');
+
+    tableManagerBase.updateSceneItem('itemOne', 'renamed');
+
+    expect(DesignCore.Scene.entities.get(0).getProperty('layer')).toBe('renamed');
+    expect(DesignCore.Scene.entities.get(1).getProperty('layer')).toBe('itemTwo');
+  });
+
+  test('updateSceneItem matches names case-insensitively', () => {
+    addLine('ITEMONE');
+
+    tableManagerBase.updateSceneItem('itemOne', 'renamed');
+
+    expect(DesignCore.Scene.entities.get(0).getProperty('layer')).toBe('renamed');
+  });
+
+  test('updateSceneItem ignores an undefined name', () => {
+    addLine('itemOne');
+
+    tableManagerBase.updateSceneItem(undefined, 'renamed');
+
+    expect(DesignCore.Scene.entities.get(0).getProperty('layer')).toBe('itemOne');
+  });
+
+  test('renameItem updates dependent entities', () => {
+    addLine('itemOne');
+
+    tableManagerBase.renameItem(0, 'renamed');
+
+    expect(DesignCore.Scene.entities.get(0).getProperty('layer')).toBe('renamed');
+  });
+
+  test('purge removes only unused items', () => {
+    addLine('itemOne');
+
+    tableManagerBase.purge();
+
+    expect(tableManagerBase.itemExists('itemOne')).toBe(true);
+    expect(tableManagerBase.itemExists('itemTwo')).toBe(false);
+  });
+});

package/test/tools/gripStretch.test.js

@@ -0,0 +1,108 @@
+import { Tool } from '../../core/tools/tool.js';
+import { GripStretch } from '../../core/tools/gripStretch.js';
+import { Core } from '../../core/core/core.js';
+import { DesignCore } from '../../core/designCore.js';
+import { DimensionBase } from '../../core/dimensions/dimensionBase.js';
+import { Point } from '../../core/entities/point.js';
+import { jest } from '@jest/globals';
+
+const core = new Core();
+
+test('GripStretch is a Tool with type GripStretch', () => {
+  const gripStretch = new GripStretch();
+  expect(gripStretch).toBeInstanceOf(Tool);
+  expect(gripStretch.type).toBe('GripStretch');
+});
+
+test('GripStretch is not registered as a typeable command', () => {
+  expect(typeof GripStretch.register).toBe('undefined');
+});
+
+test('GripStretch.action commits the dropped grip position to the real entity', () => {
+  core.scene.clear();
+  const dim = new DimensionBase({});
+  dim.points = [
+    Object.assign(new Point(0, 0), { sequence: 13 }),
+    Object.assign(new Point(10, 10), { sequence: 11 }),
+  ];
+  DesignCore.Scene.entities.add(dim);
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const grip = dim.getGrips()[0];
+  const gripStretch = new GripStretch(0, grip);
+  gripStretch.points.push(new Point(50, 60));
+
+  gripStretch.action();
+
+  const entity = core.scene.entities.get(0);
+  const pt11 = entity.getPointBySequence(entity.points, 11);
+  expect(pt11.x).toBe(50);
+  expect(pt11.y).toBe(60);
+  expect(entity.dimType.hasUserPositionedText()).toBe(true);
+});
+
+test('GripStretch.preview live-updates the selected-entity preview clone, not the real entity', () => {
+  core.scene.clear();
+  const dim = new DimensionBase({});
+  dim.points = [
+    Object.assign(new Point(0, 0), { sequence: 13 }),
+    Object.assign(new Point(10, 10), { sequence: 11 }),
+  ];
+  DesignCore.Scene.entities.add(dim);
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const grip = dim.getGrips()[0];
+  const gripStretch = new GripStretch(0, grip);
+  jest.spyOn(DesignCore.Mouse, 'pointOnScene').mockReturnValue(new Point(50, 60));
+
+  gripStretch.preview();
+
+  const previewEntity = core.scene.selectionManager.selectedEntities[0];
+  const previewPt11 = previewEntity.getPointBySequence(previewEntity.points, 11);
+  expect(previewPt11.x).toBe(50);
+  expect(previewPt11.y).toBe(60);
+
+  const realPt11 = core.scene.entities.get(0).getPointBySequence(core.scene.entities.get(0).points, 11);
+  expect(realPt11.x).toBe(10);
+  expect(realPt11.y).toBe(10);
+
+  jest.restoreAllMocks();
+});
+
+test('GripStretch.execute requests the stretch point then commits, keeping the entity selected', async () => {
+  core.scene.clear();
+  const dim = new DimensionBase({});
+  dim.points = [
+    Object.assign(new Point(0, 0), { sequence: 13 }),
+    Object.assign(new Point(10, 10), { sequence: 11 }),
+  ];
+  DesignCore.Scene.entities.add(dim);
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const grip = dim.getGrips()[0];
+  const gripStretch = new GripStretch(0, grip);
+
+  const origInputManager = DesignCore.Scene.inputManager;
+  DesignCore.Scene.inputManager = {
+    requestInput: async (op) => {
+      expect(op.promptMessage).toBe('Specify stretch point');
+      return new Point(50, 60);
+    },
+    actionCommand: () => gripStretch.action(),
+    refreshPreview: () => {},
+  };
+
+  try {
+    await gripStretch.execute();
+  } finally {
+    DesignCore.Scene.inputManager = origInputManager;
+  }
+
+  const entity = core.scene.entities.get(0);
+  const pt11 = entity.getPointBySequence(entity.points, 11);
+  expect(pt11.x).toBe(50);
+  expect(pt11.y).toBe(60);
+  // grip editing must leave the entity selected afterwards, unlike most commands
+  expect(core.scene.selectionManager.selectionSet.selectionSet).toContain(0);
+});
+

package/test/tools/offset.test.js

@@ -269,6 +269,7 @@ test('Test Offset.action - offset circle outward', () => {
   expect(newCircle.points[0].y).toBeCloseTo(0);
   // New radius should be 15
   expect(newCircle.getProperty('radius')).toBeCloseTo(15);
+  expect(newCircle.type).toBe('Circle'); // not an Arc
 });
 
 test('Test Offset.action - offset circle inward', () => {
@@ -288,6 +289,7 @@ test('Test Offset.action - offset circle inward', () => {
   expect(newCircle.points[0].x).toBeCloseTo(0);
   expect(newCircle.points[0].y).toBeCloseTo(0);
   expect(newCircle.getProperty('radius')).toBeCloseTo(7);
+  expect(newCircle.type).toBe('Circle'); // not an Arc
 });
 
 test('Test Offset.action - offset circle inward returns null when radius would be zero', () => {

package/test/tools/purge.test.js

@@ -46,7 +46,9 @@ test('Test purge.action', () => {
   expect(dimStyleManager.itemCount()).toBe(4);
   purge.option = 'Dimstyles';
   purge.action();
-  expect(dimStyleManager.itemCount()).toBe(1);
+  // STANDARD is indelible and ISO-25 is the current style
+  expect(dimStyleManager.itemCount()).toBe(2);
+  expect(dimStyleManager.itemExists('ISO-25')).toBe(true);
 
   expect(layerManager.itemCount()).toBe(4);
   purge.option = 'Layers';

package/test/tools/tool.test.js

@@ -0,0 +1,25 @@
+import { Core } from '../../core/core/core.js';
+import { DesignCore } from '../../core/designCore.js';
+import { Tool } from '../../core/tools/tool.js';
+import { jest } from '@jest/globals';
+
+new Core();
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+test('Tool.cancel default delegates to inputManager.reset()', () => {
+  const tool = new Tool();
+  const resetSpy = jest.spyOn(DesignCore.Scene.inputManager, 'reset').mockImplementation(() => {});
+
+  tool.cancel();
+
+  expect(resetSpy).toHaveBeenCalledTimes(1);
+});
+
+test('Tool.preview and Tool.action are no-ops by default', () => {
+  const tool = new Tool();
+  expect(() => tool.preview()).not.toThrow();
+  expect(() => tool.action()).not.toThrow();
+});