@design-core/core 0.0.1 → 0.0.3

package/test/tables/stylemanagerbase.test.js

@@ -0,0 +1,220 @@
+import { Core } from '../../core/core/core.js';
+import { StyleManagerBase } from '../../core/tables/styleManagerBase.js';
+
+
+// mock createItem method
+StyleManagerBase.prototype.createItem = function(style) {
+  return { name: style.name };
+};
+
+// mock addStandardItems method
+StyleManagerBase.prototype.addStandardItems = function() {
+  this.addItem({ 'name': 'TEST' });
+};
+
+// initialise core
+new Core();
+const styleManager = new StyleManagerBase();
+
+test('Test StyleManagerBase.getItems', () => {
+  // add some style to the styles array property
+  styleManager.items = [{ name: 'styleOne' }, { name: 'styleTwo' }];
+
+  // test getItems
+  expect(styleManager.getItems()).toHaveLength(2);
+});
+
+test('Test StyleManagerBase.itemCount', () => {
+  // add some style to the styles array property
+  styleManager.items = [{ name: 'styleOne' }, { name: 'styleTwo' }];
+
+  // test itemCount
+  expect(styleManager.itemCount()).toBe(2);
+});
+
+test('Test StyleManagerBase.newItem', () => {
+  // add some style to the styles array property
+  styleManager.items = [{ name: 'styleOne' }, { name: 'styleTwo' }];
+
+  // Add new style
+  styleManager.newItem();
+
+  expect(styleManager.itemCount()).toBe(3);
+});
+
+test('Test StyleManagerBase.getUniqueName', () => {
+  // add some style to the styles array property
+  styleManager.items = [{ name: 'styleOne' }, { name: 'styleTwo' }];
+
+  // check existing style name
+  expect(styleManager.getUniqueName('styleOne')).toBe('styleOne_1');
+  expect(styleManager.getUniqueName('sTyLeOnE')).toBe('sTyLeOnE_1');
+
+  // check new style name
+  expect(styleManager.getUniqueName('styleThree')).toBe('styleThree');
+});
+
+test('Test StyleManagerBase.addItem', () => {
+  // add some style to the styles array property
+  styleManager.items = [{ name: 'styleOne' }];
+
+  // Add new style
+  styleManager.addItem({ name: 'styleTwo' });
+  expect(styleManager.itemCount()).toBe(2);
+
+  // Try and add existing style
+  styleManager.addItem({ name: 'styleOne' });
+  expect(styleManager.itemCount()).toBe(2);
+
+  // OverWrite existing style
+  styleManager.addItem({ name: 'styleone' }, true);
+  expect(styleManager.itemCount()).toBe(2);
+  expect(styleManager.items[0].name).toBe('styleone');
+});
+
+test('Test StyleManagerBase.deleteStyle', () => {
+  // add some style to the styles array property
+  styleManager.items = [{ name: 'styleOne' }, { name: 'styleTwo' }], { name: 'Standard' };
+  styleManager.indelibleItems = ['Standard'];
+
+  // Delete style
+  styleManager.deleteStyle(1);
+  expect(styleManager.itemCount(1)).toBe(1);
+
+  // Try and delete an non-existant index
+  styleManager.deleteStyle(10);
+  expect(styleManager.itemCount()).toBe(1);
+
+
+  // Check style name
+  const styleIndex = styleManager.getItemIndex('Standard');
+
+  // Try and delete an indelible styles
+  styleManager.deleteStyle(styleIndex);
+  expect(styleManager.itemCount()).toBe(1);
+});
+
+
+test('Test StyleManagerBase.getCstyle', () => {
+  expect(styleManager.getCstyle()).toBe('TEST');
+});
+
+test('Test StyleManagerBase.setCstyle', () => {
+  // add some style to the styles array property
+  styleManager.items = [{ name: 'styleOne' }, { name: 'styleTwo' }];
+
+  styleManager.setCstyle('styleOne');
+  expect(styleManager.getCstyle()).toBe('styleOne');
+
+  // expect(() => {
+  //  styleManager.setCstyle('Non-Existent');
+  // }).toThrow();
+  // styleManager.setCstyle('Non-Existent');
+  expect(styleManager.getCstyle()).toBe('styleOne');
+});
+
+test('Test StyleManagerBase.itemExists', () => {
+  // add some style to the styles array property
+  styleManager.items = [{ name: 'styleOne' }, { name: 'styleTwo' }];
+
+  expect(styleManager.itemExists('styleOne')).toBe(true);
+  expect(styleManager.itemExists('styleTwo')).toBe(true);
+  expect(styleManager.itemExists('Non-Existent')).toBe(false);
+});
+
+test('Test StyleManagerBase.checkStyles', () => {
+  // clear all styles
+  styleManager.items = [];
+
+  expect(styleManager.itemCount()).toBe(0);
+
+  styleManager.checkStyles();
+  expect(styleManager.itemCount()).toBe(1);
+});
+
+test('Test StyleManagerBase.addStandardItems', () => {
+  // clear all styles
+  styleManager.items = [];
+
+  expect(styleManager.itemCount()).toBe(0);
+
+  styleManager.addStandardItems();
+  expect(styleManager.itemCount()).toBe(1);
+
+  // check standard styles can't be added multiple times
+  styleManager.addStandardItems();
+  expect(styleManager.itemCount()).toBe(1);
+});
+
+test('Test StyleManagerBase.getItemByName', () => {
+  // add some style to the styles array property
+  styleManager.items = [{ name: 'styleOne' }, { name: 'styleTwo' }];
+
+  expect(styleManager.getItemByName('styleOne').name).toBe('styleOne');
+  expect(styleManager.getItemByName('Non-Existent')).toBeUndefined();
+});
+
+test('Test StyleManagerBase.getItemByIndex', () => {
+  // add some style to the styles array property
+  styleManager.items = [{ name: 'styleOne' }, { name: 'styleTwo' }];
+
+  expect(styleManager.getItemByIndex(0).name).toBe('styleOne');
+  expect(styleManager.getItemByIndex(20)).toBeUndefined();
+});
+
+test('Test StyleManagerBase.renameStyle', () => {
+  // add some style to the styles array property
+  styleManager.items = [{ name: 'styleOne' }, { name: 'styleTwo' }];
+  styleManager.indelibleItems = ['Standard'];
+
+  // check index name
+  expect(styleManager.getItemByIndex(0).name).toBe('styleOne');
+
+  // try and rename to STANDARD
+  styleManager.renameStyle(0, 'STANDARD');
+  expect(styleManager.getItemByIndex(0).name).toBe('styleOne');
+
+  // valid rename
+  styleManager.renameStyle(0, 'styleOneRenamed');
+  expect(styleManager.getItemByIndex(0).name).toBe('styleOneRenamed');
+
+  // try and rename to current name - no change
+  styleManager.renameStyle(0, 'styleOneRenamed');
+  expect(styleManager.getItemByIndex(0).name).toBe('styleOneRenamed');
+
+  // try and rename current style
+  // check index name
+  expect(styleManager.getItemByIndex(1).name).toBe('styleTwo');
+  styleManager.setCstyle('styleTwo');
+  expect(styleManager.getCstyle()).toBe('styleTwo');
+
+  styleManager.renameStyle(1, 'styleTwoRenamed');
+  expect(styleManager.getItemByIndex(1).name).toBe('styleTwoRenamed');
+  expect(styleManager.getCstyle()).toBe('styleTwoRenamed');
+});
+
+
+test('Test StyleManagerBase.updateItem', () => {
+  // add some style to the styles array property
+  styleManager.items = [{ name: 'styleOne', textHeight: 2 }, { name: 'styleTwo', textHeight: 3 }];
+
+  // update non-existent style index
+  expect(() => {
+    styleManager.updateItem(10, 'Non-Existent-property', 'value');
+  }).toThrow();
+
+
+  // update non-existent style property
+  expect(() => {
+    styleManager.updateItem(1, 'Non-Existent-property', 'value');
+  }).toThrow();
+
+  // update style name
+  styleManager.updateItem(0, 'name', 'styleOneRenamed');
+  expect(styleManager.getItemByIndex(0).name).toBe('styleOneRenamed');
+
+
+  // update style text height
+  styleManager.updateItem(0, 'textHeight', 20);
+  expect(styleManager.getItemByIndex(0).textHeight).toBe(20);
+});

package/test/tables/tableManagerBase.test.js

@@ -0,0 +1,194 @@
+import { Core } from '../../core/core/core.js';
+import { TableManagerBase } from '../../core/tables/tableManagerBase.js';
+
+// initialise core
+new Core();
+
+// mock createItem method
+TableManagerBase.prototype.createItem = function(item) {
+  return { name: item.name };
+};
+
+// mock addStandardItems method
+TableManagerBase.prototype.addStandardItems = function() {
+  this.addItem({ 'name': 'TEST' });
+};
+
+const tableManagerBase = new TableManagerBase();
+
+// mock item data
+tableManagerBase.items = [{ name: 'itemOne' }, { name: 'itemTwo' }];
+
+test('Test tableManagerBase.getItems', () => {
+  // add some item to the items array property
+  tableManagerBase.items = [{ name: 'itemOne' }, { name: 'itemTwo' }];
+
+  // test getItems
+  expect(tableManagerBase.getItems()).toHaveLength(2);
+});
+
+test('Test tableManagerBase.itemCount', () => {
+  // add some item to the items array property
+  tableManagerBase.items = [{ name: 'itemOne' }, { name: 'itemTwo' }];
+
+  // test itemCount
+  expect(tableManagerBase.itemCount()).toBe(2);
+});
+
+test('Test tableManagerBase.newItem', () => {
+  // add some item to the items array property
+  tableManagerBase.items = [{ name: 'itemOne' }, { name: 'itemTwo' }];
+
+  // Add new item
+  tableManagerBase.newItem();
+
+  expect(tableManagerBase.itemCount()).toBe(3);
+});
+
+test('Test tableManagerBase.getUniqueName', () => {
+  // add some item to the items array property
+  tableManagerBase.items = [{ name: 'itemOne' }, { name: 'itemTwo' }];
+
+  // check existing item name
+  expect(tableManagerBase.getUniqueName('itemOne')).toBe('itemOne_1');
+  expect(tableManagerBase.getUniqueName('itemOnE')).toBe('itemOnE_1');
+
+  // check new item name
+  expect(tableManagerBase.getUniqueName('itemThree')).toBe('itemThree');
+});
+
+test('Test tableManagerBase.addItem', () => {
+  // add some item to the items array property
+  tableManagerBase.items = [{ name: 'itemOne' }];
+
+  // Add new item
+  tableManagerBase.addItem({ name: 'itemTwo' });
+  expect(tableManagerBase.itemCount()).toBe(2);
+
+  // Try and add existing item
+  tableManagerBase.addItem({ name: 'itemOne' });
+  expect(tableManagerBase.itemCount()).toBe(2);
+
+  // OverWrite existing item
+  tableManagerBase.addItem({ name: 'itemone' }, true);
+  expect(tableManagerBase.itemCount()).toBe(2);
+  expect(tableManagerBase.items[0].name).toBe('itemone');
+});
+
+test('Test tableManagerBase.deleteItem', () => {
+  // add some item to the items array property
+  tableManagerBase.items = [{ name: 'itemOne' }, { name: 'itemTwo' }], { name: 'Standard' };
+  tableManagerBase.indelibleItems = ['Standard'];
+
+  // Delete item
+  tableManagerBase.deleteItem(1);
+  expect(tableManagerBase.itemCount(1)).toBe(1);
+
+  // Try and delete an non-existant index
+  tableManagerBase.deleteItem(10);
+  expect(tableManagerBase.itemCount()).toBe(1);
+
+
+  // Check item name
+  const itemIndex = tableManagerBase.getItemIndex('Standard');
+
+  // Try and delete an indelible items
+  tableManagerBase.deleteItem(itemIndex);
+  expect(tableManagerBase.itemCount()).toBe(1);
+});
+
+test('Test tableManagerBase.itemExists', () => {
+  // add some item to the items array property
+  tableManagerBase.items = [{ name: 'itemOne' }, { name: 'itemTwo' }];
+
+  expect(tableManagerBase.itemExists('itemOne')).toBe(true);
+  expect(tableManagerBase.itemExists('itemTwo')).toBe(true);
+  expect(tableManagerBase.itemExists('Non-Existent')).toBe(false);
+});
+
+test('Test tableManagerBase.checkitems', () => {
+  // clear all items
+  tableManagerBase.items = [];
+
+  expect(tableManagerBase.itemCount()).toBe(0);
+
+  tableManagerBase.checkItems();
+  expect(tableManagerBase.itemCount()).toBe(1);
+});
+
+test('Test tableManagerBase.addStandardItems', () => {
+  // clear all items
+  tableManagerBase.items = [];
+
+  expect(tableManagerBase.itemCount()).toBe(0);
+
+  tableManagerBase.addStandardItems();
+  expect(tableManagerBase.itemCount()).toBe(1);
+
+  // check standard items can't be added multiple times
+  tableManagerBase.addStandardItems();
+  expect(tableManagerBase.itemCount()).toBe(1);
+});
+
+test('Test tableManagerBase.getItemByName', () => {
+  // add some item to the items array property
+  tableManagerBase.items = [{ name: 'itemOne' }, { name: 'itemTwo' }];
+
+  expect(tableManagerBase.getItemByName('itemOne').name).toBe('itemOne');
+  expect(tableManagerBase.getItemByName('Non-Existent')).toBeUndefined();
+});
+
+test('Test tableManagerBase.getItemByIndex', () => {
+  // add some item to the items array property
+  tableManagerBase.items = [{ name: 'itemOne' }, { name: 'itemTwo' }];
+
+  expect(tableManagerBase.getItemByIndex(0).name).toBe('itemOne');
+  expect(tableManagerBase.getItemByIndex(20)).toBeUndefined();
+});
+
+test('Test tableManagerBase.renameitem', () => {
+  // add some item to the items array property
+  tableManagerBase.items = [{ name: 'itemOne' }, { name: 'itemTwo' }];
+  tableManagerBase.indelibleItems = ['Standard'];
+
+  // check index name
+  expect(tableManagerBase.getItemByIndex(0).name).toBe('itemOne');
+
+  // try and rename to STANDARD
+  tableManagerBase.renameItem(0, 'STANDARD');
+  expect(tableManagerBase.getItemByIndex(0).name).toBe('itemOne');
+
+  // valid rename
+  tableManagerBase.renameItem(0, 'itemOneRenamed');
+  expect(tableManagerBase.getItemByIndex(0).name).toBe('itemOneRenamed');
+
+  // try and rename to current name - no change
+  tableManagerBase.renameItem(0, 'itemOneRenamed');
+  expect(tableManagerBase.getItemByIndex(0).name).toBe('itemOneRenamed');
+});
+
+
+test('Test tableManagerBase.updateItem', () => {
+  // add some item to the items array property
+  tableManagerBase.items = [{ name: 'itemOne', textHeight: 2 }, { name: 'itemTwo', textHeight: 3 }];
+
+  // update non-existent item index
+  expect(() => {
+    tableManagerBase.updateItem(10, 'Non-Existent-property', 'value');
+  }).toThrow();
+
+
+  // update non-existent item property
+  expect(() => {
+    tableManagerBase.updateItem(1, 'Non-Existent-property', 'value');
+  }).toThrow();
+
+  // update item name
+  tableManagerBase.updateItem(0, 'name', 'itemOneRenamed');
+  expect(tableManagerBase.getItemByIndex(0).name).toBe('itemOneRenamed');
+
+
+  // update item text height
+  tableManagerBase.updateItem(0, 'textHeight', 20);
+  expect(tableManagerBase.getItemByIndex(0).textHeight).toBe(20);
+});

package/test/tables/ucs.test.js

@@ -0,0 +1,37 @@
+import { DXFFile } from '../../core/lib/dxf/dxfFile.js';
+import { UCS } from '../../core/tables/ucs.js';
+
+test('Test UCS constructor defaults', () => {
+  const ucs = new UCS();
+  expect(ucs.name).toBe('');
+});
+
+test('Test UCS constructor with name property', () => {
+  const ucs = new UCS({ name: 'TestUCS' });
+  expect(ucs.name).toBe('TestUCS');
+});
+
+test('Test UCS constructor with DXF group code', () => {
+  const ucs = new UCS({ 2: 'DXFUcs' });
+  expect(ucs.name).toBe('DXFUcs');
+});
+
+test('Test UCS.dxf', () => {
+  const ucs = new UCS({ handle: 'A', name: 'TestUCS' });
+  const file = new DXFFile();
+  ucs.dxf(file);
+
+  const dxfString = `0
+UCS
+5
+A
+100
+AcDbSymbolTableRecord
+100
+AcDbUCSTableRecord
+2
+TestUCS
+`;
+
+  expect(file.contents).toEqual(dxfString);
+});

package/test/tables/ucsManager.test.js

@@ -0,0 +1,48 @@
+import { Core } from '../../core/core/core.js';
+import { DXFFile } from '../../core/lib/dxf/dxfFile.js';
+
+const core = new Core();
+const ucsManager = core.ucsManager;
+
+test('Test UCSManager.getItems', () => {
+  const items = ucsManager.getItems();
+  expect(items).toHaveLength(0);
+});
+
+test('Test UCSManager.itemCount', () => {
+  expect(ucsManager.itemCount()).toBe(0);
+});
+
+test('Test UCSManager.addItem', () => {
+  ucsManager.addItem({ name: 'TestUCS' });
+  expect(ucsManager.itemCount()).toBe(1);
+  expect(ucsManager.getItemByName('TestUCS')).toBeDefined();
+});
+
+test('Test UCSManager.deleteItem', () => {
+  const count = ucsManager.itemCount();
+  const index = ucsManager.getItemIndex('TestUCS');
+  ucsManager.deleteItem(index);
+  expect(ucsManager.itemCount()).toBe(count - 1);
+});
+
+test('Test UCSManager.dxf', () => {
+  const file = new DXFFile();
+  ucsManager.dxf(file);
+
+  const dxfString = `0
+TABLE
+2
+UCS
+5
+22
+100
+AcDbSymbolTable
+70
+0
+0
+ENDTAB
+`;
+
+  expect(file.contents).toEqual(dxfString);
+});

package/test/tables/view.test.js

@@ -0,0 +1,37 @@
+import { DXFFile } from '../../core/lib/dxf/dxfFile.js';
+import { View } from '../../core/tables/view.js';
+
+test('Test View constructor defaults', () => {
+  const view = new View();
+  expect(view.name).toBe('');
+});
+
+test('Test View constructor with name property', () => {
+  const view = new View({ name: 'TestView' });
+  expect(view.name).toBe('TestView');
+});
+
+test('Test View constructor with DXF group code', () => {
+  const view = new View({ 2: 'DXFView' });
+  expect(view.name).toBe('DXFView');
+});
+
+test('Test View.dxf', () => {
+  const view = new View({ handle: 'A', name: 'TestView' });
+  const file = new DXFFile();
+  view.dxf(file);
+
+  const dxfString = `0
+VIEW
+5
+A
+100
+AcDbSymbolTableRecord
+100
+AcDbViewTableRecord
+2
+TestView
+`;
+
+  expect(file.contents).toEqual(dxfString);
+});

package/test/tables/viewManager.test.js

@@ -0,0 +1,48 @@
+import { Core } from '../../core/core/core.js';
+import { DXFFile } from '../../core/lib/dxf/dxfFile.js';
+
+const core = new Core();
+const viewManager = core.viewManager;
+
+test('Test ViewManager.getItems', () => {
+  const items = viewManager.getItems();
+  expect(items).toHaveLength(0);
+});
+
+test('Test ViewManager.itemCount', () => {
+  expect(viewManager.itemCount()).toBe(0);
+});
+
+test('Test ViewManager.addItem', () => {
+  viewManager.addItem({ name: 'TestView' });
+  expect(viewManager.itemCount()).toBe(1);
+  expect(viewManager.getItemByName('TestView')).toBeDefined();
+});
+
+test('Test ViewManager.deleteItem', () => {
+  const count = viewManager.itemCount();
+  const index = viewManager.getItemIndex('TestView');
+  viewManager.deleteItem(index);
+  expect(viewManager.itemCount()).toBe(count - 1);
+});
+
+test('Test ViewManager.dxf', () => {
+  const file = new DXFFile();
+  viewManager.dxf(file);
+
+  const dxfString = `0
+TABLE
+2
+VIEW
+5
+1F
+100
+AcDbSymbolTable
+70
+0
+0
+ENDTAB
+`;
+
+  expect(file.contents).toEqual(dxfString);
+});

package/test/tables/vport.test.js

@@ -0,0 +1,117 @@
+import { VPort } from '../../core/tables/vport.js';
+import { File } from '../test-helpers/test-helpers.js';
+
+test('Test VPort constructor defaults', () => {
+  const vport = new VPort();
+  expect(vport.name).toBe('*ACTIVE');
+  expect(vport.viewCenterX).toBe(0);
+  expect(vport.viewCenterY).toBe(0);
+  expect(vport.height).toBe(0);
+  expect(vport.ratio).toBe(0);
+});
+
+test('Test VPort constructor with data', () => {
+  const vport = new VPort({ name: 'TestVPort', viewCenterX: 10, viewCenterY: 20, height: 100, ratio: 1.5 });
+  expect(vport.name).toBe('TestVPort');
+  expect(vport.viewCenterX).toBe(10);
+  expect(vport.viewCenterY).toBe(20);
+  expect(vport.height).toBe(100);
+  expect(vport.ratio).toBe(1.5);
+});
+
+test('Test VPort constructor with DXF group codes', () => {
+  const vport = new VPort({ 2: 'DXFVPort', 12: 5, 22: 15, 40: 200, 41: 2.0 });
+  expect(vport.name).toBe('DXFVPort');
+  expect(vport.viewCenterX).toBe(5);
+  expect(vport.viewCenterY).toBe(15);
+  expect(vport.height).toBe(200);
+  expect(vport.ratio).toBe(2.0);
+});
+
+test('Test VPort.dxf', () => {
+  const vport = new VPort({ handle: '1', name: '*ACTIVE', viewCenterX: 50, viewCenterY: 100, height: 200, ratio: 1.5 });
+  const file = new File();
+  vport.dxf(file);
+
+  const dxfString = `0
+VPORT
+5
+1
+100
+AcDbSymbolTableRecord
+100
+AcDbViewportTableRecord
+2
+*ACTIVE
+70
+0
+10
+0.0
+20
+0.0
+11
+1.0
+21
+1.0
+12
+50
+22
+100
+13
+0.0
+23
+0.0
+14
+10.0
+24
+10.0
+15
+10.0
+25
+10.0
+16
+0.0
+26
+0.0
+36
+1.0
+17
+0.0
+27
+0.0
+37
+0.0
+40
+200
+41
+1.5
+42
+50.0
+43
+0.0
+44
+0.0
+50
+0.0
+51
+0.0
+71
+0.0
+72
+1000
+73
+1
+74
+3
+75
+0
+76
+1
+77
+0
+78
+0
+`;
+
+  expect(file.contents).toEqual(dxfString);
+});