@design-core/core 0.0.6 → 0.0.7

package/test/lib/constants.test.js

@@ -7,3 +7,30 @@ test('Constants.Tolerance.EPSILON is 1e-10', () => {
 test('Constants.Precision.DECIMALPLACES is 5', () => {
   expect(Constants.Precision.DECIMALPLACES).toBe(5);
 });
+
+describe('Constants.PageSizes', () => {
+  test('A4 portrait is 595 × 842', () => {
+    expect(Constants.PageSizes['A4']).toEqual({ width: 595, height: 842 });
+  });
+
+  test('A3 portrait is 842 × 1191', () => {
+    expect(Constants.PageSizes['A3']).toEqual({ width: 842, height: 1191 });
+  });
+
+  test('Letter portrait is 612 × 792', () => {
+    expect(Constants.PageSizes['Letter']).toEqual({ width: 612, height: 792 });
+  });
+
+  test('all sizes have portrait orientation (width < height)', () => {
+    for (const [, size] of Object.entries(Constants.PageSizes)) {
+      expect(size.width).toBeLessThan(size.height);
+    }
+  });
+
+  test('contains all expected ISO and ANSI sizes', () => {
+    const expected = ['A4', 'A3', 'A2', 'A1', 'A0', 'Letter', 'Legal', 'Tabloid', 'ANSI C', 'ANSI D', 'ANSI E'];
+    for (const name of expected) {
+      expect(Constants.PageSizes).toHaveProperty(name);
+    }
+  });
+});

package/test/lib/entityManager.test.js

@@ -23,7 +23,7 @@ describe('EntityManager', () => {
     expect(mgr.count()).toBe(1);
     const ent = mgr.get(0);
     expect(ent).toBeInstanceOf(Line);
-    expect(ent.layer).toBe(DesignCore.LayerManager.getCstyle());
+    expect(ent.getProperty('layer')).toBe(DesignCore.LayerManager.getCstyle());
   });
 
   test('add/get/count manage entities correctly', () => {
@@ -62,7 +62,7 @@ describe('EntityManager', () => {
     const mgr = DesignCore.Scene.entities;
     const line = new Line({ points: [new Point(0, 0), new Point(1, 0)] });
     mgr.add(line);
-    const handle = line.handle;
+    const handle = line.getProperty('handle');
     expect(DesignCore.HandleManager.usedHandles.has(handle)).toBe(true);
     mgr.remove(0);
     expect(DesignCore.HandleManager.usedHandles.has(handle)).toBe(false);
@@ -72,7 +72,7 @@ describe('EntityManager', () => {
     const mgr = DesignCore.Scene.entities;
     const line = new Line({ points: [new Point(0, 0), new Point(1, 0)] });
     mgr.add(line);
-    const handle = line.handle;
+    const handle = line.getProperty('handle');
     const sizeAfterAdd = DesignCore.HandleManager.usedHandles.size;
 
     mgr.remove(0);
@@ -82,7 +82,7 @@ describe('EntityManager', () => {
 
     // Re-add the same entity (simulates undo of a delete)
     mgr.add(line);
-    expect(line.handle).toBe(handle);
+    expect(line.getProperty('handle')).toBe(handle);
     expect(DesignCore.HandleManager.usedHandles.has(handle)).toBe(true);
     // Size must return to what it was after the first add, not grow by one.
     // If checkHandle silently re-inserted without the prior releaseHandle, the

package/test/lib/inputManager.test.js

@@ -237,6 +237,38 @@ test('onCommandButton with no active command - starts command', () => {
   inputManager.reset();
 });
 
+// ─── startCommand — selection clearing ───────────────────────────────────────
+
+test('starting an entity command from idle clears the selection', () => {
+  inputManager.reset();
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.selectionManager.addToSelectionSet(0);
+  expect(core.scene.selectionManager.selectionSet.selectionSet.length).toBe(1);
+
+  inputManager.onCommand('L');
+  expect(core.scene.selectionManager.selectionSet.selectionSet.length).toBe(0);
+  inputManager.reset();
+});
+
+test('starting a tool command from idle preserves the selection', () => {
+  inputManager.reset();
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.selectionManager.addToSelectionSet(0);
+  expect(core.scene.selectionManager.selectionSet.selectionSet.length).toBe(1);
+
+  // Prevent Erase.execute() from running so we can isolate startCommand's own behaviour.
+  // Without this, Erase synchronously calls executeCommand() → reset() in the
+  // preselection branch before our assertion can fire.
+  const Erase = DesignCore.CommandManager.createNew('Erase').constructor;
+  jest.spyOn(Erase.prototype, 'execute').mockImplementation(() => {});
+
+  inputManager.onCommand('E');
+  expect(core.scene.selectionManager.selectionSet.selectionSet.length).toBe(1);
+
+  jest.restoreAllMocks();
+  inputManager.reset();
+});
+
 // ─── onCommand - command shortcut while non-accepting prompt is active ─────────
 
 test('onCommand with valid shortcut while POINT prompt active - switches command without notifying', () => {
@@ -509,12 +541,12 @@ test('actionCommand with a Tool as activeCommand - calls its action method', ()
 test('executeCommand with an entity item - adds item to scene then resets', () => {
   inputManager.reset();
   inputManager.onCommand('Line');
-  const addItemSpy = jest.spyOn(core.scene, 'addItem').mockReturnValue(1);
+  const commitEntitySpy = jest.spyOn(core.scene, 'commitEntity').mockReturnValue(1);
   const line = new Line();
   inputManager.executeCommand(line);
-  expect(addItemSpy).toHaveBeenCalled();
+  expect(commitEntitySpy).toHaveBeenCalled();
   expect(inputManager.activeCommand).toBeUndefined();
-  addItemSpy.mockRestore();
+  commitEntitySpy.mockRestore();
 });
 
 // ─── requestInput validation ──────────────────────────────────────────────────
@@ -670,6 +702,9 @@ test('highlightEntityUnderMouse returns true when entity found and no active com
   const mockLine = new Line();
   jest.spyOn(core.scene.entities, 'get').mockReturnValue(mockLine);
   expect(inputManager.highlightEntityUnderMouse()).toBe(true);
+  // entity should go into hoverEntities, not previewEntities
+  expect(core.scene.hoverEntities.count()).toBe(1);
+  expect(core.scene.previewEntities.count()).toBe(0);
   jest.restoreAllMocks();
 });
 
@@ -728,22 +763,22 @@ test('actionCommand with undefined item and non-Tool activeCommand - does nothin
 test('actionCommand returns the item index when adding an entity', () => {
   inputManager.reset();
   inputManager.onCommand('Line');
-  const addItemSpy = jest.spyOn(core.scene, 'addItem').mockReturnValue(42);
+  const commitEntitySpy = jest.spyOn(core.scene, 'commitEntity').mockReturnValue(42);
   const line = new Line();
   const index = inputManager.actionCommand(line);
   expect(index).toBe(42);
-  addItemSpy.mockRestore();
+  commitEntitySpy.mockRestore();
   inputManager.reset();
 });
 
-test('actionCommand passes index parameter to addItem', () => {
+test('actionCommand passes index parameter to commitEntity', () => {
   inputManager.reset();
   inputManager.onCommand('Line');
-  const addItemSpy = jest.spyOn(core.scene, 'addItem').mockReturnValue(5);
+  const commitEntitySpy = jest.spyOn(core.scene, 'commitEntity').mockReturnValue(5);
   const line = new Line();
   inputManager.actionCommand(line, 5);
-  expect(addItemSpy).toHaveBeenCalledWith(line.type, expect.any(Object), 5);
-  addItemSpy.mockRestore();
+  expect(commitEntitySpy).toHaveBeenCalledWith(line, 5);
+  commitEntitySpy.mockRestore();
   inputManager.reset();
 });
 
@@ -785,9 +820,9 @@ test('mouseMoved calls activeCommand.preview when command is active and no entit
   inputManager.reset();
 });
 
-test('mouseMoved does not call preview when entity is being selected', () => {
+test('mouseMoved calls preview even when entity is being highlighted', () => {
   inputManager.reset();
-  // with SINGLESELECTION prompt, highlightEntityUnderMouse will run and return true (selecting = true)
+  // preview() is always called for the active command, including when an entity is highlighted
   inputManager.activeCommand = new Line();
   const po = new PromptOptions('', [Input.Type.SINGLESELECTION]);
   inputManager.requestInput(po);
@@ -796,7 +831,7 @@ test('mouseMoved does not call preview when entity is being selected', () => {
   jest.spyOn(core.scene.entities, 'get').mockReturnValue(new Line());
   core.mouse.buttonOneDown = false;
   inputManager.mouseMoved();
-  expect(previewSpy).not.toHaveBeenCalled();
+  expect(previewSpy).toHaveBeenCalled();
   jest.restoreAllMocks();
   po.cancel();
   inputManager.reset();
@@ -904,6 +939,7 @@ test('highlightEntityUnderMouse returns true with SINGLESELECTION prompt and ent
   jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(0);
   jest.spyOn(core.scene.entities, 'get').mockReturnValue(new Line());
   expect(inputManager.highlightEntityUnderMouse()).toBe(true);
+  expect(core.scene.hoverEntities.count()).toBe(1);
   jest.restoreAllMocks();
   po.cancel();
   inputManager.reset();
@@ -917,6 +953,7 @@ test('highlightEntityUnderMouse returns true with SELECTIONSET prompt and entity
   jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(0);
   jest.spyOn(core.scene.entities, 'get').mockReturnValue(new Line());
   expect(inputManager.highlightEntityUnderMouse()).toBe(true);
+  expect(core.scene.hoverEntities.count()).toBe(1);
   jest.restoreAllMocks();
   po.cancel();
   inputManager.reset();
@@ -1002,16 +1039,14 @@ test('reset sets inputPoint to null', () => {
 
 // ─── mouseMoved – auxiliaryEntities cleared at start ─────────────────────────
 
-test('mouseMoved clears auxiliaryEntities and tempEntities at the start', () => {
-  // pre-populate both collections
+test('mouseMoved clears auxiliaryEntities, previewEntities and hoverEntities at the start', () => {
+  // pre-populate all three collections
   const addTrackLineSpy = jest.spyOn(inputManager.snapping, 'addTrackingLine').mockImplementation(() => {});
   DesignCore.Scene.auxiliaryEntities.add({ draw: () => {} });
-  DesignCore.Scene.tempEntities.add({ draw: () => {} });
+  DesignCore.Scene.previewEntities.add({ draw: () => {} });
+  DesignCore.Scene.hoverEntities.add({ draw: () => {} });
   inputManager.mouseMoved();
-  // both should have been cleared (count re-started from 0 before any new adds)
-  // After mouseMoved the tracking line may or may not have been re-added, but the
-  // clear happened — verify by checking they were empty after the initial clear
-  // (we can confirm this indirectly: no crash and spies didn't see stale data)
+  // all should have been cleared — confirm no crash and stale data is gone
   expect(() => inputManager.mouseMoved()).not.toThrow();
   addTrackLineSpy.mockRestore();
 });
@@ -1145,3 +1180,29 @@ test('highlightEntityUnderMouse returns false when buttonThreeDown is true', ()
   expect(inputManager.highlightEntityUnderMouse()).toBe(false);
   core.mouse.buttonThreeDown = false;
 });
+
+test('refreshPreview clears hoverEntities in addition to previewEntities and auxiliaryEntities', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+
+  // Simulate a stale hover glow left by the previous mouseMoved()
+  DesignCore.Scene.hoverEntities.add(core.scene.entities.get(0));
+  expect(DesignCore.Scene.hoverEntities.count()).toBe(1);
+
+  // Attach a minimal active command so refreshPreview doesn't bail early
+  inputManager.activeCommand = { preview: () => {} };
+  inputManager.refreshPreview();
+
+  expect(DesignCore.Scene.hoverEntities.count()).toBe(0);
+  expect(DesignCore.Scene.previewEntities.count()).toBe(0);
+  expect(DesignCore.Scene.auxiliaryEntities.count()).toBe(0);
+});
+
+test('refreshPreview returns early without clearing when there is no active command', () => {
+  DesignCore.Scene.hoverEntities.add({ draw: () => {} });
+  inputManager.activeCommand = undefined;
+  inputManager.refreshPreview();
+  // hoverEntities should be untouched — no active command means no refresh
+  expect(DesignCore.Scene.hoverEntities.count()).toBe(1);
+  DesignCore.Scene.hoverEntities.clear();
+});

package/test/lib/intersect.test.js

@@ -539,3 +539,86 @@ test('intersectPolylinePolyline - two full circles outside each other, no inters
   expect(result.status).toBe('None');
   expect(result.points.length).toBe(0);
 });
+
+// --- isInsidePolyline ---
+// Helper: axis-aligned rectangle as a closed polyline
+/**
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} x2
+ * @param {number} y2
+ * @return {Array}
+ */
+function makeRect(x1, y1, x2, y2) {
+  return [
+    new Point(x1, y1), new Point(x2, y1),
+    new Point(x2, y2), new Point(x1, y2),
+    new Point(x1, y1),
+  ];
+}
+
+// Helper: full circle as two bulge-encoded semicircles, centre (cx,cy) radius r
+/**
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} r
+ * @return {Array}
+ */
+function makeCircle(cx, cy, r) {
+  return [
+    new Point(cx, cy + r, 1),
+    new Point(cx, cy - r, 1),
+    new Point(cx, cy + r),
+  ];
+}
+
+test('isInsidePolyline - point inside a rectangle', () => {
+  const rect = makeRect(0, 0, 10, 10);
+  expect(Intersection.isInsidePolyline(5, 5, [rect], 20)).toBe(true);
+});
+
+test('isInsidePolyline - point outside a rectangle', () => {
+  const rect = makeRect(0, 0, 10, 10);
+  expect(Intersection.isInsidePolyline(15, 5, [rect], 20)).toBe(false);
+});
+
+test('isInsidePolyline - point on the boundary edge does not throw', () => {
+  const rect = makeRect(0, 0, 10, 10);
+  expect(() => Intersection.isInsidePolyline(0, 5, [rect], 20)).not.toThrow();
+});
+
+test('isInsidePolyline - point inside a circle boundary', () => {
+  const circle = makeCircle(0, 0, 10);
+  expect(Intersection.isInsidePolyline(0, 0, [circle], 25)).toBe(true);
+});
+
+test('isInsidePolyline - point outside a circle boundary', () => {
+  const circle = makeCircle(0, 0, 10);
+  expect(Intersection.isInsidePolyline(15, 0, [circle], 25)).toBe(false);
+});
+
+test('isInsidePolyline - ray at exact top of circle is handled correctly by rayEps', () => {
+  // Without the rayEps nudge a horizontal ray fired from y=10 would be tangent
+  // to the top of the circle and produce a wrong crossing count.
+  // The point (0,10) is on the boundary; the method must not return true.
+  const circle = makeCircle(0, 0, 10);
+  expect(Intersection.isInsidePolyline(0, 10, [circle], 25)).toBe(false);
+});
+
+test('isInsidePolyline - multiple boundaries, point inside inner boundary is outside under even-odd', () => {
+  // Outer 20×20 rect + inner 6×6 rect acting as a hole.
+  // A point inside the inner rect crosses both boundaries (count=2, even) → outside.
+  const outer = makeRect(0, 0, 20, 20);
+  const inner = makeRect(7, 7, 13, 13);
+  expect(Intersection.isInsidePolyline(10, 10, [outer, inner], 30)).toBe(false);
+});
+
+test('isInsidePolyline - multiple boundaries, point between outer and inner is inside', () => {
+  const outer = makeRect(0, 0, 20, 20);
+  const inner = makeRect(7, 7, 13, 13);
+  expect(Intersection.isInsidePolyline(2, 2, [outer, inner], 30)).toBe(true);
+});
+
+test('isInsidePolyline - empty boundaries returns false', () => {
+  expect(Intersection.isInsidePolyline(5, 5, [], 20)).toBe(false);
+});

package/test/lib/plotOptions.test.js

@@ -0,0 +1,179 @@
+import { PlotOptions } from '../../core/lib/plotOptions.js';
+import { RendererBase } from '../../core/lib/renderers/rendererBase.js';
+
+// ─── Constructor ─────────────────────────────────────────────────────────────
+
+test('constructor stores pageWidth and pageHeight', () => {
+  const po = new PlotOptions(595, 842);
+  expect(po.pageWidth).toBe(595);
+  expect(po.pageHeight).toBe(842);
+});
+
+test('constructor sets default plotScale to null', () => {
+  const po = new PlotOptions(595, 842);
+  expect(po.plotScale).toBeNull();
+});
+
+test('constructor sets default plotArea to PlotOptions.Area.EXTENTS', () => {
+  const po = new PlotOptions(595, 842);
+  expect(po.plotArea).toBe(PlotOptions.Area.EXTENTS);
+});
+
+test('constructor sets default style to RendererBase.Styles.NONE', () => {
+  const po = new PlotOptions(595, 842);
+  expect(po.style).toBe(RendererBase.Styles.NONE);
+});
+
+test('constructor sets default fileType to pdf', () => {
+  const po = new PlotOptions(595, 842);
+  expect(po.fileType).toBe('pdf');
+});
+
+test('constructor throws when pageWidth is missing', () => {
+  expect(() => new PlotOptions(undefined, 842)).toThrow('pageWidth');
+});
+
+test('constructor throws when pageHeight is missing', () => {
+  expect(() => new PlotOptions(595, undefined)).toThrow('pageHeight');
+});
+
+test('constructor throws when pageWidth is zero', () => {
+  expect(() => new PlotOptions(0, 842)).toThrow('pageWidth');
+});
+
+test('constructor throws when pageWidth is negative', () => {
+  expect(() => new PlotOptions(-1, 842)).toThrow('pageWidth');
+});
+
+test('constructor throws when pageHeight is zero', () => {
+  expect(() => new PlotOptions(595, 0)).toThrow('pageHeight');
+});
+
+test('constructor throws when pageWidth is a string', () => {
+  expect(() => new PlotOptions('595', 842)).toThrow('pageWidth');
+});
+
+// ─── static Area ─────────────────────────────────────────────────────────────
+
+test('PlotOptions.Area.EXTENTS is defined', () => {
+  expect(PlotOptions.Area.EXTENTS).toBeDefined();
+});
+
+test('PlotOptions.Area.DISPLAY is defined', () => {
+  expect(PlotOptions.Area.DISPLAY).toBeDefined();
+});
+
+test('PlotOptions.Area.EXTENTS and DISPLAY are distinct values', () => {
+  expect(PlotOptions.Area.EXTENTS).not.toBe(PlotOptions.Area.DISPLAY);
+});
+
+// ─── setOption — pageWidth / pageHeight ──────────────────────────────────────
+
+test('setOption updates pageWidth to a valid value', () => {
+  const po = new PlotOptions(595, 842);
+  po.setOption('pageWidth', 420);
+  expect(po.pageWidth).toBe(420);
+});
+
+test('setOption throws for non-positive pageWidth', () => {
+  const po = new PlotOptions(595, 842);
+  expect(() => po.setOption('pageWidth', 0)).toThrow('pageWidth');
+});
+
+test('setOption throws for non-numeric pageHeight', () => {
+  const po = new PlotOptions(595, 842);
+  expect(() => po.setOption('pageHeight', 'tall')).toThrow('pageHeight');
+});
+
+// ─── setOption — plotScale ────────────────────────────────────────────────────
+
+test('setOption accepts null for plotScale', () => {
+  const po = new PlotOptions(595, 842);
+  po.setOption('plotScale', null);
+  expect(po.plotScale).toBeNull();
+});
+
+test('setOption accepts a positive number for plotScale', () => {
+  const po = new PlotOptions(595, 842);
+  po.setOption('plotScale', 0.5);
+  expect(po.plotScale).toBe(0.5);
+});
+
+test('setOption throws for zero plotScale', () => {
+  const po = new PlotOptions(595, 842);
+  expect(() => po.setOption('plotScale', 0)).toThrow('plotScale');
+});
+
+test('setOption throws for negative plotScale', () => {
+  const po = new PlotOptions(595, 842);
+  expect(() => po.setOption('plotScale', -1)).toThrow('plotScale');
+});
+
+test('setOption throws for non-null non-number plotScale', () => {
+  const po = new PlotOptions(595, 842);
+  expect(() => po.setOption('plotScale', 'fit')).toThrow('plotScale');
+});
+
+// ─── setOption — plotArea ─────────────────────────────────────────────────────
+
+test('setOption accepts PlotOptions.Area.EXTENTS for plotArea', () => {
+  const po = new PlotOptions(595, 842);
+  po.setOption('plotArea', PlotOptions.Area.EXTENTS);
+  expect(po.plotArea).toBe(PlotOptions.Area.EXTENTS);
+});
+
+test('setOption accepts PlotOptions.Area.DISPLAY for plotArea', () => {
+  const po = new PlotOptions(595, 842);
+  po.setOption('plotArea', PlotOptions.Area.DISPLAY);
+  expect(po.plotArea).toBe(PlotOptions.Area.DISPLAY);
+});
+
+test('setOption throws for an unknown plotArea value', () => {
+  const po = new PlotOptions(595, 842);
+  expect(() => po.setOption('plotArea', 'Window')).toThrow('plotArea');
+});
+
+// ─── setOption — style ────────────────────────────────────────────────────────
+
+test('setOption accepts RendererBase.Styles.NONE for style', () => {
+  const po = new PlotOptions(595, 842);
+  po.setOption('style', RendererBase.Styles.NONE);
+  expect(po.style).toBe(RendererBase.Styles.NONE);
+});
+
+test('setOption accepts RendererBase.Styles.MONOCHROME for style', () => {
+  const po = new PlotOptions(595, 842);
+  po.setOption('style', RendererBase.Styles.MONOCHROME);
+  expect(po.style).toBe(RendererBase.Styles.MONOCHROME);
+});
+
+test('setOption throws when style is not a function', () => {
+  const po = new PlotOptions(595, 842);
+  expect(() => po.setOption('style', 'monochrome')).toThrow('style');
+});
+
+// ─── setOption — fileType ─────────────────────────────────────────────────────
+
+test('setOption accepts pdf for fileType', () => {
+  const po = new PlotOptions(595, 842);
+  po.setOption('fileType', 'pdf');
+  expect(po.fileType).toBe('pdf');
+});
+
+test('setOption accepts svg for fileType', () => {
+  const po = new PlotOptions(595, 842);
+  po.setOption('fileType', 'svg');
+  expect(po.fileType).toBe('svg');
+});
+
+test('setOption throws for an unknown fileType', () => {
+  const po = new PlotOptions(595, 842);
+  expect(() => po.setOption('fileType', 'png')).toThrow('fileType');
+});
+
+// ─── setOption — unknown key ──────────────────────────────────────────────────
+
+test('setOption throws for an unknown key', () => {
+  const po = new PlotOptions(595, 842);
+  expect(() => po.setOption('colour', 'red')).toThrow('unknown option \'colour\'');
+});

package/test/lib/rubberBand.test.js

@@ -0,0 +1,84 @@
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
+import { RubberBand } from '../../core/lib/auxiliary/rubberBand.js';
+import { jest } from '@jest/globals';
+
+new Core();
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+/**
+ * Build a mock renderer that records calls to setColour, setLineWidth, setDash, drawShape.
+ * @return {object} mock renderer
+ */
+function makeRenderer() {
+  return {
+    setColour: jest.fn(),
+    setLineWidth: jest.fn(),
+    setDash: jest.fn(),
+    drawShape: jest.fn(),
+  };
+}
+
+// ─── constructor ─────────────────────────────────────────────────────────────
+
+test('RubberBand constructor stores points and defaults', () => {
+  const pts = [new Point(0, 0), new Point(10, 0)];
+  const rb = new RubberBand(pts);
+
+  expect(rb.points).toBe(pts);
+  expect(rb.lineWidth).toBe(1.5);
+  expect(rb.dashPattern).toEqual([12, 6]);
+});
+
+// ─── draw – guard ─────────────────────────────────────────────────────────────
+
+test('RubberBand.draw does nothing when points.length < 2', () => {
+  const rb = new RubberBand([new Point(0, 0)]);
+  const renderer = makeRenderer();
+  expect(() => rb.draw(renderer, 1)).not.toThrow();
+  expect(renderer.drawShape).not.toHaveBeenCalled();
+});
+
+test('RubberBand.draw does nothing when points is empty', () => {
+  const rb = new RubberBand([]);
+  const renderer = makeRenderer();
+  expect(() => rb.draw(renderer, 1)).not.toThrow();
+  expect(renderer.drawShape).not.toHaveBeenCalled();
+});
+
+// ─── draw ─────────────────────────────────────────────────────────────────────
+
+test('RubberBand.draw with 2 points calls drawShape with the points array', () => {
+  const pts = [new Point(0, 0), new Point(10, 5)];
+  const rb = new RubberBand(pts);
+  const renderer = makeRenderer();
+
+  rb.draw(renderer, 1);
+
+  expect(renderer.setColour).toHaveBeenCalledTimes(1);
+  expect(renderer.setDash).toHaveBeenCalledTimes(1);
+  expect(renderer.drawShape).toHaveBeenCalledWith(pts);
+  expect(renderer.drawShape).toHaveBeenCalledTimes(1);
+});
+
+test('RubberBand.draw scales lineWidth and dashPattern by 1/scale', () => {
+  const scale = 2;
+  const rb = new RubberBand([new Point(0, 0), new Point(10, 0)]);
+  const renderer = makeRenderer();
+
+  rb.draw(renderer, scale);
+
+  expect(renderer.setLineWidth).toHaveBeenCalledWith(rb.lineWidth / scale);
+  expect(renderer.setDash).toHaveBeenCalledWith([12 / scale, 6 / scale], 0);
+});
+
+test('RubberBand.draw with 3 points passes all 3 points to drawShape', () => {
+  const pts = [new Point(0, 0), new Point(5, 5), new Point(10, 0)];
+  const rb = new RubberBand(pts);
+  const renderer = makeRenderer();
+
+  rb.draw(renderer, 1);
+
+  expect(renderer.drawShape).toHaveBeenCalledWith(pts);
+});

package/test/lib/settings.test.js

@@ -40,8 +40,7 @@ test('polar and ortho are mutually exclusive', () => {
 test('Settings constructor - colour defaults', () => {
   const fresh = new (settings.constructor)();
   expect(fresh.canvasbackgroundcolour).toEqual({ r: 30, g: 30, b: 30 });
-  expect(fresh.selecteditemscolour).toEqual({ r: 0, g: 255, b: 0 });
-  expect(fresh.snaptrackingcolour).toEqual({ r: 55, g: 180, b: 75 });
+  expect(fresh.accentcolour).toEqual({ r: 55, g: 180, b: 75 });
   expect(fresh.gridcolour).toEqual({ r: 119, g: 118, b: 123 });
   expect(fresh.selectionWindow).toEqual({ r: 0, g: 255, b: 0 });
   expect(fresh.crossingWindow).toEqual({ r: 0, g: 0, b: 255 });
@@ -82,9 +81,9 @@ test('setSetting with false value does not trigger polar/ortho exclusion', () =>
 });
 
 test('setSetting updates arbitrary colour settings', () => {
-  settings.setSetting('snaptrackingcolour', { r: 1, g: 2, b: 3 });
-  expect(settings.snaptrackingcolour).toEqual({ r: 1, g: 2, b: 3 });
-  settings.setSetting('snaptrackingcolour', { r: 55, g: 180, b: 75 });
+  settings.setSetting('accentcolour', { r: 1, g: 2, b: 3 });
+  expect(settings.accentcolour).toEqual({ r: 1, g: 2, b: 3 });
+  settings.setSetting('accentcolour', { r: 55, g: 180, b: 75 });
 });
 
 test('setSetting updates polarangle', () => {
@@ -116,7 +115,7 @@ test('getSetting returns current value after setSetting', () => {
 });
 
 test('getSetting returns correct type for colour objects', () => {
-  const colour = settings.getSetting('snaptrackingcolour');
+  const colour = settings.getSetting('accentcolour');
   expect(colour).toHaveProperty('r');
   expect(colour).toHaveProperty('g');
   expect(colour).toHaveProperty('b');