@metamesh/modeling 0.12.0 → 0.14.0

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";
@@ -23,10 +23,7 @@ function ellipsePoints(center, radius, segments) {
         return [center[0] + Math.cos(angle) * radius, center[1] + Math.sin(angle) * radius];
     });
 }
-function circlePolygon(center, radius, segments) {
-    return [ring(ellipsePoints(center, radius, segments))];
-}
-function cornerPolygon(previous, point, next, halfWidth, join) {
+function cornerContour(previous, point, next, halfWidth, join) {
     const incomingLength = Math.hypot(point[0] - previous[0], point[1] - previous[1]);
     const outgoingLength = Math.hypot(next[0] - point[0], next[1] - point[1]);
     const incoming = [
@@ -54,11 +51,13 @@ function cornerPolygon(previous, point, next, halfWidth, join) {
         ]);
     }
     points.push([point[0] + after[0], point[1] + after[1]]);
-    return [ring(points)];
+    return turn > 0 ? points : points.reverse();
 }
 /** Removes consecutive points that cannot define a visible stroke segment at model scale. */
 function deduplicatePath(path, closed, width) {
-    const scale = Math.max(width, ...path.flatMap(([x, y]) => [Math.abs(x), Math.abs(y)]));
+    let scale = width;
+    for (const [x, y] of path)
+        scale = Math.max(scale, Math.abs(x), Math.abs(y));
     const tolerance = resolveGeometryTolerance(scale).linear;
     const points = [];
     for (const point of path) {
@@ -76,11 +75,27 @@ function deduplicatePath(path, closed, width) {
     }
     return Object.freeze(points);
 }
-/** @internal Polygon-clipping representation shared with the bounded SVG importer. */
-export function strokePathMultiPolygon(path, options, circularSegments) {
+/** @internal Bounded CCW stroke primitives shared by native sections and pure clipping. */
+export function strokePathContours(path, options, exactCircularSegments) {
     const closed = options.closed ?? false;
     const cap = options.cap ?? "butt";
     const join = options.join ?? "miter";
+    if (typeof closed !== "boolean")
+        return fail("closed must be a boolean.");
+    if (!Number.isFinite(options.width) || options.width <= 0)
+        return fail("Stroke width must be finite and greater than zero.");
+    if (path.length < (closed ? 3 : 2))
+        return fail(`${closed ? "Closed" : "Open"} strokes need more sampled path points.`);
+    if (!path.every((point) => point.length === 2 && point.every(Number.isFinite)))
+        return fail("Stroke path coordinates must be finite XY points.");
+    if (!["butt", "round", "square"].includes(cap))
+        return fail("Stroke cap must be butt, round, or square.");
+    if (!["bevel", "miter", "round"].includes(join))
+        return fail("Stroke join must be bevel, miter, or round.");
+    const circularSegments = exactCircularSegments ??
+        (cap === "round" || join === "round"
+            ? resolveCircularSegments(options.width / 2, options.resolution, options.limits)
+            : 3);
     const half = options.width / 2;
     const limits = resolveGeometrySamplingLimits(options.limits);
     assertSamplingCount(path.length, "strokePathRegion", limits.maxPathPoints);
@@ -88,7 +103,7 @@ export function strokePathMultiPolygon(path, options, circularSegments) {
     const normalizedPath = deduplicatePath(path, closed, options.width);
     if (normalizedPath.length < (closed ? 3 : 2))
         return [];
-    const polygons = [];
+    const contours = [];
     const segmentCount = closed ? normalizedPath.length : normalizedPath.length - 1;
     const joinCount = closed ? normalizedPath.length : Math.max(0, normalizedPath.length - 2);
     const constructionVertices = segmentCount * 4 +
@@ -108,38 +123,48 @@ export function strokePathMultiPolygon(path, options, circularSegments) {
             }
         }
         const normal = [-tangent[1] * half, tangent[0] * half];
-        polygons.push([
-            ring([
-                [start[0] + normal[0], start[1] + normal[1]],
-                [end[0] + normal[0], end[1] + normal[1]],
-                [end[0] - normal[0], end[1] - normal[1]],
-                [start[0] - normal[0], start[1] - normal[1]],
-            ]),
+        contours.push([
+            [start[0] - normal[0], start[1] - normal[1]],
+            [end[0] - normal[0], end[1] - normal[1]],
+            [end[0] + normal[0], end[1] + normal[1]],
+            [start[0] + normal[0], start[1] + normal[1]],
         ]);
     }
+    const disk = join === "round" || (!closed && cap === "round")
+        ? ellipsePoints([0, 0], half, circularSegments)
+        : [];
+    const circleAt = ([x, y]) => disk.map(([u, v]) => [x + u, y + v]);
     if (join === "round") {
         const joinPoints = closed ? normalizedPath : normalizedPath.slice(1, -1);
-        polygons.push(...joinPoints.map((point) => circlePolygon(point, half, circularSegments)));
+        for (const point of joinPoints)
+            contours.push(circleAt(point));
     }
     else {
         const first = closed ? 0 : 1;
         const end = closed ? normalizedPath.length : normalizedPath.length - 1;
         for (let index = first; index < end; index += 1) {
-            const corner = cornerPolygon(normalizedPath[(index - 1 + normalizedPath.length) % normalizedPath.length], normalizedPath[index], normalizedPath[(index + 1) % normalizedPath.length], half, join);
+            const corner = cornerContour(normalizedPath[(index - 1 + normalizedPath.length) % normalizedPath.length], normalizedPath[index], normalizedPath[(index + 1) % normalizedPath.length], half, join);
             if (corner !== undefined)
-                polygons.push(corner);
+                contours.push(corner);
         }
     }
     if (!closed && cap === "round") {
-        polygons.push(circlePolygon(normalizedPath[0], half, circularSegments), circlePolygon(normalizedPath.at(-1), half, circularSegments));
+        contours.push(circleAt(normalizedPath[0]), circleAt(normalizedPath.at(-1)));
     }
-    const result = unionPolygonGeometry(polygons);
+    return contours;
+}
+/** @internal Polygon-clipping representation shared with the bounded SVG importer. */
+export function strokePathMultiPolygon(path, options, circularSegments) {
+    const contours = strokePathContours(path, options, circularSegments);
+    if (contours.length === 0)
+        return [];
+    const result = unionPolygonGeometry(contours.map((contour) => [ring(contour)]));
     const outputVertices = result.reduce((count, polygon) => count + polygon.reduce((total, contour) => total + Math.max(0, contour.length - 1), 0), 0);
-    assertSamplingCount(outputVertices, "strokePathRegion", limits.maxProfilePoints);
+    assertSamplingCount(outputVertices, "strokePathRegion", resolveGeometrySamplingLimits(options.limits).maxProfilePoints);
     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])),
     })));
@@ -153,28 +178,7 @@ function regionFromMultiPolygon(value) {
  * intersection, falling back to bevels above SVG's default miter limit of 4.
  */
 export function strokePathRegion(path, options) {
-    const closed = options.closed ?? false;
-    if (!Number.isFinite(options.width) || options.width <= 0) {
-        return fail("Stroke width must be finite and greater than zero.");
-    }
-    if (path.length < (closed ? 3 : 2)) {
-        return fail(`${closed ? "Closed" : "Open"} strokes need more sampled path points.`);
-    }
-    if (!path.every((point) => Number.isFinite(point[0]) && Number.isFinite(point[1]))) {
-        return fail("Stroke path coordinates must be finite.");
-    }
-    const cap = options.cap ?? "butt";
-    const join = options.join ?? "miter";
-    if (!["butt", "round", "square"].includes(cap)) {
-        return fail("Stroke cap must be butt, round, or square.");
-    }
-    if (!["bevel", "miter", "round"].includes(join)) {
-        return fail("Stroke join must be bevel, miter, or round.");
-    }
-    const circularSegments = cap === "round" || join === "round"
-        ? resolveCircularSegments(options.width / 2, options.resolution, options.limits)
-        : 3;
-    const result = strokePathMultiPolygon(path, { ...options, cap, closed, join }, circularSegments);
+    const result = strokePathMultiPolygon(path, options);
     if (result.length === 0)
         return fail("The sampled stroke path has no visible length.");
     return regionFromMultiPolygon(result);

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;
-}