@design-core/core 0.0.1 → 0.0.3

package/test/objects/dictionary.test.js

@@ -0,0 +1,81 @@
+import { DXFFile } from '../../core/lib/dxf/dxfFile.js';
+import { Dictionary } from '../../core/objects/dictionary.js';
+
+test('Test Dictionary constructor defaults', () => {
+  const dict = new Dictionary();
+  expect(dict.name).toBe('');
+  expect(dict.duplicateRecordCloning).toBe(1);
+  expect(dict.entries).toEqual([]);
+});
+
+test('Test Dictionary constructor with name property', () => {
+  const dict = new Dictionary({ name: 'ACAD_GROUP' });
+  expect(dict.name).toBe('ACAD_GROUP');
+});
+
+test('Test Dictionary constructor with DXF group code', () => {
+  const dict = new Dictionary({ 3: 'ACAD_GROUP' });
+  expect(dict.name).toBe('ACAD_GROUP');
+});
+
+test('Test Dictionary constructor with entries', () => {
+  const dict = new Dictionary({
+    entries: [{ name: 'ACAD_GROUP', handle: 'D' }],
+  });
+  expect(dict.entries.length).toBe(1);
+  expect(dict.entries[0].name).toBe('ACAD_GROUP');
+  expect(dict.entries[0].handle).toBe('D');
+});
+
+test('Test Dictionary constructor with duplicateRecordCloning', () => {
+  const dict = new Dictionary({ duplicateRecordCloning: 0 });
+  expect(dict.duplicateRecordCloning).toBe(0);
+});
+
+test('Test Dictionary constructor with DXF group code 281', () => {
+  const dict = new Dictionary({ 281: 0 });
+  expect(dict.duplicateRecordCloning).toBe(0);
+});
+
+test('Test Dictionary.dxf with no entries', () => {
+  const dict = new Dictionary({ name: 'ACAD_GROUP', handle: '1A' });
+  const file = new DXFFile();
+  dict.dxf(file);
+
+  const dxfString = `0
+DICTIONARY
+5
+1A
+100
+AcDbDictionary
+281
+1
+`;
+
+  expect(file.contents).toEqual(dxfString);
+});
+
+test('Test Dictionary.dxf with entries', () => {
+  const dict = new Dictionary({
+    handle: '1B',
+    entries: [{ name: 'ACAD_GROUP', handle: 'D' }],
+  });
+  const file = new DXFFile();
+  dict.dxf(file);
+
+  const dxfString = `0
+DICTIONARY
+5
+1B
+100
+AcDbDictionary
+281
+1
+3
+ACAD_GROUP
+350
+D
+`;
+
+  expect(file.contents).toEqual(dxfString);
+});

package/test/objects/dictionaryManager.test.js

@@ -0,0 +1,34 @@
+import { Core } from '../../core/core/core.js';
+import { DXFFile } from '../../core/lib/dxf/dxfFile.js';
+
+const core = new Core();
+const dictionaryManager = core.dictionaryManager;
+
+test('Test DictionaryManager.dxf', () => {
+  const file = new DXFFile();
+  dictionaryManager.dxf(file);
+
+  const dxfString = `0
+DICTIONARY
+5
+27
+100
+AcDbDictionary
+281
+1
+3
+ACAD_GROUP
+350
+26
+0
+DICTIONARY
+5
+26
+100
+AcDbDictionary
+281
+1
+`;
+
+  expect(file.contents).toEqual(dxfString);
+});

package/test/properties/dimType.test.js

@@ -0,0 +1,62 @@
+import { DimType } from '../../core/properties/dimType';
+
+test('DimType - constructor sets default and custom dimType', () => {
+  expect(new DimType().dimType).toBe(0);
+  expect(new DimType(3).dimType).toBe(3);
+});
+
+test('DimType - isValidDimensionType returns true for valid, false for invalid', () => {
+  expect(DimType.isValidDimensionType(0)).toBe(true);
+  expect(DimType.isValidDimensionType(6)).toBe(true);
+  expect(DimType.isValidDimensionType(32)).toBe(true); // block ref
+  expect(DimType.isValidDimensionType(64)).toBe(true);
+  expect(DimType.isValidDimensionType(70)).toBe(true);
+  expect(DimType.isValidDimensionType(99)).toBe(true); // 32 + 64 + 3
+  expect(DimType.isValidDimensionType(128)).toBe(true);
+
+  expect(DimType.isValidDimensionType(-1)).toBe(false);
+  expect(DimType.isValidDimensionType(9)).toBe(false);
+  expect(DimType.isValidDimensionType(999)).toBe(false);
+});
+
+test('DimType - getBaseType returns correct base type', () => {
+  expect(DimType.getBaseType(0)).toBe(0);
+  expect(DimType.getBaseType(32)).toBe(0);
+  expect(DimType.getBaseType(34)).toBe(2);
+  expect(DimType.getBaseType(36)).toBe(4);
+  expect(DimType.getBaseType(39)).toBe(7); // 7 is invalid but still returned as base type
+  expect(DimType.getBaseType(70)).toBe(6);
+  expect(DimType.getBaseType(64)).toBe(0);
+  expect(DimType.getBaseType(65)).toBe(1);
+  expect(DimType.getBaseType(128)).toBe(0);
+});
+
+test('DimType - getDimType returns correct dimType for various values', () => {
+  // getDimType should return the input value as-is for valid values
+  expect(new DimType(0).getDimType()).toBe(0);
+  expect(new DimType(3).getDimType()).toBe(3);
+  expect(new DimType(32).getDimType()).toBe(32);
+  expect(new DimType(70).getDimType()).toBe(70);
+  expect(new DimType(128).getDimType()).toBe(128);
+  expect(new DimType(99).getDimType()).toBe(99);
+
+  // For invalid or undefined input, should return default (likely 0)
+  expect(new DimType(undefined).getDimType()).toBe(0);
+  expect(new DimType(null).getDimType()).toBe(0);
+  expect(new DimType(NaN).getDimType()).toBe(0);
+});
+
+test('DimType - hasBlockReference detects block reference bit', () => {
+  expect(new DimType(32).hasBlockReference()).toBe(true);
+  expect(new DimType(38).hasBlockReference()).toBe(true); // 6 + 32
+  expect(new DimType(2).hasBlockReference()).toBe(false);
+});
+
+test('DimType - hasUserPositionedText detects user positioned text bit', () => {
+  expect(new DimType(128).hasUserPositionedText()).toBe(true);
+  expect(new DimType(129).hasUserPositionedText()).toBe(true);
+  expect(new DimType(134).hasUserPositionedText()).toBe(true);
+  expect(new DimType(2).hasUserPositionedText()).toBe(false);
+});
+
+

package/test/properties/flags.test.js

@@ -0,0 +1,164 @@
+
+import { Flags } from '../../core/properties/flags';
+
+test('Test flags set/get FlagValue', () => {
+  const flags = new Flags();
+  flags.setFlagValue(10);
+  expect(flags.getFlagValue()).toBe(10);
+  flags.setFlagValue(5);
+  expect(flags.getFlagValue()).toBe(5);
+});
+
+test('Test flags.hasFlag', () => {
+  const flags = new Flags();
+  expect(flags.hasFlag(1)).toBe(false);
+
+  // set flag value to 17
+  flags.addValue(17);
+  /* bit masked value
+  | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
+    0     0    0    1    0   0   0   1
+  */
+  // 1 should exist
+  expect(flags.hasFlag(1)).toBe(true);
+  // 2 shouldn't exist
+  expect(flags.hasFlag(2)).toBe(false);
+  // 3 shouldn't exist
+  expect(flags.hasFlag(3)).toBe(false);
+  // 4 shouldn't exist
+  expect(flags.hasFlag(4)).toBe(false);
+  // 5 shouldn't exist
+  expect(flags.hasFlag(5)).toBe(false);
+  // 6 shouldn't exist
+  expect(flags.hasFlag(6)).toBe(false);
+  // 8 shouldn't exist
+  expect(flags.hasFlag(8)).toBe(false);
+  // 16 shouldn't exist
+  expect(flags.hasFlag(16)).toBe(true);
+  // 32 shouldn't exist
+  expect(flags.hasFlag(32)).toBe(false);
+  // 64 shouldn't exist
+  expect(flags.hasFlag(64)).toBe(false);
+  // 128 shouldn't exist
+  expect(flags.hasFlag(128)).toBe(false);
+
+  // add flag value  3; total 19
+  flags.addValue(3);
+  /* bit masked value
+    | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
+      0     0    0    1    0   0   1   1
+  */
+  // 1 should exist
+  expect(flags.hasFlag(1)).toBe(true);
+  // 2 shouldn't exist
+  expect(flags.hasFlag(2)).toBe(true);
+  // 3 shouldn't exist
+  expect(flags.hasFlag(3)).toBe(true);
+  // 4 shouldn't exist
+  expect(flags.hasFlag(4)).toBe(false);
+  // 5 shouldn't exist
+  expect(flags.hasFlag(5)).toBe(false);
+  // 6 shouldn't exist
+  expect(flags.hasFlag(6)).toBe(false);
+  // 8 shouldn't exist
+  expect(flags.hasFlag(8)).toBe(false);
+  // 16 shouldn't exist
+  expect(flags.hasFlag(16)).toBe(true);
+  // 32 shouldn't exist
+  expect(flags.hasFlag(32)).toBe(false);
+  // 64 shouldn't exist
+  expect(flags.hasFlag(64)).toBe(false);
+  // 128 shouldn't exist
+  expect(flags.hasFlag(128)).toBe(false);
+
+  // try and add 3 again
+  // add flag value 3 again; total still 19
+  flags.addValue(3);
+  /* bit masked value
+      | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
+        0     0    0    1    0   0   1   1
+  */
+  // 1 should exist
+  expect(flags.hasFlag(1)).toBe(true);
+  // 2 shouldn't exist
+  expect(flags.hasFlag(2)).toBe(true);
+  // 3 shouldn't exist
+  expect(flags.hasFlag(3)).toBe(true);
+  // 4 shouldn't exist
+  expect(flags.hasFlag(4)).toBe(false);
+  // 5 shouldn't exist
+  expect(flags.hasFlag(5)).toBe(false);
+  // 6 shouldn't exist
+  expect(flags.hasFlag(6)).toBe(false);
+  // 8 shouldn't exist
+  expect(flags.hasFlag(8)).toBe(false);
+  // 16 shouldn't exist
+  expect(flags.hasFlag(16)).toBe(true);
+  // 32 shouldn't exist
+  expect(flags.hasFlag(32)).toBe(false);
+  // 64 shouldn't exist
+  expect(flags.hasFlag(64)).toBe(false);
+  // 128 shouldn't exist
+  expect(flags.hasFlag(128)).toBe(false);
+});
+
+test('Test flags.addValue', () => {
+  const flags = new Flags();
+  // 2 shouldn't exist
+  expect(flags.hasFlag(2)).toBe(false);
+  // add flag value 2
+  flags.addValue(2);
+  // 2 should exist
+  expect(flags.hasFlag(2)).toBe(true);
+  // add flag value 3
+  flags.addValue(3);
+  // 3 should exist
+  expect(flags.hasFlag(1)).toBe(true);
+  expect(flags.hasFlag(2)).toBe(true);
+  expect(flags.hasFlag(3)).toBe(true);
+  expect(flags.hasFlag(4)).toBe(false);
+  expect(flags.getFlagValue()).toBe(3);
+
+  // add flag value 3 again
+  flags.addValue(3);
+  // 3 should still exist
+  expect(flags.hasFlag(3)).toBe(true);
+  // flags value should still be 3
+  expect(flags.getFlagValue()).toBe(3);
+
+  // set flag value to 0
+  flags.setFlagValue(2);
+  // add flag value 2
+  flags.addValue(2);
+  // 2 should exist
+  expect(flags.hasFlag(2)).toBe(true);
+  // flag value should be 2
+  expect(flags.getFlagValue()).toBe(2);
+
+  // repeat add to check for unwanted behaviour
+  // add flag value 2 a second time
+  flags.addValue(2);
+  // 2 should exist
+  expect(flags.hasFlag(2)).toBe(true);
+  // flag value should still be 2
+  expect(flags.getFlagValue()).toBe(2);
+});
+
+test('Test flags.removeValue', () => {
+  const flags = new Flags();
+  // 2 shouldn't exist
+  expect(flags.hasFlag(2)).toBe(false);
+  // add flag value 2
+  flags.addValue(2);
+  // 2 should exist
+  expect(flags.hasFlag(2)).toBe(true);
+  // remove flag value 2
+  flags.removeValue(2);
+  // 2 shouldn't exist again
+  expect(flags.hasFlag(2)).toBe(false);
+
+  // repeat remove to check for unwanted behaviour
+  flags.removeValue(2);
+  // 2 shouldn't exist again
+  expect(flags.hasFlag(2)).toBe(false);
+});

package/test/properties/property.test.js

@@ -0,0 +1,13 @@
+import { Property } from '../../core/properties/property';
+import { Flags } from '../../core/properties/flags';
+
+test('Test property.loadValue', () => {
+  expect(Property.loadValue([], 3)).toBe(3);
+  expect(Property.loadValue([1, 2], 3)).toBe(1);
+  expect(Property.loadValue([undefined, 2], 3)).toBe(2);
+  expect(Property.loadValue([undefined], 3)).toBe(3);
+
+  const flags = new Flags();
+  flags.setFlagValue(4);
+  expect(Property.loadValue([flags], 3)).toBe(4);
+});

package/test/properties/propertyManager.test.js

@@ -1,7 +1,7 @@
 
-import {Core} from '../../core/core/core.js';
-import {DesignCore} from '../../core/designCore.js';
-import {Point} from '../../core/entities/point.js';
+import { Core } from '../../core/core/core.js';
+import { DesignCore } from '../../core/designCore.js';
+import { Point } from '../../core/entities/point.js';
 
 const core = new Core();
 const propertiesManager = core.propertyManager;
@@ -11,14 +11,14 @@ const point2 = new Point(0, 100);
 
 const data = {
   points: [point1, point2],
-  colour: '#FFFFFF',
+  colour: { r: 100, g: 100, b: 100 },
 };
 
 DesignCore.Scene.addItem('Line', data);
 DesignCore.Scene.addItem('Circle', data);
 DesignCore.Scene.addItem('Text', data);
 // Add Arc with a different Colour
-DesignCore.Scene.addItem('Arc', {points: [point1, point2], colour: '#000000'});
+DesignCore.Scene.addItem('Arc', { points: [point1, point2], colour: { r: 130, g: 130, b: 130 } });
 
 test('Test propertyManager.getItemTypes', () => {
   // Add an item to the selectionSet
@@ -47,13 +47,13 @@ test('Test propertyManager.setItemProperties', () => {
   const string = 'test text';
   propertiesManager.setItemProperties('string', string);
 
-  let text = DesignCore.Scene.items[2];
+  let text = DesignCore.Scene.entities.get(2);
   expect(text.type).toBe('Text');
   expect(text.string).toBe(string);
 
   // try and set a non-existent property
   propertiesManager.setItemProperties('faux-prop', string);
-  text = DesignCore.Scene.items[2];
+  text = DesignCore.Scene.entities.get(2);
   expect(text['faux-prop']).toBeUndefined();
 
   // clear the selection set
@@ -61,10 +61,10 @@ test('Test propertyManager.setItemProperties', () => {
   // Select the circle element
   DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(1);
   // get the current radius
-  const radius = DesignCore.Scene.items[1].radius;
+  const radius = DesignCore.Scene.entities.get(1).radius;
   // try and set an incorrect value
   propertiesManager.setItemProperties('radius', string);
-  const circle = DesignCore.Scene.items[1];
+  const circle = DesignCore.Scene.entities.get(1);
   expect(circle.radius).toBe(radius);
 });
 
@@ -102,8 +102,7 @@ test('Test propertyManager.getItemPropertyValue', () => {
   DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(0);
   // get the line colour
   propertyValues = propertiesManager.getItemPropertyValue('Line', 'colour');
-  expect(propertyValues.length).toBeGreaterThan(0);
-  expect(propertyValues).toBe(data.colour);
+  expect(propertyValues).toEqual(data.colour);
 
   // get circle props with a line selected - should be undefined
   propertyValues = propertiesManager.getItemPropertyValue('Circle', 'colour');

package/test/tables/appId.test.js

@@ -0,0 +1,46 @@
+import { DXFFile } from '../../core/lib/dxf/dxfFile.js';
+import { AppID } from '../../core/tables/appId.js';
+
+test('Test AppID constructor defaults', () => {
+  const appId = new AppID();
+  expect(appId.name).toBe('');
+  expect(appId.flags).toBe(0);
+});
+
+test('Test AppID constructor with name property', () => {
+  const appId = new AppID({ name: 'ACAD' });
+  expect(appId.name).toBe('ACAD');
+});
+
+test('Test AppID constructor with DXF group codes', () => {
+  const appId = new AppID({ 2: 'ACAD', 70: 0 });
+  expect(appId.name).toBe('ACAD');
+  expect(appId.flags).toBe(0);
+});
+
+test('Test AppID constructor with flags', () => {
+  const appId = new AppID({ name: 'TestApp', flags: 1 });
+  expect(appId.flags).toBe(1);
+});
+
+test('Test AppID.dxf', () => {
+  const appId = new AppID({ handle: 'A', name: 'ACAD' });
+  const file = new DXFFile();
+  appId.dxf(file);
+
+  const dxfString = `0
+APPID
+5
+A
+100
+AcDbSymbolTableRecord
+100
+AcDbRegAppTableRecord
+2
+ACAD
+70
+0
+`;
+
+  expect(file.contents).toEqual(dxfString);
+});

package/test/tables/appIdManager.test.js

@@ -0,0 +1,72 @@
+import { Core } from '../../core/core/core.js';
+import { DXFFile } from '../../core/lib/dxf/dxfFile.js';
+
+const core = new Core();
+const appIdManager = core.appIdManager;
+
+test('Test AppIDManager.getItems', () => {
+  const items = appIdManager.getItems();
+  expect(items).toHaveLength(1);
+  expect(items[0]).toHaveProperty('name', 'ACAD');
+});
+
+test('Test AppIDManager.itemCount', () => {
+  expect(appIdManager.itemCount()).toBe(1);
+});
+
+test('Test AppIDManager.addItem', () => {
+  const count = appIdManager.itemCount();
+  appIdManager.addItem({ name: 'TestApp' });
+  expect(appIdManager.itemCount()).toBe(count + 1);
+});
+
+test('Test AppIDManager.deleteItem indelible', () => {
+  const count = appIdManager.itemCount();
+  const index = appIdManager.getItemIndex('ACAD');
+  appIdManager.deleteItem(index);
+  // ACAD is indelible and cannot be deleted
+  expect(appIdManager.itemCount()).toBe(count);
+});
+
+test('Test AppIDManager.deleteItem', () => {
+  const count = appIdManager.itemCount();
+  const index = appIdManager.getItemIndex('TestApp');
+  appIdManager.deleteItem(index);
+  expect(appIdManager.itemCount()).toBe(count - 1);
+});
+
+test('Test AppIDManager.itemExists', () => {
+  expect(appIdManager.itemExists('ACAD')).toBe(true);
+  expect(appIdManager.itemExists('NonExistent')).toBe(false);
+});
+
+test('Test AppIDManager.dxf', () => {
+  const file = new DXFFile();
+  appIdManager.dxf(file);
+
+  const dxfString = `0
+TABLE
+2
+APPID
+5
+23
+100
+AcDbSymbolTable
+0
+APPID
+5
+24
+100
+AcDbSymbolTableRecord
+100
+AcDbRegAppTableRecord
+2
+ACAD
+70
+0
+0
+ENDTAB
+`;
+
+  expect(file.contents).toEqual(dxfString);
+});

package/test/tables/block.test.js

@@ -0,0 +1,157 @@
+import { Core } from '../../core/core/core.js';
+import { Block } from '../../core/tables/block.js';
+import { Line } from '../../core/entities/line.js';
+import { Point } from '../../core/entities/point.js';
+
+import { File } from '../test-helpers/test-helpers.js';
+import { Flags } from '../../core/properties/flags.js';
+
+new Core();
+
+test('Test Block', () => {
+  const line = new Line({ points: [new Point(101, 102), new Point(201, 202)] });
+  const flags = new Flags();
+  flags.addValue(1);
+  const block = new Block({ items: [line], flags: flags });
+
+  expect(block.items.length).toBe(1);
+  expect(block.flags.getFlagValue()).toBe(1);
+});
+
+test('Test Block.clearItems', () => {
+  const line = new Line({ points: [new Point(101, 102), new Point(201, 202)] });
+  const block = new Block({ items: [line] });
+  expect(block.items.length).toBe(1);
+
+  block.clearItems();
+  expect(block.items.length).toBe(0);
+});
+
+test('Test Block.snaps', () => {
+  const block = new Block();
+  expect(block.snaps()).toBeInstanceOf(Array);
+  expect(block.snaps()).toHaveLength(0);
+
+  const line = new Line({ points: [new Point(101, 102), new Point(201, 202)] });
+  block.addItem(line);
+  expect(block.snaps()).toBeInstanceOf(Array);
+  expect(block.snaps()).not.toHaveLength(0);
+});
+
+test('Test Block', () => {
+  const line = new Line({ points: [new Point(101, 102), new Point(201, 202)] });
+  const flags = new Flags();
+  flags.addValue(1);
+  const block = new Block({ items: [line], flags: flags });
+
+  expect(block.items.length).toBe(1);
+  expect(block.flags.getFlagValue()).toBe(1);
+});
+
+test('Test Block.closestPoint', () => {
+  const block = new Block();
+  const point = new Point();
+
+  expect(block.closestPoint(point)).toBeInstanceOf(Array);
+  expect(block.closestPoint(point)).toHaveLength(2);
+  expect(block.closestPoint(point)[0]).toBeInstanceOf(Point);
+  expect(block.closestPoint(point)[0].x).toBe(0);
+  expect(block.closestPoint(point)[0].y).toBe(0);
+  expect(block.closestPoint(point)[1]).toBe(Infinity);
+
+  const line = new Line({ points: [new Point(101, 102), new Point(201, 202)] });
+  block.addItem(line);
+  expect(block.closestPoint(point)).toBeInstanceOf(Array);
+  expect(block.closestPoint(point)).toHaveLength(2);
+  expect(block.closestPoint(point)[0]).toBeInstanceOf(Point);
+  expect(block.closestPoint(point)[0].x).not.toBe(0);
+  expect(block.closestPoint(point)[0].y).not.toBe(0);
+  expect(block.closestPoint(point)[1]).not.toBe(Infinity);
+});
+
+test('Test Block.dxf', () => {
+  const block = new Block({ handle: '1', endblkHandle: '1' });
+  const line = new Line({ handle: '1', points: [new Point(101, 102), new Point(201, 202)] });
+  block.addItem(line);
+
+  const file = new File();
+  block.dxf(file);
+  // console.log(file.contents);
+
+  const dxfString = `0
+BLOCK
+5
+1
+100
+AcDbEntity
+8
+0
+100
+AcDbBlockBegin
+2
+
+70
+0
+10
+0
+20
+0
+30
+0
+3
+
+1
+
+0
+LINE
+5
+1
+100
+AcDbEntity
+100
+AcDbLine
+8
+0
+6
+ByLayer
+10
+101
+20
+102
+30
+0.0
+11
+201
+21
+202
+31
+0.0
+39
+2
+0
+ENDBLK
+5
+1
+100
+AcDbEntity
+100
+AcDbBlockEnd
+`;
+
+  expect(file.contents).toEqual(dxfString);
+});
+
+test('Test Block.touched', () => {
+  const block = new Block();
+
+  // Selection {min, max}
+  const selectionExtremesTrue = { min: new Point(110, 90), max: new Point(190, 210) };
+  const selectionExtremesFalse = { min: new Point(250, 250), max: new Point(400, 400) };
+
+  expect(block.touched(selectionExtremesTrue)).toBe(false);
+
+  const line = new Line({ points: [new Point(101, 102), new Point(201, 202)] });
+  block.addItem(line);
+  expect(block.touched(selectionExtremesTrue)).toBe(true);
+  expect(block.touched(selectionExtremesFalse)).toBe(false);
+});