@design-core/core 0.0.6 → 0.0.7

package/test/entities/text.test.js

@@ -1,6 +1,7 @@
 import { Text } from '../../core/entities/text.js';
 import { Point } from '../../core/entities/point.js';
 import { DesignCore } from '../../core/designCore.js';
+import { Input } from '../../core/lib/input.js';
 
 import { File, withMockInput } from '../test-helpers/test-helpers.js';
 import { Core } from '../../core/core/core.js';
@@ -45,10 +46,10 @@ test.each(textInputScenarios)('Text.execute handles $desc', async (scenario) =>
     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);
+    expect(text.getProperty('height')).toBe(expectedHeight);
+    expect(text.getProperty('rotation')).toBe(expectedRotation);
+    expect(text.getProperty('string')).toBe(expectedString);
+    expect(text.getProperty('styleName')).toBe(styleName);
   });
 });
 
@@ -96,8 +97,8 @@ test('Test Text.getTextFrameCorners', () => {
 
   // backwards and upsideDown
   text.setRotation(0);
-  text.backwards = true;
-  text.upsideDown = true;
+  text.setProperty('backwards', true);
+  text.setProperty('upsideDown', true);
   corners = text.getTextFrameCorners();
 
   expect(corners[0].x).toBeCloseTo(90);
@@ -115,7 +116,7 @@ test('Test Text.getTextFrameCorners', () => {
   // 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
+  alignedText.setProperty('horizontalAlignment', 1); // center
   corners = alignedText.getTextFrameCorners();
 
   expect(corners[0].x).toBeCloseTo(95);
@@ -132,7 +133,7 @@ test('Test Text.getTextFrameCorners', () => {
 
   // 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
+  alignedText.setProperty('verticalAlignment', 2); // middle
   corners = alignedText.getTextFrameCorners();
 
   expect(corners[0].x).toBeCloseTo(95);
@@ -165,7 +166,7 @@ test('Test Text.getTextFrameCorners', () => {
   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;
+  alignedText.setProperty('backwards', true);
   corners = alignedText.getTextFrameCorners();
 
   expect(corners[0].x).toBeCloseTo(92.92893);
@@ -182,7 +183,7 @@ test('Test Text.getTextFrameCorners', () => {
 
   // test right and top alignment
   const rightAlignedtext = new Text({ points: [new Point(100, 100)] });
-  rightAlignedtext.horizontalAlignment = 2; // right
+  rightAlignedtext.setProperty('horizontalAlignment', 2); // right
   corners = rightAlignedtext.getTextFrameCorners();
 
   expect(corners[0].x).toBeCloseTo(90);
@@ -198,7 +199,7 @@ test('Test Text.getTextFrameCorners', () => {
   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
+  rightAlignedtext.setProperty('verticalAlignment', 3); // top
   corners = rightAlignedtext.getTextFrameCorners();
 
   expect(corners[0].x).toBeCloseTo(90);
@@ -219,47 +220,47 @@ test('Test Text.setRotation', () => {
 
   // Zero
   setRotText.setRotation(0);
-  expect(setRotText.rotation).toBeCloseTo(0);
+  expect(setRotText.getProperty('rotation')).toBeCloseTo(0);
 
   // Positive
   setRotText.setRotation(22.5);
-  expect(setRotText.rotation).toBe(22.5);
+  expect(setRotText.getProperty('rotation')).toBe(22.5);
 
   setRotText.setRotation(23);
-  expect(setRotText.rotation).toBe(23);
+  expect(setRotText.getProperty('rotation')).toBe(23);
 
   setRotText.setRotation(45);
-  expect(setRotText.rotation).toBe(45);
+  expect(setRotText.getProperty('rotation')).toBe(45);
 
   setRotText.setRotation(90);
-  expect(setRotText.rotation).toBe(90);
+  expect(setRotText.getProperty('rotation')).toBe(90);
 
   setRotText.setRotation(135);
-  expect(setRotText.rotation).toBe(135);
+  expect(setRotText.getProperty('rotation')).toBe(135);
 
   setRotText.setRotation(180);
-  expect(setRotText.rotation).toBe(180);
+  expect(setRotText.getProperty('rotation')).toBe(180);
 
   setRotText.setRotation(225);
-  expect(setRotText.rotation).toBe(225);
+  expect(setRotText.getProperty('rotation')).toBe(225);
 
   setRotText.setRotation(270);
-  expect(setRotText.rotation).toBe(270);
+  expect(setRotText.getProperty('rotation')).toBe(270);
 
   // Greater than 360
   setRotText.setRotation((360 + 90));
-  expect(setRotText.rotation).toBe(90);
+  expect(setRotText.getProperty('rotation')).toBe(90);
 
   // Negative
   setRotText.setRotation(-22.5);
-  expect(setRotText.rotation).toBe(337.5);
+  expect(setRotText.getProperty('rotation')).toBe(337.5);
 
   setRotText.setRotation(-90);
-  expect(setRotText.rotation).toBe(270);
+  expect(setRotText.getProperty('rotation')).toBe(270);
 
   // precision - rounds to closest 5 dp
   setRotText.setRotation(10.123456789);
-  expect(setRotText.rotation).toBe(10.12346);
+  expect(setRotText.getProperty('rotation')).toBe(10.12346);
 });
 
 
@@ -307,13 +308,13 @@ test('Test Text.flags', () => {
   const text = new Text();
   expect(text.flags.getFlagValue()).toBe(0);
   // set backwards - set 2 on flags
-  text.backwards = true;
+  text.setProperty('backwards', true);
   expect(text.flags.getFlagValue()).toBe(2);
   // set upsideDown - set 4 on flags
-  text.upsideDown = true;
+  text.setProperty('upsideDown', true);
   expect(text.flags.getFlagValue()).toBe(6);
   // unset backwards - remove 2 on flags
-  text.backwards = false;
+  text.setProperty('backwards', false);
   expect(text.flags.getFlagValue()).toBe(4);
 });
 
@@ -322,10 +323,10 @@ test('Test Text.backwards', () => {
   // 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.getProperty('backwards')).toBe(false);
   expect(text.flags.getFlagValue()).toBe(0);
-  text.backwards = true;
-  expect(text.backwards).toBe(true);
+  text.setProperty('backwards', true);
+  expect(text.getProperty('backwards')).toBe(true);
   expect(text.flags.getFlagValue()).toBe(2);
 });
 
@@ -334,10 +335,10 @@ test('Test Text.upsideDown', () => {
   // 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.getProperty('upsideDown')).toBe(false);
   expect(text.flags.getFlagValue()).toBe(0);
-  text.upsideDown = true;
-  expect(text.upsideDown).toBe(true);
+  text.setProperty('upsideDown', true);
+  expect(text.getProperty('upsideDown')).toBe(true);
   expect(text.flags.getFlagValue()).toBe(4);
 });
 
@@ -388,7 +389,15 @@ AcDbText
   expect(file.contents).toEqual(dxfString);
 
   // create new entity from entity data to ensure all props are loaded
-  const newText = new Text(text);
+  const newText = new Text({
+    handle: text.getProperty('handle'),
+    points: text.points,
+    string: text.getProperty('string'),
+    height: text.getProperty('height'),
+    styleName: text.getProperty('styleName'),
+    horizontalAlignment: text.getProperty('horizontalAlignment'),
+    verticalAlignment: text.getProperty('verticalAlignment'),
+  });
   file = new File();
   newText.dxf(file);
   expect(file.contents).toEqual(dxfString);
@@ -399,9 +408,17 @@ AcDbText
   // 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
+  const centeredText = new Text({
+    handle: text.getProperty('handle'),
+    points: text.points,
+    string: text.getProperty('string'),
+    height: text.getProperty('height'),
+    styleName: text.getProperty('styleName'),
+    horizontalAlignment: text.getProperty('horizontalAlignment'),
+    verticalAlignment: text.getProperty('verticalAlignment'),
+  });
+  centeredText.setProperty('horizontalAlignment', 1); // center
+  centeredText.setProperty('verticalAlignment', 2); // middle
   file = new File();
   centeredText.dxf(file);
 
@@ -445,7 +462,15 @@ AcDbText
   expect(file.contents).toEqual(dxfCenteredString);
 
   // create new entity from entity data to ensure all props are loaded
-  const importCenteredText = new Text(centeredText);
+  const importCenteredText = new Text({
+    handle: centeredText.getProperty('handle'),
+    points: centeredText.points,
+    string: centeredText.getProperty('string'),
+    height: centeredText.getProperty('height'),
+    styleName: centeredText.getProperty('styleName'),
+    horizontalAlignment: centeredText.getProperty('horizontalAlignment'),
+    verticalAlignment: centeredText.getProperty('verticalAlignment'),
+  });
   file = new File();
   importCenteredText.dxf(file);
   expect(file.contents).toEqual(dxfCenteredString);
@@ -454,11 +479,11 @@ AcDbText
 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');
+  expect(t.getProperty('string')).toBe('');
+  expect(t.getProperty('height')).toBe(2.5);
+  expect(t.getProperty('horizontalAlignment')).toBe(0);
+  expect(t.getProperty('verticalAlignment')).toBe(0);
+  expect(t.getProperty('styleName')).toBe('STANDARD');
 
   // All DXF groupcodes
   t = new Text({
@@ -478,49 +503,49 @@ test('Text constructor covers all property branches', () => {
     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(['abc', 'def']).toContain(t.getProperty('string'));
+  expect(['FOO', 'BAR']).toContain(t.getProperty('styleName'));
+  expect([5, 6]).toContain(t.getProperty('height'));
+  expect([45, 90]).toContain(t.getProperty('rotation'));
+  expect([2, 1]).toContain(t.getProperty('horizontalAlignment'));
+  expect([3, 2]).toContain(t.getProperty('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);
+  expect(Text.getApproximateWidth('abc', 10)).toBeCloseTo(16.2);
 });
 
 test('Text getHorizontalAlignment covers all cases', () => {
   const t = new Text({ points: [new Point()] });
-  t.horizontalAlignment = 0;
+  t.setProperty('horizontalAlignment', 0);
   expect(t.getHorizontalAlignment()).toBe('left');
-  t.horizontalAlignment = 1;
+  t.setProperty('horizontalAlignment', 1);
   expect(t.getHorizontalAlignment()).toBe('center');
-  t.horizontalAlignment = 2;
+  t.setProperty('horizontalAlignment', 2);
   expect(t.getHorizontalAlignment()).toBe('right');
-  t.horizontalAlignment = 3; t.verticalAlignment = 0;
+  t.setProperty('horizontalAlignment', 3); t.setProperty('verticalAlignment', 0);
   expect(t.getHorizontalAlignment()).toBe('aligned');
-  t.horizontalAlignment = 4; t.verticalAlignment = 0;
+  t.setProperty('horizontalAlignment', 4); t.setProperty('verticalAlignment', 0);
   expect(t.getHorizontalAlignment()).toBe('center');
-  t.horizontalAlignment = 5; t.verticalAlignment = 0;
+  t.setProperty('horizontalAlignment', 5); t.setProperty('verticalAlignment', 0);
   expect(t.getHorizontalAlignment()).toBe('fit');
-  t.horizontalAlignment = 99;
+  t.setProperty('horizontalAlignment', 99);
   expect(t.getHorizontalAlignment()).toBe('left');
 });
 
 test('Text getVerticalAlignment covers all cases', () => {
   const t = new Text({ points: [new Point()] });
-  t.verticalAlignment = 0;
+  t.setProperty('verticalAlignment', 0);
   expect(t.getVerticalAlignment()).toBe('alphabetic');
-  t.verticalAlignment = 1;
+  t.setProperty('verticalAlignment', 1);
   expect(t.getVerticalAlignment()).toBe('bottom');
-  t.verticalAlignment = 2;
+  t.setProperty('verticalAlignment', 2);
   expect(t.getVerticalAlignment()).toBe('middle');
-  t.verticalAlignment = 3;
+  t.setProperty('verticalAlignment', 3);
   expect(t.getVerticalAlignment()).toBe('top');
-  t.verticalAlignment = 99;
+  t.setProperty('verticalAlignment', 99);
   expect(t.getVerticalAlignment()).toBe('alphabetic');
 });
 
@@ -578,13 +603,13 @@ test('Text toPolylinePoints returns correct array', () => {
 test('Text setBackwards and setUpsideDown edge cases', () => {
   const t = new Text({ points: [new Point()] });
   t.setBackwards(true);
-  expect(t.backwards).toBe(true);
+  expect(t.getProperty('backwards')).toBe(true);
   t.setBackwards(false);
-  expect(t.backwards).toBe(false);
+  expect(t.getProperty('backwards')).toBe(false);
   t.setUpsideDown(true);
-  expect(t.upsideDown).toBe(true);
+  expect(t.getProperty('upsideDown')).toBe(true);
   t.setUpsideDown(false);
-  expect(t.upsideDown).toBe(false);
+  expect(t.getProperty('upsideDown')).toBe(false);
 });
 
 test('Text setRotation handles undefined and height 0', () => {
@@ -611,8 +636,8 @@ test('Text.execute re-prompts on zero or negative height', async () => {
     const text = new Text({});
     await text.execute();
 
-    expect(text.height).toBe(5);
-    expect(text.string).toBe('Hello');
+    expect(text.getProperty('height')).toBe(5);
+    expect(text.getProperty('string')).toBe('Hello');
   });
 });
 
@@ -624,7 +649,7 @@ test('Text.execute does not create entity for empty string', async () => {
     const text = new Text({});
     await text.execute();
 
-    expect(text.string).toBe('');
+    expect(text.getProperty('string')).toBe('');
   }, { extraMethods: { executeCommand: () => {
     executeCommandCalled = true;
   } } });
@@ -639,3 +664,203 @@ test('Text.snaps node snap position matches points[0]', () => {
   expect(nodeSnaps[0].snapPoint.x).toBe(5);
   expect(nodeSnaps[0].snapPoint.y).toBe(10);
 });
+
+test('Text.preview - uses rubber band when not waiting for string input', () => {
+  const text = new Text({ points: [new Point(5, 5)] });
+  DesignCore.Scene.auxiliaryEntities.clear();
+  DesignCore.Scene.previewEntities.clear();
+  // Simulate a pending POINT prompt (not STRING)
+  DesignCore.Scene.inputManager.promptOption = { types: [Input.Type.POINT] };
+
+  text.preview();
+
+  expect(DesignCore.Scene.auxiliaryEntities.count()).toBeGreaterThanOrEqual(1);
+  expect(DesignCore.Scene.previewEntities.count()).toBe(0);
+
+  DesignCore.Scene.inputManager.promptOption = undefined;
+});
+
+test('Text.preview - shows text entity when waiting for string input', () => {
+  const text = new Text({ points: [new Point(5, 5)], height: 5, rotation: 0, string: '' });
+  DesignCore.Scene.auxiliaryEntities.clear();
+  DesignCore.Scene.previewEntities.clear();
+  // Simulate a pending STRING prompt
+  DesignCore.Scene.inputManager.promptOption = { types: [Input.Type.STRING] };
+
+  text.preview();
+
+  expect(DesignCore.Scene.previewEntities.count()).toBeGreaterThanOrEqual(1);
+  expect(DesignCore.Scene.auxiliaryEntities.count()).toBe(0);
+
+  DesignCore.Scene.inputManager.promptOption = undefined;
+});
+
+test('Text.getApproximateWidth unknown character uses fallback width', () => {
+  // Unknown characters fall back to 0.56 em per character
+  const unknown = Text.getApproximateWidth('€', 10);
+  expect(unknown).toBeCloseTo(5.6);
+});
+
+test('Text.getApproximateWidth empty string returns 0', () => {
+  expect(Text.getApproximateWidth('', 10)).toBe(0);
+});
+
+test('Text setRotation with height 0 does not move points[1]', () => {
+  const t = new Text({ points: [new Point(0, 0)] });
+  t.setProperty('height', 0);
+  const originalPoint1 = t.points[1];
+  t.setRotation(45);
+  expect(t.points[1]).toBe(originalPoint1);
+});
+
+test('Text.fromDxf remaps insertion point from sequence-11 point', () => {
+  // When DXF points[1] has sequence == 11, fromDxf uses it as the insertion point (points[0])
+  const data = Text.fromDxf({
+    points: [
+      { x: 0, y: 0 },
+      { x: 50, y: 75, sequence: 11 },
+    ],
+  });
+  const t = new Text(data);
+  expect(t.points[0].x).toBe(50);
+  expect(t.points[0].y).toBe(75);
+});
+
+test('Text getHorizontalAlignment unsupported cases return left when verticalAlignment !== 0', () => {
+  const t = new Text({ points: [new Point()] });
+  t.setProperty('verticalAlignment', 1); // non-zero
+
+  t.setProperty('horizontalAlignment', 3);
+  expect(t.getHorizontalAlignment()).toBe('left');
+
+  t.setProperty('horizontalAlignment', 4);
+  expect(t.getHorizontalAlignment()).toBe('left');
+
+  t.setProperty('horizontalAlignment', 5);
+  expect(t.getHorizontalAlignment()).toBe('left');
+});
+
+test('Text.dxf includes non-zero flags and rotation', () => {
+  const text = new Text({ handle: '1', points: [new Point(0, 0)] });
+  text.setProperty('backwards', true); // flag value 2
+  text.setProperty('upsideDown', true); // flag value 4  → combined = 6
+  text.setRotation(90);
+  text.setProperty('string', 'R');
+
+  const file = new File();
+  text.dxf(file);
+
+  expect(file.contents).toContain('71\n6\n');
+  expect(file.contents).toContain('50\n90\n');
+});
+
+test('Text.toCharacters returns one entry with scene coords, rotation and string', () => {
+  const text = new Text({ points: [new Point(5, 10), new Point(15, 10)], string: 'Hello', height: 2.5, rotation: 0 });
+  const chars = text.toCharacters();
+  expect(chars).toHaveLength(1);
+  expect(chars[0].char).toBe('Hello');
+  expect(typeof chars[0].x).toBe('number');
+  expect(typeof chars[0].y).toBe('number');
+  expect(chars[0].rotation).toBeCloseTo(0);
+  expect(chars[0].upsideDownOffset).toBe(0);
+  expect(chars[0].backwardsOffset).toBe(0);
+});
+
+test('Text.toCharacters returns empty array for empty string', () => {
+  const text = new Text({ points: [new Point(0, 0), new Point(10, 0)], string: '', height: 2.5 });
+  expect(text.toCharacters()).toEqual([]);
+});
+
+test('Text.draw calls renderer.drawText with correct font and string', () => {
+  const text = new Text({ points: [new Point(0, 0), new Point(10, 0)], string: 'Hello', height: 2.5 });
+  let calledChars; let calledHeight;
+  const mockRenderer = {
+    drawText(characters, fontName, height) {
+      calledChars = characters;
+      calledHeight = height;
+    },
+    measureText: () => ({ width: 20 }),
+  };
+  text.draw(mockRenderer);
+  expect(calledChars).toHaveLength(1);
+  expect(calledChars[0].char).toBe('Hello');
+  expect(calledHeight).toBe(2.5);
+});
+
+test('Text.draw skips call for empty string', () => {
+  const text = new Text({ points: [new Point(0, 0), new Point(10, 0)], string: '', height: 2.5 });
+  let drawTextCalled = false;
+  const mockRenderer = { drawText() {
+    drawTextCalled = true;
+  }, measureText() {} };
+  text.draw(mockRenderer);
+  expect(drawTextCalled).toBe(false);
+});
+
+test('Text.draw updates boundingRect from measureText result', () => {
+  const text = new Text({ points: [new Point(0, 0), new Point(10, 0)], string: 'Hi', height: 3 });
+  const mockRenderer = {
+    drawText() {},
+    measureText: () => ({ width: 42 }),
+  };
+  text.draw(mockRenderer);
+  expect(text.boundingRect.width).toBe(42);
+  expect(text.boundingRect.height).toBe(3);
+});
+
+describe('Text.fromDxf', () => {
+  test('projects points[1] from rotation angle (group code 50)', () => {
+    const data = Text.fromDxf({
+      points: [new Point(10, 20)],
+      50: 90,
+      40: 2.5,
+    });
+    const t = new Text(data);
+    expect(t.getProperty('rotation')).toBeCloseTo(90);
+    expect(t.points[1].x).toBeCloseTo(10);
+    expect(t.points[1].y).toBeCloseTo(22.5);
+  });
+
+  test('remaps sequence-11 alignment point to points[0]', () => {
+    const data = Text.fromDxf({
+      points: [
+        new Point(0, 0),
+        { x: 30, y: 40, sequence: 11 },
+      ],
+    });
+    const t = new Text(data);
+    expect(t.points[0].x).toBe(30);
+    expect(t.points[0].y).toBe(40);
+  });
+
+  test('preserves other properties unchanged', () => {
+    const data = Text.fromDxf({
+      points: [new Point(0, 0)],
+      1: 'hello',
+      40: 5,
+      layer: 'TEST',
+    });
+    expect(data[1]).toBe('hello');
+    expect(data[40]).toBe(5);
+    expect(data.layer).toBe('TEST');
+  });
+
+  test('returns data unchanged when no points present', () => {
+    const data = Text.fromDxf({ 1: 'abc' });
+    expect(data[1]).toBe('abc');
+    expect(data.points).toEqual([]);
+  });
+
+  test('result equivalent to direct construction with setRotation', () => {
+    const pt = new Point(5, 10);
+    const fromDxfData = Text.fromDxf({ points: [pt], 50: 45, 40: 2.5 });
+    const t1 = new Text(fromDxfData);
+
+    const t2 = new Text({ points: [pt] });
+    t2.setRotation(45);
+
+    expect(t1.points[0].x).toBeCloseTo(t2.points[0].x);
+    expect(t1.points[0].y).toBeCloseTo(t2.points[0].y);
+    expect(t1.getProperty('rotation')).toBeCloseTo(t2.getProperty('rotation'));
+  });
+});

package/test/integration/exportIntegration.reference.dxf

@@ -861,7 +861,7 @@ AcDbViewportTableRecord
 21
 1.0
 12
-142.5
+145
 22
 142.5
 13
@@ -891,7 +891,7 @@ AcDbViewportTableRecord
 40
 275
 41
-0.9272727272727272
+0.9454545454545454
 42
 50.0
 43
@@ -1133,7 +1133,7 @@ ByLayer
 31
 0.0
 39
-2
+1
 0
 ENDBLK
 5
@@ -1173,7 +1173,7 @@ ByLayer
 31
 0.0
 39
-2
+1
 0
 TEXT
 5
@@ -1221,7 +1221,7 @@ ByLayer
 30
 0.0
 39
-2
+1
 40
 25
 0
@@ -1271,9 +1271,9 @@ ByLayer
 30
 0.0
 39
-2
-40
 1
+40
+25
 100
 AcDbArc
 50
@@ -1377,7 +1377,7 @@ POLYLINE_LAYER
 6
 ByLayer
 39
-2
+1
 90
 4
 70
@@ -1447,7 +1447,7 @@ LWPOLYLINE_LAYER
 6
 ByLayer
 39
-2
+1
 90
 4
 70

package/test/integration/exportIntegration.test.js

@@ -113,13 +113,13 @@ beforeAll(() => {
     patternName: 'ANSI31',
     layer: 'HATCH_LAYER',
   });
-  hatch.childEntities = [boundary];
+  hatch.setProperty('childEntities', [boundary]);
   core.scene.entities.add(hatch);
   core.scene.entities.add(new Text({ points: [new Point(15, 205)], string: 'Hatch', height: 4 }));
 
   // Row 2, Col 1: Insert
   const blockLine = new Line({ points: [new Point(0, 0), new Point(40, 40)] });
-  blockLine.handle = DesignCore.HandleManager.next();
+  blockLine.setProperty('handle', DesignCore.HandleManager.next());
   const block = DesignCore.Scene.blockManager.addItem({
     name: 'TEST_BLOCK',
     items: [blockLine],

package/test/integration/intersectionIntegration.test.js

@@ -285,7 +285,7 @@ describe('Entity.touched - selection rectangle intersection', () => {
       const charPos = pts[0];
       const sE = selectionExtremes(
           new Point(charPos.x - 5, charPos.y - 5),
-          new Point(charPos.x + 5, charPos.y + 5),
+          new Point(charPos.x + 1, charPos.y + 5),
       );
       expect(arcText.touched(sE)).toBe(true);
     }
@@ -705,7 +705,7 @@ describe('Hatch touched tests', () => {
     const boundary = new Polyline({
       points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100), new Point(0, 0)],
     });
-    hatch.childEntities.push(boundary);
+    hatch.setProperty('childEntities', [boundary]);
 
     // Selection rectangle crossing the boundary
     const sE = selectionExtremes(new Point(-5, 50), new Point(5, 60));
@@ -717,7 +717,7 @@ describe('Hatch touched tests', () => {
     const boundary = new Polyline({
       points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10), new Point(0, 0)],
     });
-    hatch.childEntities.push(boundary);
+    hatch.setProperty('childEntities', [boundary]);
 
     // Selection rectangle far from hatch
     const sE = selectionExtremes(new Point(500, 500), new Point(600, 600));
@@ -732,8 +732,7 @@ describe('Hatch touched tests', () => {
     const boundary2 = new Polyline({
       points: [new Point(50, 50), new Point(60, 50), new Point(60, 60), new Point(50, 60), new Point(50, 50)],
     });
-    hatch.childEntities.push(boundary1);
-    hatch.childEntities.push(boundary2);
+    hatch.setProperty('childEntities', [boundary1, boundary2]);
 
     // Touch only the second boundary
     const sE = selectionExtremes(new Point(48, 55), new Point(52, 58));