@design-core/core 0.0.1 → 0.0.3

package/test/integration/exportIntegration.test.js

@@ -0,0 +1,186 @@
+import { Core } from '../../core/core/core.js';
+import { DesignCore } from '../../core/designCore.js';
+import { Point } from '../../core/entities/point.js';
+import { Line } from '../../core/entities/line.js';
+import { Circle } from '../../core/entities/circle.js';
+import { Arc } from '../../core/entities/arc.js';
+import { Text } from '../../core/entities/text.js';
+import { Polyline } from '../../core/entities/polyline.js';
+import { Lwpolyline } from '../../core/entities/lwpolyline.js';
+// import { Solid } from '../../core/entities/solid.js';
+import { Hatch } from '../../core/entities/hatch.js';
+import { Insert } from '../../core/entities/insert.js';
+// import { ArcAlignedText } from '../../core/entities/arctext.js';
+import { BasePolyline } from '../../core/entities/basePolyline.js';
+
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+let core;
+
+beforeAll(() => {
+  core = new Core();
+
+  // Entities are arranged in a 3x3 grid of 100x100 cells:
+  //
+  //   Row 2 (y=200-300): | Hatch        | Insert       |
+  //   Row 1 (y=100-200): | Text         | Polyline     | Lwpolyline   |
+  //   Row 0 (y=0-100):   | Line         | Circle       | Arc          |
+
+  // Add layers for each entity type
+  DesignCore.LayerManager.addItem({ name: 'LINE_LAYER' });
+  DesignCore.LayerManager.addItem({ name: 'CIRCLE_LAYER' });
+  DesignCore.LayerManager.addItem({ name: 'ARC_LAYER' });
+  DesignCore.LayerManager.addItem({ name: 'TEXT_LAYER' });
+  DesignCore.LayerManager.addItem({ name: 'POLYLINE_LAYER' });
+  DesignCore.LayerManager.addItem({ name: 'LWPOLYLINE_LAYER' });
+  // DesignCore.LayerManager.addItem({ name: 'SOLID_LAYER' });
+  DesignCore.LayerManager.addItem({ name: 'HATCH_LAYER' });
+  DesignCore.LayerManager.addItem({ name: 'INSERT_LAYER' });
+  // DesignCore.LayerManager.addItem({ name: 'ARCTEXT_LAYER' });
+
+  // Row 0, Col 0: Line
+  const line = new Line({
+    points: [new Point(20, 25), new Point(80, 85)],
+    layer: 'LINE_LAYER',
+  });
+  core.scene.entities.add(line);
+  core.scene.entities.add(new Text({ points: [new Point(15, 5)], string: 'Line', height: 4 }));
+
+  // Row 0, Col 1: Circle
+  const circle = new Circle({
+    points: [new Point(150, 55)],
+    radius: 25,
+    layer: 'CIRCLE_LAYER',
+  });
+  core.scene.entities.add(circle);
+  core.scene.entities.add(new Text({ points: [new Point(115, 5)], string: 'Circle', height: 4 }));
+
+  // Row 0, Col 2: Arc
+  const arc = new Arc({
+    points: [new Point(250, 55)],
+    radius: 25,
+    startAngle: 0,
+    endAngle: 270,
+    layer: 'ARC_LAYER',
+  });
+  core.scene.entities.add(arc);
+  core.scene.entities.add(new Text({ points: [new Point(215, 5)], string: 'Arc', height: 4 }));
+
+  // Row 1, Col 0: Text
+  const text = new Text({
+    points: [new Point(25, 150)],
+    string: 'Hello',
+    height: 8,
+    layer: 'TEXT_LAYER',
+  });
+  core.scene.entities.add(text);
+  core.scene.entities.add(new Text({ points: [new Point(15, 105)], string: 'Text', height: 4 }));
+
+  // Row 1, Col 1: Polyline
+  const polyline = new Polyline({
+    points: [new Point(130, 130), new Point(170, 130), new Point(170, 175), new Point(130, 175)],
+    layer: 'POLYLINE_LAYER',
+  });
+  core.scene.entities.add(polyline);
+  core.scene.entities.add(new Text({ points: [new Point(115, 105)], string: 'Polyline', height: 4 }));
+
+  // Row 1, Col 2: Lwpolyline
+  const lwpolyline = new Lwpolyline({
+    points: [new Point(230, 130), new Point(270, 130), new Point(270, 175), new Point(230, 175)],
+    layer: 'LWPOLYLINE_LAYER',
+  });
+  core.scene.entities.add(lwpolyline);
+  core.scene.entities.add(new Text({ points: [new Point(215, 105)], string: 'Lwpolyline', height: 4 }));
+
+  // Solid - not registered as a command, cannot be imported
+  // const solid = new Solid({
+  //   points: [new Point(20, 225), new Point(80, 225), new Point(50, 280)],
+  //   layer: 'SOLID_LAYER',
+  // });
+  // core.scene.entities.add(solid);
+  // core.scene.entities.add(new Text({ points: [new Point(15, 205)], string: 'Solid', height: 4 }));
+
+  // Row 2, Col 0: Hatch
+  const boundary = new BasePolyline({
+    points: [new Point(25, 230), new Point(75, 230), new Point(75, 280), new Point(25, 280)],
+  });
+  const hatch = new Hatch({
+    patternName: 'ANSI31',
+    layer: 'HATCH_LAYER',
+  });
+  hatch.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();
+  const block = DesignCore.Scene.blockManager.addItem({
+    name: 'TEST_BLOCK',
+    items: [blockLine],
+  });
+  const insert = new Insert({
+    points: [new Point(130, 235)],
+    layer: 'INSERT_LAYER',
+  });
+  insert.block = block;
+  core.scene.entities.add(insert);
+  core.scene.entities.add(new Text({ points: [new Point(115, 205)], string: 'Insert', height: 4 }));
+
+  // ArcAlignedText - omitted
+  // const arctext = new ArcAlignedText({
+  //   points: [new Point(250, 255)],
+  //   radius: 25,
+  //   string: 'ArcText',
+  //   height: 5,
+  //   startAngle: 0,
+  //   endAngle: 180,
+  //   layer: 'ARCTEXT_LAYER',
+  // });
+  // core.scene.entities.add(arctext);
+  // core.scene.entities.add(new Text({ points: [new Point(215, 205)], string: 'ArcText', height: 4 }));
+});
+
+let dxfOutput;
+
+beforeAll(() => {
+  dxfOutput = core.saveFile('R2018');
+});
+
+test('Test DXF output contains all entities', () => {
+  expect(dxfOutput).toContain('LINE');
+  expect(dxfOutput).toContain('CIRCLE');
+  expect(dxfOutput).toContain('ARC');
+  expect(dxfOutput).toContain('TEXT');
+  expect(dxfOutput).toContain('POLYLINE');
+  expect(dxfOutput).toContain('LWPOLYLINE');
+  // expect(dxfOutput).toContain('SOLID');
+  expect(dxfOutput).toContain('HATCH');
+  expect(dxfOutput).toContain('INSERT');
+  // expect(dxfOutput).toContain('ARCALIGNEDTEXT');
+});
+
+test('Test DXF output contains all layers', () => {
+  expect(dxfOutput).toContain('LINE_LAYER');
+  expect(dxfOutput).toContain('CIRCLE_LAYER');
+  expect(dxfOutput).toContain('ARC_LAYER');
+  expect(dxfOutput).toContain('TEXT_LAYER');
+  expect(dxfOutput).toContain('POLYLINE_LAYER');
+  expect(dxfOutput).toContain('LWPOLYLINE_LAYER');
+  // expect(dxfOutput).toContain('SOLID_LAYER');
+  expect(dxfOutput).toContain('HATCH_LAYER');
+  expect(dxfOutput).toContain('INSERT_LAYER');
+  // expect(dxfOutput).toContain('ARCTEXT_LAYER');
+});
+
+test('Test DXF output matches reference file', () => {
+  const referencePath = join(__dirname, 'exportIntegration.reference.dxf');
+  const reference = readFileSync(referencePath, 'utf8');
+
+  expect(dxfOutput).toBe(reference);
+});

package/test/integration/importExportIntegration.test.js

@@ -0,0 +1,126 @@
+import { Core } from '../../core/core/core.js';
+import { DXF } from '../../core/lib/dxf/dxf.js';
+
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Strip handle values from a DXF string so that comparison
+ * is insensitive to handle allocation order.
+ * Only group codes that contain hex handles are stripped.
+ * Values are validated as hex before stripping.
+ * @param {string} dxfString
+ * @return {{stripped: string, invalidHandles: Array<{line: number, code: number, value: string}>}}
+ */
+function stripHandles(dxfString) {
+  const lines = dxfString.split('\n');
+  const invalidHandles = [];
+  let inDimStyle = false;
+
+  // DXF lines alternate: group code, value, group code, value...
+  for (let i = 0; i < lines.length - 1; i += 2) {
+    const code = parseInt(lines[i].trim(), 10);
+    if (isNaN(code)) continue;
+
+    const value = lines[i + 1].trim();
+
+    // Track DIMSTYLE context - groupcode 5 is an arrowhead
+    // block name in DIMSTYLE, not a handle (DIMSTYLE uses 105)
+    if (code === 0) {
+      inDimStyle = value === 'DIMSTYLE';
+    }
+
+    // Groupcode 5 = entity/table handle (except in DIMSTYLE)
+    // Groupcode 105 = dimstyle handle
+    // Groupcode 350 = dictionary entry handle
+    // Groupcode 390 = plotStyleHandle
+    const isHandleCode = (code === 5 && !inDimStyle) ||
+                         code === 105 || code === 350 || code === 390;
+
+    if (isHandleCode) {
+      if (/^[0-9A-Fa-f]+$/.test(value)) {
+        lines[i + 1] = '0';
+      } else {
+        invalidHandles.push({ line: i + 2, code, value });
+      }
+    }
+  }
+
+  return { stripped: lines.join('\n'), invalidHandles };
+}
+
+test('Test DXF round-trip: read reference and re-output matches', () => {
+  const core = new Core();
+
+  const referencePath = join(__dirname, 'exportIntegration.reference.dxf');
+  const reference = readFileSync(referencePath, 'utf8');
+
+  // Load the reference DXF
+  const dxf = new DXF();
+  dxf.loadDxf(reference);
+
+  // Output a new DXF
+  const output = core.saveFile('R2018');
+
+  const strippedOutput = stripHandles(output);
+  const strippedReference = stripHandles(reference);
+
+  expect(strippedOutput.invalidHandles).toEqual([]);
+  expect(strippedReference.invalidHandles).toEqual([]);
+  expect(strippedOutput.stripped).toBe(strippedReference.stripped);
+});
+
+test('Test DXF output has no duplicate handles', () => {
+  const core = new Core();
+
+  const referencePath = join(__dirname, 'exportIntegration.reference.dxf');
+  const reference = readFileSync(referencePath, 'utf8');
+
+  // Load the reference DXF
+  const dxf = new DXF();
+  dxf.loadDxf(reference);
+
+  // Output a new DXF
+  const output = core.saveFile('R2018');
+  const lines = output.split('\n');
+
+  const handles = new Map();
+  let inDimStyle = false;
+  let isHandseed = false;
+
+  for (let i = 0; i < lines.length - 1; i += 2) {
+    const code = parseInt(lines[i].trim(), 10);
+    if (isNaN(code)) continue;
+
+    const value = lines[i + 1].trim();
+
+    if (code === 0) {
+      inDimStyle = value === 'DIMSTYLE';
+    }
+
+    // $HANDSEED uses groupcode 5 for its value, not as a handle
+    if (code === 9 && value === '$HANDSEED') {
+      isHandseed = true;
+      continue;
+    }
+
+    // Only check groupcode 5 handles (entity/table handles)
+    // Skip DIMSTYLE where code 5 is arrowhead block name
+    // Skip $HANDSEED value
+    if (code === 5 && !inDimStyle && !isHandseed && /^[0-9A-Fa-f]+$/.test(value)) {
+      const lineNum = i + 2;
+      if (handles.has(value)) {
+        fail(`Duplicate handle ${value} at line ${lineNum} (first seen at line ${handles.get(value)})`);
+      }
+      handles.set(value, lineNum);
+    }
+
+    isHandseed = false;
+  }
+
+  expect(handles.size).toBeGreaterThan(0);
+});