Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

6.6 KB
Raw Blame
import assert from 'node:assert/strict';
import test from 'node:test';
import { ModelSession } from '../src/index.js';

test('imported provenance supplies face selectors and measured size without fabricating a native source span', () => {
  const model = new ModelSession({}, { revision: 1, mesh: {
    definitions: [{ id: 'part', ranges: [{ startTriangle: 0, triangleCount: 2, faceId: 'face:7',
      semanticEntityId: 'part', sourceAddressability: 'ImportedStable', selector: 'part.face("#191")', surfaceKind: 'Cylinder', diameterMm: 2 }] }],
    occurrences: [{ id: 'part:occurrence', definitionId: 'part', semanticEntityId: 'part' }],
  } });
  const picked = model.describeSelection('part', 0, 'part:occurrence');
  assert.equal(picked.selector, 'part.face("#191")');
  assert.equal(picked.diameterMm, 2);
  assert.equal(picked.surfaceKind, 'Cylinder');
  assert.equal(picked.sourceAddressable, false);
  assert.equal(picked.source, null);
});

test('display-only face identity never becomes a Firmament selector', () => {
  const session = new ModelSession({}, {
    mesh: {
      definitions: [{ id: 'definition', ranges: [{ startTriangle: 0, triangleCount: 2,
        faceId: 'face:5', semanticEntityId: 'body', sourceAddressability: 'RuntimeOnly',
        selector: null, selectorReason: 'No authored topology mapping' }] }],
      occurrences: [{ id: 'occurrence', definitionId: 'definition', semanticEntityId: 'body' }],
    },
  });
  const selection = session.describeSelection('definition', 1, 'occurrence');
  assert.equal(selection.faceId, 'face:5');
  assert.equal(selection.selector, null);
  assert.equal(selection.sourceAddressability, 'RuntimeOnly');
  assert.equal(selection.selectorReason, 'No authored topology mapping');
  assert.equal(session.describeSelection('definition', 2, 'occurrence'), null);
  assert.deepEqual(session.selectorCandidates(), []);
});

test('construction-owned face identity reaches picking and reverse source lookup', () => {
  const source = { source: 'box.firmament', line: 3, column: 5, start: 32, length: 8 };
  const range = { startTriangle: 0, triangleCount: 2, faceId: 'face:2', semanticEntityId: 'Body',
    semanticTopologyId: 'Body.face(+Z)', topologyKind: 'Face', originFeature: 'Body',
    sourceAddressability: 'DerivedStable', selector: 'face(+Z)', source, buildRevision: 4 };
  const session = new ModelSession({}, { revision: 4, mesh: {
    definitions: [{ id: 'definition', ranges: [range] }],
    occurrences: [{ id: 'occurrence', definitionId: 'definition', semanticEntityId: 'Body' }],
  } });
  const picked = session.describeSelection('definition', 1, 'occurrence');
  assert.equal(picked.semanticTopologyId, 'Body.face(+Z)');
  assert.equal(picked.selector, 'face(+Z)');
  assert.equal(picked.sourceAddressability, 'DerivedStable');
  assert.equal(picked.sourceAddressable, true);
  assert.deepEqual(picked.source, source);
  assert.equal(picked.buildRevision, 4);
  assert.deepEqual(session.selectionForSemanticId('Body.face(+Z)')[0].faceId, 'face:2');
  assert.equal(session.selectionForSourceSymbol('Body').length, 1);
  assert.equal(session.geometrySourceMap()[0].semanticKey, 'Body.face(+Z)');
  assert.equal(session.geometrySourceMap()[0].source.start, 32);
  assert.deepEqual(session.selectorCandidates().map(item => item.selector), ['face(+Z)']);
});

test('BRep edges preserve construction metadata without inventing source selectors', () => {
  const source = { source: 'box.firmament', line: 2, column: 3, start: 18, length: 42 };
  const session = new ModelSession({}, { revision: 2, mesh: {
    definitions: [{ id: 'definition', ranges: [], edges: [
      { edgeId: 'edge:7', points: [[0, 0, 0], [1, 0, 0]], closed: false, semanticEntityId: 'Body', semanticTopologyId: 'Body.edge(TopFront)', sourceAddressability: 'DerivedStable', selector: null, selectorReason: 'No qualified edge selector', source },
      { edgeId: 'edge:8', points: [[0, 0, 0], [0, 1, 0]], closed: false, sourceAddressability: 'RuntimeOnly', selector: null },
    ] }],
    occurrences: [{ id: 'occurrence', definitionId: 'definition', semanticEntityId: 'Body' }],
  } });
  const stable = session.describeEdgeSelection('definition', 'edge:7', 'occurrence');
  assert.equal(stable.semanticTopologyId, 'Body.edge(TopFront)');
  assert.deepEqual(stable.source, source);
  assert.equal(stable.sourceAddressable, true);
  assert.equal(stable.selector, null);
  const runtime = session.describeEdgeSelection('definition', 'edge:8', 'occurrence');
  assert.equal(runtime.semanticTopologyId, null);
  assert.equal(runtime.sourceAddressability, 'RuntimeOnly');
  assert.equal(runtime.selector, null);
  assert.equal(session.geometrySourceMap().filter(item => item.topologyKind === 'Edge').length, 2);
});

test('single-edge finish bindings survive picking only in their owning identity occurrence', () => {
  const edgeFinish = { body: 'Body', face: 'Bottom', target: 'Section.Outer.South', label: 'Extrusion end-face edge', filletSupported: false };
  const identity = [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1];
  const shifted = [...identity]; shifted[12] = 10;
  const session = new ModelSession({}, { mesh: {
    definitions: [{ id: 'part', ranges: [], edges: [{ edgeId: 'edge:1', points: [[0,0,0],[20,0,0]], closed: false, edgeFinish }] }],
    occurrences: [{ id: 'local', definitionId: 'part', transform: identity }, { id: 'placed', definitionId: 'part', transform: shifted }],
  } });
  assert.deepEqual(session.describeEdgeSelection('part', 'edge:1', 'local').edgeFinish, edgeFinish);
  assert.equal(session.describeEdgeSelection('part', 'edge:1', 'placed').edgeFinish, null);
  assert.equal(session.describeEdgeSelection('part', 'edge:99', 'local'), null);
});

test('a feature face keeps its owner inside a body occurrence', () => {
  const source = { source: 'hole.firmament', line: 4, column: 2, start: 65, length: 94 };
  const session = new ModelSession({}, { mesh: {
    definitions: [{ id: 'definition', ranges: [{ startTriangle: 0, triangleCount: 1, faceId: 'face:7', semanticEntityId: 'Body.H',
      semanticTopologyId: 'material:hole:Body.H:wall', sourceAddressability: 'DerivedStable', selector: 'face(H.Wall)', source }] }],
    occurrences: [{ id: 'occurrence', definitionId: 'definition', semanticEntityId: 'Body' }],
  } });
  const picked = session.describeSelection('definition', 0, 'occurrence');
  assert.equal(picked.semanticEntityId, 'Body.H');
  assert.equal(picked.sourceAddressable, true);
  assert.equal(picked.selector, 'face(H.Wall)');
  assert.deepEqual(picked.source, source);
  assert.equal(session.selectionForEntity('Body.H').ranges.length, 1);
  assert.deepEqual(session.selectorCandidates().map(item => item.selector), ['face(H.Wall)']);
});