@design-core/core 0.0.1 → 0.0.3

package/test/entities/text.test.js

@@ -1,9 +1,59 @@
-import {Point} from '../../core/entities/point';
-import {Text} from '../../core/entities/text';
+import { Text } from '../../core/entities/text.js';
+import { Point } from '../../core/entities/point.js';
+import { DesignCore } from '../../core/designCore.js';
 
+import { File, withMockInput } from '../test-helpers/test-helpers.js';
+import { Core } from '../../core/core/core.js';
 
-test('Test BasePolyline.closestPoint', () => {
-  const text = new Text({points: [new Point(100, 100)]});
+// initialise core
+new Core();
+
+const textInputScenarios = [
+  {
+    desc: 'standard style, custom height and rotation',
+    pt0: new Point(1, 2),
+    styleName: 'STANDARD',
+    // style: { textHeight: 2.5, backwards: false, upsideDown: false },
+    heightInput: 5,
+    rotationInput: 45,
+    stringInput: 'Hello',
+    expectedHeight: 5,
+    expectedRotation: 45,
+    expectedString: 'Hello',
+  },
+  {
+    desc: 'custom style, default height, rotation 90',
+    pt0: new Point(10, 20),
+    styleName: 'STANDARD',
+    // style: { textHeight: 3, backwards: true, upsideDown: true },
+    heightInput: 3,
+    rotationInput: 90,
+    stringInput: 'World',
+    expectedHeight: 3,
+    expectedRotation: 90,
+    expectedString: 'World',
+  },
+];
+
+test.each(textInputScenarios)('Text.execute handles $desc', async (scenario) => {
+  const { pt0, styleName, heightInput, rotationInput, stringInput, expectedHeight, expectedRotation, expectedString } = scenario;
+
+  await withMockInput(DesignCore.Scene, [pt0, heightInput, rotationInput, stringInput], async () => {
+    const text = new Text({});
+    await text.execute();
+
+    expect(text.points.length).toBeGreaterThanOrEqual(1);
+    expect(text.points[0].x).toBe(pt0.x);
+    expect(text.points[0].y).toBe(pt0.y);
+    expect(text.height).toBe(expectedHeight);
+    expect(text.rotation).toBe(expectedRotation);
+    expect(text.string).toBe(expectedString);
+    expect(text.styleName).toBe(styleName);
+  });
+});
+
+test('Test Text.closestPoint', () => {
+  const text = new Text({ points: [new Point(100, 100)] });
   const point1 = new Point(90, 90);
   const closest1 = text.closestPoint(point1);
   expect(closest1[0].x).toBeCloseTo(105);
@@ -11,12 +61,165 @@ test('Test BasePolyline.closestPoint', () => {
   expect(closest1[1]).toBeCloseTo(21.21);
 });
 
+
+test('Test Text.getTextFrameCorners', () => {
+  const text = new Text({ points: [new Point(100, 100)] });
+  let corners = text.getTextFrameCorners();
+
+  expect(corners[0].x).toBeCloseTo(100);
+  expect(corners[0].y).toBeCloseTo(100);
+
+  expect(corners[1].x).toBeCloseTo(110);
+  expect(corners[1].y).toBeCloseTo(100);
+
+  expect(corners[2].x).toBeCloseTo(110);
+  expect(corners[2].y).toBeCloseTo(110);
+
+  expect(corners[3].x).toBeCloseTo(100);
+  expect(corners[3].y).toBeCloseTo(110);
+
+  // Rotate 45 degrees
+  text.setRotation(45);
+  corners = text.getTextFrameCorners();
+
+  expect(corners[0].x).toBeCloseTo(100);
+  expect(corners[0].y).toBeCloseTo(100);
+
+  expect(corners[1].x).toBeCloseTo(107.07106);
+  expect(corners[1].y).toBeCloseTo(107.07106);
+
+  expect(corners[2].x).toBeCloseTo(100);
+  expect(corners[2].y).toBeCloseTo(114.14213);
+
+  expect(corners[3].x).toBeCloseTo(92.92893);
+  expect(corners[3].y).toBeCloseTo(107.07106);
+
+  // backwards and upsideDown
+  text.setRotation(0);
+  text.backwards = true;
+  text.upsideDown = true;
+  corners = text.getTextFrameCorners();
+
+  expect(corners[0].x).toBeCloseTo(90);
+  expect(corners[0].y).toBeCloseTo(90);
+
+  expect(corners[1].x).toBeCloseTo(100);
+  expect(corners[1].y).toBeCloseTo(90);
+
+  expect(corners[2].x).toBeCloseTo(100);
+  expect(corners[2].y).toBeCloseTo(100);
+
+  expect(corners[3].x).toBeCloseTo(90);
+  expect(corners[3].y).toBeCloseTo(100);
+
+  // Text frame calculation with text alignment
+  // bounding rect is 10x10, so with center/middle alignment the text frame should be offset by 5 in both x and y from the insertion point
+  const alignedText = new Text({ points: [new Point(100, 100)] });
+  alignedText.horizontalAlignment = 1; // center
+  corners = alignedText.getTextFrameCorners();
+
+  expect(corners[0].x).toBeCloseTo(95);
+  expect(corners[0].y).toBeCloseTo(100);
+
+  expect(corners[1].x).toBeCloseTo(105);
+  expect(corners[1].y).toBeCloseTo(100);
+
+  expect(corners[2].x).toBeCloseTo(105);
+  expect(corners[2].y).toBeCloseTo(110);
+
+  expect(corners[3].x).toBeCloseTo(95);
+  expect(corners[3].y).toBeCloseTo(110);
+
+  // set vertical alignment to middle as well
+  // offset the text frame up by another 5 in y so the corners should be at 95,95 - 105,105
+  alignedText.verticalAlignment = 2; // middle
+  corners = alignedText.getTextFrameCorners();
+
+  expect(corners[0].x).toBeCloseTo(95);
+  expect(corners[0].y).toBeCloseTo(95);
+
+  expect(corners[1].x).toBeCloseTo(105);
+  expect(corners[1].y).toBeCloseTo(95);
+
+  expect(corners[2].x).toBeCloseTo(105);
+  expect(corners[2].y).toBeCloseTo(105);
+
+  expect(corners[3].x).toBeCloseTo(95);
+  expect(corners[3].y).toBeCloseTo(105);
+
+
+  // add rotation of 45 degrees to the center/middle aligned text and ensure the text frame corners are correctly calculated with both alignment and rotation applied
+  alignedText.setRotation(45);
+  corners = alignedText.getTextFrameCorners();
+
+  expect(corners[0].x).toBeCloseTo(100);
+  expect(corners[0].y).toBeCloseTo(92.92893);
+
+  expect(corners[1].x).toBeCloseTo(107.07106);
+  expect(corners[1].y).toBeCloseTo(100);
+
+  expect(corners[2].x).toBeCloseTo(100);
+  expect(corners[2].y).toBeCloseTo(107.07106);
+
+  expect(corners[3].x).toBeCloseTo(92.92893);
+  expect(corners[3].y).toBeCloseTo(100);
+
+  // flip the text backwards and ensure the text frame corners are still correctly calculated with the flipped text
+  alignedText.backwards = true;
+  corners = alignedText.getTextFrameCorners();
+
+  expect(corners[0].x).toBeCloseTo(92.92893);
+  expect(corners[0].y).toBeCloseTo(85.8579);
+
+  expect(corners[1].x).toBeCloseTo(100);
+  expect(corners[1].y).toBeCloseTo(92.92893);
+
+  expect(corners[2].x).toBeCloseTo(92.92893);
+  expect(corners[2].y).toBeCloseTo(100);
+
+  expect(corners[3].x).toBeCloseTo(85.8579);
+  expect(corners[3].y).toBeCloseTo(92.92893);
+
+  // test right and top alignment
+  const rightAlignedtext = new Text({ points: [new Point(100, 100)] });
+  rightAlignedtext.horizontalAlignment = 2; // right
+  corners = rightAlignedtext.getTextFrameCorners();
+
+  expect(corners[0].x).toBeCloseTo(90);
+  expect(corners[0].y).toBeCloseTo(100);
+
+  expect(corners[1].x).toBeCloseTo(100);
+  expect(corners[1].y).toBeCloseTo(100);
+
+  expect(corners[2].x).toBeCloseTo(100);
+  expect(corners[2].y).toBeCloseTo(110);
+
+  expect(corners[3].x).toBeCloseTo(90);
+  expect(corners[3].y).toBeCloseTo(110);
+
+  // add vertical alignment top and ensure the text frame is still correctly calculated with the right and top alignment applied
+  rightAlignedtext.verticalAlignment = 3; // top
+  corners = rightAlignedtext.getTextFrameCorners();
+
+  expect(corners[0].x).toBeCloseTo(90);
+  expect(corners[0].y).toBeCloseTo(90);
+
+  expect(corners[1].x).toBeCloseTo(100);
+  expect(corners[1].y).toBeCloseTo(90);
+
+  expect(corners[2].x).toBeCloseTo(100);
+  expect(corners[2].y).toBeCloseTo(100);
+
+  expect(corners[3].x).toBeCloseTo(90);
+  expect(corners[3].y).toBeCloseTo(100);
+});
+
 test('Test Text.setRotation', () => {
-  const setRotText = new Text({points: [new Point()]});
+  const setRotText = new Text({ points: [new Point()] });
 
   // Zero
   setRotText.setRotation(0);
-  expect(setRotText.rotation).toBe(0);
+  expect(setRotText.rotation).toBeCloseTo(0);
 
   // Positive
   setRotText.setRotation(22.5);
@@ -97,10 +300,333 @@ test('Test Text.getRotation', () => {
 });
 
 
+test('Test Text.flags', () => {
+  // DXF Groupcode 71 - flags (bit-coded values):
+  // 2 = Text is backward (mirrored in X).
+  // 4 = Text is upside down (mirrored in Y).
+  const text = new Text();
+  expect(text.flags.getFlagValue()).toBe(0);
+  // set backwards - set 2 on flags
+  text.backwards = true;
+  expect(text.flags.getFlagValue()).toBe(2);
+  // set upsideDown - set 4 on flags
+  text.upsideDown = true;
+  expect(text.flags.getFlagValue()).toBe(6);
+  // unset backwards - remove 2 on flags
+  text.backwards = false;
+  expect(text.flags.getFlagValue()).toBe(4);
+});
+
+test('Test Text.backwards', () => {
+  // DXF Groupcode 71 - flags (bit-coded values):
+  // 2 = Text is backward (mirrored in X).
+  // 4 = Text is upside down (mirrored in Y).
+  const text = new Text();
+  expect(text.backwards).toBe(false);
+  expect(text.flags.getFlagValue()).toBe(0);
+  text.backwards = true;
+  expect(text.backwards).toBe(true);
+  expect(text.flags.getFlagValue()).toBe(2);
+});
+
+test('Test Text.upsideDown', () => {
+  // DXF Groupcode 71 - flags (bit-coded values):
+  // 2 = Text is backward (mirrored in X).
+  // 4 = Text is upside down (mirrored in Y).
+  const text = new Text();
+  expect(text.upsideDown).toBe(false);
+  expect(text.flags.getFlagValue()).toBe(0);
+  text.upsideDown = true;
+  expect(text.upsideDown).toBe(true);
+  expect(text.flags.getFlagValue()).toBe(4);
+});
+
 test('Test Text.boundingBox', () => {
-  const text = new Text({points: [new Point(11, 12)]});
+  const text = new Text({ points: [new Point(11, 12)] });
   expect(text.boundingBox().xMin).toBeCloseTo(11);
   expect(text.boundingBox().xMax).toBeCloseTo(21);
   expect(text.boundingBox().yMin).toBeCloseTo(12);
   expect(text.boundingBox().yMax).toBeCloseTo(22);
 });
+
+test('Test Text.dxf', () => {
+  const text = new Text({ handle: '1', points: [new Point(100, 200)] });
+  let file = new File();
+  text.dxf(file);
+  // console.log(file.contents);
+
+  const dxfString = `0
+TEXT
+5
+1
+100
+AcDbEntity
+8
+0
+100
+AcDbText
+10
+100
+20
+200
+30
+0.0
+40
+2.5
+1
+
+50
+0
+71
+0
+72
+0
+100
+AcDbText
+`;
+
+  expect(file.contents).toEqual(dxfString);
+
+  // create new entity from entity data to ensure all props are loaded
+  const newText = new Text(text);
+  file = new File();
+  newText.dxf(file);
+  expect(file.contents).toEqual(dxfString);
+
+
+  // create new entity to test text alignment
+  // this should include dxf groupcodes 73 and 72 for vertical and horizontal alignment respectively
+  // and a second alignment point with groupcode 11,21,31 for the text insertion point
+  // bounding rect is 10x10, so second point should be at 100-(10*0.5), 200-(10*0.5) = 95, 195
+
+  const centeredText = new Text(text);
+  centeredText.horizontalAlignment = 1; // center
+  centeredText.verticalAlignment = 2; // middle
+  file = new File();
+  centeredText.dxf(file);
+
+  const dxfCenteredString = `0
+TEXT
+5
+1
+100
+AcDbEntity
+8
+0
+100
+AcDbText
+10
+95
+20
+195
+30
+0.0
+40
+2.5
+1
+
+50
+0
+71
+0
+72
+1
+11
+100
+21
+200
+31
+0.0
+100
+AcDbText
+73
+2
+`;
+  expect(file.contents).toEqual(dxfCenteredString);
+
+  // create new entity from entity data to ensure all props are loaded
+  const importCenteredText = new Text(centeredText);
+  file = new File();
+  importCenteredText.dxf(file);
+  expect(file.contents).toEqual(dxfCenteredString);
+});
+
+test('Text constructor covers all property branches', () => {
+  // Minimal data
+  let t = new Text({ points: [new Point(1, 2)] });
+  expect(t.string).toBe('');
+  expect(t.height).toBe(2.5);
+  expect(t.horizontalAlignment).toBe(0);
+  expect(t.verticalAlignment).toBe(0);
+  expect(t.styleName).toBe('STANDARD');
+
+  // All DXF groupcodes
+  t = new Text({
+    points: [new Point(0, 0)],
+    string: 'abc',
+    1: 'def',
+    styleName: 'FOO',
+    7: 'BAR',
+    height: 5,
+    40: 6,
+    rotation: 45,
+    50: 90,
+    horizontalAlignment: 2,
+    72: 1,
+    verticalAlignment: 3,
+    73: 2,
+    flags: 2,
+    71: 4,
+  });
+  expect(['abc', 'def']).toContain(t.string);
+  expect(['FOO', 'BAR']).toContain(t.styleName);
+  expect([5, 6]).toContain(t.height);
+  expect([45, 90]).toContain(t.rotation);
+  expect([2, 1]).toContain(t.horizontalAlignment);
+  expect([3, 2]).toContain(t.verticalAlignment);
+  expect([2, 4, 6, 0]).toContain(t.flags.getFlagValue());
+});
+
+test('Text static register and getApproximateWidth', () => {
+  expect(Text.register()).toEqual({ command: 'Text', shortcut: 'DT', type: 'Entity' });
+  expect(Text.getApproximateWidth('abc', 10)).toBeCloseTo(18);
+});
+
+test('Text getHorizontalAlignment covers all cases', () => {
+  const t = new Text({ points: [new Point()] });
+  t.horizontalAlignment = 0;
+  expect(t.getHorizontalAlignment()).toBe('left');
+  t.horizontalAlignment = 1;
+  expect(t.getHorizontalAlignment()).toBe('center');
+  t.horizontalAlignment = 2;
+  expect(t.getHorizontalAlignment()).toBe('right');
+  t.horizontalAlignment = 3; t.verticalAlignment = 0;
+  expect(t.getHorizontalAlignment()).toBe('aligned');
+  t.horizontalAlignment = 4; t.verticalAlignment = 0;
+  expect(t.getHorizontalAlignment()).toBe('center');
+  t.horizontalAlignment = 5; t.verticalAlignment = 0;
+  expect(t.getHorizontalAlignment()).toBe('fit');
+  t.horizontalAlignment = 99;
+  expect(t.getHorizontalAlignment()).toBe('left');
+});
+
+test('Text getVerticalAlignment covers all cases', () => {
+  const t = new Text({ points: [new Point()] });
+  t.verticalAlignment = 0;
+  expect(t.getVerticalAlignment()).toBe('alphabetic');
+  t.verticalAlignment = 1;
+  expect(t.getVerticalAlignment()).toBe('bottom');
+  t.verticalAlignment = 2;
+  expect(t.getVerticalAlignment()).toBe('middle');
+  t.verticalAlignment = 3;
+  expect(t.getVerticalAlignment()).toBe('top');
+  t.verticalAlignment = 99;
+  expect(t.getVerticalAlignment()).toBe('alphabetic');
+});
+
+test('Text getBoundingRect returns correct object', () => {
+  const t = new Text({ points: [new Point(1, 2)] });
+  t.boundingRect = { width: 5, height: 6 };
+  const rect = t.getBoundingRect();
+  expect(rect).toEqual({ width: 5, height: 6, x: 1, y: 2 });
+});
+
+test('Text snaps returns all snap points', () => {
+  const t = new Text({ points: [new Point(1, 2)] });
+  t.boundingRect = { width: 10, height: 10 };
+  const snaps = t.snaps(new Point(0, 0), 1);
+  expect(snaps.length).toBe(5);
+});
+
+test('Text closestPoint returns correct distance', () => {
+  const t = new Text({ points: [new Point(0, 0)] });
+  t.boundingRect = { width: 10, height: 10 };
+  const [mid, dist] = t.closestPoint(new Point(5, 5));
+  expect(mid.x).toBe(5);
+  expect(mid.y).toBe(5);
+  expect(dist).toBe(0);
+  const [mid2, dist2] = t.closestPoint(new Point(100, 100));
+  expect(mid2.x).toBe(5);
+  expect(mid2.y).toBe(5);
+  expect(dist2).toBeGreaterThan(0);
+});
+
+test('Text boundingBox returns BoundingBox', () => {
+  const t = new Text({ points: [new Point(1, 2)] });
+  t.boundingRect = { width: 10, height: 10 };
+  const box = t.getBoundingRect();
+  expect(box.x).toBe(1);
+  expect(box.y).toBe(2);
+  expect(box.width).toBe(10);
+  expect(box.height).toBe(10);
+});
+
+test('Text toPolylinePoints returns correct array', () => {
+  const t = new Text({ points: [new Point(1, 2)] });
+  t.boundingRect = { width: 10, height: 10 };
+  const pts = t.toPolylinePoints();
+  expect(pts.length).toBe(5);
+  expect(pts[0].x).toBe(1);
+  expect(pts[0].y).toBe(2);
+  expect(pts[2].x).toBe(11);
+  expect(pts[2].y).toBe(12);
+  expect(pts[4].x).toBe(pts[0].x);
+  expect(pts[4].y).toBe(pts[0].y);
+});
+
+test('Text setBackwards and setUpsideDown edge cases', () => {
+  const t = new Text({ points: [new Point()] });
+  t.setBackwards(true);
+  expect(t.backwards).toBe(true);
+  t.setBackwards(false);
+  expect(t.backwards).toBe(false);
+  t.setUpsideDown(true);
+  expect(t.upsideDown).toBe(true);
+  t.setUpsideDown(false);
+  expect(t.upsideDown).toBe(false);
+});
+
+test('Text setRotation handles undefined and height 0', () => {
+  const t = new Text({ points: [new Point()] });
+  t.setRotation(45);
+  expect(t.points[1].x).toBeCloseTo(1.7677);
+  expect(t.points[1].y).toBeCloseTo(1.7677);
+  t.setRotation(undefined);
+  expect(t.points[1].x).toBeCloseTo(1.7677);
+  expect(t.points[1].y).toBeCloseTo(1.7677);
+});
+
+test('Text getRotation returns 0 if points[1] undefined', () => {
+  const t = new Text({ points: [new Point()] });
+  t.points[1] = undefined;
+  expect(t.getRotation()).toBe(0);
+});
+
+test('Text.execute re-prompts on zero or negative height', async () => {
+  const pt = new Point(0, 0);
+
+  // 0 and -5 are rejected; 5 is accepted
+  await withMockInput(DesignCore.Scene, [pt, 0, -5, 5, 0, 'Hello'], async () => {
+    const text = new Text({});
+    await text.execute();
+
+    expect(text.height).toBe(5);
+    expect(text.string).toBe('Hello');
+  });
+});
+
+test('Text.execute does not create entity for empty string', async () => {
+  const pt = new Point(0, 0);
+  let executeCommandCalled = false;
+
+  await withMockInput(DesignCore.Scene, [pt, 5, 0, ''], async () => {
+    const text = new Text({});
+    await text.execute();
+
+    expect(text.string).toBe('');
+  }, { extraMethods: { executeCommand: () => {
+    executeCommandCalled = true;
+  } } });
+
+  expect(executeCommandCalled).toBe(false);
+});