@design-core/core 52.0.0 → 52.2.0

package/core/tables/dimStyleManager.js

@@ -13,6 +13,8 @@ export class DimStyleManager extends StyleManagerBase {
 
     this.indelibleItems.push('STANDARD');
     this.itemProperty = 'dimensionStyle';
+
+    this.setCstyle('ISO-25');
   }
 
   /** Get the item class */

package/core/tables/styleManagerBase.js

@@ -23,12 +23,17 @@ export class StyleManagerBase extends TableManagerBase {
    * @param {boolean} showWarning
    */
   deleteStyle(itemIndex, showWarning = true) {
-    // call the super class delete
-    const deletedItem = this.deleteItem(itemIndex, showWarning);
+    // deleteItem returns the spliced array, or undefined when nothing was deleted
+    const deletedItem = this.deleteItem(itemIndex, showWarning)?.[0];
 
     if (deletedItem) {
       // delete all item using the selected style
       this.deleteStyleFromScene(deletedItem.name);
+
+      // the current style no longer exists, fall back to the first available style
+      if (this.currentstyle?.toUpperCase() === deletedItem.name.toUpperCase()) {
+        this.currentstyle = this.items[0]?.name;
+      }
     }
   }
 
@@ -37,10 +42,19 @@ export class StyleManagerBase extends TableManagerBase {
    * @param {string} style
    */
   deleteStyleFromScene(style) {
+    if (typeof style !== 'string') {
+      return;
+    }
+
+    const target = style.toUpperCase();
     const selectionSet = [];
 
     for (let i = 0; i < DesignCore.Scene.entities.count(); i++) {
-      if ((DesignCore.Scene.entities.get(i).getProperty?.(this.itemProperty) ?? DesignCore.Scene.entities.get(i)[this.itemProperty]) === style) {
+      const entity = DesignCore.Scene.entities.get(i);
+      // entities without the property (e.g. a line has no dimensionStyle) are not dependent
+      const value = entity.getProperty?.(this.itemProperty) ?? entity[this.itemProperty];
+
+      if (typeof value === 'string' && value.toUpperCase() === target) {
         selectionSet.push(i);
       }
     }

package/core/tables/tableManagerBase.js

@@ -307,9 +307,24 @@ export class TableManagerBase {
    * @param {string} newItemName
    */
   updateSceneItem(oldItemName, newItemName) {
+    const target = typeof oldItemName === 'string' ? oldItemName.toUpperCase() : undefined;
+    if (target === undefined) {
+      return;
+    }
+
     for (let i = 0; i < DesignCore.Scene.entities.count(); i++) {
-      if (DesignCore.Scene.entities.get(i)[this.itemProperty] === oldItemName) {
-        DesignCore.Scene.entities.get(i)[this.itemProperty] = newItemName;
+      const entity = DesignCore.Scene.entities.get(i);
+      const isProperty = entity.properties?.has(this.itemProperty) ?? false;
+      const value = isProperty ? entity.getProperty(this.itemProperty) : entity[this.itemProperty];
+
+      if (typeof value !== 'string' || value.toUpperCase() !== target) {
+        continue;
+      }
+
+      if (isProperty) {
+        entity.setProperty(this.itemProperty, newItemName);
+      } else {
+        entity[this.itemProperty] = newItemName;
       }
     }
   }
@@ -344,7 +359,14 @@ export class TableManagerBase {
   /** Purge unused items */
   purge() {
     const itemsToPurge = [];
+    // only style managers have a current style
+    const currentStyle = this.getCstyle?.()?.toUpperCase();
+
     this.items.forEach((item, index) => {
+      if (item.name.toUpperCase() === currentStyle) {
+        return;
+      }
+
       const searchTerm = this.itemProperty === 'block' ? item : item.name;
       const items = DesignCore.Scene.entities.find('ANY', this.itemProperty, searchTerm);
       if (items.length === 0) {

package/package.json

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

package/test/dimensions/diametricDimension.test.js

@@ -12,6 +12,7 @@ import { Utils } from '../../core/lib/utils.js';
 
 // initialise core
 new Core();
+DesignCore.DimStyleManager.setCstyle('STANDARD');
 
 // Test cases for user input
 const scenarios = [

package/test/dimensions/radialDimension.test.js

@@ -11,6 +11,7 @@ import { Polyline } from '../../core/entities/polyline.js';
 
 // initialise core
 new Core();
+DesignCore.DimStyleManager.setCstyle('STANDARD');
 
 // Test cases for user input
 const scenarios = [

package/test/integration/exportIntegration.test.js

@@ -24,6 +24,7 @@ let core;
 
 beforeAll(() => {
   core = new Core();
+  core.dimStyleManager.setCstyle('STANDARD');
 
   // Entities are arranged in a 3x3 grid of 100x100 cells:
   //

package/test/integration/userInputIntegration.test.js

@@ -95,6 +95,7 @@ async function executeToolWithInputs(tool, selectionIndices, inputs) {
 
 beforeAll(async () => {
   core = new Core();
+  core.dimStyleManager.setCstyle('STANDARD');
 
   // =====================================================================
   // Phase 1: Showcase entities  (idx 0–7)

package/test/tables/dimStyleManager.test.js

@@ -0,0 +1,90 @@
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
+
+const core = new Core();
+const dimStyleManager = core.dimStyleManager;
+
+const dimensionData = (dimensionStyle) => ({
+  points: [new Point(), new Point(10, 0), new Point(5, 5)],
+  dimensionStyle: dimensionStyle,
+});
+
+beforeEach(() => {
+  while (core.scene.entities.count() > 0) {
+    core.scene.entities.remove(0);
+  }
+});
+
+test('Test DimStyleManager.deleteStyle removes only dimensions using the style', () => {
+  dimStyleManager.addItem({ name: 'CUSTOM' });
+
+  core.scene.addEntity('Line', { points: [new Point(), new Point(10, 10)] });
+  core.scene.addEntity('Circle', { points: [new Point()], radius: 5 });
+  core.scene.addEntity('RotatedDimension', dimensionData('CUSTOM'));
+  core.scene.addEntity('RotatedDimension', dimensionData('STANDARD'));
+  expect(core.scene.entities.count()).toBe(4);
+
+  dimStyleManager.deleteStyle(dimStyleManager.getItemIndex('CUSTOM'));
+
+  expect(dimStyleManager.itemExists('CUSTOM')).toBe(false);
+  const types = core.scene.entities.get(0).type + ',' + core.scene.entities.get(1).type + ',' + core.scene.entities.get(2).type;
+  expect(core.scene.entities.count()).toBe(3);
+  expect(types).toBe('Line,Circle,RotatedDimension');
+  expect(core.scene.entities.get(2).getProperty('dimensionStyle')).toBe('STANDARD');
+});
+
+test('Test DimStyleManager.deleteStyle matches style names case-insensitively', () => {
+  dimStyleManager.addItem({ name: 'MixedCase' });
+  core.scene.addEntity('RotatedDimension', dimensionData('MIXEDCASE'));
+
+  dimStyleManager.deleteStyle(dimStyleManager.getItemIndex('MixedCase'));
+
+  expect(core.scene.entities.count()).toBe(0);
+});
+
+test('Test DimStyleManager.deleteStyle resets the current style when it is deleted', () => {
+  dimStyleManager.addItem({ name: 'CURRENT' });
+  dimStyleManager.setCstyle('CURRENT');
+
+  dimStyleManager.deleteStyle(dimStyleManager.getItemIndex('CURRENT'));
+
+  expect(dimStyleManager.getCstyle()).toBe(dimStyleManager.getItems()[0].name);
+});
+
+test('Test DimStyleManager.deleteStyle keeps indelible styles and their dimensions', () => {
+  core.scene.addEntity('RotatedDimension', dimensionData('STANDARD'));
+
+  dimStyleManager.deleteStyle(dimStyleManager.getItemIndex('STANDARD'), false);
+
+  expect(dimStyleManager.itemExists('STANDARD')).toBe(true);
+  expect(core.scene.entities.count()).toBe(1);
+});
+
+test('Test DimStyleManager.renameStyle updates dimensions through the property API', () => {
+  dimStyleManager.addItem({ name: 'OLDNAME' });
+  core.scene.addEntity('Line', { points: [new Point(), new Point(10, 10)] });
+  core.scene.addEntity('RotatedDimension', dimensionData('OLDNAME'));
+  core.scene.addEntity('RotatedDimension', dimensionData('STANDARD'));
+
+  dimStyleManager.renameStyle(dimStyleManager.getItemIndex('OLDNAME'), 'NEWNAME');
+
+  const dimension = core.scene.entities.get(1);
+  expect(dimension.getProperty('dimensionStyle')).toBe('NEWNAME');
+  expect(Object.hasOwn(dimension, 'dimensionStyle')).toBe(false);
+  expect(core.scene.entities.get(2).getProperty('dimensionStyle')).toBe('STANDARD');
+  expect(dimension.getDimensionStyle()?.name).toBe('NEWNAME');
+});
+
+test('Test DimStyleManager defaults to the ISO-25 current style', () => {
+  expect(new Core().dimStyleManager.getCstyle()).toBe('ISO-25');
+});
+
+test('Test DimStyleManager.purge keeps the current style', () => {
+  dimStyleManager.setCstyle('ISO-25');
+
+  dimStyleManager.purge();
+
+  expect(dimStyleManager.itemExists('ISO-25')).toBe(true);
+  expect(dimStyleManager.getCstyle()).toBe('ISO-25');
+  expect(dimStyleManager.itemExists('ANNOTATIVE')).toBe(false);
+});

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/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';