@design-core/core 50.1.0 → 51.2.0

package/test/properties/propertyManager.test.js

@@ -113,3 +113,74 @@ test('Test propertyManager.getEntityPropertyValue', () => {
   propertyValues = propertiesManager.getEntityPropertyValue('All', 'colour');
   expect(propertyValues).toBe('Varies');
 });
+
+test('Test propertyManager.getEntityPropertyDefinition', () => {
+  // clear the selection set
+  DesignCore.Scene.reset();
+
+  // returns undefined when nothing is selected
+  let def = propertiesManager.getEntityPropertyDefinition('All', 'colour');
+  expect(def).toBeUndefined();
+
+  // select the line entity
+  DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(0);
+
+  // returns a Property descriptor for a valid property
+  def = propertiesManager.getEntityPropertyDefinition('All', 'colour');
+  expect(def).toBeDefined();
+  expect(typeof def.type).toBe('string');
+
+  // returns undefined for a property the entity does not have
+  def = propertiesManager.getEntityPropertyDefinition('All', 'non-existent-prop');
+  expect(def).toBeUndefined();
+
+  // filters by entityType — Circle not selected, so returns undefined
+  def = propertiesManager.getEntityPropertyDefinition('Circle', 'colour');
+  expect(def).toBeUndefined();
+});
+
+test('Test propertyManager.getEntityForProperty', () => {
+  // clear the selection set
+  DesignCore.Scene.reset();
+
+  // returns undefined when nothing is selected
+  let entity = propertiesManager.getEntityForProperty('All', 'colour');
+  expect(entity).toBeUndefined();
+
+  // select the line (index 0) and circle (index 1)
+  DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(0);
+  DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(1);
+
+  // returns an entity for 'All' and a known property
+  entity = propertiesManager.getEntityForProperty('All', 'colour');
+  expect(entity).toBeDefined();
+  expect(entity.type === 'Line' || entity.type === 'Circle').toBe(true);
+
+  // filters by entityType — only Circle entities
+  entity = propertiesManager.getEntityForProperty('Circle', 'colour');
+  expect(entity).toBeDefined();
+  expect(entity.type).toBe('Circle');
+
+  // returns undefined when the property does not exist on any selected entity
+  entity = propertiesManager.getEntityForProperty('All', 'non-existent-prop');
+  expect(entity).toBeUndefined();
+});
+
+test('Test propertyManager.setPropertyCallbackFunction and selectionSetChanged', () => {
+  let callCount = 0;
+  const callback = () => {
+    callCount++;
+  };
+
+  // selectionSetChanged with no callback set should not throw
+  propertiesManager.selectionSetChanged();
+
+  propertiesManager.setPropertyCallbackFunction(callback);
+
+  // callback is invoked when selectionSetChanged is called
+  propertiesManager.selectionSetChanged();
+  expect(callCount).toBe(1);
+
+  propertiesManager.selectionSetChanged();
+  expect(callCount).toBe(2);
+});

package/test/tools/windowPick.test.js

@@ -0,0 +1,129 @@
+import { Core } from '../../core/core/core.js';
+import { DesignCore } from '../../core/designCore.js';
+import { Point } from '../../core/entities/point.js';
+import { WindowPick } from '../../core/tools/windowPick.js';
+import { expect, jest } from '@jest/globals';
+import { withMockInput } from '../test-helpers/test-helpers.js';
+
+const core = new Core();
+
+// ─── register ────────────────────────────────────────────────────────────────
+
+test('WindowPick.register returns correct command object', () => {
+  const reg = WindowPick.register();
+  expect(reg.command).toBe('WindowPick');
+  expect(reg.shortcut).toBeUndefined();
+  expect(reg.type).toBeUndefined();
+});
+
+// ─── execute ──────────────────────────────────────────────────────────────────
+
+test('WindowPick.execute collects two points and calls executeCommand', async () => {
+  const executeCommandSpy = jest.fn();
+
+  await withMockInput(
+      core.scene,
+      [new Point(0, 0), new Point(10, 10)],
+      async () => {
+        const tool = new WindowPick();
+        await tool.execute();
+      },
+      { extraMethods: { executeCommand: executeCommandSpy } },
+  );
+
+  expect(executeCommandSpy).toHaveBeenCalled();
+});
+
+test('WindowPick.execute returns early when first point is undefined', async () => {
+  const executeCommandSpy = jest.fn();
+
+  await withMockInput(
+      core.scene,
+      [],
+      async () => {
+        const tool = new WindowPick();
+        await tool.execute();
+      },
+      { extraMethods: { executeCommand: executeCommandSpy } },
+  );
+
+  expect(executeCommandSpy).not.toHaveBeenCalled();
+});
+
+test('WindowPick.execute returns early when second point is undefined', async () => {
+  const executeCommandSpy = jest.fn();
+
+  await withMockInput(
+      core.scene,
+      [new Point(0, 0)],
+      async () => {
+        const tool = new WindowPick();
+        await tool.execute();
+      },
+      { extraMethods: { executeCommand: executeCommandSpy } },
+  );
+
+  expect(executeCommandSpy).not.toHaveBeenCalled();
+});
+
+test('WindowPick.execute stores the two collected points', async () => {
+  let capturedTool;
+  const executeCommandSpy = jest.fn();
+
+  await withMockInput(
+      core.scene,
+      [new Point(1, 2), new Point(30, 40)],
+      async () => {
+        capturedTool = new WindowPick();
+        await capturedTool.execute();
+      },
+      { extraMethods: { executeCommand: executeCommandSpy } },
+  );
+
+  expect(capturedTool.points).toHaveLength(2);
+  expect(capturedTool.points[0].x).toBe(1);
+  expect(capturedTool.points[0].y).toBe(2);
+  expect(capturedTool.points[1].x).toBe(30);
+  expect(capturedTool.points[1].y).toBe(40);
+});
+
+// ─── preview ──────────────────────────────────────────────────────────────────
+
+test('WindowPick.preview with one point creates a rectangle polyline preview', () => {
+  const tool = new WindowPick();
+  tool.points.push(new Point(10, 10));
+
+  core.mouse.mouseMoved(50, 50);
+
+  const initialCount = DesignCore.Scene.previewEntities.count();
+
+  tool.preview();
+
+  expect(DesignCore.Scene.previewEntities.count()).toBe(initialCount + 1);
+
+  const tempItem = DesignCore.Scene.previewEntities.get(DesignCore.Scene.previewEntities.count() - 1);
+  expect(tempItem.type).toBe('Polyline');
+  expect(tempItem.points.length).toBe(4);
+});
+
+test('WindowPick.preview with no points does not create a preview', () => {
+  const tool = new WindowPick();
+
+  const initialCount = DesignCore.Scene.previewEntities.count();
+
+  tool.preview();
+
+  expect(DesignCore.Scene.previewEntities.count()).toBe(initialCount);
+});
+
+test('WindowPick.preview with two points does not create another preview', () => {
+  const tool = new WindowPick();
+  tool.points.push(new Point(0, 0));
+  tool.points.push(new Point(10, 10));
+
+  const initialCount = DesignCore.Scene.previewEntities.count();
+
+  tool.preview();
+
+  expect(DesignCore.Scene.previewEntities.count()).toBe(initialCount);
+});

package/test/tools/zoom.test.js

@@ -181,40 +181,38 @@ test('Test Canvas.zoomToWindow - reversed points', () => {
   expect(finalScale).not.toBe(initialScale);
 });
 
-test('Test Canvas.zoomToWindow - zero width (should not zoom)', () => {
+test('Test Canvas.zoomToWindow - zero width (zooms using height)', () => {
   core.canvas.width = 800;
   core.canvas.height = 600;
   core.canvas.matrix.scale(1, 1);
 
-  const initialScale = core.canvas.getScale();
-
-  // Points with same x coordinate (zero width)
+  // Points with same x coordinate (zero width, i.e. a vertical line)
   const pt1 = new Point(50, 0);
   const pt2 = new Point(50, 100);
 
   core.canvas.zoomToWindow(pt1, pt2);
 
-  // Should not change scale
+  // Resulting scale depends only on the window size, not the prior scale,
+  // so assert the expected value rather than comparing against initialScale
   const finalScale = core.canvas.getScale();
-  expect(finalScale).toBe(initialScale);
+  expect(finalScale).toBeCloseTo((core.canvas.height / 100) * 0.9);
 });
 
-test('Test Canvas.zoomToWindow - zero height (should not zoom)', () => {
+test('Test Canvas.zoomToWindow - zero height (zooms using width)', () => {
   core.canvas.width = 800;
   core.canvas.height = 600;
   core.canvas.matrix.scale(1, 1);
 
-  const initialScale = core.canvas.getScale();
-
-  // Points with same y coordinate (zero height)
+  // Points with same y coordinate (zero height, i.e. a horizontal line)
   const pt1 = new Point(0, 50);
   const pt2 = new Point(100, 50);
 
   core.canvas.zoomToWindow(pt1, pt2);
 
-  // Should not change scale
+  // Resulting scale depends only on the window size, not the prior scale,
+  // so assert the expected value rather than comparing against initialScale
   const finalScale = core.canvas.getScale();
-  expect(finalScale).toBe(initialScale);
+  expect(finalScale).toBeCloseTo((core.canvas.width / 100) * 0.9);
 });
 
 test('Test Canvas.zoomToWindow - same point (should not zoom)', () => {