fluidcad 0.0.2 → 0.0.4

package/lib/dist/math/vector3d.test.js

@@ -1,276 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { Vector3d, normalizeVector } from "./vector3d.js";
-describe("Vector3d", () => {
-    describe("constructor", () => {
-        it("creates a vector with x, y, z components", () => {
-            const v = new Vector3d(1, 2, 3);
-            expect(v.x).toBe(1);
-            expect(v.y).toBe(2);
-            expect(v.z).toBe(3);
-        });
-    });
-    describe("equals", () => {
-        it("returns true for identical vectors", () => {
-            const v1 = new Vector3d(1, 2, 3);
-            const v2 = new Vector3d(1, 2, 3);
-            expect(v1.equals(v2)).toBe(true);
-        });
-        it("returns false for different vectors", () => {
-            const v1 = new Vector3d(1, 2, 3);
-            const v2 = new Vector3d(1, 2, 4);
-            expect(v1.equals(v2)).toBe(false);
-        });
-        it("supports tolerance", () => {
-            const v1 = new Vector3d(1, 2, 3);
-            const v2 = new Vector3d(1.001, 2.001, 3.001);
-            expect(v1.equals(v2, 0.01)).toBe(true);
-            expect(v1.equals(v2, 0.0001)).toBe(false);
-        });
-    });
-    describe("dot", () => {
-        it("computes dot product correctly", () => {
-            const v1 = new Vector3d(1, 2, 3);
-            const v2 = new Vector3d(4, 5, 6);
-            expect(v1.dot(v2)).toBe(32); // 1*4 + 2*5 + 3*6
-        });
-        it("returns 0 for perpendicular vectors", () => {
-            const v1 = new Vector3d(1, 0, 0);
-            const v2 = new Vector3d(0, 1, 0);
-            expect(v1.dot(v2)).toBe(0);
-        });
-    });
-    describe("cross", () => {
-        it("computes cross product correctly", () => {
-            const v1 = new Vector3d(1, 0, 0);
-            const v2 = new Vector3d(0, 1, 0);
-            const result = v1.cross(v2);
-            expect(result.x).toBe(0);
-            expect(result.y).toBe(0);
-            expect(result.z).toBe(1);
-        });
-        it("returns zero vector for parallel vectors", () => {
-            const v1 = new Vector3d(1, 0, 0);
-            const v2 = new Vector3d(2, 0, 0);
-            const result = v1.cross(v2);
-            expect(result.isZero()).toBe(true);
-        });
-    });
-    describe("length", () => {
-        it("computes length correctly", () => {
-            const v = new Vector3d(3, 4, 0);
-            expect(v.length()).toBe(5);
-        });
-        it("returns 0 for zero vector", () => {
-            const v = new Vector3d(0, 0, 0);
-            expect(v.length()).toBe(0);
-        });
-    });
-    describe("normalize", () => {
-        it("returns unit vector", () => {
-            const v = new Vector3d(3, 4, 0);
-            const normalized = v.normalize();
-            expect(normalized.length()).toBeCloseTo(1);
-            expect(normalized.x).toBeCloseTo(0.6);
-            expect(normalized.y).toBeCloseTo(0.8);
-            expect(normalized.z).toBe(0);
-        });
-        it("throws for zero vector", () => {
-            const v = new Vector3d(0, 0, 0);
-            expect(() => v.normalize()).toThrow();
-        });
-    });
-    describe("add", () => {
-        it("adds vectors correctly", () => {
-            const v1 = new Vector3d(1, 2, 3);
-            const v2 = new Vector3d(4, 5, 6);
-            const result = v1.add(v2);
-            expect(result.x).toBe(5);
-            expect(result.y).toBe(7);
-            expect(result.z).toBe(9);
-        });
-        it("is immutable", () => {
-            const v1 = new Vector3d(1, 2, 3);
-            const v2 = new Vector3d(4, 5, 6);
-            v1.add(v2);
-            expect(v1.x).toBe(1);
-        });
-    });
-    describe("subtract", () => {
-        it("subtracts vectors correctly", () => {
-            const v1 = new Vector3d(4, 5, 6);
-            const v2 = new Vector3d(1, 2, 3);
-            const result = v1.subtract(v2);
-            expect(result.x).toBe(3);
-            expect(result.y).toBe(3);
-            expect(result.z).toBe(3);
-        });
-    });
-    describe("multiply", () => {
-        it("multiplies by scalar correctly", () => {
-            const v = new Vector3d(1, 2, 3);
-            const result = v.multiply(2);
-            expect(result.x).toBe(2);
-            expect(result.y).toBe(4);
-            expect(result.z).toBe(6);
-        });
-    });
-    describe("negate", () => {
-        it("negates vector correctly", () => {
-            const v = new Vector3d(1, -2, 3);
-            const result = v.negate();
-            expect(result.x).toBe(-1);
-            expect(result.y).toBe(2);
-            expect(result.z).toBe(-3);
-        });
-    });
-    describe("isZero", () => {
-        it("returns true for zero vector", () => {
-            const v = new Vector3d(0, 0, 0);
-            expect(v.isZero()).toBe(true);
-        });
-        it("returns false for non-zero vector", () => {
-            const v = new Vector3d(0.001, 0, 0);
-            expect(v.isZero()).toBe(false);
-        });
-        it("supports tolerance", () => {
-            const v = new Vector3d(0.001, 0.001, 0.001);
-            expect(v.isZero(0.01)).toBe(true);
-        });
-    });
-    describe("angleTo", () => {
-        it("returns 0 for same direction", () => {
-            const v1 = new Vector3d(1, 0, 0);
-            const v2 = new Vector3d(2, 0, 0);
-            expect(v1.angleTo(v2)).toBeCloseTo(0);
-        });
-        it("returns PI/2 for perpendicular vectors", () => {
-            const v1 = new Vector3d(1, 0, 0);
-            const v2 = new Vector3d(0, 1, 0);
-            expect(v1.angleTo(v2)).toBeCloseTo(Math.PI / 2);
-        });
-        it("returns PI for opposite directions", () => {
-            const v1 = new Vector3d(1, 0, 0);
-            const v2 = new Vector3d(-1, 0, 0);
-            expect(v1.angleTo(v2)).toBeCloseTo(Math.PI);
-        });
-    });
-    describe("projectOnto", () => {
-        it("projects vector correctly", () => {
-            const v = new Vector3d(3, 4, 0);
-            const onto = new Vector3d(1, 0, 0);
-            const result = v.projectOnto(onto);
-            expect(result.x).toBeCloseTo(3);
-            expect(result.y).toBeCloseTo(0);
-            expect(result.z).toBeCloseTo(0);
-        });
-    });
-    describe("reflect", () => {
-        it("reflects vector correctly", () => {
-            const v = new Vector3d(1, -1, 0);
-            const normal = new Vector3d(0, 1, 0);
-            const result = v.reflect(normal);
-            expect(result.x).toBeCloseTo(1);
-            expect(result.y).toBeCloseTo(1);
-            expect(result.z).toBeCloseTo(0);
-        });
-    });
-    describe("lerp", () => {
-        it("interpolates at t=0", () => {
-            const v1 = new Vector3d(0, 0, 0);
-            const v2 = new Vector3d(10, 10, 10);
-            const result = v1.lerp(v2, 0);
-            expect(result.equals(v1)).toBe(true);
-        });
-        it("interpolates at t=1", () => {
-            const v1 = new Vector3d(0, 0, 0);
-            const v2 = new Vector3d(10, 10, 10);
-            const result = v1.lerp(v2, 1);
-            expect(result.equals(v2)).toBe(true);
-        });
-        it("interpolates at t=0.5", () => {
-            const v1 = new Vector3d(0, 0, 0);
-            const v2 = new Vector3d(10, 10, 10);
-            const result = v1.lerp(v2, 0.5);
-            expect(result.x).toBe(5);
-            expect(result.y).toBe(5);
-            expect(result.z).toBe(5);
-        });
-    });
-    describe("isParallelTo", () => {
-        it("returns true for parallel vectors", () => {
-            const v1 = new Vector3d(1, 0, 0);
-            const v2 = new Vector3d(5, 0, 0);
-            expect(v1.isParallelTo(v2)).toBe(true);
-        });
-        it("returns true for anti-parallel vectors", () => {
-            const v1 = new Vector3d(1, 0, 0);
-            const v2 = new Vector3d(-5, 0, 0);
-            expect(v1.isParallelTo(v2)).toBe(true);
-        });
-        it("returns false for non-parallel vectors", () => {
-            const v1 = new Vector3d(1, 0, 0);
-            const v2 = new Vector3d(1, 1, 0);
-            expect(v1.isParallelTo(v2)).toBe(false);
-        });
-    });
-    describe("isPerpendicularTo", () => {
-        it("returns true for perpendicular vectors", () => {
-            const v1 = new Vector3d(1, 0, 0);
-            const v2 = new Vector3d(0, 1, 0);
-            expect(v1.isPerpendicularTo(v2)).toBe(true);
-        });
-        it("returns false for non-perpendicular vectors", () => {
-            const v1 = new Vector3d(1, 0, 0);
-            const v2 = new Vector3d(1, 1, 0);
-            expect(v1.isPerpendicularTo(v2)).toBe(false);
-        });
-    });
-    describe("static methods", () => {
-        it("unitX returns (1,0,0)", () => {
-            const v = Vector3d.unitX();
-            expect(v.x).toBe(1);
-            expect(v.y).toBe(0);
-            expect(v.z).toBe(0);
-        });
-        it("unitY returns (0,1,0)", () => {
-            const v = Vector3d.unitY();
-            expect(v.x).toBe(0);
-            expect(v.y).toBe(1);
-            expect(v.z).toBe(0);
-        });
-        it("unitZ returns (0,0,1)", () => {
-            const v = Vector3d.unitZ();
-            expect(v.x).toBe(0);
-            expect(v.y).toBe(0);
-            expect(v.z).toBe(1);
-        });
-        it("zero returns (0,0,0)", () => {
-            const v = Vector3d.zero();
-            expect(v.isZero()).toBe(true);
-        });
-        it("fromArray creates vector from array", () => {
-            const v = Vector3d.fromArray([1, 2, 3]);
-            expect(v.x).toBe(1);
-            expect(v.y).toBe(2);
-            expect(v.z).toBe(3);
-        });
-    });
-    describe("toVector3d helper", () => {
-        it("returns same instance for Vector3d", () => {
-            const v = new Vector3d(1, 2, 3);
-            expect(normalizeVector(v)).toBe(v);
-        });
-        it("converts array to Vector3d", () => {
-            const v = normalizeVector([1, 2, 3]);
-            expect(v.x).toBe(1);
-            expect(v.y).toBe(2);
-            expect(v.z).toBe(3);
-        });
-        it("converts object to Vector3d", () => {
-            const v = normalizeVector({ x: 1, y: 2, z: 3 });
-            expect(v.x).toBe(1);
-            expect(v.y).toBe(2);
-            expect(v.z).toBe(3);
-        });
-    });
-});

package/lib/dist/oc/constraint-resolver.d.ts

@@ -1,7 +0,0 @@
-import type { GccEnt_Position, GccEnt_QualifiedCirc, GccEnt_QualifiedLin, gp_Circ, gp_Circ2d, gp_Lin, gp_Lin2d, gp_Pln, gp_Pnt, gp_Pnt2d } from "occjs-wrapper";
-import { ConstraintQualifier } from "../features/2d/constraints/qualified-geometry.js";
-export declare class ConstraintResolver {
-    static get2dGeometry<T extends gp_Circ | gp_Lin | gp_Pnt>(plane: gp_Pln, geometry: T): gp_Lin2d | gp_Circ2d | gp_Pnt2d;
-    static getQualifier(qualifier: ConstraintQualifier): GccEnt_Position;
-    static getQualified(plane: gp_Pln, geometry: gp_Circ | gp_Lin, qualifier: ConstraintQualifier): GccEnt_QualifiedCirc | GccEnt_QualifiedLin;
-}

package/lib/dist/oc/constraint-resolver.js

@@ -1,31 +0,0 @@
-import { getOC } from "./init.js";
-export class ConstraintResolver {
-    static get2dGeometry(plane, geometry) {
-        const oc = getOC();
-        return oc.ProjLib.Project(plane, geometry);
-    }
-    static getQualifier(qualifier) {
-        const oc = getOC();
-        switch (qualifier) {
-            case 'unqualified':
-                return oc.GccEnt_Position.GccEnt_unqualified;
-            case 'enclosed':
-                return oc.GccEnt_Position.GccEnt_enclosed;
-            case 'enclosing':
-                return oc.GccEnt_Position.GccEnt_enclosing;
-            case 'outside':
-                return oc.GccEnt_Position.GccEnt_outside;
-        }
-    }
-    static getQualified(plane, geometry, qualifier) {
-        const oc = getOC();
-        const geom = this.get2dGeometry(plane, geometry);
-        if (geom instanceof oc.gp_Circ2d) {
-            return new oc.GccEnt_QualifiedCirc(geom, this.getQualifier(qualifier));
-        }
-        else if (geom instanceof oc.gp_Lin2d) {
-            return new oc.GccEnt_QualifiedLin(geom, this.getQualifier(qualifier));
-        }
-        throw new Error('Unsupported geometry type');
-    }
-}

package/lib/dist/oc/constraints/curve-constraint-solver.d.ts

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

package/lib/dist/oc/constraints/curve-constraint-solver.js

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

package/lib/dist/oc/constraints/geometric-constraint-solver.d.ts

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

package/lib/dist/oc/constraints/geometric-constraint-solver.js

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

package/lib/dist/oc/face-maker.d.ts

@@ -1,14 +0,0 @@
-import type { TopoDS_Compound, gp_Pln, TopoDS_Face, TopoDS_Wire } from "occjs-wrapper";
-import type { BoundingBox, FaceInfo } from "../helpers/types.js";
-export declare class OcFaceMaker {
-    static createFacesFromWires(wires: TopoDS_Wire[], gpPln: gp_Pln): TopoDS_Face[];
-    static fuseIntersectingFaces(faces: TopoDS_Face[]): TopoDS_Face[];
-    static unifyFaces(facesCompound: TopoDS_Compound): TopoDS_Face;
-    static boundingBoxesIntersect(bbox1: BoundingBox, bbox2: BoundingBox): boolean;
-    static getWiresFromFaces(faces: TopoDS_Face[]): TopoDS_Wire[];
-    static drillHoles(faceInfos: FaceInfo[]): FaceInfo[];
-    private static getFaceHoles;
-    private static wireIsInsideFace;
-    private static getFirstPointOfWire;
-    private static hitTest;
-}

package/lib/dist/oc/face-maker.js

@@ -1,191 +0,0 @@
-import { getOC } from "./init.js";
-import { Explorer } from "./explorer.js";
-import { ShapeOps } from "./shape-ops.js";
-import { FaceOps } from "./face-ops.js";
-import { Face } from "../common/face.js";
-export class OcFaceMaker {
-    static createFacesFromWires(wires, gpPln) {
-        const oc = getOC();
-        if (wires.length === 0)
-            return [];
-        console.log("Creating faces from wires:", wires.length);
-        const faces = [];
-        for (let wire of wires) {
-            const face = FaceOps.makeFaceOnPlane(oc.TopoDS.Wire(wire), gpPln);
-            const fixer = new oc.ShapeFix_Face(face);
-            fixer.FixOrientation();
-            fixer.Perform();
-            const fixedFace = fixer.Face();
-            faces.push(fixedFace);
-            fixer.delete();
-            face.delete();
-        }
-        return faces;
-    }
-    static fuseIntersectingFaces(faces) {
-        const oc = getOC();
-        if (faces.length === 0)
-            return [];
-        if (faces.length === 1)
-            return faces;
-        const faceBoxes = faces.map((face, index) => ({
-            face,
-            index,
-            bbox: ShapeOps.getBoundingBox(face)
-        }));
-        const result = [];
-        const processedFaces = new Set();
-        for (let i = 0; i < faces.length; i++) {
-            const face1 = faces[i];
-            if (processedFaces.has(face1)) {
-                continue;
-            }
-            let fusedFace = face1;
-            const facesToFuse = [face1];
-            let bbox1 = faceBoxes[i].bbox;
-            for (let j = i + 1; j < faces.length; j++) {
-                const face2 = faces[j];
-                if (processedFaces.has(face2)) {
-                    continue;
-                }
-                const bbox2 = faceBoxes[j].bbox;
-                if (!OcFaceMaker.boundingBoxesIntersect(bbox1, bbox2)) {
-                    continue;
-                }
-                const progress = new oc.Message_ProgressRange();
-                const fuseMaker = new oc.BRepAlgoAPI_Fuse(fusedFace, face2, progress);
-                if (fuseMaker.IsDone()) {
-                    const newShape = fuseMaker.Shape();
-                    if (!newShape.IsNull()) {
-                        if (newShape.ShapeType() === oc.TopAbs_ShapeEnum.TopAbs_COMPOUND) {
-                            const facesInCompound = Explorer.findShapes(newShape, oc.TopAbs_ShapeEnum.TopAbs_FACE);
-                            console.log("Fused faces into a compound, found faces:", facesInCompound.length);
-                            if (facesInCompound.length > 2) {
-                                fusedFace = OcFaceMaker.unifyFaces(newShape);
-                                bbox1 = ShapeOps.getBoundingBox(fusedFace);
-                                facesToFuse.push(face2);
-                            }
-                        }
-                    }
-                }
-                progress.delete();
-                fuseMaker.delete();
-            }
-            result.push(fusedFace);
-            facesToFuse.forEach(face => processedFaces.add(face));
-        }
-        console.log("Fused faces count:", result.length);
-        return result;
-    }
-    static unifyFaces(facesCompound) {
-        console.log("Unifying faces compound:", facesCompound);
-        const oc = getOC();
-        const freeBounds = new oc.ShapeAnalysis_FreeBounds(facesCompound, oc.Precision.Confusion(), true, false);
-        const closedWiresCompound = freeBounds.GetClosedWires();
-        const firstWire = Explorer.findFirstShapeOfType(closedWiresCompound, oc.TopAbs_ShapeEnum.TopAbs_WIRE);
-        freeBounds.delete();
-        return FaceOps.makeFace(oc.TopoDS.Wire(firstWire));
-    }
-    static boundingBoxesIntersect(bbox1, bbox2) {
-        return !(bbox1.maxX < bbox2.minX || bbox2.maxX < bbox1.minX ||
-            bbox1.maxY < bbox2.minY || bbox2.maxY < bbox1.minY);
-    }
-    static getWiresFromFaces(faces) {
-        const oc = getOC();
-        const wires = [];
-        for (let face of faces) {
-            const faceWires = Explorer.findShapes(face, oc.TopAbs_ShapeEnum.TopAbs_WIRE);
-            console.log("Found wires in face:", faceWires.length);
-            for (const wire of faceWires) {
-                wires.push(oc.TopoDS.Wire(wire));
-            }
-        }
-        return wires;
-    }
-    static drillHoles(faceInfos) {
-        const oc = getOC();
-        const foundHoles = [];
-        let drilledFaces = [];
-        for (const faceInfo of faceInfos) {
-            if (foundHoles.includes(faceInfo)) {
-                continue;
-            }
-            const faceHoles = OcFaceMaker.getFaceHoles(faceInfo, faceInfos, foundHoles);
-            console.log("Found holes for face:", faceHoles.length);
-            if (faceHoles.length === 0) {
-                drilledFaces.push(faceInfo);
-                continue;
-            }
-            faceInfo.holes = faceHoles;
-            drilledFaces.push(faceInfo);
-            for (const hole of faceHoles) {
-                foundHoles.push(hole);
-            }
-        }
-        console.log("Found holes:", foundHoles.length);
-        console.log("Drilled faces before removing holes:", drilledFaces.length);
-        drilledFaces = drilledFaces.filter(info => !foundHoles.includes(info));
-        console.log("Drilled faces:", drilledFaces.length);
-        for (const info of drilledFaces) {
-            const holes = info.holes;
-            if (!holes?.length) {
-                continue;
-            }
-            const rawWire = info.wire.getShape();
-            const faceMaker = new oc.BRepLib_MakeFace(rawWire, false);
-            for (const hole of holes) {
-                const holeWire = hole.wire.getShape();
-                holeWire.Reverse();
-                faceMaker.Add(holeWire);
-            }
-            const newFace = faceMaker.Face();
-            info.face = Face.fromTopoDSFace(newFace);
-            for (const hole of holes) {
-                hole.wire.getShape().delete();
-                hole.face.getShape().delete();
-            }
-            info.holes = [];
-        }
-        return drilledFaces;
-    }
-    static getFaceHoles(faceInfo, allFaceInfos, exclude) {
-        const holes = [];
-        for (let fInfo of allFaceInfos) {
-            if (fInfo === faceInfo || exclude.includes(faceInfo)) {
-                continue;
-            }
-            if (OcFaceMaker.wireIsInsideFace(fInfo, faceInfo)) {
-                holes.push(fInfo);
-            }
-        }
-        return holes;
-    }
-    static wireIsInsideFace(inner, outer) {
-        const firstPoint = OcFaceMaker.getFirstPointOfWire(inner.wire.getShape());
-        return OcFaceMaker.hitTest(firstPoint, outer.face.getShape());
-    }
-    static getFirstPointOfWire(wire) {
-        const oc = getOC();
-        try {
-            const edges = Explorer.findShapes(wire, oc.TopAbs_ShapeEnum.TopAbs_EDGE);
-            const firstEdge = oc.TopoDS.Edge(edges[0]);
-            const vertex = oc.TopExp.FirstVertex(firstEdge, true);
-            const point = oc.BRep_Tool.Pnt(vertex);
-            return point;
-        }
-        catch (error) {
-            console.error("Error getting first point of wire:", error);
-            return null;
-        }
-    }
-    static hitTest(point, face) {
-        const oc = getOC();
-        const classifier = new oc.BRepClass_FaceClassifier();
-        classifier.Perform(face, point, oc.Precision.Confusion(), true, oc.Precision.Confusion());
-        const state = classifier.State();
-        const isInside = state === oc.TopAbs_State.TopAbs_IN ||
-            state === oc.TopAbs_State.TopAbs_ON;
-        classifier.delete();
-        return isInside;
-    }
-}

package/lib/dist/oc/measure.d.ts

@@ -1,21 +0,0 @@
-import type { TopoDS_Shape } from "occjs-wrapper";
-export interface MeasurementEntry {
-    label: string;
-    value: number;
-    unit: 'mm' | 'deg';
-    icon: 'distance' | 'angle' | 'radius';
-    axisBreakdown?: {
-        dx: number;
-        dy: number;
-        dz: number;
-    };
-}
-export interface MeasurementResult {
-    headline: MeasurementEntry;
-    others: MeasurementEntry[];
-    refPointA: [number, number, number];
-    refPointB: [number, number, number];
-}
-export declare class OccMeasure {
-    static compute(shapeA: TopoDS_Shape, typeA: 'face' | 'edge', indexA: number, shapeB: TopoDS_Shape, typeB: 'face' | 'edge', indexB: number): MeasurementResult | null;
-}