@weasel-js/core 1.10.0 → 1.11.0

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

@@ -1 +1 @@
-{"version":3,"file":"pathPainter.js","names":["PATH_PAINTER","paintsPose","node","ctx","withAnimatedVertexColors","nodeMemo","PAINT_SLOT","pose","d","projected","pathInPoseFrame","declared","strokeSpec","pathPaintOf","fill","commandFill","stroke","commandStroke","DERIVED_PAINTER","inkReach","poseBoxBounds","resolveNodeStroke"],"sources":["../../../src/canvas/nodeShapes/pathPainter.ts"],"sourcesContent":["import type {\n  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 { pathInPoseFrame } from '@weasel-js/geom';\nimport { commandFill, commandStroke } from '@weasel-js/renderer';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { DERIVED_PAINTER } from './derivedPainter';\nimport { PAINT_SLOT } from './memo';\nimport { inkReach, pathPaintOf, withAnimatedVertexColors, resolveNodeStroke } from './nodePaint';\nimport { paintsPose, poseBoxBounds } from './poseBox';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\nexport const PATH_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:path',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const d = node.data as { path?: Path } | null;\n    return d?.path != null;\n  },\n  // Memoized: a pure function of `(data, pose)`, and `pathInPoseFrame`\n  // allocates on every call but the identity (`kind: 'rect'`) branch. See\n  // PAINT_SLOT.\n  paint: (node, pose, ctx) => ctx?.derivedPath != null\n    // A pose override's path stands in for `data.path`, already where it is drawn.\n    ? DERIVED_PAINTER.paint(node, pose, ctx)\n    : withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {\n    const d = node.data as {\n      path: Path;\n      fill?: Fill | null;\n      stroke?: Stroke | null;\n      vertexColors?: number[];\n    };\n    const projected = pathInPoseFrame(d.path, pose);\n    const { fill: declared, stroke: strokeSpec } = pathPaintOf(d);\n    // The pose is baked into `projected` rather than emitted as a transform,\n    // so a box-relative gradient has to be baked onto the same box here or\n    // it would arrive in the renderer referring to a frame that never exists.\n    const fill = declared && commandFill(declared, pose);\n    const stroke = strokeSpec && commandStroke(strokeSpec, pose);\n    const cmd: DrawCommand = {\n      kind: 'path',\n      path: projected,\n      ...(fill ? { fill } : {}),\n      ...(fill && d.vertexColors ? { vertexColors: d.vertexColors } : {}),\n      ...(stroke ? { stroke } : {}),\n    };\n    return [cmd];\n  }), ctx),\n  silhouette: (node, pose, ctx) => {\n    if (ctx?.derivedPath != null) return ctx.derivedPath;\n    const d = node.data as { path: Path };\n    return pathInPoseFrame(d.path, pose);\n  },\n  ink: (node, _pose, ctx) => {\n    const d = node.data as {\n      fill?: Fill | null;\n      stroke?: Stroke | null;\n    };\n    const { fill, stroke } = pathPaintOf(d);\n    return { filled: fill !== null, ...inkReach(stroke ?? null, ctx?.scale) };\n  },\n  // `pathInPoseFrame` fits the path's own bounds to the pose box.\n  bounds: (node, pose, ctx) =>\n    poseBoxBounds(pose, resolveNodeStroke((node.data as { stroke?: Stroke | null }).stroke), ctx),\n};\n"],"mappings":";;;;;;;;AAgBA,IAAaA,IAAkD;CAC7D,IAAI;CACJ,UAAU,MACHC,EAAWC,EAAK,IAAI,IACfA,EAAK,MACL,QAAQ,OAFiB;CAOrC,QAAQ,GAAM,GAAM,MAAQC,GAAK,eAAe,OAG5CC,EAAyBC,EAASH,GAAMI,GAAYC,SAAY;EAClE,IAAMC,IAAIN,EAAK,MAMTO,IAAYC,EAAgBF,EAAE,MAAMD,CAAI,GACxC,EAAE,MAAMI,GAAU,QAAQC,MAAeC,EAAYL,CAAC,GAItDM,IAAOH,KAAYI,EAAYJ,GAAUJ,CAAI,GAC7CS,IAASJ,KAAcK,EAAcL,GAAYL,CAAI;EAQ3D,OAAO,CAAC;GANN,MAAM;GACN,MAAME;GACN,GAAIK,IAAO,EAAE,QAAK,IAAI,CAAC;GACvB,GAAIA,KAAQN,EAAE,eAAe,EAAE,cAAcA,EAAE,aAAa,IAAI,CAAC;GACjE,GAAIQ,IAAS,EAAE,UAAO,IAAI,CAAC;EAErB,CAAG;CACb,CAAC,GAAGb,CAAG,IAvBHe,EAAgB,MAAMhB,GAAMK,GAAMJ,CAAG;CAwBzC,aAAa,GAAM,GAAM,MAAQ;EAC/B,IAAIA,GAAK,eAAe,MAAM,OAAOA,EAAI;EACzC,IAAMK,IAAIN,EAAK;EACf,OAAOQ,EAAgBF,EAAE,MAAMD,CAAI;CACrC;CACA,MAAM,GAAM,GAAO,MAAQ;EACzB,IAAMC,IAAIN,EAAK,MAIT,EAAE,SAAM,cAAWW,EAAYL,CAAC;EACtC,OAAO;GAAE,QAAQM,MAAS;GAAM,GAAGK,EAASH,KAAU,MAAMb,GAAK,KAAK;EAAE;CAC1E;CAEA,SAAS,GAAM,GAAM,MACnBiB,EAAcb,GAAMc,EAAmBnB,EAAK,KAAoC,MAAM,GAAGC,CAAG;AAChG"}
+{"version":3,"file":"pathPainter.js","names":[],"sources":["../../../src/canvas/nodeShapes/pathPainter.ts"],"sourcesContent":["import type {\n  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 { pathInPoseFrame } from '@weasel-js/geom';\nimport { commandFill, commandStroke } from '@weasel-js/renderer';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { DERIVED_PAINTER } from './derivedPainter';\nimport { PAINT_SLOT } from './memo';\nimport { inkReach, pathPaintOf, withAnimatedVertexColors, resolveNodeStroke } from './nodePaint';\nimport { paintsPose, poseBoxBounds } from './poseBox';\nimport { strokedPoseBox } from './strokedBounds';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\nexport const PATH_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:path',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const d = node.data as { path?: Path } | null;\n    return d?.path != null;\n  },\n  // Memoized: a pure function of `(data, pose)`, and `pathInPoseFrame`\n  // allocates on every call but the identity (`kind: 'rect'`) branch. See\n  // PAINT_SLOT.\n  paint: (node, pose, ctx) => ctx?.derivedPath != null\n    // A pose override's path stands in for `data.path`, already where it is drawn.\n    ? DERIVED_PAINTER.paint(node, pose, ctx)\n    : withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {\n    const d = node.data as {\n      path: Path;\n      fill?: Fill | null;\n      stroke?: Stroke | null;\n      vertexColors?: number[];\n    };\n    const projected = pathInPoseFrame(d.path, pose);\n    const { fill: declared, stroke: strokeSpec } = pathPaintOf(d);\n    // The pose is baked into `projected` rather than emitted as a transform,\n    // so a box-relative gradient has to be baked onto the same box here or\n    // it would arrive in the renderer referring to a frame that never exists.\n    const fill = declared && commandFill(declared, pose);\n    const stroke = strokeSpec && commandStroke(strokeSpec, pose);\n    const cmd: DrawCommand = {\n      kind: 'path',\n      path: projected,\n      ...(fill ? { fill } : {}),\n      ...(fill && d.vertexColors ? { vertexColors: d.vertexColors } : {}),\n      ...(stroke ? { stroke } : {}),\n    };\n    return [cmd];\n  }), ctx),\n  silhouette: (node, pose, ctx) => {\n    if (ctx?.derivedPath != null) return ctx.derivedPath;\n    const d = node.data as { path: Path };\n    return pathInPoseFrame(d.path, pose);\n  },\n  ink: (node, _pose, ctx) => {\n    const d = node.data as {\n      fill?: Fill | null;\n      stroke?: Stroke | null;\n    };\n    const { fill, stroke } = pathPaintOf(d);\n    return { filled: fill !== null, ...inkReach(stroke ?? null, ctx?.scale) };\n  },\n  // `pathInPoseFrame` fits the path's own bounds to the pose box.\n  bounds: (node, pose, ctx) =>\n    poseBoxBounds(pose, resolveNodeStroke((node.data as { stroke?: Stroke | null }).stroke), ctx),\n  drawnBounds: (node, pose, ctx) => {\n    const d = node.data as { path: Path; stroke?: Stroke | null };\n    return strokedPoseBox(node, pose, resolveNodeStroke(d.stroke), ctx, (at) => pathInPoseFrame(d.path, at));\n  },\n};\n"],"mappings":";;;;;;;;;;AAiBA,IAAa,eAAkD;CAC7D,IAAI;CACJ,UAAU,SAAS;EACjB,IAAI,CAAC,WAAW,KAAK,IAAI,GAAG,OAAO;EAEnC,OADU,KAAK,MACL,QAAQ;CACpB;CAIA,QAAQ,MAAM,MAAM,QAAQ,KAAK,eAAe,OAE5C,gBAAgB,MAAM,MAAM,MAAM,GAAG,IACrC,yBAAyB,SAAS,MAAM,YAAY,YAAY;EAClE,MAAM,IAAI,KAAK;EAMf,MAAM,YAAY,gBAAgB,EAAE,MAAM,IAAI;EAC9C,MAAM,EAAE,MAAM,UAAU,QAAQ,eAAe,YAAY,CAAC;EAI5D,MAAM,OAAO,YAAY,YAAY,UAAU,IAAI;EACnD,MAAM,SAAS,cAAc,cAAc,YAAY,IAAI;EAQ3D,OAAO,CAAC;GANN,MAAM;GACN,MAAM;GACN,GAAI,OAAO,EAAE,KAAK,IAAI,CAAC;GACvB,GAAI,QAAQ,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,IAAI,CAAC;GACjE,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;EAErB,CAAG;CACb,CAAC,GAAG,GAAG;CACP,aAAa,MAAM,MAAM,QAAQ;EAC/B,IAAI,KAAK,eAAe,MAAM,OAAO,IAAI;EACzC,MAAM,IAAI,KAAK;EACf,OAAO,gBAAgB,EAAE,MAAM,IAAI;CACrC;CACA,MAAM,MAAM,OAAO,QAAQ;EACzB,MAAM,IAAI,KAAK;EAIf,MAAM,EAAE,MAAM,WAAW,YAAY,CAAC;EACtC,OAAO;GAAE,QAAQ,SAAS;GAAM,GAAG,SAAS,UAAU,MAAM,KAAK,KAAK;EAAE;CAC1E;CAEA,SAAS,MAAM,MAAM,QACnB,cAAc,MAAM,kBAAmB,KAAK,KAAoC,MAAM,GAAG,GAAG;CAC9F,cAAc,MAAM,MAAM,QAAQ;EAChC,MAAM,IAAI,KAAK;EACf,OAAO,eAAe,MAAM,MAAM,kBAAkB,EAAE,MAAM,GAAG,MAAM,OAAO,gBAAgB,EAAE,MAAM,EAAE,CAAC;CACzG;AACF"}

package/dist/canvas/nodeShapes/poseBox.js

@@ -1,20 +1,27 @@
-import { isRectPose as e } from "../../core/geometry/autoPoseDescriptor.js";
-import { strokeReachAt as t } from "@weasel-js/renderer";
+import { isRectPose } from "../../core/geometry/autoPoseDescriptor.js";
+import { strokeReachAt } from "@weasel-js/renderer";
+
 //#region src/canvas/nodeShapes/poseBox.ts
-function n(t) {
-	return t === void 0 || e(t);
+/** Whether a built-in painter can read this pose. A node that declares none
+*  passes: the pose is then the caller's argument, not the node's. */
+function paintsPose(pose) {
+	return pose === void 0 || isRectPose(pose);
 }
-function r(n, r, i) {
-	if (!e(n)) return null;
-	let a = r ? t(r, i?.scale ?? 1, i?.leastScale) : 0, o = Math.min(n.x, n.x + n.width), s = Math.min(n.y, n.y + n.height);
+/** The pose rect grown by how far `stroke` can paint outside it — the paint
+*  box of every built-in painter whose geometry the pose box contains. */
+function poseBoxBounds(pose, stroke, ctx) {
+	if (!isRectPose(pose)) return null;
+	const reach = stroke ? strokeReachAt(stroke, ctx?.scale ?? 1, ctx?.leastScale) : 0;
+	const x = Math.min(pose.x, pose.x + pose.width);
+	const y = Math.min(pose.y, pose.y + pose.height);
 	return {
-		x: o - a,
-		y: s - a,
-		width: Math.abs(n.width) + 2 * a,
-		height: Math.abs(n.height) + 2 * a
+		x: x - reach,
+		y: y - reach,
+		width: Math.abs(pose.width) + 2 * reach,
+		height: Math.abs(pose.height) + 2 * reach
 	};
 }
-//#endregion
-export { n as paintsPose, r as poseBoxBounds };
 
+//#endregion
+export { paintsPose, poseBoxBounds };
 //# sourceMappingURL=poseBox.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"poseBox.js","names":["paintsPose","pose","isRectPose","poseBoxBounds","reach","stroke","strokeReachAt","ctx","x","y"],"sources":["../../../src/canvas/nodeShapes/poseBox.ts"],"sourcesContent":["import type { Stroke } from '@weasel-js/paint';\nimport type { NodeInkCtx } from 'canvas/NodeShape';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { isRectPose } from 'core/geometry/autoPoseDescriptor';\nimport { strokeReachAt } from '@weasel-js/renderer';\n\n/** Whether a built-in painter can read this pose. A node that declares none\n *  passes: the pose is then the caller's argument, not the node's. */\nexport function paintsPose(pose: unknown): boolean {\n  return pose === undefined || isRectPose(pose);\n}\n\n/** The pose rect grown by how far `stroke` can paint outside it — the paint\n *  box of every built-in painter whose geometry the pose box contains. */\nexport function poseBoxBounds(pose: unknown, stroke: Stroke | null, ctx: NodeInkCtx | undefined): Bounds | null {\n  if (!isRectPose(pose)) return null;\n  const reach = stroke ? strokeReachAt(stroke, ctx?.scale ?? 1, ctx?.leastScale) : 0;\n  const x = Math.min(pose.x, pose.x + pose.width);\n  const y = Math.min(pose.y, pose.y + pose.height);\n  return {\n    x: x - reach,\n    y: y - reach,\n    width: Math.abs(pose.width) + 2 * reach,\n    height: Math.abs(pose.height) + 2 * reach,\n  };\n}\n"],"mappings":";;;AAQA,SAAgBA,EAAW,GAAwB;CACjD,OAAOC,MAAS,KAAA,KAAaC,EAAWD,CAAI;AAC9C;AAIA,SAAgBE,EAAc,GAAe,GAAuB,GAA4C;CAC9G,IAAI,CAACD,EAAWD,CAAI,GAAG,OAAO;CAC9B,IAAMG,IAAQC,IAASC,EAAcD,GAAQE,GAAK,SAAS,GAAGA,GAAK,UAAU,IAAI,GAC3EC,IAAI,KAAK,IAAIP,EAAK,GAAGA,EAAK,IAAIA,EAAK,KAAK,GACxCQ,IAAI,KAAK,IAAIR,EAAK,GAAGA,EAAK,IAAIA,EAAK,MAAM;CAC/C,OAAO;EACL,GAAGO,IAAIJ;EACP,GAAGK,IAAIL;EACP,OAAO,KAAK,IAAIH,EAAK,KAAK,IAAI,IAAIG;EAClC,QAAQ,KAAK,IAAIH,EAAK,MAAM,IAAI,IAAIG;CACtC;AACF"}
+{"version":3,"file":"poseBox.js","names":[],"sources":["../../../src/canvas/nodeShapes/poseBox.ts"],"sourcesContent":["import type { Stroke } from '@weasel-js/paint';\nimport type { NodeInkCtx } from 'canvas/NodeShape';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { isRectPose } from 'core/geometry/autoPoseDescriptor';\nimport { strokeReachAt } from '@weasel-js/renderer';\n\n/** Whether a built-in painter can read this pose. A node that declares none\n *  passes: the pose is then the caller's argument, not the node's. */\nexport function paintsPose(pose: unknown): boolean {\n  return pose === undefined || isRectPose(pose);\n}\n\n/** The pose rect grown by how far `stroke` can paint outside it — the paint\n *  box of every built-in painter whose geometry the pose box contains. */\nexport function poseBoxBounds(pose: unknown, stroke: Stroke | null, ctx: NodeInkCtx | undefined): Bounds | null {\n  if (!isRectPose(pose)) return null;\n  const reach = stroke ? strokeReachAt(stroke, ctx?.scale ?? 1, ctx?.leastScale) : 0;\n  const x = Math.min(pose.x, pose.x + pose.width);\n  const y = Math.min(pose.y, pose.y + pose.height);\n  return {\n    x: x - reach,\n    y: y - reach,\n    width: Math.abs(pose.width) + 2 * reach,\n    height: Math.abs(pose.height) + 2 * reach,\n  };\n}\n"],"mappings":";;;;;;AAQA,SAAgB,WAAW,MAAwB;CACjD,OAAO,SAAS,UAAa,WAAW,IAAI;AAC9C;;;AAIA,SAAgB,cAAc,MAAe,QAAuB,KAA4C;CAC9G,IAAI,CAAC,WAAW,IAAI,GAAG,OAAO;CAC9B,MAAM,QAAQ,SAAS,cAAc,QAAQ,KAAK,SAAS,GAAG,KAAK,UAAU,IAAI;CACjF,MAAM,IAAI,KAAK,IAAI,KAAK,GAAG,KAAK,IAAI,KAAK,KAAK;CAC9C,MAAM,IAAI,KAAK,IAAI,KAAK,GAAG,KAAK,IAAI,KAAK,MAAM;CAC/C,OAAO;EACL,GAAG,IAAI;EACP,GAAG,IAAI;EACP,OAAO,KAAK,IAAI,KAAK,KAAK,IAAI,IAAI;EAClC,QAAQ,KAAK,IAAI,KAAK,MAAM,IAAI,IAAI;CACtC;AACF"}

package/dist/canvas/nodeShapes/rectFallbackPainter.js

@@ -1,38 +1,42 @@
-import { DEFAULT_SHAPE_FILL as e } from "../../util/paint.js";
-import { resolveNodeFill as t } from "./nodePaint.js";
-import { paintsPose as n, poseBoxBounds as r } from "./poseBox.js";
-import { commandFill as i } from "@weasel-js/renderer";
+import { DEFAULT_SHAPE_FILL } from "../../util/paint.js";
+import { resolveNodeFill } from "./nodePaint.js";
+import { paintsPose, poseBoxBounds } from "./poseBox.js";
+import { commandFill } from "@weasel-js/renderer";
+
 //#region src/canvas/nodeShapes/rectFallbackPainter.ts
-var a = {
+var RECT_FALLBACK_PAINTER = {
 	id: "kit:rect-fallback",
-	matches: (e) => n(e.pose),
-	paint: (n, r) => {
-		let a = n.data, o = r, s = t(a?.fill, e), c = s && i(s, o);
+	matches: (node) => paintsPose(node.pose),
+	paint: (node, pose) => {
+		const d = node.data;
+		const p = pose;
+		const declared = resolveNodeFill(d?.fill, DEFAULT_SHAPE_FILL);
+		const fill = declared && commandFill(declared, p);
 		return [{
 			kind: "path",
 			path: {
 				kind: "rect",
-				x: o.x,
-				y: o.y,
-				width: o.width,
-				height: o.height
+				x: p.x,
+				y: p.y,
+				width: p.width,
+				height: p.height
 			},
-			...c ? { fill: c } : {}
+			...fill ? { fill } : {}
 		}];
 	},
-	silhouette: (e, t) => {
-		let n = t;
+	silhouette: (_node, pose) => {
+		const p = pose;
 		return {
 			kind: "rect",
-			x: n.x,
-			y: n.y,
-			width: n.width,
-			height: n.height
+			x: p.x,
+			y: p.y,
+			width: p.width,
+			height: p.height
 		};
 	},
-	bounds: (e, t) => r(t, null, void 0)
+	bounds: (_node, pose) => poseBoxBounds(pose, null, void 0)
 };
-//#endregion
-export { a as RECT_FALLBACK_PAINTER };
 
+//#endregion
+export { RECT_FALLBACK_PAINTER };
 //# sourceMappingURL=rectFallbackPainter.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"rectFallbackPainter.js","names":["RECT_FALLBACK_PAINTER","paintsPose","node","d","p","pose","declared","resolveNodeFill","DEFAULT_SHAPE_FILL","fill","commandFill","poseBoxBounds"],"sources":["../../../src/canvas/nodeShapes/rectFallbackPainter.ts"],"sourcesContent":["import type { Fill } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport type { RectPose } from 'core/scene/types';\nimport { commandFill } from '@weasel-js/renderer';\nimport { DEFAULT_SHAPE_FILL } from '../../util/paint';\nimport { resolveNodeFill } from './nodePaint';\nimport { paintsPose, poseBoxBounds } from './poseBox';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\nexport const RECT_FALLBACK_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  // Last-resort painter — matches any rect-posed node, so it must be\n  // registered last within `'normal'`. Consumers who want a different\n  // fallback should register their own painter at `'high'` priority and let\n  // this one never fire (or unregister it explicitly).\n  id: 'kit:rect-fallback',\n  matches: (node) => paintsPose(node.pose),\n  paint: (node, pose) => {\n    const d = node.data as { fill?: Fill | null } | null;\n    const p = pose;\n    const declared = resolveNodeFill(d?.fill, DEFAULT_SHAPE_FILL);\n    const fill = declared && commandFill(declared, p);\n    return [{\n      kind: 'path',\n      path: { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height },\n      ...(fill ? { fill } : {}),\n    }];\n  },\n  silhouette: (_node, pose) => {\n    const p = pose;\n    return { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height };\n  },\n  bounds: (_node, pose) => poseBoxBounds(pose, null, undefined),\n};\n"],"mappings":";;;;;AASA,IAAaA,IAA2D;CAKtE,IAAI;CACJ,UAAU,MAASC,EAAWC,EAAK,IAAI;CACvC,QAAQ,GAAM,MAAS;EACrB,IAAMC,IAAID,EAAK,MACTE,IAAIC,GACJC,IAAWC,EAAgBJ,GAAG,MAAMK,CAAkB,GACtDC,IAAOH,KAAYI,EAAYJ,GAAUF,CAAC;EAChD,OAAO,CAAC;GACN,MAAM;GACN,MAAM;IAAE,MAAM;IAAQ,GAAGA,EAAE;IAAG,GAAGA,EAAE;IAAG,OAAOA,EAAE;IAAO,QAAQA,EAAE;GAAO;GACvE,GAAIK,IAAO,EAAE,QAAK,IAAI,CAAC;EACzB,CAAC;CACH;CACA,aAAa,GAAO,MAAS;EAC3B,IAAML,IAAIC;EACV,OAAO;GAAE,MAAM;GAAQ,GAAGD,EAAE;GAAG,GAAGA,EAAE;GAAG,OAAOA,EAAE;GAAO,QAAQA,EAAE;EAAO;CAC1E;CACA,SAAS,GAAO,MAASO,EAAcN,GAAM,MAAM,KAAA,CAAS;AAC9D"}
+{"version":3,"file":"rectFallbackPainter.js","names":[],"sources":["../../../src/canvas/nodeShapes/rectFallbackPainter.ts"],"sourcesContent":["import type { Fill } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport type { RectPose } from 'core/scene/types';\nimport { commandFill } from '@weasel-js/renderer';\nimport { DEFAULT_SHAPE_FILL } from '../../util/paint';\nimport { resolveNodeFill } from './nodePaint';\nimport { paintsPose, poseBoxBounds } from './poseBox';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\nexport const RECT_FALLBACK_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  // Last-resort painter — matches any rect-posed node, so it must be\n  // registered last within `'normal'`. Consumers who want a different\n  // fallback should register their own painter at `'high'` priority and let\n  // this one never fire (or unregister it explicitly).\n  id: 'kit:rect-fallback',\n  matches: (node) => paintsPose(node.pose),\n  paint: (node, pose) => {\n    const d = node.data as { fill?: Fill | null } | null;\n    const p = pose;\n    const declared = resolveNodeFill(d?.fill, DEFAULT_SHAPE_FILL);\n    const fill = declared && commandFill(declared, p);\n    return [{\n      kind: 'path',\n      path: { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height },\n      ...(fill ? { fill } : {}),\n    }];\n  },\n  silhouette: (_node, pose) => {\n    const p = pose;\n    return { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height };\n  },\n  bounds: (_node, pose) => poseBoxBounds(pose, null, undefined),\n};\n"],"mappings":";;;;;;AASA,IAAa,wBAA2D;CAKtE,IAAI;CACJ,UAAU,SAAS,WAAW,KAAK,IAAI;CACvC,QAAQ,MAAM,SAAS;EACrB,MAAM,IAAI,KAAK;EACf,MAAM,IAAI;EACV,MAAM,WAAW,gBAAgB,GAAG,MAAM,kBAAkB;EAC5D,MAAM,OAAO,YAAY,YAAY,UAAU,CAAC;EAChD,OAAO,CAAC;GACN,MAAM;GACN,MAAM;IAAE,MAAM;IAAQ,GAAG,EAAE;IAAG,GAAG,EAAE;IAAG,OAAO,EAAE;IAAO,QAAQ,EAAE;GAAO;GACvE,GAAI,OAAO,EAAE,KAAK,IAAI,CAAC;EACzB,CAAC;CACH;CACA,aAAa,OAAO,SAAS;EAC3B,MAAM,IAAI;EACV,OAAO;GAAE,MAAM;GAAQ,GAAG,EAAE;GAAG,GAAG,EAAE;GAAG,OAAO,EAAE;GAAO,QAAQ,EAAE;EAAO;CAC1E;CACA,SAAS,OAAO,SAAS,cAAc,MAAM,MAAM,MAAS;AAC9D"}

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 { paintsPose, poseBoxBounds } from "./poseBox.js";
+import { outsetPoseBox, strokedPoseBox } from "./strokedBounds.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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"}