@metamesh/modeling 0.8.0 → 0.9.0

package/dist/geometry/index.js

@@ -28,6 +28,7 @@ export { cumulativePathLengths, pathLength } from "./paths/path.js";
 export { distributeAlongPath, roundClosedPolylinePath, } from "./paths/planar.js";
 export { circleLoop, rectangleLoop, regularPolygonLoop, starLoop, } from "./profiles/profiles.js";
 export { sampleOpenProfile, } from "./profiles/open-profile.js";
+export { sampleCrossSection, } from "./profiles/cross-section.js";
 export { ellipseLoop } from "./profiles/shapes.js";
 export { rectangleProfile, } from "./profiles/rectangle.js";
 export { loopContainsPoint, normalizeLoop2, normalizePolygon2, normalizeRegion2, regionArea, regionBounds, signedAreaLoop2, } from "./regions.js";

package/dist/geometry/profiles/cross-section.js

@@ -0,0 +1,102 @@
+import { sampleCurve2 } from "../curves/sampling.js";
+import { GeometryError } from "../errors.js";
+import { normalizeLoop2 } from "../regions.js";
+import { resolveGeometrySamplingLimits } from "../sampling-limits.js";
+import { requireProfileVertexCount } from "./validation.js";
+const OPERATION = "sampleCrossSection";
+function invalid(message) {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation: OPERATION });
+}
+/**
+ * Samples 2–32 connected line/cubic segments into a simple, nonzero-area, immutable CCW XY loop.
+ * Physical scaling precedes adaptive curve sampling; the final end must repeat start exactly.
+ * Shared anchors and the closing seam are emitted once. Winding normalization may change the
+ * starting vertex. The sampled loop is checked for self-intersection and degeneracy by
+ * `normalizeLoop2`; this is a single contour without holes. No editor modes or normalized
+ * coordinate range are required. No native engine, SDK, or ambient resolution is used.
+ *
+ * @param curve - Closed contour in millimetres unless positive scales convert its coordinates.
+ * @param options - Physical resolution and unique vertex budget; defaults to 4096 vertices.
+ * @returns Frozen counterclockwise loop in millimetres, without a repeated seam endpoint.
+ * @throws {@link GeometryError} for invalid data, topology, scale, or exceeded sampling budgets.
+ *
+ * @example
+ * ```ts
+ * const section = sampleCrossSection({
+ *   start: { x: 0, y: 0 },
+ *   segments: [
+ *     { type: "line", end: { x: 1, y: 0 } },
+ *     { type: "line", end: { x: 0.5, y: 1 } },
+ *     { type: "line", end: { x: 0, y: 0 } },
+ *   ],
+ * }, { widthScale: 20, heightScale: 12 });
+ * ```
+ */
+export function sampleCrossSection(curve, options = {}) {
+    const widthScale = options.widthScale ?? 1;
+    const heightScale = options.heightScale ?? 1;
+    if (![widthScale, heightScale].every((scale) => Number.isFinite(scale) && scale > 0))
+        invalid("Cross-section scales must be finite and positive.");
+    const limits = resolveGeometrySamplingLimits(options.limits);
+    const maximumVertices = options.maximumVertices ?? Math.min(4096, limits.maxProfilePoints);
+    requireProfileVertexCount(maximumVertices, 3, OPERATION, limits);
+    const segmentInput = curve?.segments;
+    if (!curve ||
+        !Array.isArray(segmentInput) ||
+        curve.segments.length < 2 ||
+        curve.segments.length > 32)
+        invalid("A cross section must contain 2–32 segments.");
+    const physical = (point) => {
+        if (!point || !Number.isFinite(point.x) || !Number.isFinite(point.y))
+            invalid("Cross-section coordinates must be finite.");
+        const result = [point.x * widthScale, point.y * heightScale];
+        if (!result.every(Number.isFinite))
+            invalid("Scaled cross-section coordinates must be finite.");
+        return result;
+    };
+    const first = physical(curve.start);
+    const final = curve.segments.at(-1)?.end;
+    if (!final || final.x !== curve.start.x || final.y !== curve.start.y)
+        invalid("The final cross-section endpoint must match the start exactly.");
+    const output = [first];
+    let start = first;
+    for (let index = 0; index < curve.segments.length; index++) {
+        const segment = curve.segments[index];
+        if (!segment)
+            invalid("Cross-section segments must be lines or cubics.");
+        const end = physical(segment.end);
+        const closed = index === curve.segments.length - 1;
+        const remainingVertices = Math.min(limits.maxPathPoints, maximumVertices - output.length + 1 + (closed ? 1 : 0));
+        if (remainingVertices < 2)
+            throw new GeometryError("COMPLEXITY_LIMIT", "Cross-section sampling exceeds its vertex budget.", {
+                operation: OPERATION,
+                details: { maximumVertices },
+            });
+        let span;
+        if (segment.type === "line") {
+            span = { kind: "line", start, end };
+        }
+        else if (segment.type === "cubic") {
+            span = {
+                kind: "cubic",
+                start,
+                end,
+                control1: physical(segment.control1),
+                control2: physical(segment.control2),
+            };
+        }
+        else {
+            invalid("Cross-section segments must be lines or cubics.");
+        }
+        const sampled = sampleCurve2(span, {
+            ...(options.resolution === undefined ? {} : { resolution: options.resolution }),
+            maximumVertices: remainingVertices,
+            limits,
+        }).points;
+        const endIndex = sampled.length - (closed ? 1 : 0);
+        for (let pointIndex = 1; pointIndex < endIndex; pointIndex++)
+            output.push(sampled[pointIndex]);
+        start = end;
+    }
+    return normalizeLoop2(output, true);
+}

package/dist/geometry/svg-import.js

@@ -280,7 +280,14 @@ function canvasTransform(values, width, height, box, origin) {
     return [appliedX, 0, 0, -appliedY, offsetX, offsetY];
 }
 function isPainted(color, opacity) {
-    return color !== "none" && color !== "transparent" && opacity > 0;
+    // Mirrored by the editor's core/document.ts: embedded CSS alpha also controls geometry.
+    const normalized = color.trim().toLowerCase();
+    if (normalized === "none" || normalized === "transparent" || !(opacity > 0))
+        return false;
+    if (/^#[0-9a-f]{4}(?:[0-9a-f]{4})?$/u.test(normalized))
+        return Number.parseInt(normalized.slice(normalized.length === 5 ? -1 : -2), 16) > 0;
+    const components = /^(?:rgb|hsl)a?\((.*)\)$/u.exec(normalized)?.[1]?.split(",");
+    return components?.length !== 4 || Number(components[3].trim().replace(/%$/u, "")) > 0;
 }
 function ellipsePoints(cx, cy, rx, ry, segments, budget) {
     if (rx <= 0 || ry <= 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamesh/modeling",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Scoped solid modeling and pure geometry foundations for Node and browsers.",
   "license": "Apache-2.0",
   "repository": {