@weasel-js/core 1.10.1 → 1.11.1

package/dist/canvas/nodeShapes/shapePainter.js

@@ -1,72 +1,93 @@
-import { nodeMemo as e } from "../../core/scene/nodeMemo.js";
-import { DEFAULT_SHAPE_FILL as t } from "../../util/paint.js";
-import { PAINT_SLOT as n } from "./memo.js";
-import { inkReach as r, resolveNodeFill as i, resolveNodeStroke as a, withAnimatedVertexColors as o } from "./nodePaint.js";
-import { paintsPose as s, poseBoxBounds as c } from "./poseBox.js";
-import { commandFill as l, commandStroke as u } from "@weasel-js/renderer";
-import { ellipsePath as d, regularPolygonPath as f, starPath as p } from "@weasel-js/geom";
+import { nodeMemo } from "../../core/scene/nodeMemo.js";
+import { DEFAULT_SHAPE_FILL } from "../../util/paint.js";
+import { PAINT_SLOT } from "./memo.js";
+import { inkReach, resolveNodeFill, resolveNodeStroke, withAnimatedVertexColors } from "./nodePaint.js";
+import { outsetPoseBox, strokedPoseBox } from "./strokedBounds.js";
+import { paintsPose, poseBoxBounds } from "./poseBox.js";
+import { commandFill, commandStroke } from "@weasel-js/renderer";
+import { ellipsePath, regularPolygonPath, starPath } from "@weasel-js/geom";
+
 //#region src/canvas/nodeShapes/shapePainter.ts
-var m = {
+/** Built-in shape dispatcher — matches when `data.shape` names a kit-known
+*  shape kind. Computes both paint and silhouette from the pose so consumer
+*  scenes can declare clipping/rendering directly in JSON without
+*  registering a custom painter. */
+var SHAPE_PAINTER = {
 	id: "kit:shape",
-	matches: (e) => {
-		if (!s(e.pose)) return !1;
-		let t = e.data?.shape;
-		return t != null && h.has(t);
+	matches: (node) => {
+		if (!paintsPose(node.pose)) return false;
+		const s = node.data?.shape;
+		return s != null && SHAPE_KINDS.has(s);
 	},
-	paint: (r, s, c) => o(e(r, n, s, () => {
-		let e = r.data, n = g(e, s), o = i(e.fill, t), c = o && l(o, s), d = a(e.stroke), f = d && u(d, s);
+	paint: (node, pose, ctx) => withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {
+		const d = node.data;
+		const path = pathForShape(d, pose);
+		const declaredFill = resolveNodeFill(d.fill, DEFAULT_SHAPE_FILL);
+		const shapeFill = declaredFill && commandFill(declaredFill, pose);
+		const strokeSpec = resolveNodeStroke(d.stroke);
+		const stroke = strokeSpec && commandStroke(strokeSpec, pose);
 		return [{
 			kind: "path",
-			path: n,
-			...c ? { fill: c } : {},
-			...f ? { stroke: f } : {}
+			path,
+			...shapeFill ? { fill: shapeFill } : {},
+			...stroke ? { stroke } : {}
 		}];
-	}), c),
-	silhouette: (e, t) => {
-		let n = e.data;
-		return g(n, t);
+	}), ctx),
+	silhouette: (node, pose) => {
+		const d = node.data;
+		return pathForShape(d, pose);
 	},
-	ink: (e, n, o) => {
-		let s = e.data;
+	ink: (node, _pose, ctx) => {
+		const d = node.data;
 		return {
-			filled: i(s.fill, t) !== null,
-			...r(a(s.stroke), o?.scale)
+			filled: resolveNodeFill(d.fill, DEFAULT_SHAPE_FILL) !== null,
+			...inkReach(resolveNodeStroke(d.stroke), ctx?.scale)
 		};
 	},
-	bounds: (e, t, n) => c(t, a(e.data.stroke), n)
-}, h = /* @__PURE__ */ new Set([
+	bounds: (node, pose, ctx) => poseBoxBounds(pose, resolveNodeStroke(node.data.stroke), ctx),
+	drawnBounds: (node, pose, ctx) => {
+		const d = node.data;
+		const stroke = resolveNodeStroke(d.stroke);
+		return d.shape === "polygon" || d.shape === "star" ? strokedPoseBox(node, pose, stroke, ctx, (at) => pathForShape(d, at)) : outsetPoseBox(pose, stroke, ctx);
+	}
+};
+var SHAPE_KINDS = /* @__PURE__ */ new Set([
 	"rect",
 	"ellipse",
 	"polygon",
 	"star"
 ]);
-function g(e, t) {
-	switch (e.shape) {
-		case "ellipse": return d(t);
+function pathForShape(d, p) {
+	switch (d.shape) {
+		case "ellipse": return ellipsePath(p);
 		case "polygon": {
-			let n = t.x + t.width / 2, r = t.y + t.height / 2, i = Math.min(t.width, t.height) / 2;
-			return f({
-				x: n,
-				y: r
-			}, i, e.sides ?? 6);
+			const cx = p.x + p.width / 2;
+			const cy = p.y + p.height / 2;
+			const r = Math.min(p.width, p.height) / 2;
+			return regularPolygonPath({
+				x: cx,
+				y: cy
+			}, r, d.sides ?? 6);
 		}
 		case "star": {
-			let n = t.x + t.width / 2, r = t.y + t.height / 2, i = Math.min(t.width, t.height) / 2;
-			return p({
-				x: n,
-				y: r
-			}, i, e.points ?? 5);
+			const cx = p.x + p.width / 2;
+			const cy = p.y + p.height / 2;
+			const r = Math.min(p.width, p.height) / 2;
+			return starPath({
+				x: cx,
+				y: cy
+			}, r, d.points ?? 5);
 		}
 		default: return {
 			kind: "rect",
-			x: t.x,
-			y: t.y,
-			width: t.width,
-			height: t.height
+			x: p.x,
+			y: p.y,
+			width: p.width,
+			height: p.height
 		};
 	}
 }
-//#endregion
-export { h as SHAPE_KINDS, m as SHAPE_PAINTER, g as pathForShape };
 
+//#endregion
+export { SHAPE_KINDS, SHAPE_PAINTER, pathForShape };
 //# sourceMappingURL=shapePainter.js.map

package/dist/canvas/nodeShapes/shapePainter.js.map

@@ -1 +1 @@
-{"version":3,"file":"shapePainter.js","names":["SHAPE_PAINTER","paintsPose","node","s","SHAPE_KINDS","withAnimatedVertexColors","nodeMemo","PAINT_SLOT","pose","d","path","pathForShape","declaredFill","resolveNodeFill","DEFAULT_SHAPE_FILL","shapeFill","commandFill","strokeSpec","resolveNodeStroke","stroke","commandStroke","ctx","inkReach","poseBoxBounds","ellipsePath","p","cx","cy","r","regularPolygonPath","starPath"],"sources":["../../../src/canvas/nodeShapes/shapePainter.ts"],"sourcesContent":["import {\n  ellipsePath,\n  regularPolygonPath,\n  starPath,\n  type Path\n} from '@weasel-js/geom';\nimport type { Stroke, Fill } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { RectPose } from 'core/scene/types';\nimport { commandFill, commandStroke } from '@weasel-js/renderer';\nimport { DEFAULT_SHAPE_FILL } from '../../util/paint';\nimport { PAINT_SLOT } from './memo';\nimport { inkReach, withAnimatedVertexColors, resolveNodeFill, resolveNodeStroke } from './nodePaint';\nimport { paintsPose, poseBoxBounds } from './poseBox';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\n/** Built-in shape dispatcher — matches when `data.shape` names a kit-known\n *  shape kind. Computes both paint and silhouette from the pose so consumer\n *  scenes can declare clipping/rendering directly in JSON without\n *  registering a custom painter. */\nexport const SHAPE_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:shape',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const s = (node.data as { shape?: string } | null)?.shape;\n    return s != null && SHAPE_KINDS.has(s);\n  },\n  // Memoized: a pure function of `(data, pose)`, and `pathForShape` builds a\n  // fresh `Uint8Array` + `Float32Array` for every ellipse, polygon and star.\n  // See PAINT_SLOT.\n  paint: (node, pose, ctx) => withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {\n    const d = node.data as { shape: string; fill?: Fill | null; stroke?: Stroke | null; sides?: number; points?: number };\n    const path = pathForShape(d, pose);\n    const declaredFill = resolveNodeFill(d.fill, DEFAULT_SHAPE_FILL);\n    const shapeFill = declaredFill && commandFill(declaredFill, pose);\n    const strokeSpec = resolveNodeStroke(d.stroke);\n    const stroke = strokeSpec && commandStroke(strokeSpec, pose);\n    return [{\n      kind: 'path',\n      path,\n      ...(shapeFill ? { fill: shapeFill } : {}),\n      ...(stroke ? { stroke } : {}),\n    }];\n  }), ctx),\n  silhouette: (node, pose) => {\n    const d = node.data as { shape: string; sides?: number; points?: number };\n    return pathForShape(d, pose);\n  },\n  // `paint` above emits the default fill when none is declared, so a shape\n  // is filled unless it declares `fill: null` — unlike `kit:path`, it has no\n  // implicit stroke-only form.\n  ink: (node, _pose, ctx) => {\n    const d = node.data as { fill?: Fill | null; stroke?: Stroke | null };\n    return {\n      filled: resolveNodeFill(d.fill, DEFAULT_SHAPE_FILL) !== null,\n      ...inkReach(resolveNodeStroke(d.stroke), ctx?.scale),\n    };\n  },\n  // Every shape kind is inscribed in the pose box.\n  bounds: (node, pose, ctx) =>\n    poseBoxBounds(pose, resolveNodeStroke((node.data as { stroke?: Stroke | null }).stroke), ctx),\n};\n\nexport const SHAPE_KINDS = new Set(['rect', 'ellipse', 'polygon', 'star']);\n\nexport function pathForShape(\n  d: { shape: string; sides?: number; points?: number },\n  p: RectPose,\n): Path {\n  switch (d.shape) {\n    case 'ellipse':\n      return ellipsePath(p);\n    case 'polygon': {\n      const cx = p.x + p.width / 2;\n      const cy = p.y + p.height / 2;\n      const r = Math.min(p.width, p.height) / 2;\n      return regularPolygonPath({ x: cx, y: cy }, r, d.sides ?? 6);\n    }\n    case 'star': {\n      const cx = p.x + p.width / 2;\n      const cy = p.y + p.height / 2;\n      const r = Math.min(p.width, p.height) / 2;\n      return starPath({ x: cx, y: cy }, r, d.points ?? 5);\n    }\n    case 'rect':\n    default:\n      return { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height };\n  }\n}\n"],"mappings":";;;;;;;;AAqBA,IAAaA,IAAmD;CAC9D,IAAI;CACJ,UAAU,MAAS;EACjB,IAAI,CAACC,EAAWC,EAAK,IAAI,GAAG,OAAO;EACnC,IAAMC,IAAKD,EAAK,MAAoC;EACpD,OAAOC,KAAK,QAAQC,EAAY,IAAID,CAAC;CACvC;CAIA,QAAQ,GAAM,GAAM,MAAQE,EAAyBC,EAASJ,GAAMK,GAAYC,SAAY;EAC1F,IAAMC,IAAIP,EAAK,MACTQ,IAAOC,EAAaF,GAAGD,CAAI,GAC3BI,IAAeC,EAAgBJ,EAAE,MAAMK,CAAkB,GACzDC,IAAYH,KAAgBI,EAAYJ,GAAcJ,CAAI,GAC1DS,IAAaC,EAAkBT,EAAE,MAAM,GACvCU,IAASF,KAAcG,EAAcH,GAAYT,CAAI;EAC3D,OAAO,CAAC;GACN,MAAM;GACN;GACA,GAAIO,IAAY,EAAE,MAAMA,EAAU,IAAI,CAAC;GACvC,GAAII,IAAS,EAAE,UAAO,IAAI,CAAC;EAC7B,CAAC;CACH,CAAC,GAAGE,CAAG;CACP,aAAa,GAAM,MAAS;EAC1B,IAAMZ,IAAIP,EAAK;EACf,OAAOS,EAAaF,GAAGD,CAAI;CAC7B;CAIA,MAAM,GAAM,GAAO,MAAQ;EACzB,IAAMC,IAAIP,EAAK;EACf,OAAO;GACL,QAAQW,EAAgBJ,EAAE,MAAMK,CAAkB,MAAM;GACxD,GAAGQ,EAASJ,EAAkBT,EAAE,MAAM,GAAGY,GAAK,KAAK;EACrD;CACF;CAEA,SAAS,GAAM,GAAM,MACnBE,EAAcf,GAAMU,EAAmBhB,EAAK,KAAoC,MAAM,GAAGmB,CAAG;AAChG,GAEajB,oBAAc,IAAI,IAAI;CAAC;CAAQ;CAAW;CAAW;AAAM,CAAC;AAEzE,SAAgBO,EACd,GACA,GACM;CACN,QAAQF,EAAE,OAAV;EACE,KAAK,WACH,OAAOe,EAAYC,CAAC;EACtB,KAAK,WAAW;GACd,IAAMC,IAAKD,EAAE,IAAIA,EAAE,QAAQ,GACrBE,IAAKF,EAAE,IAAIA,EAAE,SAAS,GACtBG,IAAI,KAAK,IAAIH,EAAE,OAAOA,EAAE,MAAM,IAAI;GACxC,OAAOI,EAAmB;IAAE,GAAGH;IAAI,GAAGC;GAAG,GAAGC,GAAGnB,EAAE,SAAS,CAAC;EAC7D;EACA,KAAK,QAAQ;GACX,IAAMiB,IAAKD,EAAE,IAAIA,EAAE,QAAQ,GACrBE,IAAKF,EAAE,IAAIA,EAAE,SAAS,GACtBG,IAAI,KAAK,IAAIH,EAAE,OAAOA,EAAE,MAAM,IAAI;GACxC,OAAOK,EAAS;IAAE,GAAGJ;IAAI,GAAGC;GAAG,GAAGC,GAAGnB,EAAE,UAAU,CAAC;EACpD;EAEA,SACE,OAAO;GAAE,MAAM;GAAQ,GAAGgB,EAAE;GAAG,GAAGA,EAAE;GAAG,OAAOA,EAAE;GAAO,QAAQA,EAAE;EAAO;CAC5E;AACF"}
+{"version":3,"file":"shapePainter.js","names":[],"sources":["../../../src/canvas/nodeShapes/shapePainter.ts"],"sourcesContent":["import {\n  ellipsePath,\n  regularPolygonPath,\n  starPath,\n  type Path\n} from '@weasel-js/geom';\nimport type { Stroke, Fill } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { RectPose } from 'core/scene/types';\nimport { commandFill, commandStroke } from '@weasel-js/renderer';\nimport { DEFAULT_SHAPE_FILL } from '../../util/paint';\nimport { PAINT_SLOT } from './memo';\nimport { inkReach, withAnimatedVertexColors, resolveNodeFill, resolveNodeStroke } from './nodePaint';\nimport { paintsPose, poseBoxBounds } from './poseBox';\nimport { outsetPoseBox, strokedPoseBox } from './strokedBounds';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\n/** Built-in shape dispatcher — matches when `data.shape` names a kit-known\n *  shape kind. Computes both paint and silhouette from the pose so consumer\n *  scenes can declare clipping/rendering directly in JSON without\n *  registering a custom painter. */\nexport const SHAPE_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:shape',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const s = (node.data as { shape?: string } | null)?.shape;\n    return s != null && SHAPE_KINDS.has(s);\n  },\n  // Memoized: a pure function of `(data, pose)`, and `pathForShape` builds a\n  // fresh `Uint8Array` + `Float32Array` for every ellipse, polygon and star.\n  // See PAINT_SLOT.\n  paint: (node, pose, ctx) => withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {\n    const d = node.data as { shape: string; fill?: Fill | null; stroke?: Stroke | null; sides?: number; points?: number };\n    const path = pathForShape(d, pose);\n    const declaredFill = resolveNodeFill(d.fill, DEFAULT_SHAPE_FILL);\n    const shapeFill = declaredFill && commandFill(declaredFill, pose);\n    const strokeSpec = resolveNodeStroke(d.stroke);\n    const stroke = strokeSpec && commandStroke(strokeSpec, pose);\n    return [{\n      kind: 'path',\n      path,\n      ...(shapeFill ? { fill: shapeFill } : {}),\n      ...(stroke ? { stroke } : {}),\n    }];\n  }), ctx),\n  silhouette: (node, pose) => {\n    const d = node.data as { shape: string; sides?: number; points?: number };\n    return pathForShape(d, pose);\n  },\n  // `paint` above emits the default fill when none is declared, so a shape\n  // is filled unless it declares `fill: null` — unlike `kit:path`, it has no\n  // implicit stroke-only form.\n  ink: (node, _pose, ctx) => {\n    const d = node.data as { fill?: Fill | null; stroke?: Stroke | null };\n    return {\n      filled: resolveNodeFill(d.fill, DEFAULT_SHAPE_FILL) !== null,\n      ...inkReach(resolveNodeStroke(d.stroke), ctx?.scale),\n    };\n  },\n  // Every shape kind is inscribed in the pose box.\n  bounds: (node, pose, ctx) =>\n    poseBoxBounds(pose, resolveNodeStroke((node.data as { stroke?: Stroke | null }).stroke), ctx),\n  // A rect's or an ellipse's stroke reaches its box evenly; a polygon's or a\n  // star's corners are sharper than a right angle, so their miters are measured.\n  drawnBounds: (node, pose, ctx) => {\n    const d = node.data as { shape: string; stroke?: Stroke | null; sides?: number; points?: number };\n    const stroke = resolveNodeStroke(d.stroke);\n    return d.shape === 'polygon' || d.shape === 'star'\n      ? strokedPoseBox(node, pose, stroke, ctx, (at) => pathForShape(d, at))\n      : outsetPoseBox(pose, stroke, ctx);\n  },\n};\n\nexport const SHAPE_KINDS = new Set(['rect', 'ellipse', 'polygon', 'star']);\n\nexport function pathForShape(\n  d: { shape: string; sides?: number; points?: number },\n  p: RectPose,\n): Path {\n  switch (d.shape) {\n    case 'ellipse':\n      return ellipsePath(p);\n    case 'polygon': {\n      const cx = p.x + p.width / 2;\n      const cy = p.y + p.height / 2;\n      const r = Math.min(p.width, p.height) / 2;\n      return regularPolygonPath({ x: cx, y: cy }, r, d.sides ?? 6);\n    }\n    case 'star': {\n      const cx = p.x + p.width / 2;\n      const cy = p.y + p.height / 2;\n      const r = Math.min(p.width, p.height) / 2;\n      return starPath({ x: cx, y: cy }, r, d.points ?? 5);\n    }\n    case 'rect':\n    default:\n      return { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAsBA,IAAa,gBAAmD;CAC9D,IAAI;CACJ,UAAU,SAAS;EACjB,IAAI,CAAC,WAAW,KAAK,IAAI,GAAG,OAAO;EACnC,MAAM,IAAK,KAAK,MAAoC;EACpD,OAAO,KAAK,QAAQ,YAAY,IAAI,CAAC;CACvC;CAIA,QAAQ,MAAM,MAAM,QAAQ,yBAAyB,SAAS,MAAM,YAAY,YAAY;EAC1F,MAAM,IAAI,KAAK;EACf,MAAM,OAAO,aAAa,GAAG,IAAI;EACjC,MAAM,eAAe,gBAAgB,EAAE,MAAM,kBAAkB;EAC/D,MAAM,YAAY,gBAAgB,YAAY,cAAc,IAAI;EAChE,MAAM,aAAa,kBAAkB,EAAE,MAAM;EAC7C,MAAM,SAAS,cAAc,cAAc,YAAY,IAAI;EAC3D,OAAO,CAAC;GACN,MAAM;GACN;GACA,GAAI,YAAY,EAAE,MAAM,UAAU,IAAI,CAAC;GACvC,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;EAC7B,CAAC;CACH,CAAC,GAAG,GAAG;CACP,aAAa,MAAM,SAAS;EAC1B,MAAM,IAAI,KAAK;EACf,OAAO,aAAa,GAAG,IAAI;CAC7B;CAIA,MAAM,MAAM,OAAO,QAAQ;EACzB,MAAM,IAAI,KAAK;EACf,OAAO;GACL,QAAQ,gBAAgB,EAAE,MAAM,kBAAkB,MAAM;GACxD,GAAG,SAAS,kBAAkB,EAAE,MAAM,GAAG,KAAK,KAAK;EACrD;CACF;CAEA,SAAS,MAAM,MAAM,QACnB,cAAc,MAAM,kBAAmB,KAAK,KAAoC,MAAM,GAAG,GAAG;CAG9F,cAAc,MAAM,MAAM,QAAQ;EAChC,MAAM,IAAI,KAAK;EACf,MAAM,SAAS,kBAAkB,EAAE,MAAM;EACzC,OAAO,EAAE,UAAU,aAAa,EAAE,UAAU,SACxC,eAAe,MAAM,MAAM,QAAQ,MAAM,OAAO,aAAa,GAAG,EAAE,CAAC,IACnE,cAAc,MAAM,QAAQ,GAAG;CACrC;AACF;AAEA,IAAa,8BAAc,IAAI,IAAI;CAAC;CAAQ;CAAW;CAAW;AAAM,CAAC;AAEzE,SAAgB,aACd,GACA,GACM;CACN,QAAQ,EAAE,OAAV;EACE,KAAK,WACH,OAAO,YAAY,CAAC;EACtB,KAAK,WAAW;GACd,MAAM,KAAK,EAAE,IAAI,EAAE,QAAQ;GAC3B,MAAM,KAAK,EAAE,IAAI,EAAE,SAAS;GAC5B,MAAM,IAAI,KAAK,IAAI,EAAE,OAAO,EAAE,MAAM,IAAI;GACxC,OAAO,mBAAmB;IAAE,GAAG;IAAI,GAAG;GAAG,GAAG,GAAG,EAAE,SAAS,CAAC;EAC7D;EACA,KAAK,QAAQ;GACX,MAAM,KAAK,EAAE,IAAI,EAAE,QAAQ;GAC3B,MAAM,KAAK,EAAE,IAAI,EAAE,SAAS;GAC5B,MAAM,IAAI,KAAK,IAAI,EAAE,OAAO,EAAE,MAAM,IAAI;GACxC,OAAO,SAAS;IAAE,GAAG;IAAI,GAAG;GAAG,GAAG,GAAG,EAAE,UAAU,CAAC;EACpD;EAEA,SACE,OAAO;GAAE,MAAM;GAAQ,GAAG,EAAE;GAAG,GAAG,EAAE;GAAG,OAAO,EAAE;GAAO,QAAQ,EAAE;EAAO;CAC5E;AACF"}

package/dist/canvas/nodeShapes/strokedBounds.js

@@ -0,0 +1,177 @@
+import { nodeMemo } from "../../core/scene/nodeMemo.js";
+import { strokeOutsetPerAxis } from "./nodePaint.js";
+import { resolveStrokeLengths } from "@weasel-js/renderer";
+import { boundsOfPath } from "@weasel-js/geom";
+import { scaleVertexWidth } from "@weasel-js/paint";
+import { markerHeads, resolveStrokeWidth, strokeInsets, tessellateStroke } from "@weasel-js/stroke";
+
+//#region src/canvas/nodeShapes/strokedBounds.ts
+/**
+* The box `stroke` covers along `path`, from the ribbon the renderer draws:
+* joins, caps, dashes, and per-vertex widths as tessellated, and marker heads.
+* An inner stroke stays inside the path, and an outer one reaches as far out as
+* a centered stroke twice as wide. `null` when the stroke paints nothing.
+*
+* With `screen` (see `NodeInkCtx.screen`), each screen-sized part is built the
+* way the renderer builds it under that map, so a `{ px }` stroke is exact in
+* every direction; without, it is resolved at `scale`.
+*/
+function strokedBounds(path, stroke, scale, screen) {
+	const { sized, spaces } = screen ? onScreen(path, stroke, screen) : atScale(stroke, scale);
+	const width = resolveStrokeWidth(sized.width ?? 1, 1);
+	if (!(width > 0)) return null;
+	const box = new Box();
+	const align = stroke.align ?? "center";
+	if (align !== "inner") {
+		const k = align === "outer" ? 2 : 1;
+		const insets = strokeInsets(sized, width);
+		const v = tessellateStroke(path, {
+			...sized,
+			width: width * k,
+			align: "center",
+			vertexWidths: stroke.vertexWidths?.map((w) => scaleVertexWidth(w, k))
+		}, {
+			startInset: insetIn(insets.start, spaces.start, spaces.ribbon),
+			endInset: insetIn(insets.end, spaces.end, spaces.ribbon),
+			...spaces.ribbon ? { metric: spaces.ribbon.metric } : {}
+		}).vertices;
+		for (let i = 0; i + 1 < v.length; i += 2) box.add(v[i], v[i + 1], 0);
+	}
+	for (const { entry, path: head, size } of markerHeads(path, sized, width, void 0, spaces)) {
+		const b = boundsOfPath(head);
+		const pad = entry.outline ? entry.outline.width * size / 2 : 0;
+		box.add(b.x, b.y, pad);
+		box.add(b.x + b.width, b.y + b.height, pad);
+	}
+	return box.bounds();
+}
+function atScale(stroke, scale) {
+	return {
+		sized: {
+			...stroke,
+			width: resolveStrokeWidth(stroke.width ?? 1, scale)
+		},
+		spaces: {}
+	};
+}
+function onScreen(path, stroke, [a, b, c, d]) {
+	const transform = new Float32Array([
+		a,
+		b,
+		0,
+		c,
+		d,
+		0,
+		0,
+		0,
+		1
+	]);
+	const { cmd, spaces } = resolveStrokeLengths(transform, {
+		kind: "path",
+		path,
+		stroke
+	});
+	return {
+		sized: cmd.stroke,
+		spaces
+	};
+}
+/** `length`, measured in `head`'s space, as the tessellator reads it. */
+function insetIn(length, head, ribbon) {
+	return head?.metric === ribbon?.metric ? length : {
+		length,
+		metric: head?.metric ?? null
+	};
+}
+var Box = class {
+	x0 = Infinity;
+	y0 = Infinity;
+	x1 = -Infinity;
+	y1 = -Infinity;
+	add(x, y, pad) {
+		this.x0 = Math.min(this.x0, x - pad);
+		this.y0 = Math.min(this.y0, y - pad);
+		this.x1 = Math.max(this.x1, x + pad);
+		this.y1 = Math.max(this.y1, y + pad);
+	}
+	bounds() {
+		return this.x0 === Infinity ? null : {
+			x: this.x0,
+			y: this.y0,
+			width: this.x1 - this.x0,
+			height: this.y1 - this.y0
+		};
+	}
+};
+var DRAWN_SLOT = "shape:drawn";
+/** The pose box grown by a uniform stroke outset: exact for a rect or an
+*  ellipse, whose stroke reaches the same distance past the box on every side. */
+function outsetPoseBox(pose, stroke, ctx) {
+	const box = normalized(pose);
+	if (!stroke) return box;
+	const r = strokeOutsetPerAxis(stroke, ctx);
+	return {
+		x: box.x - r.x,
+		y: box.y - r.y,
+		width: box.width + 2 * r.x,
+		height: box.height + 2 * r.y
+	};
+}
+/**
+* The pose box together with what `stroke` covers along `pathAt(pose)`,
+* memoized per node on the pose's size and the view scale: a drag that only
+* moves the node does not stroke it again.
+*/
+function strokedPoseBox(node, pose, stroke, ctx, pathAt) {
+	const box = normalized(pose);
+	if (stroke === null) return box;
+	const scale = ctx?.scale ?? 1;
+	const screen = ctx?.screen;
+	const held = nodeMemo(node, DRAWN_SLOT, void 0, () => ({
+		width: NaN,
+		height: NaN,
+		scale: NaN,
+		screen: void 0,
+		box: null
+	}));
+	if (held.width !== pose.width || held.height !== pose.height || held.scale !== scale || !sameMap(held.screen, screen)) {
+		const at = {
+			x: 0,
+			y: 0,
+			width: pose.width,
+			height: pose.height
+		};
+		held.width = pose.width;
+		held.height = pose.height;
+		held.scale = scale;
+		held.screen = screen;
+		held.box = strokedBounds(pathAt(at), stroke, scale, screen);
+	}
+	if (held.box === null) return box;
+	const x0 = Math.min(box.x, pose.x + held.box.x);
+	const y0 = Math.min(box.y, pose.y + held.box.y);
+	const x1 = Math.max(box.x + box.width, pose.x + held.box.x + held.box.width);
+	const y1 = Math.max(box.y + box.height, pose.y + held.box.y + held.box.height);
+	return {
+		x: x0,
+		y: y0,
+		width: x1 - x0,
+		height: y1 - y0
+	};
+}
+function sameMap(m, n) {
+	if (m === n) return true;
+	return !!m && !!n && m[0] === n[0] && m[1] === n[1] && m[2] === n[2] && m[3] === n[3];
+}
+function normalized(pose) {
+	return {
+		x: Math.min(pose.x, pose.x + pose.width),
+		y: Math.min(pose.y, pose.y + pose.height),
+		width: Math.abs(pose.width),
+		height: Math.abs(pose.height)
+	};
+}
+
+//#endregion
+export { outsetPoseBox, strokedBounds, strokedPoseBox };
+//# sourceMappingURL=strokedBounds.js.map

package/dist/canvas/nodeShapes/strokedBounds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strokedBounds.js","names":[],"sources":["../../../src/canvas/nodeShapes/strokedBounds.ts"],"sourcesContent":["import { boundsOfPath, type Path } from '@weasel-js/geom';\nimport { scaleVertexWidth, type Stroke } from '@weasel-js/paint';\nimport {\n  markerHeads, resolveStrokeWidth, strokeInsets, tessellateStroke,\n  type InsetLength, type ScreenSpace, type StrokeSpaces,\n} from '@weasel-js/stroke';\nimport { resolveStrokeLengths, type GlMat3, type StrokedPathCommand } from '@weasel-js/renderer';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { NodeInkCtx } from 'canvas/NodeShape';\nimport { strokeOutsetPerAxis } from './nodePaint';\n\n/**\n * The box `stroke` covers along `path`, from the ribbon the renderer draws:\n * joins, caps, dashes, and per-vertex widths as tessellated, and marker heads.\n * An inner stroke stays inside the path, and an outer one reaches as far out as\n * a centered stroke twice as wide. `null` when the stroke paints nothing.\n *\n * With `screen` (see `NodeInkCtx.screen`), each screen-sized part is built the\n * way the renderer builds it under that map, so a `{ px }` stroke is exact in\n * every direction; without, it is resolved at `scale`.\n */\nexport function strokedBounds(path: Path, stroke: Stroke, scale: number, screen?: ScreenMap): Bounds | null {\n  const { sized, spaces } = screen ? onScreen(path, stroke, screen) : atScale(stroke, scale);\n  const width = resolveStrokeWidth(sized.width ?? 1, 1);\n  if (!(width > 0)) return null;\n  const box = new Box();\n  const align = stroke.align ?? 'center';\n  if (align !== 'inner') {\n    const k = align === 'outer' ? 2 : 1;\n    const insets = strokeInsets(sized, width);\n    const mesh = tessellateStroke(\n      path,\n      { ...sized, width: width * k, align: 'center', vertexWidths: stroke.vertexWidths?.map((w) => scaleVertexWidth(w, k)) },\n      {\n        startInset: insetIn(insets.start, spaces.start, spaces.ribbon),\n        endInset: insetIn(insets.end, spaces.end, spaces.ribbon),\n        ...(spaces.ribbon ? { metric: spaces.ribbon.metric } : {}),\n      },\n    );\n    const v = mesh.vertices;\n    for (let i = 0; i + 1 < v.length; i += 2) box.add(v[i]!, v[i + 1]!, 0);\n  }\n  for (const { entry, path: head, size } of markerHeads(path, sized, width, undefined, spaces)) {\n    const b = boundsOfPath(head);\n    const pad = entry.outline ? (entry.outline.width * size) / 2 : 0;\n    box.add(b.x, b.y, pad);\n    box.add(b.x + b.width, b.y + b.height, pad);\n  }\n  return box.bounds();\n}\n\n/** `[a, b, c, d]`: a frame's linear map to screen pixels. */\nexport type ScreenMap = readonly [number, number, number, number];\n\nfunction atScale(stroke: Stroke, scale: number): { sized: Stroke; spaces: StrokeSpaces } {\n  return { sized: { ...stroke, width: resolveStrokeWidth(stroke.width ?? 1, scale) }, spaces: {} };\n}\n\nfunction onScreen(path: Path, stroke: Stroke, [a, b, c, d]: ScreenMap): { sized: Stroke; spaces: StrokeSpaces } {\n  const transform = new Float32Array([a, b, 0, c, d, 0, 0, 0, 1]) as GlMat3;\n  const { cmd, spaces } = resolveStrokeLengths(transform, { kind: 'path', path, stroke } as StrokedPathCommand);\n  return { sized: cmd.stroke as Stroke, spaces };\n}\n\n/** `length`, measured in `head`'s space, as the tessellator reads it. */\nfunction insetIn(length: number, head: ScreenSpace | undefined, ribbon: ScreenSpace | undefined): InsetLength {\n  return head?.metric === ribbon?.metric ? length : { length, metric: head?.metric ?? null };\n}\n\nclass Box {\n  private x0 = Infinity;\n  private y0 = Infinity;\n  private x1 = -Infinity;\n  private y1 = -Infinity;\n  add(x: number, y: number, pad: number): void {\n    this.x0 = Math.min(this.x0, x - pad);\n    this.y0 = Math.min(this.y0, y - pad);\n    this.x1 = Math.max(this.x1, x + pad);\n    this.y1 = Math.max(this.y1, y + pad);\n  }\n  bounds(): Bounds | null {\n    return this.x0 === Infinity ? null : { x: this.x0, y: this.y0, width: this.x1 - this.x0, height: this.y1 - this.y0 };\n  }\n}\n\nconst DRAWN_SLOT = 'shape:drawn';\n\ninterface DrawnRecord {\n  width: number;\n  height: number;\n  scale: number;\n  screen: ScreenMap | undefined;\n  /** Relative to the pose's top-left, so a move reuses it. */\n  box: Bounds | null;\n}\n\n/** The pose box grown by a uniform stroke outset: exact for a rect or an\n *  ellipse, whose stroke reaches the same distance past the box on every side. */\nexport function outsetPoseBox(pose: Bounds, stroke: Stroke | null, ctx: NodeInkCtx | undefined): Bounds {\n  const box = normalized(pose);\n  if (!stroke) return box;\n  const r = strokeOutsetPerAxis(stroke, ctx);\n  return { x: box.x - r.x, y: box.y - r.y, width: box.width + 2 * r.x, height: box.height + 2 * r.y };\n}\n\n/**\n * The pose box together with what `stroke` covers along `pathAt(pose)`,\n * memoized per node on the pose's size and the view scale: a drag that only\n * moves the node does not stroke it again.\n */\nexport function strokedPoseBox(\n  node: { data?: unknown },\n  pose: Bounds,\n  stroke: Stroke | null,\n  ctx: NodeInkCtx | undefined,\n  pathAt: (pose: Bounds) => Path,\n): Bounds {\n  const box = normalized(pose);\n  if (stroke === null) return box;\n  const scale = ctx?.scale ?? 1;\n  const screen = ctx?.screen;\n  const held = nodeMemo(node, DRAWN_SLOT, undefined, (): DrawnRecord => ({ width: NaN, height: NaN, scale: NaN, screen: undefined, box: null }));\n  if (held.width !== pose.width || held.height !== pose.height || held.scale !== scale || !sameMap(held.screen, screen)) {\n    const at = { x: 0, y: 0, width: pose.width, height: pose.height };\n    held.width = pose.width;\n    held.height = pose.height;\n    held.scale = scale;\n    held.screen = screen;\n    held.box = strokedBounds(pathAt(at), stroke, scale, screen);\n  }\n  if (held.box === null) return box;\n  const x0 = Math.min(box.x, pose.x + held.box.x);\n  const y0 = Math.min(box.y, pose.y + held.box.y);\n  const x1 = Math.max(box.x + box.width, pose.x + held.box.x + held.box.width);\n  const y1 = Math.max(box.y + box.height, pose.y + held.box.y + held.box.height);\n  return { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };\n}\n\nfunction sameMap(m: ScreenMap | undefined, n: ScreenMap | undefined): boolean {\n  if (m === n) return true;\n  return !!m && !!n && m[0] === n[0] && m[1] === n[1] && m[2] === n[2] && m[3] === n[3];\n}\n\nfunction normalized(pose: Bounds): Bounds {\n  return {\n    x: Math.min(pose.x, pose.x + pose.width),\n    y: Math.min(pose.y, pose.y + pose.height),\n    width: Math.abs(pose.width),\n    height: Math.abs(pose.height),\n  };\n}\n"],"mappings":"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"}

package/dist/canvas/nodeShapes/textPainter.js

@@ -1,55 +1,188 @@
-import { nodeMemo as e } from "../../core/scene/nodeMemo.js";
-import { PAINT_SLOT as t } from "./memo.js";
-import { inkReach as n, resolveNodeStroke as r } from "./nodePaint.js";
-import { paintsPose as i } from "./poseBox.js";
-import { textCommandFromPose as a } from "@weasel-js/renderer";
-import { PATH_L as o, PATH_M as s, PATH_Z as c } from "@weasel-js/geom";
-import { textLineBoxes as l } from "@weasel-js/text";
+import { nodeMemo } from "../../core/scene/nodeMemo.js";
+import { PAINT_SLOT } from "./memo.js";
+import { inkReach, resolveNodeFill, resolveNodeStroke, strokeOutsetPerAxis } from "./nodePaint.js";
+import { paintsPose } from "./poseBox.js";
+import { commandFill, textCommandFromPose } from "@weasel-js/renderer";
+import { PATH_L, PATH_M, PATH_Z } from "@weasel-js/geom";
+import { textLineBoxes } from "@weasel-js/text";
+
 //#region src/canvas/nodeShapes/textPainter.ts
-function u(e, t) {
+/** `cmd` cut to `box`: a group whose clip is the box as a rect, which the
+*  renderer cuts on the CPU when the frame keeps it axis-aligned. */
+function clippedToBox(cmd, box) {
 	return {
-		x: t.x,
-		y: t.y,
-		width: t.width,
-		height: t.height,
-		text: e.text,
-		runs: e.runs,
-		style: e.style,
-		fill: e.fill,
-		stroke: r(e.stroke) ?? void 0,
-		verticalAlign: e.verticalAlign
+		kind: "group",
+		clip: {
+			kind: "rect",
+			x: box.x,
+			y: box.y,
+			width: box.width,
+			height: box.height
+		},
+		children: [cmd]
 	};
 }
-var d = {
+/** The box a text node's lines lay out in: its pose box, inset by
+*  `data.padding` and never past its center. */
+function textBoxOf(d, p) {
+	const pad = Math.max(0, d.padding ?? 0);
+	const px = Math.min(pad, p.width / 2);
+	const py = Math.min(pad, p.height / 2);
+	return {
+		x: p.x + px,
+		y: p.y + py,
+		width: p.width - 2 * px,
+		height: p.height - 2 * py
+	};
+}
+/** A `kit:text` node as the `TextPose` every text consumer reads, in the box
+*  {@link textBoxOf} insets. The stroke goes through the same resolver every
+*  other node kind's does, so one carrying no paint is dropped here rather
+*  than throwing in the renderer. */
+function textPoseOf(d, p) {
+	return {
+		...textBoxOf(d, p),
+		text: d.text,
+		runs: d.runs,
+		style: d.style,
+		fill: d.fill,
+		stroke: resolveNodeStroke(d.stroke) ?? void 0,
+		verticalAlign: d.verticalAlign
+	};
+}
+var TEXT_PAINTER = {
 	id: "kit:text",
-	matches: (e) => i(e.pose) ? e.data?.text != null : !1,
-	paint: (n, r) => e(n, t, r, () => [a(u(n.data, r))]),
-	silhouette: (e, t) => {
-		let n = l(u(e.data, t));
-		return n.length === 0 ? null : f(n);
+	snapsToBox: true,
+	matches: (node) => {
+		if (!paintsPose(node.pose)) return false;
+		return node.data?.text != null;
+	},
+	paint: (node, pose) => nodeMemo(node, PAINT_SLOT, pose, () => {
+		const d = node.data;
+		const laid = textCommandFromPose(textPoseOf(d, pose));
+		const text = d.overflow === "clip" ? clippedToBox(laid, pose) : laid;
+		const bg = resolveNodeFill(d.background, null);
+		if (!bg) return [text];
+		const fill = commandFill(bg, pose);
+		return [{
+			kind: "path",
+			path: {
+				kind: "rect",
+				x: pose.x,
+				y: pose.y,
+				width: pose.width,
+				height: pose.height
+			},
+			...fill ? { fill } : {}
+		}, text];
+	}),
+	silhouette: (node, pose) => {
+		const d = node.data;
+		if (resolveNodeFill(d.background, null)) return {
+			kind: "rect",
+			x: pose.x,
+			y: pose.y,
+			width: pose.width,
+			height: pose.height
+		};
+		const lines = textLineBoxes(textPoseOf(d, pose));
+		const boxes = d.overflow === "clip" ? cutRects(lines, pose) : lines;
+		if (boxes.length === 0) return null;
+		return rectsToPath(boxes);
 	},
-	ink: (e, t, i) => {
-		let a = e.data;
+	ink: (node, _pose, ctx) => {
+		const d = node.data;
 		return {
-			filled: !0,
-			...n(r(a.stroke), i?.scale)
+			filled: true,
+			...inkReach(resolveNodeStroke(d.stroke), ctx?.scale)
 		};
+	},
+	drawnBounds: (node, pose, ctx) => {
+		const d = node.data;
+		const stroke = resolveNodeStroke(d.stroke);
+		return stroke ? strokedLinesBox(pose, textLineBoxes(textPoseOf(d, pose)), strokeOutsetPerAxis(stroke, ctx)) : null;
 	}
 };
-function f(e) {
-	let t = new Uint8Array(e.length * 6), n = new Float32Array(e.length * 10), r = 0, i = 0;
-	for (let a of e) {
-		let { x: e, y: l, width: u, height: d } = a;
-		t[i++] = s, n[r++] = e, n[r++] = l, t[i++] = o, n[r++] = e + u, n[r++] = l, t[i++] = o, n[r++] = e + u, n[r++] = l + d, t[i++] = o, n[r++] = e, n[r++] = l + d, t[i++] = o, n[r++] = e, n[r++] = l, t[i++] = c;
+/** Each of `rects` cut to `box`, leaving out any it does not overlap. */
+function cutRects(rects, box) {
+	const out = [];
+	for (const r of rects) {
+		const x0 = Math.max(r.x, box.x);
+		const y0 = Math.max(r.y, box.y);
+		const x1 = Math.min(r.x + r.width, box.x + box.width);
+		const y1 = Math.min(r.y + r.height, box.y + box.height);
+		if (x1 > x0 && y1 > y0) out.push({
+			x: x0,
+			y: y0,
+			width: x1 - x0,
+			height: y1 - y0
+		});
+	}
+	return out;
+}
+/**
+* The layout box grown where a stroked line reaches it: each line box, cut to
+* the layout box, then outset by the stroke's reach. A line that overflows the
+* layout box is left to it — the layout box is what a text node claims.
+*/
+function strokedLinesBox(pose, lines, reach) {
+	if (!(reach.x > 0 || reach.y > 0)) return null;
+	let x0 = pose.x, y0 = pose.y, x1 = pose.x + pose.width, y1 = pose.y + pose.height;
+	for (const l of lines) {
+		const lx0 = Math.max(l.x, pose.x), ly0 = Math.max(l.y, pose.y);
+		const lx1 = Math.min(l.x + l.width, pose.x + pose.width), ly1 = Math.min(l.y + l.height, pose.y + pose.height);
+		if (lx1 <= lx0 || ly1 <= ly0) continue;
+		x0 = Math.min(x0, lx0 - reach.x);
+		y0 = Math.min(y0, ly0 - reach.y);
+		x1 = Math.max(x1, lx1 + reach.x);
+		y1 = Math.max(y1, ly1 + reach.y);
+	}
+	return {
+		x: x0,
+		y: y0,
+		width: x1 - x0,
+		height: y1 - y0
+	};
+}
+/**
+* Union of axis-aligned rects as one multi-contour `PolygonPath`.
+*
+* Every contour winds the same way, so `'nonzero'` reads overlapping rects as
+* covered rather than punching a hole where two lines happen to overlap —
+* which they do the moment `lineHeight` drops below 1.
+*/
+function rectsToPath(rects) {
+	const commands = new Uint8Array(rects.length * 6);
+	const coords = new Float32Array(rects.length * 10);
+	let ci = 0;
+	let cmd = 0;
+	for (const r of rects) {
+		const { x, y, width: w, height: h } = r;
+		commands[cmd++] = PATH_M;
+		coords[ci++] = x;
+		coords[ci++] = y;
+		commands[cmd++] = PATH_L;
+		coords[ci++] = x + w;
+		coords[ci++] = y;
+		commands[cmd++] = PATH_L;
+		coords[ci++] = x + w;
+		coords[ci++] = y + h;
+		commands[cmd++] = PATH_L;
+		coords[ci++] = x;
+		coords[ci++] = y + h;
+		commands[cmd++] = PATH_L;
+		coords[ci++] = x;
+		coords[ci++] = y;
+		commands[cmd++] = PATH_Z;
 	}
 	return {
 		kind: "polygon",
-		commands: t,
-		coords: n,
+		commands,
+		coords,
 		fillRule: "nonzero"
 	};
 }
-//#endregion
-export { d as TEXT_PAINTER, f as rectsToPath, u as textPoseOf };
 
+//#endregion
+export { TEXT_PAINTER, clippedToBox, rectsToPath, textBoxOf, textPoseOf };
 //# sourceMappingURL=textPainter.js.map

package/dist/canvas/nodeShapes/textPainter.js.map

@@ -1 +1 @@
-{"version":3,"file":"textPainter.js","names":["textPoseOf","p","d","resolveNodeStroke","TEXT_PAINTER","paintsPose","node","nodeMemo","PAINT_SLOT","pose","textCommandFromPose","boxes","textLineBoxes","rectsToPath","inkReach","ctx","commands","rects","coords","ci","cmd","r","w","h","PATH_M","x","y","PATH_L","PATH_Z"],"sources":["../../../src/canvas/nodeShapes/textPainter.ts"],"sourcesContent":["import {\n  PATH_L,\n  PATH_M,\n  PATH_Z,\n  type PolygonPath\n} from '@weasel-js/geom';\nimport type { Stroke, Fill } from '@weasel-js/paint';\nimport type { StyledRun, TextPose, TextStyle, TextVerticalAlign } from '@weasel-js/text';\nimport { textLineBoxes } from '@weasel-js/text';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { RectPose } from 'core/scene/types';\nimport { textCommandFromPose } from '@weasel-js/renderer';\nimport { PAINT_SLOT } from './memo';\nimport { inkReach, resolveNodeStroke } from './nodePaint';\nimport { paintsPose } from './poseBox';\n\n/** The `data` a `kit:text` node carries. */\nexport interface TextNodeData {\n  text: string;\n  style?: TextStyle;\n  runs?: readonly StyledRun[];\n  fill?: Fill | null;\n  stroke?: Stroke | null;\n  verticalAlign?: TextVerticalAlign;\n}\n\n/** A `kit:text` node as the `TextPose` every text consumer reads. The stroke\n *  goes through the same resolver every other node kind's does, so one\n *  carrying no paint is dropped here rather than throwing in the renderer. */\nexport function textPoseOf(d: TextNodeData, p: RectPose): TextPose {\n  return {\n    x: p.x, y: p.y, width: p.width, height: p.height,\n    text: d.text,\n    runs: d.runs as StyledRun[] | undefined,\n    style: d.style,\n    fill: d.fill,\n    stroke: resolveNodeStroke(d.stroke) ?? undefined,\n    verticalAlign: d.verticalAlign,\n  };\n}\n\nexport const TEXT_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:text',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const d = node.data as { text?: string } | null;\n    return d?.text != null;\n  },\n  // Memoized because the renderer's layout cache keys on the `ResolvedRun[]` array\n  // identity: a fresh runs array per frame would leave that cache missing on every\n  // draw. Both resolvers are pure style merging — no font reads — so `(data, pose)` is\n  // the whole key. See PAINT_SLOT.\n  //\n  // `y` is the top of the first line box, not a baseline — see `TextDrawCommand.y`.\n  paint: (node, pose) => nodeMemo(node, PAINT_SLOT, pose, () => [\n    textCommandFromPose(textPoseOf(node.data as TextNodeData, pose)),\n  ]),\n  // The pose is a layout box, not a bounding box: the union of the line boxes is what\n  // the node actually covers, so picking, lasso, and clipping stop grabbing blank space.\n  //\n  // `null` rather than an empty path when there are no non-blank lines: a caller\n  // reading \"no silhouette\" falls back to the pose rect, which keeps an empty text\n  // node pickable.\n  silhouette: (node, pose) => {\n    const boxes = textLineBoxes(textPoseOf(node.data as TextNodeData, pose));\n    if (boxes.length === 0) return null;\n    return rectsToPath(boxes);\n  },\n  // `filled` is unconditional, `data.fill: null` included: the silhouette above is line\n  // boxes, not glyph ink, so reporting outline-only text as unfilled would leave it\n  // grabbable within a stroke width of a box edge and nowhere near the letters.\n  ink: (node, _pose, ctx) => {\n    const d = node.data as { stroke?: Stroke | null };\n    return { filled: true, ...inkReach(resolveNodeStroke(d.stroke), ctx?.scale) };\n  },\n};\n\n/**\n * Union of axis-aligned rects as one multi-contour `PolygonPath`.\n *\n * Every contour winds the same way, so `'nonzero'` reads overlapping rects as\n * covered rather than punching a hole where two lines happen to overlap —\n * which they do the moment `lineHeight` drops below 1.\n */\nexport function rectsToPath(rects: readonly { x: number; y: number; width: number; height: number }[]): PolygonPath {\n  const commands = new Uint8Array(rects.length * 6);\n  const coords = new Float32Array(rects.length * 10);\n  let ci = 0;\n  let cmd = 0;\n  for (const r of rects) {\n    const { x, y, width: w, height: h } = r;\n    commands[cmd++] = PATH_M; coords[ci++] = x; coords[ci++] = y;\n    commands[cmd++] = PATH_L; coords[ci++] = x + w; coords[ci++] = y;\n    commands[cmd++] = PATH_L; coords[ci++] = x + w; coords[ci++] = y + h;\n    commands[cmd++] = PATH_L; coords[ci++] = x; coords[ci++] = y + h;\n    commands[cmd++] = PATH_L; coords[ci++] = x; coords[ci++] = y;\n    commands[cmd++] = PATH_Z;\n  }\n  return { kind: 'polygon', commands, coords, fillRule: 'nonzero' };\n}\n"],"mappings":";;;;;;;;AA8BA,SAAgBA,EAAW,GAAiB,GAAuB;CACjE,OAAO;EACL,GAAGC,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;EAC1C,MAAMC,EAAE;EACR,MAAMA,EAAE;EACR,OAAOA,EAAE;EACT,MAAMA,EAAE;EACR,QAAQC,EAAkBD,EAAE,MAAM,KAAK,KAAA;EACvC,eAAeA,EAAE;CACnB;AACF;AAEA,IAAaE,IAAkD;CAC7D,IAAI;CACJ,UAAU,MACHC,EAAWC,EAAK,IAAI,IACfA,EAAK,MACL,QAAQ,OAFiB;CAUrC,QAAQ,GAAM,MAASC,EAASD,GAAME,GAAYC,SAAY,CAC5DC,EAAoBV,EAAWM,EAAK,MAAsBG,CAAI,CAAC,CACjE,CAAC;CAOD,aAAa,GAAM,MAAS;EAC1B,IAAME,IAAQC,EAAcZ,EAAWM,EAAK,MAAsBG,CAAI,CAAC;EAEvE,OADIE,EAAM,WAAW,IAAU,OACxBE,EAAYF,CAAK;CAC1B;CAIA,MAAM,GAAM,GAAO,MAAQ;EACzB,IAAMT,IAAII,EAAK;EACf,OAAO;GAAE,QAAQ;GAAM,GAAGQ,EAASX,EAAkBD,EAAE,MAAM,GAAGa,GAAK,KAAK;EAAE;CAC9E;AACF;AASA,SAAgBF,EAAY,GAAwF;CAClH,IAAMG,IAAW,IAAI,WAAWC,EAAM,SAAS,CAAC,GAC1CC,IAAS,IAAI,aAAaD,EAAM,SAAS,EAAE,GAC7CE,IAAK,GACLC,IAAM;CACV,KAAK,IAAMC,KAAKJ,GAAO;EACrB,IAAM,EAAE,MAAG,MAAG,OAAOK,GAAG,QAAQC,MAAMF;EAMtC,AALA,EAAS,OAASG,GAAQ,EAAO,OAAQC,GAAG,EAAO,OAAQC,GAC3D,EAAS,OAASC,GAAQ,EAAO,OAAQF,IAAIH,GAAG,EAAO,OAAQI,GAC/D,EAAS,OAASC,GAAQ,EAAO,OAAQF,IAAIH,GAAG,EAAO,OAAQI,IAAIH,GACnE,EAAS,OAASI,GAAQ,EAAO,OAAQF,GAAG,EAAO,OAAQC,IAAIH,GAC/D,EAAS,OAASI,GAAQ,EAAO,OAAQF,GAAG,EAAO,OAAQC,GAC3D,EAAS,OAASE;CACpB;CACA,OAAO;EAAE,MAAM;EAAW;EAAU;EAAQ,UAAU;CAAU;AAClE"}
+{"version":3,"file":"textPainter.js","names":[],"sources":["../../../src/canvas/nodeShapes/textPainter.ts"],"sourcesContent":["import {\n  PATH_L,\n  PATH_M,\n  PATH_Z,\n  type PolygonPath,\n  type Rect,\n} from '@weasel-js/geom';\nimport type { Stroke, Fill } from '@weasel-js/paint';\nimport type { StyledRun, TextPose, TextStyle, TextVerticalAlign } from '@weasel-js/text';\nimport { textLineBoxes } from '@weasel-js/text';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { RectPose } from 'core/scene/types';\nimport { commandFill, textCommandFromPose, type DrawCommand } from '@weasel-js/renderer';\nimport { PAINT_SLOT } from './memo';\nimport { inkReach, resolveNodeFill, resolveNodeStroke, strokeOutsetPerAxis } from './nodePaint';\nimport { paintsPose } from './poseBox';\n\n/** The `data` a `kit:text` node carries. */\nexport interface TextNodeData {\n  text: string;\n  style?: TextStyle;\n  runs?: readonly StyledRun[];\n  fill?: Fill | null;\n  stroke?: Stroke | null;\n  verticalAlign?: TextVerticalAlign;\n  /** Paint for the whole pose box, drawn under the glyphs. `fill` is the\n   *  glyphs' own paint, so a box behind them needs a key of its own. */\n  background?: Fill | null;\n  /** World units between the pose box and the box the text lays out in, on\n   *  every side. */\n  padding?: number;\n  /** What happens to text that runs past the pose box: `'visible'` (the\n   *  default) draws it there, `'clip'` cuts it at the box's edge. */\n  overflow?: TextOverflow;\n}\n\n/** How a text node treats lines that run past its box. */\nexport type TextOverflow = 'visible' | 'clip';\n\ntype Box = { x: number; y: number; width: number; height: number };\n\n/** `cmd` cut to `box`: a group whose clip is the box as a rect, which the\n *  renderer cuts on the CPU when the frame keeps it axis-aligned. */\nexport function clippedToBox(cmd: DrawCommand, box: Box): DrawCommand {\n  return {\n    kind: 'group',\n    clip: { kind: 'rect', x: box.x, y: box.y, width: box.width, height: box.height },\n    children: [cmd],\n  };\n}\n\n/** The box a text node's lines lay out in: its pose box, inset by\n *  `data.padding` and never past its center. */\nexport function textBoxOf(\n  d: Pick<TextNodeData, 'padding'>,\n  p: RectPose,\n): { x: number; y: number; width: number; height: number } {\n  const pad = Math.max(0, d.padding ?? 0);\n  const px = Math.min(pad, p.width / 2);\n  const py = Math.min(pad, p.height / 2);\n  return { x: p.x + px, y: p.y + py, width: p.width - 2 * px, height: p.height - 2 * py };\n}\n\n/** A `kit:text` node as the `TextPose` every text consumer reads, in the box\n *  {@link textBoxOf} insets. The stroke goes through the same resolver every\n *  other node kind's does, so one carrying no paint is dropped here rather\n *  than throwing in the renderer. */\nexport function textPoseOf(d: TextNodeData, p: RectPose): TextPose {\n  return {\n    ...textBoxOf(d, p),\n    text: d.text,\n    runs: d.runs as StyledRun[] | undefined,\n    style: d.style,\n    fill: d.fill,\n    stroke: resolveNodeStroke(d.stroke) ?? undefined,\n    verticalAlign: d.verticalAlign,\n  };\n}\n\nexport const TEXT_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:text',\n  snapsToBox: true,\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const d = node.data as { text?: string } | null;\n    return d?.text != null;\n  },\n  // Memoized because the renderer's layout cache keys on the `ResolvedRun[]` array\n  // identity: a fresh runs array per frame would leave that cache missing on every\n  // draw. Both resolvers are pure style merging — no font reads — so `(data, pose)` is\n  // the whole key. See PAINT_SLOT.\n  //\n  // `y` is the top of the first line box, not a baseline — see `TextDrawCommand.y`.\n  paint: (node, pose) => nodeMemo(node, PAINT_SLOT, pose, (): DrawCommand[] => {\n    const d = node.data as TextNodeData;\n    const laid = textCommandFromPose(textPoseOf(d, pose));\n    const text = d.overflow === 'clip' ? clippedToBox(laid, pose) : laid;\n    const bg = resolveNodeFill(d.background, null);\n    if (!bg) return [text];\n    const fill = commandFill(bg, pose);\n    return [\n      { kind: 'path', path: { kind: 'rect', x: pose.x, y: pose.y, width: pose.width, height: pose.height }, ...(fill ? { fill } : {}) },\n      text,\n    ];\n  }),\n  // The pose is a layout box, not a bounding box: the union of the line boxes is what\n  // the node actually covers, so picking, lasso, and clipping stop grabbing blank space.\n  //\n  // `null` rather than an empty path when there are no non-blank lines: a caller\n  // reading \"no silhouette\" falls back to the pose rect, which keeps an empty text\n  // node pickable.\n  //\n  // A background is ink across the whole box, so a node with one is its box.\n  // A clipped node's lines are cut to the box, as they are drawn.\n  silhouette: (node, pose) => {\n    const d = node.data as TextNodeData;\n    if (resolveNodeFill(d.background, null)) {\n      return { kind: 'rect', x: pose.x, y: pose.y, width: pose.width, height: pose.height };\n    }\n    const lines = textLineBoxes(textPoseOf(d, pose));\n    const boxes = d.overflow === 'clip' ? cutRects(lines, pose) : lines;\n    if (boxes.length === 0) return null;\n    return rectsToPath(boxes);\n  },\n  // `filled` is unconditional, `data.fill: null` included: the silhouette above is line\n  // boxes, not glyph ink, so reporting outline-only text as unfilled would leave it\n  // grabbable within a stroke width of a box edge and nowhere near the letters.\n  ink: (node, _pose, ctx) => {\n    const d = node.data as { stroke?: Stroke | null };\n    return { filled: true, ...inkReach(resolveNodeStroke(d.stroke), ctx?.scale) };\n  },\n  drawnBounds: (node, pose, ctx) => {\n    const d = node.data as TextNodeData;\n    const stroke = resolveNodeStroke(d.stroke);\n    return stroke ? strokedLinesBox(pose, textLineBoxes(textPoseOf(d, pose)), strokeOutsetPerAxis(stroke, ctx)) : null;\n  },\n};\n\n/** Each of `rects` cut to `box`, leaving out any it does not overlap. */\nfunction cutRects(rects: readonly Box[], box: Box): Box[] {\n  const out: Box[] = [];\n  for (const r of rects) {\n    const x0 = Math.max(r.x, box.x);\n    const y0 = Math.max(r.y, box.y);\n    const x1 = Math.min(r.x + r.width, box.x + box.width);\n    const y1 = Math.min(r.y + r.height, box.y + box.height);\n    if (x1 > x0 && y1 > y0) out.push({ x: x0, y: y0, width: x1 - x0, height: y1 - y0 });\n  }\n  return out;\n}\n\n/**\n * The layout box grown where a stroked line reaches it: each line box, cut to\n * the layout box, then outset by the stroke's reach. A line that overflows the\n * layout box is left to it — the layout box is what a text node claims.\n */\nfunction strokedLinesBox(pose: RectPose, lines: readonly Rect[], reach: { x: number; y: number }): Rect | null {\n  if (!(reach.x > 0 || reach.y > 0)) return null;\n  let x0 = pose.x, y0 = pose.y, x1 = pose.x + pose.width, y1 = pose.y + pose.height;\n  for (const l of lines) {\n    const lx0 = Math.max(l.x, pose.x), ly0 = Math.max(l.y, pose.y);\n    const lx1 = Math.min(l.x + l.width, pose.x + pose.width), ly1 = Math.min(l.y + l.height, pose.y + pose.height);\n    if (lx1 <= lx0 || ly1 <= ly0) continue;\n    x0 = Math.min(x0, lx0 - reach.x); y0 = Math.min(y0, ly0 - reach.y);\n    x1 = Math.max(x1, lx1 + reach.x); y1 = Math.max(y1, ly1 + reach.y);\n  }\n  return { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };\n}\n\n/**\n * Union of axis-aligned rects as one multi-contour `PolygonPath`.\n *\n * Every contour winds the same way, so `'nonzero'` reads overlapping rects as\n * covered rather than punching a hole where two lines happen to overlap —\n * which they do the moment `lineHeight` drops below 1.\n */\nexport function rectsToPath(rects: readonly { x: number; y: number; width: number; height: number }[]): PolygonPath {\n  const commands = new Uint8Array(rects.length * 6);\n  const coords = new Float32Array(rects.length * 10);\n  let ci = 0;\n  let cmd = 0;\n  for (const r of rects) {\n    const { x, y, width: w, height: h } = r;\n    commands[cmd++] = PATH_M; coords[ci++] = x; coords[ci++] = y;\n    commands[cmd++] = PATH_L; coords[ci++] = x + w; coords[ci++] = y;\n    commands[cmd++] = PATH_L; coords[ci++] = x + w; coords[ci++] = y + h;\n    commands[cmd++] = PATH_L; coords[ci++] = x; coords[ci++] = y + h;\n    commands[cmd++] = PATH_L; coords[ci++] = x; coords[ci++] = y;\n    commands[cmd++] = PATH_Z;\n  }\n  return { kind: 'polygon', commands, coords, fillRule: 'nonzero' };\n}\n"],"mappings":"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"}