fluidcad 0.0.2

package/lib/dist/index.js

@@ -0,0 +1,75 @@
+import { loadOC } from "./load.js";
+import { createManager, getCurrentScene } from "./scene-manager.js";
+export function captureSourceLocation() {
+    const stack = new Error().stack;
+    if (!stack) {
+        return null;
+    }
+    const lines = stack.split('\n');
+    for (const frame of lines) {
+        const match = frame.match(/(\/[^:]+\.fluid\.js):(\d+):(\d+)/);
+        if (match) {
+            return {
+                filePath: match[1],
+                line: parseInt(match[2], 10),
+                column: parseInt(match[3], 10),
+            };
+        }
+    }
+    return null;
+}
+export function registerBuilder(builder) {
+    const fn = function () {
+        let scene = getCurrentScene();
+        const sourceLocation = captureSourceLocation();
+        const context = {
+            addSceneObject(obj) {
+                if (sourceLocation) {
+                    obj.setSourceLocation(sourceLocation);
+                }
+                scene.addSceneObject(obj);
+            },
+            addSceneObjects(objs) {
+                for (const obj of objs) {
+                    if (sourceLocation) {
+                        obj.setSourceLocation(sourceLocation);
+                    }
+                    scene.addSceneObject(obj);
+                }
+            },
+            getLastExtrudable() {
+                return scene.getLastExtrudable();
+            },
+            getLastSelection() {
+                return scene.getLastSelection();
+            },
+            getLastSelections() {
+                return scene.getLastSelections();
+            },
+            startProgressiveContainer(obj) {
+                if (sourceLocation) {
+                    obj.setSourceLocation(sourceLocation);
+                }
+                scene.startProgressiveContainer(obj);
+            },
+            endProgressiveContainer() {
+                scene.endProgressiveContainer();
+            },
+            getSceneObjects() {
+                return scene.getPartScopedSceneObjects();
+            },
+            getActiveSketch() {
+                return scene.getActiveSketch();
+            }
+        };
+        const originalFn = builder(context);
+        return originalFn(...arguments);
+    };
+    return fn;
+    ;
+}
+export async function init(rootPath) {
+    await loadOC();
+    const resolvedPath = rootPath || process.env.FLUIDCAD_WORKSPACE_PATH || '';
+    return createManager(resolvedPath);
+}

package/lib/dist/io/file-export.d.ts

@@ -0,0 +1,30 @@
+import { Solid } from "../common/solid.js";
+export interface ExportOptions {
+    format: 'step' | 'stl';
+    includeColors?: boolean;
+    resolution?: 'coarse' | 'medium' | 'fine' | 'custom';
+    customLinearDeflection?: number;
+    customAngularDeflectionDeg?: number;
+}
+export declare const RESOLUTION_PRESETS: {
+    readonly coarse: {
+        readonly linearDeflection: 1;
+        readonly angularDeflection: 0.5;
+    };
+    readonly medium: {
+        readonly linearDeflection: 0.3;
+        readonly angularDeflection: 0.3;
+    };
+    readonly fine: {
+        readonly linearDeflection: 0.05;
+        readonly angularDeflection: 0.1;
+    };
+};
+export declare class FileExport {
+    static exportShapes(solids: Solid[], options: ExportOptions): {
+        data: string | Uint8Array;
+        fileName: string;
+    };
+    private static exportStep;
+    private static exportStl;
+}

package/lib/dist/io/file-export.js

@@ -0,0 +1,45 @@
+import { OcIO } from "../oc/io.js";
+export const RESOLUTION_PRESETS = {
+    coarse: { linearDeflection: 1.0, angularDeflection: 0.5 },
+    medium: { linearDeflection: 0.3, angularDeflection: 0.3 },
+    fine: { linearDeflection: 0.05, angularDeflection: 0.1 },
+};
+export class FileExport {
+    static exportShapes(solids, options) {
+        if (solids.length === 0) {
+            throw new Error('No solids to export');
+        }
+        if (options.format === 'step') {
+            return FileExport.exportStep(solids, options);
+        }
+        return FileExport.exportStl(solids, options);
+    }
+    static exportStep(solids, options) {
+        const fileName = 'export.step';
+        const includeColors = options.includeColors !== false;
+        if (includeColors) {
+            const data = OcIO.writeStepXCAF(solids, fileName);
+            return { data, fileName };
+        }
+        const compound = OcIO.makeCompoundRaw(solids.map(s => s.getShape()));
+        const data = OcIO.writeStepRaw(compound, fileName);
+        return { data, fileName };
+    }
+    static exportStl(solids, options) {
+        const fileName = 'export.stl';
+        const compound = OcIO.makeCompoundRaw(solids.map(s => s.getShape()));
+        let linearDeflection;
+        let angularDeflection;
+        if (options.resolution === 'custom' && options.customLinearDeflection != null && options.customAngularDeflectionDeg != null) {
+            linearDeflection = options.customLinearDeflection;
+            angularDeflection = options.customAngularDeflectionDeg * Math.PI / 180;
+        }
+        else {
+            const preset = RESOLUTION_PRESETS[options.resolution] || RESOLUTION_PRESETS.medium;
+            linearDeflection = preset.linearDeflection;
+            angularDeflection = preset.angularDeflection;
+        }
+        const data = OcIO.writeStl(compound, fileName, linearDeflection, angularDeflection);
+        return { data, fileName };
+    }
+}

package/lib/dist/io/file-import.d.ts

@@ -0,0 +1,8 @@
+import { Shape } from "../common/shape.js";
+import { Solid } from "../common/solid.js";
+export declare class FileImport {
+    static deserializeShapes(fileName: string): Solid[];
+    static serializeShape(shape: Shape, workspacePath: string, fileName: string): void;
+    static importFile(workspacePath: string, fileName: string, data: Uint8Array): Solid[];
+    static deserializeShapesWithMetadata(fileName: string): Solid[];
+}

package/lib/dist/io/file-import.js

@@ -0,0 +1,81 @@
+import * as fs from "fs";
+import { join } from "path";
+import { OcIO } from "../oc/io.js";
+import { getSceneManager } from "../scene-manager.js";
+export class FileImport {
+    static deserializeShapes(fileName) {
+        if (!fileName.endsWith(('.brep'))) {
+            fileName += '.brep';
+        }
+        const sceneManager = getSceneManager();
+        const filePath = join(sceneManager.rootPath, 'imports', fileName);
+        console.log(`Reading file ${fileName}`);
+        const file = fs.readFileSync(filePath, 'utf8');
+        console.log(`File ${filePath} read successfully, size: ${file.length} bytes`);
+        return OcIO.readBRepSolids(fileName, file);
+    }
+    static serializeShape(shape, workspacePath, fileName) {
+        const file = OcIO.writeBRep(shape, fileName);
+        console.log(`Writing file ${fileName} to actual filesystem at ${workspacePath}`);
+        fs.writeFileSync(join(workspacePath, 'imports', fileName.replace(/.(step|stp)$/i, '.brep')), file);
+    }
+    static importFile(workspacePath, fileName, data) {
+        console.log(`Importing file: ${fileName}, size: ${data.length} bytes`);
+        const { docHandle, cleanup } = OcIO.readStepXCAF(fileName, data);
+        const { solids: solidEntries } = OcIO.extractSolidsAndColors(docHandle);
+        const solids = [];
+        const colorData = [];
+        for (const entry of solidEntries) {
+            const solid = entry.shape;
+            const faces = OcIO.findFaces(solid);
+            for (const fc of entry.faceColors) {
+                if (fc.faceIndex < faces.length) {
+                    solid.setColor(faces[fc.faceIndex].getShape(), fc.color);
+                }
+            }
+            solids.push(solid);
+            colorData.push({ faces: entry.faceColors });
+        }
+        // Serialize all solids as compound .brep
+        const brepFileName = fileName.replace(/\.(step|stp)$/i, '.brep');
+        const brepContent = OcIO.writeSolidsAsBRep(solids, brepFileName);
+        fs.writeFileSync(join(workspacePath, 'imports', brepFileName), brepContent);
+        // Write color metadata as JSON sidecar
+        const jsonFileName = fileName.replace(/\.(step|stp)$/i, '.colors.json');
+        const jsonPath = join(workspacePath, 'imports', jsonFileName);
+        fs.writeFileSync(jsonPath, JSON.stringify(colorData, null, 2));
+        console.log(`Written color metadata to ${jsonPath}`);
+        cleanup();
+        console.log(`Imported ${solids.length} solids with color metadata`);
+        return solids;
+    }
+    static deserializeShapesWithMetadata(fileName) {
+        // Read geometry from .brep
+        const brepFileName = fileName.replace(/\.(step|stp|brep)$/i, '');
+        const shapes = FileImport.deserializeShapes(brepFileName);
+        // Read color metadata from JSON sidecar
+        const sceneManager = getSceneManager();
+        const jsonPath = join(sceneManager.rootPath, 'imports', brepFileName + '.colors.json');
+        let colorData = [];
+        if (fs.existsSync(jsonPath)) {
+            colorData = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
+            console.log(`Loaded color metadata from ${jsonPath}`);
+        }
+        // Build Solid objects and apply colors by face index
+        const solids = shapes.map((shape, solidIndex) => {
+            const solid = shape;
+            const solidColors = colorData[solidIndex];
+            if (!solidColors)
+                return solid;
+            const faces = OcIO.findFaces(solid);
+            for (const entry of solidColors.faces) {
+                if (entry.faceIndex < faces.length) {
+                    solid.setColor(faces[entry.faceIndex].getShape(), entry.color);
+                }
+            }
+            return solid;
+        });
+        console.log(`Deserialized ${solids.length} solids with color metadata`);
+        return solids;
+    }
+}

package/lib/dist/load.d.ts

@@ -0,0 +1 @@
+export { getOC, loadOC } from "./oc/init.js";

package/lib/dist/load.js

@@ -0,0 +1 @@
+export { getOC, loadOC } from "./oc/init.js";

package/lib/dist/math/axis.d.ts

@@ -0,0 +1,72 @@
+import { Point } from "./point.js";
+import { Vector3d } from "./vector3d.js";
+import { Matrix4 } from "./matrix4.js";
+import { AxisObjectBase } from "../features/axis-renderable-base.js";
+import { IAxis } from "../core/interfaces.js";
+export interface AxisTransformOptions {
+    offsetX?: number;
+    offsetY?: number;
+    offsetZ?: number;
+    rotateX?: number;
+    rotateY?: number;
+    rotateZ?: number;
+}
+export declare class Axis {
+    readonly origin: Point;
+    readonly direction: Vector3d;
+    constructor(origin: Point, direction: Vector3d);
+    equals(other: Axis, tolerance?: number): boolean;
+    add(other: Axis): Axis;
+    translate(dx: number, dy: number, dz: number): Axis;
+    translateVector(v: Vector3d): Axis;
+    applyMatrix(matrix: Matrix4): Axis;
+    rotateAroundAxis(axis: Axis, angle: number): Axis;
+    rotateX(angle: number): Axis;
+    rotateY(angle: number): Axis;
+    rotateZ(angle: number): Axis;
+    transform(options: AxisTransformOptions): Axis;
+    isParallelTo(other: Axis, tolerance?: number): boolean;
+    isPerpendicularTo(other: Axis, tolerance?: number): boolean;
+    isPerpendicularToVector(vector: Vector3d, tolerance?: number): boolean;
+    distanceToPoint(point: Point): number;
+    closestPointOnAxis(point: Point): Point;
+    pointAtParameter(t: number): Point;
+    reverse(): Axis;
+    mirrorAroundPoint(point: Point): Axis;
+    mirrorAroundPlane(planeNormal: Vector3d, pointOnPlane: Point): Axis;
+    mirrorAroundAxis(mirrorAxis: Axis): Axis;
+    clone(): Axis;
+    serialize(): {
+        origin: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        direction: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    toString(): string;
+    static X(): Axis;
+    static Y(): Axis;
+    static Z(): Axis;
+    static fromPoints(start: Point, end: Point): Axis;
+    static deserialize(data: {
+        origin: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        direction: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }): Axis;
+}
+export type StandardAxis = "x" | "y" | "z";
+export type AxisLike = StandardAxis | Axis | IAxis | AxisObjectBase;
+export declare function isAxisLike(value: unknown): value is AxisLike;
+export declare function toAxis(value: AxisLike): Axis;

package/lib/dist/math/axis.js

@@ -0,0 +1,157 @@
+import { Point } from "./point.js";
+import { Vector3d } from "./vector3d.js";
+import { Matrix4 } from "./matrix4.js";
+import { Quaternion } from "./quaternion.js";
+import { AxisObjectBase } from "../features/axis-renderable-base.js";
+export class Axis {
+    origin;
+    direction;
+    constructor(origin, direction) {
+        this.origin = origin;
+        this.direction = direction;
+    }
+    equals(other, tolerance = 0) {
+        return (this.origin.equals(other.origin, tolerance) &&
+            this.direction.equals(other.direction, tolerance));
+    }
+    add(other) {
+        const newOrigin = this.origin.add(other.origin.toVector3d());
+        const newDirection = this.direction.add(other.direction).normalize();
+        return new Axis(newOrigin, newDirection);
+    }
+    translate(dx, dy, dz) {
+        return new Axis(this.origin.translate(dx, dy, dz), this.direction);
+    }
+    translateVector(v) {
+        return new Axis(this.origin.add(v), this.direction);
+    }
+    applyMatrix(matrix) {
+        return new Axis(matrix.transformPoint(this.origin), matrix.transformDirection(this.direction));
+    }
+    rotateAroundAxis(axis, angle) {
+        const matrix = Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, angle);
+        return this.applyMatrix(matrix);
+    }
+    rotateX(angle) {
+        const matrix = Matrix4.fromRotationX(angle);
+        return this.applyMatrix(matrix);
+    }
+    rotateY(angle) {
+        const matrix = Matrix4.fromRotationY(angle);
+        return this.applyMatrix(matrix);
+    }
+    rotateZ(angle) {
+        const matrix = Matrix4.fromRotationZ(angle);
+        return this.applyMatrix(matrix);
+    }
+    transform(options) {
+        let result = this;
+        // Apply translation first
+        if (options.offsetX || options.offsetY || options.offsetZ) {
+            result = result.translate(options.offsetX || 0, options.offsetY || 0, options.offsetZ || 0);
+        }
+        const hasRotation = options.rotateX || options.rotateY || options.rotateZ;
+        if (!hasRotation) {
+            return result;
+        }
+        // Compose all rotations into a single quaternion to avoid gimbal lock
+        let q = Quaternion.identity();
+        if (options.rotateX) {
+            q = q.multiply(Quaternion.fromAxisAngle(Vector3d.unitX(), options.rotateX));
+        }
+        if (options.rotateY) {
+            q = q.multiply(Quaternion.fromAxisAngle(Vector3d.unitY(), options.rotateY));
+        }
+        if (options.rotateZ) {
+            q = q.multiply(Quaternion.fromAxisAngle(Vector3d.unitZ(), options.rotateZ));
+        }
+        // Apply the composed rotation around the axis origin
+        const toOrigin = Matrix4.fromTranslation(-result.origin.x, -result.origin.y, -result.origin.z);
+        const rotation = Matrix4.fromQuaternion(q);
+        const fromOrigin = Matrix4.fromTranslation(result.origin.x, result.origin.y, result.origin.z);
+        const matrix = fromOrigin.multiply(rotation).multiply(toOrigin);
+        return result.applyMatrix(matrix);
+    }
+    isParallelTo(other, tolerance = 1e-10) {
+        return this.direction.isParallelTo(other.direction, tolerance);
+    }
+    isPerpendicularTo(other, tolerance = 1e-10) {
+        return this.direction.isPerpendicularTo(other.direction, tolerance);
+    }
+    isPerpendicularToVector(vector, tolerance = 1e-6) {
+        return Math.abs(this.direction.dot(vector)) <= tolerance;
+    }
+    distanceToPoint(point) {
+        const v = this.origin.vectorTo(point);
+        const projected = v.projectOnto(this.direction);
+        const perpendicular = v.subtract(projected);
+        return perpendicular.length();
+    }
+    closestPointOnAxis(point) {
+        const v = this.origin.vectorTo(point);
+        const t = v.dot(this.direction);
+        return this.origin.add(this.direction.multiply(t));
+    }
+    pointAtParameter(t) {
+        return this.origin.add(this.direction.multiply(t));
+    }
+    reverse() {
+        return new Axis(this.origin, this.direction.negate());
+    }
+    mirrorAroundPoint(point) {
+        const matrix = Matrix4.mirrorPoint(point);
+        return this.applyMatrix(matrix);
+    }
+    mirrorAroundPlane(planeNormal, pointOnPlane) {
+        const matrix = Matrix4.mirrorPlane(planeNormal, pointOnPlane);
+        return this.applyMatrix(matrix);
+    }
+    mirrorAroundAxis(mirrorAxis) {
+        const matrix = Matrix4.mirrorAxis(mirrorAxis.origin, mirrorAxis.direction);
+        return this.applyMatrix(matrix);
+    }
+    clone() {
+        return new Axis(this.origin.clone(), this.direction.clone());
+    }
+    serialize() {
+        return {
+            origin: { x: this.origin.x, y: this.origin.y, z: this.origin.z },
+            direction: { x: this.direction.x, y: this.direction.y, z: this.direction.z },
+        };
+    }
+    toString() {
+        return `Axis(origin: ${this.origin.toString()}, direction: ${this.direction.toString()})`;
+    }
+    static X() {
+        return new Axis(Point.origin(), Vector3d.unitX());
+    }
+    static Y() {
+        return new Axis(Point.origin(), Vector3d.unitY());
+    }
+    static Z() {
+        return new Axis(Point.origin(), Vector3d.unitZ());
+    }
+    static fromPoints(start, end) {
+        const direction = start.vectorTo(end).normalize();
+        return new Axis(start, direction);
+    }
+    static deserialize(data) {
+        return new Axis(new Point(data.origin.x, data.origin.y, data.origin.z), new Vector3d(data.direction.x, data.direction.y, data.direction.z));
+    }
+}
+export function isAxisLike(value) {
+    return value instanceof AxisObjectBase || value instanceof Axis || value === "x" || value === "y" || value === "z";
+}
+export function toAxis(value) {
+    if (value instanceof Axis) {
+        return value;
+    }
+    switch (value) {
+        case "x":
+            return Axis.X();
+        case "y":
+            return Axis.Y();
+        case "z":
+            return Axis.Z();
+    }
+}

package/lib/dist/math/axis.test.d.ts

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