@weasel-js/core 1.11.0 → 1.12.0

package/dist/types-oFeQ5VjV.d.ts

@@ -0,0 +1,264 @@
+import { L as LayoutStrategy, P as ParallaxOpts } from './types-7puAuVD2.js';
+import { Op } from '@weasel-js/history';
+import { View } from '@weasel-js/geom';
+import { P as PoseDescriptor } from './poseDescriptor-DN2yfnq_.js';
+import { Target } from '@weasel-js/animator';
+
+/**
+ * Opaque clipboard payload: the kit never inspects entries. The adapter both
+ * produces snapshots (`snapshotSelection`) and consumes them (`commitPaste`).
+ */
+interface ClipboardSnapshot {
+    items: unknown[];
+}
+/**
+ * A copied node a paste did not make, and why:
+ *
+ * - `dependency-not-copied` — it derives from the nodes in `missing`, which
+ *   were not copied with it.
+ * - `derivation-not-registered` — it derives from other nodes through a
+ *   function that did not survive the clipboard and is not in the scene's
+ *   registry.
+ * - `container-not-pasted` — its container was left out.
+ */
+interface PasteOmission {
+    /** The id the node had when it was copied. */
+    id: string;
+    reason: 'dependency-not-copied' | 'derivation-not-registered' | 'container-not-pasted';
+    missing?: string[];
+}
+/** What `commitPaste` is told beyond the snapshot and the offset. */
+interface PasteCtx {
+    dropPoint?: {
+        worldX: number;
+        worldY: number;
+    };
+    /** Called once per copied node the paste leaves out. */
+    onOmit?: (omission: PasteOmission) => void;
+}
+/**
+ * Where a dragged node would re-parent to if released. `slotPose` is the pose
+ * (in world coordinates) the node should snap to within the target;
+ * `metadata` is an opaque pass-through for app-specific snap details.
+ */
+interface SnapTarget<TPose = unknown> {
+    parentId: string;
+    slotPose: TPose;
+    metadata?: unknown;
+}
+/**
+ * The contracts below are slices: each names what one reader asks of an
+ * adapter. The whole of it, as the kit builds it over a `Scene`, is
+ * `SceneCanvasAdapter` (`sceneToAdapter`).
+ *
+ * **Pose semantics:** `getPose` / `setPose` work in **local** coordinates —
+ * relative to the node's direct parent (or world, for root-parented nodes).
+ * `getWorldPose`, where an adapter has it, is the composed reading.
+ *
+ * **Every adapter carries the tree:** `getNode`, `getParent`, and
+ * `getChildren`. A list with no nesting is a tree whose nodes are all roots:
+ * `getParent` answers `null` and `getChildren(null)` answers every id,
+ * bottom first.
+ */
+/** Narrow adapter for move. Apps without container-snapping leave out `findSnapTarget`. */
+interface MoveAdapter<TNode extends {
+    id: string;
+}, TPose> {
+    getNode(id: string): TNode | undefined;
+    getNodes(): TNode[];
+    getPose(id: string): TPose;
+    /** The node's container, `null` for a root. */
+    getParent(id: string): string | null;
+    /** Optional paint depth, read by `pickTopMostHit` to resolve two *siblings*
+     *  whose bodies both cover the pointer. Without it the hit list's own order
+     *  decides, which is right for a back-to-front walk and wrong for anything
+     *  else. See `PickTopMostHitAdapter` for the `compareZ` alternative. */
+    getZIndex?(id: string): number | null | undefined;
+    compareZ?(a: string, b: string): number;
+    setPose(id: string, pose: TPose): void;
+    /** Optional. Used only by reparent ops; an adapter that never reparents may omit. */
+    setParent?(id: string, parentId: string | null): void;
+    /** Optional. The commit point of a gesture. When omitted, ops are applied
+     *  against the adapter one by one; an adapter with a history of its own
+     *  takes them here as one entry. */
+    applyOps?(ops: Op[], label: string): void;
+    /** Optional. Show each node at its pose without writing the document, so
+     *  nothing is recorded; `null` withdraws a node's preview. What a behavior
+     *  that keeps moving nodes after the gesture ends writes each frame. */
+    previewPoses?(poses: ReadonlyMap<string, TPose | null>): void;
+    /** Optional. The animation target of node `id`'s pose, the same one on
+     *  every call, so everything animating the node adds; `descriptor` supplies
+     *  its axes the first time. `tweenPose`, `springPose`, and `momentum` move
+     *  it where it is there, and write `setPose` each frame where it is not or
+     *  it answers `undefined`. */
+    poseTarget?(id: string, descriptor?: PoseDescriptor<TPose>): Target<TPose> | undefined;
+    findSnapTarget?(draggedId: string, worldX: number, worldY: number): SnapTarget<TPose> | null;
+    /** Ordered children of `parentId`, `null` for the root siblings, in
+     *  z-order: index 0 is the bottom. One contract with
+     *  {@link OrderedAdapter.getChildren} — the two land on the same adapter
+     *  object. Picking walks it, and the ops read a node's sibling slot from it.
+     *  A node with no children answers `[]`. */
+    getChildren(parentId: string | null): string[];
+    /** Optional: layout strategy attached to a container, or null if the
+     *  container uses absolute positioning. When present, a move uses it to
+     *  compute drop targets, sibling reflow, and the commit op batch. */
+    getLayout?(containerId: string): LayoutStrategy<TPose> | null;
+}
+/** Narrow adapter for resize. */
+interface ResizeAdapter<TNode extends {
+    id: string;
+}, TPose> {
+    getNode(id: string): TNode | undefined;
+    getPose(id: string): TPose;
+    setPose(id: string, pose: TPose): void;
+    /** Optional: see MoveAdapter.applyOps. */
+    applyOps?(ops: Op[], label: string): void;
+}
+/** Narrow adapter for rotate, which mutates pose only and never reparents. */
+interface RotateAdapter<TNode extends {
+    id: string;
+}, TPose> {
+    getNode(id: string): TNode | undefined;
+    getPose(id: string): TPose;
+    setPose(id: string, pose: TPose): void;
+    /** Optional: see MoveAdapter.applyOps. */
+    applyOps?(ops: Op[], label: string): void;
+}
+/** The view a region pick answers for. */
+interface RegionPickView {
+    /** The camera the region was drawn under. With it, a node on a parallax
+     *  layer is tested where that camera's plane paints it. */
+    get?(): View;
+    /** Whether that view paints a layer at all. */
+    layerIsPainted?(layer: string): boolean;
+}
+/**
+ * Narrow adapter for marquee selection. Transient: no checkpoint, no
+ * history — `applyOps(ops)` is called with no label.
+ *
+ * All fields are **optional**. `useSelectTool` only wires the default marquee
+ * behavior when `hitTestArea`, `getSelection`, `setSelection`, and `applyOps`
+ * are all present on the adapter; otherwise empty-space drags do nothing.
+ */
+interface AreaSelectAdapter {
+    /** Returns ids of nodes intersecting the world-space rect, as the view the
+     *  rect was drawn in paints them. */
+    hitTestArea?(rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, view?: RegionPickView): string[];
+    /** Current selection — read by behaviors to compute additive merges. */
+    getSelection?(): string[];
+    /** Mutator wired by `setSelection` op. */
+    setSelection?(ids: string[]): void;
+    /** Apply ops without checkpointing or pushing a history entry. The optional
+     *  `label` parameter is accepted (and ignored by transient implementations)
+     *  so that this signature is compatible with `MoveAdapter.applyOps`. */
+    applyOps?(ops: Op[], label?: string): void;
+}
+/**
+ * Hit mode for `LassoSelectAdapter.hitTestLasso`:
+ *   - 'centers'   — the center of the node's visual bounds is inside the polygon.
+ *   - 'intersect' — the node's outline meets the polygon anywhere.
+ *   - 'enclosed'  — the node's whole outline is inside the polygon.
+ *
+ * The outline is the drawn silhouette, rotation included.
+ */
+type LassoHitMode = 'centers' | 'intersect' | 'enclosed';
+/**
+ * Narrow adapter for lasso selection: `AreaSelectAdapter` plus a polygon
+ * hit-test. `selectFromLasso` does nothing without `hitTestLasso`.
+ */
+interface LassoSelectAdapter extends AreaSelectAdapter {
+    /** Hit-test against a closed polygon. Vertex order may be CW or CCW; the
+     *  closing edge from last → first is implicit. */
+    hitTestLasso?(polygon: ReadonlyArray<{
+        x: number;
+        y: number;
+    }>, mode: LassoHitMode, view?: RegionPickView): string[];
+}
+/**
+ * Narrow adapter for insert and `useClipboardOps`. The kit knows nothing
+ * about what shape to construct; it asks the adapter to produce node(s) given
+ * gesture or paste inputs, and wraps each in an `InsertOp`.
+ */
+interface InsertAdapter<TNode extends {
+    id: string;
+}> {
+    getNode(id: string): TNode | undefined;
+    getParent(id: string): string | null;
+    /** Ordered children of `parentId`, `null` for the root siblings. An insert
+     *  resolves its sibling slot against it. */
+    getChildren(parentId: string | null): string[];
+    /** Materialize a new node from drag-rect bounds (drag-to-insert tools).
+     *  Optional: `sceneToAdapter` only fills it in when `options.commitInsert`
+     *  is supplied. */
+    commitInsert?(bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): TNode | null;
+    /** Materialize the new nodes from a clipboard snapshot, in order.
+     *  Optional — required only for paste. */
+    commitPaste?(clipboard: ClipboardSnapshot, offset: {
+        dx: number;
+        dy: number;
+    }, ctx?: PasteCtx): TNode[];
+    /** Snapshot the current selection into the clipboard payload shape.
+     *  Optional — required only for copy, cut, and clone's ghost capture. */
+    snapshotSelection?(ids: string[]): ClipboardSnapshot;
+    getPasteOffset?(clipboard: ClipboardSnapshot): {
+        dx: number;
+        dy: number;
+    };
+    /** Mutator wired by `insertNode`-using ops (kit-side InsertOp). `index` is
+     *  the node's z-position among its siblings. `createDeleteOp` captures it
+     *  and `invert()` forwards it, so an implementation that drops it makes
+     *  undo of a delete restore the node at the top instead of where it was.
+     *  Omit only for an unordered store. */
+    insertNode(node: TNode, index?: number): void;
+    /** Mutator wired by `setSelection` ops batched alongside paste. */
+    setSelection(ids: string[]): void;
+    /** Optional: see MoveAdapter.applyOps. */
+    applyOps?(ops: Op[], label: string): void;
+    /** Returns the current selection. Used by clone behaviors. */
+    getSelection(): string[];
+}
+/**
+ * The layer list of an adapter whose nodes sit on layers. The scene slot
+ * paints one canvas layer per entry; a pick over a bare adapter reads it for
+ * parallax planes where it is there.
+ */
+interface LayerEnumerableAdapter<TLayer extends string = string> {
+    getLayers?(): readonly {
+        id: TLayer;
+        visible: boolean;
+        parallax?: ParallaxOpts;
+    }[];
+    /** Call `listener` whenever the list `getLayers` answers may have changed.
+     *  A canvas reads the list at mount and again on each call, so an adapter
+     *  whose list never changes leaves this out. */
+    subscribeLayers?(listener: () => void): () => void;
+}
+/**
+ * Sibling z-order: what the reorder ops read and write.
+ *
+ * **Convention:** array order IS z-order. Index 0 is the bottom of the
+ * stack, the last index is the top. Hit-testing should iterate the returned
+ * list in REVERSE (top to bottom). Render layers iterate FORWARD (bottom to
+ * top).
+ */
+interface OrderedAdapter {
+    /** Ordered children of `parentId` (or root siblings if null), in z-order:
+     *  index 0 is bottom, last index is top. The same contract
+     *  {@link MoveAdapter.getChildren} declares — one method, two readers. */
+    getChildren(parentId: string | null): string[];
+    /** Rewrite the order of `parentId`'s children. Length and contents must
+     *  match the existing children — reorder only, no add/remove. */
+    setChildOrder(parentId: string | null, ids: string[]): void;
+}
+
+export type { AreaSelectAdapter as A, ClipboardSnapshot as C, InsertAdapter as I, LayerEnumerableAdapter as L, MoveAdapter as M, OrderedAdapter as O, PasteOmission as P, RegionPickView as R, SnapTarget as S, LassoHitMode as a, ResizeAdapter as b, RotateAdapter as c, LassoSelectAdapter as d, PasteCtx as e };

package/dist/util/paint.js

@@ -86,8 +86,6 @@ function strokeWith(paint, width = 1) {
 		width
 	};
 }
-/** The kit's default node fill — what a shape with no declared fill paints. */
-var DEFAULT_SHAPE_FILL = { paint: { color: "#888" } };
 /**
 * The 0..1 alpha a paint paints at.
 *
@@ -123,5 +121,5 @@ function paintWithColor(paint, color) {
 }
 
 //#endregion
-export { DEFAULT_FILL_COLOR, DEFAULT_PALETTE, DEFAULT_SHAPE_FILL, DEFAULT_STROKE_COLOR, GHOST_STROKE, cycleFill, paintAlpha, paintWithAlpha, paintWithColor, solid, strokeOf, strokeWith };
+export { DEFAULT_FILL_COLOR, DEFAULT_PALETTE, DEFAULT_STROKE_COLOR, GHOST_STROKE, cycleFill, paintAlpha, paintWithAlpha, paintWithColor, solid, strokeOf, strokeWith };
 //# sourceMappingURL=paint.js.map

package/dist/util/paint.js.map

@@ -1 +1 @@
-{"version":3,"file":"paint.js","names":[],"sources":["../../src/util/paint.ts"],"sourcesContent":["/** Kit-shipped default paint constants.\n *\n *  Single source of truth for the colors the built-in tools and the default\n *  fill/stroke actions reach for. Consumers that want to match the kit's\n *  out-of-the-box look (e.g. seed their own active-paint state) should import\n *  these rather than re-declaring the literals.\n *\n *  All values are `#rrggbbaa` so they round-trip through the kit's hex8 alpha\n *  helpers (`util/color`) without ambiguity.\n */\nimport {\n  colorLiteralToHex,\n  hexToColorLiteral,\n  resolvePaletteColor,\n  type ColorLiteral,\n  type CommandStroke,\n  type Fill,\n  type Paint,\n  type Palette,\n  type SolidPaint,\n  type Stroke,\n} from '@weasel-js/paint';\nimport { getAlpha01 } from './color';\n\n/** Default fill paint for shapes and the fill action — opaque white. */\nexport const DEFAULT_FILL_COLOR = '#ffffffff';\n\n/** Default stroke paint for shapes and the stroke action — opaque black. */\nexport const DEFAULT_STROKE_COLOR = '#000000ff';\n\nconst srgb = (hex: string): ColorLiteral => hexToColorLiteral(hex) as ColorLiteral;\n\n/** Default fill palette cycled through for auto-generated shape nodes\n *  (the kit's built-in shape tools and the `insert` action). */\nexport const DEFAULT_PALETTE: Palette = {\n  entries: [\n    { name: 'sage', color: srgb('#7fb069') },\n    { name: 'tan', color: srgb('#d4a574') },\n    { name: 'lavender', color: srgb('#a48bd4') },\n    { name: 'sky', color: srgb('#7ab8d4') },\n    { name: 'rose', color: srgb('#d47a7a') },\n  ],\n};\n\n/** The `seq`th color of `palette`'s entries as hex, wrapping past the end.\n *  An entry that resolves to nothing, or to a space with no hex form, gives\n *  `fallback`. */\nexport function cycleFill(seq: number, palette: Palette = DEFAULT_PALETTE, fallback = DEFAULT_FILL_COLOR): string {\n  const { entries } = palette;\n  const entry = entries[((seq % entries.length) + entries.length) % entries.length];\n  const color = entry && resolvePaletteColor(palette, { ref: entry.name });\n  return (color && colorLiteralToHex(color)) ?? fallback;\n}\n\n/** Preview / \"ghost\" stroke color used by drag-to-draw tool overlays and the\n *  selected-anchor highlight. Derived from the first palette entry so the\n *  preview chrome matches the default insert color. */\nexport const GHOST_STROKE: string = cycleFill(0);\n\n/**\n * A solid paint from a color string — the authoring shorthand for the one\n * shape a `Fill.paint` or a `Stroke.paint` may take.\n *\n * An alpha channel in `color` moves to `opacity`, because that is where every\n * paint kind carries its alpha; leaving it in the hex too would multiply the\n * two in the renderer.\n */\nexport function solid(color: string): SolidPaint {\n  const a = getAlpha01(color);\n  const rgb = color.length === 9 && color.startsWith('#') ? color.slice(0, 7) : color;\n  return a === 1 ? { color: rgb } : { color: rgb, opacity: a };\n}\n\n/** A solid stroke of `color` at `width` world units. Authoring shorthand for\n *  `{ paint: solid(color), width }`. */\nexport function strokeOf(color: string, width = 1): CommandStroke & { paint: SolidPaint } {\n  return { paint: solid(color), width };\n}\n\n/** A stroke painted with `paint` at `width` world units — `strokeOf`'s sibling\n *  for a gradient or pattern, which has no color to pass. */\nexport function strokeWith(paint: Paint, width = 1): Stroke {\n  return { paint, width };\n}\n\n/** The kit's default node fill — what a shape with no declared fill paints. */\nexport const DEFAULT_SHAPE_FILL: Fill & { paint: Paint } = { paint: { color: '#888' } };\n\n/**\n * The 0..1 alpha a paint paints at.\n *\n * Every paint kind carries its alpha in `opacity` — that is the one slot a\n * gradient or a pattern has, so it is the slot all of them use.\n */\nexport function paintAlpha(paint: Paint | undefined): number {\n  return paint?.opacity ?? 1;\n}\n\n/** `paint` painting at `alpha01` (clamped to 0..1). */\nexport function paintWithAlpha(paint: Paint, alpha01: number): Paint {\n  return { ...paint, opacity: Math.max(0, Math.min(1, alpha01)) };\n}\n\n/**\n * `paint` recolored to `color`, keeping everything else about it.\n *\n * A solid paint takes the new color; a gradient or a pattern has no single\n * color to replace, so it is superseded by a solid one — picking a color off\n * a swatch means \"paint this color\". An alpha channel in `color` wins;\n * without one, the paint's existing opacity carries over.\n */\nexport function paintWithColor(paint: Paint | undefined, color: string): Paint {\n  const next = solid(color);\n  const explicitAlpha = color.length === 9 && color.startsWith('#');\n  if (explicitAlpha || paint === undefined) return next;\n  const alpha = paintAlpha(paint);\n  return alpha === 1 ? next : { ...next, opacity: alpha };\n}\n"],"mappings":";;;;;;;;;;;;;;;AAyBA,IAAa,qBAAqB;;AAGlC,IAAa,uBAAuB;AAEpC,IAAM,QAAQ,QAA8B,kBAAkB,GAAG;;;AAIjE,IAAa,kBAA2B,EACtC,SAAS;CACP;EAAE,MAAM;EAAQ,OAAO,KAAK,SAAS;CAAE;CACvC;EAAE,MAAM;EAAO,OAAO,KAAK,SAAS;CAAE;CACtC;EAAE,MAAM;EAAY,OAAO,KAAK,SAAS;CAAE;CAC3C;EAAE,MAAM;EAAO,OAAO,KAAK,SAAS;CAAE;CACtC;EAAE,MAAM;EAAQ,OAAO,KAAK,SAAS;CAAE;AACzC,EACF;;;;AAKA,SAAgB,UAAU,KAAa,UAAmB,iBAAiB,WAAW,oBAA4B;CAChH,MAAM,EAAE,YAAY;CACpB,MAAM,QAAQ,SAAU,MAAM,QAAQ,SAAU,QAAQ,UAAU,QAAQ;CAC1E,MAAM,QAAQ,SAAS,oBAAoB,SAAS,EAAE,KAAK,MAAM,KAAK,CAAC;CACvE,QAAQ,SAAS,kBAAkB,KAAK,MAAM;AAChD;;;;AAKA,IAAa,eAAuB,UAAU,CAAC;;;;;;;;;AAU/C,SAAgB,MAAM,OAA2B;CAC/C,MAAM,IAAI,WAAW,KAAK;CAC1B,MAAM,MAAM,MAAM,WAAW,KAAK,MAAM,WAAW,GAAG,IAAI,MAAM,MAAM,GAAG,CAAC,IAAI;CAC9E,OAAO,MAAM,IAAI,EAAE,OAAO,IAAI,IAAI;EAAE,OAAO;EAAK,SAAS;CAAE;AAC7D;;;AAIA,SAAgB,SAAS,OAAe,QAAQ,GAA0C;CACxF,OAAO;EAAE,OAAO,MAAM,KAAK;EAAG;CAAM;AACtC;;;AAIA,SAAgB,WAAW,OAAc,QAAQ,GAAW;CAC1D,OAAO;EAAE;EAAO;CAAM;AACxB;;AAGA,IAAa,qBAA8C,EAAE,OAAO,EAAE,OAAO,OAAO,EAAE;;;;;;;AAQtF,SAAgB,WAAW,OAAkC;CAC3D,OAAO,OAAO,WAAW;AAC3B;;AAGA,SAAgB,eAAe,OAAc,SAAwB;CACnE,OAAO;EAAE,GAAG;EAAO,SAAS,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC;CAAE;AAChE;;;;;;;;;AAUA,SAAgB,eAAe,OAA0B,OAAsB;CAC7E,MAAM,OAAO,MAAM,KAAK;CAExB,IADsB,MAAM,WAAW,KAAK,MAAM,WAAW,GAAG,KAC3C,UAAU,QAAW,OAAO;CACjD,MAAM,QAAQ,WAAW,KAAK;CAC9B,OAAO,UAAU,IAAI,OAAO;EAAE,GAAG;EAAM,SAAS;CAAM;AACxD"}
+{"version":3,"file":"paint.js","names":[],"sources":["../../src/util/paint.ts"],"sourcesContent":["/** Kit-shipped default paint constants.\n *\n *  Single source of truth for the colors the built-in tools and the default\n *  fill/stroke actions reach for. Consumers that want to match the kit's\n *  out-of-the-box look (e.g. seed their own active-paint state) should import\n *  these rather than re-declaring the literals.\n *\n *  All values are `#rrggbbaa` so they round-trip through the kit's hex8 alpha\n *  helpers (`util/color`) without ambiguity.\n */\nimport {\n  colorLiteralToHex,\n  hexToColorLiteral,\n  resolvePaletteColor,\n  type ColorLiteral,\n  type CommandStroke,\n  type Paint,\n  type Palette,\n  type SolidPaint,\n  type Stroke,\n} from '@weasel-js/paint';\nimport { getAlpha01 } from './color';\n\n/** Default fill paint for shapes and the fill action — opaque white. */\nexport const DEFAULT_FILL_COLOR = '#ffffffff';\n\n/** Default stroke paint for shapes and the stroke action — opaque black. */\nexport const DEFAULT_STROKE_COLOR = '#000000ff';\n\nconst srgb = (hex: string): ColorLiteral => hexToColorLiteral(hex) as ColorLiteral;\n\n/** Default fill palette cycled through for auto-generated shape nodes\n *  (the kit's built-in shape tools and the `insert` action). */\nexport const DEFAULT_PALETTE: Palette = {\n  entries: [\n    { name: 'sage', color: srgb('#7fb069') },\n    { name: 'tan', color: srgb('#d4a574') },\n    { name: 'lavender', color: srgb('#a48bd4') },\n    { name: 'sky', color: srgb('#7ab8d4') },\n    { name: 'rose', color: srgb('#d47a7a') },\n  ],\n};\n\n/** The `seq`th color of `palette`'s entries as hex, wrapping past the end.\n *  An entry that resolves to nothing, or to a space with no hex form, gives\n *  `fallback`. */\nexport function cycleFill(seq: number, palette: Palette = DEFAULT_PALETTE, fallback = DEFAULT_FILL_COLOR): string {\n  const { entries } = palette;\n  const entry = entries[((seq % entries.length) + entries.length) % entries.length];\n  const color = entry && resolvePaletteColor(palette, { ref: entry.name });\n  return (color && colorLiteralToHex(color)) ?? fallback;\n}\n\n/** Preview / \"ghost\" stroke color used by drag-to-draw tool overlays and the\n *  selected-anchor highlight. Derived from the first palette entry so the\n *  preview chrome matches the default insert color. */\nexport const GHOST_STROKE: string = cycleFill(0);\n\n/**\n * A solid paint from a color string — the authoring shorthand for the one\n * shape a `Fill.paint` or a `Stroke.paint` may take.\n *\n * An alpha channel in `color` moves to `opacity`, because that is where every\n * paint kind carries its alpha; leaving it in the hex too would multiply the\n * two in the renderer.\n */\nexport function solid(color: string): SolidPaint {\n  const a = getAlpha01(color);\n  const rgb = color.length === 9 && color.startsWith('#') ? color.slice(0, 7) : color;\n  return a === 1 ? { color: rgb } : { color: rgb, opacity: a };\n}\n\n/** A solid stroke of `color` at `width` world units. Authoring shorthand for\n *  `{ paint: solid(color), width }`. */\nexport function strokeOf(color: string, width = 1): CommandStroke & { paint: SolidPaint } {\n  return { paint: solid(color), width };\n}\n\n/** A stroke painted with `paint` at `width` world units — `strokeOf`'s sibling\n *  for a gradient or pattern, which has no color to pass. */\nexport function strokeWith(paint: Paint, width = 1): Stroke {\n  return { paint, width };\n}\n\n/**\n * The 0..1 alpha a paint paints at.\n *\n * Every paint kind carries its alpha in `opacity` — that is the one slot a\n * gradient or a pattern has, so it is the slot all of them use.\n */\nexport function paintAlpha(paint: Paint | undefined): number {\n  return paint?.opacity ?? 1;\n}\n\n/** `paint` painting at `alpha01` (clamped to 0..1). */\nexport function paintWithAlpha(paint: Paint, alpha01: number): Paint {\n  return { ...paint, opacity: Math.max(0, Math.min(1, alpha01)) };\n}\n\n/**\n * `paint` recolored to `color`, keeping everything else about it.\n *\n * A solid paint takes the new color; a gradient or a pattern has no single\n * color to replace, so it is superseded by a solid one — picking a color off\n * a swatch means \"paint this color\". An alpha channel in `color` wins;\n * without one, the paint's existing opacity carries over.\n */\nexport function paintWithColor(paint: Paint | undefined, color: string): Paint {\n  const next = solid(color);\n  const explicitAlpha = color.length === 9 && color.startsWith('#');\n  if (explicitAlpha || paint === undefined) return next;\n  const alpha = paintAlpha(paint);\n  return alpha === 1 ? next : { ...next, opacity: alpha };\n}\n"],"mappings":";;;;;;;;;;;;;;;AAwBA,IAAa,qBAAqB;;AAGlC,IAAa,uBAAuB;AAEpC,IAAM,QAAQ,QAA8B,kBAAkB,GAAG;;;AAIjE,IAAa,kBAA2B,EACtC,SAAS;CACP;EAAE,MAAM;EAAQ,OAAO,KAAK,SAAS;CAAE;CACvC;EAAE,MAAM;EAAO,OAAO,KAAK,SAAS;CAAE;CACtC;EAAE,MAAM;EAAY,OAAO,KAAK,SAAS;CAAE;CAC3C;EAAE,MAAM;EAAO,OAAO,KAAK,SAAS;CAAE;CACtC;EAAE,MAAM;EAAQ,OAAO,KAAK,SAAS;CAAE;AACzC,EACF;;;;AAKA,SAAgB,UAAU,KAAa,UAAmB,iBAAiB,WAAW,oBAA4B;CAChH,MAAM,EAAE,YAAY;CACpB,MAAM,QAAQ,SAAU,MAAM,QAAQ,SAAU,QAAQ,UAAU,QAAQ;CAC1E,MAAM,QAAQ,SAAS,oBAAoB,SAAS,EAAE,KAAK,MAAM,KAAK,CAAC;CACvE,QAAQ,SAAS,kBAAkB,KAAK,MAAM;AAChD;;;;AAKA,IAAa,eAAuB,UAAU,CAAC;;;;;;;;;AAU/C,SAAgB,MAAM,OAA2B;CAC/C,MAAM,IAAI,WAAW,KAAK;CAC1B,MAAM,MAAM,MAAM,WAAW,KAAK,MAAM,WAAW,GAAG,IAAI,MAAM,MAAM,GAAG,CAAC,IAAI;CAC9E,OAAO,MAAM,IAAI,EAAE,OAAO,IAAI,IAAI;EAAE,OAAO;EAAK,SAAS;CAAE;AAC7D;;;AAIA,SAAgB,SAAS,OAAe,QAAQ,GAA0C;CACxF,OAAO;EAAE,OAAO,MAAM,KAAK;EAAG;CAAM;AACtC;;;AAIA,SAAgB,WAAW,OAAc,QAAQ,GAAW;CAC1D,OAAO;EAAE;EAAO;CAAM;AACxB;;;;;;;AAQA,SAAgB,WAAW,OAAkC;CAC3D,OAAO,OAAO,WAAW;AAC3B;;AAGA,SAAgB,eAAe,OAAc,SAAwB;CACnE,OAAO;EAAE,GAAG;EAAO,SAAS,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC;CAAE;AAChE;;;;;;;;;AAUA,SAAgB,eAAe,OAA0B,OAAsB;CAC7E,MAAM,OAAO,MAAM,KAAK;CAExB,IADsB,MAAM,WAAW,KAAK,MAAM,WAAW,GAAG,KAC3C,UAAU,QAAW,OAAO;CACjD,MAAM,QAAQ,WAAW,KAAK;CAC9B,OAAO,UAAU,IAAI,OAAO;EAAE,GAAG;EAAM,SAAS;CAAM;AACxD"}

package/dist/version.js

@@ -7,7 +7,7 @@
 * throwing, since nothing about version reporting should be able to break a
 * consumer's build.
 */
-var VERSION = "1.11.0";
+var VERSION = "1.12.0";
 
 //#endregion
 export { VERSION };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/core",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "A 2D scene-graph engine for React, rendered on WebGL2: the scene tree, viewport math, pointer and keyboard input, layered rendering, and op-based undo.",
   "weasel": {
     "needs": ["webgl2"]
@@ -20,6 +20,8 @@
   "sideEffects": [
     "*.css",
     "./src/import-shims/mesh.ts",
+    "./src/import-shims/devtools.ts",
+    "./dist/devtools.js",
     "./src/core/paint/registerMesh.ts",
     "./dist/mesh.js",
     "./dist/core/paint/registerMesh.js"
@@ -73,6 +75,18 @@
       "import": "./dist/clone.js",
       "types": "./dist/clone.d.ts"
     },
+    "./json": {
+      "import": "./dist/json.js",
+      "types": "./dist/json.d.ts"
+    },
+    "./devtools": {
+      "import": "./dist/devtools.js",
+      "types": "./dist/devtools.d.ts"
+    },
+    "./devtools-protocol": {
+      "import": "./dist/devtools-protocol.js",
+      "types": "./dist/devtools-protocol.d.ts"
+    },
     "./patterns-builtin": {
       "import": "./dist/patterns-builtin.js",
       "types": "./dist/patterns-builtin.d.ts"
@@ -96,30 +110,30 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "peerDependencies": {
-    "@weasel-js/font": "1.11.0",
+    "@weasel-js/font": "1.12.0",
     "react": ">=18"
   },
   "dependencies": {
-    "@msb235/blits": "0.10.0",
-    "@weasel-js/animator": "1.11.0",
-    "@weasel-js/cursor": "1.11.0",
-    "@weasel-js/geom": "1.11.0",
-    "@weasel-js/gestures": "1.11.0",
-    "@weasel-js/history": "1.11.0",
-    "@weasel-js/icons": "1.11.0",
-    "@weasel-js/modes": "1.11.0",
-    "@weasel-js/paint": "1.11.0",
-    "@weasel-js/prefs": "1.11.0",
-    "@weasel-js/quantity": "1.11.0",
-    "@weasel-js/react": "1.11.0",
-    "@weasel-js/registry": "1.11.0",
-    "@weasel-js/renderer": "1.11.0",
-    "@weasel-js/routing": "1.11.0",
-    "@weasel-js/select": "1.11.0",
-    "@weasel-js/simulation": "1.11.0",
-    "@weasel-js/stroke": "1.11.0",
-    "@weasel-js/text": "1.11.0",
-    "@weasel-js/text-dom": "1.11.0",
+    "@msb235/blits": "0.11.0",
+    "@weasel-js/animator": "1.12.0",
+    "@weasel-js/cursor": "1.12.0",
+    "@weasel-js/geom": "1.12.0",
+    "@weasel-js/gestures": "1.12.0",
+    "@weasel-js/history": "1.12.0",
+    "@weasel-js/icons": "1.12.0",
+    "@weasel-js/modes": "1.12.0",
+    "@weasel-js/paint": "1.12.0",
+    "@weasel-js/prefs": "1.12.0",
+    "@weasel-js/quantity": "1.12.0",
+    "@weasel-js/react": "1.12.0",
+    "@weasel-js/registry": "1.12.0",
+    "@weasel-js/renderer": "1.12.0",
+    "@weasel-js/routing": "1.12.0",
+    "@weasel-js/select": "1.12.0",
+    "@weasel-js/simulation": "1.12.0",
+    "@weasel-js/stroke": "1.12.0",
+    "@weasel-js/text": "1.12.0",
+    "@weasel-js/text-dom": "1.12.0",
     "earcut": "3.2.3",
     "polygon-clipping": "^0.15.7"
   },
@@ -137,8 +151,8 @@
     "2d"
   ],
   "devDependencies": {
-    "@weasel-js/icons-plugin": "1.11.0",
-    "@weasel-js/modes": "1.11.0",
-    "@weasel-js/theme": "1.11.0"
+    "@weasel-js/icons-plugin": "1.12.0",
+    "@weasel-js/modes": "1.12.0",
+    "@weasel-js/theme": "1.12.0"
   }
 }

package/dist/canvas/SceneCanvas/useBuiltinRigTools.js

@@ -1,65 +0,0 @@
-import { createRigEditState } from "../../tools/builtin/bone/rigEditState.js";
-import { useBoneTool } from "../../tools/builtin/bone/useBoneTool.js";
-import { useWeightTool } from "../../tools/builtin/weight/useWeightTool.js";
-import { useMemo } from "react";
-import { useLatest } from "@weasel-js/react";
-
-//#region src/canvas/SceneCanvas/useBuiltinRigTools.ts
-/**
-* The bone and weight tools as `<SceneCanvas>` mounts them: on the canvas's
-* own scene, sharing one `RigEditState`, and acting on the rig the selection
-* names unless `toolOptions.rig` fixes one.
-*
-* Both hooks always run (React rules of hooks); `resolveToolRegistry` decides
-* which the canvas registers.
-*/
-/**
-* The rig a selection names: with one node selected, the nearest of it and its
-* ancestors whose `data.skeleton` exists, else that node itself, so a first
-* bone can be drawn onto it. With none or several selected, `null`.
-*/
-function rigOfSelection(scene, ids) {
-	if (ids.length !== 1) return null;
-	const own = ids[0];
-	for (let id = own; id !== null;) {
-		const node = scene.get(id);
-		if (!node) break;
-		if (node.data?.skeleton) return id;
-		id = node.parent;
-	}
-	return scene.get(own) ? own : null;
-}
-function useBuiltinRigTools(args) {
-	const { scene, options } = args;
-	const latest = useLatest({
-		scene,
-		selection: args.selection,
-		rig: options?.rig?.rig
-	});
-	const rig = useMemo(() => () => {
-		const { scene: s, selection, rig: fixed } = latest.current;
-		return fixed ? fixed() : rigOfSelection(s, selection());
-	}, [latest]);
-	const ownState = useMemo(() => createRigEditState(), []);
-	const state = options?.rig?.state ?? ownState;
-	const reach = options?.rig?.reach;
-	return {
-		bone: useBoneTool({
-			scene,
-			rig,
-			state,
-			reach
-		}),
-		weight: useWeightTool({
-			scene,
-			rig,
-			state,
-			reach,
-			radius: options?.weight?.radius
-		})
-	};
-}
-
-//#endregion
-export { rigOfSelection, useBuiltinRigTools };
-//# sourceMappingURL=useBuiltinRigTools.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"useBuiltinRigTools.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useBuiltinRigTools.ts"],"sourcesContent":["/**\n * The bone and weight tools as `<SceneCanvas>` mounts them: on the canvas's\n * own scene, sharing one `RigEditState`, and acting on the rig the selection\n * names unless `toolOptions.rig` fixes one.\n *\n * Both hooks always run (React rules of hooks); `resolveToolRegistry` decides\n * which the canvas registers.\n */\nimport { useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { RigNodeData } from '../../animation/rig/rigNode';\nimport { useBoneTool } from 'tools/builtin/bone/useBoneTool';\nimport { createRigEditState } from 'tools/builtin/bone/rigEditState';\nimport { useWeightTool } from 'tools/builtin/weight/useWeightTool';\nimport type { Tool } from 'tools/overlayBinding';\nimport type { BuiltinToolOptions } from './useBuiltinShapeTools';\n\n/**\n * The rig a selection names: with one node selected, the nearest of it and its\n * ancestors whose `data.skeleton` exists, else that node itself, so a first\n * bone can be drawn onto it. With none or several selected, `null`.\n */\nexport function rigOfSelection(\n  scene: { get(id: NodeId): { parent: NodeId | null; data?: unknown } | undefined },\n  ids: readonly NodeId[],\n): NodeId | null {\n  if (ids.length !== 1) return null;\n  const own = ids[0];\n  for (let id: NodeId | null = own; id !== null;) {\n    const node = scene.get(id);\n    if (!node) break;\n    if ((node.data as RigNodeData | null | undefined)?.skeleton) return id;\n    id = node.parent;\n  }\n  return scene.get(own) ? own : null;\n}\n\nexport interface UseBuiltinRigToolsArgs {\n  scene: Scene<unknown, string, unknown>;\n  /** The canvas's selection, read when a tool acts. */\n  selection: () => readonly NodeId[];\n  options?: BuiltinToolOptions;\n}\n\nexport function useBuiltinRigTools(args: UseBuiltinRigToolsArgs): { bone: Tool; weight: Tool } {\n  const { scene, options } = args;\n  const latest = useLatest({ scene, selection: args.selection, rig: options?.rig?.rig });\n  const rig = useMemo(() => (): NodeId | null => {\n    const { scene: s, selection, rig: fixed } = latest.current;\n    return fixed ? fixed() : rigOfSelection(s, selection());\n  }, [latest]);\n  const ownState = useMemo(() => createRigEditState(), []);\n  const state = options?.rig?.state ?? ownState;\n  const reach = options?.rig?.reach;\n  const bone = useBoneTool({ scene, rig, state, reach });\n  const weight = useWeightTool({ scene, rig, state, reach, radius: options?.weight?.radius });\n  return { bone, weight };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,eACd,OACA,KACe;CACf,IAAI,IAAI,WAAW,GAAG,OAAO;CAC7B,MAAM,MAAM,IAAI;CAChB,KAAK,IAAI,KAAoB,KAAK,OAAO,OAAO;EAC9C,MAAM,OAAO,MAAM,IAAI,EAAE;EACzB,IAAI,CAAC,MAAM;EACX,IAAK,KAAK,MAAyC,UAAU,OAAO;EACpE,KAAK,KAAK;CACZ;CACA,OAAO,MAAM,IAAI,GAAG,IAAI,MAAM;AAChC;AASA,SAAgB,mBAAmB,MAA4D;CAC7F,MAAM,EAAE,OAAO,YAAY;CAC3B,MAAM,SAAS,UAAU;EAAE;EAAO,WAAW,KAAK;EAAW,KAAK,SAAS,KAAK;CAAI,CAAC;CACrF,MAAM,MAAM,oBAAmC;EAC7C,MAAM,EAAE,OAAO,GAAG,WAAW,KAAK,UAAU,OAAO;EACnD,OAAO,QAAQ,MAAM,IAAI,eAAe,GAAG,UAAU,CAAC;CACxD,GAAG,CAAC,MAAM,CAAC;CACX,MAAM,WAAW,cAAc,mBAAmB,GAAG,CAAC,CAAC;CACvD,MAAM,QAAQ,SAAS,KAAK,SAAS;CACrC,MAAM,QAAQ,SAAS,KAAK;CAG5B,OAAO;EAAE,MAFI,YAAY;GAAE;GAAO;GAAK;GAAO;EAAM,CAE3C;EAAM,QADA,cAAc;GAAE;GAAO;GAAK;GAAO;GAAO,QAAQ,SAAS,QAAQ;EAAO,CAC1E;CAAO;AACxB"}

package/dist/tools/builtin/bone/boneActions.js

@@ -1,156 +0,0 @@
-import { createSetDataOp } from "../../../core/ops/setData.js";
-import { defaultCommitAdapter } from "../../../interactions/actions/defaultCommitAdapter.js";
-import { unplaceSkeleton } from "../../../animation/rig/rigNode.js";
-import { sceneReach } from "./placedRig.js";
-import { ActionDisabledReason } from "@weasel-js/routing";
-import { addJoint, dropSkinJoints, jointAt, jointPositions, moveJoint, removeJoint } from "@weasel-js/animator";
-
-//#region src/tools/builtin/bone/boneActions.ts
-var eligible = { capability: "edits-page" };
-var reachOf = (env, deps) => sceneReach(deps, env.reachPx());
-var activeIn = (env, skeleton) => {
-	const name = env.state.active();
-	return name !== null && skeleton.joints.some((j) => j.name === name) ? name : null;
-};
-/** Write `next`, a skeleton in the scene's space, into the rig node, and take `removed`
-*  joints out of the skins under it, as one undo entry. */
-function commitSkeleton(scene, deps, id, next, label, removed = []) {
-	const node = scene.get(id);
-	if (!node) return;
-	const ops = [createSetDataOp({
-		id,
-		from: node.data,
-		to: {
-			...node.data,
-			skeleton: unplaceSkeleton(next, node.pose)
-		},
-		label
-	})];
-	const strip = (parent) => {
-		for (const child of scene.childrenOf(parent)) {
-			const data = scene.get(child)?.data;
-			const kept = data?.skin && dropSkinJoints(data.skin, removed);
-			if (kept && kept !== data.skin) ops.push(createSetDataOp({
-				id: child,
-				from: data,
-				to: {
-					...data,
-					skin: kept
-				},
-				label
-			}));
-			strip(child);
-		}
-	};
-	if (removed.length > 0) strip(id);
-	if (deps.applyOps) deps.applyOps(ops, label);
-	else scene.applyBatch(ops, label, defaultCommitAdapter(scene, deps.selection?.adapterMethods));
-}
-function dragAction(env, editing) {
-	return {
-		id: "bone.drag",
-		label: "Bone — move a joint or draw a bone",
-		eligible,
-		requires: [
-			"view",
-			"selection",
-			"applyOps"
-		],
-		enabled: editing,
-		invoker: {
-			timing: "ongoing",
-			start: ({ deps, drag, world }) => {
-				const at = env.placed();
-				if (!at) return {};
-				const press = drag?.start ?? world;
-				const before = env.state.active();
-				const hit = jointAt(at.skeleton, press.x, press.y, reachOf(env, deps));
-				let origin = at.skeleton;
-				let name = hit;
-				if (name === null) {
-					let parent = activeIn(env, origin);
-					if (parent === null) ({skeleton: origin, name: parent} = addJoint(origin, null, press.x, press.y));
-					({skeleton: origin, name} = addJoint(origin, parent, press.x, press.y));
-				}
-				const joint = name;
-				const from = jointPositions(origin).get(joint);
-				env.state.setActive(joint);
-				env.show(origin);
-				return {
-					onMove: (move) => {
-						env.show(moveJoint(origin, joint, from.x + move.world.x - press.x, from.y + move.world.y - press.y));
-					},
-					onEnd: (_end, reason) => {
-						const next = env.shown();
-						env.show(null);
-						if (reason === "cancel" || !next) {
-							env.state.setActive(before);
-							return;
-						}
-						commitSkeleton(env.scene(), deps, at.id, next, hit === null ? "Add bone" : "Move joint");
-					}
-				};
-			}
-		}
-	};
-}
-/** The bone tool's actions: `bone.drag`, `bone.pick`, `bone.remove`, and `bone.clear`. */
-function createBoneActions(env) {
-	const editing = () => env.placed() ? true : ActionDisabledReason.NotApplicable;
-	const hasActive = () => {
-		const at = env.placed();
-		return at && activeIn(env, at.skeleton) !== null ? true : ActionDisabledReason.NotApplicable;
-	};
-	return [
-		dragAction(env, editing),
-		{
-			id: "bone.pick",
-			label: "Bone — pick the active joint",
-			eligible,
-			requires: ["view"],
-			enabled: editing,
-			invoker: {
-				timing: "immediate",
-				run: (deps, params) => {
-					const p = params;
-					const at = env.placed();
-					if (!at || p?.pressX === void 0 || p.pressY === void 0) return;
-					env.state.setActive(jointAt(at.skeleton, p.pressX, p.pressY, reachOf(env, deps)));
-				}
-			}
-		},
-		{
-			id: "bone.remove",
-			label: "Bone — remove the active joint",
-			eligible,
-			requires: ["selection", "applyOps"],
-			enabled: hasActive,
-			invoker: {
-				timing: "immediate",
-				run: (deps) => {
-					const at = env.placed();
-					const name = at && activeIn(env, at.skeleton);
-					if (!at || name == null) return;
-					const parent = at.skeleton.joints.find((j) => j.name === name).parent;
-					const { skeleton, removed } = removeJoint(at.skeleton, name);
-					commitSkeleton(env.scene(), deps, at.id, skeleton, "Remove joint", removed);
-					env.state.setActive(parent);
-				}
-			}
-		},
-		{
-			id: "bone.clear",
-			label: "Bone — clear the active joint",
-			eligible,
-			enabled: hasActive,
-			invoker: {
-				timing: "immediate",
-				run: () => env.state.setActive(null)
-			}
-		}
-	];
-}
-
-//#endregion
-export { createBoneActions };
-//# sourceMappingURL=boneActions.js.map