@weasel-js/core 1.10.1 → 1.11.1

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/color.js

@@ -1,26 +1,47 @@
 //#region src/util/color.ts
-function e(e) {
-	if (!e.startsWith("#")) return e;
-	let t = e.slice(1);
-	if (t.length === 3 || t.length === 4) {
-		let [e, n, r, i = "f"] = t.toLowerCase();
-		return `#${e}${e}${n}${n}${r}${r}${i}${i}`;
+/** Color hex8 helpers. All stored colors are `#rrggbbaa`. `<input type="color">`
+*  only round-trips the 6-char form, so call-sites pad the saved alpha back on
+*  when the user picks via the native widget. */
+/** Expand `#rgb` / `#rgba` / `#rrggbb` to `#rrggbbaa`. Pads `ff` when no alpha
+*  channel is present. Non-hex inputs (named colors, `rgba(...)`) are
+*  returned unchanged — the kit's renderer accepts arbitrary CSS, and
+*  we only normalize the hex shapes we actually persist. */
+function toHex8(color) {
+	if (!color.startsWith("#")) return color;
+	const hex = color.slice(1);
+	if (hex.length === 3 || hex.length === 4) {
+		const [r, g, b, a = "f"] = hex.toLowerCase();
+		return `#${r}${r}${g}${g}${b}${b}${a}${a}`;
 	}
-	return t.length === 6 ? `#${t}ff` : t.length === 8 ? e.toLowerCase() : e;
+	if (hex.length === 6) return `#${hex}ff`;
+	if (hex.length === 8) return color.toLowerCase();
+	return color;
 }
-function t(e) {
-	if (!e.startsWith("#") || e.length !== 9) return 1;
-	let t = parseInt(e.slice(7, 9), 16);
-	return Number.isFinite(t) ? t / 255 : 1;
+/** Return the alpha channel of `color` as 0..1. Defaults to 1 when the
+*  color is not in 8-char hex form. */
+function getAlpha01(color) {
+	if (!color.startsWith("#") || color.length !== 9) return 1;
+	const a = parseInt(color.slice(7, 9), 16);
+	return Number.isFinite(a) ? a / 255 : 1;
 }
-function n(t, n) {
-	let r = Math.round(Math.max(0, Math.min(1, n)) * 255).toString(16).padStart(2, "0"), i = e(t);
-	return !i.startsWith("#") || i.length !== 9 ? t : `${i.slice(0, 7)}${r}`;
+/** Replace the alpha channel of `color` with `alpha01` (clamped to 0..1).
+*  Expands shorter hex forms first. Pass-through for non-hex inputs. */
+function withAlpha01(color, alpha01) {
+	const aa = Math.round(Math.max(0, Math.min(1, alpha01)) * 255).toString(16).padStart(2, "0");
+	const eight = toHex8(color);
+	if (!eight.startsWith("#") || eight.length !== 9) return color;
+	return `${eight.slice(0, 7)}${aa}`;
 }
-function r(e, r) {
-	return e.length === 9 && e.startsWith("#") ? e.toLowerCase() : n(e, t(r));
+/** Merge a freshly-picked color with the previous color's alpha channel.
+*  If `picked` is already in 8-char hex form (`#rrggbbaa`, length 9), it is
+*  used as-is — its explicit alpha is preserved. Otherwise the alpha from
+*  `prev` is adopted, which handles the common case where `<input type="color">`
+*  strips the alpha channel and returns a bare 6-char hex. */
+function mergeAlphaFromPrev(picked, prev) {
+	if (picked.length === 9 && picked.startsWith("#")) return picked.toLowerCase();
+	return withAlpha01(picked, getAlpha01(prev));
 }
-//#endregion
-export { t as getAlpha01, r as mergeAlphaFromPrev, e as toHex8, n as withAlpha01 };
 
+//#endregion
+export { getAlpha01, mergeAlphaFromPrev, toHex8, withAlpha01 };
 //# sourceMappingURL=color.js.map

package/dist/util/color.js.map

@@ -1 +1 @@
-{"version":3,"file":"color.js","names":["toHex8","color","hex","r","g","b","a","getAlpha01","withAlpha01","aa","alpha01","eight","mergeAlphaFromPrev","picked","prev"],"sources":["../../src/util/color.ts"],"sourcesContent":["/** Color hex8 helpers. All stored colors are `#rrggbbaa`. `<input type=\"color\">`\n *  only round-trips the 6-char form, so call-sites pad the saved alpha back on\n *  when the user picks via the native widget. */\n\n/** Expand `#rgb` / `#rgba` / `#rrggbb` to `#rrggbbaa`. Pads `ff` when no alpha\n *  channel is present. Non-hex inputs (named colors, `rgba(...)`) are\n *  returned unchanged — the kit's renderer accepts arbitrary CSS, and\n *  we only normalize the hex shapes we actually persist. */\nexport function toHex8(color: string): string {\n  if (!color.startsWith('#')) return color;\n  const hex = color.slice(1);\n  if (hex.length === 3 || hex.length === 4) {\n    const [r, g, b, a = 'f'] = hex.toLowerCase();\n    return `#${r}${r}${g}${g}${b}${b}${a}${a}`;\n  }\n  if (hex.length === 6) return `#${hex}ff`;\n  if (hex.length === 8) return color.toLowerCase();\n  return color;\n}\n\n/** Return the alpha channel of `color` as 0..1. Defaults to 1 when the\n *  color is not in 8-char hex form. */\nexport function getAlpha01(color: string): number {\n  if (!color.startsWith('#') || color.length !== 9) return 1;\n  const a = parseInt(color.slice(7, 9), 16);\n  return Number.isFinite(a) ? a / 255 : 1;\n}\n\n/** Replace the alpha channel of `color` with `alpha01` (clamped to 0..1).\n *  Expands shorter hex forms first. Pass-through for non-hex inputs. */\nexport function withAlpha01(color: string, alpha01: number): string {\n  const a = Math.max(0, Math.min(1, alpha01));\n  const aa = Math.round(a * 255).toString(16).padStart(2, '0');\n  const eight = toHex8(color);\n  if (!eight.startsWith('#') || eight.length !== 9) return color;\n  return `${eight.slice(0, 7)}${aa}`;\n}\n\n/** Merge a freshly-picked color with the previous color's alpha channel.\n *  If `picked` is already in 8-char hex form (`#rrggbbaa`, length 9), it is\n *  used as-is — its explicit alpha is preserved. Otherwise the alpha from\n *  `prev` is adopted, which handles the common case where `<input type=\"color\">`\n *  strips the alpha channel and returns a bare 6-char hex. */\nexport function mergeAlphaFromPrev(picked: string, prev: string): string {\n  if (picked.length === 9 && picked.startsWith('#')) return picked.toLowerCase();\n  return withAlpha01(picked, getAlpha01(prev));\n}\n"],"mappings":";AAQA,SAAgBA,EAAO,GAAuB;CAC5C,IAAI,CAACC,EAAM,WAAW,GAAG,GAAG,OAAOA;CACnC,IAAMC,IAAMD,EAAM,MAAM,CAAC;CACzB,IAAIC,EAAI,WAAW,KAAKA,EAAI,WAAW,GAAG;EACxC,IAAM,CAACC,GAAGC,GAAGC,GAAGC,IAAI,OAAOJ,EAAI,YAAY;EAC3C,OAAO,IAAIC,IAAIA,IAAIC,IAAIA,IAAIC,IAAIA,IAAIC,IAAIA;CACzC;CAGA,OAFIJ,EAAI,WAAW,IAAU,IAAIA,EAAI,MACjCA,EAAI,WAAW,IAAUD,EAAM,YAAY,IACxCA;AACT;AAIA,SAAgBM,EAAW,GAAuB;CAChD,IAAI,CAACN,EAAM,WAAW,GAAG,KAAKA,EAAM,WAAW,GAAG,OAAO;CACzD,IAAMK,IAAI,SAASL,EAAM,MAAM,GAAG,CAAC,GAAG,EAAE;CACxC,OAAO,OAAO,SAASK,CAAC,IAAIA,IAAI,MAAM;AACxC;AAIA,SAAgBE,EAAY,GAAe,GAAyB;CAElE,IAAMC,IAAK,KAAK,MADN,KAAK,IAAI,GAAG,KAAK,IAAI,GAAGC,CAAO,CACnB,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG,GACrDC,IAAQX,EAAOC,CAAK;CAE1B,OADI,CAACU,EAAM,WAAW,GAAG,KAAKA,EAAM,WAAW,IAAUV,IAClD,GAAGU,EAAM,MAAM,GAAG,CAAC,IAAIF;AAChC;AAOA,SAAgBG,EAAmB,GAAgB,GAAsB;CAEvE,OADIC,EAAO,WAAW,KAAKA,EAAO,WAAW,GAAG,IAAUA,EAAO,YAAY,IACtEL,EAAYK,GAAQN,EAAWO,CAAI,CAAC;AAC7C"}
+{"version":3,"file":"color.js","names":[],"sources":["../../src/util/color.ts"],"sourcesContent":["/** Color hex8 helpers. All stored colors are `#rrggbbaa`. `<input type=\"color\">`\n *  only round-trips the 6-char form, so call-sites pad the saved alpha back on\n *  when the user picks via the native widget. */\n\n/** Expand `#rgb` / `#rgba` / `#rrggbb` to `#rrggbbaa`. Pads `ff` when no alpha\n *  channel is present. Non-hex inputs (named colors, `rgba(...)`) are\n *  returned unchanged — the kit's renderer accepts arbitrary CSS, and\n *  we only normalize the hex shapes we actually persist. */\nexport function toHex8(color: string): string {\n  if (!color.startsWith('#')) return color;\n  const hex = color.slice(1);\n  if (hex.length === 3 || hex.length === 4) {\n    const [r, g, b, a = 'f'] = hex.toLowerCase();\n    return `#${r}${r}${g}${g}${b}${b}${a}${a}`;\n  }\n  if (hex.length === 6) return `#${hex}ff`;\n  if (hex.length === 8) return color.toLowerCase();\n  return color;\n}\n\n/** Return the alpha channel of `color` as 0..1. Defaults to 1 when the\n *  color is not in 8-char hex form. */\nexport function getAlpha01(color: string): number {\n  if (!color.startsWith('#') || color.length !== 9) return 1;\n  const a = parseInt(color.slice(7, 9), 16);\n  return Number.isFinite(a) ? a / 255 : 1;\n}\n\n/** Replace the alpha channel of `color` with `alpha01` (clamped to 0..1).\n *  Expands shorter hex forms first. Pass-through for non-hex inputs. */\nexport function withAlpha01(color: string, alpha01: number): string {\n  const a = Math.max(0, Math.min(1, alpha01));\n  const aa = Math.round(a * 255).toString(16).padStart(2, '0');\n  const eight = toHex8(color);\n  if (!eight.startsWith('#') || eight.length !== 9) return color;\n  return `${eight.slice(0, 7)}${aa}`;\n}\n\n/** Merge a freshly-picked color with the previous color's alpha channel.\n *  If `picked` is already in 8-char hex form (`#rrggbbaa`, length 9), it is\n *  used as-is — its explicit alpha is preserved. Otherwise the alpha from\n *  `prev` is adopted, which handles the common case where `<input type=\"color\">`\n *  strips the alpha channel and returns a bare 6-char hex. */\nexport function mergeAlphaFromPrev(picked: string, prev: string): string {\n  if (picked.length === 9 && picked.startsWith('#')) return picked.toLowerCase();\n  return withAlpha01(picked, getAlpha01(prev));\n}\n"],"mappings":";;;;;;;;AAQA,SAAgB,OAAO,OAAuB;CAC5C,IAAI,CAAC,MAAM,WAAW,GAAG,GAAG,OAAO;CACnC,MAAM,MAAM,MAAM,MAAM,CAAC;CACzB,IAAI,IAAI,WAAW,KAAK,IAAI,WAAW,GAAG;EACxC,MAAM,CAAC,GAAG,GAAG,GAAG,IAAI,OAAO,IAAI,YAAY;EAC3C,OAAO,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;CACzC;CACA,IAAI,IAAI,WAAW,GAAG,OAAO,IAAI,IAAI;CACrC,IAAI,IAAI,WAAW,GAAG,OAAO,MAAM,YAAY;CAC/C,OAAO;AACT;;;AAIA,SAAgB,WAAW,OAAuB;CAChD,IAAI,CAAC,MAAM,WAAW,GAAG,KAAK,MAAM,WAAW,GAAG,OAAO;CACzD,MAAM,IAAI,SAAS,MAAM,MAAM,GAAG,CAAC,GAAG,EAAE;CACxC,OAAO,OAAO,SAAS,CAAC,IAAI,IAAI,MAAM;AACxC;;;AAIA,SAAgB,YAAY,OAAe,SAAyB;CAElE,MAAM,KAAK,KAAK,MADN,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,OAAO,CACnB,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG;CAC3D,MAAM,QAAQ,OAAO,KAAK;CAC1B,IAAI,CAAC,MAAM,WAAW,GAAG,KAAK,MAAM,WAAW,GAAG,OAAO;CACzD,OAAO,GAAG,MAAM,MAAM,GAAG,CAAC,IAAI;AAChC;;;;;;AAOA,SAAgB,mBAAmB,QAAgB,MAAsB;CACvE,IAAI,OAAO,WAAW,KAAK,OAAO,WAAW,GAAG,GAAG,OAAO,OAAO,YAAY;CAC7E,OAAO,YAAY,QAAQ,WAAW,IAAI,CAAC;AAC7C"}

package/dist/util/paint.js

@@ -1,72 +1,127 @@
-import { getAlpha01 as e } from "./color.js";
-import { colorLiteralToHex as t, hexToColorLiteral as n, resolvePaletteColor as r } from "@weasel-js/paint";
+import { getAlpha01 } from "./color.js";
+import { colorLiteralToHex, hexToColorLiteral, resolvePaletteColor } from "@weasel-js/paint";
+
 //#region src/util/paint.ts
-var i = "#ffffffff", a = "#000000ff", o = (e) => n(e), s = { entries: [
+/** Kit-shipped default paint constants.
+*
+*  Single source of truth for the colors the built-in tools and the default
+*  fill/stroke actions reach for. Consumers that want to match the kit's
+*  out-of-the-box look (e.g. seed their own active-paint state) should import
+*  these rather than re-declaring the literals.
+*
+*  All values are `#rrggbbaa` so they round-trip through the kit's hex8 alpha
+*  helpers (`util/color`) without ambiguity.
+*/
+/** Default fill paint for shapes and the fill action — opaque white. */
+var DEFAULT_FILL_COLOR = "#ffffffff";
+/** Default stroke paint for shapes and the stroke action — opaque black. */
+var DEFAULT_STROKE_COLOR = "#000000ff";
+var srgb = (hex) => hexToColorLiteral(hex);
+/** Default fill palette cycled through for auto-generated shape nodes
+*  (the kit's built-in shape tools and the `insert` action). */
+var DEFAULT_PALETTE = { entries: [
 	{
 		name: "sage",
-		color: o("#7fb069")
+		color: srgb("#7fb069")
 	},
 	{
 		name: "tan",
-		color: o("#d4a574")
+		color: srgb("#d4a574")
 	},
 	{
 		name: "lavender",
-		color: o("#a48bd4")
+		color: srgb("#a48bd4")
 	},
 	{
 		name: "sky",
-		color: o("#7ab8d4")
+		color: srgb("#7ab8d4")
 	},
 	{
 		name: "rose",
-		color: o("#d47a7a")
+		color: srgb("#d47a7a")
 	}
 ] };
-function c(e, n = s, a = i) {
-	let { entries: o } = n, c = o[(e % o.length + o.length) % o.length], l = c && r(n, { ref: c.name });
-	return (l && t(l)) ?? a;
+/** The `seq`th color of `palette`'s entries as hex, wrapping past the end.
+*  An entry that resolves to nothing, or to a space with no hex form, gives
+*  `fallback`. */
+function cycleFill(seq, palette = DEFAULT_PALETTE, fallback = DEFAULT_FILL_COLOR) {
+	const { entries } = palette;
+	const entry = entries[(seq % entries.length + entries.length) % entries.length];
+	const color = entry && resolvePaletteColor(palette, { ref: entry.name });
+	return (color && colorLiteralToHex(color)) ?? fallback;
 }
-var l = c(0);
-function u(t) {
-	let n = e(t), r = t.length === 9 && t.startsWith("#") ? t.slice(0, 7) : t;
-	return n === 1 ? { color: r } : {
-		color: r,
-		opacity: n
+/** Preview / "ghost" stroke color used by drag-to-draw tool overlays and the
+*  selected-anchor highlight. Derived from the first palette entry so the
+*  preview chrome matches the default insert color. */
+var GHOST_STROKE = cycleFill(0);
+/**
+* A solid paint from a color string — the authoring shorthand for the one
+* shape a `Fill.paint` or a `Stroke.paint` may take.
+*
+* An alpha channel in `color` moves to `opacity`, because that is where every
+* paint kind carries its alpha; leaving it in the hex too would multiply the
+* two in the renderer.
+*/
+function solid(color) {
+	const a = getAlpha01(color);
+	const rgb = color.length === 9 && color.startsWith("#") ? color.slice(0, 7) : color;
+	return a === 1 ? { color: rgb } : {
+		color: rgb,
+		opacity: a
 	};
 }
-function d(e, t = 1) {
+/** A solid stroke of `color` at `width` world units. Authoring shorthand for
+*  `{ paint: solid(color), width }`. */
+function strokeOf(color, width = 1) {
 	return {
-		paint: u(e),
-		width: t
+		paint: solid(color),
+		width
 	};
 }
-function f(e, t = 1) {
+/** A stroke painted with `paint` at `width` world units — `strokeOf`'s sibling
+*  for a gradient or pattern, which has no color to pass. */
+function strokeWith(paint, width = 1) {
 	return {
-		paint: e,
-		width: t
+		paint,
+		width
 	};
 }
-var p = { paint: { color: "#888" } };
-function m(e) {
-	return e?.opacity ?? 1;
+/** 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.
+*
+* Every paint kind carries its alpha in `opacity` — that is the one slot a
+* gradient or a pattern has, so it is the slot all of them use.
+*/
+function paintAlpha(paint) {
+	return paint?.opacity ?? 1;
 }
-function h(e, t) {
+/** `paint` painting at `alpha01` (clamped to 0..1). */
+function paintWithAlpha(paint, alpha01) {
 	return {
-		...e,
-		opacity: Math.max(0, Math.min(1, t))
+		...paint,
+		opacity: Math.max(0, Math.min(1, alpha01))
 	};
 }
-function g(e, t) {
-	let n = u(t);
-	if (t.length === 9 && t.startsWith("#") || e === void 0) return n;
-	let r = m(e);
-	return r === 1 ? n : {
-		...n,
-		opacity: r
+/**
+* `paint` recolored to `color`, keeping everything else about it.
+*
+* A solid paint takes the new color; a gradient or a pattern has no single
+* color to replace, so it is superseded by a solid one — picking a color off
+* a swatch means "paint this color". An alpha channel in `color` wins;
+* without one, the paint's existing opacity carries over.
+*/
+function paintWithColor(paint, color) {
+	const next = solid(color);
+	if (color.length === 9 && color.startsWith("#") || paint === void 0) return next;
+	const alpha = paintAlpha(paint);
+	return alpha === 1 ? next : {
+		...next,
+		opacity: alpha
 	};
 }
-//#endregion
-export { i as DEFAULT_FILL_COLOR, s as DEFAULT_PALETTE, p as DEFAULT_SHAPE_FILL, a as DEFAULT_STROKE_COLOR, l as GHOST_STROKE, c as cycleFill, m as paintAlpha, h as paintWithAlpha, g as paintWithColor, u as solid, d as strokeOf, f as strokeWith };
 
+//#endregion
+export { DEFAULT_FILL_COLOR, DEFAULT_PALETTE, DEFAULT_SHAPE_FILL, 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":["DEFAULT_FILL_COLOR","DEFAULT_STROKE_COLOR","srgb","hexToColorLiteral","hex","DEFAULT_PALETTE","cycleFill","palette","entry","entries","seq","color","resolvePaletteColor","colorLiteralToHex","fallback","GHOST_STROKE","solid","a","getAlpha01","rgb","strokeOf","strokeWith","DEFAULT_SHAPE_FILL","paintAlpha","paint","paintWithAlpha","alpha01","paintWithColor","next","alpha"],"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,IAAaA,IAAqB,aAGrBC,IAAuB,aAE9BC,KAAQ,MAA8BC,EAAkBC,CAAG,GAIpDC,IAA2B,EACtC,SAAS;CACP;EAAE,MAAM;EAAQ,OAAOH,EAAK,SAAS;CAAE;CACvC;EAAE,MAAM;EAAO,OAAOA,EAAK,SAAS;CAAE;CACtC;EAAE,MAAM;EAAY,OAAOA,EAAK,SAAS;CAAE;CAC3C;EAAE,MAAM;EAAO,OAAOA,EAAK,SAAS;CAAE;CACtC;EAAE,MAAM;EAAQ,OAAOA,EAAK,SAAS;CAAE;AACzC,EACF;AAKA,SAAgBI,EAAU,GAAa,IAAmBD,GAAiB,IAAWL,GAA4B;CAChH,IAAM,EAAE,eAAYO,GACdC,IAAQC,GAAUC,IAAMD,EAAQ,SAAUA,EAAQ,UAAUA,EAAQ,SACpEE,IAAQH,KAASI,EAAoBL,GAAS,EAAE,KAAKC,EAAM,KAAK,CAAC;CACvE,QAAQG,KAASE,EAAkBF,CAAK,MAAMG;AAChD;AAKA,IAAaC,IAAuBT,EAAU,CAAC;AAU/C,SAAgBU,EAAM,GAA2B;CAC/C,IAAMC,IAAIC,EAAWP,CAAK,GACpBQ,IAAMR,EAAM,WAAW,KAAKA,EAAM,WAAW,GAAG,IAAIA,EAAM,MAAM,GAAG,CAAC,IAAIA;CAC9E,OAAOM,MAAM,IAAI,EAAE,OAAOE,EAAI,IAAI;EAAE,OAAOA;EAAK,SAASF;CAAE;AAC7D;AAIA,SAAgBG,EAAS,GAAe,IAAQ,GAA0C;CACxF,OAAO;EAAE,OAAOJ,EAAML,CAAK;EAAG;CAAM;AACtC;AAIA,SAAgBU,EAAW,GAAc,IAAQ,GAAW;CAC1D,OAAO;EAAE;EAAO;CAAM;AACxB;AAGA,IAAaC,IAA8C,EAAE,OAAO,EAAE,OAAO,OAAO,EAAE;AAQtF,SAAgBC,EAAW,GAAkC;CAC3D,OAAOC,GAAO,WAAW;AAC3B;AAGA,SAAgBC,EAAe,GAAc,GAAwB;CACnE,OAAO;EAAE,GAAGD;EAAO,SAAS,KAAK,IAAI,GAAG,KAAK,IAAI,GAAGE,CAAO,CAAC;CAAE;AAChE;AAUA,SAAgBC,EAAe,GAA0B,GAAsB;CAC7E,IAAMC,IAAOZ,EAAML,CAAK;CAExB,IADsBA,EAAM,WAAW,KAAKA,EAAM,WAAW,GAAG,KAC3Ca,MAAU,KAAA,GAAW,OAAOI;CACjD,IAAMC,IAAQN,EAAWC,CAAK;CAC9B,OAAOK,MAAU,IAAID,IAAO;EAAE,GAAGA;EAAM,SAASC;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 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"}

package/dist/version.js

@@ -1,6 +1,14 @@
 //#region src/version.ts
-var e = "1.10.1";
-//#endregion
-export { e as VERSION };
+/**
+* Semver of `@weasel-js/core` as of the build.
+*
+* Falls back to `'0.0.0-unknown'` when core's source is imported by a bundler
+* that hasn't been given the define — honest about not knowing rather than
+* throwing, since nothing about version reporting should be able to break a
+* consumer's build.
+*/
+var VERSION = "1.11.1";
 
+//#endregion
+export { VERSION };
 //# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","names":["VERSION"],"sources":["../src/version.ts"],"sourcesContent":["/**\n * The kit version a build was compiled from, so an app can report what it is\n * running. Substituted at build time — by `vite.config.ts` for the published\n * package, and by `scripts/vite-build-info.ts` for anything in this repo that\n * bundles core's source through the workspace aliases.\n *\n * Apps pair this with their own compile timestamp; the kit deliberately does\n * not carry one, since a published package's build date says nothing about\n * when the app embedding it was built.\n */\n\ndeclare const __WEASEL_CORE_VERSION__: string | undefined;\n\n/**\n * Semver of `@weasel-js/core` as of the build.\n *\n * Falls back to `'0.0.0-unknown'` when core's source is imported by a bundler\n * that hasn't been given the define — honest about not knowing rather than\n * throwing, since nothing about version reporting should be able to break a\n * consumer's build.\n */\nexport const VERSION: string =\n  typeof __WEASEL_CORE_VERSION__ === 'string' ? __WEASEL_CORE_VERSION__ : '0.0.0-unknown';\n"],"mappings":";AAqBA,IAAaA,IAAA"}
+{"version":3,"file":"version.js","names":[],"sources":["../src/version.ts"],"sourcesContent":["/**\n * The kit version a build was compiled from, so an app can report what it is\n * running. Substituted at build time — by `vite.config.ts` for the published\n * package, and by `scripts/vite-build-info.ts` for anything in this repo that\n * bundles core's source through the workspace aliases.\n *\n * Apps pair this with their own compile timestamp; the kit deliberately does\n * not carry one, since a published package's build date says nothing about\n * when the app embedding it was built.\n */\n\ndeclare const __WEASEL_CORE_VERSION__: string | undefined;\n\n/**\n * Semver of `@weasel-js/core` as of the build.\n *\n * Falls back to `'0.0.0-unknown'` when core's source is imported by a bundler\n * that hasn't been given the define — honest about not knowing rather than\n * throwing, since nothing about version reporting should be able to break a\n * consumer's build.\n */\nexport const VERSION: string =\n  typeof __WEASEL_CORE_VERSION__ === 'string' ? __WEASEL_CORE_VERSION__ : '0.0.0-unknown';\n"],"mappings":";;;;;;;;;AAqBA,IAAa"}