fluidcad 0.0.34 → 0.0.35

package/lib/dist/math/lazy-matrix.js

@@ -16,9 +16,11 @@ function isPlaneLazySource(p) {
 export class LazyMatrix {
     _resolver;
     _cached;
-    constructor(resolver, cached = null) {
+    _identity;
+    constructor(resolver, identity, cached = null) {
         this._resolver = resolver;
         this._cached = cached;
+        this._identity = identity;
     }
     resolve() {
         if (this._cached === null) {
@@ -27,40 +29,106 @@ export class LazyMatrix {
         return this._cached;
     }
     equals(other, tolerance = 0) {
-        return this.resolve().equals(other.resolve(), tolerance);
+        const a = this._identity;
+        const b = other._identity;
+        if (a.kind !== b.kind) {
+            return false;
+        }
+        switch (a.kind) {
+            case "eager":
+                return a.matrix.equals(b.matrix, tolerance);
+            case "rotation": {
+                const bo = b;
+                return Math.abs(a.angle - bo.angle) <= tolerance
+                    && LazyMatrix.axisSourceEquals(a.axis, bo.axis, tolerance);
+            }
+            case "translation": {
+                const bo = b;
+                return Math.abs(a.distance - bo.distance) <= tolerance
+                    && LazyMatrix.axisSourceEquals(a.axis, bo.axis, tolerance);
+            }
+            case "mirror": {
+                const bo = b;
+                return LazyMatrix.planeSourceEquals(a.plane, bo.plane, tolerance);
+            }
+            case "opaque":
+                // No structural information — can't compare safely without resolving,
+                // and resolving may dereference unbuilt sources. Treat as unequal so
+                // the caller takes the rebuild path instead of crashing.
+                return false;
+        }
+    }
+    static axisSourceEquals(a, b, tolerance) {
+        if (isAxisLazySource(a)) {
+            if (!isAxisLazySource(b)) {
+                return false;
+            }
+            if (a === b) {
+                return true;
+            }
+            if (typeof a.compareTo === "function" && typeof b.compareTo === "function") {
+                return a.compareTo(b);
+            }
+            return false;
+        }
+        if (isAxisLazySource(b)) {
+            return false;
+        }
+        return a.equals(b, tolerance);
+    }
+    static planeSourceEquals(a, b, tolerance) {
+        if (isPlaneLazySource(a)) {
+            if (!isPlaneLazySource(b)) {
+                return false;
+            }
+            if (a === b) {
+                return true;
+            }
+            if (typeof a.compareTo === "function" && typeof b.compareTo === "function") {
+                return a.compareTo(b);
+            }
+            return false;
+        }
+        if (isPlaneLazySource(b)) {
+            return false;
+        }
+        return a.compareTo(b, tolerance);
     }
     static of(matrix) {
-        return new LazyMatrix(() => matrix, matrix);
+        return new LazyMatrix(() => matrix, { kind: "eager", matrix }, matrix);
     }
     static from(resolver) {
-        return new LazyMatrix(resolver);
+        return new LazyMatrix(resolver, { kind: "opaque" });
     }
     static mirror(plane) {
         if (isPlaneLazySource(plane)) {
             return new LazyMatrix(() => {
                 const p = plane.getPlane();
                 return Matrix4.mirrorPlane(p.normal, p.origin);
-            });
+            }, { kind: "mirror", plane });
         }
-        return LazyMatrix.of(Matrix4.mirrorPlane(plane.normal, plane.origin));
+        const matrix = Matrix4.mirrorPlane(plane.normal, plane.origin);
+        return new LazyMatrix(() => matrix, { kind: "mirror", plane }, matrix);
     }
     static rotation(axis, angle) {
         if (isAxisLazySource(axis)) {
             return new LazyMatrix(() => {
                 const a = axis.getAxis();
                 return Matrix4.fromRotationAroundAxis(a.origin, a.direction, angle);
-            });
+            }, { kind: "rotation", axis, angle });
         }
-        return LazyMatrix.of(Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, angle));
+        const matrix = Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, angle);
+        return new LazyMatrix(() => matrix, { kind: "rotation", axis, angle }, matrix);
     }
     static translation(axis, distance) {
         if (isAxisLazySource(axis)) {
             return new LazyMatrix(() => {
                 const dir = axis.getAxis().direction;
                 return Matrix4.fromTranslation(dir.x * distance, dir.y * distance, dir.z * distance);
-            });
+            }, { kind: "translation", axis, distance });
         }
         const dir = axis.direction;
-        return LazyMatrix.of(Matrix4.fromTranslation(dir.x * distance, dir.y * distance, dir.z * distance));
+        const matrix = Matrix4.fromTranslation(dir.x * distance, dir.y * distance, dir.z * distance);
+        return new LazyMatrix(() => matrix, { kind: "translation", axis, distance }, matrix);
     }
 }

package/lib/dist/oc/boolean-ops.d.ts

@@ -8,8 +8,8 @@ export declare class BooleanOps {
     static cutShapes(shape: Shape, tool: Shape): Shape;
     static cutShapesRaw(shape: TopoDS_Shape, tool: TopoDS_Shape): TopoDS_Shape;
     static cutMultiShape(stocks: Shape[], tools: Shape[], plane?: Plane, cutDistance?: number): {
-        result: Edge | import("../common/wire.js").Wire | Solid | Face;
-        modified: (shape: Shape) => (Edge | import("../common/wire.js").Wire | Solid | Face)[];
+        result: import("../common/vertex.js").Vertex | Edge | import("../common/wire.js").Wire | Solid | Face;
+        modified: (shape: Shape) => (import("../common/vertex.js").Vertex | Edge | import("../common/wire.js").Wire | Solid | Face)[];
         sectionEdges: Edge[];
         startEdges: Edge[];
         endEdges: Edge[];

package/lib/dist/param-registry.d.ts

@@ -0,0 +1,34 @@
+export type ControlType = 'auto' | 'text' | 'number' | 'slider' | 'select' | 'checkbox' | 'color';
+export type MultiControlType = 'select' | 'checkboxes' | 'chips';
+export type SelectOption = {
+    label: string;
+    value: string | number;
+};
+export type ParamScalar = string | number | boolean;
+export type ParamVal = ParamScalar | (string | number)[];
+export type ParamDefinition = {
+    label: string;
+    defaultValue: ParamVal;
+    currentValue: ParamVal;
+    controlType: ControlType;
+    description?: string;
+    group?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: SelectOption[];
+    multi?: boolean;
+    multiControlType?: MultiControlType;
+};
+export declare class ParamRegistry {
+    private definitions;
+    private overrides;
+    register(def: ParamDefinition): void;
+    resolve(label: string, defaultValue: (string | number)[]): (string | number)[];
+    resolve<T extends string | number | boolean>(label: string, defaultValue: T): T;
+    setOverrides(overrides: Map<string, any>): void;
+    getDefinitions(): ParamDefinition[];
+    clear(): void;
+}
+export declare function createParamRegistry(): ParamRegistry;
+export declare function getParamRegistry(): ParamRegistry;

package/lib/dist/param-registry.js

@@ -0,0 +1,60 @@
+export class ParamRegistry {
+    definitions = new Map();
+    overrides = new Map();
+    register(def) {
+        this.definitions.set(def.label, def);
+    }
+    resolve(label, defaultValue) {
+        if (!this.overrides.has(label)) {
+            return defaultValue;
+        }
+        const override = this.overrides.get(label);
+        if (Array.isArray(defaultValue)) {
+            if (Array.isArray(override)) {
+                return override;
+            }
+            if (override != null) {
+                return [override];
+            }
+            return defaultValue;
+        }
+        if (typeof defaultValue === 'boolean') {
+            if (override === true || override === 'true' || override === 1) {
+                return true;
+            }
+            if (override === false || override === 'false' || override === 0) {
+                return false;
+            }
+            return defaultValue;
+        }
+        if (typeof defaultValue === 'number') {
+            const num = Number(override);
+            if (Number.isFinite(num)) {
+                return num;
+            }
+            return defaultValue;
+        }
+        return String(override);
+    }
+    setOverrides(overrides) {
+        this.overrides = overrides;
+    }
+    getDefinitions() {
+        return Array.from(this.definitions.values());
+    }
+    clear() {
+        this.definitions.clear();
+        this.overrides.clear();
+    }
+}
+let currentRegistry = null;
+export function createParamRegistry() {
+    currentRegistry = new ParamRegistry();
+    return currentRegistry;
+}
+export function getParamRegistry() {
+    if (!currentRegistry) {
+        currentRegistry = new ParamRegistry();
+    }
+    return currentRegistry;
+}

package/lib/dist/rendering/mesh-builder.js

@@ -33,7 +33,8 @@ export class MeshBuilder {
             console.warn("Shell shapes are not supported yet.");
         }
         else if (Explorer.isVertex(shape)) {
-            console.warn("Vertex shapes are not supported yet.");
+            const pt = shapeObj.toPoint();
+            result = { vertices: [pt.x, pt.y, pt.z], normals: [], indices: [] };
         }
         else {
             console.warn("Shape is not a valid TopoDS_Shape.");

package/lib/dist/tests/features/copy-circular.test.js

@@ -28,7 +28,7 @@ describe("copy circular", () => {
         const c = copy("circular", "z", { count: 3, angle: 180 }, e);
         render();
         const shapes = c.getShapes();
-        expect(shapes).toHaveLength(2);
+        expect(shapes).toHaveLength(3);
     });
     it("should skip specified indices", () => {
         sketch("xy", () => {

package/lib/dist/tests/features/copy-linear.test.js

@@ -25,11 +25,11 @@ describe("copy linear", () => {
         const e = extrude(10).new();
         const c = copy("linear", "x", { count: 3, offset: 50 }, e);
         render();
-        // 2 copies (index 1 and 2), each offset by 50 along X
+        // Original + 2 copies (index 1 and 2), each offset by 50 along X
         const shapes = c.getShapes();
-        expect(shapes).toHaveLength(2);
-        const bbox1 = ShapeOps.getBoundingBox(shapes[0]);
-        const bbox2 = ShapeOps.getBoundingBox(shapes[1]);
+        expect(shapes).toHaveLength(3);
+        const bbox1 = ShapeOps.getBoundingBox(shapes[1]);
+        const bbox2 = ShapeOps.getBoundingBox(shapes[2]);
         expect(bbox1.minX).toBeCloseTo(50, 0);
         expect(bbox2.minX).toBeCloseTo(100, 0);
     });
@@ -41,8 +41,8 @@ describe("copy linear", () => {
         const c = copy("linear", "y", { count: 2, offset: 60 }, e);
         render();
         const shapes = c.getShapes();
-        expect(shapes).toHaveLength(1);
-        const bbox = ShapeOps.getBoundingBox(shapes[0]);
+        expect(shapes).toHaveLength(2);
+        const bbox = ShapeOps.getBoundingBox(shapes[1]);
         expect(bbox.minY).toBeCloseTo(60, 0);
     });
     it("should copy along Z axis", () => {
@@ -53,8 +53,8 @@ describe("copy linear", () => {
         const c = copy("linear", "z", { count: 2, offset: 30 }, e);
         render();
         const shapes = c.getShapes();
-        expect(shapes).toHaveLength(1);
-        const bbox = ShapeOps.getBoundingBox(shapes[0]);
+        expect(shapes).toHaveLength(2);
+        const bbox = ShapeOps.getBoundingBox(shapes[1]);
         expect(bbox.minZ).toBeCloseTo(30, 0);
     });
     it("should distribute copies by total length", () => {
@@ -66,8 +66,8 @@ describe("copy linear", () => {
         const c = copy("linear", "x", { count: 4, length: 120 }, e);
         render();
         const shapes = c.getShapes();
-        expect(shapes).toHaveLength(3);
-        const bbox = ShapeOps.getBoundingBox(shapes[0]);
+        expect(shapes).toHaveLength(4);
+        const bbox = ShapeOps.getBoundingBox(shapes[1]);
         expect(bbox.minX).toBeCloseTo(40, 0);
     });
     it("should create a 2D grid with multiple axes", () => {

package/lib/dist/tests/features/repeat-user-repro-cache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/features/repeat-user-repro-cache.test.js

@@ -0,0 +1,97 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../setup.js";
+import { getSceneManager } from "../../scene-manager.js";
+import { SceneCompare } from "../../rendering/scene-compare.js";
+import sketch from "../../core/sketch.js";
+import extrude from "../../core/extrude.js";
+import axis from "../../core/axis.js";
+import repeat from "../../core/repeat.js";
+import sweep from "../../core/sweep.js";
+import cut from "../../core/cut.js";
+import remove from "../../core/remove.js";
+import { rect, circle, vLine, tArc, tLine, slot, move, hMove } from "../../core/2d/index.js";
+import copy from "../../core/copy.js";
+// Regression: re-rendering a scene whose `repeat("circular", ...)` axis is an
+// AxisFromEdge derived from a sketch line used to crash inside
+// SceneCompare.compare with "Cannot read properties of undefined (reading
+// 'origin')". RepeatCircular.compareTo eagerly called getAxis() on the
+// new-scene axis source, which hadn't been built yet (compare runs pre-render).
+describe("repeat circular cache-compare on unbuilt axis source", () => {
+    setupOC();
+    function buildScene(includeRemove) {
+        const spine = sketch("front", () => {
+            vLine(1.5);
+            tArc(-4, 45);
+            const topSegment = tLine(1.5);
+            return { topSegment };
+        }).reusable();
+        const profile = sketch("top", () => {
+            const innerPipe = circle(1.5);
+            const outerPipe = circle(2);
+            return { innerPipe, outerPipe };
+        });
+        const pipe = sweep(spine, profile.regions.outerPipe);
+        sketch("top", () => {
+            rect(3.5).centered().radius(0.5);
+            move([-2.5 / 2, -2.5 / 2]);
+            const c = circle(0.5);
+            copy("circular", [0, 0], { count: 4, angle: 360 }, c);
+        });
+        extrude(0.375);
+        sketch(pipe.endFaces(), () => {
+            circle(4);
+        });
+        const upperFlange = extrude(-0.625);
+        sweep(spine, profile.regions.innerPipe).remove();
+        const slots = sketch(upperFlange.endFaces(), () => {
+            hMove(3.25 / 2);
+            const outerSlot = slot(1, 0.75 / 2);
+            const innerSlot = slot(1, 0.45 / 2);
+            return { outerSlot, innerSlot };
+        });
+        const s1 = cut(slots.regions.innerSlot);
+        const s2 = cut(0.25, slots.regions.outerSlot);
+        const a = axis(spine.regions.topSegment);
+        repeat("circular", a, { count: 4, angle: 360 }, s1, s2);
+        if (includeRemove) {
+            remove(spine);
+        }
+    }
+    function currentScene() {
+        const mgr = getSceneManager();
+        if (!mgr) {
+            throw new Error("Scene manager not initialized");
+        }
+        return mgr.currentScene;
+    }
+    function startNewScene() {
+        const mgr = getSceneManager();
+        if (!mgr) {
+            throw new Error("Scene manager not initialized");
+        }
+        return mgr.startScene();
+    }
+    it("re-parsing the same script with cache compare does not throw", () => {
+        buildScene(false);
+        render();
+        const previousScene = currentScene();
+        expect(previousScene.getAllSceneObjects().some(o => o.getError())).toBe(false);
+        const newScene = startNewScene();
+        buildScene(false);
+        SceneCompare.compare(previousScene, newScene);
+        const rendered = render();
+        const errored = rendered.getAllSceneObjects().filter(o => o.getError());
+        expect(errored.map(o => `${o.getUniqueType()}: ${o.getError()}`)).toEqual([]);
+    });
+    it("appending remove(spine) after a cached render does not throw", () => {
+        buildScene(false);
+        render();
+        const previousScene = currentScene();
+        const newScene = startNewScene();
+        buildScene(true);
+        SceneCompare.compare(previousScene, newScene);
+        const rendered = render();
+        const errored = rendered.getAllSceneObjects().filter(o => o.getError());
+        expect(errored.map(o => `${o.getUniqueType()}: ${o.getError()}`)).toEqual([]);
+    });
+});