fluidcad 0.0.2

package/lib/dist/rendering/scene.d.ts

@@ -0,0 +1,81 @@
+import { Sketch } from "../features/2d/sketch.js";
+import { SelectSceneObject } from "../features/select.js";
+import { SceneObject } from "../common/scene-object.js";
+import { Extrudable } from "../helpers/types.js";
+import { Part } from "../features/part.js";
+export type SceneObjectMesh = {
+    label?: string;
+    vertices: number[];
+    normals: number[];
+    indices: number[];
+    color?: string;
+    faceMapping?: number[];
+    edgeIndex?: number;
+};
+export type RenderedShape = {
+    shapeId: string;
+    meshes: SceneObjectMesh[];
+    shapeType: string;
+    isMetaShape?: boolean;
+    isGuide?: boolean;
+    metaType?: string;
+    metaData?: Record<string, any>;
+};
+export type SceneObjectRender = {
+    id: string;
+    name: string;
+    parentId: string | null;
+    isContainer: boolean;
+    object: any;
+    sceneShapes: RenderedShape[];
+    visible: boolean;
+    type: string;
+    uniqueType: string;
+    fromCache: boolean;
+    hasError: boolean;
+    errorMessage?: string;
+    sourceLocation?: {
+        filePath: string;
+        line: number;
+        column: number;
+    };
+};
+export declare class Scene {
+    private sceneObjects;
+    private renderedObjects;
+    private cached;
+    private progressiveContainers;
+    private idMap;
+    constructor();
+    addSceneObject(obj: SceneObject): void;
+    startProgressiveContainer(obj: SceneObject): void;
+    getActiveContainer(): SceneObject | null;
+    endProgressiveContainer(): SceneObject;
+    getActiveSketch(): Sketch | null;
+    getActivePart(): Part | null;
+    findEnclosingPart(obj: SceneObject): Part | null;
+    getPartScopedObjectsUpTo(obj: SceneObject): SceneObject[];
+    getPartScopedActiveObjectsUpTo(obj: SceneObject): SceneObject[];
+    getSceneObjects(): SceneObject[];
+    getPartScopedSceneObjects(): SceneObject[];
+    getPartScopedAllObjects(obj: SceneObject): SceneObject[];
+    getActiveSceneObjectsUpTo(obj: SceneObject): SceneObject[];
+    getSceneObjectsUpTo(obj: SceneObject): SceneObject[];
+    getSceneObjectsFromTo(obj: SceneObject, to: SceneObject): SceneObject[];
+    getAllSceneObjects(): SceneObject[];
+    getLastExtrudable(): Extrudable | null;
+    getLastSelections(): SelectSceneObject[];
+    getLastSelection(): SelectSceneObject | null;
+    replaceSceneObject(currentSceneObject: SceneObject, newSceneObject: SceneObject): void;
+    addRenderedObject(object: SceneObject, rendered: SceneObjectRender): void;
+    getRenderedObject(obj: SceneObject): SceneObjectRender | null;
+    getRenderedObjects(): SceneObjectRender[];
+    clearRenderedObjects(): void;
+    removeRenderedObject(obj: SceneObject): void;
+    markCached(obj: SceneObject): void;
+    isCached(obj: SceneObject): boolean;
+    indexOf(obj: SceneObject): number;
+    getSceneObjectAt(index: number): SceneObject;
+    getSceneObjectById(id: string): SceneObject | null;
+    getChildren(parent: SceneObject): SceneObject[];
+}

package/lib/dist/rendering/scene.js

@@ -0,0 +1,206 @@
+import { Sketch } from "../features/2d/sketch.js";
+import { SelectSceneObject } from "../features/select.js";
+import { Part } from "../features/part.js";
+export class Scene {
+    sceneObjects = [];
+    renderedObjects = new Map();
+    cached = new Set();
+    progressiveContainers = [];
+    idMap = new Map();
+    constructor() {
+    }
+    addSceneObject(obj) {
+        obj.setOrder(this.sceneObjects.length);
+        const activeObj = this.getActiveContainer();
+        if (activeObj && !obj.getParent()) {
+            activeObj.addChildObject(obj);
+        }
+        if (!this.sceneObjects.includes(obj)) {
+            this.sceneObjects.push(obj);
+            this.idMap.set(obj.id, obj);
+        }
+    }
+    startProgressiveContainer(obj) {
+        this.addSceneObject(obj);
+        this.progressiveContainers.push(obj);
+    }
+    getActiveContainer() {
+        if (this.progressiveContainers.length > 0) {
+            return this.progressiveContainers[this.progressiveContainers.length - 1];
+        }
+        return null;
+    }
+    endProgressiveContainer() {
+        const obj = this.progressiveContainers.pop();
+        if (!obj) {
+            throw new Error('No progressive container to end.');
+        }
+        return obj;
+    }
+    getActiveSketch() {
+        const activeObject = this.getActiveContainer();
+        if (activeObject && activeObject instanceof Sketch) {
+            return activeObject;
+        }
+        return null;
+    }
+    getActivePart() {
+        for (let i = this.progressiveContainers.length - 1; i >= 0; i--) {
+            if (this.progressiveContainers[i] instanceof Part) {
+                return this.progressiveContainers[i];
+            }
+        }
+        return null;
+    }
+    findEnclosingPart(obj) {
+        let current = obj.getParent();
+        while (current) {
+            if (current instanceof Part) {
+                return current;
+            }
+            current = current.getParent();
+        }
+        // The object itself might be a Part
+        if (obj instanceof Part) {
+            return obj;
+        }
+        return null;
+    }
+    getPartScopedObjectsUpTo(obj) {
+        const allUpTo = this.getSceneObjectsUpTo(obj);
+        const part = this.findEnclosingPart(obj);
+        if (!part) {
+            return allUpTo;
+        }
+        return allUpTo.filter(o => this.findEnclosingPart(o) === part);
+    }
+    getPartScopedActiveObjectsUpTo(obj) {
+        const allUpTo = this.getActiveSceneObjectsUpTo(obj);
+        const part = this.findEnclosingPart(obj);
+        if (!part) {
+            return allUpTo;
+        }
+        return allUpTo.filter(o => this.findEnclosingPart(o) === part);
+    }
+    getSceneObjects() {
+        const object = this.sceneObjects;
+        return object;
+    }
+    getPartScopedSceneObjects() {
+        const activePart = this.getActivePart();
+        if (!activePart) {
+            return this.sceneObjects;
+        }
+        return this.sceneObjects.filter(o => this.findEnclosingPart(o) === activePart);
+    }
+    getPartScopedAllObjects(obj) {
+        const part = this.findEnclosingPart(obj);
+        if (!part) {
+            return this.sceneObjects;
+        }
+        return this.sceneObjects.filter(o => this.findEnclosingPart(o) === part);
+    }
+    getActiveSceneObjectsUpTo(obj) {
+        const index = this.sceneObjects.findIndex(f => f === obj);
+        return this.sceneObjects.slice(0, index).filter(f => f.hasShapes());
+    }
+    getSceneObjectsUpTo(obj) {
+        const index = this.sceneObjects.findIndex(f => f === obj);
+        const objects = this.sceneObjects
+            .slice(0, index);
+        return objects;
+    }
+    getSceneObjectsFromTo(obj, to) {
+        const fromIndex = this.sceneObjects.findIndex(f => f === obj);
+        const toIndex = this.sceneObjects.findIndex(f => f === to);
+        const objects = this.sceneObjects
+            .slice(fromIndex, toIndex);
+        return objects;
+    }
+    getAllSceneObjects() {
+        return this.sceneObjects;
+    }
+    getLastExtrudable() {
+        const activePart = this.getActivePart();
+        let count = this.sceneObjects.length;
+        while (count--) {
+            const object = this.sceneObjects[count];
+            if (!object.isExtrudable()) {
+                continue;
+            }
+            if (activePart) {
+                // Inside a Part: find extrudables that are direct children of this Part
+                if (object.getParent() === activePart) {
+                    return object;
+                }
+            }
+            else {
+                // Outside any Part: original behavior (top-level only)
+                if (!object.parentId) {
+                    return object;
+                }
+            }
+        }
+        return null;
+    }
+    getLastSelections() {
+        let count = this.sceneObjects.length;
+        const selections = [];
+        while (count--) {
+            const obj = this.sceneObjects[count];
+            if (obj instanceof SelectSceneObject) {
+                selections.push(obj);
+            }
+        }
+        return selections;
+    }
+    getLastSelection() {
+        let count = this.sceneObjects.length;
+        while (count--) {
+            const obj = this.sceneObjects[count];
+            if (obj instanceof SelectSceneObject) {
+                return obj;
+            }
+        }
+        return null;
+    }
+    replaceSceneObject(currentSceneObject, newSceneObject) {
+        const index = this.sceneObjects.findIndex(f => f === currentSceneObject);
+        if (index !== -1) {
+            this.sceneObjects[index] = newSceneObject;
+        }
+    }
+    addRenderedObject(object, rendered) {
+        this.renderedObjects.set(object, rendered);
+    }
+    getRenderedObject(obj) {
+        return this.renderedObjects.get(obj) || null;
+    }
+    getRenderedObjects() {
+        return Array.from(this.renderedObjects.values());
+    }
+    clearRenderedObjects() {
+        this.renderedObjects.clear();
+    }
+    removeRenderedObject(obj) {
+        this.renderedObjects.delete(obj);
+    }
+    markCached(obj) {
+        this.cached.add(obj);
+    }
+    isCached(obj) {
+        return this.cached.has(obj);
+    }
+    indexOf(obj) {
+        return this.sceneObjects.indexOf(obj);
+    }
+    getSceneObjectAt(index) {
+        return this.sceneObjects[index];
+    }
+    getSceneObjectById(id) {
+        return this.idMap.get(id) || null;
+    }
+    getChildren(parent) {
+        return this.sceneObjects.filter(obj => obj.parentId === parent.id);
+    }
+}

package/lib/dist/scene-manager.d.ts

@@ -0,0 +1,32 @@
+import { Scene } from "./rendering/scene.js";
+import type { ExportOptions } from "./io/file-export.js";
+import type { ShapeProperties } from "./oc/props.js";
+import type { FaceProperties } from "./oc/face-props.js";
+import type { EdgeProperties } from "./oc/edge-props.js";
+import type { HitTestResult } from "./oc/hit-test.js";
+declare class SceneManager {
+    rootPath: string;
+    currentScene: Scene;
+    currentFile: string;
+    constructor(rootPath: string);
+    setCurrentFile(filePath: string): void;
+    startScene(): Scene;
+    renderScene(scene: Scene): Scene;
+    rollbackScene(scene: Scene, rollbackIndex: number): Scene;
+    compare(previous: Scene, current: Scene): Scene;
+    importFile(workspacePath: string, fileName: string, data: Uint8Array): void;
+    getShapeProperties(scene: Scene, shapeId: string): ShapeProperties | null;
+    getFaceProperties(scene: Scene, shapeId: string, faceIndex: number): FaceProperties | null;
+    getEdgeProperties(scene: Scene, shapeId: string, edgeIndex: number): EdgeProperties | null;
+    exportShapes(scene: Scene, shapeIds: string[], options: ExportOptions): {
+        data: string | Uint8Array;
+        fileName: string;
+    };
+    hitTest(scene: Scene, shapeId: string, rayOrigin: [number, number, number], rayDir: [number, number, number], edgeThreshold: number): HitTestResult;
+}
+export declare function createManager(rootPath: string): SceneManager;
+export declare function getCurrentScene(): Scene;
+export declare function getCurrentFile(): string;
+export declare function setCurrentFile(filePath: string): void;
+export declare function getSceneManager(): SceneManager;
+export {};

package/lib/dist/scene-manager.js

@@ -0,0 +1,120 @@
+import { Scene } from "./rendering/scene.js";
+import { renderScene, renderSceneRollback } from "./rendering/render.js";
+import { SceneCompare } from "./rendering/scene-compare.js";
+import { FileImport } from "./io/file-import.js";
+import { FileExport } from "./io/file-export.js";
+import { ShapeProps } from "./oc/props.js";
+import { FaceProps } from "./oc/face-props.js";
+import { EdgeProps } from "./oc/edge-props.js";
+import { Explorer } from "./oc/explorer.js";
+import { OccHitTest } from "./oc/hit-test.js";
+class SceneManager {
+    rootPath;
+    currentScene = new Scene();
+    currentFile = '';
+    constructor(rootPath) {
+        this.rootPath = rootPath;
+    }
+    setCurrentFile(filePath) {
+        this.currentFile = filePath;
+    }
+    startScene() {
+        this.currentScene = new Scene();
+        console.log("Starting new scene");
+        return this.currentScene;
+    }
+    renderScene(scene) {
+        return renderScene(scene);
+    }
+    rollbackScene(scene, rollbackIndex) {
+        return renderSceneRollback(scene, rollbackIndex);
+    }
+    compare(previous, current) {
+        return SceneCompare.compare(previous, current);
+    }
+    importFile(workspacePath, fileName, data) {
+        FileImport.importFile(workspacePath, fileName, data);
+    }
+    getShapeProperties(scene, shapeId) {
+        for (const obj of scene.getAllSceneObjects()) {
+            for (const shape of obj.getAddedShapes()) {
+                if (shape.id === shapeId) {
+                    return ShapeProps.getProperties(shape.getShape());
+                }
+            }
+        }
+        return null;
+    }
+    getFaceProperties(scene, shapeId, faceIndex) {
+        for (const obj of scene.getAllSceneObjects()) {
+            for (const shape of obj.getAddedShapes()) {
+                if (shape.id === shapeId) {
+                    const faces = Explorer.findFacesWrapped(shape);
+                    if (faceIndex < 0 || faceIndex >= faces.length) {
+                        return null;
+                    }
+                    return FaceProps.getProperties(faces[faceIndex].getShape());
+                }
+            }
+        }
+        return null;
+    }
+    getEdgeProperties(scene, shapeId, edgeIndex) {
+        for (const obj of scene.getAllSceneObjects()) {
+            for (const shape of obj.getAddedShapes()) {
+                if (shape.id === shapeId) {
+                    const edges = Explorer.findEdgesWrapped(shape);
+                    if (edgeIndex < 0 || edgeIndex >= edges.length) {
+                        return null;
+                    }
+                    return EdgeProps.getProperties(edges[edgeIndex].getShape());
+                }
+            }
+        }
+        return null;
+    }
+    exportShapes(scene, shapeIds, options) {
+        const solids = [];
+        for (const obj of scene.getAllSceneObjects()) {
+            for (const shape of obj.getAddedShapes()) {
+                if (shapeIds.includes(shape.id) && shape.isSolid()) {
+                    solids.push(shape);
+                }
+            }
+        }
+        if (solids.length === 0) {
+            throw new Error('No matching solids found for export');
+        }
+        return FileExport.exportShapes(solids, options);
+    }
+    hitTest(scene, shapeId, rayOrigin, rayDir, edgeThreshold) {
+        for (const obj of scene.getAllSceneObjects()) {
+            for (const shape of obj.getAddedShapes()) {
+                if (shape.id === shapeId) {
+                    return OccHitTest.hitTest(shape.getShape(), rayOrigin, rayDir, edgeThreshold);
+                }
+            }
+        }
+        return null;
+    }
+}
+let currentManager = null;
+export function createManager(rootPath) {
+    console.log(`Creating SceneManager with root path: ${rootPath}`);
+    currentManager = new SceneManager(rootPath);
+    return currentManager;
+}
+export function getCurrentScene() {
+    return currentManager?.currentScene;
+}
+export function getCurrentFile() {
+    return currentManager?.currentFile || '';
+}
+export function setCurrentFile(filePath) {
+    if (currentManager) {
+        currentManager.setCurrentFile(filePath);
+    }
+}
+export function getSceneManager() {
+    return currentManager;
+}

package/lib/dist/tests/extrude.test.d.ts

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

package/lib/dist/tests/extrude.test.js

@@ -0,0 +1,48 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, buildScene } from "./setup.js";
+import sketch from "../core/sketch.js";
+import extrude from "../core/extrude.js";
+import { rect } from "../core/2d/index.js";
+import { ShapeProps } from "../oc/props.js";
+describe("extrude", () => {
+    setupOC();
+    it("extrudes a rectangular sketch into a solid", () => {
+        sketch("xy", () => {
+            rect(100, 50);
+        });
+        const e = extrude(30);
+        buildScene();
+        const shapes = e.getShapes();
+        expect(shapes).toHaveLength(1);
+        expect(shapes[0].getType()).toBe("solid");
+    });
+    it("produces correct volume for a box", () => {
+        sketch("xy", () => {
+            rect(100, 50);
+        });
+        const e = extrude(30);
+        buildScene();
+        const shapes = e.getShapes();
+        const props = ShapeProps.getProperties(shapes[0].getShape());
+        expect(props.volumeMm3).toBeCloseTo(100 * 50 * 30, 0);
+    });
+    it("produces a solid with 6 faces", () => {
+        sketch("xy", () => {
+            rect(100, 50);
+        });
+        const e = extrude(30);
+        buildScene();
+        const solid = e.getShapes()[0];
+        expect(solid.getFaces()).toHaveLength(6);
+    });
+    it("uses default distance of 25 when no distance given", () => {
+        sketch("xy", () => {
+            rect(10, 10);
+        });
+        const e = extrude();
+        buildScene();
+        const shapes = e.getShapes();
+        const props = ShapeProps.getProperties(shapes[0].getShape());
+        expect(props.volumeMm3).toBeCloseTo(10 * 10 * 25, 0);
+    });
+});

package/lib/dist/tests/features/2d/arc.test.d.ts

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

package/lib/dist/tests/features/2d/arc.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../../setup.js";
+import sketch from "../../../core/sketch.js";
+import extrude from "../../../core/extrude.js";
+import { arc, hLine, vLine } from "../../../core/2d/index.js";
+import { getEdgesByType } from "../../utils.js";
+describe("arc", () => {
+    setupOC();
+    describe("in sketch (point mode)", () => {
+        it("should create an arc and form a closed shape", () => {
+            sketch("xy", () => {
+                hLine(50);
+                arc([50, 30], 20);
+                hLine(-50);
+                vLine(-30);
+            });
+            const e = extrude(10);
+            render();
+            expect(e.getShapes()).toHaveLength(1);
+            const solid = e.getShapes()[0];
+            const arcEdges = getEdgesByType(solid, "arc");
+            expect(arcEdges.length).toBeGreaterThan(0);
+        });
+    });
+    describe("combined with lines", () => {
+        it("should create a shape with straight and curved edges", () => {
+            sketch("xy", () => {
+                hLine(60);
+                vLine(20);
+                hLine(-60);
+                vLine(-20);
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            const lineEdges = getEdgesByType(solid, "line");
+            expect(lineEdges.length).toBeGreaterThan(0);
+        });
+    });
+});

package/lib/dist/tests/features/2d/circle.test.d.ts

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

package/lib/dist/tests/features/2d/circle.test.js

@@ -0,0 +1,64 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../../setup.js";
+import sketch from "../../../core/sketch.js";
+import extrude from "../../../core/extrude.js";
+import { circle } from "../../../core/2d/index.js";
+import { ShapeOps } from "../../../oc/shape-ops.js";
+import { getFacesByType } from "../../utils.js";
+describe("circle", () => {
+    setupOC();
+    describe("in sketch", () => {
+        it("should create a circle with default diameter", () => {
+            sketch("xy", () => {
+                circle();
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            // Default diameter is 40
+            const bbox = ShapeOps.getBoundingBox(solid);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(40, 0);
+        });
+        it("should create a circle with given diameter", () => {
+            sketch("xy", () => {
+                circle(60);
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            const bbox = ShapeOps.getBoundingBox(solid);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(60, 0);
+        });
+        it("should create a circle at a given center", () => {
+            sketch("xy", () => {
+                circle([50, 30], 40);
+            });
+            const e = extrude(10);
+            render();
+            const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+            expect(bbox.centerX).toBeCloseTo(50, 0);
+            expect(bbox.centerY).toBeCloseTo(30, 0);
+        });
+        it("should produce a cylinder when extruded", () => {
+            sketch("xy", () => {
+                circle(50);
+            });
+            const e = extrude(30);
+            render();
+            const solid = e.getShapes()[0];
+            // Cylinder has 2 circular + 1 cylindrical face
+            expect(getFacesByType(solid, "circle")).toHaveLength(2);
+            expect(getFacesByType(solid, "cylinder")).toHaveLength(1);
+        });
+    });
+    describe("standalone with targetPlane", () => {
+        it("should create a circle on a specific plane", () => {
+            circle(60, "xy");
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            const bbox = ShapeOps.getBoundingBox(solid);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(60, 0);
+        });
+    });
+});

package/lib/dist/tests/features/2d/constrained.test.d.ts

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