@weasel-js/core 1.7.0 → 1.7.2

package/dist/features/paths/penPreviewLayer.js

@@ -0,0 +1,220 @@
+import { anchorsToPath as e } from "./anchors.js";
+import { circlePath as t } from "./markers.js";
+import { PATH_C as n, PATH_L as r, PATH_M as i } from "@weasel-js/geom";
+//#region src/features/paths/penPreviewLayer.ts
+var a = {
+	anchorFill: "#d4c4a8",
+	anchorStroke: "#d4c4a8",
+	handleStroke: "#d4c4a8",
+	rubberBandStroke: "#d4c4a8",
+	closeHintFill: "#d4c4a8",
+	finishedSubpathStroke: "#8a7a5e"
+}, o = 4, s = 3, c = 8;
+function l(e, t, n) {
+	return [(e - n.x) * n.scale.x, (t - n.y) * n.scale.y];
+}
+function u(e, n, r) {
+	return t(e, n, r);
+}
+function d(t, n) {
+	if (t.anchors.length === 0) return null;
+	let r = (e) => {
+		let [t, r] = l(e.x, e.y, n);
+		return {
+			x: t,
+			y: r
+		};
+	}, i = t.anchors.map((e) => ({
+		...r(e),
+		...e.inHandle ? { inHandle: r(e.inHandle) } : {},
+		...e.outHandle ? { outHandle: r(e.outHandle) } : {}
+	}));
+	return e([i], [t.closed]);
+}
+function f(e) {
+	let t = {
+		...a,
+		...e.style ?? {}
+	}, f = () => e.penTool.initScratch();
+	return {
+		id: "penPreview",
+		label: "Pen preview",
+		space: "screen",
+		draw: (e, a) => {
+			let p = f(), m = [];
+			for (let e of p.finishedSubpaths) {
+				let n = d(e, a);
+				n !== null && m.push({
+					kind: "path",
+					path: n,
+					stroke: {
+						paint: {
+							fill: "solid",
+							color: t.finishedSubpathStroke
+						},
+						width: 1
+					}
+				});
+			}
+			let h = p.current;
+			if (!h && p.cursor === null) return m;
+			if (h) {
+				let e = d(h, a);
+				e !== null && m.push({
+					kind: "path",
+					path: e,
+					stroke: {
+						paint: {
+							fill: "solid",
+							color: t.rubberBandStroke
+						},
+						width: 1
+					}
+				});
+			}
+			if (h && h.anchors.length > 0 && p.cursor && p.draggingHandleAt === null) {
+				let e = h.anchors[h.anchors.length - 1], o = e.outHandle, [s, c] = l(e.x, e.y, a), [u, d] = l(p.cursor.x, p.cursor.y, a), f;
+				if (o) {
+					let [e, t] = l(o.x, o.y, a);
+					f = {
+						kind: "polygon",
+						commands: new Uint8Array([i, n]),
+						coords: new Float32Array([
+							s,
+							c,
+							e,
+							t,
+							u,
+							d,
+							u,
+							d
+						]),
+						fillRule: "nonzero"
+					};
+				} else f = {
+					kind: "polygon",
+					commands: new Uint8Array([i, r]),
+					coords: new Float32Array([
+						s,
+						c,
+						u,
+						d
+					]),
+					fillRule: "nonzero"
+				};
+				m.push({
+					kind: "path",
+					path: f,
+					stroke: {
+						paint: {
+							fill: "solid",
+							color: t.rubberBandStroke
+						},
+						width: 1
+					}
+				});
+			}
+			if (h) {
+				for (let e = 0; e < h.anchors.length; e++) {
+					let n = h.anchors[e], [c, d] = l(n.x, n.y, a);
+					if (m.push({
+						kind: "path",
+						path: u(c, d, o),
+						fill: {
+							fill: "solid",
+							color: t.anchorFill
+						},
+						stroke: {
+							paint: {
+								fill: "solid",
+								color: t.anchorStroke
+							},
+							width: 1
+						}
+					}), e === h.anchors.length - 1 && n.outHandle) {
+						let [e, o] = l(n.outHandle.x, n.outHandle.y, a), f = {
+							kind: "polygon",
+							commands: new Uint8Array([i, r]),
+							coords: new Float32Array([
+								c,
+								d,
+								e,
+								o
+							]),
+							fillRule: "nonzero"
+						};
+						m.push({
+							kind: "path",
+							path: f,
+							stroke: {
+								paint: {
+									fill: "solid",
+									color: t.handleStroke
+								},
+								width: 1
+							}
+						}), m.push({
+							kind: "path",
+							path: u(e, o, s),
+							fill: {
+								fill: "solid",
+								color: t.handleStroke
+							}
+						});
+						let p = n.inHandle;
+						if (p) {
+							let [e, n] = l(p.x, p.y, a), o = {
+								kind: "polygon",
+								commands: new Uint8Array([i, r]),
+								coords: new Float32Array([
+									c,
+									d,
+									e,
+									n
+								]),
+								fillRule: "nonzero"
+							};
+							m.push({
+								kind: "path",
+								path: o,
+								stroke: {
+									paint: {
+										fill: "solid",
+										color: t.handleStroke
+									},
+									width: 1
+								}
+							}), m.push({
+								kind: "path",
+								path: u(e, n, s),
+								fill: {
+									fill: "solid",
+									color: t.handleStroke
+								}
+							});
+						}
+					}
+				}
+				if (p.closeHintActive && h.anchors.length >= 3) {
+					let e = h.anchors[0], [n, r] = l(e.x, e.y, a);
+					m.push({
+						kind: "path",
+						path: u(n, r, c),
+						stroke: {
+							paint: {
+								fill: "solid",
+								color: t.closeHintFill
+							},
+							width: 1.5
+						}
+					});
+				}
+			}
+			return m;
+		}
+	};
+}
+//#endregion
+export { f as createPenPreviewLayer };
+
+//# sourceMappingURL=penPreviewLayer.js.map

package/dist/features/paths/penPreviewLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"penPreviewLayer.js","names":["DEFAULT_STYLE","ANCHOR_RADIUS_PX","HANDLE_DOT_RADIUS_PX","CLOSE_HINT_RADIUS_PX","w2s","wx","view","wy","approximateCircle","circlePath","cx","cy","subpathToPath","sp","pt","x","y","p","anchors","a","anchorsToPath","createPenPreviewLayer","style","opts","getScratch","s","out","path","cur","last","out2","sx","sy","c1x","c1y","PATH_M","PATH_C","PATH_L","i","ax","ay","hx","hy","linePath","inSide","mx","my","inLine","first","fx","fy"],"sources":["../../../src/features/paths/penPreviewLayer.ts"],"sourcesContent":["/**\n * Screen-space preview layer for `usePenTool`. Reads the tool's\n * persistent scratch each frame and renders the in-progress path: finished\n * subpaths (faded), the current subpath (bright + anchor dots + handles),\n * a rubber-band segment from the latest anchor to the cursor, and a\n * close-hint ring on the first anchor when the tool flags it as hot.\n *\n * Runs in screen space so anchor/handle sizes stay constant under zoom.\n * All world-space coords go through `worldToScreen` via the layer's `view`\n * argument.\n */\n\nimport type { DrawCommand } from '../../renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { Tool } from '../../tools/overlayBinding';\nimport type { PenScratch, PenAnchor, PenSubpath } from 'tools/builtin/pen';\nimport { PATH_C, PATH_L, PATH_M, type PolygonPath } from '@weasel-js/geom';\nimport { anchorsToPath } from './anchors';\nimport { circlePath } from './markers';\n\n/** Appearance of the pen tool's in-progress path. */\nexport interface PenPreviewStyle {\n  anchorFill?: string;\n  anchorStroke?: string;\n  handleStroke?: string;\n  rubberBandStroke?: string;\n  closeHintFill?: string;\n  finishedSubpathStroke?: string;\n}\n\n/** Options for `createPenPreviewLayer`. */\nexport interface CreatePenPreviewLayerOptions {\n  /** The Tool returned by usePenTool. The layer reads its scratch via\n   *  `tool.initScratch()` (the hook is contracted to return a stable ref). */\n  penTool: Tool<PenScratch>;\n  style?: PenPreviewStyle;\n}\n\nconst DEFAULT_STYLE: Required<PenPreviewStyle> = {\n  anchorFill: '#d4c4a8',\n  anchorStroke: '#d4c4a8',\n  handleStroke: '#d4c4a8',\n  rubberBandStroke: '#d4c4a8',\n  closeHintFill: '#d4c4a8',\n  finishedSubpathStroke: '#8a7a5e',\n};\n\nconst ANCHOR_RADIUS_PX = 4;\nconst HANDLE_DOT_RADIUS_PX = 3;\nconst CLOSE_HINT_RADIUS_PX = 8;\n\nfunction w2s(wx: number, wy: number, view: { x: number; y: number; scale: { x: number; y: number } }): [number, number] {\n  return [(wx - view.x) * view.scale.x, (wy - view.y) * view.scale.y];\n}\n\n// approximateCircle has moved to `./markers.ts` as `circlePath`. Re-exported\n// locally so we don't rename callers in this file.\nfunction approximateCircle(cx: number, cy: number, r: number): PolygonPath {\n  return circlePath(cx, cy, r);\n}\n\n/** A pen subpath as a screen-space `PolygonPath`, segmented by the same rule\n *  the pen commits with. */\nfunction subpathToPath(\n  sp: PenSubpath,\n  view: { x: number; y: number; scale: { x: number; y: number } },\n): PolygonPath | null {\n  if (sp.anchors.length === 0) return null;\n  const pt = (p: { x: number; y: number }) => {\n    const [x, y] = w2s(p.x, p.y, view);\n    return { x, y };\n  };\n  const anchors = sp.anchors.map((a: PenAnchor) => ({\n    ...pt(a),\n    ...(a.inHandle ? { inHandle: pt(a.inHandle) } : {}),\n    ...(a.outHandle ? { outHandle: pt(a.outHandle) } : {}),\n  }));\n  return anchorsToPath([anchors], [sp.closed]);\n}\n\n/** Render layer that draws the pen tool's path as it is being placed —\n *  committed anchors, the rubber band to the cursor, and the close hint. Draws\n *  nothing when the pen is idle. */\nexport function createPenPreviewLayer(\n  opts: CreatePenPreviewLayerOptions,\n): RenderLayer<unknown> {\n  const style = { ...DEFAULT_STYLE, ...(opts.style ?? {}) };\n  // Stable scratch ref — the pen tool contract guarantees identity stability.\n  const getScratch = (): PenScratch => opts.penTool.initScratch!();\n\n  return {\n    id: 'penPreview',\n    label: 'Pen preview',\n    space: 'screen',\n    draw: (_data, view) => {\n      const s = getScratch();\n      const out: DrawCommand[] = [];\n\n      // (1) Finished subpaths — faded outline.\n      for (const sp of s.finishedSubpaths) {\n        const path = subpathToPath(sp, view);\n        if (path === null) continue;\n        out.push({\n          kind: 'path',\n          path,\n          stroke: { paint: { fill: 'solid', color: style.finishedSubpathStroke }, width: 1 },\n        });\n      }\n\n      const cur = s.current;\n      if (!cur && s.cursor === null) return out;\n\n      // (2) Current subpath — bright outline.\n      if (cur) {\n        const path = subpathToPath(cur, view);\n        if (path !== null) {\n          out.push({\n            kind: 'path',\n            path,\n            stroke: { paint: { fill: 'solid', color: style.rubberBandStroke }, width: 1 },\n          });\n        }\n      }\n\n      // (3) Rubber-band from latest anchor to cursor.\n      if (cur && cur.anchors.length > 0 && s.cursor && s.draggingHandleAt === null) {\n        const last = cur.anchors[cur.anchors.length - 1];\n        const out2 = last.outHandle;\n        const [sx, sy] = w2s(last.x, last.y, view);\n        const [cx, cy] = w2s(s.cursor.x, s.cursor.y, view);\n        let path: PolygonPath;\n        if (out2) {\n          const [c1x, c1y] = w2s(out2.x, out2.y, view);\n          path = {\n            kind: 'polygon',\n            commands: new Uint8Array([PATH_M, PATH_C]),\n            coords: new Float32Array([sx, sy, c1x, c1y, cx, cy, cx, cy]),\n            fillRule: 'nonzero',\n          };\n        } else {\n          path = {\n            kind: 'polygon',\n            commands: new Uint8Array([PATH_M, PATH_L]),\n            coords: new Float32Array([sx, sy, cx, cy]),\n            fillRule: 'nonzero',\n          };\n        }\n        out.push({\n          kind: 'path',\n          path,\n          stroke: { paint: { fill: 'solid', color: style.rubberBandStroke }, width: 1 },\n        });\n      }\n\n      // (4) Anchor dots + handles.\n      if (cur) {\n        for (let i = 0; i < cur.anchors.length; i++) {\n          const a = cur.anchors[i];\n          const [ax, ay] = w2s(a.x, a.y, view);\n          out.push({\n            kind: 'path',\n            path: approximateCircle(ax, ay, ANCHOR_RADIUS_PX),\n            fill: { fill: 'solid', color: style.anchorFill },\n            stroke: { paint: { fill: 'solid', color: style.anchorStroke }, width: 1 },\n          });\n          // Handle line + dot (only the latest anchor, per spec).\n          if (i === cur.anchors.length - 1 && a.outHandle) {\n            const [hx, hy] = w2s(a.outHandle.x, a.outHandle.y, view);\n            const linePath: PolygonPath = {\n              kind: 'polygon',\n              commands: new Uint8Array([PATH_M, PATH_L]),\n              coords: new Float32Array([ax, ay, hx, hy]),\n              fillRule: 'nonzero',\n            };\n            out.push({\n              kind: 'path',\n              path: linePath,\n              stroke: { paint: { fill: 'solid', color: style.handleStroke }, width: 1 },\n            });\n            out.push({\n              kind: 'path',\n              path: approximateCircle(hx, hy, HANDLE_DOT_RADIUS_PX),\n              fill: { fill: 'solid', color: style.handleStroke },\n            });\n            const inSide = a.inHandle;\n            if (inSide) {\n              const [mx, my] = w2s(inSide.x, inSide.y, view);\n              const inLine: PolygonPath = {\n                kind: 'polygon',\n                commands: new Uint8Array([PATH_M, PATH_L]),\n                coords: new Float32Array([ax, ay, mx, my]),\n                fillRule: 'nonzero',\n              };\n              out.push({\n                kind: 'path',\n                path: inLine,\n                stroke: { paint: { fill: 'solid', color: style.handleStroke }, width: 1 },\n              });\n              out.push({\n                kind: 'path',\n                path: approximateCircle(mx, my, HANDLE_DOT_RADIUS_PX),\n                fill: { fill: 'solid', color: style.handleStroke },\n              });\n            }\n          }\n        }\n\n        // (5) Close-hint ring on first anchor.\n        if (s.closeHintActive && cur.anchors.length >= 3) {\n          const first = cur.anchors[0];\n          const [fx, fy] = w2s(first.x, first.y, view);\n          out.push({\n            kind: 'path',\n            path: approximateCircle(fx, fy, CLOSE_HINT_RADIUS_PX),\n            stroke: { paint: { fill: 'solid', color: style.closeHintFill }, width: 1.5 },\n          });\n        }\n      }\n\n      return out;\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/features/paths/poseDescriptor.js

@@ -0,0 +1,39 @@
+import { boundsOfPath as e, boxToBox as t, transformPath as n, translatePath as r } from "@weasel-js/geom";
+//#region src/features/paths/poseDescriptor.ts
+var i = {
+	getBounds: (t) => e(t),
+	remapBounds: (e, r, i) => n(e, t(r.x, r.y, r.width, r.height, i.x, i.y, i.width, i.height)),
+	fromBounds: (e) => ({
+		kind: "rect",
+		x: e.x,
+		y: e.y,
+		width: e.width,
+		height: e.height
+	}),
+	translate: (e, t, n) => r(e, t, n),
+	lerp: (e, t, n) => {
+		if (e.kind === "rect" && t.kind === "rect") return {
+			kind: "rect",
+			x: e.x + (t.x - e.x) * n,
+			y: e.y + (t.y - e.y) * n,
+			width: e.width + (t.width - e.width) * n,
+			height: e.height + (t.height - e.height) * n
+		};
+		if (e.kind === "polygon" && t.kind === "polygon" && e.coords.length === t.coords.length) {
+			let r = new Float32Array(e.coords.length);
+			for (let i = 0; i < e.coords.length; i++) r[i] = e.coords[i] + (t.coords[i] - e.coords[i]) * n;
+			return {
+				kind: "polygon",
+				commands: e.commands,
+				coords: r,
+				fillRule: e.fillRule
+			};
+		}
+		throw Error("pathPoseDescriptor.lerp: incompatible path shapes");
+	},
+	supportsRotation: () => !1
+};
+//#endregion
+export { i as pathPoseDescriptor };
+
+//# sourceMappingURL=poseDescriptor.js.map

package/dist/features/paths/poseDescriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"poseDescriptor.js","names":["pathPoseDescriptor","boundsOfPath","path","transformPath","boxToBox","src","dst","b","translatePath","dx","dy","a","t","next"],"sources":["../../../src/features/paths/poseDescriptor.ts"],"sourcesContent":["import {\n  boxToBox,\n  boundsOfPath,\n  translatePath,\n  transformPath,\n  type Path,\n} from '@weasel-js/geom';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\n\n/**\n * `PoseDescriptor` for `Path` poses — wires `useResize` to operate\n * on `Path` directly. `getBounds` defers to the same `boundsOfPath` kernel\n * the rest of the kit uses.\n *\n * `remapBounds` mirrors `scalePathToBounds` but takes `src` explicitly: the\n * resize hook knows the group's origin AABB and uses it for every leaf,\n * instead of each leaf scaling against its own AABB (which would ignore\n * group context).\n */\nexport const pathPoseDescriptor: PoseDescriptor<Path> = {\n  getBounds: (path) => boundsOfPath(path),\n  remapBounds: (path, src, dst) => transformPath(\n    path,\n    boxToBox(src.x, src.y, src.width, src.height, dst.x, dst.y, dst.width, dst.height),\n  ),\n  fromBounds: (b) => ({ kind: 'rect', x: b.x, y: b.y, width: b.width, height: b.height }),\n  translate: (path, dx, dy) => translatePath(path, dx, dy),\n  lerp: (a, b, t) => {\n    if (a.kind === 'rect' && b.kind === 'rect') {\n      return {\n        kind: 'rect',\n        x: a.x + (b.x - a.x) * t,\n        y: a.y + (b.y - a.y) * t,\n        width: a.width + (b.width - a.width) * t,\n        height: a.height + (b.height - a.height) * t,\n      };\n    }\n    if (a.kind === 'polygon' && b.kind === 'polygon' && a.coords.length === b.coords.length) {\n      const next = new Float32Array(a.coords.length);\n      for (let i = 0; i < a.coords.length; i++) {\n        next[i] = a.coords[i] + (b.coords[i] - a.coords[i]) * t;\n      }\n      return { kind: 'polygon', commands: a.commands, coords: next, fillRule: a.fillRule };\n    }\n    throw new Error('pathPoseDescriptor.lerp: incompatible path shapes');\n  },\n  // Path poses carry no x/y/width/height/rotation fields — the kit's\n  // `wrapWithPoseRotation` helper has nothing to bind a rotation to, and\n  // `remapBounds` would drop a synthetic rotation field on every commit.\n  // Returning false here hides the rotation affordance for Path consumers\n  // so the rotate cursor doesn't appear without a working interaction.\n  supportsRotation: () => false,\n};\n"],"mappings":";;AAmBA,IAAaA,IAA2C;CACtD,YAAY,MAASC,EAAaC,CAAI;CACtC,cAAc,GAAM,GAAK,MAAQC,EAC/BD,GACAE,EAASC,EAAI,GAAGA,EAAI,GAAGA,EAAI,OAAOA,EAAI,QAAQC,EAAI,GAAGA,EAAI,GAAGA,EAAI,OAAOA,EAAI,MAAM,CACnF;CACA,aAAa,OAAO;EAAE,MAAM;EAAQ,GAAGC,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;CAAO;CACrF,YAAY,GAAM,GAAI,MAAOC,EAAcN,GAAMO,GAAIC,CAAE;CACvD,OAAO,GAAG,GAAG,MAAM;EACjB,IAAIC,EAAE,SAAS,UAAUJ,EAAE,SAAS,QAClC,OAAO;GACL,MAAM;GACN,GAAGI,EAAE,KAAKJ,EAAE,IAAII,EAAE,KAAKC;GACvB,GAAGD,EAAE,KAAKJ,EAAE,IAAII,EAAE,KAAKC;GACvB,OAAOD,EAAE,SAASJ,EAAE,QAAQI,EAAE,SAASC;GACvC,QAAQD,EAAE,UAAUJ,EAAE,SAASI,EAAE,UAAUC;EAC7C;EAEF,IAAID,EAAE,SAAS,aAAaJ,EAAE,SAAS,aAAaI,EAAE,OAAO,WAAWJ,EAAE,OAAO,QAAQ;GACvF,IAAMM,IAAO,IAAI,aAAaF,EAAE,OAAO,MAAM;GAC7C,KAAK,IAAI,IAAI,GAAG,IAAIA,EAAE,OAAO,QAAQ,KACnC,EAAK,KAAKA,EAAE,OAAO,MAAMJ,EAAE,OAAO,KAAKI,EAAE,OAAO,MAAMC;GAExD,OAAO;IAAE,MAAM;IAAW,UAAUD,EAAE;IAAU,QAAQE;IAAM,UAAUF,EAAE;GAAS;EACrF;EACA,MAAU,MAAM,mDAAmD;CACrE;CAMA,wBAAwB;AAC1B"}

package/dist/features/paths/tessellate/stroke.js

@@ -0,0 +1,230 @@
+import { alignedStrokeRect as e, resolveScreenLength as t } from "@weasel-js/paint";
+import { extractPolylines as n, trimPolyline as r } from "@weasel-js/geom/tessellate";
+//#region src/features/paths/tessellate/stroke.ts
+var i = {
+	vertices: /* @__PURE__ */ new Float32Array(),
+	indices: /* @__PURE__ */ new Uint32Array(),
+	anchorA: /* @__PURE__ */ new Uint32Array(),
+	anchorB: /* @__PURE__ */ new Uint32Array(),
+	anchorT: /* @__PURE__ */ new Float32Array()
+};
+function a(e, n) {
+	return t(e, n);
+}
+function o(t, o, l = {}) {
+	let u = a(o.width ?? 1, 1);
+	if (u <= 0) return i;
+	let f = o.join ?? "miter", p = o.cap ?? "butt", g = o.align ?? "center", _ = o.miterLimit ?? m, v = o.varyingWidthJoinThreshold ?? h, y = t;
+	if (t.kind === "rect" && g !== "center") {
+		let n = e(t, g, u);
+		y = {
+			kind: "rect",
+			x: n.x,
+			y: n.y,
+			width: n.width,
+			height: n.height
+		};
+	}
+	let b = n(y, l);
+	if (o.vertexWidths && o.vertexWidths.length > 0) for (let e of b) c(e, o.vertexWidths, u);
+	let x = o.dash ?? [], S = [], C = [], w = [], T = [], E = [], D = l.startInset ?? 0, O = l.endInset ?? 0;
+	for (let e of b) {
+		let t = D > 0 || O > 0 ? r(e, D, O) : e;
+		if (t === null) continue;
+		let n = x.length > 0 ? d(t, x) : [t];
+		for (let e of n) s(e, u, f, p, _, v, S, C, w, T, E);
+	}
+	return {
+		vertices: new Float32Array(S),
+		indices: new Uint32Array(C),
+		anchorA: new Uint32Array(w),
+		anchorB: new Uint32Array(T),
+		anchorT: new Float32Array(E)
+	};
+}
+function s(e, t, n, r, i, a, o, s, c, l, d) {
+	let f = t / 2, m = e.points, h = m.length / 2, _ = h - 1;
+	if (_ < 1) return;
+	let v = e.anchorA ?? new Uint32Array(h), y = e.anchorB ?? new Uint32Array(h), b = e.anchorT ?? new Float32Array(h), x = e.widths ? e.widths.map((e) => e / 2) : null, S = [], C = [];
+	for (let e = 0; e < _; e++) {
+		let t = x ? x[e] : f, n = x ? x[e + 1] : f, r = p(m[e * 2], m[e * 2 + 1], m[(e + 1) * 2], m[(e + 1) * 2 + 1], t, n);
+		r && (S.push(r), C.push(e));
+	}
+	let w = -1;
+	if (e.closed && S.length >= 1) {
+		let e = S[S.length - 1], t = S[0], n = x ? x[h - 1] : f, r = x ? x[0] : f, i = p(e.bx, e.by, t.ax, t.ay, n, r);
+		i && (S.push(i), w = h - 1, C.push(w));
+	}
+	if (S.length === 0) return;
+	let T = [];
+	for (let t = 0; t < S.length; t++) {
+		let n = S[t], r = C[t], i = t === S.length - 1 && e.closed && w >= 0 ? 0 : r + 1, a = o.length / 2;
+		T.push(a);
+		let u = n.nxUnit * n.halfA, f = n.nyUnit * n.halfA, p = n.nxUnit * n.halfB, m = n.nyUnit * n.halfB;
+		o.push(n.ax + u, n.ay + f), c.push(v[r]), l.push(y[r]), d.push(b[r]), o.push(n.ax - u, n.ay - f), c.push(v[r]), l.push(y[r]), d.push(b[r]), o.push(n.bx + p, n.by + m), c.push(v[i]), l.push(y[i]), d.push(b[i]), o.push(n.bx - p, n.by - m), c.push(v[i]), l.push(y[i]), d.push(b[i]), s.push(a, a + 1, a + 2, a + 1, a + 3, a + 2);
+	}
+	let E = e.closed ? S.length : S.length - 1;
+	for (let e = 0; e < E; e++) g(S, T, e, n, i, a, o, s, c, l, d, C, v, y, b);
+	if (!e.closed && r !== "butt") {
+		let e = S[0], t = T[0];
+		u(e, t + 0, t + 1, !1, e.halfA, r, o, s, c, l, d, v[0], y[0], b[0]);
+		let n = S[S.length - 1], i = T[S.length - 1], a = C[S.length - 1] + 1;
+		u(n, i + 2, i + 3, !0, n.halfB, r, o, s, c, l, d, v[a], y[a], b[a]);
+	}
+}
+function c(e, t, n) {
+	let r = e.points.length / 2;
+	if (r === 0) return;
+	let i = e.anchorA ?? new Uint32Array(r), a = e.anchorB ?? new Uint32Array(r), o = e.anchorT ?? new Float32Array(r), s = new Float32Array(r), c = (e) => {
+		let r = t[e];
+		return typeof r == "number" && isFinite(r) && r > 0 ? r : n;
+	};
+	for (let e = 0; e < r; e++) {
+		let t = i[e], n = a[e], r = o[e];
+		if (t === n) s[e] = c(t);
+		else {
+			let i = c(t), a = c(n);
+			s[e] = i + (a - i) * r;
+		}
+	}
+	e.widths = s;
+}
+var l = 10 * Math.PI / 180;
+function u(e, t, n, r, i, a, o, s, c, u, d, f, p, m) {
+	let h = r ? 1 : -1, g = (e.bx - e.ax) / e.len * h, _ = (e.by - e.ay) / e.len * h, v = r ? e.bx : e.ax, y = r ? e.by : e.ay, b = e.nxUnit * i, x = e.nyUnit * i;
+	if (a === "square") {
+		let e = v + g * i, a = y + _ * i, l = o.length / 2;
+		o.push(e + b, a + x), c.push(f), u.push(p), d.push(m);
+		let h = o.length / 2;
+		o.push(e - b, a - x), c.push(f), u.push(p), d.push(m), r ? s.push(t, l, h, t, h, n) : s.push(t, h, l, t, n, h);
+		return;
+	}
+	if (a === "round") {
+		let e = o.length / 2;
+		o.push(v, y), c.push(f), u.push(p), d.push(m);
+		let a = Math.atan2(x, b), h = r ? -Math.PI : Math.PI, g = Math.max(1, Math.ceil(Math.abs(h) / l)), _ = h / g, S = t;
+		for (let t = 1; t < g; t++) {
+			let n = a + t * _, l = v + Math.cos(n) * i, h = y + Math.sin(n) * i, g = o.length / 2;
+			o.push(l, h), c.push(f), u.push(p), d.push(m), r ? s.push(S, g, e) : s.push(S, e, g), S = g;
+		}
+		r ? s.push(S, n, e) : s.push(S, e, n);
+	}
+}
+function d(e, t) {
+	let n = [], r = e.anchorA ?? new Uint32Array(e.points.length / 2), i = e.anchorB ?? new Uint32Array(e.points.length / 2), a = e.anchorT ?? new Float32Array(e.points.length / 2), o = 0, s = t[0], c = !0, l = c ? [e.points[0], e.points[1]] : null, u = c ? [r[0]] : null, d = c ? [i[0]] : null, p = c ? [a[0]] : null, m = () => {
+		l && l.length >= 4 && n.push({
+			points: l,
+			closed: !1,
+			anchorA: new Uint32Array(u),
+			anchorB: new Uint32Array(d),
+			anchorT: new Float32Array(p)
+		}), l = null, u = null, d = null, p = null, o = (o + 1) % t.length, s = t[o], c = !c;
+	}, h = e.points[0], g = e.points[1], _ = e.points.length / 2, v = e.closed ? _ : _ - 1;
+	for (let t = 0; t < v; t++) {
+		let n = (t + 1) % _, o = e.points[n * 2], f = e.points[n * 2 + 1], v = r[t], y = i[t], b = a[t], x = r[n], S = i[n], C = a[n], w = o - h, T = f - g, E = Math.hypot(w, T), D = w, O = T, k = E, A = 0;
+		for (; k > 1e-9;) if (k <= s) c && l && (l.push(o, f), u.push(x), d.push(S), p.push(C)), s -= k, h = o, g = f, A = E, k = 0, s <= 1e-9 && (m(), c && (l = [h, g], u = [x], d = [S], p = [C]));
+		else {
+			let e = s / k, t = h + D * e, n = g + O * e;
+			A += s;
+			let r = A / E, i, a, _;
+			v === x && y === S ? (i = v, a = y, _ = b + (C - b) * r) : r < .5 ? (i = v, a = y, _ = b) : (i = x, a = S, _ = C), c && l && (l.push(t, n), u.push(i), d.push(a), p.push(_)), h = t, g = n, D = o - h, O = f - g, k = Math.hypot(D, O), m(), c && (l = [h, g], u = [i], d = [a], p = [_]);
+		}
+	}
+	if (l && l.length >= 4) {
+		let t = {
+			points: l,
+			closed: !1,
+			anchorA: new Uint32Array(u),
+			anchorB: new Uint32Array(d),
+			anchorT: new Float32Array(p)
+		}, r = l[l.length - 2], i = l[l.length - 1], a = (e, t) => Math.hypot(r - e, i - t) <= 1e-9;
+		e.closed && n.length > 0 && a(n[0].points[0], n[0].points[1]) ? n[0] = f(t, n[0]) : e.closed && n.length === 0 && a(l[0], l[1]) ? n.push({
+			points: l.slice(0, -2),
+			closed: !0,
+			anchorA: t.anchorA.slice(0, -1),
+			anchorB: t.anchorB.slice(0, -1),
+			anchorT: t.anchorT.slice(0, -1)
+		}) : n.push(t);
+	}
+	return n;
+}
+function f(e, t) {
+	return {
+		points: [...e.points, ...t.points.slice(2)],
+		closed: !1,
+		anchorA: Uint32Array.from([...e.anchorA, ...t.anchorA.subarray(1)]),
+		anchorB: Uint32Array.from([...e.anchorB, ...t.anchorB.subarray(1)]),
+		anchorT: Float32Array.from([...e.anchorT, ...t.anchorT.subarray(1)])
+	};
+}
+function p(e, t, n, r, i, a) {
+	let o = n - e, s = r - t, c = Math.hypot(o, s);
+	return c === 0 ? null : {
+		ax: e,
+		ay: t,
+		bx: n,
+		by: r,
+		nxUnit: -s / c,
+		nyUnit: o / c,
+		halfA: i,
+		halfB: a,
+		len: c
+	};
+}
+var m = 4, h = 1.5;
+function g(e, t, n, r, i, a, o, s, c, l, u, d, f, p, m) {
+	let h = e[n], g = e[(n + 1) % e.length], _ = t[n], x = t[(n + 1) % e.length], S = h.bx - h.ax, C = h.by - h.ay, w = g.bx - g.ax, T = g.by - g.ay, E = S * T - C * w;
+	if (E === 0) return;
+	let D = E > 0, O = D ? _ + 3 : _ + 2, k = D ? x + 1 : x + 0, A = d[(n + 1) % e.length], j = f[A], M = p[A], N = m[A], P = h.halfB, F = Math.max(h.halfA, h.halfB) / Math.max(1e-9, Math.min(h.halfA, h.halfB)), I = Math.max(g.halfA, g.halfB) / Math.max(1e-9, Math.min(g.halfA, g.halfB));
+	if (r === "bevel" || F > a || I > a) {
+		y(h, O, k, D, o, s, c, l, u, j, M, N);
+		return;
+	}
+	if (r === "miter") {
+		let e = o[O * 2], t = o[O * 2 + 1], n = o[k * 2], r = o[k * 2 + 1], a = b(e, t, S, C, n, r, -w, -T);
+		if (!a) {
+			y(h, O, k, D, o, s, c, l, u, j, M, N);
+			return;
+		}
+		if (Math.hypot(a[0] - h.bx, a[1] - h.by) > i * P) {
+			y(h, O, k, D, o, s, c, l, u, j, M, N);
+			return;
+		}
+		let d = o.length / 2;
+		o.push(a[0], a[1]), c.push(j), l.push(M), u.push(N);
+		let f = o.length / 2;
+		o.push(h.bx, h.by), c.push(j), l.push(M), u.push(N), D ? (s.push(O, d, k), s.push(O, k, f)) : (s.push(O, k, d), s.push(O, f, k));
+		return;
+	}
+	if (r === "round") {
+		v(h, O, k, D, o, s, c, l, u, j, M, N);
+		return;
+	}
+}
+var _ = 10 * Math.PI / 180;
+function v(e, t, n, r, i, a, o, s, c, l, u, d) {
+	let f = e.bx, p = e.by, m = i.length / 2;
+	i.push(f, p), o.push(l), s.push(u), c.push(d);
+	let h = i[t * 2] - f, g = i[t * 2 + 1] - p, v = i[n * 2] - f, y = i[n * 2 + 1] - p, b = Math.hypot(h, g), x = Math.atan2(g, h), S = Math.atan2(y, v) - x;
+	r && S < 0 ? S += 2 * Math.PI : !r && S > 0 && (S -= 2 * Math.PI);
+	let C = Math.max(1, Math.ceil(Math.abs(S) / _)), w = S / C, T = t;
+	for (let e = 1; e < C; e++) {
+		let t = x + e * w, n = f + Math.cos(t) * b, h = p + Math.sin(t) * b, g = i.length / 2;
+		i.push(n, h), o.push(l), s.push(u), c.push(d), r ? a.push(T, m, g) : a.push(T, g, m), T = g;
+	}
+	r ? a.push(T, m, n) : a.push(T, n, m);
+}
+function y(e, t, n, r, i, a, o, s, c, l, u, d) {
+	let f = i.length / 2;
+	i.push(e.bx, e.by), o.push(l), s.push(u), c.push(d), r ? a.push(t, f, n) : a.push(t, n, f);
+}
+function b(e, t, n, r, i, a, o, s) {
+	let c = n * s - r * o;
+	if (Math.abs(c) < 1e-9) return null;
+	let l = ((i - e) * s - (a - t) * o) / c;
+	return [e + l * n, t + l * r];
+}
+//#endregion
+export { a as resolveStrokeWidth, o as tessellateStroke };
+
+//# sourceMappingURL=stroke.js.map

package/dist/features/paths/tessellate/stroke.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stroke.js","names":["EMPTY_MESH","resolveStrokeWidth","resolveScreenLength","width","scale","tessellateStroke","stroke","join","cap","align","miterLimit","DEFAULT_MITER_LIMIT","varyingThreshold","DEFAULT_VARYING_WIDTH_JOIN_THRESHOLD","workingPath","path","aligned","alignedStrokeRect","polylines","extractPolylines","opts","pl","dash","verts","idx","anchorA","anchorB","anchorT","startInset","endInset","trimmed","trimPolyline","subs","splitForDash","sub","expandPolyline","half","pts","ptCount","segCount","plA","plB","plT","plHalf","w","segs","segSrcIdx","s","ha","hb","seg","makeSeg","closerSrcIdx","last","first","haCloser","hbCloser","closer","segBaseIdx","startSrc","endSrc","base","nxA","nyA","nxB","nyB","joinCount","j","firstBase","lastBase","lastSrc","populatePolylineWidths","aA","aB","aT","widths","read","v","vertexWidths","i","fallbackWidth","a","b","t","wa","wb","ROUND_CAP_STEP_RAD","emitCap","sign","atEnd","dx","dy","cx","cy","nx","ny","ox","oy","lOut","endA","endB","endT","rOut","leftIdx","rightIdx","pivotIdx","startAngle","sweep","steps","stepAngle","prevIdx","ang","fx","fy","newIdx","out","dashIdx","dashRemaining","onPhase","curPts","curA","curB","curT","flushAndAdvance","prevX","prevY","nextIdx","startA","startB","startT","segFullDx","segFullDy","segFullLen","segDx","segDy","segLen","traveled","tConsume","ix","iy","frac","mA","mB","mT","tail","tx","ty","meets","x","y","joinAtSeam","head","bx","ax","by","ay","len","emitJoin","aBase","bBase","adx","ady","bdx","bdy","cross","onPositive","aOuterEnd","bOuterStart","cornerSrc","cornerA","cornerB","cornerT","halfAtCorner","taperA","taperB","aOX","aOY","bOX","bOY","apex","lineLineIntersect","apexIdx","jIdx","ROUND_STEP_RAD","emitRoundJoin","startX","startY","endX","endY","r","emitBevel","denom","bpx","apx","bpy","apy"],"sources":["../../../../src/features/paths/tessellate/stroke.ts"],"sourcesContent":["import type { Path } from '@weasel-js/core';\nimport type { ScreenLength, Stroke } from '@weasel-js/paint';\nimport { alignedStrokeRect, resolveScreenLength } from '@weasel-js/paint';\nimport { type Mesh, extractPolylines, type Polyline, trimPolyline } from '@weasel-js/geom/tessellate';\n\n/** Options for stroke tessellation. */\nexport interface StrokeOptions {\n  flattenTolerance?: number;\n  /**\n   * Shorten each open subpath by this much at its start / end, in the same\n   * world units as the path. Stroke markers use this so a filled head is not\n   * speared by its own line; the caller resolves the distance, because this\n   * layer knows nothing about the marker registry.\n   */\n  startInset?: number;\n  endInset?: number;\n}\n\nconst EMPTY_MESH: Mesh = {\n  vertices: new Float32Array(0),\n  indices: new Uint32Array(0),\n  anchorA: new Uint32Array(0),\n  anchorB: new Uint32Array(0),\n  anchorT: new Float32Array(0),\n};\n\ntype Cap = 'butt' | 'round' | 'square';\ntype Join = 'miter' | 'round' | 'bevel';\n\n/** Per-segment data the join code needs. */\ninterface Seg {\n  ax: number; ay: number;\n  bx: number; by: number;\n  /** Unit perpendicular (rotated 90° CCW from direction). */\n  nxUnit: number; nyUnit: number;\n  /** Half-width at the start (a) and end (b) endpoints. Equal for uniform\n   *  strokes; differ when the polyline carries per-point widths. */\n  halfA: number; halfB: number;\n  len: number;\n}\n\n/** Resolve a stroke width to world units. A number is already world units;\n *  `{ px }` is screen pixels divided by the accumulated scale, so it holds its\n *  on-screen thickness as the view zooms. */\nexport function resolveStrokeWidth(width: ScreenLength, scale: number): number {\n  return resolveScreenLength(width, scale);\n}\n\n/**\n * Build a triangle-mesh ribbon from a stroked Path.\n *\n * Supports:\n *   - cap: 'butt' | 'round' | 'square'\n *   - join: 'miter' | 'round' | 'bevel'\n *   - center alignment directly; RectPath inner/outer alignment via a\n *     pre-shifted rect; PolygonPath inner/outer alignment via stencil at the\n *     renderer level\n *   - dash splitting\n */\nexport function tessellateStroke(\n  path: Path,\n  stroke: Stroke,\n  opts: StrokeOptions = {},\n): Mesh {\n  // The renderer resolves `{ px }` against the accumulated transform before it\n  // gets here; a stroke that reaches the tessellator unresolved is read at\n  // scale 1, matching what the ribbon cache keys it under.\n  const width = resolveStrokeWidth(stroke.width ?? 1, 1);\n  if (width <= 0) return EMPTY_MESH;\n  const join: Join = stroke.join ?? 'miter';\n  const cap: Cap = stroke.cap ?? 'butt';\n  const align = stroke.align ?? 'center';\n  const miterLimit = stroke.miterLimit ?? DEFAULT_MITER_LIMIT;\n  const varyingThreshold = stroke.varyingWidthJoinThreshold ?? DEFAULT_VARYING_WIDTH_JOIN_THRESHOLD;\n\n  // RectPath fast path for inner/outer alignment: shift the rect by half-width\n  // so the ribbon's center alignment lands the stroke on the desired side of\n  // the original geometric edge. Arbitrary paths handle alignment via stencil\n  // clipping at the renderer level (not here).\n  let workingPath = path;\n  if (path.kind === 'rect' && align !== 'center') {\n    const aligned = alignedStrokeRect(path, align, width);\n    workingPath = {\n      kind: 'rect',\n      x: aligned.x,\n      y: aligned.y,\n      width: aligned.width,\n      height: aligned.height,\n    };\n  }\n\n  const polylines = extractPolylines(workingPath, opts);\n  // Derive per-polyline-point widths by lerping vertexWidths across\n  // anchor pairs using each point's anchorT. When vertexWidths is absent\n  // or invalid (length mismatch / non-finite values), polyline.widths is\n  // left undefined and the uniform-width fast path runs.\n  if (stroke.vertexWidths && stroke.vertexWidths.length > 0) {\n    for (const pl of polylines) populatePolylineWidths(pl, stroke.vertexWidths, width);\n  }\n  const dash = stroke.dash ?? [];\n  const verts: number[] = [];\n  const idx: number[] = [];\n  const anchorA: number[] = [];\n  const anchorB: number[] = [];\n  const anchorT: number[] = [];\n\n  // Trim before dashing, so the dash pattern fits the visible line rather than\n  // running off under a marker head.\n  const startInset = opts.startInset ?? 0;\n  const endInset = opts.endInset ?? 0;\n  for (const pl of polylines) {\n    const trimmed = startInset > 0 || endInset > 0 ? trimPolyline(pl, startInset, endInset) : pl;\n    if (trimmed === null) continue;\n    const subs = dash.length > 0 ? splitForDash(trimmed, dash) : [trimmed];\n    for (const sub of subs) {\n      expandPolyline(sub, width, join, cap, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT);\n    }\n  }\n\n  return {\n    vertices: new Float32Array(verts),\n    indices: new Uint32Array(idx),\n    anchorA: new Uint32Array(anchorA),\n    anchorB: new Uint32Array(anchorB),\n    anchorT: new Float32Array(anchorT),\n  };\n}\n\nfunction expandPolyline(\n  pl: Polyline,\n  width: number,\n  join: Join,\n  cap: Cap,\n  miterLimit: number,\n  varyingThreshold: number,\n  verts: number[],\n  idx: number[],\n  anchorA: number[],\n  anchorB: number[],\n  anchorT: number[],\n): void {\n  const half = width / 2;\n  const pts = pl.points;\n  const ptCount = pts.length / 2;\n  const segCount = ptCount - 1;\n  if (segCount < 1) return;\n\n  // Anchor params per polyline point (set by extractPolylines; splitForDash\n  // re-derives them on dash boundaries). Default to A=B=0,t=0 if missing.\n  const plA = pl.anchorA ?? new Uint32Array(ptCount);\n  const plB = pl.anchorB ?? new Uint32Array(ptCount);\n  const plT = pl.anchorT ?? new Float32Array(ptCount);\n  // Per-point half-widths: derived from pl.widths if present, else the\n  // uniform half. Indexing matches `pts` (one entry per polyline point).\n  const plHalf = pl.widths\n    ? pl.widths.map((w) => w / 2)\n    : null;\n\n  const segs: Seg[] = [];\n  const segSrcIdx: number[] = [];  // For each seg, the polyline-point index of its start.\n  for (let s = 0; s < segCount; s++) {\n    const ha = plHalf ? plHalf[s] : half;\n    const hb = plHalf ? plHalf[s + 1] : half;\n    const seg = makeSeg(pts[s * 2], pts[s * 2 + 1], pts[(s + 1) * 2], pts[(s + 1) * 2 + 1], ha, hb);\n    if (seg) {\n      segs.push(seg);\n      segSrcIdx.push(s);\n    }\n  }\n  let closerSrcIdx = -1;\n  if (pl.closed && segs.length >= 1) {\n    const last = segs[segs.length - 1];\n    const first = segs[0];\n    // Closer: from last point back to point 0. Half-widths are the\n    // already-resolved ones at those source indices.\n    const haCloser = plHalf ? plHalf[ptCount - 1] : half;\n    const hbCloser = plHalf ? plHalf[0] : half;\n    const closer = makeSeg(last.bx, last.by, first.ax, first.ay, haCloser, hbCloser);\n    if (closer) {\n      segs.push(closer);\n      closerSrcIdx = ptCount - 1;  // start is the last polyline point.\n      segSrcIdx.push(closerSrcIdx);\n    }\n  }\n  if (segs.length === 0) return;\n\n  // Emit ribbon quads. For each emitted vertex, record the (A, B, t) of the\n  // source polyline point that the geometric vertex sits at. Per-end\n  // half-widths produce trapezoidal segments when the stroke tapers.\n  const segBaseIdx: number[] = [];\n  for (let s = 0; s < segs.length; s++) {\n    const seg = segs[s];\n    const startSrc = segSrcIdx[s];\n    // End-source index for the seg. For closer (closed-path wraparound), end is point 0.\n    const endSrc = (s === segs.length - 1 && pl.closed && closerSrcIdx >= 0) ? 0 : startSrc + 1;\n    const base = verts.length / 2;\n    segBaseIdx.push(base);\n    const nxA = seg.nxUnit * seg.halfA, nyA = seg.nyUnit * seg.halfA;\n    const nxB = seg.nxUnit * seg.halfB, nyB = seg.nyUnit * seg.halfB;\n    // L0, R0 — at seg.ax/ay with start half-width.\n    verts.push(seg.ax + nxA, seg.ay + nyA);\n    anchorA.push(plA[startSrc]); anchorB.push(plB[startSrc]); anchorT.push(plT[startSrc]);\n    verts.push(seg.ax - nxA, seg.ay - nyA);\n    anchorA.push(plA[startSrc]); anchorB.push(plB[startSrc]); anchorT.push(plT[startSrc]);\n    // L1, R1 — at seg.bx/by with end half-width.\n    verts.push(seg.bx + nxB, seg.by + nyB);\n    anchorA.push(plA[endSrc]); anchorB.push(plB[endSrc]); anchorT.push(plT[endSrc]);\n    verts.push(seg.bx - nxB, seg.by - nyB);\n    anchorA.push(plA[endSrc]); anchorB.push(plB[endSrc]); anchorT.push(plT[endSrc]);\n    idx.push(base, base + 1, base + 2, base + 1, base + 3, base + 2);\n  }\n\n  // Joins between consecutive segments.\n  const joinCount = pl.closed ? segs.length : segs.length - 1;\n  for (let j = 0; j < joinCount; j++) {\n    emitJoin(segs, segBaseIdx, j, join, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT, segSrcIdx, plA, plB, plT);\n  }\n\n  // Caps. Use the local half-width at the cap end (seg.halfA at start, seg.halfB at end).\n  if (!pl.closed && cap !== 'butt') {\n    const first = segs[0];\n    const firstBase = segBaseIdx[0];\n    emitCap(first, firstBase + 0, firstBase + 1, false, first.halfA, cap, verts, idx, anchorA, anchorB, anchorT, plA[0], plB[0], plT[0]);\n\n    const last = segs[segs.length - 1];\n    const lastBase = segBaseIdx[segs.length - 1];\n    const lastSrc = segSrcIdx[segs.length - 1] + 1;\n    emitCap(last, lastBase + 2, lastBase + 3, true, last.halfB, cap, verts, idx, anchorA, anchorB, anchorT, plA[lastSrc], plB[lastSrc], plT[lastSrc]);\n  }\n}\n\n/** Fill `pl.widths` by interpolating `vertexWidths` across each point's\n *  (anchorA, anchorB, anchorT). Anchor-aligned points (A === B) read the\n *  anchor's value directly. Out-of-range / non-finite anchor entries fall\n *  back to `fallbackWidth`. */\nfunction populatePolylineWidths(\n  pl: Polyline,\n  vertexWidths: number[],\n  fallbackWidth: number,\n): void {\n  const ptCount = pl.points.length / 2;\n  if (ptCount === 0) return;\n  const aA = pl.anchorA ?? new Uint32Array(ptCount);\n  const aB = pl.anchorB ?? new Uint32Array(ptCount);\n  const aT = pl.anchorT ?? new Float32Array(ptCount);\n  const widths = new Float32Array(ptCount);\n  const read = (i: number): number => {\n    const v = vertexWidths[i];\n    return typeof v === 'number' && isFinite(v) && v > 0 ? v : fallbackWidth;\n  };\n  for (let i = 0; i < ptCount; i++) {\n    const a = aA[i], b = aB[i], t = aT[i];\n    if (a === b) {\n      widths[i] = read(a);\n    } else {\n      const wa = read(a);\n      const wb = read(b);\n      widths[i] = wa + (wb - wa) * t;\n    }\n  }\n  pl.widths = widths;\n}\n\nconst ROUND_CAP_STEP_RAD = (10 * Math.PI) / 180;\n\n/**\n * Emit a cap at one end of a segment. `leftIdx`/`rightIdx` are the buffer\n * indices of the L (perpendicular +n) and R (perpendicular -n) vertices at\n * the segment endpoint where the cap attaches. `atEnd` chooses which end of\n * the segment to extend from (and which cap-direction sign to use).\n */\nfunction emitCap(\n  seg: Seg, leftIdx: number, rightIdx: number, atEnd: boolean,\n  half: number, cap: Cap,\n  verts: number[], idx: number[],\n  anchorA: number[], anchorB: number[], anchorT: number[],\n  endA: number, endB: number, endT: number,\n): void {\n  // Outward direction = forward at end, backward at start.\n  const sign = atEnd ? 1 : -1;\n  const dx = (seg.bx - seg.ax) / seg.len * sign;\n  const dy = (seg.by - seg.ay) / seg.len * sign;\n  const cx = atEnd ? seg.bx : seg.ax;\n  const cy = atEnd ? seg.by : seg.ay;\n\n  // Perpendicular offset at this cap end uses the local half-width\n  // (varies along the polyline when vertexWidths is set).\n  const nx = seg.nxUnit * half;\n  const ny = seg.nyUnit * half;\n\n  if (cap === 'square') {\n    const ox = cx + dx * half;\n    const oy = cy + dy * half;\n    const lOut = verts.length / 2;\n    verts.push(ox + nx, oy + ny);\n    anchorA.push(endA); anchorB.push(endB); anchorT.push(endT);\n    const rOut = verts.length / 2;\n    verts.push(ox - nx, oy - ny);\n    anchorA.push(endA); anchorB.push(endB); anchorT.push(endT);\n    // Two triangles forming the cap rectangle. Wind so triangles are CCW\n    // viewed from the front; orientation symmetric for start vs. end caps.\n    if (atEnd) {\n      idx.push(leftIdx, lOut, rOut, leftIdx, rOut, rightIdx);\n    } else {\n      idx.push(leftIdx, rOut, lOut, leftIdx, rightIdx, rOut);\n    }\n    return;\n  }\n\n  if (cap === 'round') {\n    // Pivot vertex at the endpoint center; fan from L through the outward\n    // 180° arc to R.\n    const pivotIdx = verts.length / 2;\n    verts.push(cx, cy);\n    anchorA.push(endA); anchorB.push(endB); anchorT.push(endT);\n\n    // Starting angle: direction from pivot to L (= +n direction).\n    const startAngle = Math.atan2(ny, nx);\n    // Sweep 180° toward the outward direction. The outward unit is (dx, dy);\n    // we rotate from +n to -n the \"outward\" way. The dot product of (dx, dy)\n    // with the perpendicular tells us which way around the arc to go.\n    // A start-cap (sign = -1) sweeps backward; end-cap (sign = +1) sweeps forward.\n    const sweep = atEnd ? -Math.PI : Math.PI;\n    const steps = Math.max(1, Math.ceil(Math.abs(sweep) / ROUND_CAP_STEP_RAD));\n    const stepAngle = sweep / steps;\n\n    let prevIdx = leftIdx;\n    for (let i = 1; i < steps; i++) {\n      const ang = startAngle + i * stepAngle;\n      const fx = cx + Math.cos(ang) * half;\n      const fy = cy + Math.sin(ang) * half;\n      const newIdx = verts.length / 2;\n      verts.push(fx, fy);\n      anchorA.push(endA); anchorB.push(endB); anchorT.push(endT);\n      if (atEnd) idx.push(prevIdx, newIdx, pivotIdx);\n      else       idx.push(prevIdx, pivotIdx, newIdx);\n      prevIdx = newIdx;\n    }\n    if (atEnd) idx.push(prevIdx, rightIdx, pivotIdx);\n    else       idx.push(prevIdx, pivotIdx, rightIdx);\n  }\n}\n\n/**\n * Split a polyline into open sub-polylines for the \"on\" portions of a dash\n * pattern. Each output sub-polyline gets caps from the stroke's `cap` setting.\n * The \"off\" portions become invisible gaps. Anchor params are carried through:\n * sub-polyline endpoints inherit their source polyline-point's anchor params;\n * dash boundaries that land mid-segment (between two polyline points) snap\n * their anchor params to whichever endpoint they're closer to when the\n * segment crosses a path-anchor boundary, otherwise interpolate `t` linearly.\n */\nfunction splitForDash(pl: Polyline, dash: number[]): Polyline[] {\n  const out: Polyline[] = [];\n  const plA = pl.anchorA ?? new Uint32Array(pl.points.length / 2);\n  const plB = pl.anchorB ?? new Uint32Array(pl.points.length / 2);\n  const plT = pl.anchorT ?? new Float32Array(pl.points.length / 2);\n\n  let dashIdx = 0;\n  let dashRemaining = dash[0];\n  let onPhase = true;\n  let curPts: number[] | null = onPhase ? [pl.points[0], pl.points[1]] : null;\n  let curA: number[] | null = onPhase ? [plA[0]] : null;\n  let curB: number[] | null = onPhase ? [plB[0]] : null;\n  let curT: number[] | null = onPhase ? [plT[0]] : null;\n\n  const flushAndAdvance = () => {\n    if (curPts && curPts.length >= 4) {\n      out.push({\n        points: curPts,\n        closed: false,\n        anchorA: new Uint32Array(curA!),\n        anchorB: new Uint32Array(curB!),\n        anchorT: new Float32Array(curT!),\n      });\n    }\n    curPts = null; curA = null; curB = null; curT = null;\n    dashIdx = (dashIdx + 1) % dash.length;\n    dashRemaining = dash[dashIdx];\n    onPhase = !onPhase;\n  };\n\n  let prevX = pl.points[0], prevY = pl.points[1];\n  const ptCount = pl.points.length / 2;\n  const segCount = pl.closed ? ptCount : ptCount - 1;\n\n  for (let i = 0; i < segCount; i++) {\n    const nextIdx = (i + 1) % ptCount;\n    const cx = pl.points[nextIdx * 2], cy = pl.points[nextIdx * 2 + 1];\n    const startA = plA[i], startB = plB[i], startT = plT[i];\n    const endA = plA[nextIdx], endB = plB[nextIdx], endT = plT[nextIdx];\n    const segFullDx = cx - prevX, segFullDy = cy - prevY;\n    const segFullLen = Math.hypot(segFullDx, segFullDy);\n    let segDx = segFullDx, segDy = segFullDy;\n    let segLen = segFullLen;\n    let traveled = 0;\n\n    while (segLen > 1e-9) {\n      if (segLen <= dashRemaining) {\n        if (onPhase && curPts) {\n          curPts.push(cx, cy);\n          curA!.push(endA); curB!.push(endB); curT!.push(endT);\n        }\n        dashRemaining -= segLen;\n        prevX = cx; prevY = cy;\n        traveled = segFullLen;\n        segLen = 0;\n        if (dashRemaining <= 1e-9) {\n          flushAndAdvance();\n          if (onPhase) {\n            curPts = [prevX, prevY];\n            curA = [endA]; curB = [endB]; curT = [endT];\n          }\n        }\n      } else {\n        const tConsume = dashRemaining / segLen;\n        const ix = prevX + segDx * tConsume;\n        const iy = prevY + segDy * tConsume;\n        traveled += dashRemaining;\n        const frac = traveled / segFullLen;\n        let mA: number, mB: number, mT: number;\n        if (startA === endA && startB === endB) {\n          mA = startA; mB = startB;\n          mT = startT + (endT - startT) * frac;\n        } else {\n          // Cross-anchor segment: pick the nearer endpoint's params.\n          if (frac < 0.5) { mA = startA; mB = startB; mT = startT; }\n          else            { mA = endA; mB = endB; mT = endT; }\n        }\n        if (onPhase && curPts) {\n          curPts.push(ix, iy);\n          curA!.push(mA); curB!.push(mB); curT!.push(mT);\n        }\n        prevX = ix; prevY = iy;\n        segDx = cx - prevX; segDy = cy - prevY;\n        segLen = Math.hypot(segDx, segDy);\n        flushAndAdvance();\n        if (onPhase) {\n          curPts = [prevX, prevY];\n          curA = [mA]; curB = [mB]; curT = [mT];\n        }\n      }\n    }\n  }\n\n  if (curPts && curPts.length >= 4) {\n    const tail: Polyline = {\n      points: curPts,\n      closed: false,\n      anchorA: new Uint32Array(curA!),\n      anchorB: new Uint32Array(curB!),\n      anchorT: new Float32Array(curT!),\n    };\n    // A closed subpath's walk ends at the vertex it started from, so the run\n    // still open there and the run that started there are one dash. Pushed\n    // separately they are two butt-capped ribbons meeting at the seam — the\n    // visible artifact whenever the pattern doesn't divide the perimeter.\n    const tx = curPts[curPts.length - 2], ty = curPts[curPts.length - 1];\n    const meets = (x: number, y: number) => Math.hypot(tx - x, ty - y) <= 1e-9;\n    if (pl.closed && out.length > 0 && meets(out[0].points[0], out[0].points[1])) {\n      out[0] = joinAtSeam(tail, out[0]);\n    } else if (pl.closed && out.length === 0 && meets(curPts[0], curPts[1])) {\n      // Every gap fell outside the perimeter: the dash is the whole loop, and\n      // a loop stroked as an open run seams at its own start vertex too.\n      out.push({\n        points: curPts.slice(0, -2),\n        closed: true,\n        anchorA: tail.anchorA!.slice(0, -1),\n        anchorB: tail.anchorB!.slice(0, -1),\n        anchorT: tail.anchorT!.slice(0, -1),\n      });\n    } else {\n      out.push(tail);\n    }\n  }\n  return out;\n}\n\n/** `tail` continued by `head`, which starts where `tail` ends — the shared\n *  vertex is carried once. */\nfunction joinAtSeam(tail: Polyline, head: Polyline): Polyline {\n  return {\n    points: [...tail.points, ...head.points.slice(2)],\n    closed: false,\n    anchorA: Uint32Array.from([...tail.anchorA!, ...head.anchorA!.subarray(1)]),\n    anchorB: Uint32Array.from([...tail.anchorB!, ...head.anchorB!.subarray(1)]),\n    anchorT: Float32Array.from([...tail.anchorT!, ...head.anchorT!.subarray(1)]),\n  };\n}\n\nfunction makeSeg(ax: number, ay: number, bx: number, by: number, halfA: number, halfB: number): Seg | null {\n  const dx = bx - ax, dy = by - ay;\n  const len = Math.hypot(dx, dy);\n  if (len === 0) return null;\n  return {\n    ax, ay, bx, by,\n    nxUnit: -dy / len, nyUnit: dx / len,\n    halfA, halfB,\n    len,\n  };\n}\n\n/**\n * Miter limit for a stroke that does not set one. SVG's default, not\n * Canvas2D's 10, because the serializer omits the attribute when the field is\n * unset — so a kit stroke exported to SVG is read back by every other renderer\n * as 4, and a kit that used 10 would disagree with its own export. 10 also\n * lets an acute corner throw a spike four times the half-width, which is what\n * a glyph outline's sharpest vertices do.\n */\nconst DEFAULT_MITER_LIMIT = 4;\n/** Default `Stroke.varyingWidthJoinThreshold`. */\nconst DEFAULT_VARYING_WIDTH_JOIN_THRESHOLD = 1.5;\n\nfunction emitJoin(\n  segs: Seg[], segBaseIdx: number[], j: number, join: Join,\n  miterLimit: number,\n  varyingThreshold: number,\n  verts: number[], idx: number[],\n  anchorA: number[], anchorB: number[], anchorT: number[],\n  segSrcIdx: number[],\n  plA: Uint32Array, plB: Uint32Array, plT: Float32Array,\n): void {\n  const a = segs[j];\n  const b = segs[(j + 1) % segs.length];\n  const aBase = segBaseIdx[j];\n  const bBase = segBaseIdx[(j + 1) % segs.length];\n\n  const adx = a.bx - a.ax, ady = a.by - a.ay;\n  const bdx = b.bx - b.ax, bdy = b.by - b.ay;\n  const cross = adx * bdy - ady * bdx;\n  if (cross === 0) return;                                       // straight (collinear), no wedge\n  const onPositive = cross > 0;\n\n  const aOuterEnd = onPositive ? aBase + 3 : aBase + 2;\n  const bOuterStart = onPositive ? bBase + 1 : bBase + 0;\n\n  // The corner of join `j` is the start of segment `j+1` (which is the END of\n  // segment `j` — they share the same polyline point). For the wraparound join\n  // on a closed polyline, j+1 wraps to segment 0 whose start is the closer\n  // segment's endpoint, which is polyline point 0.\n  const nextSeg = (j + 1) % segs.length;\n  // The corner anchor is the start of the next segment (shared endpoint).\n  // For a closed path's final join, nextSeg wraps to 0, whose start is\n  // polyline point 0 — correct.\n  const cornerSrc = segSrcIdx[nextSeg];\n  const cornerA = plA[cornerSrc];\n  const cornerB = plB[cornerSrc];\n  const cornerT = plT[cornerSrc];\n  // The two adjoining half-widths agree at the shared corner (a.halfB ===\n  // b.halfA for a single-contour polyline), so use either for miter-limit\n  // sizing. Force bevel when either adjacent segment itself tapers by\n  // more than `varyingThreshold` — the miter apex math computes against\n  // outer edges parallel to the segment direction, an assumption that\n  // breaks on tapered trapezoids (outer edges fan in/out).\n  const halfAtCorner = a.halfB;\n  const taperA = Math.max(a.halfA, a.halfB) / Math.max(1e-9, Math.min(a.halfA, a.halfB));\n  const taperB = Math.max(b.halfA, b.halfB) / Math.max(1e-9, Math.min(b.halfA, b.halfB));\n  const forceBevelForVarying = taperA > varyingThreshold || taperB > varyingThreshold;\n\n  if (join === 'bevel' || forceBevelForVarying) {\n    emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);\n    return;\n  }\n\n  if (join === 'miter') {\n    // Compute apex: intersection of A's outer edge extended forward and\n    // B's outer edge extended backward. If miter length > MITER_LIMIT * half,\n    // fall back to bevel.\n    const aOX = verts[aOuterEnd * 2], aOY = verts[aOuterEnd * 2 + 1];\n    const bOX = verts[bOuterStart * 2], bOY = verts[bOuterStart * 2 + 1];\n    const apex = lineLineIntersect(aOX, aOY, adx, ady, bOX, bOY, -bdx, -bdy);\n    if (!apex) {\n      emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);\n      return;\n    }\n    const miterLen = Math.hypot(apex[0] - a.bx, apex[1] - a.by);\n    if (miterLen > miterLimit * halfAtCorner) {\n      emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);\n      return;\n    }\n    // A miter join's outer face is a kite quadrilateral with vertices\n    // (R1, apex, R0, J) — covered by TWO triangles. The bevel inner half\n    // (R1, R0, J) fills the area between the joint corner and the diagonal\n    // hypotenuse R0-R1; the outer extension (R1, apex, R0) fills from the\n    // hypotenuse to the apex point. Without the bevel half, an \"inverted\n    // triangle\" gap opens at every miter corner.\n    const apexIdx = verts.length / 2;\n    verts.push(apex[0], apex[1]);\n    anchorA.push(cornerA); anchorB.push(cornerB); anchorT.push(cornerT);\n    const jIdx = verts.length / 2;\n    verts.push(a.bx, a.by);\n    anchorA.push(cornerA); anchorB.push(cornerB); anchorT.push(cornerT);\n    if (onPositive) {\n      idx.push(aOuterEnd, apexIdx, bOuterStart);\n      idx.push(aOuterEnd, bOuterStart, jIdx);\n    } else {\n      idx.push(aOuterEnd, bOuterStart, apexIdx);\n      idx.push(aOuterEnd, jIdx, bOuterStart);\n    }\n    return;\n  }\n\n  if (join === 'round') {\n    emitRoundJoin(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);\n    return;\n  }\n}\n\nconst ROUND_STEP_RAD = (10 * Math.PI) / 180;   // ~10° per fan triangle\n\nfunction emitRoundJoin(\n  a: Seg, aOuterEnd: number, bOuterStart: number, onPositive: boolean,\n  verts: number[], idx: number[],\n  anchorA: number[], anchorB: number[], anchorT: number[],\n  cornerA: number, cornerB: number, cornerT: number,\n): void {\n  // Pivot = joint center; emit fresh vertex.\n  const cx = a.bx, cy = a.by;\n  const pivotIdx = verts.length / 2;\n  verts.push(cx, cy);\n  anchorA.push(cornerA); anchorB.push(cornerB); anchorT.push(cornerT);\n\n  const startX = verts[aOuterEnd * 2] - cx;\n  const startY = verts[aOuterEnd * 2 + 1] - cy;\n  const endX = verts[bOuterStart * 2] - cx;\n  const endY = verts[bOuterStart * 2 + 1] - cy;\n  const r = Math.hypot(startX, startY);\n\n  const startAngle = Math.atan2(startY, startX);\n  const endAngle = Math.atan2(endY, endX);\n  // Outer-side sweep: for CCW turns (cross > 0, onPositive true) outer is on\n  // the -n side and the arc sweeps from R1 (south of joint) clockwise to R0\n  // (east of joint) — i.e., negative sweep. For CW turns, sweep is positive.\n  // Pick the SHORT arc that crosses the outer wedge. For onPositive=true\n  // (CW turn in screen coords with y-down), the outer wedge sits where the\n  // natural sweep is positive; for onPositive=false, where it is negative.\n  // If the natural sweep has the wrong sign, wrap by ±2π.\n  let sweep = endAngle - startAngle;\n  if (onPositive && sweep < 0) sweep += 2 * Math.PI;\n  else if (!onPositive && sweep > 0) sweep -= 2 * Math.PI;\n\n  const steps = Math.max(1, Math.ceil(Math.abs(sweep) / ROUND_STEP_RAD));\n  const stepAngle = sweep / steps;\n\n  let prevIdx = aOuterEnd;\n  for (let i = 1; i < steps; i++) {\n    const ang = startAngle + i * stepAngle;\n    const fx = cx + Math.cos(ang) * r;\n    const fy = cy + Math.sin(ang) * r;\n    const newIdx = verts.length / 2;\n    verts.push(fx, fy);\n    anchorA.push(cornerA); anchorB.push(cornerB); anchorT.push(cornerT);\n    if (onPositive) idx.push(prevIdx, pivotIdx, newIdx);\n    else            idx.push(prevIdx, newIdx, pivotIdx);\n    prevIdx = newIdx;\n  }\n  if (onPositive) idx.push(prevIdx, pivotIdx, bOuterStart);\n  else            idx.push(prevIdx, bOuterStart, pivotIdx);\n}\n\nfunction emitBevel(\n  a: Seg, aOuterEnd: number, bOuterStart: number, onPositive: boolean,\n  verts: number[], idx: number[],\n  anchorA: number[], anchorB: number[], anchorT: number[],\n  cornerA: number, cornerB: number, cornerT: number,\n): void {\n  const jIdx = verts.length / 2;\n  verts.push(a.bx, a.by);\n  anchorA.push(cornerA); anchorB.push(cornerB); anchorT.push(cornerT);\n  if (onPositive) idx.push(aOuterEnd, jIdx, bOuterStart);\n  else            idx.push(aOuterEnd, bOuterStart, jIdx);\n}\n\n/**\n * Solve for the intersection of line A (point ap, direction ad) with line B\n * (point bp, direction bd). Returns null if parallel or near-parallel.\n */\nfunction lineLineIntersect(\n  apx: number, apy: number, adx: number, ady: number,\n  bpx: number, bpy: number, bdx: number, bdy: number,\n): [number, number] | null {\n  const denom = adx * bdy - ady * bdx;\n  if (Math.abs(denom) < 1e-9) return null;\n  const t = ((bpx - apx) * bdy - (bpy - apy) * bdx) / denom;\n  return [apx + t * adx, apy + t * ady];\n}\n"],"mappings":"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"}

package/dist/features/patterns/index.js

@@ -0,0 +1,23 @@
+import { registerTexture as e } from "../../renderer/textures/registerTexture.js";
+//#region src/features/patterns/index.ts
+function t(t) {
+	let n;
+	try {
+		n = new OffscreenCanvas(t.size, t.size);
+	} catch {
+		if (typeof document > "u") return null;
+		let e = document.createElement("canvas");
+		e.width = t.size, e.height = t.size, n = e;
+	}
+	let r = n.getContext("2d");
+	if (!r) return null;
+	t.draw(r, t.size);
+	let i;
+	if (typeof n.transferToImageBitmap == "function") i = n.transferToImageBitmap();
+	else return null;
+	return e(i);
+}
+//#endregion
+export { t as createTilePattern };
+
+//# sourceMappingURL=index.js.map