@weasel-js/core 1.7.0 → 1.7.1

package/dist/canvas/SceneCanvas/defaultNodeProperties.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultNodeProperties.js","names":["rotationDegreesUnit","prefUnit","ANGLE_RADIANS","strokeWidthOf","w","stroke","strokeDashEncoding","strokeDashStyleOf","dash","style","dashForStrokeStyle","markerEncoding","ref","value","italicEncoding","stored","on","alignEncoding","direction","resolveAlign","edge","markerOptions","listMarkers","m","shapeSchema","opts","defaultNodeProperties","KIT_SHAPE_KINDS","name","inferredNodeProperties","inferredNodeRouting"],"sources":["../../../src/canvas/SceneCanvas/defaultNodeProperties.ts"],"sourcesContent":["import { inferredNodeRouting } from './defaultNodeRouting';\nimport { KIT_SHAPE_KINDS } from 'core/shapeKinds';\nimport { listMarkers } from 'core/strokeMarkers';\nimport { dashForStrokeStyle, strokeDashStyleOf } from '@weasel-js/paint';\nimport { resolveAlign, type TextAlign } from '@weasel-js/text';\nimport type { NodePropertiesEntry } from 'core/scene/NodeProperties';\nimport { ANGLE_RADIANS } from '@weasel-js/quantity';\nimport { prefUnit, type ToolPrefBooleanEncoding, type ToolPrefEnumEncoding, type ToolPrefGroup, type ToolPrefNumberUnit } from 'tools/prefs';\n\n/** Radians-stored / degrees-shown conversion for `pose.rotation` leaves.\n *  Display rounds to 0.1° so a canonical radian value doesn't render as\n *  a 15-digit float. */\nexport const rotationDegreesUnit: ToolPrefNumberUnit = prefUnit(ANGLE_RADIANS, 'deg', {\n  precision: 1,\n  suffix: '°',\n});\n\n/** `Stroke.width` off a partly-typed stroke object, or `undefined`. */\nfunction strokeWidthOf(stroke: Record<string, unknown> | undefined): number | { px: number } | undefined {\n  const w = stroke?.width;\n  if (typeof w === 'number') return w;\n  if (typeof w === 'object' && w !== null && typeof (w as { px?: unknown }).px === 'number') {\n    return w as { px: number };\n  }\n  return undefined;\n}\n\n/** `Stroke.dash` — a stored array of lengths — read and written as a named\n *  style. The presets are multiples of the sibling `width`, which is why the\n *  encoding is handed the whole stroke rather than the field. */\nconst strokeDashEncoding: ToolPrefEnumEncoding = {\n  read: (dash, stroke) =>\n    stroke === undefined\n      ? undefined\n      : strokeDashStyleOf(Array.isArray(dash) ? (dash as number[]) : undefined, strokeWidthOf(stroke)),\n  write: (style, stroke) =>\n    style === 'dashed' || style === 'dotted'\n      ? dashForStrokeStyle(style, strokeWidthOf(stroke))\n      // `solid` is stored as no dash at all. `custom` is reportable, not\n      // authorable: it names an imported array, and the array it names is the\n      // one already stored.\n      : style === 'solid'\n        ? undefined\n        : stroke?.dash,\n};\n\n/** `Stroke.markerStart` / `markerMid` / `markerEnd` — a `MarkerRef` — read and\n *  written as a bare key, with the empty string standing for no marker. */\nconst markerEncoding: ToolPrefEnumEncoding = {\n  read: (ref) => {\n    if (typeof ref === 'string') return ref;\n    if (ref && typeof ref === 'object' && 'key' in ref) return String((ref as { key: string }).key);\n    return '';\n  },\n  write: (value) => (value === '' ? undefined : value),\n};\n\n/** `TextStyle.fontStyle` as an Italic flag. Off removes the field rather than\n *  storing `'normal'`, which is what an absent one already means. */\nconst italicEncoding: ToolPrefBooleanEncoding = {\n  read: (stored) => stored === 'italic',\n  write: (on) => (on ? 'italic' : undefined),\n};\n\n/** `TextStyle.align` read as the edge that paints, or as `justify`. The model\n *  also holds the reading-order pair `start` / `end`, which the segments would\n *  otherwise leave unlit; they read through `direction`, and a click writes the\n *  edge. */\nconst alignEncoding: ToolPrefEnumEncoding = {\n  read: (stored, style) => {\n    if (stored === undefined || stored === 'justify') return stored;\n    const direction = style?.direction === 'rtl' ? 'rtl' : 'ltr';\n    return resolveAlign(stored as TextAlign, direction);\n  },\n  write: (edge) => edge,\n};\n\n/** Options come from the registry, so a consumer's registered entry appears in\n *  the picker with no kit edit. A `select` rather than a `toggle`: nine options\n *  will not fit a segmented strip. */\nconst markerOptions = () => [\n  { value: '', label: 'None' },\n  ...listMarkers().map((m) => ({ value: m.id, label: m.id })),\n];\n\n/** Build the standard shape schema — Layout (pose box + rotation) +\n *  Appearance (fill / stroke), optionally a Text group. Matches the kit's\n *  builtin-shape data template (`{ path, fill, stroke?, text? }`,\n *  `useBuiltinShapeTools`). */\nfunction shapeSchema(opts: { text?: boolean } = {}): ToolPrefGroup {\n  return {\n    name: 'Properties',\n    children: {\n      layout: {\n        name: 'Layout',\n        children: {\n          'pose.x': { kind: 'number', name: 'X', description: 'Left edge, world units.', default: 0, pair: 'Position' },\n          'pose.y': { kind: 'number', name: 'Y', description: 'Top edge, world units.', default: 0, pair: 'Position' },\n          'pose.width': { kind: 'number', name: 'W', description: 'Width, world units.', default: 0, min: 0, pair: 'Size' },\n          'pose.height': { kind: 'number', name: 'H', description: 'Height, world units.', default: 0, min: 0, pair: 'Size' },\n          'pose.rotation': { kind: 'number', name: 'Rotation', description: 'Rotation about the box center.', default: 0, step: 1, unit: rotationDegreesUnit },\n        },\n      },\n      // What the node *is* outranks how it is painted: a text node's copy is\n      // the first thing an editor reaches for.\n      ...(opts.text\n        ? {\n            content: {\n              name: 'Content',\n              children: {\n                // `block`: the content is the section, so a 64px label column\n                // reading \"Text\" inside a section reading \"Text\" is one word\n                // twice and a narrower field for the sake of it.\n                'data.text': { kind: 'string', name: 'Text', description: 'Text content.', default: '', block: true },\n              },\n            },\n          }\n        : {}),\n      appearance: {\n        // Headless: `Fill` and `Stroke` head their own blocks, and an\n        // `Appearance` rule over them names neither of the two paints a\n        // reader is looking at.\n        name: '',\n        children: {\n          // A `paint` leaf, not a `color` one: `data.fill` is the tagged\n          // `FillStyle` union, so a color control pointed at it would read\n          // `undefined` off a gradient and write a bare string over it.\n          // `block` for the same reason every stroke field is: the kind bar\n          // and the per-kind editor want the width a 64px label column takes.\n          'data.fill': { kind: 'paint', name: 'Fill', description: 'Fill paint.', default: { fill: 'solid', color: '#000000ff' }, alpha: true, block: true },\n          // An object leaf: `data.stroke` is a whole `Stroke`, and its fields\n          // belong to one value. Sibling leaves addressing into it would each\n          // write one field of a value they can only half see.\n          'data.stroke': {\n            kind: 'object',\n            name: 'Stroke',\n            description: 'Stroke paint and line geometry.',\n            default: { paint: { fill: 'solid', color: '#000000ff' }, width: 1 },\n            block: true,\n            children: {\n              // Every row is `block`: under a heading already reading STROKE,\n              // a 64px label column spells the section name again and takes\n              // the width the controls need. Each field leads with its own\n              // glyph instead.\n              // Unpaired: the paint field is a whole paint editor — a kind bar\n              // over a per-kind body — and cannot share a row with a slider.\n              width: { kind: 'number', name: 'Width', description: 'Stroke width, world units.', default: 1, min: 0, max: 20, step: 0.5, control: 'slider', icon: 'strokeWidth', block: true },\n              paint: { kind: 'paint', name: 'Paint', description: 'Stroke paint.', default: { fill: 'solid', color: '#000000ff' }, alpha: true, block: true },\n              // Three options each: a segmented control shows every one at\n              // once where a select shows the current one and hides the rest\n              // behind a click.\n              cap: { kind: 'enum', name: 'Cap', description: 'How an open end is drawn.', default: 'butt', control: 'toggle', block: true, pair: 'Line', options: [{ value: 'butt', label: 'Butt', icon: 'capButt' }, { value: 'round', label: 'Round', icon: 'capRound' }, { value: 'square', label: 'Square', icon: 'capSquare' }] },\n              join: { kind: 'enum', name: 'Join', description: 'How a corner is drawn.', default: 'miter', control: 'toggle', block: true, pair: 'Line', options: [{ value: 'miter', label: 'Miter', icon: 'joinMiter' }, { value: 'round', label: 'Round', icon: 'joinRound' }, { value: 'bevel', label: 'Bevel', icon: 'joinBevel' }] },\n              align: { kind: 'enum', name: 'Align', description: 'Where the ribbon sits relative to the edge.', default: 'center', control: 'toggle', block: true, pair: 'Line', options: [{ value: 'inner', label: 'Inner', icon: 'alignInner' }, { value: 'center', label: 'Center', icon: 'alignCenter' }, { value: 'outer', label: 'Outer', icon: 'alignOuter' }] },\n              // Its own row: three bars already fill the one above, and the\n              // dash pattern is a property of the line rather than of how the\n              // ribbon meets the geometry.\n              dash: { kind: 'enum', name: 'Style', description: 'Solid, dashed or dotted. Dash lengths are multiples of the stroke width, so a style holds as the width changes.', default: 'solid', control: 'toggle', block: true, encoding: strokeDashEncoding, options: [{ value: 'solid', label: 'Solid', icon: 'dashSolid' }, { value: 'dashed', label: 'Dashed', icon: 'dashDashed' }, { value: 'dotted', label: 'Dotted', icon: 'dashDotted' }, { value: 'custom', label: 'Custom', icon: 'dashCustom', disabled: true }] },\n              markerStart: { kind: 'enum', name: 'Start', description: 'Marker at the first vertex of each open subpath.', default: '', control: 'select', block: true, pair: 'Markers', encoding: markerEncoding, options: markerOptions() },\n              markerMid: { kind: 'enum', name: 'Mid', description: 'Marker at every interior authored vertex.', default: '', control: 'select', block: true, pair: 'Markers', encoding: markerEncoding, options: markerOptions() },\n              markerEnd: { kind: 'enum', name: 'End', description: 'Marker at the last vertex of each open subpath.', default: '', control: 'select', block: true, pair: 'Markers', encoding: markerEncoding, options: markerOptions() },\n            },\n          },\n        },\n      },\n      ...(opts.text\n        ? {\n            text: {\n              // Headless: `Character` and `Paragraph` carry the labels, and a\n              // `Typography` heading over them names nothing a reader can't\n              // already see.\n              name: '',\n              children: {\n                // One object leaf, not a row of siblings addressing into it:\n                // `data.style` is a `TextStyle`, and its character and\n                // paragraph fields are one value that reads as two lists.\n                // The groups head those lists and contribute nothing to the\n                // path — a field inside one is still a field of the style.\n                'data.style': {\n                  kind: 'object',\n                  name: 'Style',\n                  description: 'Typography for the whole node. Its color is the node\\'s own `data.fill`, in Appearance.',\n                  default: {},\n                  block: true,\n                  children: {\n                    character: {\n                      name: 'Character',\n                      children: {\n                        fontFamily: { kind: 'font-family', name: 'Font', description: 'Registered font family.', default: 'sans-serif' },\n                        fontSize: { kind: 'number', name: 'Size', description: 'Font size, world units.', default: 16, min: 1, step: 1, pair: 'Size / weight' },\n                        fontWeight: { kind: 'font-weight', name: 'Weight', description: 'Font weight, from the faces the family has.', default: 400, pair: 'Size / weight' },\n                        // One row of segments, the strip every text editor\n                        // draws: the slant, the three rules, then the two\n                        // scripts. Italic is a flag here although the field\n                        // is `fontStyle`, whose only other value is upright.\n                        fontStyle: { kind: 'boolean', name: 'Italic', description: 'Set the text in its italic face.', default: false, control: 'toggle', icon: 'italic', short: 'I', pair: 'Style', encoding: italicEncoding },\n                        underline: { kind: 'boolean', name: 'Underline', description: 'Underline the text.', default: false, control: 'toggle', icon: 'underline', short: 'U', pair: 'Style' },\n                        strikethrough: { kind: 'boolean', name: 'Strikethrough', description: 'Strike through the text.', default: false, control: 'toggle', icon: 'strikethrough', short: 'S', pair: 'Style' },\n                        overline: { kind: 'boolean', name: 'Overline', description: 'Rule the text above its ascent.', default: false, control: 'toggle', icon: 'overline', short: 'O', pair: 'Style' },\n                        script: { kind: 'enum', name: 'Script', description: 'Set the text smaller and raised or lowered, on the line it would otherwise hold.', default: undefined, control: 'toggle', clearable: true, pair: 'Style', options: [{ value: 'super', label: 'Superscript', icon: 'superscript' }, { value: 'sub', label: 'Subscript', icon: 'subscript' }] },\n                        letterSpacing: { kind: 'number', name: 'Tracking', description: 'Extra advance per glyph, world units.', default: 0, step: 0.1 },\n                        textTransform: { kind: 'enum', name: 'Case', description: 'Draw the text in capitals, lowercase or title case. The text itself is unchanged.', default: 'none', control: 'toggle', options: [{ value: 'none', label: 'None', short: '–' }, { value: 'uppercase', label: 'Uppercase', short: 'AA' }, { value: 'lowercase', label: 'Lowercase', short: 'aa' }, { value: 'capitalize', label: 'Capitalize', short: 'Aa' }] },\n                        fontVariantCaps: { kind: 'enum', name: 'Small caps', description: 'Draw lowercase letters as smaller capitals. The text itself is unchanged.', default: 'normal', control: 'toggle', options: [{ value: 'normal', label: 'Normal', short: '–' }, { value: 'small-caps', label: 'Small caps', short: 'Sc' }] },\n                      },\n                    },\n                    paragraph: {\n                      name: 'Paragraph',\n                      children: {\n                        lineHeight: { kind: 'number', name: 'Leading', description: 'Line height as a multiple of font size.', default: 1.2, min: 0.5, step: 0.1 },\n                        wrap: { kind: 'boolean', name: 'Wrap', description: 'Break lines between words at the box width.', default: false, control: 'switch' },\n                        direction: { kind: 'enum', name: 'Direction', description: 'Reading direction.', default: 'ltr', control: 'toggle', options: [{ value: 'ltr', label: 'Left to right', short: 'LTR' }, { value: 'rtl', label: 'Right to left', short: 'RTL' }] },\n                        // Last, so the box's vertical alignment — a field of\n                        // the node rather than of its style — follows it.\n                        align: { kind: 'enum', name: 'Align', description: 'Horizontal alignment.', default: 'left', control: 'toggle', encoding: alignEncoding, options: [{ value: 'left', label: 'Left', icon: 'textAlignLeft' }, { value: 'center', label: 'Center', icon: 'textAlignCenter' }, { value: 'right', label: 'Right', icon: 'textAlignRight' }, { value: 'justify', label: 'Justify', icon: 'textAlignJustify' }] },\n                      },\n                    },\n                  },\n                },\n                'data.verticalAlign': { kind: 'enum', name: 'Vertical', description: 'Where the lines sit in the box\\'s height.', default: 'top', control: 'toggle', options: [{ value: 'top', label: 'Top', icon: 'textAlignTop' }, { value: 'center', label: 'Middle', icon: 'textAlignMiddle' }, { value: 'bottom', label: 'Bottom', icon: 'textAlignBottom' }] },\n              },\n            },\n          }\n        : {}),\n    },\n  };\n}\n\n/**\n * Default properties-trait entries covering the kit's built-in shape\n * kinds (`KIT_SHAPE_KINDS`) — the sibling of `defaultNodeRouting`. Every\n * kind gets the standard box schema; `text` adds a Text group. In\n * lockstep with `KIT_SHAPE_KINDS` by construction (derived via `.map`).\n */\nexport const defaultNodeProperties: readonly NodePropertiesEntry[] =\n  KIT_SHAPE_KINDS.map((name) => ({\n    name,\n    schema: shapeSchema({ text: name === 'text' }),\n  }));\n\n/**\n * Properties-trait entries for the *inferred* routing kinds\n * (`inferredNodeRouting`: `text` / `path` / `image`) — the vocabulary\n * consumers produce when they don't tag `data.kind` (e.g. WeaselDraw).\n * In lockstep with `inferredNodeRouting` by construction.\n */\nexport const inferredNodeProperties: readonly NodePropertiesEntry[] =\n  inferredNodeRouting.map((e) => ({\n    name: e.name,\n    schema: shapeSchema({ text: e.name === 'text' }),\n  }));\n"],"mappings":"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"}

package/dist/canvas/SceneCanvas/defaultNodeRouting.js

@@ -0,0 +1,26 @@
+import { KIT_SHAPE_KINDS as e } from "../../core/shapeKinds.js";
+//#region src/canvas/SceneCanvas/defaultNodeRouting.ts
+function t(e) {
+	return typeof e == "object" && !!e;
+}
+var n = e.map((e) => ({
+	name: e,
+	matches: (n) => t(n) && n.kind === e
+})), r = [
+	{
+		name: "text",
+		matches: (e) => t(e) && typeof e.text == "string"
+	},
+	{
+		name: "path",
+		matches: (e) => t(e) && e.path != null
+	},
+	{
+		name: "image",
+		matches: (e) => t(e) && e.image != null
+	}
+];
+//#endregion
+export { n as defaultNodeRouting, r as inferredNodeRouting };
+
+//# sourceMappingURL=defaultNodeRouting.js.map

package/dist/canvas/SceneCanvas/defaultNodeRouting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultNodeRouting.js","names":["isObj","d","defaultNodeRouting","KIT_SHAPE_KINDS","data","name","inferredNodeRouting"],"sources":["../../../src/canvas/SceneCanvas/defaultNodeRouting.ts"],"sourcesContent":["import { KIT_SHAPE_KINDS } from 'core/shapeKinds';\nimport type { NodeRoutingEntry } from 'core/scene/NodeRouting';\n\nfunction isObj(d: unknown): d is Record<string, unknown> {\n  return typeof d === 'object' && d !== null;\n}\n\n/**\n * Default routing-trait classifiers covering the kit's built-in shape\n * tools (`KIT_SHAPE_KINDS`). Each entry matches `data.kind === '<name>'`\n * — the convention demos use when they explicitly tag scene data with a\n * routing-kind string. The routing trait's default values happen to\n * mirror the shape trait's by name; the two traits remain independent\n * — a consumer can register routing kinds that have no matching shape\n * painter (e.g. `'group'`, `'sticky-note'`).\n *\n * Lives in the canvas layer (next to the builtin shape tools it mirrors)\n * rather than `core/scene`: the generic routing machinery (`NodeRouting`)\n * is core, but this default *population* depends on the canvas-layer\n * `KIT_SHAPE_KINDS`, so `core` must not own it.\n *\n * Consumers using the kit's standard data shape spread\n * `defaultNodeRouting` into their `<SceneCanvas routing={...}>` prop;\n * consumers whose data carries no `kind` field but follows the kit's\n * common shapes (`{ path }`, `{ text }`, `{ image }`) should prefer\n * `inferredNodeRouting` below, which SceneCanvas applies automatically\n * when `routing` is unset.\n *\n * In lockstep with `KIT_SHAPE_KINDS` by construction (derived via `.map`).\n */\nexport const defaultNodeRouting: readonly NodeRoutingEntry[] = KIT_SHAPE_KINDS.map(\n  (name) => ({\n    name,\n    matches: (data) =>\n      isObj(data) &&\n      (data as { kind?: unknown }).kind === name,\n  }),\n);\n\n/**\n * Shape-inferred routing-trait classifiers used when a consumer doesn't\n * pass `routing` to `<SceneCanvas>`. Produces semantic kinds based on\n * data-shape hints rather than an explicit `data.kind` tag:\n *\n *   - `'text'` when `data.text` is a string (`text-edit` mode entry)\n *   - `'path'` when `data.path` is present  (`path-edit` mode entry)\n *   - `'image'` when `data.image` is present\n *\n * Order matters: `'text'` beats `'path'` so an SVG-imported text node\n * carrying a fallback `path` routes to text-edit. Consumers wanting\n * different precedence pass their own `routing` array.\n *\n * Without this default the kind classifier is undefined when\n * `routing` is unset and every hit comes back as `kind: 'unknown'`,\n * silently breaking `Hit.kind`-based routing (e.g. modality's\n * `dispatchDoubleClickEntry`).\n */\nexport const inferredNodeRouting: readonly NodeRoutingEntry[] = [\n  { name: 'text', matches: (d) => isObj(d) && typeof d.text === 'string' },\n  { name: 'path', matches: (d) => isObj(d) && d.path != null },\n  { name: 'image', matches: (d) => isObj(d) && d.image != null },\n];\n"],"mappings":";;AAGA,SAASA,EAAM,GAA0C;CACvD,OAAO,OAAOC,KAAM,cAAYA;AAClC;AAyBA,IAAaC,IAAkDC,EAAgB,KAC5E,OAAU;CACT;CACA,UAAU,MACRH,EAAMI,CAAI,KACTA,EAA4B,SAASC;AAC1C,EACF,GAoBaC,IAAmD;CAC9D;EAAE,MAAM;EAAQ,UAAU,MAAMN,EAAMC,CAAC,KAAK,OAAOA,EAAE,QAAS;CAAS;CACvE;EAAE,MAAM;EAAQ,UAAU,MAAMD,EAAMC,CAAC,KAAKA,EAAE,QAAQ;CAAK;CAC3D;EAAE,MAAM;EAAS,UAAU,MAAMD,EAAMC,CAAC,KAAKA,EAAE,SAAS;CAAK;AAC/D"}

package/dist/canvas/SceneCanvas/dispatcherGestureBounds.js

@@ -0,0 +1,69 @@
+import { insertPreviewExtent as e } from "../insertPreviewExtent.js";
+//#region src/canvas/SceneCanvas/dispatcherGestureBounds.ts
+function t(e) {
+	let t = [];
+	if (!e) return t;
+	for (let n of e.getInFlightHandles()) {
+		let e = n.previewIds?.();
+		if (e) for (let n of e) t.push(n);
+	}
+	return t;
+}
+function n(t) {
+	let n = [];
+	if (!t) return n;
+	for (let r of t.getInFlightHandles()) {
+		let t = r.overlay?.();
+		if (!t || t.kind !== "insertPreview") continue;
+		let i = e(t).bounds;
+		(i.width !== 0 || i.height !== 0 || t.shape === "pencil") && n.push({
+			x: i.x,
+			y: i.y,
+			width: i.width,
+			height: i.height
+		});
+	}
+	return n;
+}
+var r = () => {};
+function i(e) {
+	return {
+		ids: () => t(e()),
+		bounds: () => n(e()),
+		subscribe: (t) => e()?.subscribe(t) ?? r,
+		getVersion: () => e()?.getVersion() ?? 0,
+		previewSources: () => [...e()?.getInFlightHandles() ?? []],
+		overlays: () => {
+			let t = [];
+			for (let n of e()?.getInFlightHandles() ?? []) {
+				let e = n.overlay?.();
+				e && t.push(e);
+			}
+			return t;
+		}
+	};
+}
+function a(e) {
+	return {
+		previewIdsExtra: () => {
+			let t = [];
+			for (let n of e()?.getInFlightHandles() ?? []) {
+				if (n.previewHidesSource === !1) continue;
+				let e = n.previewIds?.();
+				if (e) for (let n of e) t.push(n);
+			}
+			return t;
+		},
+		previewPoseExtra: (t) => {
+			for (let n of e()?.getInFlightHandles() ?? []) {
+				let e = n.previewPose?.(t);
+				if (e != null) return e;
+			}
+			return null;
+		}
+	};
+}
+//#endregion
+export { a as createDispatcherPreviewSources, i as createGestureSource, t as dispatcherGestureIds, n as dispatcherInsertBounds };
+
+//# sourceMappingURL=dispatcherGestureBounds.js.map

package/dist/canvas/SceneCanvas/dispatcherGestureBounds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatcherGestureBounds.js","names":["dispatcherGestureIds","out","dispatcher","handle","ids","id","dispatcherInsertBounds","ov","b","insertPreviewExtent","NO_OP_UNSUBSCRIBE","createGestureSource","getDispatcher","fn","createDispatcherPreviewSources","p"],"sources":["../../../src/canvas/SceneCanvas/dispatcherGestureBounds.ts"],"sourcesContent":["/**\n * The dispatcher side of `<Canvas>`'s {@link GestureSource} seam.\n *\n * `<Canvas>` owns the `CanvasHelpers` gesture surface (`getGestureBounds`,\n * `subscribeGestures`, `getGestureVersion`) but knows nothing about the\n * gesture dispatcher — like `previewIdsExtra` / `previewPoseExtra`, the\n * dispatcher's contribution is wired in from `<SceneCanvas>`. This module is\n * the whole of that contribution:\n *\n *  - {@link dispatcherGestureIds} — every id any in-flight handle is\n *    previewing, so Canvas can resolve each one's preview bounds;\n *  - {@link dispatcherInsertBounds} — the AABBs of gestures that have no\n *    scene id at all (a drag-to-insert, pre-commit);\n *  - {@link createGestureSource} — those two plus the dispatcher's change\n *    signal, its in-flight preview surfaces and its published overlays,\n *    bundled into the object `<Canvas>` takes.\n *\n * `useDispatcherOverlayLayer` paints the same `insertPreview` overlays this\n * reads, and both size them through `insertPreviewExtent`, so the reported\n * bounds and the drawn preview can't disagree.\n */\nimport type { Dispatcher } from '@weasel-js/routing';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { GestureSource } from '../gestureBounds';\nimport type { OngoingOverlay } from '@weasel-js/routing';\nimport { insertPreviewExtent } from '../insertPreviewExtent';\n\n/**\n * Ids every in-flight handle is previewing.\n *\n * Deliberately *not* `previewIdsExtra`: that one honors\n * `previewHidesSource: false` because its job is deciding whose committed\n * paint to suppress. A clone ghost hides nothing yet still proposes content\n * at the drag target, so gesture bounds must count it.\n */\nexport function dispatcherGestureIds(dispatcher: Dispatcher | null | undefined): string[] {\n  const out: string[] = [];\n  if (!dispatcher) return out;\n  for (const handle of dispatcher.getInFlightHandles()) {\n    const ids = handle.previewIds?.();\n    if (!ids) continue;\n    for (const id of ids) out.push(id);\n  }\n  return out;\n}\n\n/**\n * World-space AABBs of in-flight gestures with no scene node yet — the\n * `insertPreview` overlay variant, sized by {@link insertPreviewExtent}.\n *\n * Only `insertPreview`. `marquee` and `lasso` are in-flight gestures with\n * geometry too, but they *select* rather than *propose content*: a consumer\n * sizing itself to the gesture (lbx-editor's live auto-length) must not grow\n * because the user swept a selection rectangle. A `polyline` — a slice's cut\n * line, a connector being routed — proposes no content either.\n */\nexport function dispatcherInsertBounds(dispatcher: Dispatcher | null | undefined): Bounds[] {\n  const out: Bounds[] = [];\n  if (!dispatcher) return out;\n  for (const handle of dispatcher.getInFlightHandles()) {\n    const ov = handle.overlay?.();\n    if (!ov || ov.kind !== 'insertPreview') continue;\n    const b = insertPreviewExtent(ov).bounds;\n    // A zero-area extent is the pointerdown frame before the first move.\n    // Mirrors `useDispatcherOverlayLayer`'s skip, pencil exception included:\n    // a pencil gesture can be meaningful at near-zero AABB (closed loop /\n    // sub-threshold), so it reports its point rather than nothing.\n    if (b.width === 0 && b.height === 0 && ov.shape !== 'pencil') continue;\n    out.push({ x: b.x, y: b.y, width: b.width, height: b.height });\n  }\n  return out;\n}\n\nconst NO_OP_UNSUBSCRIBE = (): void => {};\n\n/**\n * Bundle a dispatcher into the {@link GestureSource} `<Canvas>` consumes.\n *\n * Reads the dispatcher through a getter rather than closing over it, so the\n * source can be built once and keep pointing at the live dispatcher across\n * re-renders. A `null` dispatcher yields the empty answers — no ids, no\n * bounds, a no-op subscription, version 0.\n */\nexport function createGestureSource(\n  getDispatcher: () => Dispatcher | null | undefined,\n): GestureSource {\n  return {\n    ids: () => dispatcherGestureIds(getDispatcher()),\n    bounds: () => dispatcherInsertBounds(getDispatcher()),\n    subscribe: (fn) => getDispatcher()?.subscribe(fn) ?? NO_OP_UNSUBSCRIBE,\n    getVersion: () => getDispatcher()?.getVersion() ?? 0,\n    previewSources: () => [...(getDispatcher()?.getInFlightHandles() ?? [])],\n    overlays: () => {\n      const out: OngoingOverlay[] = [];\n      for (const handle of getDispatcher()?.getInFlightHandles() ?? []) {\n        const ov = handle.overlay?.();\n        if (ov) out.push(ov);\n      }\n      return out;\n    },\n  };\n}\n\n/**\n * The dispatcher's contribution to a view's overlay-aware lookups: which ids\n * an in-flight handle hides behind a ghost, and the pose it proposes for one.\n *\n * Separate from {@link createGestureSource} only because `<Canvas>` takes\n * these as two loose props rather than a bundle.\n */\nexport function createDispatcherPreviewSources(\n  getDispatcher: () => Dispatcher | null | undefined,\n): {\n  previewIdsExtra: () => string[];\n  previewPoseExtra: (id: string) => unknown;\n} {\n  return {\n    // Handles that set `previewHidesSource: false` (clone, etc.) opt out —\n    // their ghost still paints, but the source stays at its committed home.\n    previewIdsExtra: () => {\n      const out: string[] = [];\n      for (const handle of getDispatcher()?.getInFlightHandles() ?? []) {\n        if (handle.previewHidesSource === false) continue;\n        const ids = handle.previewIds?.();\n        if (!ids) continue;\n        for (const id of ids) out.push(id);\n      }\n      return out;\n    },\n    previewPoseExtra: (id: string) => {\n      for (const handle of getDispatcher()?.getInFlightHandles() ?? []) {\n        const p = handle.previewPose?.(id);\n        if (p != null) return p;\n      }\n      return null;\n    },\n  };\n}\n"],"mappings":";;AAmCA,SAAgBA,EAAqB,GAAqD;CACxF,IAAMC,IAAgB,CAAC;CACvB,IAAI,CAACC,GAAY,OAAOD;CACxB,KAAK,IAAME,KAAUD,EAAW,mBAAmB,GAAG;EACpD,IAAME,IAAMD,EAAO,aAAa;EAChC,IAAKC,GACL,KAAK,IAAMC,KAAMD,GAAK,EAAI,KAAKC,CAAE;CACnC;CACA,OAAOJ;AACT;AAYA,SAAgBK,EAAuB,GAAqD;CAC1F,IAAML,IAAgB,CAAC;CACvB,IAAI,CAACC,GAAY,OAAOD;CACxB,KAAK,IAAME,KAAUD,EAAW,mBAAmB,GAAG;EACpD,IAAMK,IAAKJ,EAAO,UAAU;EAC5B,IAAI,CAACI,KAAMA,EAAG,SAAS,iBAAiB;EACxC,IAAMC,IAAIC,EAAoBF,CAAE,CAAC,CAAC;EAKlC,CAAIC,EAAE,UAAU,KAAKA,EAAE,WAAW,KAAKD,EAAG,UAAU,aACpDN,EAAI,KAAK;GAAE,GAAGO,EAAE;GAAG,GAAGA,EAAE;GAAG,OAAOA,EAAE;GAAO,QAAQA,EAAE;EAAO,CAAC;CAC/D;CACA,OAAOP;AACT;AAEA,IAAMS,UAAgC,CAAC;AAUvC,SAAgBC,EACd,GACe;CACf,OAAO;EACL,WAAWX,EAAqBY,EAAc,CAAC;EAC/C,cAAcN,EAAuBM,EAAc,CAAC;EACpD,YAAY,MAAOA,EAAc,CAAC,EAAE,UAAUC,CAAE,KAAKH;EACrD,kBAAkBE,EAAc,CAAC,EAAE,WAAW,KAAK;EACnD,sBAAsB,CAAC,GAAIA,EAAc,CAAC,EAAE,mBAAmB,KAAK,CAAC,CAAE;EACvE,gBAAgB;GACd,IAAMX,IAAwB,CAAC;GAC/B,KAAK,IAAME,KAAUS,EAAc,CAAC,EAAE,mBAAmB,KAAK,CAAC,GAAG;IAChE,IAAML,IAAKJ,EAAO,UAAU;IAC5B,AAAII,KAAIN,EAAI,KAAKM,CAAE;GACrB;GACA,OAAON;EACT;CACF;AACF;AASA,SAAgBa,EACd,GAIA;CACA,OAAO;EAGL,uBAAuB;GACrB,IAAMb,IAAgB,CAAC;GACvB,KAAK,IAAME,KAAUS,EAAc,CAAC,EAAE,mBAAmB,KAAK,CAAC,GAAG;IAChE,IAAIT,EAAO,uBAAuB,IAAO;IACzC,IAAMC,IAAMD,EAAO,aAAa;IAChC,IAAKC,GACL,KAAK,IAAMC,KAAMD,GAAK,EAAI,KAAKC,CAAE;GACnC;GACA,OAAOJ;EACT;EACA,mBAAmB,MAAe;GAChC,KAAK,IAAME,KAAUS,EAAc,CAAC,EAAE,mBAAmB,KAAK,CAAC,GAAG;IAChE,IAAMG,IAAIZ,EAAO,cAAcE,CAAE;IACjC,IAAIU,KAAK,MAAM,OAAOA;GACxB;GACA,OAAO;EACT;CACF;AACF"}

package/dist/canvas/SceneCanvas/features.js

@@ -0,0 +1,97 @@
+//#region src/canvas/SceneCanvas/features.ts
+var e = [
+	"view",
+	"pick",
+	"move",
+	"transform",
+	"edit",
+	"arrange",
+	"paths",
+	"ingest",
+	"draw"
+], t = e.filter((e) => e !== "draw"), n = {
+	view: ["viewport.dragPan", "viewport.pinchZoom"],
+	pick: [
+		"areaSelect",
+		"clearSelection",
+		"lassoSelect"
+	],
+	move: ["move", "clone"],
+	transform: ["resize", "rotate"],
+	edit: [
+		"escape",
+		"cancelGesture",
+		"selectAll",
+		"duplicate",
+		"delete",
+		"group",
+		"ungroup",
+		"undo",
+		"redo",
+		"nudge.up",
+		"nudge.down",
+		"nudge.left",
+		"nudge.right",
+		"clipboard.cut",
+		"clipboard.copy",
+		"clipboard.paste",
+		"setFill",
+		"setStroke",
+		"setFillOpacity",
+		"setStrokeOpacity"
+	],
+	arrange: [
+		"flip",
+		"reorder.forward",
+		"reorder.backward",
+		"align.left",
+		"align.centerX",
+		"align.right",
+		"align.top",
+		"align.centerY",
+		"align.bottom",
+		"distribute.horizontal",
+		"distribute.vertical"
+	],
+	paths: [
+		"pathfinder.union",
+		"pathfinder.subtract",
+		"pathfinder.intersect",
+		"pathfinder.exclude",
+		"pathfinder.divide",
+		"pathfinder.crop",
+		"createOutlines",
+		"editAnchors",
+		"enterPathEdit",
+		"exitPathEdit",
+		"insertPathAnchor",
+		"nudgeAnchors.up",
+		"nudgeAnchors.down",
+		"nudgeAnchors.left",
+		"nudgeAnchors.right",
+		"deleteAnchors",
+		"cutPathAtAnchor",
+		"marqueeAnchors",
+		"selectAnchor"
+	],
+	ingest: ["ingest"]
+}, r = [
+	"insert",
+	"insert.adjustRotation",
+	"enterTextEdit"
+];
+function i(e, n = {}) {
+	let r = /* @__PURE__ */ new Set();
+	for (let n of e ?? []) if (n === "draw") for (let e of t) r.add(e);
+	else r.add(n);
+	return n.viewport && r.add("view"), r;
+}
+function a(e) {
+	let t = /* @__PURE__ */ new Set();
+	for (let r of e) for (let e of n[r]) t.add(e);
+	return t;
+}
+//#endregion
+export { n as FEATURE_ACTION_IDS, e as SCENE_CANVAS_FEATURES, r as TOOL_DRIVEN_ACTION_IDS, a as featureActionIds, i as resolveFeatures };
+
+//# sourceMappingURL=features.js.map

package/dist/canvas/SceneCanvas/features.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features.js","names":["SCENE_CANVAS_FEATURES","BASE_FEATURES","f","FEATURE_ACTION_IDS","TOOL_DRIVEN_ACTION_IDS","resolveFeatures","out","features","b","opts","featureActionIds","ids","id"],"sources":["../../../src/canvas/SceneCanvas/features.ts"],"sourcesContent":["/**\n * The behavior presets `<SceneCanvas features>` composes. A bare canvas renders\n * its scene and keeps a selection nothing sets; every behavior beyond that is\n * turned on by naming a preset here.\n */\n\n/** A behavior preset for `<SceneCanvas features>`. `draw` names every other\n *  one. */\nexport type Feature =\n  | 'view'\n  | 'pick'\n  | 'move'\n  | 'transform'\n  | 'edit'\n  | 'arrange'\n  | 'paths'\n  | 'ingest'\n  | 'draw';\n\n/** Every preset except `draw`, which only abbreviates them. */\nexport type BaseFeature = Exclude<Feature, 'draw'>;\n\n/** Every preset `<SceneCanvas features>` accepts, `draw` last. */\nexport const SCENE_CANVAS_FEATURES: readonly Feature[] = [\n  'view', 'pick', 'move', 'transform', 'edit', 'arrange', 'paths', 'ingest', 'draw',\n];\n\nconst BASE_FEATURES: readonly BaseFeature[] =\n  SCENE_CANVAS_FEATURES.filter((f): f is BaseFeature => f !== 'draw');\n\n/**\n * The kit-standard actions each preset registers.\n *\n * Every id `useStandardActions` knows appears under exactly one preset, except\n * the ones in {@link TOOL_DRIVEN_ACTION_IDS}. `move` and `transform` also bring\n * the ambient bindings that route drags to their actions, and `pick` brings the\n * select tool; this table is only the registration half.\n */\nexport const FEATURE_ACTION_IDS: Readonly<Record<BaseFeature, readonly string[]>> = {\n  view: ['viewport.dragPan', 'viewport.pinchZoom'],\n  pick: ['areaSelect', 'clearSelection', 'lassoSelect'],\n  move: ['move', 'clone'],\n  transform: ['resize', 'rotate'],\n  edit: [\n    'escape', 'cancelGesture', 'selectAll', 'duplicate', 'delete',\n    'group', 'ungroup', 'undo', 'redo',\n    'nudge.up', 'nudge.down', 'nudge.left', 'nudge.right',\n    'clipboard.cut', 'clipboard.copy', 'clipboard.paste',\n    'setFill', 'setStroke', 'setFillOpacity', 'setStrokeOpacity',\n  ],\n  arrange: [\n    'flip',\n    'reorder.forward', 'reorder.backward',\n    'align.left', 'align.centerX', 'align.right',\n    'align.top', 'align.centerY', 'align.bottom',\n    'distribute.horizontal', 'distribute.vertical',\n  ],\n  paths: [\n    'pathfinder.union', 'pathfinder.subtract', 'pathfinder.intersect',\n    'pathfinder.exclude', 'pathfinder.divide', 'pathfinder.crop', 'createOutlines',\n    'editAnchors', 'enterPathEdit', 'exitPathEdit', 'insertPathAnchor',\n    'nudgeAnchors.up', 'nudgeAnchors.down', 'nudgeAnchors.left', 'nudgeAnchors.right',\n    'deleteAnchors', 'cutPathAtAnchor', 'marqueeAnchors', 'selectAnchor',\n  ],\n  ingest: ['ingest'],\n};\n\n/**\n * Kit-standard actions no preset registers: they belong to the tools that bind\n * them. A canvas registers each one whenever a tool it carries names it in a\n * binding — `insert` with any shape tool, `enterTextEdit` with the text tool.\n */\nexport const TOOL_DRIVEN_ACTION_IDS: readonly string[] = ['insert', 'insert.adjustRotation', 'enterTextEdit'];\n\n/**\n * The presets a canvas runs with: `features` with `draw` expanded, plus `view`\n * whenever the canvas was handed a `viewport` config, since that prop only\n * configures what `view` turns on.\n */\nexport function resolveFeatures(\n  features: readonly Feature[] | undefined,\n  opts: { viewport?: boolean } = {},\n): ReadonlySet<BaseFeature> {\n  const out = new Set<BaseFeature>();\n  for (const f of features ?? []) {\n    if (f === 'draw') for (const b of BASE_FEATURES) out.add(b);\n    else out.add(f);\n  }\n  if (opts.viewport) out.add('view');\n  return out;\n}\n\n/** The kit-standard action ids the given presets register. */\nexport function featureActionIds(features: ReadonlySet<BaseFeature>): Set<string> {\n  const ids = new Set<string>();\n  for (const f of features) for (const id of FEATURE_ACTION_IDS[f]) ids.add(id);\n  return ids;\n}\n"],"mappings":";AAuBA,IAAaA,IAA4C;CACvD;CAAQ;CAAQ;CAAQ;CAAa;CAAQ;CAAW;CAAS;CAAU;AAC7E,GAEMC,IACJD,EAAsB,QAAQ,MAAwBE,MAAM,MAAM,GAUvDC,IAAuE;CAClF,MAAM,CAAC,oBAAoB,oBAAoB;CAC/C,MAAM;EAAC;EAAc;EAAkB;CAAa;CACpD,MAAM,CAAC,QAAQ,OAAO;CACtB,WAAW,CAAC,UAAU,QAAQ;CAC9B,MAAM;EACJ;EAAU;EAAiB;EAAa;EAAa;EACrD;EAAS;EAAW;EAAQ;EAC5B;EAAY;EAAc;EAAc;EACxC;EAAiB;EAAkB;EACnC;EAAW;EAAa;EAAkB;CAC5C;CACA,SAAS;EACP;EACA;EAAmB;EACnB;EAAc;EAAiB;EAC/B;EAAa;EAAiB;EAC9B;EAAyB;CAC3B;CACA,OAAO;EACL;EAAoB;EAAuB;EAC3C;EAAsB;EAAqB;EAAmB;EAC9D;EAAe;EAAiB;EAAgB;EAChD;EAAmB;EAAqB;EAAqB;EAC7D;EAAiB;EAAmB;EAAkB;CACxD;CACA,QAAQ,CAAC,QAAQ;AACnB,GAOaC,IAA4C;CAAC;CAAU;CAAyB;AAAe;AAO5G,SAAgBC,EACd,GACA,IAA+B,CAAC,GACN;CAC1B,IAAMC,oBAAM,IAAI,IAAiB;CACjC,KAAK,IAAMJ,KAAKK,KAAY,CAAC,GAC3B,IAAIL,MAAM,QAAQ,KAAK,IAAMM,KAAKP,GAAe,EAAI,IAAIO,CAAC;MACrD,EAAI,IAAIN,CAAC;CAGhB,OADIO,EAAK,YAAUH,EAAI,IAAI,MAAM,GAC1BA;AACT;AAGA,SAAgBI,EAAiB,GAAiD;CAChF,IAAMC,oBAAM,IAAI,IAAY;CAC5B,KAAK,IAAMT,KAAKK,GAAU,KAAK,IAAMK,KAAMT,EAAmBD,IAAI,EAAI,IAAIU,CAAE;CAC5E,OAAOD;AACT"}

package/dist/canvas/SceneCanvas/poseGeometry.js

@@ -0,0 +1,46 @@
+import { poseRotationOf as e } from "../../core/geometry/poseRotation.js";
+import { AUTO_POSE_DESCRIPTOR as t, isPathLike as n } from "../../interactions/actions/resize/autoPoseDescriptor.js";
+import { hasSlop as r, slopForStrokeHit as i } from "../../core/viewport/screenSlop.js";
+import { applyToPoint as a, pointInPath as o, rotateAboutPoint as s, strokeHitTest as c } from "@weasel-js/geom";
+//#region src/canvas/SceneCanvas/poseGeometry.ts
+function l(e, n = t) {
+	return n.getBounds(e);
+}
+var u = 4;
+function d(e, n, r, i, a = t) {
+	return p(e, n, r, i, a, 0);
+}
+function f(n, r, i, o, c = t) {
+	let l = c === t ? e(n) : m(n, c);
+	if (l) {
+		let [e, t] = a(s(l.cx, l.cy, -l.rotation), r, i);
+		return p(n, e, t, o, c, l.rotation);
+	}
+	return p(n, r, i, o, c, 0);
+}
+function p(e, t, a, s, d, f) {
+	let p = n(e), m = s === void 0 ? p ? u : 0 : typeof s == "number" ? s : s.reach ?? 0, h = typeof s == "object" ? s : void 0, { opts: g } = i(h, f);
+	if (p) return o(e, t, a) ? !0 : c(e, t, a, m, g);
+	let _ = l(e, d), v = {
+		kind: "rect",
+		x: _.x - m,
+		y: _.y - m,
+		width: _.width + 2 * m,
+		height: _.height + 2 * m
+	};
+	return o(v, t, a) ? !0 : r(h) && c(v, t, a, 0, g);
+}
+function m(e, t) {
+	let n = t.getRotation?.(e) ?? 0;
+	if (!n) return null;
+	let r = t.getBounds(e);
+	return {
+		cx: r.x + r.width / 2,
+		cy: r.y + r.height / 2,
+		rotation: n
+	};
+}
+//#endregion
+export { l as aabbOfPose, n as isPathLike, d as poseContains, f as poseContainsRotated };
+
+//# sourceMappingURL=poseGeometry.js.map

package/dist/canvas/SceneCanvas/poseGeometry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"poseGeometry.js","names":["aabbOfPose","AUTO_POSE_DESCRIPTOR","descriptor","pose","DEFAULT_PATH_STROKE_SLOP","poseContains","containsInFrame","wx","wy","tolerance","poseContainsRotated","r","poseRotationOf","rotationAboutCenter","lx","ly","applyToPoint","rotateAboutPoint","pathLike","isPathLike","reach","screen","slopForStrokeHit","rotation","pointInPath","x","y","strokeHitTest","opts","b","grown","hasSlop"],"sources":["../../../src/canvas/SceneCanvas/poseGeometry.ts"],"sourcesContent":["/**\n * Pose-shape helpers shared by `<SceneCanvas>` internals.\n *\n * Every bounds read goes through a `PoseDescriptor`, defaulting to\n * `AUTO_POSE_DESCRIPTOR` (path descriptor for `{kind:'polygon'|'rect'}` poses,\n * rect descriptor for everything else). Used by hit-test, marquee and bounds\n * extraction, so a consumer-supplied descriptor reaches all three.\n */\nimport type { Bounds } from 'tools/builtin/select';\nimport { applyToPoint, pointInPath, rotateAboutPoint, strokeHitTest } from '@weasel-js/geom';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { AUTO_POSE_DESCRIPTOR, isPathLike } from 'interactions/actions/resize/autoPoseDescriptor';\nimport { poseRotationOf } from 'core/geometry/poseRotation';\nimport { hasSlop, slopForStrokeHit, type ScreenSlop } from 'core/viewport/screenSlop';\n\nexport { isPathLike };\n\nexport function aabbOfPose<TPose>(\n  pose: TPose,\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n): Bounds {\n  return descriptor.getBounds(pose);\n}\n\n/** Screen-px slop applied to the stroke-distance hit-test for paths. Catches\n *  fingertip-imprecision around thin lines / curves without depending on the\n *  stroke's actual rendered width (which the hit-test layer doesn't know). */\nconst DEFAULT_PATH_STROKE_SLOP = 4;\n\n/** A containment slop: `reach` world units the caller knows the ink extends\n *  past the pose (a stroke's outward half-width), then `px`/`scale` of screen\n *  slop measured from there. */\nexport interface PoseSlop extends ScreenSlop {\n  reach?: number;\n}\n\n/**\n * @param tolerance - Grab slop. A number is **world** units and grows the\n *   AABB test and the path stroke-distance test alike; a {@link PoseSlop}\n *   is measured on screen, from `reach` world units out. Defaults to\n *   {@link DEFAULT_PATH_STROKE_SLOP} for path-like poses (the historical\n *   fixed slop) and to `0` for rect poses, whose edges were never fuzzy.\n */\nexport function poseContains<TPose>(\n  pose: TPose,\n  wx: number,\n  wy: number,\n  tolerance?: number | PoseSlop,\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n): boolean {\n  return containsInFrame(pose, wx, wy, tolerance, descriptor, 0);\n}\n\n/**\n * Containment for `<SceneCanvas>`'s default `pickEvery`. When the pose carries\n * an effective rotation (`poseRotationOf`), inverse-rotates the query point\n * about the AABB center and tests in the pose's own frame — exactly mirroring\n * the renderer's rotation wrap, so the click target matches the rendered shape.\n * This covers both rect-shaped poses and rotated `kind:'rect'`/polygon poses\n * that carry an AABB. Poses with no effective rotation test directly.\n *\n * Rotation comes from the descriptor when one is supplied, and otherwise from\n * `pose.rotation` — the convention the renderer reads.\n */\nexport function poseContainsRotated<TPose>(\n  pose: TPose,\n  wx: number,\n  wy: number,\n  tolerance?: number | PoseSlop,\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n): boolean {\n  const r = descriptor === AUTO_POSE_DESCRIPTOR\n    ? poseRotationOf(pose)\n    : rotationAboutCenter(pose, descriptor);\n  if (r) {\n    // Inverse of `rotateAboutPoint(cx, cy, θ)` is `rotateAboutPoint(cx, cy, -θ)`\n    // (same pivot + negated angle). Rotation is rigid, so world reach carries\n    // over unchanged; a screen slop does not, and gets the rotation passed on.\n    const [lx, ly] = applyToPoint(rotateAboutPoint(r.cx, r.cy, -r.rotation), wx, wy);\n    return containsInFrame(pose, lx, ly, tolerance, descriptor, r.rotation);\n  }\n  return containsInFrame(pose, wx, wy, tolerance, descriptor, 0);\n}\n\n/** `(x, y)` is in the pose's own frame, which reaches world by `rotation`. */\nfunction containsInFrame<TPose>(\n  pose: TPose,\n  x: number,\n  y: number,\n  tolerance: number | PoseSlop | undefined,\n  descriptor: PoseDescriptor<unknown>,\n  rotation: number,\n): boolean {\n  const pathLike = isPathLike(pose);\n  const reach = tolerance === undefined\n    ? (pathLike ? DEFAULT_PATH_STROKE_SLOP : 0)\n    : typeof tolerance === 'number' ? tolerance : (tolerance.reach ?? 0);\n  const screen = typeof tolerance === 'object' ? tolerance : undefined;\n  const { opts } = slopForStrokeHit(screen, rotation);\n  if (pathLike) {\n    // Precise inside-filled-region OR within-stroke-slop. Replaces the old\n    // \"AABB-conservative-fallback\" path that returned true anywhere inside\n    // the path's bounding box (which over-picked on open / non-convex paths).\n    if (pointInPath(pose, x, y)) return true;\n    return strokeHitTest(pose, x, y, reach, opts);\n  }\n  const b = aabbOfPose(pose, descriptor);\n  // `reach` is the caller's budget for being at least as generous as whatever\n  // refinement follows: the stroke's outward reach, which this function\n  // cannot see. Grown square, so it contains the round band the refinement\n  // tests.\n  const grown = {\n    kind: 'rect' as const,\n    x: b.x - reach, y: b.y - reach, width: b.width + 2 * reach, height: b.height + 2 * reach,\n  };\n  if (pointInPath(grown, x, y)) return true;\n  return hasSlop(screen) && strokeHitTest(grown, x, y, 0, opts);\n}\n\nfunction rotationAboutCenter<TPose>(\n  pose: TPose,\n  descriptor: PoseDescriptor<unknown>,\n): { cx: number; cy: number; rotation: number } | null {\n  const rotation = descriptor.getRotation?.(pose) ?? 0;\n  if (!rotation) return null;\n  const b = descriptor.getBounds(pose);\n  return { cx: b.x + b.width / 2, cy: b.y + b.height / 2, rotation };\n}\n"],"mappings":";;;;;AAiBA,SAAgBA,EACd,GACA,IAAsCC,GAC9B;CACR,OAAOC,EAAW,UAAUC,CAAI;AAClC;AAKA,IAAMC,IAA2B;AAgBjC,SAAgBC,EACd,GACA,GACA,GACA,GACA,IAAsCJ,GAC7B;CACT,OAAOK,EAAgBH,GAAMI,GAAIC,GAAIC,GAAWP,GAAY,CAAC;AAC/D;AAaA,SAAgBQ,EACd,GACA,GACA,GACA,GACA,IAAsCT,GAC7B;CACT,IAAMU,IAAIT,MAAeD,IACrBW,EAAeT,CAAI,IACnBU,EAAoBV,GAAMD,CAAU;CACxC,IAAIS,GAAG;EAIL,IAAM,CAACG,GAAIC,KAAMC,EAAaC,EAAiBN,EAAE,IAAIA,EAAE,IAAI,CAACA,EAAE,QAAQ,GAAGJ,GAAIC,CAAE;EAC/E,OAAOF,EAAgBH,GAAMW,GAAIC,GAAIN,GAAWP,GAAYS,EAAE,QAAQ;CACxE;CACA,OAAOL,EAAgBH,GAAMI,GAAIC,GAAIC,GAAWP,GAAY,CAAC;AAC/D;AAGA,SAASI,EACP,GACA,GACA,GACA,GACA,GACA,GACS;CACT,IAAMY,IAAWC,EAAWhB,CAAI,GAC1BiB,IAAQX,MAAc,KAAA,IACvBS,IAAWd,IAA2B,IACvC,OAAOK,KAAc,WAAWA,IAAaA,EAAU,SAAS,GAC9DY,IAAS,OAAOZ,KAAc,WAAWA,IAAY,KAAA,GACrD,EAAE,YAASa,EAAiBD,GAAQE,CAAQ;CAClD,IAAIL,GAKF,OADIM,EAAYrB,GAAMsB,GAAGC,CAAC,IAAU,KAC7BC,EAAcxB,GAAMsB,GAAGC,GAAGN,GAAOQ,CAAI;CAE9C,IAAMC,IAAI7B,EAAWG,GAAMD,CAAU,GAK/B4B,IAAQ;EACZ,MAAM;EACN,GAAGD,EAAE,IAAIT;EAAO,GAAGS,EAAE,IAAIT;EAAO,OAAOS,EAAE,QAAQ,IAAIT;EAAO,QAAQS,EAAE,SAAS,IAAIT;CACrF;CAEA,OADII,EAAYM,GAAOL,GAAGC,CAAC,IAAU,KAC9BK,EAAQV,CAAM,KAAKM,EAAcG,GAAOL,GAAGC,GAAG,GAAGE,CAAI;AAC9D;AAEA,SAASf,EACP,GACA,GACqD;CACrD,IAAMU,IAAWrB,EAAW,cAAcC,CAAI,KAAK;CACnD,IAAI,CAACoB,GAAU,OAAO;CACtB,IAAMM,IAAI3B,EAAW,UAAUC,CAAI;CACnC,OAAO;EAAE,IAAI0B,EAAE,IAAIA,EAAE,QAAQ;EAAG,IAAIA,EAAE,IAAIA,EAAE,SAAS;EAAG;CAAS;AACnE"}

package/dist/canvas/SceneCanvas/useActionsPropResolver.js

@@ -0,0 +1,48 @@
+import { useEffect as e } from "react";
+import { useLatest as t } from "@weasel-js/react";
+import { useActionsRegistry as n } from "@weasel-js/routing/react";
+//#region src/canvas/SceneCanvas/useActionsPropResolver.ts
+function r(r, i) {
+	let a = n(), o = t(r);
+	e(() => {
+		if (!a) return;
+		let e = o.current, t = [];
+		if (e === null) {
+			for (let e of a.list().map((e) => e.id)) t.push(a.mute(e));
+			return () => {
+				for (let e of t) e();
+			};
+		}
+		if (!e) return;
+		let n = /* @__PURE__ */ new Set();
+		for (let [r, i] of Object.entries(e)) {
+			if (i === null) {
+				t.push(a.mute(r));
+				continue;
+			}
+			let e = (e) => typeof e.id == "string" && typeof e.label == "string" && !!e.invoker, o = a.list().find((e) => e.id === r);
+			if (!o) {
+				e(i) ? t.push(a.register(i)) : n.has(r) || (n.add(r), console.warn(`weasel actions resolver: actions["${r}"] is a partial Action but no default with this id exists. Pass a complete {id, label, invoker} descriptor.`));
+				continue;
+			}
+			i.id !== void 0 && i.id !== r && !n.has(`mismatch:${r}`) && (n.add(`mismatch:${r}`), console.warn(`weasel actions resolver: actions["${r}"].id="${i.id}" mismatches the slot key. Ignoring the id field; the action remains at id="${r}".`));
+			let { id: s, ...c } = i, l = {
+				...o,
+				...c
+			};
+			t.push(a.register(l));
+		}
+		return () => {
+			for (let e of t) e();
+		};
+	}, [
+		a,
+		r,
+		o,
+		i
+	]);
+}
+//#endregion
+export { r as useActionsPropResolver };
+
+//# sourceMappingURL=useActionsPropResolver.js.map

package/dist/canvas/SceneCanvas/useActionsPropResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActionsPropResolver.js","names":["useActionsPropResolver","reg","useActionsRegistry","actionsRef","useLatest","actions","prop","unregisters","id","a","u","warnedIds","slotId","entry","isFull","existing","_drop","rest","merged","rev"],"sources":["../../../src/canvas/SceneCanvas/useActionsPropResolver.ts"],"sourcesContent":["/**\n * `useActionsPropResolver` — applies the `actions` prop overrides on top of\n * whatever `useStandardActions` registered. Runs after it (caller mounts this\n * hook last). Resolution rules:\n *\n *   actions === null           → mute every currently-registered action\n *   actions[id] === null       → mute that id\n *   actions[id] = partial      → merge onto the existing descriptor (slot wins\n *                                over entry.id; warns once on mismatch)\n *   actions[id] = full (new)   → register alongside defaults\n *\n * `null` mutes rather than unregisters: the opt-out belongs to this canvas, so\n * a sibling sharing the registry keeps the action and this canvas's unmount\n * gives it back.\n */\nimport { useEffect } from 'react';\nimport type { ActionsProp } from '@weasel-js/routing';\nimport { useActionsRegistry } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Action } from '@weasel-js/routing';\n\n/** `rev` re-applies the overrides when it changes — pass whatever changes when\n *  the set they sit on is re-registered. */\nexport function useActionsPropResolver(actions: ActionsProp | undefined, rev?: string): void {\n  const reg = useActionsRegistry();\n  const actionsRef = useLatest(actions);\n\n  useEffect(() => {\n    if (!reg) return;\n    const prop = actionsRef.current;\n\n    const unregisters: Array<() => void> = [];\n\n    if (prop === null) {\n      for (const id of reg.list().map((a) => a.id)) unregisters.push(reg.mute(id));\n      return () => { for (const u of unregisters) u(); };\n    }\n\n    if (!prop) return;\n\n    const warnedIds = new Set<string>();\n\n    for (const [slotId, entry] of Object.entries(prop)) {\n      if (entry === null) {\n        unregisters.push(reg.mute(slotId));\n        continue;\n      }\n\n      const isFull = (e: Partial<Action>): e is Action =>\n        typeof e.id === 'string' && typeof e.label === 'string' && !!e.invoker;\n      const existing = reg.list().find((a) => a.id === slotId);\n\n      if (!existing) {\n        if (isFull(entry)) {\n          unregisters.push(reg.register(entry));\n        } else if (!warnedIds.has(slotId)) {\n          warnedIds.add(slotId);\n          console.warn(\n            `weasel actions resolver: actions[\"${slotId}\"] is a partial Action but no default ` +\n            `with this id exists. Pass a complete {id, label, invoker} descriptor.`,\n          );\n        }\n        continue;\n      }\n\n      if (entry.id !== undefined && entry.id !== slotId && !warnedIds.has(`mismatch:${slotId}`)) {\n        warnedIds.add(`mismatch:${slotId}`);\n        console.warn(\n          `weasel actions resolver: actions[\"${slotId}\"].id=\"${entry.id as string}\" mismatches the slot key. ` +\n          `Ignoring the id field; the action remains at id=\"${slotId}\".`,\n        );\n      }\n      const { id: _drop, ...rest } = entry;\n      void _drop;\n      const merged: Action = { ...existing, ...rest };\n      // No explicit restore: `register` stacks, so popping `merged` uncovers\n      // the descriptor it displaced. Re-registering `existing` here would push\n      // a stale snapshot back on top and never take it off again.\n      unregisters.push(reg.register(merged));\n    }\n\n    return () => { for (const u of unregisters) u(); };\n  }, [reg, actions, actionsRef, rev]);\n}\n"],"mappings":";;;;AAuBA,SAAgBA,EAAuB,GAAkC,GAAoB;CAC3F,IAAMC,IAAMC,EAAmB,GACzBC,IAAaC,EAAUC,CAAO;CAEpC,QAAgB;EACd,IAAI,CAACJ,GAAK;EACV,IAAMK,IAAOH,EAAW,SAElBI,IAAiC,CAAC;EAExC,IAAID,MAAS,MAAM;GACjB,KAAK,IAAME,KAAMP,EAAI,KAAK,CAAC,CAAC,KAAK,MAAMQ,EAAE,EAAE,GAAG,EAAY,KAAKR,EAAI,KAAKO,CAAE,CAAC;GAC3E,aAAa;IAAE,KAAK,IAAME,KAAKH,GAAa,EAAE;GAAG;EACnD;EAEA,IAAI,CAACD,GAAM;EAEX,IAAMK,oBAAY,IAAI,IAAY;EAElC,KAAK,IAAM,CAACC,GAAQC,MAAU,OAAO,QAAQP,CAAI,GAAG;GAClD,IAAIO,MAAU,MAAM;IAClB,EAAY,KAAKZ,EAAI,KAAKW,CAAM,CAAC;IACjC;GACF;GAEA,IAAME,KAAU,MACd,OAAO,EAAE,MAAO,YAAY,OAAO,EAAE,SAAU,YAAY,CAAC,CAAC,EAAE,SAC3DC,IAAWd,EAAI,KAAK,CAAC,CAAC,MAAM,MAAMQ,EAAE,OAAOG,CAAM;GAEvD,IAAI,CAACG,GAAU;IACb,AAAID,EAAOD,CAAK,IACdN,EAAY,KAAKN,EAAI,SAASY,CAAK,CAAC,IAC1BF,EAAU,IAAIC,CAAM,MAC9BD,EAAU,IAAIC,CAAM,GACpB,QAAQ,KACN,qCAAqCA,EAAO,4GAE9C;IAEF;GACF;GAEA,AAAIC,EAAM,OAAO,KAAA,KAAaA,EAAM,OAAOD,KAAU,CAACD,EAAU,IAAI,YAAYC,GAAQ,MACtFD,EAAU,IAAI,YAAYC,GAAQ,GAClC,QAAQ,KACN,qCAAqCA,EAAO,SAASC,EAAM,GAAa,8EACpBD,EAAO,GAC7D;GAEF,IAAM,EAAE,IAAII,GAAO,GAAGC,MAASJ,GAEzBK,IAAiB;IAAE,GAAGH;IAAU,GAAGE;GAAK;GAI9C,EAAY,KAAKhB,EAAI,SAASiB,CAAM,CAAC;EACvC;EAEA,aAAa;GAAE,KAAK,IAAMR,KAAKH,GAAa,EAAE;EAAG;CACnD,GAAG;EAACN;EAAKI;EAASF;EAAYgB;CAAG,CAAC;AACpC"}

package/dist/canvas/SceneCanvas/useBuiltinShapeTools.js

@@ -0,0 +1,70 @@
+import { asNodeId as e } from "../../core/scene/types.js";
+import "../../core/shapeKinds.js";
+import { cycleFill as t, solid as n, strokeOf as r } from "../../util/paint.js";
+import { useTextTool as i } from "../../tools/builtin/text/useTextTool.js";
+import { usePenTool as a } from "../../tools/builtin/pen/usePenTool.js";
+import { useRectTool as o } from "../../tools/builtin/rect/useRectTool.js";
+import { useEllipseTool as s } from "../../tools/builtin/ellipse/useEllipseTool.js";
+import { useLineTool as c } from "../../tools/builtin/line/useLineTool.js";
+import { useLassoTool as l } from "../../tools/builtin/lasso/useLassoTool.js";
+import { usePolygonTool as u } from "../../tools/builtin/polygon/usePolygonTool.js";
+import { useStarTool as d } from "../../tools/builtin/star/useStarTool.js";
+import { usePencilTool as f } from "../../tools/builtin/pencil/usePencilTool.js";
+import { boundsOfPath as p } from "@weasel-js/geom";
+import { useRef as m } from "react";
+//#region src/canvas/SceneCanvas/useBuiltinShapeTools.tsx
+function h(h) {
+	let { scene: g, adapter: _, options: v } = h, y = m(0), b = (t) => e(`${t}-${++y.current}`), x = () => t(y.current), S = () => g.layers[0]?.id ?? "default", C = (e, t, n) => ({
+		id: e,
+		kind: "leaf",
+		layer: S(),
+		pose: t,
+		data: n,
+		parent: null
+	}), w = v?.snapPoint, T = v?.insert ?? {}, E = o(T), D = s(T), O = c(T), k = u(T), A = d(T), j = f(T), M = (e) => {
+		let t = b("pn"), i = x();
+		return C(t, e.bounds, {
+			path: e.path,
+			fill: e.closed ? n(x()) : null,
+			stroke: r(i, 2)
+		});
+	};
+	return {
+		rect: E,
+		ellipse: D,
+		line: O,
+		polygon: k,
+		star: A,
+		pen: a({
+			snapPoint: w,
+			wrapPath: (e, { closed: t }) => {
+				let n = p(e);
+				return {
+					path: e,
+					closed: t,
+					bounds: {
+						x: n.x,
+						y: n.y,
+						width: n.width,
+						height: n.height
+					}
+				};
+			},
+			adapter: {
+				addNode: (e) => {
+					let t = M(e);
+					return _.insertNode(t), String(t.id);
+				},
+				makeNode: (e) => M(e),
+				setSelection: (e) => _.setSelection(e)
+			}
+		}),
+		pencil: j,
+		lasso: l(_, v?.lasso ?? {}),
+		text: i(T)
+	};
+}
+//#endregion
+export { h as useBuiltinShapeTools };
+
+//# sourceMappingURL=useBuiltinShapeTools.js.map

package/dist/canvas/SceneCanvas/useBuiltinShapeTools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBuiltinShapeTools.js","names":["useBuiltinShapeTools","args","seqRef","useRef","freshId","asNodeId","prefix","nextFill","cycleFill","layerOf","scene","makeLeaf","snapPoint","options","insert","rect","useRectTool","ellipse","useEllipseTool","line","useLineTool","polygon","usePolygonTool","star","useStarTool","pencil","usePencilTool","makePenLeaf","id","color","carrier","solid","strokeOf","usePenTool","b","boundsOfPath","path","node","adapter","ids","useLassoTool","useTextTool"],"sources":["../../../src/canvas/SceneCanvas/useBuiltinShapeTools.tsx"],"sourcesContent":["/**\n * Shape-tool synthesis for `<SceneCanvas>` — calls the kit's per-shape tool\n * hooks with default `create` callbacks that produce leaf nodes shaped for\n * the kit's PATH_PAINTER (`data: { path, fill }`). Lets consumers opt into\n * a complete drawing toolset via `<SceneCanvas defaultTools={['rect', 'ellipse']}>`\n * without writing per-tool factory code.\n *\n * All hooks are always called (React rules of hooks) — `<SceneCanvas>` only\n * registers the ones requested via `defaultTools`.\n */\nimport { useRef } from 'react';\nimport { asNodeId } from 'core/scene/types';\nimport { boundsOfPath } from '@weasel-js/geom';\nimport { cycleFill, solid, strokeOf } from '../../util/paint';\nimport { useEllipseTool } from 'tools/builtin/ellipse/useEllipseTool';\nimport { useLassoTool } from 'tools/builtin/lasso/useLassoTool';\nimport { useLineTool } from 'tools/builtin/line/useLineTool';\nimport { usePencilTool } from 'tools/builtin/pencil/usePencilTool';\nimport { usePenTool } from 'tools/builtin/pen/usePenTool';\nimport { usePolygonTool } from 'tools/builtin/polygon/usePolygonTool';\nimport { useRectTool } from 'tools/builtin/rect/useRectTool';\nimport { useStarTool } from 'tools/builtin/star/useStarTool';\nimport { useTextTool } from 'tools/builtin/text/useTextTool';\nimport type { AnyTool, FillStyle, InsertToolOptions, LassoHitMode, NodeId, Path, PolygonPath, Scene, SceneNode, Stroke } from '@weasel-js/core';\nimport type { SceneCanvasAdapter } from '../sceneAdapter';\nimport type { BuiltinShapeToolId } from 'core/shapeKinds';\n\n/** Per-tool option overrides for the built-in shape/lasso tools.\n *  Each entry is a narrow subset of the underlying hook's options surface\n *  — just the knobs that need consumer control under the bundle pattern. */\nexport interface BuiltinToolOptions {\n  lasso?: { mode?: LassoHitMode };\n  /** Insert-action options for every drag-to-insert tool (rect / ellipse /\n   *  line / polygon / star / pencil / text): `behaviors` become each insert\n   *  binding's `opts.behaviors`, the way `selectTool.move.behaviors` do for\n   *  move. */\n  insert?: InsertToolOptions;\n  /** Snap world-space points to the active grid (or any other snap target).\n   *\n   *  Registered as the `snap` dep, which `insertAction` applies to the\n   *  drag start and current point — so the live preview and the committed\n   *  geometry agree — and which the pen tool reads for its own anchor\n   *  placement. Covers every drag-to-insert tool (rect / ellipse / line /\n   *  polygon / star / text); freehand pencil samples are deliberately left\n   *  unsnapped. */\n  snapPoint?: (p: { x: number; y: number }) => { x: number; y: number };\n}\n\n// `BuiltinShapeToolId` / `KIT_SHAPE_KINDS` derive from the `core/shapeKinds`\n// table, a dependency-free module, so barrel-reachable code can reach them\n// without entering this file's `@weasel-js/core` self-import cycle.\n// Re-exported here so existing importers of this module keep working.\nexport { KIT_SHAPE_KINDS } from 'core/shapeKinds';\nexport type { BuiltinShapeToolId } from 'core/shapeKinds';\n\nexport interface UseBuiltinShapeToolsArgs<TData, TLayer extends string, TPose> {\n  scene: Scene<TData, TLayer, TPose>;\n  adapter: SceneCanvasAdapter<TData, TLayer, TPose>;\n  /** Per-tool option overrides (lasso mode, etc.). */\n  options?: BuiltinToolOptions;\n}\n\nexport type BuiltinShapeTools = Record<BuiltinShapeToolId, AnyTool>;\n\n/** Synthesize the full shape-tool registry. Hooks always run; consumers\n *  decide via `wants(...)` which to register with `useTools`. */\nexport function useBuiltinShapeTools<TData, TLayer extends string, TPose>(\n  args: UseBuiltinShapeToolsArgs<TData, TLayer, TPose>,\n): BuiltinShapeTools {\n  const { scene, adapter, options } = args;\n\n  // Per-canvas counter + fill cycler. Refs survive renders and stay\n  // private to the SceneCanvas instance.\n  const seqRef = useRef(0);\n  const freshId = (prefix: string) => asNodeId(`${prefix}-${++seqRef.current}`);\n  const nextFill = () => cycleFill(seqRef.current);\n\n  // First system-or-trivial layer is the default insertion layer. Falls back\n  // to 'default' when the scene has none yet (rare — useScene synthesizes\n  // a 'default' layer when systemLayers is omitted).\n  const layerOf = (): TLayer => (scene.layers[0]?.id ?? ('default' as TLayer));\n\n  // Helper to build the kit's leaf-node template — `data: { path, fill }`\n  // matches PATH_PAINTER's `matches`/`paint` contract. The cast through\n  // `unknown` reflects the kit's intentional looseness around TData when\n  // synthesized defaults are in play.\n  type Pose = { x: number; y: number; width: number; height: number };\n  const makeLeaf = (\n    id: NodeId,\n    pose: Pose,\n    data: { path: Path; fill: FillStyle | null; stroke?: Stroke; text?: string },\n  ): SceneNode<TData, TLayer, TPose> => ({\n    id,\n    kind: 'leaf',\n    layer: layerOf(),\n    pose: pose as unknown as TPose,\n    data: data as unknown as TData,\n    parent: null,\n  });\n\n  type LeafNode = SceneNode<TData, TLayer, TPose> & { id: NodeId };\n\n  const snapPoint = options?.snapPoint;\n  // Every drag-to-insert tool is a declarative shell: the drag is owned by\n  // the dispatcher's `insertAction` and the node is minted by the `insert`\n  // dep (`useInsertDepSource`). Tool-side `create` factories were removed\n  // when the dispatcher took over — consumers wanting custom node\n  // factories override the dep, not the tool.\n  const insert = options?.insert ?? {};\n  const rect = useRectTool(insert);\n  const ellipse = useEllipseTool(insert);\n  const line = useLineTool(insert);\n  const polygon = usePolygonTool(insert);\n  const star = useStarTool(insert);\n  const pencil = usePencilTool(insert);\n  // Pen: takes an opaque \"pose\" carrier (here, the committed PolygonPath +\n  // closed flag + AABB) and an addNode/setSelection adapter. We construct\n  // the carrier in `wrapPath` and unpack it in `addNode` into a\n  // PATH_PAINTER-shaped leaf. (Pen is the one built-in still commiting\n  // through its own adapter rather than the `insert` dep — see §4b of the\n  // 2026-07-27 inspector handoff.)\n  // Editing a committed path is not the pen's job — double-click it to\n  // enter anchor-edit mode (see `usePenTool`'s PenScratch docs).\n  type PenCarrier = { path: PolygonPath; closed: boolean; bounds: { x: number; y: number; width: number; height: number } };\n  const makePenLeaf = (carrier: PenCarrier): LeafNode => {\n    const id = freshId('pn');\n    const color = nextFill();\n    return makeLeaf(id, carrier.bounds, {\n      path: carrier.path,\n      fill: carrier.closed ? solid(nextFill()) : null,\n      stroke: strokeOf(color, 2),\n    }) as LeafNode;\n  };\n  const pen = usePenTool<PenCarrier>({\n    snapPoint,\n    wrapPath: (path, { closed }): PenCarrier => {\n      const b = boundsOfPath(path);\n      return { path, closed, bounds: { x: b.x, y: b.y, width: b.width, height: b.height } };\n    },\n    adapter: {\n      addNode: (carrier) => {\n        const node = makePenLeaf(carrier);\n        adapter.insertNode(node);\n        return String(node.id);\n      },\n      makeNode: (carrier) => makePenLeaf(carrier),\n      setSelection: (ids) => adapter.setSelection(ids),\n    },\n  });\n  const lasso = useLassoTool(adapter, options?.lasso ?? {});\n  const text = useTextTool(insert);\n  return { rect, ellipse, line, polygon, star, pen, pencil, lasso, text };\n}\n"],"mappings":";;;;;;;;;;;;;;;AAkEA,SAAgBA,EACd,GACmB;CACnB,IAAM,EAAE,UAAO,YAAS,eAAYC,GAI9BC,IAASC,EAAO,CAAC,GACjBC,KAAW,MAAmBC,EAAS,GAAGC,EAAO,GAAG,EAAEJ,EAAO,SAAS,GACtEK,UAAiBC,EAAUN,EAAO,OAAO,GAKzCO,UAAyBC,EAAM,OAAO,EAAE,EAAE,MAAO,WAOjDC,KACJ,GACA,GACA,OACqC;EACrC;EACA,MAAM;EACN,OAAOF,EAAQ;EACT;EACA;EACN,QAAQ;CACV,IAIMG,IAAYC,GAAS,WAMrBC,IAASD,GAAS,UAAU,CAAC,GAC7BE,IAAOC,EAAYF,CAAM,GACzBG,IAAUC,EAAeJ,CAAM,GAC/BK,IAAOC,EAAYN,CAAM,GACzBO,IAAUC,EAAeR,CAAM,GAC/BS,IAAOC,EAAYV,CAAM,GACzBW,IAASC,EAAcZ,CAAM,GAU7Ba,KAAe,MAAkC;EACrD,IAAMC,IAAKxB,EAAQ,IAAI,GACjByB,IAAQtB,EAAS;EACvB,OAAOI,EAASiB,GAAIE,EAAQ,QAAQ;GAClC,MAAMA,EAAQ;GACd,MAAMA,EAAQ,SAASC,EAAMxB,EAAS,CAAC,IAAI;GAC3C,QAAQyB,EAASH,GAAO,CAAC;EAC3B,CAAC;CACH;CAmBA,OAAO;EAAE;EAAM;EAAS;EAAM;EAAS;EAAM,KAlBjCI,EAAuB;GACjC;GACA,WAAW,GAAM,EAAE,gBAAyB;IAC1C,IAAMC,IAAIC,EAAaC,CAAI;IAC3B,OAAO;KAAE;KAAM;KAAQ,QAAQ;MAAE,GAAGF,EAAE;MAAG,GAAGA,EAAE;MAAG,OAAOA,EAAE;MAAO,QAAQA,EAAE;KAAO;IAAE;GACtF;GACA,SAAS;IACP,UAAU,MAAY;KACpB,IAAMG,IAAOV,EAAYG,CAAO;KAEhC,OADAQ,EAAQ,WAAWD,CAAI,GAChB,OAAOA,EAAK,EAAE;IACvB;IACA,WAAW,MAAYV,EAAYG,CAAO;IAC1C,eAAe,MAAQQ,EAAQ,aAAaC,CAAG;GACjD;EACF,CAG6C;EAAK;EAAQ,OAF5CC,EAAaF,GAASzB,GAAS,SAAS,CAAC,CAEG;EAAO,MADpD4B,EAAY3B,CACwC;CAAK;AACxE"}

package/dist/canvas/SceneCanvas/useContributionRoles.js

@@ -0,0 +1,75 @@
+import { checkRequirements as e } from "../kitRequirements.js";
+import { useContributionFrameHooks as t } from "./contributionFrameHooks.js";
+import { useEffect as n, useRef as r } from "react";
+import { useActionsRegistry as i, useOffhandAction as a, useOptionalDepRegistry as o } from "@weasel-js/routing/react";
+//#region src/canvas/SceneCanvas/useContributionRoles.ts
+var s = { get: () => void 0 }, c = /* @__PURE__ */ new WeakSet();
+function l(e) {
+	switch (e.reason) {
+		case "unsatisfied": return `${e.package} ${e.range} (running ${e.running})`;
+		case "invalid-range": return `${e.package} "${e.range}", which is not a range this check reads`;
+		case "unknown-package": return `${e.package} ${e.range}, but ${e.package} reports no version`;
+	}
+}
+function u(t, n) {
+	if (n !== "off") for (let r of t) {
+		let t = r.requires;
+		if (!t || n === "warn" && c.has(t)) continue;
+		let i = e(t);
+		if (i.length === 0) continue;
+		let a = `[weasel] contribution "${r.id}" requires ${i.map(l).join("; ")}.`;
+		if (n === "strict") throw Error(a);
+		c.add(t), console.warn(a);
+	}
+}
+function d(e) {
+	return [...Object.values(e.registry), ...e.ambient];
+}
+function f(e) {
+	let t = r(/* @__PURE__ */ new Map());
+	n(() => {
+		for (let [n, r] of t.current) e.has(n) || (r(), t.current.delete(n));
+		for (let [n, r] of e) t.current.has(n) || t.current.set(n, r());
+	}), n(() => () => {
+		for (let e of t.current.values()) e();
+		t.current.clear();
+	}, []);
+}
+function p(e, r, c = "warn") {
+	let l = i(), p = o(), { registry: h, ambient: g } = e;
+	n(() => {
+		if (!l) return;
+		let e = [];
+		for (let t of d({
+			registry: h,
+			ambient: g
+		})) for (let n of t.actions ?? []) e.push(l.register(n));
+		return () => {
+			for (let t of e) t();
+		};
+	}, [
+		l,
+		h,
+		g
+	]);
+	let _ = d(e);
+	(c === "strict" || c === "warn" && process.env.NODE_ENV !== "production") && u(_, c);
+	let v = p ?? s, y = /* @__PURE__ */ new Map();
+	for (let e of _) {
+		let t = e.deps;
+		t && p && y.set(t, () => m(p, t));
+		let n = e.attach;
+		n && r && y.set(n, () => n(r, v));
+	}
+	f(y), t(_, r, v), a(d(e));
+}
+function m(e, t) {
+	let n = Object.keys(t).map((n) => e.register(n, t[n]));
+	return () => {
+		for (let e of n) e();
+	};
+}
+//#endregion
+export { d as contributionEntries, p as useContributionRoles };
+
+//# sourceMappingURL=useContributionRoles.js.map

package/dist/canvas/SceneCanvas/useContributionRoles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useContributionRoles.js","names":["NO_DEPS","warnedRequirements","describeMismatch","m","checkEntryRequirements","mode","entry","entries","requires","mismatches","checkRequirements","message","contributionEntries","tools","useKeyedInstall","live","useRef","useEffect","key","teardown","items","install","useContributionRoles","registry","useActionsRegistry","depRegistry","useOptionalDepRegistry","toolRegistry","unregisters","action","u","ambient","versionCheck","reader","installs","deps","registerDeps","attach","api","useContributionFrameHooks","useOffhandAction","name"],"sources":["../../../src/canvas/SceneCanvas/useContributionRoles.ts"],"sourcesContent":["/**\n * `useContributionRoles` — installs the roles of every entry in the tools\n * registry that a surface owns rather than the dispatcher: its actions into the\n * `<ActionsProvider>`, its deps into the dep registry, and its `attach` against\n * the mounted canvas. Views are the fourth such role; `<SceneCanvas>` renders\n * those itself, because a view is a component.\n *\n * Tool hooks run wherever the consumer calls them, which may be outside any\n * registry. Declaring roles on the entry and installing them from in here keeps\n * the tool hook callable from anywhere.\n */\nimport { useEffect, useRef } from 'react';\nimport { useActionsRegistry, useOffhandAction, useOptionalDepRegistry } from '@weasel-js/routing/react';\nimport type { DepRegistry } from '@weasel-js/routing/react';\nimport type { DepName } from 'interactions/actions/depSchema';\nimport type { ToolsApi } from '../../tools/overlayBinding';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport type { SurfaceContribution } from '../surfaceContribution';\nimport { checkRequirements, type RequirementMismatch } from '../kitRequirements';\nimport { useContributionFrameHooks } from './contributionFrameHooks';\n\n/** How a surface treats an entry whose `requires` the running kit does not\n *  meet: warn in development (the default), throw, or not check. */\nexport type VersionCheck = 'warn' | 'strict' | 'off';\n\nconst NO_DEPS = { get: () => undefined };\nconst warnedRequirements = new WeakSet<object>();\n\nfunction describeMismatch(m: RequirementMismatch): string {\n  switch (m.reason) {\n    case 'unsatisfied': return `${m.package} ${m.range} (running ${m.running})`;\n    case 'invalid-range': return `${m.package} \"${m.range}\", which is not a range this check reads`;\n    case 'unknown-package': return `${m.package} ${m.range}, but ${m.package} reports no version`;\n  }\n}\n\nfunction checkEntryRequirements(entries: readonly SurfaceContribution[], mode: VersionCheck): void {\n  if (mode === 'off') return;\n  for (const entry of entries) {\n    const requires = entry.requires;\n    if (!requires) continue;\n    if (mode === 'warn' && warnedRequirements.has(requires)) continue;\n    const mismatches = checkRequirements(requires);\n    if (mismatches.length === 0) continue;\n    const message = `[weasel] contribution \"${entry.id}\" requires ${mismatches.map(describeMismatch).join('; ')}.`;\n    if (mode === 'strict') throw new Error(message);\n    warnedRequirements.add(requires);\n    console.warn(message);\n  }\n}\n\n/** Every entry the registry holds, registry and ambient alike. */\nexport function contributionEntries(tools: Pick<ToolsApi, 'registry' | 'ambient'>): SurfaceContribution[] {\n  return [...Object.values(tools.registry), ...tools.ambient] as SurfaceContribution[];\n}\n\n/**\n * Keep one installation per key alive: install keys that appeared, tear down\n * keys that went. Keys are role objects the consumer owns, so an entry the\n * host re-wraps every render — `useTools` restates eligibility on a copy —\n * still installs once.\n */\nfunction useKeyedInstall(\n  items: ReadonlyMap<object, () => () => void>,\n): void {\n  const live = useRef(new Map<object, () => void>());\n  useEffect(() => {\n    for (const [key, teardown] of live.current) {\n      if (items.has(key)) continue;\n      teardown();\n      live.current.delete(key);\n    }\n    for (const [key, install] of items) {\n      if (live.current.has(key)) continue;\n      live.current.set(key, install());\n    }\n  });\n  useEffect(() => () => {\n    for (const teardown of live.current.values()) teardown();\n    live.current.clear();\n  }, []);\n}\n\nexport function useContributionRoles(\n  tools: ToolsApi,\n  api: CanvasExtensionApi | null,\n  versionCheck: VersionCheck = 'warn',\n): void {\n  const registry = useActionsRegistry();\n  const depRegistry = useOptionalDepRegistry();\n  const { registry: toolRegistry, ambient } = tools;\n\n  useEffect(() => {\n    if (!registry) return;\n    const unregisters: Array<() => void> = [];\n    // Ambient entries included: an always-on entry owns actions its own\n    // bindings reference exactly as a registry tool does, and leaving them out\n    // gives the same silent failure this hook exists to prevent — a binding\n    // pointing at an id nothing registered.\n    for (const entry of contributionEntries({ registry: toolRegistry, ambient })) {\n      for (const action of entry.actions ?? []) {\n        unregisters.push(registry.register(action));\n      }\n    }\n    return () => { for (const u of unregisters) u(); };\n  }, [registry, toolRegistry, ambient]);\n\n  const entries = contributionEntries(tools);\n  // Development only for a warning; a strict surface asked to be stopped, so\n  // it throws in every build.\n  if (versionCheck === 'strict' || (versionCheck === 'warn' && process.env.NODE_ENV !== 'production')) {\n    checkEntryRequirements(entries, versionCheck);\n  }\n\n  const reader = depRegistry ?? NO_DEPS;\n  const installs = new Map<object, () => () => void>();\n  for (const entry of entries) {\n    const deps = entry.deps;\n    if (deps && depRegistry) installs.set(deps, () => registerDeps(depRegistry, deps));\n    const attach = entry.attach;\n    if (attach && api) installs.set(attach, () => attach(api, reader));\n  }\n  useKeyedInstall(installs);\n  useContributionFrameHooks(entries, api, reader);\n\n  // Tool assembly runs above the provider too, so its own registration of\n  // held-key engagement finds no registry unless the consumer mounted one.\n  useOffhandAction(contributionEntries(tools));\n}\n\nfunction registerDeps(\n  depRegistry: DepRegistry,\n  deps: NonNullable<SurfaceContribution['deps']>,\n): () => void {\n  const unregisters = (Object.keys(deps) as DepName[]).map((name) =>\n    depRegistry.register(name, deps[name] as never));\n  return () => { for (const u of unregisters) u(); };\n}\n"],"mappings":"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"}