@design-core/core 0.0.6 → 0.0.7

package/test/lib/snapping.test.js

@@ -1,6 +1,7 @@
 import { jest } from '@jest/globals';
 import { Core } from '../../core/core/core.js';
-import { Snapping, SnapPoint } from '../../core/lib/snapping.js';
+import { Snapping } from '../../core/lib/snapping.js';
+import { SnapPoint } from '../../core/lib/auxiliary/snapPoint.js';
 import { Point } from '../../core/entities/point.js';
 import { DesignCore } from '../../core/designCore.js';
 
@@ -69,21 +70,10 @@ test('Test SnapPoint.draw', () => {
   DesignCore.Scene.auxiliaryEntities.clear();
   snapping.addSnapPoint(new SnapPoint(new Point(0.5, 0.5), SnapPoint.Type.CENTRE));
   const snapPointEntity = DesignCore.Scene.auxiliaryEntities.get(0);
-  const ctx = {
-    strokeStyle: '',
-    lineWidth: 0,
-    setLineDash: jest.fn(),
-    beginPath: jest.fn(),
-    moveTo: jest.fn(),
-    lineTo: jest.fn(),
-    closePath: jest.fn(),
-    arc: jest.fn(),
-    stroke: jest.fn(),
-  };
-  snapPointEntity.draw(ctx, 1);
-  expect(ctx.beginPath).toHaveBeenCalled();
-  expect(ctx.arc).toHaveBeenCalledWith(0.5, 0.5, expect.any(Number), 0, 6.283);
-  expect(ctx.stroke).toHaveBeenCalled();
+  const renderer = makeSnapRenderer();
+  snapPointEntity.draw(renderer, 1);
+  expect(renderer.setColour).toHaveBeenCalled();
+  expect(renderer.drawShape).toHaveBeenCalled();
 });
 
 test('Test Snapping.addTrackingLine', () => {
@@ -98,23 +88,9 @@ test('Test TrackingLine.draw', () => {
   // note: the default matrix has d=-1, so scene y is in [-1, 0] for a 1x1 canvas
   snapping.addTrackingLine(new Point(0.2, -0.5), new Point(0.8, -0.5));
   const trackingLine = DesignCore.Scene.auxiliaryEntities.get(0);
-  const ctx = {
-    save: jest.fn(),
-    restore: jest.fn(),
-    beginPath: jest.fn(),
-    strokeStyle: '',
-    lineWidth: 0,
-    setLineDash: jest.fn(),
-    moveTo: jest.fn(),
-    lineTo: jest.fn(),
-    stroke: jest.fn(),
-  };
-  trackingLine.draw(ctx, 1);
-  expect(ctx.save).toHaveBeenCalled();
-  expect(ctx.moveTo).toHaveBeenCalled();
-  expect(ctx.lineTo).toHaveBeenCalled();
-  expect(ctx.stroke).toHaveBeenCalled();
-  expect(ctx.restore).toHaveBeenCalled();
+  const renderer = makeTrackingRenderer();
+  trackingLine.draw(renderer, 1);
+  expect(renderer.drawShape).toHaveBeenCalled();
 });
 
 test('Test TrackingLine.draw degenerate zero direction', () => {
@@ -122,20 +98,10 @@ test('Test TrackingLine.draw degenerate zero direction', () => {
   // inputPoint equals snapPoint → direction is zero vector → draw returns early
   snapping.addTrackingLine(new Point(0.5, 0.5), new Point(0.5, 0.5));
   const trackingLine = DesignCore.Scene.auxiliaryEntities.get(0);
-  const ctx = {
-    save: jest.fn(),
-    restore: jest.fn(),
-    beginPath: jest.fn(),
-    strokeStyle: '',
-    lineWidth: 0,
-    setLineDash: jest.fn(),
-    moveTo: jest.fn(),
-    lineTo: jest.fn(),
-    stroke: jest.fn(),
-  };
-  trackingLine.draw(ctx, 1);
-  expect(ctx.moveTo).not.toHaveBeenCalled();
-  expect(ctx.stroke).not.toHaveBeenCalled();
+  const renderer = makeTrackingRenderer();
+  trackingLine.draw(renderer, 1);
+  expect(renderer.drawShape).not.toHaveBeenCalled();
+  expect(renderer.restore).not.toHaveBeenCalled();
 });
 
 test('Test Snapping.polarSnap', () => {
@@ -199,35 +165,27 @@ test('Test Snapping.orthoSnap', () => {
   expect(snapping.orthoSnap(new Point(0, 0))).toBeUndefined();
 });
 
-// ─── Context mock helpers ────────────────────────────────────────────────────
+// ─── Renderer mock helpers ──────────────────────────────────────────────────
 
-/** @return {object} mock HTML canvas context for SnapPoint.draw tests */
-function makeSnapCtx() {
+/** @return {object} mock renderer for SnapPoint.draw tests */
+function makeSnapRenderer() {
   return {
-    strokeStyle: '',
-    lineWidth: 0,
-    setLineDash: jest.fn(),
-    beginPath: jest.fn(),
-    moveTo: jest.fn(),
-    lineTo: jest.fn(),
-    closePath: jest.fn(),
-    arc: jest.fn(),
-    stroke: jest.fn(),
+    setColour: jest.fn(),
+    setLineWidth: jest.fn(),
+    setDash: jest.fn(),
+    drawShape: jest.fn(),
   };
 }
 
-/** @return {object} mock HTML canvas context for TrackingLine.draw tests */
-function makeTrackingCtx() {
+/** @return {object} mock renderer for TrackingLine.draw tests */
+function makeTrackingRenderer() {
   return {
     save: jest.fn(),
     restore: jest.fn(),
-    beginPath: jest.fn(),
-    strokeStyle: '',
-    lineWidth: 0,
-    setLineDash: jest.fn(),
-    moveTo: jest.fn(),
-    lineTo: jest.fn(),
-    stroke: jest.fn(),
+    setColour: jest.fn(),
+    setLineWidth: jest.fn(),
+    setDash: jest.fn(),
+    drawShape: jest.fn(),
   };
 }
 
@@ -294,74 +252,58 @@ test('Test Snapping.getSnapPoint with non-matching override returns undefined',
 
 // ─── SnapPoint.draw – all snap types ────────────────────────────────────────
 
-test('Test SnapPoint.draw END type draws closed polygon without arc', () => {
+test('Test SnapPoint.draw END type draws closed polygon', () => {
   const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.END);
-  const ctx = makeSnapCtx();
-  sp.draw(ctx, 1);
-  expect(ctx.beginPath).toHaveBeenCalled();
-  expect(ctx.closePath).toHaveBeenCalled();
-  expect(ctx.stroke).toHaveBeenCalled();
-  expect(ctx.arc).not.toHaveBeenCalled();
+  const renderer = makeSnapRenderer();
+  sp.draw(renderer, 1);
+  expect(renderer.drawShape).toHaveBeenCalledTimes(1);
+  expect(renderer.drawShape).toHaveBeenCalledWith(expect.any(Array), expect.objectContaining({ closed: true }));
 });
 
-test('Test SnapPoint.draw MID type draws closed polygon without arc', () => {
+test('Test SnapPoint.draw MID type draws closed polygon', () => {
   const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.MID);
-  const ctx = makeSnapCtx();
-  sp.draw(ctx, 1);
-  expect(ctx.beginPath).toHaveBeenCalled();
-  expect(ctx.closePath).toHaveBeenCalled();
-  expect(ctx.stroke).toHaveBeenCalled();
-  expect(ctx.arc).not.toHaveBeenCalled();
+  const renderer = makeSnapRenderer();
+  sp.draw(renderer, 1);
+  expect(renderer.drawShape).toHaveBeenCalledTimes(1);
+  expect(renderer.drawShape).toHaveBeenCalledWith(expect.any(Array), expect.objectContaining({ closed: true }));
 });
 
-test('Test SnapPoint.draw QUADRANT type draws closed polygon without arc', () => {
+test('Test SnapPoint.draw QUADRANT type draws closed polygon', () => {
   const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.QUADRANT);
-  const ctx = makeSnapCtx();
-  sp.draw(ctx, 1);
-  expect(ctx.beginPath).toHaveBeenCalled();
-  expect(ctx.closePath).toHaveBeenCalled();
-  expect(ctx.stroke).toHaveBeenCalled();
-  expect(ctx.arc).not.toHaveBeenCalled();
+  const renderer = makeSnapRenderer();
+  sp.draw(renderer, 1);
+  expect(renderer.drawShape).toHaveBeenCalledTimes(1);
+  expect(renderer.drawShape).toHaveBeenCalledWith(expect.any(Array), expect.objectContaining({ closed: true }));
 });
 
-test('Test SnapPoint.draw NEAREST type draws closed polygon without arc', () => {
+test('Test SnapPoint.draw NEAREST type draws closed polygon', () => {
   const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.NEAREST);
-  const ctx = makeSnapCtx();
-  sp.draw(ctx, 1);
-  expect(ctx.beginPath).toHaveBeenCalled();
-  expect(ctx.closePath).toHaveBeenCalled();
-  expect(ctx.stroke).toHaveBeenCalled();
-  expect(ctx.arc).not.toHaveBeenCalled();
+  const renderer = makeSnapRenderer();
+  sp.draw(renderer, 1);
+  expect(renderer.drawShape).toHaveBeenCalledTimes(1);
+  expect(renderer.drawShape).toHaveBeenCalledWith(expect.any(Array), expect.objectContaining({ closed: true }));
 });
 
-test('Test SnapPoint.draw TANGENT type draws arc with tangent line', () => {
+test('Test SnapPoint.draw TANGENT type draws circle and tangent line', () => {
   const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.TANGENT);
-  const ctx = makeSnapCtx();
-  sp.draw(ctx, 1);
-  expect(ctx.beginPath).toHaveBeenCalled();
-  expect(ctx.arc).toHaveBeenCalledWith(5, 5, expect.any(Number), 0, 6.283);
-  expect(ctx.stroke).toHaveBeenCalled();
-  expect(ctx.closePath).not.toHaveBeenCalled();
+  const renderer = makeSnapRenderer();
+  sp.draw(renderer, 1);
+  expect(renderer.drawShape).toHaveBeenCalledTimes(2);
 });
 
-test('Test SnapPoint.draw NODE type draws arc with X inside', () => {
+test('Test SnapPoint.draw NODE type draws circle and X lines', () => {
   const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.NODE);
-  const ctx = makeSnapCtx();
-  sp.draw(ctx, 1);
-  expect(ctx.beginPath).toHaveBeenCalled();
-  expect(ctx.arc).toHaveBeenCalledWith(5, 5, expect.any(Number), 0, 6.283);
-  expect(ctx.stroke).toHaveBeenCalled();
-  expect(ctx.closePath).not.toHaveBeenCalled();
+  const renderer = makeSnapRenderer();
+  sp.draw(renderer, 1);
+  expect(renderer.drawShape).toHaveBeenCalledTimes(3);
 });
 
-test('Test SnapPoint.draw PERPENDICULAR type draws L-shape without arc', () => {
+test('Test SnapPoint.draw PERPENDICULAR type draws L-shape', () => {
   const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.PERPENDICULAR);
-  const ctx = makeSnapCtx();
-  sp.draw(ctx, 1);
-  expect(ctx.beginPath).toHaveBeenCalled();
-  expect(ctx.stroke).toHaveBeenCalled();
-  expect(ctx.closePath).not.toHaveBeenCalled();
-  expect(ctx.arc).not.toHaveBeenCalled();
+  const renderer = makeSnapRenderer();
+  sp.draw(renderer, 1);
+  expect(renderer.drawShape).toHaveBeenCalledTimes(1);
+  expect(renderer.drawShape).not.toHaveBeenCalledWith(expect.any(Array), expect.objectContaining({ closed: true }));
 });
 
 // ─── TrackingLine.draw – out-of-bounds cases ─────────────────────────────────
@@ -371,10 +313,10 @@ test('Test TrackingLine.draw vertical line outside x bounds', () => {
   // dir.x === 0 and from.x = 2 > boundsMax.x = 1 → draw returns early
   snapping.addTrackingLine(new Point(2, -0.5), new Point(2, 0.5));
   const trackingLine = DesignCore.Scene.auxiliaryEntities.get(0);
-  const ctx = makeTrackingCtx();
-  trackingLine.draw(ctx, 1);
-  expect(ctx.moveTo).not.toHaveBeenCalled();
-  expect(ctx.stroke).not.toHaveBeenCalled();
+  const renderer = makeTrackingRenderer();
+  trackingLine.draw(renderer, 1);
+  expect(renderer.drawShape).not.toHaveBeenCalled();
+  expect(renderer.restore).not.toHaveBeenCalled();
 });
 
 test('Test TrackingLine.draw horizontal line outside y bounds', () => {
@@ -382,10 +324,10 @@ test('Test TrackingLine.draw horizontal line outside y bounds', () => {
   // dir.y === 0 and from.y = -5 < boundsMin.y = -1 → draw returns early
   snapping.addTrackingLine(new Point(0.5, -5), new Point(0.8, -5));
   const trackingLine = DesignCore.Scene.auxiliaryEntities.get(0);
-  const ctx = makeTrackingCtx();
-  trackingLine.draw(ctx, 1);
-  expect(ctx.moveTo).not.toHaveBeenCalled();
-  expect(ctx.stroke).not.toHaveBeenCalled();
+  const renderer = makeTrackingRenderer();
+  trackingLine.draw(renderer, 1);
+  expect(renderer.drawShape).not.toHaveBeenCalled();
+  expect(renderer.restore).not.toHaveBeenCalled();
 });
 
 test('Test TrackingLine.draw line does not intersect canvas bounds', () => {
@@ -394,8 +336,8 @@ test('Test TrackingLine.draw line does not intersect canvas bounds', () => {
   // tMax (-1) < tMin (-0.5) → draw returns early
   snapping.addTrackingLine(new Point(2, -0.5), new Point(3, 0.5));
   const trackingLine = DesignCore.Scene.auxiliaryEntities.get(0);
-  const ctx = makeTrackingCtx();
-  trackingLine.draw(ctx, 1);
-  expect(ctx.moveTo).not.toHaveBeenCalled();
-  expect(ctx.stroke).not.toHaveBeenCalled();
+  const renderer = makeTrackingRenderer();
+  trackingLine.draw(renderer, 1);
+  expect(renderer.drawShape).not.toHaveBeenCalled();
+  expect(renderer.restore).not.toHaveBeenCalled();
 });

package/test/lib/stateManager.test.js

@@ -58,24 +58,24 @@ describe('StateManager', () => {
     }
     const target = em.get(2);
     sm.commit(em, [new UpdateState(target, { layer: 'newLayer' })]);
-    expect(em.get(2).layer).toBe('newLayer');
+    expect(em.get(2).getProperty('layer')).toBe('newLayer');
     sm.undo();
-    expect(em.get(2).layer).toBe('testLayer');
+    expect(em.get(2).getProperty('layer')).toBe('testLayer');
     sm.redo();
-    expect(em.get(2).layer).toBe('newLayer');
+    expect(em.get(2).getProperty('layer')).toBe('newLayer');
   });
 
   test('addState removed future states', () => {
     const em = new EntityManager();
     const line = new Line({ layer: 'testLayer', points: [new Point(), new Point(10, 11)] });
     sm.commit(em, [new AddState(line)]);
-    expect(em.get(0).layer).toBe('testLayer');
+    expect(em.get(0).getProperty('layer')).toBe('testLayer');
     sm.commit(em, [new UpdateState(line, { layer: 'differentLayer', points: [new Point(1, 2), new Point(101, 110)] })]);
-    expect(em.get(0).layer).toBe('differentLayer');
+    expect(em.get(0).getProperty('layer')).toBe('differentLayer');
     sm.undo();
-    expect(em.get(0).layer).toBe('testLayer');
+    expect(em.get(0).getProperty('layer')).toBe('testLayer');
     sm.redo();
-    expect(em.get(0).layer).toBe('differentLayer');
+    expect(em.get(0).getProperty('layer')).toBe('differentLayer');
   });
 
   test('clearHistory resets history and indices', () => {

package/test/lib/utils.test.js

@@ -1,4 +1,5 @@
 import { Arc } from '../../core/entities/arc.js';
+import { Hatch } from '../../core/entities/hatch.js';
 import { Utils } from '../../core/lib/utils.js';
 import { Point } from '../../core/entities/point.js';
 
@@ -74,7 +75,7 @@ test('Test Utils.sortPointsOnArc mutates array ordered by angular position', ()
   ];
 
   const arc = new Arc({ points: [new Point(0, 0), new Point(10, 0), new Point(-10, 0)], direction: 1 });
-  Utils.sortPointsOnArc(pts, arc.points[1], arc.points[2], arc.points[0], arc.direction);
+  Utils.sortPointsOnArc(pts, arc.points[1], arc.points[2], arc.points[0], arc.getProperty('direction'));
   // Expect order: (10,0), (7.1, 7.1), (10,10), (-7.1, 7.1), (-10,0)
   expect(pts[0].x).toBe(10);
   expect(pts[0].y).toBe(0);
@@ -92,7 +93,7 @@ test('Test Utils.sortPointsOnArc mutates array ordered by angular position', ()
   expect(pts[4].y).toBe(0);
 
   const cwArc = new Arc({ points: [new Point(0, 0), new Point(-10, 0), new Point(10, 0)], direction: -1 });
-  Utils.sortPointsOnArc(pts, cwArc.points[1], cwArc.points[2], cwArc.points[0], cwArc.direction);
+  Utils.sortPointsOnArc(pts, cwArc.points[1], cwArc.points[2], cwArc.points[0], cwArc.getProperty('direction'));
   // Expect order: (-10,0), (-7.1, 7.1), (10,10), (7.1, 7.1), (10,0)
   expect(pts[0].x).toBe(-10);
   expect(pts[0].y).toBe(0);
@@ -110,6 +111,39 @@ test('Test Utils.sortPointsOnArc mutates array ordered by angular position', ()
   expect(pts[4].y).toBe(0);
 });
 
+test('Test Utils.cloneProperties copies default properties from entity', () => {
+  const arc = new Arc({ layer: 'walls', lineWidth: 5, lineType: 'DASHED' });
+  const props = Utils.cloneProperties(arc);
+  expect(props.layer).toBe('walls');
+  expect(props.lineWidth).toBe(5);
+  expect(props.lineType).toBe('DASHED');
+  expect(Object.keys(props)).toEqual(expect.arrayContaining(['layer', 'colour', 'lineWidth', 'lineType']));
+});
+
+test('Test Utils.cloneProperties respects custom properties list', () => {
+  const arc = new Arc({ layer: 'walls', lineWidth: 5, lineType: 'DASHED' });
+  const props = Utils.cloneProperties(arc, ['layer', 'lineWidth']);
+  expect(props.layer).toBe('walls');
+  expect(props.lineWidth).toBe(5);
+  expect(props.lineType).toBeUndefined();
+  expect(props.colour).toBeUndefined();
+});
+
+test('Test Utils.cloneProperties copies patternName from Hatch', () => {
+  const hatch = new Hatch({ patternName: 'ANSI37' });
+  const props = Utils.cloneProperties(hatch);
+  expect(props.patternName).toBe('ANSI37');
+  // lineType is hidden on Hatch
+  expect(props.lineType).toBeUndefined();
+  expect(props.lineWidth).toBeDefined();
+});
+
+test('Test Utils.cloneProperties does not include patternName for non-hatch entities', () => {
+  const arc = new Arc({ layer: 'walls' });
+  const props = Utils.cloneProperties(arc);
+  expect(props.patternName).toBeUndefined();
+});
+
 test('Test Utils.areaOfTriangle', () => {
   expect(Utils.areaOfTriangle(new Point(0, 0), new Point(10, 0), new Point(0, 10))).toBe(50);
   expect(Utils.areaOfTriangle(new Point(-5, -5), new Point(5, -5), new Point(0, 5))).toBe(50);

package/test/properties/entityProperties.test.js

@@ -0,0 +1,132 @@
+import { Core } from '../../core/core/core.js';
+import { EntityProperties } from '../../core/properties/entityProperties.js';
+import { Property } from '../../core/properties/property.js';
+import { Entity } from '../../core/entities/entity.js';
+
+// initialise core
+new Core();
+
+/**
+ * Minimal entity-like object for isolated EntityProperties tests.
+ * @return {Object} plain object with layer and lineWidth fields
+ */
+function makeTarget() {
+  return { layer: '0', lineWidth: 1 };
+}
+
+describe('EntityProperties.add / get', () => {
+  test('get returns value after add', () => {
+    const ep = new EntityProperties(makeTarget());
+    ep.add('layer', { type: Property.Type.LIST, value: '0' });
+    expect(ep.get('layer')).toBe('0');
+  });
+
+  test('get returns undefined for unknown property', () => {
+    const ep = new EntityProperties(makeTarget());
+    expect(ep.get('unknown')).toBeUndefined();
+  });
+});
+
+describe('EntityProperties.set', () => {
+  test('updates value in _store, readable via get', () => {
+    const target = makeTarget();
+    const ep = new EntityProperties(target);
+    ep.add('layer', { type: Property.Type.LIST, value: target.layer });
+    ep.set('layer', 'WALLS');
+    expect(ep.get('layer')).toBe('WALLS');
+  });
+
+  test('no-op for unknown property', () => {
+    const target = makeTarget();
+    const ep = new EntityProperties(target);
+    expect(() => ep.set('unknown', 'X')).not.toThrow();
+  });
+
+  test('no-op when property is readOnly', () => {
+    const target = makeTarget();
+    const ep = new EntityProperties(target);
+    ep.add('type', { type: Property.Type.LABEL, value: 'Line', readOnly: true });
+    ep.set('type', 'Circle');
+    expect(ep.get('type')).toBe('Line');
+  });
+});
+
+describe('EntityProperties.has', () => {
+  test('returns true for registered property', () => {
+    const ep = new EntityProperties(makeTarget());
+    ep.add('layer', { type: Property.Type.LIST, value: '0' });
+    expect(ep.has('layer')).toBe(true);
+  });
+
+  test('returns false for unregistered property', () => {
+    const ep = new EntityProperties(makeTarget());
+    expect(ep.has('layer')).toBe(false);
+  });
+});
+
+describe('EntityProperties.remove', () => {
+  test('removes a registered property', () => {
+    const ep = new EntityProperties(makeTarget());
+    ep.add('layer', { type: Property.Type.LIST, value: '0' });
+    ep.remove('layer');
+    expect(ep.has('layer')).toBe(false);
+  });
+});
+
+describe('EntityProperties.list', () => {
+  test('returns names of visible properties in registration order', () => {
+    const ep = new EntityProperties(makeTarget());
+    ep.add('layer', { type: Property.Type.LIST, value: '0' });
+    ep.add('lineWidth', { type: Property.Type.NUMBER, value: 1 });
+    ep.add('hidden', { type: Property.Type.LABEL, value: 'x', visible: false });
+    expect(ep.list()).toEqual(['layer', 'lineWidth']);
+  });
+});
+
+describe('EntityProperties.definition', () => {
+  test('returns the Property descriptor', () => {
+    const ep = new EntityProperties(makeTarget());
+    ep.add('layer', { type: Property.Type.LIST, value: '0', dxfCode: 8 });
+    const def = ep.definition('layer');
+    expect(def).toBeInstanceOf(Property);
+    expect(def.type).toBe(Property.Type.LIST);
+    expect(def.dxfCode).toBe(8);
+  });
+
+  test('returns undefined for unknown property', () => {
+    const ep = new EntityProperties(makeTarget());
+    expect(ep.definition('unknown')).toBeUndefined();
+  });
+});
+
+describe('Entity.properties integration', () => {
+  test('entity has properties registered for layer, lineType, lineWidth, colour', () => {
+    const e = new Entity();
+    expect(e.properties.has('layer')).toBe(true);
+    expect(e.properties.has('lineType')).toBe(true);
+    expect(e.properties.has('lineWidth')).toBe(true);
+    expect(e.properties.has('colour')).toBe(true);
+  });
+
+  test('properties values match entity fields at construction', () => {
+    const e = new Entity({ layer: 'TEST', lineWidth: 5 });
+    expect(e.properties.get('layer')).toBe('TEST');
+    expect(e.properties.get('lineWidth')).toBe(5);
+  });
+
+  test('set updates _store value, readable via get', () => {
+    const e = new Entity();
+    e.properties.set('layer', 'DOORS');
+    expect(e.properties.get('layer')).toBe('DOORS');
+  });
+
+  test('list returns the 4 registered property names', () => {
+    const e = new Entity();
+    expect(e.properties.list()).toEqual(['layer', 'lineType', 'lineWidth', 'colour']);
+  });
+
+  test('properties is non-enumerable on entity', () => {
+    const e = new Entity();
+    expect(Object.keys(e)).not.toContain('properties');
+  });
+});

package/test/properties/property.test.js

@@ -11,3 +11,56 @@ test('Test property.loadValue', () => {
   flags.setFlagValue(4);
   expect(Property.loadValue([flags], 3)).toBe(4);
 });
+
+describe('Property.Type', () => {
+  test('has all expected members', () => {
+    expect(Property.Type.NUMBER).toBe('NUMBER');
+    expect(Property.Type.STRING).toBe('STRING');
+    expect(Property.Type.BOOLEAN).toBe('BOOLEAN');
+    expect(Property.Type.LIST).toBe('LIST');
+    expect(Property.Type.COLOUR).toBe('COLOUR');
+    expect(Property.Type.LABEL).toBe('LABEL');
+    expect(Property.Type.ENTITIES).toBe('ENTITIES');
+  });
+
+  test('has exactly 7 members', () => {
+    expect(Object.keys(Property.Type)).toHaveLength(7);
+  });
+});
+
+describe('Property instance', () => {
+  test('stores type and value', () => {
+    const p = new Property({ type: Property.Type.NUMBER, value: 42 });
+    expect(p.type).toBe(Property.Type.NUMBER);
+    expect(p.value).toBe(42);
+  });
+
+  test('defaults readOnly to false and visible to true', () => {
+    const p = new Property({ type: Property.Type.STRING, value: 'hello' });
+    expect(p.readOnly).toBe(false);
+    expect(p.visible).toBe(true);
+  });
+
+  test('set value updates when not readOnly', () => {
+    const p = new Property({ type: Property.Type.NUMBER, value: 1 });
+    p.value = 99;
+    expect(p.value).toBe(99);
+  });
+
+  test('set value is ignored when readOnly', () => {
+    const p = new Property({ type: Property.Type.LABEL, value: 'fixed', readOnly: true });
+    p.value = 'changed';
+    expect(p.value).toBe('fixed');
+  });
+
+  test('stores dxfCode', () => {
+    const p = new Property({ type: Property.Type.LIST, value: '0', dxfCode: 8 });
+    expect(p.dxfCode).toBe(8);
+  });
+
+  test('no-arg constructor produces undefined fields without throwing', () => {
+    const p = new Property();
+    expect(p.type).toBeUndefined();
+    expect(p.value).toBeUndefined();
+  });
+});

package/test/properties/propertyManager.test.js

@@ -49,7 +49,7 @@ test('Test propertyManager.setItemProperties', () => {
 
   let text = DesignCore.Scene.entities.get(2);
   expect(text.type).toBe('Text');
-  expect(text.string).toBe(string);
+  expect(text.getProperty('string')).toBe(string);
 
   // try and set a non-existent property
   propertiesManager.setItemProperties('faux-prop', string);
@@ -61,11 +61,11 @@ test('Test propertyManager.setItemProperties', () => {
   // Select the circle element
   DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(1);
   // get the current radius
-  const radius = DesignCore.Scene.entities.get(1).radius;
+  const radius = DesignCore.Scene.entities.get(1).getProperty('radius');
   // try and set an incorrect value
   propertiesManager.setItemProperties('radius', string);
   const circle = DesignCore.Scene.entities.get(1);
-  expect(circle.radius).toBe(radius);
+  expect(circle.getProperty('radius')).toBe(radius);
 });
 
 test('Test propertyManager.getItemProperties', () => {