@design-core/core 0.0.1 → 0.0.3

package/test/lib/logging.test.js

@@ -1,4 +1,4 @@
-import {Logging} from '../../core/lib/logging';
+import { Logging } from '../../core/lib/logging';
 
 // mock console.log for tests
 const msg = 'testMessage';

package/test/lib/matrix.test.js

@@ -1,4 +1,4 @@
-import {Matrix} from '../../core/lib/matrix';
+import { Matrix } from '../../core/lib/matrix';
 
 
 test('Test Matrix.scale and Matrix.getScale', () => {

package/test/lib/mouse.test.js

@@ -1,5 +1,328 @@
-// import {Point} from '../../entities/point.js';
-// import {Utils} from '../../lib/utils.js';
-// import {Mouse} from '../../lib/mouse';
+import { Core } from '../../core/core/core.js';
+import { DesignCore } from '../../core/designCore.js';
+import { Point } from '../../core/entities/point.js';
+import { Matrix } from '../../core/lib/matrix.js';
+import { expect, jest } from '@jest/globals';
 
-test.todo('Test mouse');
+const core = new Core();
+const mouse = core.mouse;
+
+test('Test Mouse constructor defaults', () => {
+  expect(mouse.x).toBe(0);
+  expect(mouse.y).toBe(0);
+  expect(mouse.buttonOneDown).toBe(false);
+  expect(mouse.buttonTwoDown).toBe(false);
+  expect(mouse.buttonThreeDown).toBe(false);
+  expect(mouse.mouseDownCanvasPoint).toBeDefined();
+  expect(mouse.lastClick).toBe(0);
+  expect(mouse.lastButton).toBe(0);
+});
+
+test('Test Mouse.pointOnCanvas', () => {
+  mouse.x = 150;
+  mouse.y = 200;
+  const pt = mouse.pointOnCanvas();
+  expect(pt).toBeInstanceOf(Point);
+  expect(pt.x).toBe(150);
+  expect(pt.y).toBe(200);
+});
+
+test('Test Mouse.pointOnScene returns Point', () => {
+  mouse.x = 100;
+  mouse.y = 50;
+  const pt = mouse.pointOnScene();
+  expect(pt).toBeInstanceOf(Point);
+  expect(typeof pt.x).toBe('number');
+  expect(typeof pt.y).toBe('number');
+});
+
+test('Test Mouse.transformToScene and transformToCanvas are inverse', () => {
+  core.canvas.matrix = new Matrix();
+  core.canvas.height = 600;
+
+  const scenePoint = new Point(250, 300);
+  const canvasPoint = mouse.transformToCanvas(scenePoint);
+  const roundTrip = mouse.transformToScene(canvasPoint);
+
+  expect(roundTrip.x).toBeCloseTo(scenePoint.x, 5);
+  expect(roundTrip.y).toBeCloseTo(scenePoint.y, 5);
+});
+
+test('Test Mouse.positionString format', () => {
+  mouse.x = 0;
+  mouse.y = 0;
+  const str = mouse.positionString();
+  expect(typeof str).toBe('string');
+  expect(str).toMatch(/X: .+ Y: .+/);
+});
+
+test('Test Mouse.positionString returns empty string when buttonOneDown', () => {
+  mouse.lastClick = 0;
+  mouse.mouseDown(0);
+  expect(mouse.positionString()).toBe('');
+  mouse.mouseUp(0);
+});
+
+test('Test Mouse.positionString returns empty string when buttonTwoDown', () => {
+  mouse.lastClick = 0;
+  mouse.mouseDown(1);
+  expect(mouse.positionString()).toBe('');
+  mouse.mouseUp(1);
+});
+
+test('Test Mouse.positionString returns empty string when buttonThreeDown', () => {
+  mouse.lastClick = 0;
+  mouse.mouseDown(2);
+  expect(mouse.positionString()).toBe('');
+  mouse.mouseUp(2);
+});
+
+test('Test Mouse.positionString returns coordinate string when no buttons down', () => {
+  mouse.buttonOneDown = false;
+  mouse.buttonTwoDown = false;
+  mouse.buttonThreeDown = false;
+  expect(mouse.positionString()).toMatch(/X: .+ Y: .+/);
+});
+
+test('Test Mouse.mouseDown sets button states', () => {
+  mouse.lastClick = 0;
+
+  mouse.mouseDown(0);
+  expect(mouse.buttonOneDown).toBe(true);
+  mouse.mouseUp(0);
+
+  mouse.mouseDown(1);
+  expect(mouse.buttonTwoDown).toBe(true);
+  mouse.mouseUp(1);
+
+  mouse.mouseDown(2);
+  expect(mouse.buttonThreeDown).toBe(true);
+  mouse.mouseUp(2);
+});
+
+test('Test Mouse.mouseUp clears button states', () => {
+  mouse.lastClick = 0;
+
+  mouse.mouseDown(0);
+  mouse.mouseUp(0);
+  expect(mouse.buttonOneDown).toBe(false);
+
+  mouse.mouseDown(1);
+  mouse.mouseUp(1);
+  expect(mouse.buttonTwoDown).toBe(false);
+
+  mouse.mouseDown(2);
+  mouse.mouseUp(2);
+  expect(mouse.buttonThreeDown).toBe(false);
+});
+
+test('Test Mouse.mouseDown sets mouseDownCanvasPoint', () => {
+  mouse.x = 42;
+  mouse.y = 84;
+  mouse.lastClick = 0;
+  mouse.mouseDown(0);
+  expect(mouse.mouseDownCanvasPoint.x).toBe(42);
+  expect(mouse.mouseDownCanvasPoint.y).toBe(84);
+  mouse.mouseUp(0);
+});
+
+test('Test Mouse.mouseMoved updates position', () => {
+  core.canvas.height = 600;
+  mouse.mouseMoved(300, 400);
+  expect(mouse.x).toBe(300);
+  // y is inverted: -y + canvas.height = -400 + 600 = 200
+  expect(mouse.y).toBe(200);
+});
+
+test('Test Mouse.mouseMoved updates position when button is held down', () => {
+  core.canvas.height = 600;
+  mouse.lastClick = 0;
+  mouse.mouseDown(1); // buttonTwoDown (pan)
+  mouse.mouseMoved(100, 200);
+  expect(mouse.x).toBe(100);
+  expect(mouse.y).toBe(400); // -200 + 600
+  mouse.mouseUp(1);
+});
+
+test('Test Mouse.mouseMoved skips polar snap when a button is held down', () => {
+  core.canvas.height = 600;
+  const prevPolar = DesignCore.Settings.polar;
+  DesignCore.Settings.polar = true;
+  const polarSpy = jest.spyOn(core.scene.inputManager.snapping, 'polarSnap');
+  try {
+    mouse.lastClick = 0;
+    mouse.mouseDown(1);
+    mouse.mouseMoved(200, 300);
+    expect(polarSpy).not.toHaveBeenCalled();
+    mouse.mouseUp(1);
+  } finally {
+    DesignCore.Settings.polar = prevPolar;
+    polarSpy.mockRestore();
+  }
+});
+
+test('Test Mouse.mouseMoved skips ortho snap when a button is held down', () => {
+  core.canvas.height = 600;
+  const prevPolar = DesignCore.Settings.polar;
+  const prevOrtho = DesignCore.Settings.ortho;
+  DesignCore.Settings.polar = false;
+  DesignCore.Settings.ortho = true;
+  const orthoSpy = jest.spyOn(core.scene.inputManager.snapping, 'orthoSnap');
+  try {
+    mouse.lastClick = 0;
+    mouse.mouseDown(1);
+    mouse.mouseMoved(200, 300);
+    expect(orthoSpy).not.toHaveBeenCalled();
+    mouse.mouseUp(1);
+  } finally {
+    DesignCore.Settings.polar = prevPolar;
+    DesignCore.Settings.ortho = prevOrtho;
+    orthoSpy.mockRestore();
+  }
+});
+
+test('Test Mouse.setPosFromScenePoint', () => {
+  core.canvas.matrix = new Matrix();
+  core.canvas.height = 600;
+
+  const scenePoint = new Point(100, 200);
+  mouse.setPosFromScenePoint(scenePoint);
+
+  // Convert back to verify round-trip
+  const result = mouse.pointOnScene();
+  expect(result.x).toBeCloseTo(scenePoint.x, 5);
+  expect(result.y).toBeCloseTo(scenePoint.y, 5);
+});
+
+test('Test Mouse.isDoubleClick', () => {
+  // First click is never a double click
+  mouse.lastClick = 0;
+  expect(mouse.isDoubleClick(0)).toBe(false);
+
+  // Immediate second click should be a double click
+  expect(mouse.isDoubleClick(0)).toBe(true);
+});
+
+test('Test Mouse.isDoubleClick with different buttons', () => {
+  // Different buttons in quick succession should not be a double click
+  mouse.lastClick = 0;
+  mouse.isDoubleClick(0); // first click - left button
+  expect(mouse.isDoubleClick(1)).toBe(false); // second click - middle button
+});
+
+test('Test Mouse.wheel delegates to canvas', () => {
+  const scaleBefore = core.canvas.getScale();
+  mouse.wheel(1);
+  expect(core.canvas.getScale()).not.toBe(scaleBefore);
+});
+
+// ─── isDoubleClick ────────────────────────────────────────────────────────────
+
+test('Test Mouse.isDoubleClick - slow second click is not a double click', () => {
+  const doubleClickThreshold = 250;
+  mouse.lastClick = 0;
+  mouse.isDoubleClick(0); // first click
+  // advance lastClick far enough back to exceed the threshold
+  mouse.lastClick = new Date().getTime() - doubleClickThreshold - 1;
+  expect(mouse.isDoubleClick(0)).toBe(false);
+});
+
+test('Test Mouse.isDoubleClick - updates lastButton', () => {
+  mouse.lastClick = 0;
+  mouse.lastButton = 0;
+  mouse.isDoubleClick(2);
+  expect(mouse.lastButton).toBe(2);
+});
+
+// ─── doubleClick ──────────────────────────────────────────────────────────────
+
+test('Test Mouse.doubleClick delegates to Canvas.doubleClick', () => {
+  const spy = jest.spyOn(core.canvas, 'doubleClick').mockImplementation(() => {});
+  mouse.doubleClick(0);
+  expect(spy).toHaveBeenCalledWith(0);
+  spy.mockRestore();
+});
+
+test('Test Mouse.mouseDown triggers doubleClick on rapid second click', () => {
+  const spy = jest.spyOn(mouse, 'doubleClick').mockImplementation(() => {});
+  mouse.lastClick = 0;
+  mouse.mouseDown(0); // first click
+  mouse.mouseUp(0);
+  mouse.mouseDown(0); // immediate second click — should be double click
+  expect(spy).toHaveBeenCalledWith(0);
+  spy.mockRestore();
+  mouse.mouseUp(0);
+});
+
+// ─── mouseDown / mouseUp – unhandled button ───────────────────────────────────
+
+test('Test Mouse.mouseDown with unhandled button does not change state', () => {
+  mouse.buttonOneDown = false;
+  mouse.buttonTwoDown = false;
+  mouse.buttonThreeDown = false;
+  mouse.lastClick = 0;
+  mouse.mouseDown(99);
+  expect(mouse.buttonOneDown).toBe(false);
+  expect(mouse.buttonTwoDown).toBe(false);
+  expect(mouse.buttonThreeDown).toBe(false);
+});
+
+test('Test Mouse.mouseUp with unhandled button does not change state', () => {
+  mouse.buttonOneDown = true;
+  mouse.buttonTwoDown = true;
+  mouse.buttonThreeDown = true;
+  mouse.mouseUp(99);
+  expect(mouse.buttonOneDown).toBe(true);
+  expect(mouse.buttonTwoDown).toBe(true);
+  expect(mouse.buttonThreeDown).toBe(true);
+  // restore
+  mouse.buttonOneDown = false;
+  mouse.buttonTwoDown = false;
+  mouse.buttonThreeDown = false;
+});
+
+// ─── mouseUp – delegates to Canvas ───────────────────────────────────────────
+
+test('Test Mouse.mouseUp delegates to Canvas.mouseUp', () => {
+  mouse.lastClick = 0;
+  mouse.mouseDown(0);
+  const spy = jest.spyOn(core.canvas, 'mouseUp').mockImplementation(() => {});
+  mouse.mouseUp(0);
+  expect(spy).toHaveBeenCalledWith(0);
+  spy.mockRestore();
+});
+
+// ─── mouseMoved – delegates to Canvas ────────────────────────────────────────
+
+test('Test Mouse.mouseMoved delegates to Canvas.mouseMoved', () => {
+  const spy = jest.spyOn(core.canvas, 'mouseMoved').mockImplementation(() => {});
+  mouse.mouseMoved(10, 20);
+  expect(spy).toHaveBeenCalled();
+  spy.mockRestore();
+});
+
+// ─── positionString – correct coordinate values ───────────────────────────────
+
+test('Test Mouse.positionString reports current scene coordinates', () => {
+  mouse.buttonOneDown = false;
+  mouse.buttonTwoDown = false;
+  mouse.buttonThreeDown = false;
+  const scenePoint = mouse.pointOnScene();
+  const str = mouse.positionString();
+  expect(str).toContain(`X: ${scenePoint.x.toFixed(1)}`);
+  expect(str).toContain(`Y: ${scenePoint.y.toFixed(1)}`);
+});
+
+// ─── setPosFromScenePoint – x/y updated directly ─────────────────────────────
+
+test('Test Mouse.setPosFromScenePoint sets x and y from scene coordinates', () => {
+  core.canvas.height = 600;
+
+  const scenePoint = new Point(123, 456);
+  mouse.setPosFromScenePoint(scenePoint);
+
+  // The canvas point is what transformToCanvas returns
+  const expected = mouse.transformToCanvas(scenePoint);
+  expect(mouse.x).toBeCloseTo(expected.x, 5);
+  expect(mouse.y).toBeCloseTo(expected.y, 5);
+});

package/test/lib/patterns.test.js

@@ -0,0 +1,105 @@
+import { PatternLine, Patterns } from '../../core/lib/patterns.js';
+
+test('Test Patterns.getPattern', () => {
+  const pattern = Patterns.getPattern('HONEY');
+  expect(pattern.length).toBe(3);
+  pattern.forEach((patternLine) => {
+    expect(patternLine instanceof PatternLine).toBe(true);
+  });
+});
+
+test('Test Patterns.getPattern returns cached result', () => {
+  const first = Patterns.getPattern('ANSI31');
+  const second = Patterns.getPattern('ANSI31');
+  expect(first).toBe(second);
+});
+
+test('Test Patterns.getPattern cache is case-insensitive', () => {
+  const upper = Patterns.getPattern('HONEY');
+  const lower = Patterns.getPattern('honey');
+  const mixed = Patterns.getPattern('Honey');
+  expect(upper).toBe(lower);
+  expect(upper).toBe(mixed);
+});
+
+test('Test Patterns.getPattern returns frozen pattern array and objects', () => {
+  const pattern = Patterns.getPattern('ANSI31');
+  expect(Object.isFrozen(pattern)).toBe(true);
+  pattern.forEach((patternLine) => {
+    expect(Object.isFrozen(patternLine)).toBe(true);
+    expect(Object.isFrozen(patternLine.dashes)).toBe(true);
+  });
+});
+
+test('Test Patterns.getPattern frozen cache is not corrupted by caller mutation attempts', () => {
+  const pattern = Patterns.getPattern('ANSI31');
+  const originalAngle = pattern[0].angle;
+  const originalDashLength = pattern[0].dashes.length;
+  const originalLength = pattern.length;
+
+  // In strict mode (ESM), mutating frozen objects throws TypeError
+  expect(() => {
+    pattern[0].angle = 999;
+  }).toThrow(TypeError);
+  expect(() => {
+    pattern[0].dashes.push(999);
+  }).toThrow(TypeError);
+  expect(() => {
+    pattern.push(null);
+  }).toThrow(TypeError);
+
+  // Cache is unaffected
+  const patternAgain = Patterns.getPattern('ANSI31');
+  expect(patternAgain[0].angle).toBe(originalAngle);
+  expect(patternAgain[0].dashes.length).toBe(originalDashLength);
+  expect(patternAgain.length).toBe(originalLength);
+});
+
+
+test('Test Patterns.getPatternLineCount', () => {
+  expect(Patterns.getPatternLineCount('HONEY')).toBe(3);
+  expect(Patterns.getPatternLineCount('hOnEy')).toBe(3);
+  expect(Patterns.getPatternLineCount('ansi34')).toBe(4);
+});
+
+test('Test Patterns.patternExists', () => {
+  expect(Patterns.patternExists('HONEY')).toBe(true);
+  expect(Patterns.patternExists('hOnEy')).toBe(true);
+  expect(Patterns.patternExists('ansi34')).toBe(true);
+
+  expect(Patterns.patternExists('fakeName')).toBe(false);
+});
+
+
+test('Test PatternLine.loadPatternLine', () => {
+  const patternLine = new PatternLine();
+  const patternString = `45, 0, 0, 0, 3.175`;
+
+  patternLine.loadPatternLine(patternString);
+
+  expect(patternLine.angle).toBe(45);
+  expect(patternLine.xOrigin).toBe(0);
+  expect(patternLine.yOrigin).toBe(0);
+  expect(patternLine.xDelta).toBe(0);
+  expect(patternLine.yDelta).toBe(3.175);
+  expect(patternLine.dashes.length).toBe(0);
+
+  const patternStringwithDashes = `120, 0, 0, 4.7625, 2.749630645, 3.175, -6.35 `;
+
+  patternLine.loadPatternLine(patternStringwithDashes);
+
+  expect(patternLine.angle).toBe(120);
+  expect(patternLine.xOrigin).toBe(0);
+  expect(patternLine.yOrigin).toBe(0);
+  expect(patternLine.xDelta).toBe(4.7625);
+  expect(patternLine.yDelta).toBe(2.749630645);
+  expect(patternLine.dashes.length).toBe(2);
+  expect(patternLine.dashes[0]).toBe(3.175);
+  expect(patternLine.dashes[1]).toBe(-6.35);
+});
+
+test('Test PatternLine.getDashLength', () => {
+  const patternStringwithDashes = `120, 0, 0, 4.7625, 2.749630645, 3.175, -6.35 `;
+  const patternLine = new PatternLine(patternStringwithDashes);
+  expect(patternLine.getDashLength()).toBeCloseTo(9.5249);
+});

package/test/lib/promptOptions.test.js

@@ -0,0 +1,179 @@
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
+import { Input, PromptOptions } from '../../core/lib/inputManager.js';
+import { expect, jest } from '@jest/globals';
+
+// Core must be initialised so that DesignCore.Core is available for
+// PromptOptions.respond() to call Core.notify() on bad input.
+const core = new Core();
+
+// ─── Constructor ─────────────────────────────────────────────────────────────
+
+test('constructor uses default values when no arguments are supplied', () => {
+  const po = new PromptOptions();
+  expect(po.promptMessage).toBe('error');
+  expect(po.types).toEqual([]);
+  expect(po.options).toEqual([]);
+  expect(po.defaultValue).toBeUndefined();
+  expect(po.resolve).toBeUndefined();
+  expect(po.reject).toBeUndefined();
+});
+
+test('constructor stores all supplied arguments', () => {
+  const types = [Input.Type.POINT, Input.Type.NUMBER];
+  const options = ['One', 'Two', 'Three'];
+  const po = new PromptOptions('Select a point', types, options, 42);
+  expect(po.promptMessage).toBe('Select a point');
+  expect(po.types).toBe(types);
+  expect(po.options).toBe(options);
+  expect(po.defaultValue).toBe(42);
+});
+
+test('constructor defaultValue is undefined when not provided', () => {
+  const po = new PromptOptions('Enter value', [Input.Type.NUMBER]);
+  expect(po.defaultValue).toBeUndefined();
+});
+
+// ─── acceptsInput ─────────────────────────────────────────────────────────────
+
+test('acceptsInput returns true for exact matching type', () => {
+  const po = new PromptOptions('', [Input.Type.POINT]);
+  expect(po.acceptsInput(new Point(1, 2))).toBe(true);
+  expect(po.acceptsInput('text')).toBe(false);
+  expect(po.acceptsInput(42)).toBe(false);
+});
+
+test('acceptsInput returns true for DYNAMIC type with numeric input', () => {
+  const po = new PromptOptions('', [Input.Type.DYNAMIC]);
+  expect(po.acceptsInput(42)).toBe(true);
+  expect(po.acceptsInput(3.14)).toBe(true);
+  expect(po.acceptsInput('text')).toBe(false);
+  expect(po.acceptsInput(new Point())).toBe(false);
+});
+
+test('acceptsInput returns true when any of multiple types matches', () => {
+  const po = new PromptOptions('', [Input.Type.POINT, Input.Type.NUMBER]);
+  expect(po.acceptsInput(new Point(1, 2))).toBe(true);
+  expect(po.acceptsInput(42)).toBe(true);
+  expect(po.acceptsInput('text')).toBe(false);
+});
+
+// ─── createPromise ────────────────────────────────────────────────────────────
+
+test('createPromise returns a Promise and sets resolve and reject', async () => {
+  const po = new PromptOptions('', [Input.Type.STRING]);
+  const p = po.createPromise();
+  expect(p).toBeInstanceOf(Promise);
+  expect(typeof po.resolve).toBe('function');
+  expect(typeof po.reject).toBe('function');
+  po.resolve('done');
+  await expect(p).resolves.toBe('done');
+});
+
+// ─── respond ─────────────────────────────────────────────────────────────────
+
+test('respond returns true and resolves the promise when input matches accepted type', async () => {
+  const po = new PromptOptions('Enter text', [Input.Type.STRING]);
+  const p = po.createPromise();
+  const result = po.respond('hello');
+  expect(result).toBe(true);
+  await expect(p).resolves.toBe('hello');
+});
+
+test('respond returns true and resolves the promise when input matches an option', async () => {
+  const po = new PromptOptions('Choose', [Input.Type.POINT], ['Yes', 'No']);
+  const p = po.createPromise();
+  const result = po.respond('Y');
+  expect(result).toBe(true);
+  await expect(p).resolves.toBe('Yes');
+});
+
+test('respond returns false and calls Core.notify when input is invalid', () => {
+  const notifySpy = jest.spyOn(core, 'notify').mockImplementation(() => {});
+  const po = new PromptOptions('Enter point', [Input.Type.POINT]);
+  po.createPromise();
+  const result = po.respond('invalid string');
+  expect(result).toBe(false);
+  expect(notifySpy).toHaveBeenCalled();
+  notifySpy.mockRestore();
+  po.cancel();
+});
+
+// ─── parseInputToOption ───────────────────────────────────────────────────────
+
+test('parseInputToOption returns undefined when no options are defined', () => {
+  const po = new PromptOptions('Enter value', [Input.Type.STRING]);
+  expect(po.parseInputToOption('A')).toBeUndefined();
+  expect(po.parseInputToOption('X')).toBeUndefined();
+});
+
+test('parseInputToOption returns undefined for non-string input', () => {
+  const po = new PromptOptions('Choose', [], ['Apple']);
+  expect(po.parseInputToOption(42)).toBeUndefined();
+  expect(po.parseInputToOption(new Point())).toBeUndefined();
+});
+
+test('parseInputToOption matches options by case-insensitive prefix', () => {
+  const po = new PromptOptions('Select option', [Input.Type.STRING], ['Apple', 'Banana', 'Cherry']);
+  expect(po.parseInputToOption('A')).toBe('Apple');
+  expect(po.parseInputToOption('B')).toBe('Banana');
+  expect(po.parseInputToOption('C')).toBe('Cherry');
+  expect(po.parseInputToOption('a')).toBe('Apple');
+  expect(po.parseInputToOption('Apple')).toBe('Apple');
+});
+
+test('parseInputToOption returns undefined when no option matches', () => {
+  const po = new PromptOptions('Choose', [], ['Apple', 'Banana']);
+  expect(po.parseInputToOption('X')).toBeUndefined();
+});
+
+// ─── cancel ──────────────────────────────────────────────────────────────────
+
+test('cancel resolves the pending promise with undefined', async () => {
+  const po = new PromptOptions('Enter point', [Input.Type.POINT]);
+  const p = po.createPromise();
+  po.cancel();
+  await expect(p).resolves.toBeUndefined();
+});
+
+test('cancel is a no-op when no promise has been created', () => {
+  const po = new PromptOptions('', [Input.Type.STRING]);
+  expect(() => po.cancel()).not.toThrow();
+});
+
+// ─── getPrompt ────────────────────────────────────────────────────────────────
+
+test('getPrompt returns bare message when no options or defaultValue are set', () => {
+  const po = new PromptOptions('Enter value', [Input.Type.NUMBER]);
+  expect(po.getPrompt()).toBe('Enter value');
+});
+
+test('getPrompt includes OR keyword and underscored shortcuts when options are set', () => {
+  const po = new PromptOptions('Select', [Input.Type.STRING], ['Apple', 'Banana']);
+  const prompt = po.getPrompt();
+  expect(prompt).toContain('Select');
+  expect(prompt).toContain('or');
+  expect(prompt).toContain('A\u0332pple');
+  expect(prompt).toContain('B\u0332anana');
+});
+
+test('getPrompt appends <defaultValue> when defaultValue is set', () => {
+  const po = new PromptOptions('Enter distance', [Input.Type.NUMBER], [], 10);
+  expect(po.getPrompt()).toBe('Enter distance <10>');
+});
+
+test('getPrompt appends <defaultValue> after the options bracket when both are set', () => {
+  const po = new PromptOptions('Select', [Input.Type.STRING], ['Apple', 'Banana'], 'Apple');
+  const prompt = po.getPrompt();
+  expect(prompt).toContain('A\u0332pple');
+  expect(prompt).toMatch(/<Apple>$/);
+});
+
+// ─── getOptionWithShortcut ────────────────────────────────────────────────────
+
+test('getOptionWithShortcut underlines the first character of the option', () => {
+  const po = new PromptOptions();
+  expect(po.getOptionWithShortcut('input')).toBe('i\u0332nput');
+  expect(po.getOptionWithShortcut('Through')).toBe('T\u0332hrough');
+  expect(po.getOptionWithShortcut('A')).toBe('A\u0332');
+});