@design-core/core 0.0.1 → 0.0.3

package/test/tables/blockManager.test.js

@@ -0,0 +1,52 @@
+import { BlockManager } from '../../core/tables/blockManager.js';
+import { Core } from '../../core/core/core.js';
+
+// initialise core
+new Core();
+
+const blockManager = new BlockManager();
+
+// mock block data
+blockManager.items = [{ name: 'blockOne' }, { name: 'blockTwo' }];
+
+test('Test blockManager.getItems', () => {
+  const blocks = blockManager.getItems();
+  expect(blocks).toHaveLength(2);
+
+  expect(blocks[0]).toHaveProperty('name', 'blockOne');
+  expect(blocks[1]).toHaveProperty('name', 'blockTwo');
+});
+
+test('Test blockManager.itemCount', () => {
+  const count = blockManager.itemCount();
+  expect(count).toBe(2);
+});
+
+test('Test blockManager.addItem', () => {
+  const count = blockManager.itemCount();
+  blockManager.addItem({ name: 'blockThree' });
+  expect(blockManager.itemCount()).toBe(count + 1);
+});
+
+test('Test blockManager.deleteblock', () => {
+  const count = blockManager.itemCount();
+
+  // get block index
+  const blockIndex = blockManager.getItemIndex('blockThree');
+  blockManager.deleteItem(blockIndex);
+  expect(blockManager.itemCount()).toBe(count - 1);
+});
+
+test('Test blockManager.getItemIndex', () => {
+  expect(blockManager.getItemIndex('blockOne')).toBe(0);
+  expect(blockManager.getItemIndex('blockTwo')).toBe(1);
+});
+
+test('Test blockManager.getItemByName', () => {
+  // add a new block to blocks
+  blockManager.items.push({ 'name': 'test' });
+  const block = blockManager.getItemByName('test');
+  expect(block.name).toBe('test');
+  // get a block that doesn't exist
+  expect(blockManager.getItemByName('Non-Existent')).toBeUndefined();
+});

package/test/tables/blockRecord.test.js

@@ -0,0 +1,39 @@
+import { DXFFile } from '../../core/lib/dxf/dxfFile.js';
+import { BlockRecord } from '../../core/tables/blockRecord.js';
+
+test('Test BlockRecord constructor defaults', () => {
+  const record = new BlockRecord();
+  expect(record.name).toBe('');
+});
+
+test('Test BlockRecord constructor with name property', () => {
+  const record = new BlockRecord({ name: '*Model_Space' });
+  expect(record.name).toBe('*Model_Space');
+});
+
+test('Test BlockRecord constructor with DXF group code', () => {
+  const record = new BlockRecord({ 2: '*Paper_Space' });
+  expect(record.name).toBe('*Paper_Space');
+});
+
+test('Test BlockRecord.dxf', () => {
+  const record = new BlockRecord({ name: '*Model_Space', handle: 'C' });
+  const file = new DXFFile();
+  record.dxf(file);
+
+  const dxfString = `0
+BLOCK_RECORD
+5
+C
+100
+AcDbSymbolTableRecord
+100
+AcDbBlockTableRecord
+2
+*Model_Space
+340
+0
+`;
+
+  expect(file.contents).toEqual(dxfString);
+});

package/test/tables/blockRecordManager.test.js

@@ -0,0 +1,60 @@
+import { Core } from '../../core/core/core.js';
+import { DXFFile } from '../../core/lib/dxf/dxfFile.js';
+
+const core = new Core();
+const blockRecordManager = core.blockRecordManager;
+
+test('Test BlockRecordManager.dxf', () => {
+  const file = new DXFFile();
+  blockRecordManager.dxf(file);
+
+  const dxfString = `0
+TABLE
+2
+BLOCK_RECORD
+5
+25
+100
+AcDbSymbolTable
+70
+2
+0
+BLOCK_RECORD
+5
+C
+100
+AcDbSymbolTableRecord
+100
+AcDbBlockTableRecord
+2
+*Model_Space
+340
+0
+0
+BLOCK_RECORD
+5
+F
+100
+AcDbSymbolTableRecord
+100
+AcDbBlockTableRecord
+2
+*Paper_Space
+340
+0
+0
+ENDTAB
+`;
+
+  expect(file.contents).toEqual(dxfString);
+});
+
+test('Test BlockRecordManager.dxf block count', () => {
+  const file = new DXFFile();
+  blockRecordManager.dxf(file);
+
+  // default blocks: *Model_Space and *Paper_Space
+  const lines = file.contents.split('\n');
+  const seventyIndex = lines.indexOf('70');
+  expect(lines[seventyIndex + 1]).toBe('2');
+});

package/test/tables/dimstyle.test.js

@@ -0,0 +1,72 @@
+import { DimStyle } from '../../core/tables/dimStyle';
+
+describe('DimStyle', () => {
+  let style;
+
+  beforeEach(() => {
+    const data = {};
+    style = new DimStyle(data);
+  });
+
+  test('getValue returns correct default values', () => {
+    expect(style.getValue('DIMSE1')).toBe(0); // Suppress first extension line
+    expect(style.getValue('DIMASZ')).toBe(0.18); // Arrow size
+  });
+
+  test('vertical flag getter and setter', () => {
+    expect(style.vertical).toBe(false);
+    expect(style.standardFlags.getFlagValue()).toBe(0);
+
+    style.vertical = true;
+    expect(style.vertical).toBe(true);
+    expect(style.standardFlags.hasFlag(4)).toBe(true);
+    expect(style.standardFlags.getFlagValue()).toBe(4);
+
+    style.vertical = false;
+    expect(style.vertical).toBe(false);
+    expect(style.standardFlags.hasFlag(4)).toBe(false);
+    expect(style.standardFlags.getFlagValue()).toBe(0);
+  });
+
+  test('DimStyle text-related properties and edge cases', () => {
+    // Test default text style properties
+    expect(style.getValue('DIMTXSTY')).toBeDefined(); // Text style name
+    expect(typeof style.getValue('DIMTXT')).toBe('number'); // Text height
+    expect(typeof style.getValue('DIMGAP')).toBe('number'); // Gap between text and dimension line
+    expect(typeof style.getValue('DIMTAD')).toBe('number'); // Text vertical position
+    expect(typeof style.getValue('DIMJUST')).toBe('number'); // Text justification
+    expect(typeof style.getValue('DIMTIH')).toBe('number'); // Text inside horizontal
+    expect(typeof style.getValue('DIMTOH')).toBe('number'); // Text outside horizontal
+
+    // Set and get a custom value
+    style.setValue('DIMTXT', 3.14);
+    expect(style.getValue('DIMTXT')).toBe(3.14);
+
+    // Unknown property returns undefined or default
+    expect(style.getValue('DOES_NOT_EXIST')).toBeUndefined();
+
+    // Test setting and getting string property
+    style.setValue('DIMTXSTY', 'MyTextStyle');
+    expect(style.getValue('DIMTXSTY')).toBe('MyTextStyle');
+
+    // Test boolean property
+    style.setValue('DIMTIX', true);
+    expect(style.getValue('DIMTIX')).toBe(1);
+    style.setValue('DIMTIX', false);
+    expect(style.getValue('DIMTIX')).toBe(0);
+
+    // Test numeric property edge case
+    style.setValue('DIMTAD', 99);
+    expect(style.getValue('DIMTAD')).toBe(99);
+  });
+
+  test('setValue sets property correctly', () => {
+    style.setValue('DIMTXT', 42);
+    expect(style.DIMTXT).toBe(42);
+    expect(style.getValue('DIMTXT')).toBe(42);
+    style.setValue('customProp', 'hello');
+    expect(style.customProp).toBeUndefined();
+  });
+});
+
+

package/test/tables/endblk.test.js

@@ -0,0 +1,30 @@
+import { EndBlock } from '../../core/tables/endblk.js';
+import { File } from '../test-helpers/test-helpers.js';
+
+test('Test EndBlock constructor defaults', () => {
+  const endblk = new EndBlock();
+  expect(endblk.layer).toBe('0');
+});
+
+test('Test EndBlock constructor with layer', () => {
+  const endblk = new EndBlock({ 8: 'TestLayer' });
+  expect(endblk.layer).toBe('TestLayer');
+});
+
+test('Test EndBlock.dxf', () => {
+  const endblk = new EndBlock({ handle: '1' });
+  const file = new File();
+  endblk.dxf(file);
+
+  const dxfString = `0
+ENDBLK
+5
+1
+100
+AcDbEntity
+100
+AcDbBlockEnd
+`;
+
+  expect(file.contents).toEqual(dxfString);
+});

package/test/tables/layer.test.js

@@ -0,0 +1,95 @@
+import { Layer } from '../../core/tables/layer';
+
+import { File } from '../test-helpers/test-helpers.js';
+
+test('Test Layer.frozen', () => {
+  const layer = new Layer();
+  expect(layer.frozen).toBe(false);
+  expect(layer.flags.getFlagValue()).toBe(0);
+
+  layer.frozen = true;
+  expect(layer.frozen).toBe(true);
+  expect(layer.flags.hasFlag(1)).toBe(true);
+  expect(layer.flags.getFlagValue()).toBe(1);
+
+  layer.frozen = false;
+  expect(layer.frozen).toBe(false);
+  expect(layer.flags.hasFlag(1)).toBe(false);
+  expect(layer.flags.getFlagValue()).toBe(0);
+});
+
+test('Test Layer.locked', () => {
+  const layer = new Layer();
+  expect(layer.locked).toBe(false);
+  expect(layer.flags.getFlagValue()).toBe(0);
+
+  layer.locked = true;
+  expect(layer.locked).toBe(true);
+  expect(layer.flags.hasFlag(4)).toBe(true);
+  expect(layer.flags.getFlagValue()).toBe(4);
+
+  layer.locked = false;
+  expect(layer.locked).toBe(false);
+  expect(layer.flags.hasFlag(4)).toBe(false);
+  expect(layer.flags.getFlagValue()).toBe(0);
+});
+
+test('Test Layer.isVisible', () => {
+  const layer = new Layer();
+  expect(layer.isVisible).toBe(true);
+
+  layer.frozen = true;
+  expect(layer.isVisible).toBe(false);
+
+  layer.frozen = false;
+  expect(layer.isVisible).toBe(true);
+});
+
+test('Test Layer.isSelectable', () => {
+  const layer = new Layer();
+  expect(layer.isSelectable).toBe(true);
+
+  layer.frozen = true;
+  expect(layer.isSelectable).toBe(false);
+
+  layer.frozen = false;
+  expect(layer.isSelectable).toBe(true);
+
+  layer.locked = true;
+  expect(layer.isSelectable).toBe(false);
+
+  layer.locked = false;
+  expect(layer.isSelectable).toBe(true);
+});
+
+test('Test Layer.dxf', () => {
+  const layer = new Layer({ handle: 'A', name: 'TestLayer' });
+  const file = new File();
+  layer.dxf(file);
+  // console.log(file.contents);
+
+  const dxfString = `0
+LAYER
+5
+A
+100
+AcDbSymbolTableRecord
+100
+AcDbLayerTableRecord
+2
+TestLayer
+70
+0
+62
+7
+6
+CONTINUOUS
+290
+1
+390
+0
+`;
+
+  expect(file.contents).toEqual(dxfString);
+});
+

package/test/tables/layerManager.test.js

@@ -0,0 +1,172 @@
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
+
+const core = new Core();
+const layerManager = core.layerManager;
+
+test('Test LayerManager.getItems', () => {
+  const layers = layerManager.getItems();
+  expect(layers).toHaveLength(2);
+
+  expect(layers[0]).toHaveProperty('name', '0');
+  expect(layers[1]).toHaveProperty('name', 'DEFPOINTS');
+});
+
+test('Test LayerManager.itemCount', () => {
+  const count = layerManager.itemCount();
+  expect(count).toBe(2);
+});
+
+test('Test LayerManager.newItem', () => {
+  const count = layerManager.itemCount();
+  layerManager.newItem();
+  expect(layerManager.itemCount()).toBe(count + 1);
+});
+
+test('Test LayerManager.getUniqueName', () => {
+  // existing defpoints layer
+  let name = layerManager.getUniqueName('DEFPOINTS');
+  expect(name).toBe('DEFPOINTS_1');
+  // existing NEW_LAYER layer
+  name = layerManager.getUniqueName('NEW_LAYER');
+  expect(name).toBe('NEW_LAYER_1');
+  // unique layer
+  name = layerManager.getUniqueName('UNIQUE_LAYER');
+  expect(name).toBe('UNIQUE_LAYER');
+});
+
+test('Test LayerManager.addItem', () => {
+  const count = layerManager.itemCount();
+  layerManager.addItem({ 'name': 'test', 'colour': '#00BFFF' });
+  expect(layerManager.itemCount()).toBe(count + 1);
+});
+
+test('Test LayerManager.deleteStyle', () => {
+  const count = layerManager.itemCount();
+  // defpoints can't be deleted
+  layerManager.deleteStyle('DEFPOINTS');
+  expect(layerManager.itemCount()).toBe(count);
+
+  // clayer can't be deleted
+  layerManager.deleteStyle(layerManager.getCstyle());
+  expect(layerManager.itemCount()).toBe(count);
+
+  // test should be deleted
+  layerManager.deleteStyle(layerManager.getItemIndex('test'));
+  expect(layerManager.itemCount()).toBe(count - 1);
+});
+
+test('Test LayerManager.deleteStyle', () => {
+  const count = layerManager.itemCount();
+  layerManager.deleteStyle(2);
+  expect(layerManager.itemCount()).toBe(count - 1);
+});
+
+test('Test LayerManager.getCstyle', () => {
+  const clayer = layerManager.getCstyle();
+  expect(clayer).toBe('0');
+});
+
+test('Test LayerManager.setCstyle', () => {
+  const layer = layerManager.getItems().at(-1).name;
+  layerManager.setCstyle(layer);
+  expect(layerManager.getCstyle()).toBe(layer);
+});
+
+test('Test LayerManager.itemExists', () => {
+  expect(layerManager.itemExists('DEFPOINTS')).toBe(true);
+  expect(layerManager.itemExists('OBSCURE_LAYER_NAME')).toBe(false);
+});
+
+test('Test LayerManager.checkStyles', () => {
+  layerManager.layers = [];
+
+  const newItemName = 'checkStyles';
+  const startPoint = new Point();
+  const endPoint = new Point(10, 10);
+
+  const data = {
+    points: [startPoint, endPoint],
+    colour: '#FFFFFF',
+    layer: newItemName,
+  };
+
+  core.scene.addItem('Line', data);
+
+  layerManager.checkStyles();
+  const layers = layerManager.getItems();
+  expect(layers).toHaveLength(3);
+
+  expect(layers[0]).toHaveProperty('name', '0');
+  expect(layers[1]).toHaveProperty('name', 'DEFPOINTS');
+  expect(layers[2]).toHaveProperty('name', newItemName);
+});
+
+test('Test LayerManager.checkItems', () => {
+  layerManager.layers = [];
+
+  const newItemName = 'checkStyles';
+  const startPoint = new Point();
+  const endPoint = new Point(10, 10);
+
+  const data = {
+    points: [startPoint, endPoint],
+    colour: '#FFFFFF',
+    layer: newItemName,
+  };
+
+  core.scene.addItem('Line', data);
+
+  layerManager.checkItems();
+  const layers = layerManager.getItems();
+  expect(layers).toHaveLength(3);
+
+  expect(layers[0]).toHaveProperty('name', '0');
+  expect(layers[1]).toHaveProperty('name', 'DEFPOINTS');
+  expect(layers[2]).toHaveProperty('name', newItemName);
+});
+
+test('Test LayerManager.addStandardItems', () => {
+  layerManager.clearItems();
+
+  layerManager.addStandardItems();
+
+  const layers = layerManager.getItems();
+  expect(layers).toHaveLength(2);
+
+  expect(layers[0]).toHaveProperty('name', '0');
+  expect(layers[1]).toHaveProperty('name', 'DEFPOINTS');
+});
+
+test('Test LayerManager.getItemIndex', () => {
+  layerManager.addItem({ 'name': 'addItem', 'colour': '#00BFFF' });
+  // get index for test layer - should be the last layer
+  expect(layerManager.getItemIndex('addItem')).toBe(layerManager.itemCount() - 1);
+  // get index for a layer that doesn't exist
+  expect(layerManager.getItemIndex('no-exist')).toBe(-1);
+});
+
+test('Test LayerManager.getItemByName', () => {
+  layerManager.addItem({ 'name': 'test' });
+  const layer = layerManager.getItemByName('test');
+  expect(layer.name).toBe('test');
+  // get a layer that doesn't exist
+  expect(layerManager.getItemByName('Non-Existent')).toBeUndefined();
+});
+
+test('Test LayerManager.getItemByIndex', () => {
+  const testLayer = layerManager.getItemByName('test');
+  const layer = layerManager.getItemByIndex(layerManager.getItemIndex('test'));
+  expect(testLayer === layer).toBe(true);
+  // get a layer that doesn't exist
+  expect(layerManager.getItemByIndex(1000)).toBeUndefined();
+});
+
+test('Test LayerManager.renameStyle', () => {
+  const index = layerManager.getItemIndex('test');
+  const newItemname = 'RENAMED_TEST';
+  layerManager.renameStyle(index, newItemname);
+
+  expect(layerManager.getItemIndex(newItemname)).toBe(index);
+  expect(layerManager.getItemIndex('test')).toBe(-1);
+});

package/test/{styles → tables}/ltype.test.js

@@ -1,11 +1,11 @@
-import {DXFFile} from '../../core/lib/dxf/dxfFile.js';
-import {LType} from '../../core/styles/ltype.js';
+import { DXFFile } from '../../core/lib/dxf/dxfFile.js';
+import { LType } from '../../core/tables/ltype.js';
 
 const file = new DXFFile();
 const R12File = new DXFFile('R12');
 
-const continuousLType = new LType({'name': 'CONTINUOUS', 'description': 'Solid Line ________________________________________'});
-const dashedLType = new LType({'name': 'DASHED', 'pattern': [12.7, -6.35], 'description': 'Dashed __ __ __ __ __ __ __ __ __ __ __ __ __ _'});
+const continuousLType = new LType({ 'handle': 'A', 'name': 'CONTINUOUS', 'description': 'Solid Line ________________________________________' });
+const dashedLType = new LType({ 'handle': 'A', 'name': 'DASHED', 'pattern': [12.7, -6.35], 'description': 'Dashed __ __ __ __ __ __ __ __ __ __ __ __ __ _' });
 
 
 const continuousDxf = `0
@@ -119,9 +119,9 @@ test('Test LType.dxf', () => {
 });
 
 test('Test LType.getPattern', () => {
-  const patternOneLType = new LType({'name': 'Pattern One', 'pattern': [10, 10]});
-  const patternTwoLType = new LType({'name': 'Pattern Two', 'pattern': [10, -10]});
-  const patternThreeLType = new LType({'name': 'Pattern Three', 'pattern': [10, 0, -1]});
+  const patternOneLType = new LType({ 'name': 'Pattern One', 'pattern': [10, 10] });
+  const patternTwoLType = new LType({ 'name': 'Pattern Two', 'pattern': [10, -10] });
+  const patternThreeLType = new LType({ 'name': 'Pattern Three', 'pattern': [10, 0, -1] });
   // Scale 1
   expect(patternOneLType.getPattern(1)).toEqual([11, 11]);
   expect(patternTwoLType.getPattern(1)).toEqual([11, 11]);

package/test/{styles → tables}/ltypeManager.test.js

@@ -1,9 +1,9 @@
-import {Core} from '../../core/core/core.js';
+import { Core } from '../../core/core/core.js';
 
 const core = new Core();
 const lineTypeManager = core.ltypeManager;
 
-test('Test LineTypeManager.getStyles', () => {
+test('Test LineTypeManager.getItems', () => {
   const layers = lineTypeManager.getOptionalStyles();
   expect(layers).toHaveLength(6);
 

package/test/tables/style.test.js

@@ -0,0 +1,44 @@
+import { Style } from '../../core/tables/style';
+
+test('Test Style.vertical', () => {
+  const style = new Style();
+  expect(style.vertical).toBe(false);
+  expect(style.standardFlags.getFlagValue()).toBe(0);
+
+  style.vertical = true;
+  expect(style.vertical).toBe(true);
+  expect(style.standardFlags.hasFlag(4)).toBe(true);
+  expect(style.standardFlags.getFlagValue()).toBe(4);
+});
+
+
+test('Test Style.backwards', () => {
+  const style = new Style();
+  expect(style.backwards).toBe(false);
+  expect(style.flags.getFlagValue()).toBe(0);
+
+  style.backwards = true;
+  expect(style.backwards).toBe(true);
+  expect(style.flags.hasFlag(2)).toBe(true);
+  expect(style.flags.getFlagValue()).toBe(2);
+
+  style.backwards = false;
+  expect(style.backwards).toBe(false);
+  expect(style.flags.hasFlag(2)).toBe(false);
+});
+
+test('Test Style.upsideDown', () => {
+  const style = new Style();
+  expect(style.upsideDown).toBe(false);
+  expect(style.flags.getFlagValue()).toBe(0);
+
+  style.upsideDown = true;
+  expect(style.upsideDown).toBe(true);
+  expect(style.flags.hasFlag(4)).toBe(true);
+  expect(style.flags.getFlagValue()).toBe(4);
+
+  style.upsideDown = false;
+  expect(style.upsideDown).toBe(false);
+  expect(style.flags.hasFlag(4)).toBe(false);
+});
+