fluidcad 0.0.2

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

@@ -0,0 +1,287 @@
+import { describe, it, expect } from "vitest";
+import { Axis, toAxis, isAxisLike } from "./axis.js";
+import { Point } from "./point.js";
+import { Vector3d } from "./vector3d.js";
+describe("Axis", () => {
+    describe("constructor", () => {
+        it("creates axis with origin and direction", () => {
+            const origin = new Point(1, 2, 3);
+            const direction = new Vector3d(0, 0, 1);
+            const axis = new Axis(origin, direction);
+            expect(axis.origin.equals(origin)).toBe(true);
+            expect(axis.direction.equals(direction)).toBe(true);
+        });
+    });
+    describe("static axes", () => {
+        it("X returns X axis at origin", () => {
+            const axis = Axis.X();
+            expect(axis.origin.equals(Point.origin())).toBe(true);
+            expect(axis.direction.equals(Vector3d.unitX())).toBe(true);
+        });
+        it("Y returns Y axis at origin", () => {
+            const axis = Axis.Y();
+            expect(axis.origin.equals(Point.origin())).toBe(true);
+            expect(axis.direction.equals(Vector3d.unitY())).toBe(true);
+        });
+        it("Z returns Z axis at origin", () => {
+            const axis = Axis.Z();
+            expect(axis.origin.equals(Point.origin())).toBe(true);
+            expect(axis.direction.equals(Vector3d.unitZ())).toBe(true);
+        });
+    });
+    describe("equals", () => {
+        it("returns true for identical axes", () => {
+            const a1 = new Axis(new Point(1, 2, 3), new Vector3d(0, 0, 1));
+            const a2 = new Axis(new Point(1, 2, 3), new Vector3d(0, 0, 1));
+            expect(a1.equals(a2)).toBe(true);
+        });
+        it("returns false for different origin", () => {
+            const a1 = new Axis(new Point(1, 2, 3), new Vector3d(0, 0, 1));
+            const a2 = new Axis(new Point(1, 2, 4), new Vector3d(0, 0, 1));
+            expect(a1.equals(a2)).toBe(false);
+        });
+        it("returns false for different direction", () => {
+            const a1 = new Axis(new Point(1, 2, 3), new Vector3d(0, 0, 1));
+            const a2 = new Axis(new Point(1, 2, 3), new Vector3d(0, 1, 0));
+            expect(a1.equals(a2)).toBe(false);
+        });
+        it("supports tolerance", () => {
+            const a1 = new Axis(new Point(1, 2, 3), new Vector3d(0, 0, 1));
+            const a2 = new Axis(new Point(1.001, 2.001, 3.001), new Vector3d(0, 0, 1));
+            expect(a1.equals(a2, 0.01)).toBe(true);
+        });
+    });
+    describe("translate", () => {
+        it("translates origin, keeps direction", () => {
+            const axis = Axis.Z();
+            const translated = axis.translate(1, 2, 3);
+            expect(translated.origin.x).toBe(1);
+            expect(translated.origin.y).toBe(2);
+            expect(translated.origin.z).toBe(3);
+            expect(translated.direction.equals(Vector3d.unitZ())).toBe(true);
+        });
+    });
+    describe("translateVector", () => {
+        it("translates by vector", () => {
+            const axis = Axis.Z();
+            const translated = axis.translateVector(new Vector3d(1, 2, 3));
+            expect(translated.origin.x).toBe(1);
+            expect(translated.origin.y).toBe(2);
+            expect(translated.origin.z).toBe(3);
+        });
+    });
+    describe("rotateX/Y/Z", () => {
+        it("rotateX rotates around world X axis", () => {
+            const axis = new Axis(Point.origin(), Vector3d.unitY());
+            const rotated = axis.rotateX(Math.PI / 2);
+            expect(rotated.direction.x).toBeCloseTo(0);
+            expect(rotated.direction.y).toBeCloseTo(0);
+            expect(rotated.direction.z).toBeCloseTo(1);
+        });
+        it("rotateY rotates around world Y axis", () => {
+            const axis = new Axis(Point.origin(), Vector3d.unitX());
+            const rotated = axis.rotateY(Math.PI / 2);
+            expect(rotated.direction.x).toBeCloseTo(0);
+            expect(rotated.direction.y).toBeCloseTo(0);
+            expect(rotated.direction.z).toBeCloseTo(-1);
+        });
+        it("rotateZ rotates around world Z axis", () => {
+            const axis = new Axis(Point.origin(), Vector3d.unitX());
+            const rotated = axis.rotateZ(Math.PI / 2);
+            expect(rotated.direction.x).toBeCloseTo(0);
+            expect(rotated.direction.y).toBeCloseTo(1);
+            expect(rotated.direction.z).toBeCloseTo(0);
+        });
+    });
+    describe("rotateAroundAxis", () => {
+        it("rotates around another axis", () => {
+            const axis = new Axis(new Point(1, 0, 0), Vector3d.unitY());
+            const rotateAround = Axis.Z();
+            const rotated = axis.rotateAroundAxis(rotateAround, Math.PI / 2);
+            expect(rotated.origin.x).toBeCloseTo(0);
+            expect(rotated.origin.y).toBeCloseTo(1);
+            expect(rotated.origin.z).toBeCloseTo(0);
+        });
+    });
+    describe("transform", () => {
+        it("applies offset", () => {
+            const axis = Axis.Z();
+            const transformed = axis.transform({ offsetX: 1, offsetY: 2, offsetZ: 3 });
+            expect(transformed.origin.x).toBe(1);
+            expect(transformed.origin.y).toBe(2);
+            expect(transformed.origin.z).toBe(3);
+        });
+        it("applies rotation without gimbal lock", () => {
+            const axis = new Axis(Point.origin(), Vector3d.unitX());
+            // Apply 90° Y rotation - this would cause gimbal lock with sequential rotations
+            const transformed = axis.transform({ rotateY: Math.PI / 2 });
+            expect(transformed.direction.x).toBeCloseTo(0);
+            expect(transformed.direction.z).toBeCloseTo(-1);
+        });
+        it("combines offset and rotation", () => {
+            const axis = new Axis(Point.origin(), Vector3d.unitX());
+            const transformed = axis.transform({
+                offsetX: 5,
+                rotateZ: Math.PI / 2,
+            });
+            expect(transformed.origin.x).toBe(5);
+            expect(transformed.direction.x).toBeCloseTo(0);
+            expect(transformed.direction.y).toBeCloseTo(1);
+        });
+    });
+    describe("isParallelTo", () => {
+        it("returns true for parallel axes", () => {
+            const a1 = new Axis(new Point(0, 0, 0), Vector3d.unitZ());
+            const a2 = new Axis(new Point(5, 5, 0), Vector3d.unitZ());
+            expect(a1.isParallelTo(a2)).toBe(true);
+        });
+        it("returns true for anti-parallel axes", () => {
+            const a1 = new Axis(Point.origin(), Vector3d.unitZ());
+            const a2 = new Axis(Point.origin(), Vector3d.unitZ().negate());
+            expect(a1.isParallelTo(a2)).toBe(true);
+        });
+        it("returns false for non-parallel axes", () => {
+            const a1 = new Axis(Point.origin(), Vector3d.unitZ());
+            const a2 = new Axis(Point.origin(), Vector3d.unitX());
+            expect(a1.isParallelTo(a2)).toBe(false);
+        });
+    });
+    describe("isPerpendicularTo", () => {
+        it("returns true for perpendicular axes", () => {
+            const a1 = Axis.X();
+            const a2 = Axis.Y();
+            expect(a1.isPerpendicularTo(a2)).toBe(true);
+        });
+        it("returns false for non-perpendicular axes", () => {
+            const a1 = Axis.X();
+            const a2 = new Axis(Point.origin(), new Vector3d(1, 1, 0));
+            expect(a1.isPerpendicularTo(a2)).toBe(false);
+        });
+    });
+    describe("distanceToPoint", () => {
+        it("returns 0 for point on axis", () => {
+            const axis = Axis.Z();
+            const point = new Point(0, 0, 5);
+            expect(axis.distanceToPoint(point)).toBeCloseTo(0);
+        });
+        it("returns perpendicular distance", () => {
+            const axis = Axis.Z();
+            const point = new Point(3, 4, 0);
+            expect(axis.distanceToPoint(point)).toBeCloseTo(5);
+        });
+    });
+    describe("closestPointOnAxis", () => {
+        it("returns closest point", () => {
+            const axis = Axis.Z();
+            const point = new Point(3, 4, 5);
+            const closest = axis.closestPointOnAxis(point);
+            expect(closest.x).toBeCloseTo(0);
+            expect(closest.y).toBeCloseTo(0);
+            expect(closest.z).toBeCloseTo(5);
+        });
+    });
+    describe("pointAtParameter", () => {
+        it("returns point at parameter t", () => {
+            const axis = new Axis(new Point(1, 0, 0), Vector3d.unitX());
+            const p = axis.pointAtParameter(5);
+            expect(p.x).toBe(6);
+            expect(p.y).toBe(0);
+            expect(p.z).toBe(0);
+        });
+    });
+    describe("reverse", () => {
+        it("reverses direction", () => {
+            const axis = Axis.Z();
+            const reversed = axis.reverse();
+            expect(reversed.direction.z).toBe(-1);
+            expect(reversed.origin.equals(axis.origin)).toBe(true);
+        });
+    });
+    describe("mirror methods", () => {
+        it("mirrorAroundPoint mirrors through point", () => {
+            const axis = new Axis(new Point(2, 0, 0), Vector3d.unitZ());
+            const mirrored = axis.mirrorAroundPoint(Point.origin());
+            expect(mirrored.origin.x).toBeCloseTo(-2);
+        });
+        it("mirrorAroundPlane mirrors through plane", () => {
+            const axis = new Axis(new Point(0, 0, 2), Vector3d.unitZ());
+            const mirrored = axis.mirrorAroundPlane(Vector3d.unitZ(), Point.origin());
+            expect(mirrored.origin.z).toBeCloseTo(-2);
+            expect(mirrored.direction.z).toBeCloseTo(-1);
+        });
+        it("mirrorAroundAxis mirrors through axis", () => {
+            const axis = new Axis(new Point(2, 0, 0), Vector3d.unitY());
+            const mirrorAxis = Axis.Z();
+            const mirrored = axis.mirrorAroundAxis(mirrorAxis);
+            expect(mirrored.origin.x).toBeCloseTo(-2);
+        });
+    });
+    describe("fromPoints", () => {
+        it("creates axis from two points", () => {
+            const start = new Point(0, 0, 0);
+            const end = new Point(0, 0, 5);
+            const axis = Axis.fromPoints(start, end);
+            expect(axis.origin.equals(start)).toBe(true);
+            expect(axis.direction.equals(Vector3d.unitZ())).toBe(true);
+        });
+    });
+    describe("serialize/deserialize", () => {
+        it("serializes to object", () => {
+            const axis = new Axis(new Point(1, 2, 3), new Vector3d(0, 0, 1));
+            const data = axis.serialize();
+            expect(data.origin).toEqual({ x: 1, y: 2, z: 3 });
+            expect(data.direction).toEqual({ x: 0, y: 0, z: 1 });
+        });
+        it("deserializes from object", () => {
+            const data = {
+                origin: { x: 1, y: 2, z: 3 },
+                direction: { x: 0, y: 0, z: 1 },
+            };
+            const axis = Axis.deserialize(data);
+            expect(axis.origin.x).toBe(1);
+            expect(axis.direction.z).toBe(1);
+        });
+    });
+    describe("clone", () => {
+        it("creates independent copy", () => {
+            const axis = new Axis(new Point(1, 2, 3), Vector3d.unitZ());
+            const clone = axis.clone();
+            expect(clone.equals(axis)).toBe(true);
+            expect(clone).not.toBe(axis);
+        });
+    });
+});
+describe("helper functions", () => {
+    describe("toAxis", () => {
+        it("returns same instance for Axis", () => {
+            const axis = Axis.Z();
+            expect(toAxis(axis)).toBe(axis);
+        });
+        it("converts 'x' to X axis", () => {
+            const axis = toAxis("x");
+            expect(axis.direction.equals(Vector3d.unitX())).toBe(true);
+        });
+        it("converts 'y' to Y axis", () => {
+            const axis = toAxis("y");
+            expect(axis.direction.equals(Vector3d.unitY())).toBe(true);
+        });
+        it("converts 'z' to Z axis", () => {
+            const axis = toAxis("z");
+            expect(axis.direction.equals(Vector3d.unitZ())).toBe(true);
+        });
+    });
+    describe("isAxisLike", () => {
+        it("returns true for Axis", () => {
+            expect(isAxisLike(Axis.Z())).toBe(true);
+        });
+        it("returns true for 'x', 'y', 'z'", () => {
+            expect(isAxisLike("x")).toBe(true);
+            expect(isAxisLike("y")).toBe(true);
+            expect(isAxisLike("z")).toBe(true);
+        });
+        it("returns false for other values", () => {
+            expect(isAxisLike("w")).toBe(false);
+            expect(isAxisLike(123)).toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,2 @@
+export { Convert } from "../oc/convert.js";
+export type { Disposable } from "../oc/convert.js";

package/lib/dist/math/convert.js

@@ -0,0 +1 @@
+export { Convert } from "../oc/convert.js";

package/lib/dist/math/coordinate-system.d.ts

@@ -0,0 +1,43 @@
+import { Point } from "./point.js";
+import { Vector3d } from "./vector3d.js";
+import { Axis } from "./axis.js";
+import { Plane, PlaneLike } from "./plane.js";
+import { Matrix4 } from "./matrix4.js";
+export declare class CoordinateSystem {
+    readonly origin: Point;
+    readonly mainDirection: Vector3d;
+    readonly xDirection: Vector3d;
+    readonly yDirection: Vector3d;
+    constructor(origin: Point, mainDirection: Vector3d, xDirection: Vector3d);
+    get xAxis(): Axis;
+    get yAxis(): Axis;
+    get mainAxis(): Axis;
+    get zAxis(): Axis;
+    angle(other: CoordinateSystem): number;
+    isCoplanar(other: CoordinateSystem, linearTolerance?: number, angularTolerance?: number): boolean;
+    applyMatrix(matrix: Matrix4): CoordinateSystem;
+    mirrorAroundPoint(point: Point): CoordinateSystem;
+    mirrorAroundAxis(axis: Axis): CoordinateSystem;
+    mirrorAroundPlane(planeNormal: Vector3d, pointOnPlane: Point): CoordinateSystem;
+    rotate(axis: Axis, angle: number): CoordinateSystem;
+    scale(point: Point, factor: number): CoordinateSystem;
+    translate(dx: number, dy: number, dz: number): CoordinateSystem;
+    translateVector(v: Vector3d): CoordinateSystem;
+    getXYPlane(): Plane;
+    getXZPlane(): Plane;
+    getYZPlane(): Plane;
+    worldToLocal(point: Point): Point;
+    localToWorld(point: Point): Point;
+    worldToLocalVector(v: Vector3d): Vector3d;
+    localToWorldVector(v: Vector3d): Vector3d;
+    getBasisMatrix(): Matrix4;
+    getInverseBasisMatrix(): Matrix4;
+    equals(other: CoordinateSystem, tolerance?: number): boolean;
+    clone(): CoordinateSystem;
+    toString(): string;
+    private static _world;
+    static World(): CoordinateSystem;
+    static fromPlane(plane: PlaneLike): CoordinateSystem;
+    static fromOriginAndAxes(origin: Point, xAxis: Vector3d, _yAxis: Vector3d, zAxis: Vector3d): CoordinateSystem;
+    static fromTwoAxes(origin: Point, primaryAxis: Vector3d, secondaryAxis: Vector3d): CoordinateSystem;
+}

package/lib/dist/math/coordinate-system.js

@@ -0,0 +1,140 @@
+import { Point } from "./point.js";
+import { Vector3d } from "./vector3d.js";
+import { Axis } from "./axis.js";
+import { Plane, toPlane } from "./plane.js";
+import { Matrix4 } from "./matrix4.js";
+export class CoordinateSystem {
+    origin;
+    mainDirection;
+    xDirection;
+    yDirection;
+    constructor(origin, mainDirection, xDirection) {
+        this.origin = origin;
+        this.mainDirection = mainDirection;
+        this.xDirection = xDirection;
+        this.yDirection = this.mainDirection.cross(this.xDirection).normalize();
+    }
+    get xAxis() {
+        return new Axis(this.origin, this.xDirection);
+    }
+    get yAxis() {
+        return new Axis(this.origin, this.yDirection);
+    }
+    get mainAxis() {
+        return new Axis(this.origin, this.mainDirection);
+    }
+    get zAxis() {
+        return this.mainAxis;
+    }
+    angle(other) {
+        return this.mainDirection.angleTo(other.mainDirection);
+    }
+    isCoplanar(other, linearTolerance = 1e-10, angularTolerance = 1e-10) {
+        if (!this.mainDirection.isParallelTo(other.mainDirection, angularTolerance)) {
+            return false;
+        }
+        const v = this.origin.vectorTo(other.origin);
+        const distance = Math.abs(v.dot(this.mainDirection));
+        return distance <= linearTolerance;
+    }
+    applyMatrix(matrix) {
+        return new CoordinateSystem(matrix.transformPoint(this.origin), matrix.transformDirection(this.mainDirection), matrix.transformDirection(this.xDirection));
+    }
+    mirrorAroundPoint(point) {
+        const matrix = Matrix4.mirrorPoint(point);
+        return this.applyMatrix(matrix);
+    }
+    mirrorAroundAxis(axis) {
+        const matrix = Matrix4.mirrorAxis(axis.origin, axis.direction);
+        return this.applyMatrix(matrix);
+    }
+    mirrorAroundPlane(planeNormal, pointOnPlane) {
+        const matrix = Matrix4.mirrorPlane(planeNormal, pointOnPlane);
+        return this.applyMatrix(matrix);
+    }
+    rotate(axis, angle) {
+        const toOrigin = Matrix4.fromTranslation(-axis.origin.x, -axis.origin.y, -axis.origin.z);
+        const rotate = Matrix4.fromAxisAngle(axis.direction, angle);
+        const fromOrigin = Matrix4.fromTranslation(axis.origin.x, axis.origin.y, axis.origin.z);
+        const matrix = fromOrigin.multiply(rotate).multiply(toOrigin);
+        return this.applyMatrix(matrix);
+    }
+    scale(point, factor) {
+        const toOrigin = Matrix4.fromTranslation(-point.x, -point.y, -point.z);
+        const scaleMatrix = Matrix4.fromUniformScale(factor);
+        const fromOrigin = Matrix4.fromTranslation(point.x, point.y, point.z);
+        const matrix = fromOrigin.multiply(scaleMatrix).multiply(toOrigin);
+        return new CoordinateSystem(matrix.transformPoint(this.origin), this.mainDirection, this.xDirection);
+    }
+    translate(dx, dy, dz) {
+        return new CoordinateSystem(this.origin.translate(dx, dy, dz), this.mainDirection, this.xDirection);
+    }
+    translateVector(v) {
+        return this.translate(v.x, v.y, v.z);
+    }
+    getXYPlane() {
+        return new Plane(this.origin, this.xDirection, this.mainDirection);
+    }
+    getXZPlane() {
+        return new Plane(this.origin, this.xDirection, this.yDirection.negate());
+    }
+    getYZPlane() {
+        return new Plane(this.origin, this.yDirection, this.xDirection);
+    }
+    worldToLocal(point) {
+        const v = this.origin.vectorTo(point);
+        return new Point(v.dot(this.xDirection), v.dot(this.yDirection), v.dot(this.mainDirection));
+    }
+    localToWorld(point) {
+        return this.origin
+            .add(this.xDirection.multiply(point.x))
+            .add(this.yDirection.multiply(point.y))
+            .add(this.mainDirection.multiply(point.z));
+    }
+    worldToLocalVector(v) {
+        return new Vector3d(v.dot(this.xDirection), v.dot(this.yDirection), v.dot(this.mainDirection));
+    }
+    localToWorldVector(v) {
+        return this.xDirection
+            .multiply(v.x)
+            .add(this.yDirection.multiply(v.y))
+            .add(this.mainDirection.multiply(v.z));
+    }
+    getBasisMatrix() {
+        return Matrix4.fromBasis(this.xDirection, this.yDirection, this.mainDirection, this.origin);
+    }
+    getInverseBasisMatrix() {
+        return this.getBasisMatrix().inverse();
+    }
+    equals(other, tolerance = 0) {
+        return (this.origin.equals(other.origin, tolerance) &&
+            this.mainDirection.equals(other.mainDirection, tolerance) &&
+            this.xDirection.equals(other.xDirection, tolerance));
+    }
+    clone() {
+        return new CoordinateSystem(this.origin.clone(), this.mainDirection.clone(), this.xDirection.clone());
+    }
+    toString() {
+        return `CoordinateSystem(origin: ${this.origin.toString()}, mainDirection: ${this.mainDirection.toString()}, xDirection: ${this.xDirection.toString()})`;
+    }
+    static _world = null;
+    static World() {
+        if (!CoordinateSystem._world) {
+            CoordinateSystem._world = new CoordinateSystem(Point.origin(), Vector3d.unitZ(), Vector3d.unitX());
+        }
+        return CoordinateSystem._world;
+    }
+    static fromPlane(plane) {
+        const p = toPlane(plane);
+        return new CoordinateSystem(p.origin, p.normal, p.xDirection);
+    }
+    static fromOriginAndAxes(origin, xAxis, _yAxis, zAxis) {
+        return new CoordinateSystem(origin, zAxis, xAxis);
+    }
+    static fromTwoAxes(origin, primaryAxis, secondaryAxis) {
+        const z = primaryAxis.normalize();
+        const y = z.cross(secondaryAxis.normalize()).normalize();
+        const x = y.cross(z).normalize();
+        return new CoordinateSystem(origin, z, x);
+    }
+}

package/lib/dist/math/coordinate-system.test.d.ts

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