@code3d/core 0.0.1-alpha.0 → 0.0.1-alpha.11

package/src/library/shell.ts

@@ -119,7 +119,7 @@ function openShell(
     return {
       shape: result,
       topology: transferShapeTopology(
-        [{shape, topology, index: 1}],
+        [{shape, topology, namespace: 'preserve'}],
         result,
         builder,
       ),
@@ -202,12 +202,12 @@ function closedShell(
       } finally {
         shells.delete();
       }
-      // Original boundaries retain their input paths for either direction. Offset
+      // Original boundaries retain their IDs for either direction. Offset
       // boundaries are new topology, even when OCCT has generation history.
       return {
         shape: result,
         topology: transferShapeTopology(
-          [{shape, topology, index: 1}],
+          [{shape, topology, namespace: 'preserve'}],
           result,
           cut,
         ),

package/src/library/sketch-solver.ts

@@ -1,4 +1,6 @@
-import type {GcsSystem, ModuleStatic} from '@salusoft89/planegcs';
+import type {GcsSystem} from '@salusoft89/planegcs/dist/planegcs_dist/gcs_system.js';
+// Upstream ships this declaration alongside sources, but omits it from dist.
+import type {ModuleStatic} from '@salusoft89/planegcs/planegcs_dist/planegcs.js';
 import type {SketchArcDirection, SketchPosition} from './sketch.js';
 import {sketchArcGeometry} from './sketch-curves.js';
 import {pointLineDistance} from './sketch-incidence.js';

package/src/library/sketch.ts

@@ -6,11 +6,16 @@ import {
 import {solveSketchDrag} from './sketch-drag-rules.js';
 import {sketchRegions} from './sketch-regions.js';
 import {
-  sketchFaceModel,
+  SketchFrame,
+  relate,
   disposeModelObjects,
   isModelObject,
+  type Relation,
+  type FaceAnchor,
   type FaceModel,
 } from './runtime.js';
+import {retainInspectionIdentity} from './inspect.js';
+import type {RigidTransform} from './spatial.js';
 import {
   sketchIncidences,
   sketchIncidencePoints,
@@ -85,6 +90,16 @@ export type SketchOptions = Readonly<{
 
 /** An immutable sketch definition, independent of B-Rep construction. */
 export interface Sketch {
+  /** The unbounded local XZ plane (+Y normal), independent of closed regions. */
+  readonly plane: FaceAnchor;
+  /**
+   * Relates a new frame without changing this sketch's two-dimensional data.
+   * Each constraint must involve callback self; external references keep their identity.
+   * @code3d.inspect relate.inspectCall
+   * @code3d.inspect.context build relate.inspectContext
+   * @code3d.inspect.closure build relate.inspectBody
+   */
+  relate(build: (self: Sketch) => Relation | readonly Relation[]): Sketch;
   /** References a point defined in this layer. */
   point(id: number): SketchPoint;
   /** Adds a local layer while retaining the upstream sketch as read-only input. */
@@ -110,13 +125,31 @@ type Definition = Readonly<{
 
 const definitions = new WeakMap<Sketch, Definition>();
 const references = new WeakSet<SketchPoint>();
+const framedSketches = new WeakMap<SketchFrame, Sketch>();
 
 class SketchValue implements Sketch {
+  readonly frame: SketchFrame;
+  readonly source?: Sketch;
+
   constructor(
-    entries?: readonly SketchEntry[],
-    options?: SketchOptions,
-    base?: Sketch,
+    input:
+      | {
+          entries?: readonly SketchEntry[];
+          options?: SketchOptions;
+          base?: Sketch;
+        }
+      | {source: Sketch; frame: SketchFrame},
   ) {
+    if ('source' in input) {
+      this.frame = input.frame;
+      framedSketches.set(this.frame, this);
+      this.source = input.source;
+      definitions.set(this, definitions.get(input.source)!);
+      return;
+    }
+    const {entries, options, base} = input;
+    this.frame = new SketchFrame(base && (base as SketchValue).frame);
+    framedSketches.set(this.frame, this);
     const ids = new Set<number>();
     const points = new Map<number, SketchPosition>();
     const copied = (entries ?? []).map<SketchEntry>(entry => {
@@ -164,6 +197,10 @@ class SketchValue implements Sketch {
       ancestor = definitions.get(ancestor)?.base
     )
       ancestors.add(ancestor);
+    const ancestorFor = (value: Sketch) =>
+      [...ancestors].find(
+        ancestor => definitions.get(ancestor) === definitions.get(value),
+      );
     for (const [kind, id, data] of copied) {
       if (kind === 'point' && Array.isArray(data)) continue;
       const refs =
@@ -180,7 +217,7 @@ class SketchValue implements Sketch {
             throw new Error(
               `Sketch ${kind} ${id} references missing local point ${ref}.`,
             );
-        } else if (!references.has(ref) || !ancestors.has(ref.sketch)) {
+        } else if (!references.has(ref) || !ancestorFor(ref.sketch)) {
           throw new Error(
             `Sketch ${kind} ${id} must reference a local or upstream point.`,
           );
@@ -209,7 +246,7 @@ class SketchValue implements Sketch {
       if (
         typeof ref === 'number'
           ? !points.has(ref)
-          : !references.has(ref) || !ancestors.has(ref.sketch)
+          : !references.has(ref) || !ancestorFor(ref.sketch)
       )
         throw new Error(
           'Sketch constraints must reference a local or upstream point.',
@@ -304,6 +341,7 @@ class SketchValue implements Sketch {
     const local = 'local';
     const layers = new Map<Sketch, string>();
     const identity = (value: Sketch) => {
+      value = ancestorFor(value) ?? value;
       let id = layers.get(value);
       if (!id) layers.set(value, (id = `upstream:${layers.size}`));
       return id;
@@ -345,8 +383,21 @@ class SketchValue implements Sketch {
     return ref;
   }
 
+  get plane(): FaceAnchor {
+    return this.frame.plane;
+  }
+
+  relate(build: (self: Sketch) => Relation | readonly Relation[]): Sketch {
+    let related!: SketchValue;
+    this.frame.relate(frame => {
+      related = new SketchValue({source: this, frame});
+      return build(related);
+    });
+    return related;
+  }
+
   derive(entries?: readonly SketchEntry[], options?: SketchOptions): Sketch {
-    return new SketchValue(entries, options, this);
+    return new SketchValue({entries, options, base: this});
   }
 
   face(): FaceModel {
@@ -355,14 +406,14 @@ class SketchValue implements Sketch {
       throw new Error(
         `sketch.face() requires exactly one closed region; found ${regions.length}. Use faces() for multiple regions.`,
       );
-    return sketchFaceModel(regions[0]);
+    return this.frame.face(regions[0]);
   }
 
   faces(): readonly FaceModel[] {
     const faces: FaceModel[] = [];
     try {
       for (const region of sketchRegions(this.layers()))
-        faces.push(sketchFaceModel(region));
+        faces.push(this.frame.face(region));
       return faces;
     } catch (error) {
       disposeModelObjects(
@@ -381,7 +432,13 @@ class SketchValue implements Sketch {
     )
       values.unshift(value);
     return values.map(value =>
-      snapshotSketch(value, s => String(values.indexOf(s))),
+      snapshotSketch(value, s =>
+        String(
+          values.findIndex(
+            value => definitions.get(value) === definitions.get(s),
+          ),
+        ),
+      ),
     );
   }
 }
@@ -391,17 +448,46 @@ export function sketch(
   entries?: readonly SketchEntry[],
   options?: SketchOptions,
 ): Sketch {
-  return new SketchValue(entries, options);
+  return new SketchValue({entries, options});
 }
 
 export function isSketch(value: unknown): value is Sketch {
   return value instanceof SketchValue;
 }
 
+export function isSketchPoint(value: unknown): value is SketchPoint {
+  return (
+    !!value && typeof value === 'object' && references.has(value as SketchPoint)
+  );
+}
+
+/** Internal correspondence between a spatial participant and its sketch data. */
+export function sketchForFrame(frame: SketchFrame): Sketch {
+  return framedSketches.get(frame)!;
+}
+
+/** A normal immutable sketch value in a captured inspection stage. */
+export function retainSketchFrame(value: Sketch, pose: RigidTransform): Sketch {
+  return retainInspectionIdentity(
+    new SketchValue({source: value, frame: sketchFrame(value).retained(pose)}),
+    value,
+  );
+}
+
 export function sketchDefinition(value: Sketch): Definition {
   return definitions.get(value)!;
 }
 
+/** The preceding spatial value; it shares a geometry definition, not a derived layer. */
+export function sketchSource(value: Sketch): Sketch | undefined {
+  return (value as SketchValue).source;
+}
+
+/** The relation frame used by this sketch and inherited by its generated faces. */
+export function sketchFrame(value: Sketch): SketchFrame {
+  return (value as SketchValue).frame;
+}
+
 export type SketchPointSnapshot = Readonly<{
   kind: 'point';
   id: number;
@@ -497,17 +583,30 @@ export function snapshotSketch(
     redundant,
   } = sketchDefinition(value);
   const id = identity(value);
+  const ancestors: Sketch[] = [];
+  for (
+    let ancestor = base;
+    ancestor;
+    ancestor = sketchDefinition(ancestor).base
+  )
+    ancestors.push(ancestor);
+  const pointIdentity = (reference: Sketch) =>
+    identity(
+      ancestors.find(
+        ancestor => definitions.get(ancestor) === definitions.get(reference),
+      ) ?? reference,
+    );
   return {
     id,
     base: base && identity(base),
-    entities: snapshotEntries(entries, id, identity, points).map(e =>
+    entities: snapshotEntries(entries, id, pointIdentity, points).map(e =>
       e.kind === 'point'
         ? {...e, position: points.get(e.id)!}
         : e.kind === 'circle' || e.kind === 'arc'
           ? {...e, radius: radii.get(e.id)!}
           : e,
     ),
-    constraints: snapshotConstraints(constraints, id, identity),
+    constraints: snapshotConstraints(constraints, id, pointIdentity),
     degreesOfFreedom,
     redundant,
   };