@metamesh/modeling 0.11.0 → 0.13.0

package/dist/geometry/regions.js

@@ -28,7 +28,7 @@ const coordinateScale = (loop) => {
     return Math.max(maxX - minX, maxY - minY);
 };
 /** Returns the signed area of a non-duplicated loop; positive means CCW. */
-export function signedAreaLoop2(loop) {
+export function signedContourArea(loop) {
     if (loop.length === 0)
         return 0;
     const origin = loop[0];
@@ -48,7 +48,7 @@ export function signedAreaLoop2(loop) {
     return (twiceArea + correction) / 2;
 }
 /** Returns true when a point lies inside or on the boundary of a loop. */
-export function loopContainsPoint(loop, point) {
+export function contourContainsPoint(loop, point) {
     let inside = false;
     for (let index = 0, previous = loop.length - 1; index < loop.length; previous = index++) {
         const a = loop[index];
@@ -128,7 +128,7 @@ const boundedSegments = (loop, epsilon) => loop.map((a, index) => {
 const consumeIntersectionCandidate = (budget) => {
     budget.candidates += 1;
     if (budget.candidates > MAX_INTERSECTION_CANDIDATES) {
-        throw new GeometryError("COMPLEXITY_LIMIT", "Region validation exceeds the 2000000 intersection-candidate work limit.", { operation: "normalizeRegion2", details: { maximumCandidates: MAX_INTERSECTION_CANDIDATES } });
+        throw new GeometryError("COMPLEXITY_LIMIT", "Region validation exceeds the 2000000 intersection-candidate work limit.", { operation: "normalizeRegion", details: { maximumCandidates: MAX_INTERSECTION_CANDIDATES } });
     }
 };
 const boundedIntersections = (segments, epsilon, budget, sameLoop) => {
@@ -170,7 +170,7 @@ const loopsIntersect = (a, b, epsilon, budget) => a === b ||
  * result must be simple and have non-zero area. Previously validated immutable results may be
  * returned unchanged when their winding and tolerance policy match.
  */
-export function normalizeLoop2(input, counterClockwise, tolerance = {}) {
+export function normalizeContour(input, counterClockwise, tolerance = {}) {
     return normalizeLoopWithBudget(input, counterClockwise, tolerance, { candidates: 0 });
 }
 const normalizeLoopWithBudget = (input, counterClockwise, tolerance, budget) => {
@@ -199,7 +199,7 @@ const normalizeLoopWithBudget = (input, counterClockwise, tolerance, budget) =>
     if (boundedIntersections(boundedSegments(cleaned, resolved.linear), resolved.linear, budget, true)) {
         throw new GeometryError("SELF_INTERSECTION", "A loop must not self-intersect.");
     }
-    const area = signedAreaLoop2(cleaned);
+    const area = signedContourArea(cleaned);
     if (!Number.isFinite(area)) {
         throw new GeometryError("NON_FINITE_VALUE", "Loop area must be finite.");
     }
@@ -223,7 +223,7 @@ const normalizeLoopWithBudget = (input, counterClockwise, tolerance, budget) =>
  * within its exterior and boundaries may not intersect. Previously validated immutable results
  * may be returned unchanged under the same tolerance policy.
  */
-export function normalizePolygon2(polygon, tolerance = {}) {
+export function normalizePolygon(polygon, tolerance = {}) {
     return normalizePolygonWithBudget(polygon, tolerance, { candidates: 0 });
 }
 const normalizePolygonWithBudget = (polygon, tolerance, budget) => {
@@ -236,7 +236,7 @@ const normalizePolygonWithBudget = (polygon, tolerance, budget) => {
     const epsilon = resolveGeometryTolerance(scale, policy).linear;
     for (let index = 0; index < holes.length; index += 1) {
         const hole = holes[index];
-        if (!loopContainsPoint(outer, hole[0]) || loopsIntersect(outer, hole, epsilon, budget)) {
+        if (!contourContainsPoint(outer, hole[0]) || loopsIntersect(outer, hole, epsilon, budget)) {
             throw new GeometryError("INVALID_TOPOLOGY", "Every hole must lie inside its exterior.");
         }
     }
@@ -254,8 +254,8 @@ const normalizePolygonWithBudget = (polygon, tolerance, budget) => {
             if (!boundsOverlap(previous, current, 2 * epsilon))
                 continue;
             if (loopsIntersect(previous.loop, current.loop, epsilon, budget) ||
-                loopContainsPoint(previous.loop, current.loop[0]) ||
-                loopContainsPoint(current.loop, previous.loop[0])) {
+                contourContainsPoint(previous.loop, current.loop[0]) ||
+                contourContainsPoint(current.loop, previous.loop[0])) {
                 throw new GeometryError("INVALID_TOPOLOGY", "Polygon holes must be disjoint.");
             }
         }
@@ -273,7 +273,7 @@ const normalizePolygonWithBudget = (polygon, tolerance, budget) => {
  * Validates a disjoint explicit region and returns immutable normalized data.
  * Previously validated immutable results may be returned unchanged under the same tolerance policy.
  */
-export function normalizeRegion2(region, tolerance = {}) {
+export function normalizeRegion(region, tolerance = {}) {
     const policy = resolveGeometryTolerance(1, tolerance);
     if (samePolicy(normalizedRegions.get(region), policy))
         return region;
@@ -284,8 +284,8 @@ export function normalizeRegion2(region, tolerance = {}) {
     }
     const budget = { candidates: 0 };
     const polygons = region.map((polygon) => normalizePolygonWithBudget(polygon, policy, budget));
-    const containsFilledPoint = (polygon, point) => loopContainsPoint(polygon.outer, point) &&
-        !polygon.holes.some((hole) => loopContainsPoint(hole, point));
+    const containsFilledPoint = (polygon, point) => contourContainsPoint(polygon.outer, point) &&
+        !polygon.holes.some((hole) => contourContainsPoint(hole, point));
     // Broad phase preserves exact contact semantics while avoiding pairwise loop
     // walks for separated polygons (for example many disconnected QR modules).
     const bounded = polygons
@@ -336,7 +336,7 @@ export function normalizeRegion2(region, tolerance = {}) {
  * Returns the total filled area of a normalized region in square millimetres.
  *
  * Each polygon contributes its outer-loop area minus the areas of its holes. An empty region has
- * zero area. Call {@link normalizeRegion2} first when input winding or topology is not already
+ * zero area. Call {@link normalizeRegion} first when input winding or topology is not already
  * canonical.
  *
  * @param region - Normalized disjoint polygons with CCW outers and clockwise holes.
@@ -344,8 +344,8 @@ export function normalizeRegion2(region, tolerance = {}) {
  */
 export function regionArea(region) {
     return region.reduce((total, polygon) => total +
-        Math.abs(signedAreaLoop2(polygon.outer)) -
-        polygon.holes.reduce((holeTotal, hole) => holeTotal + Math.abs(signedAreaLoop2(hole)), 0), 0);
+        Math.abs(signedContourArea(polygon.outer)) -
+        polygon.holes.reduce((holeTotal, hole) => holeTotal + Math.abs(signedContourArea(hole)), 0), 0);
 }
 /** Returns finite axis-aligned bounds for a non-empty region. */
 export function regionBounds(region) {

package/dist/geometry/revolve/revolve-mesh.js

@@ -1,10 +1,10 @@
 import { GeometryError } from "../errors.js";
-import { triangulateLoop2 } from "../loft.js";
-import { validateTriangleMesh } from "../mesh.js";
+import { triangulateContour } from "../loft/loft.js";
+import { validateTriangleMesh } from "../mesh/mesh.js";
 import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../model-limits.js";
 import { writeMeshVertex } from "../numeric.js";
 import { resolveCircularPrimitiveSegments } from "../primitive-resolution.js";
-import { normalizeLoop2 } from "../regions.js";
+import { normalizeContour } from "../regions.js";
 import { assertSamplingCount } from "../sampling-limits.js";
 const AXIS_EPSILON = 1e-10;
 /**
@@ -52,7 +52,7 @@ export const revolveMesh = (profile, options = {}) => {
         }
         maximumRadius = Math.max(maximumRadius, radius);
     }
-    profile = normalizeLoop2(profile, true);
+    profile = normalizeContour(profile, true);
     const circularSegments = resolveCircularPrimitiveSegments(maximumRadius, options, "revolveMesh");
     const closed = degrees === 360;
     const segments = closed
@@ -117,7 +117,7 @@ export const revolveMesh = (profile, options = {}) => {
         }
     }
     if (!closed) {
-        const cap = triangulateLoop2(profile);
+        const cap = triangulateContour(profile);
         const at = (profileIndex, station) => vertexIndices[profileIndex][profile[profileIndex][0] <= AXIS_EPSILON ? 0 : station];
         for (let offset = 0; offset < cap.length; offset += 3) {
             const a = cap[offset], b = cap[offset + 1], c = cap[offset + 2];

package/dist/geometry/stroke-path.js

@@ -1,6 +1,6 @@
 import { GeometryError } from "./errors.js";
 import { unionPolygonGeometry } from "./polygon-clipping.js";
-import { normalizeRegion2 } from "./regions.js";
+import { normalizeRegion } from "./regions.js";
 import { resolveCircularSegments } from "./resolution.js";
 import { assertSamplingCount, resolveGeometrySamplingLimits, } from "./sampling-limits.js";
 import { resolveGeometryTolerance } from "./tolerance.js";
@@ -139,7 +139,7 @@ export function strokePathMultiPolygon(path, options, circularSegments) {
     return result;
 }
 function regionFromMultiPolygon(value) {
-    return normalizeRegion2(value.map((polygon) => ({
+    return normalizeRegion(value.map((polygon) => ({
         outer: polygon[0].slice(0, -1).map(([x, y]) => [x, y]),
         holes: polygon.slice(1).map((hole) => hole.slice(0, -1).map(([x, y]) => [x, y])),
     })));

package/dist/geometry/svg/errors.js

@@ -2,9 +2,6 @@ import { GeometryError } from "../errors.js";
 export function invalid(operation, message) {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation });
 }
-export function unsupported(operation, message) {
-    throw new GeometryError("UNSUPPORTED_RUNTIME", message, { operation });
-}
 export function emptyGeometry(operation, message) {
     throw new GeometryError("DEGENERATE_GEOMETRY", message, { operation });
 }

package/dist/geometry/svg/fill.js

@@ -1,5 +1,5 @@
 import { polygonClipping, unionPolygonGeometry, xorPolygonGeometry } from "../polygon-clipping.js";
-import { normalizeRegion2, signedAreaLoop2 } from "../regions.js";
+import { normalizeRegion, signedContourArea } from "../regions.js";
 import { assertSamplingCount } from "../sampling-limits.js";
 /** Private clipping stage with the selected execution's immutable allocation ceiling. */
 export function createBoundedSvgClipping(maximumVertices) {
@@ -52,12 +52,12 @@ export function createBoundedSvgClipping(maximumVertices) {
             if (outer === undefined)
                 return total;
             return (total +
-                Math.abs(signedAreaLoop2(outer)) -
-                holes.reduce((holeTotal, hole) => holeTotal + Math.abs(signedAreaLoop2(hole)), 0));
+                Math.abs(signedContourArea(outer)) -
+                holes.reduce((holeTotal, hole) => holeTotal + Math.abs(signedContourArea(hole)), 0));
         }, 0);
     }
     function coverageHasMultiplicity(rings, union) {
-        const summedArea = rings.reduce((total, points) => total + Math.abs(signedAreaLoop2(points)), 0);
+        const summedArea = rings.reduce((total, points) => total + Math.abs(signedContourArea(points)), 0);
         const tolerance = Math.max(1, summedArea) * 1e-9;
         return Math.abs(summedArea - multiPolygonArea(union)) > tolerance;
     }
@@ -141,10 +141,10 @@ export function createBoundedSvgClipping(maximumVertices) {
             return boundedXor(polygons.map((polygon) => [polygon]), "even-odd fill output");
         }
         const positive = rings
-            .filter((points) => signedAreaLoop2(points) >= 0)
+            .filter((points) => signedContourArea(points) >= 0)
             .map((points) => [ring(points)]);
         const negative = rings
-            .filter((points) => signedAreaLoop2(points) < 0)
+            .filter((points) => signedContourArea(points) < 0)
             .map((points) => [ring(points)]);
         if (positive.length === 0)
             return boundedUnion([negative], "negative fill output");
@@ -156,7 +156,7 @@ export function createBoundedSvgClipping(maximumVertices) {
         return differingCoverage(positive, negative);
     }
     function regionFromMultiPolygon(value) {
-        return normalizeRegion2(value.map((polygon) => ({
+        return normalizeRegion(value.map((polygon) => ({
             outer: polygon[0].slice(0, -1).map(([x, y]) => [x, y]),
             holes: polygon.slice(1).map((hole) => hole.slice(0, -1).map(([x, y]) => [x, y])),
         })));

package/dist/geometry/svg/index.js

@@ -1 +1 @@
-export { parseSvgDocument, parseSvgPath } from "./parser.js";
+export { parseSvgPath } from "./parser.js";

package/dist/geometry/svg/matrix.js

@@ -1,5 +1,3 @@
-import { invalid } from "./errors.js";
-export const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
 export function multiplyMatrices(left, right) {
     return [
         left[0] * right[0] + left[2] * right[1],
@@ -16,115 +14,3 @@ export function transformPoint(matrix, point) {
         matrix[1] * point[0] + matrix[3] * point[1] + matrix[5],
     ];
 }
-const NUMBER_PATTERN = /[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/g;
-/** Parses compact SVG number sequences while rejecting unconsumed syntax. */
-export function parseNumberSequence(value, operation) {
-    const numbers = [];
-    let end = 0;
-    NUMBER_PATTERN.lastIndex = 0;
-    for (let match = NUMBER_PATTERN.exec(value); match !== null; match = NUMBER_PATTERN.exec(value)) {
-        const separator = value.slice(end, match.index);
-        if (!/^[\s,]*$/.test(separator) ||
-            (separator.match(/,/g)?.length ?? 0) > 1 ||
-            (numbers.length === 0 && separator.includes(","))) {
-            invalid(operation, `Invalid numeric syntax near "${separator}".`);
-        }
-        const parsed = Number(match[0]);
-        if (!Number.isFinite(parsed)) {
-            invalid(operation, "SVG numeric values must be finite.");
-        }
-        numbers.push(parsed);
-        end = match.index + match[0].length;
-    }
-    if (!/^\s*$/.test(value.slice(end))) {
-        invalid(operation, "Invalid trailing numeric syntax.");
-    }
-    if (numbers.length === 0 && value.trim() !== "") {
-        invalid(operation, `Expected a numeric value, received "${value}".`);
-    }
-    return numbers;
-}
-function transformFor(name, values, operation) {
-    switch (name) {
-        case "matrix":
-            if (values.length !== 6)
-                invalid(operation, "matrix() requires six numbers.");
-            return values;
-        case "translate":
-            if (values.length < 1 || values.length > 2) {
-                invalid(operation, "translate() requires one or two numbers.");
-            }
-            return [1, 0, 0, 1, values[0] ?? 0, values[1] ?? 0];
-        case "scale": {
-            if (values.length < 1 || values.length > 2) {
-                invalid(operation, "scale() requires one or two numbers.");
-            }
-            const sx = values[0] ?? 1;
-            return [sx, 0, 0, values[1] ?? sx, 0, 0];
-        }
-        case "rotate": {
-            if (values.length !== 1 && values.length !== 3) {
-                invalid(operation, "rotate() requires an angle, optionally followed by a center.");
-            }
-            const radians = ((values[0] ?? 0) * Math.PI) / 180;
-            const rotation = [
-                Math.cos(radians),
-                Math.sin(radians),
-                -Math.sin(radians),
-                Math.cos(radians),
-                0,
-                0,
-            ];
-            if (values.length === 1)
-                return rotation;
-            const cx = values[1] ?? 0;
-            const cy = values[2] ?? 0;
-            return multiplyMatrices(multiplyMatrices([1, 0, 0, 1, cx, cy], rotation), [
-                1,
-                0,
-                0,
-                1,
-                -cx,
-                -cy,
-            ]);
-        }
-        case "skewX": {
-            if (values.length !== 1)
-                invalid(operation, "skewX() requires one angle.");
-            const tangent = Math.tan(((values[0] ?? 0) * Math.PI) / 180);
-            if (!Number.isFinite(tangent))
-                invalid(operation, "skewX() produced a non-finite matrix.");
-            return [1, 0, tangent, 1, 0, 0];
-        }
-        case "skewY": {
-            if (values.length !== 1)
-                invalid(operation, "skewY() requires one angle.");
-            const tangent = Math.tan(((values[0] ?? 0) * Math.PI) / 180);
-            if (!Number.isFinite(tangent))
-                invalid(operation, "skewY() produced a non-finite matrix.");
-            return [1, tangent, 0, 1, 0, 0];
-        }
-        default:
-            invalid(operation, `Unsupported SVG transform "${name}".`);
-    }
-}
-/** Parses an SVG transform list using standard post-multiplication order. */
-export function parseTransform(value, operation) {
-    if (value === undefined || value.trim() === "")
-        return IDENTITY_MATRIX;
-    const callPattern = /([A-Za-z]+)\s*\(([^()]*)\)/g;
-    let result = IDENTITY_MATRIX;
-    let end = 0;
-    for (let match = callPattern.exec(value); match !== null; match = callPattern.exec(value)) {
-        if (!/^[\s,]*$/.test(value.slice(end, match.index))) {
-            invalid(operation, "Malformed SVG transform list.");
-        }
-        const values = parseNumberSequence(match[2] ?? "", operation);
-        result = multiplyMatrices(result, transformFor(match[1] ?? "", values, operation));
-        end = match.index + match[0].length;
-    }
-    if (end === 0 || !/^\s*$/.test(value.slice(end))) {
-        invalid(operation, "Malformed SVG transform list.");
-    }
-    return result;
-}