fluidcad 0.0.3 → 0.0.4

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

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

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

@@ -1,287 +0,0 @@
-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/coordinate-system.test.d.ts

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

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

@@ -1,308 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { CoordinateSystem } from "./coordinate-system.js";
-import { Point } from "./point.js";
-import { Vector3d } from "./vector3d.js";
-import { Axis } from "./axis.js";
-import { Plane } from "./plane.js";
-describe("CoordinateSystem", () => {
-    describe("constructor", () => {
-        it("creates coordinate system with origin, mainDirection, xDirection", () => {
-            const origin = new Point(1, 2, 3);
-            const mainDir = Vector3d.unitZ();
-            const xDir = Vector3d.unitX();
-            const cs = new CoordinateSystem(origin, mainDir, xDir);
-            expect(cs.origin.equals(origin)).toBe(true);
-            expect(cs.mainDirection.equals(mainDir)).toBe(true);
-            expect(cs.xDirection.equals(xDir)).toBe(true);
-        });
-        it("computes yDirection automatically", () => {
-            const cs = CoordinateSystem.World();
-            expect(cs.yDirection.x).toBeCloseTo(0);
-            expect(cs.yDirection.y).toBeCloseTo(1);
-            expect(cs.yDirection.z).toBeCloseTo(0);
-        });
-    });
-    describe("World", () => {
-        it("returns world coordinate system", () => {
-            const world = CoordinateSystem.World();
-            expect(world.origin.equals(Point.origin())).toBe(true);
-            expect(world.mainDirection.equals(Vector3d.unitZ())).toBe(true);
-            expect(world.xDirection.equals(Vector3d.unitX())).toBe(true);
-        });
-        it("returns same instance", () => {
-            const w1 = CoordinateSystem.World();
-            const w2 = CoordinateSystem.World();
-            expect(w1).toBe(w2);
-        });
-    });
-    describe("axes", () => {
-        it("xAxis returns axis along X direction", () => {
-            const cs = CoordinateSystem.World();
-            const axis = cs.xAxis;
-            expect(axis.origin.equals(cs.origin)).toBe(true);
-            expect(axis.direction.equals(cs.xDirection)).toBe(true);
-        });
-        it("yAxis returns axis along Y direction", () => {
-            const cs = CoordinateSystem.World();
-            const axis = cs.yAxis;
-            expect(axis.direction.equals(cs.yDirection)).toBe(true);
-        });
-        it("mainAxis returns axis along main direction", () => {
-            const cs = CoordinateSystem.World();
-            const axis = cs.mainAxis;
-            expect(axis.direction.equals(cs.mainDirection)).toBe(true);
-        });
-        it("zAxis is same as mainAxis", () => {
-            const cs = CoordinateSystem.World();
-            expect(cs.zAxis.direction.equals(cs.mainAxis.direction)).toBe(true);
-        });
-    });
-    describe("angle", () => {
-        it("returns 0 for same orientation", () => {
-            const cs1 = CoordinateSystem.World();
-            const cs2 = new CoordinateSystem(new Point(5, 5, 5), Vector3d.unitZ(), Vector3d.unitX());
-            expect(cs1.angle(cs2)).toBeCloseTo(0);
-        });
-        it("returns PI/2 for perpendicular", () => {
-            const cs1 = CoordinateSystem.World();
-            const cs2 = new CoordinateSystem(Point.origin(), Vector3d.unitX(), Vector3d.unitY());
-            expect(cs1.angle(cs2)).toBeCloseTo(Math.PI / 2);
-        });
-    });
-    describe("isCoplanar", () => {
-        it("returns true for coplanar systems", () => {
-            const cs1 = CoordinateSystem.World();
-            const cs2 = new CoordinateSystem(new Point(5, 5, 0), Vector3d.unitZ(), Vector3d.unitX());
-            expect(cs1.isCoplanar(cs2)).toBe(true);
-        });
-        it("returns false for non-coplanar systems", () => {
-            const cs1 = CoordinateSystem.World();
-            const cs2 = new CoordinateSystem(new Point(0, 0, 10), Vector3d.unitZ(), Vector3d.unitX());
-            expect(cs1.isCoplanar(cs2)).toBe(false);
-        });
-        it("returns false for different orientations", () => {
-            const cs1 = CoordinateSystem.World();
-            const cs2 = new CoordinateSystem(Point.origin(), Vector3d.unitX(), Vector3d.unitY());
-            expect(cs1.isCoplanar(cs2)).toBe(false);
-        });
-    });
-    describe("translate", () => {
-        it("translates origin, keeps orientation", () => {
-            const cs = CoordinateSystem.World();
-            const translated = cs.translate(1, 2, 3);
-            expect(translated.origin.x).toBe(1);
-            expect(translated.origin.y).toBe(2);
-            expect(translated.origin.z).toBe(3);
-            expect(translated.mainDirection.equals(cs.mainDirection)).toBe(true);
-        });
-    });
-    describe("translateVector", () => {
-        it("translates by vector", () => {
-            const cs = CoordinateSystem.World();
-            const translated = cs.translateVector(new Vector3d(5, 10, 15));
-            expect(translated.origin.x).toBe(5);
-            expect(translated.origin.y).toBe(10);
-            expect(translated.origin.z).toBe(15);
-        });
-    });
-    describe("rotate", () => {
-        it("rotates around axis", () => {
-            const cs = CoordinateSystem.World();
-            const rotated = cs.rotate(Axis.Z(), Math.PI / 2);
-            expect(rotated.xDirection.x).toBeCloseTo(0);
-            expect(rotated.xDirection.y).toBeCloseTo(1);
-        });
-    });
-    describe("scale", () => {
-        it("scales origin distance from point", () => {
-            const cs = new CoordinateSystem(new Point(2, 0, 0), Vector3d.unitZ(), Vector3d.unitX());
-            const scaled = cs.scale(Point.origin(), 2);
-            expect(scaled.origin.x).toBeCloseTo(4);
-            // Direction should not change
-            expect(scaled.mainDirection.equals(cs.mainDirection)).toBe(true);
-        });
-    });
-    describe("mirror methods", () => {
-        it("mirrorAroundPoint mirrors through point", () => {
-            const cs = new CoordinateSystem(new Point(2, 0, 0), Vector3d.unitZ(), Vector3d.unitX());
-            const mirrored = cs.mirrorAroundPoint(Point.origin());
-            expect(mirrored.origin.x).toBeCloseTo(-2);
-        });
-        it("mirrorAroundAxis mirrors through axis", () => {
-            const cs = new CoordinateSystem(new Point(2, 0, 0), Vector3d.unitZ(), Vector3d.unitX());
-            const mirrored = cs.mirrorAroundAxis(Axis.Z());
-            expect(mirrored.origin.x).toBeCloseTo(-2);
-        });
-        it("mirrorAroundPlane mirrors through plane", () => {
-            const cs = new CoordinateSystem(new Point(0, 0, 5), Vector3d.unitZ(), Vector3d.unitX());
-            const mirrored = cs.mirrorAroundPlane(Vector3d.unitZ(), Point.origin());
-            expect(mirrored.origin.z).toBeCloseTo(-5);
-        });
-    });
-    describe("getXYPlane", () => {
-        it("returns XY plane of coordinate system", () => {
-            const cs = CoordinateSystem.World();
-            const plane = cs.getXYPlane();
-            expect(plane.origin.equals(cs.origin)).toBe(true);
-            expect(plane.normal.equals(cs.mainDirection)).toBe(true);
-        });
-    });
-    describe("getXZPlane", () => {
-        it("returns XZ plane of coordinate system", () => {
-            const cs = CoordinateSystem.World();
-            const plane = cs.getXZPlane();
-            expect(plane.origin.equals(cs.origin)).toBe(true);
-            expect(plane.xDirection.equals(cs.xDirection)).toBe(true);
-        });
-    });
-    describe("getYZPlane", () => {
-        it("returns YZ plane of coordinate system", () => {
-            const cs = CoordinateSystem.World();
-            const plane = cs.getYZPlane();
-            expect(plane.origin.equals(cs.origin)).toBe(true);
-            expect(plane.xDirection.equals(cs.yDirection)).toBe(true);
-        });
-    });
-    describe("worldToLocal", () => {
-        it("converts world point to local coordinates", () => {
-            const cs = CoordinateSystem.World();
-            const world = new Point(3, 4, 5);
-            const local = cs.worldToLocal(world);
-            expect(local.x).toBeCloseTo(3);
-            expect(local.y).toBeCloseTo(4);
-            expect(local.z).toBeCloseTo(5);
-        });
-        it("handles offset origin", () => {
-            const cs = new CoordinateSystem(new Point(10, 20, 30), Vector3d.unitZ(), Vector3d.unitX());
-            const world = new Point(15, 25, 35);
-            const local = cs.worldToLocal(world);
-            expect(local.x).toBeCloseTo(5);
-            expect(local.y).toBeCloseTo(5);
-            expect(local.z).toBeCloseTo(5);
-        });
-    });
-    describe("localToWorld", () => {
-        it("converts local coordinates to world point", () => {
-            const cs = CoordinateSystem.World();
-            const local = new Point(3, 4, 5);
-            const world = cs.localToWorld(local);
-            expect(world.x).toBeCloseTo(3);
-            expect(world.y).toBeCloseTo(4);
-            expect(world.z).toBeCloseTo(5);
-        });
-        it("handles offset origin", () => {
-            const cs = new CoordinateSystem(new Point(10, 20, 30), Vector3d.unitZ(), Vector3d.unitX());
-            const local = new Point(5, 5, 5);
-            const world = cs.localToWorld(local);
-            expect(world.x).toBeCloseTo(15);
-            expect(world.y).toBeCloseTo(25);
-            expect(world.z).toBeCloseTo(35);
-        });
-    });
-    describe("worldToLocal and localToWorld roundtrip", () => {
-        it("roundtrip returns original point", () => {
-            const cs = new CoordinateSystem(new Point(10, 20, 30), new Vector3d(0, 0, 1), new Vector3d(1, 0, 0));
-            const original = new Point(50, 60, 70);
-            const local = cs.worldToLocal(original);
-            const back = cs.localToWorld(local);
-            expect(back.x).toBeCloseTo(original.x);
-            expect(back.y).toBeCloseTo(original.y);
-            expect(back.z).toBeCloseTo(original.z);
-        });
-        it("roundtrip works with rotated system", () => {
-            const cs = new CoordinateSystem(Point.origin(), new Vector3d(1, 0, 0), new Vector3d(0, 1, 0));
-            const local = new Point(3, 4, 5);
-            const world = cs.localToWorld(local);
-            const backToLocal = cs.worldToLocal(world);
-            expect(backToLocal.x).toBeCloseTo(local.x);
-            expect(backToLocal.y).toBeCloseTo(local.y);
-            expect(backToLocal.z).toBeCloseTo(local.z);
-        });
-    });
-    describe("worldToLocalVector", () => {
-        it("converts world vector to local coordinates", () => {
-            const cs = CoordinateSystem.World();
-            const world = new Vector3d(1, 0, 0);
-            const local = cs.worldToLocalVector(world);
-            expect(local.x).toBeCloseTo(1);
-            expect(local.y).toBeCloseTo(0);
-            expect(local.z).toBeCloseTo(0);
-        });
-    });
-    describe("localToWorldVector", () => {
-        it("converts local vector to world coordinates", () => {
-            const cs = CoordinateSystem.World();
-            const local = new Vector3d(1, 0, 0);
-            const world = cs.localToWorldVector(local);
-            expect(world.x).toBeCloseTo(1);
-            expect(world.y).toBeCloseTo(0);
-            expect(world.z).toBeCloseTo(0);
-        });
-    });
-    describe("getBasisMatrix", () => {
-        it("returns basis transformation matrix", () => {
-            const cs = CoordinateSystem.World();
-            const matrix = cs.getBasisMatrix();
-            const p = matrix.transformPoint(new Point(1, 0, 0));
-            expect(p.x).toBeCloseTo(1);
-            expect(p.y).toBeCloseTo(0);
-            expect(p.z).toBeCloseTo(0);
-        });
-    });
-    describe("getInverseBasisMatrix", () => {
-        it("returns inverse basis matrix", () => {
-            const cs = CoordinateSystem.World();
-            const matrix = cs.getBasisMatrix();
-            const inverse = cs.getInverseBasisMatrix();
-            const result = matrix.multiply(inverse);
-            // Should be identity
-            expect(result.get(0, 0)).toBeCloseTo(1);
-            expect(result.get(1, 1)).toBeCloseTo(1);
-            expect(result.get(2, 2)).toBeCloseTo(1);
-        });
-    });
-    describe("equals", () => {
-        it("returns true for identical systems", () => {
-            const cs1 = CoordinateSystem.World();
-            const cs2 = new CoordinateSystem(Point.origin(), Vector3d.unitZ(), Vector3d.unitX());
-            expect(cs1.equals(cs2)).toBe(true);
-        });
-        it("returns false for different systems", () => {
-            const cs1 = CoordinateSystem.World();
-            const cs2 = new CoordinateSystem(new Point(1, 0, 0), Vector3d.unitZ(), Vector3d.unitX());
-            expect(cs1.equals(cs2)).toBe(false);
-        });
-        it("supports tolerance", () => {
-            const cs1 = CoordinateSystem.World();
-            const cs2 = new CoordinateSystem(new Point(0.001, 0, 0), Vector3d.unitZ(), Vector3d.unitX());
-            expect(cs1.equals(cs2, 0.01)).toBe(true);
-        });
-    });
-    describe("fromPlane", () => {
-        it("creates coordinate system from plane", () => {
-            const plane = Plane.XY();
-            const cs = CoordinateSystem.fromPlane(plane);
-            expect(cs.origin.equals(plane.origin)).toBe(true);
-            expect(cs.mainDirection.equals(plane.normal)).toBe(true);
-            expect(cs.xDirection.equals(plane.xDirection)).toBe(true);
-        });
-        it("creates from plane string", () => {
-            const cs = CoordinateSystem.fromPlane("xy");
-            expect(cs.mainDirection.z).toBeCloseTo(1);
-        });
-    });
-    describe("fromTwoAxes", () => {
-        it("creates coordinate system from two axes", () => {
-            const cs = CoordinateSystem.fromTwoAxes(Point.origin(), Vector3d.unitZ(), Vector3d.unitX());
-            expect(cs.mainDirection.z).toBeCloseTo(1);
-        });
-    });
-    describe("clone", () => {
-        it("creates independent copy", () => {
-            const cs = CoordinateSystem.World();
-            const clone = cs.clone();
-            expect(clone.equals(cs)).toBe(true);
-            expect(clone).not.toBe(cs);
-        });
-    });
-});

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

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