@metamesh/modeling 0.16.0 → 0.18.0

package/dist/engine/knuckle-hinge-operation.js

@@ -1,85 +0,0 @@
-import { GeometryError } from "../geometry/errors.js";
-import { resolveKnuckleHinge } from "../geometry/mechanical/knuckle-hinge.js";
-import { assertPrimitiveOptions } from "../geometry/primitive-resolvers.js";
-import { assertSamplingCount } from "../geometry/sampling-limits.js";
-/** Composes existing scoped operations after resolving both halves against one host policy. */
-export function createKnuckleHingeOperation(environment, operations) {
-    return (options) => {
-        environment.assertActive();
-        assertPrimitiveOptions(options, "knuckleHinge");
-        const resolved = environment.withResolutionDefaults(options);
-        const d = resolveKnuckleHinge(options, resolved);
-        assertSamplingCount(d.segments * d.spec.knuckleCount * 2, "knuckleHinge", resolved.limits.maxVertices);
-        const invalid = (message) => {
-            throw new GeometryError("INVALID_ARGUMENT", message, { operation: "knuckleHinge" });
-        };
-        const validateHalf = (half = {}) => {
-            assertPrimitiveOptions(half, "knuckleHinge");
-            const chamfer = half.barrelChamfer ?? 0;
-            if (!Number.isFinite(chamfer) ||
-                chamfer < 0 ||
-                2 * chamfer >= d.knuckleLength ||
-                chamfer >= d.minimumBarrelWall)
-                invalid("barrelChamfer must be nonnegative and leave a positive axial band and faceted barrel wall.");
-            const web = half.web;
-            if (web !== undefined) {
-                assertPrimitiveOptions(web, "knuckleHinge");
-                if (web.direction !== "positive-y" && web.direction !== "negative-y")
-                    invalid("Unknown web direction.");
-                if (!Number.isFinite(web.reach) ||
-                    web.reach <= 0 ||
-                    !Number.isFinite(web.thickness) ||
-                    web.thickness <= 0 ||
-                    !Number.isFinite(web.zMin) ||
-                    !Number.isFinite(web.zMin + web.thickness))
-                    invalid("Web dimensions must be finite, with positive reach and thickness.");
-                const innerRadius = d.barrelRadius * Math.cos(Math.PI / d.segments);
-                if (web.zMin >= innerRadius || web.zMin + web.thickness <= -innerRadius)
-                    invalid("A web must overlap the interior of its barrel.");
-            }
-            return { chamfer, web };
-        };
-        // Validate both attachments before allocating either half.
-        const a = validateHalf(options.halfA);
-        const b = validateHalf(options.halfB);
-        const axial = (radius, start, length, bore = false, chamfer = 0) => operations.translate(operations.rotate(operations.cylinder({
-            radius,
-            height: length,
-            center: false,
-            segments: d.segments,
-            sizing: bore ? "face" : "vertex",
-            ...(chamfer === 0
-                ? {}
-                : {
-                    ends: {
-                        bottom: { kind: "chamfer", distance: chamfer },
-                        top: { kind: "chamfer", distance: chamfer },
-                    },
-                }),
-        }), [0, 90, 0]), [start, 0, 0]);
-        const buildHalf = (side, { chamfer, web }) => {
-            const features = [];
-            for (const interval of d.knuckles) {
-                if (interval.side !== side)
-                    continue;
-                features.push(axial(d.barrelRadius, interval.start, interval.length, false, chamfer));
-                if (web !== undefined)
-                    features.push(operations.translate(operations.box({
-                        size: [interval.length, web.reach, web.thickness],
-                        center: false,
-                    }), [interval.start, web.direction === "positive-y" ? 0 : -web.reach, web.zMin]));
-            }
-            if (side === "a" && d.pin !== null)
-                features.push(axial(d.pinRadius, d.pin.start, d.pin.length));
-            const solid = operations.union(features);
-            // Overtravel is numerical cutter extent, independent of the physical radial/axial allowances.
-            const overtravel = Math.min(d.knuckleLength, d.barrelRadius) * 0.01;
-            return side === "a" && d.pin !== null
-                ? solid
-                : operations.subtract(solid, [
-                    axial(d.boreRadius, -d.spec.length / 2 - overtravel, d.spec.length + 2 * overtravel, true),
-                ]);
-        };
-        return Object.freeze({ halfA: buildHalf("a", a), halfB: buildHalf("b", b), axis: d.axis });
-    };
-}

package/dist/geometry/profiles/profiles.js

@@ -1,91 +0,0 @@
-import { GeometryError } from "../errors.js";
-import { resolveCircularPrimitiveSegments } from "../primitive-resolution.js";
-import { assertPrimitiveOptions } from "../primitive-resolvers.js";
-import { requireFiniteProfileValues, requireProfileVertexCount } from "./validation.js";
-export { rectangleContour } from "./rectangle.js";
-/**
- * Creates an immutable centered CCW circle with +X seam and vertex or face radial sizing.
- *
- * @example Explicit circular point data
- * ```ts
- * circleContour({ diameter: 20, segments: 32 });
- * ```
- */
-export const circleContour = (options) => {
-    const operation = "circleContour";
-    assertPrimitiveOptions(options, operation);
-    if ((options.radius === undefined) === (options.diameter === undefined)) {
-        throw new GeometryError("INVALID_ARGUMENT", "Specify exactly one radius or diameter.", {
-            operation,
-        });
-    }
-    const radius = options.radius ?? options.diameter / 2;
-    requireFiniteProfileValues([radius], operation);
-    if (!(radius > 0)) {
-        throw new GeometryError("INVALID_ARGUMENT", "Circle radius must be positive.", { operation });
-    }
-    const segments = resolveCircularPrimitiveSegments(radius, options, operation);
-    requireProfileVertexCount(segments, 3, operation, options.limits);
-    const sizing = options.sizing ?? "vertex";
-    if (sizing !== "vertex" && sizing !== "face") {
-        throw new GeometryError("INVALID_ARGUMENT", "Circle sizing must be vertex or face.", {
-            operation,
-        });
-    }
-    const sampledRadius = sizing === "face" ? radius / Math.cos(Math.PI / segments) : radius;
-    requireFiniteProfileValues([sampledRadius], operation);
-    return Object.freeze(Array.from({ length: segments }, (_, index) => {
-        const angle = (Math.PI * 2 * index) / segments;
-        return Object.freeze([sampledRadius * Math.cos(angle), sampledRadius * Math.sin(angle)]);
-    }));
-};
-/**
- * Creates a centered CCW point loop with vertex or face radial sizing and an implicit seam.
- *
- * @example Hexagon sized to its faces
- * ```ts
- * regularPolygonContour({ radius: 10, sides: 6, sizing: "face" });
- * ```
- */
-export const regularPolygonContour = (options) => {
-    const operation = "regularPolygonContour";
-    const { radius, sides, rotation = 0, sizing = "vertex" } = options;
-    requireFiniteProfileValues([radius, rotation], operation);
-    if (!(radius > 0)) {
-        throw new GeometryError("INVALID_ARGUMENT", "Polygon radius must be positive.", { operation });
-    }
-    requireProfileVertexCount(sides, 3, operation, options.limits);
-    if (sizing !== "vertex" && sizing !== "face")
-        throw new GeometryError("INVALID_ARGUMENT", "Polygon sizing must be vertex or face.", {
-            operation,
-        });
-    const sampledRadius = sizing === "face" ? radius / Math.cos(Math.PI / sides) : radius;
-    requireFiniteProfileValues([sampledRadius], operation);
-    const rotationRadians = ((rotation % 360) * Math.PI) / 180;
-    return Array.from({ length: sides }, (_, index) => {
-        const angle = rotationRadians + (Math.PI * 2 * index) / sides;
-        return [sampledRadius * Math.cos(angle), sampledRadius * Math.sin(angle)];
-    });
-};
-/**
- * Creates a centered CCW alternating-radius star within the selected profile sampling ceiling.
- *
- * @example Five-point outline
- * ```ts
- * starContour(12, 5, 6);
- * ```
- */
-export const starContour = (outerRadius, points, innerRadius = outerRadius / 2, limits = {}) => {
-    const operation = "starContour";
-    requireFiniteProfileValues([outerRadius, innerRadius], operation);
-    if (!(outerRadius > 0) || !(innerRadius > 0) || innerRadius >= outerRadius) {
-        throw new GeometryError("INVALID_ARGUMENT", "Star radii must be positive, with the inner radius smaller than the outer.", { operation });
-    }
-    requireProfileVertexCount(points, 3, operation, limits);
-    requireProfileVertexCount(points * 2, 6, operation, limits);
-    return Array.from({ length: points * 2 }, (_, index) => {
-        const radius = index % 2 === 0 ? outerRadius : innerRadius;
-        const angle = (Math.PI * index) / points;
-        return [radius * Math.cos(angle), radius * Math.sin(angle)];
-    });
-};