@weasel-js/core 0.5.0

package/dist/clipboard.d.ts

@@ -0,0 +1,91 @@
+import { N as NodeId } from './types-Cpb4hii1.js';
+import { C as ClipboardSnapshot, I as InsertAdapter } from './types-B_-khFM0.js';
+import '@weasel-js/history';
+import './types-B6MMiodD.js';
+
+type Replacer$1 = (key: string, value: unknown) => unknown;
+/** Options for `useClipboardOps`. */
+interface UseClipboardOpsOptions {
+    /** How the hook reads "current selection" for copy. The kit doesn't assume
+     *  a global selection store; each consumer wires this. */
+    getSelection: () => NodeId[];
+    /** Called after a successful paste with the ids of the newly inserted objects. */
+    onPaste?: (newIds: NodeId[]) => void;
+    /** Label for the history entry produced by paste. Default 'Paste'. */
+    pasteLabel?: string;
+    /** Pulled once per paste() call. When non-null, threaded to commitPaste
+     *  as `ctx.dropPoint`; adapters typically use it as the cluster origin
+     *  (ignoring `offset`). When null/undefined, the hook falls back to the
+     *  existing cascade-offset behavior. */
+    getDropPoint?: () => {
+        worldX: number;
+        worldY: number;
+    } | null;
+    /** Produce the OS-clipboard flavor map for a copied snapshot. Keys are MIME
+     *  types, values the serialized payload. The kit default emits
+     *  `application/x-weasel-clipboard+json` plus `text/plain` carrying the
+     *  same JSON. Apps override to add richer flavors (e.g. real SVG) or to
+     *  replace the text flavor. Return an empty object to skip the OS write
+     *  entirely. */
+    produceFlavors?: (snapshot: ClipboardSnapshot) => Record<string, string>;
+    /** Replacer for the kit-default JSON flavor (typed arrays etc.). Ignored
+     *  when `produceFlavors` is supplied. */
+    jsonReplacer?: Replacer$1;
+}
+/** Return shape of `useClipboardOps`: imperative `copy`, `paste`, and `isEmpty` functions. */
+interface UseClipboardOpsReturn {
+    copy(): void;
+    paste(): void;
+    isEmpty(): boolean;
+}
+/** In-memory copy/paste of selections via `InsertAdapter.snapshotSelection` / `commitPaste`. */
+declare function useClipboardOps<TNode extends {
+    id: string;
+}>(adapter: InsertAdapter<TNode>, options: UseClipboardOpsOptions): UseClipboardOpsReturn;
+
+declare const WEASEL_CLIPBOARD_MIME = "application/x-weasel-clipboard+json";
+/** Chromium's async-clipboard spelling for custom formats. */
+declare const WEASEL_CLIPBOARD_MIME_WEB = "web application/x-weasel-clipboard+json";
+type Replacer = (key: string, value: unknown) => unknown;
+type Reviver = (key: string, value: unknown) => unknown;
+/** Serialize snapshot items into the versioned wire text.
+ *
+ *  Function-valued fields (e.g. a container's `clipFromPose`) are dropped by
+ *  JSON serialization — OS-pasted clip containers arrive unclipped.
+ *  Consumers who need clips to survive the OS round-trip can translate
+ *  function ↔ registry key in their `jsonReplacer`/reviver pair (the
+ *  scene-serialization `clipFromPoseKey` precedent). */
+declare function buildWeaselClipboardText(items: unknown[], replacer?: Replacer): string;
+/** Cheap check: could this text be a weasel clipboard payload? Substring
+ *  pre-check, then a guarded parse + marker/version test. */
+declare function sniffWeaselClipboardText(text: string): boolean;
+/**
+ * Embed a weasel clipboard payload in an SVG document as a `<metadata>`
+ * child of the root — legal SVG 1.1, ignored by external tools — so one
+ * `text/plain` flavor serves both audiences: external tools parse the SVG,
+ * weasel extracts the JSON for full fidelity on draw→draw DOM paste.
+ *
+ * The payload rides in CDATA so JSON's `<` / `&` need no entity escaping; a
+ * literal `]]>` inside the payload is split across CDATA sections
+ * (`]]]]><![CDATA[>`), which {@link extractWeaselClipboardFromSvg} rejoins.
+ *
+ * Intended for OUR serializer's output only (`serializeSvg` — single
+ * `<svg ...>` open tag, XML-escaped attributes). When no open tag is found
+ * the input is returned unchanged with a debug warning.
+ */
+declare function embedWeaselMetadataInSvg(svgText: string, payloadText: string): string;
+/**
+ * Recover an embedded weasel clipboard payload from SVG text: read the first
+ * `<metadata>` block, rejoin its CDATA sections (concatenation restores the
+ * `]]>` split by {@link embedWeaselMetadataInSvg}; plain non-CDATA content
+ * passes through as-is), and return the payload text iff it sniffs as the
+ * weasel wire format — else null (external/non-weasel metadata declines).
+ *
+ * A text scan, not an XML parse — the payload is small and ours.
+ */
+declare function extractWeaselClipboardFromSvg(svgText: string): string | null;
+/** Parse wire text to snapshot items, or null when malformed/mismatched
+ *  (callers decline to the next content handler). */
+declare function parseWeaselClipboardText(text: string, reviver?: Reviver): unknown[] | null;
+
+export { type UseClipboardOpsOptions, type UseClipboardOpsReturn, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, buildWeaselClipboardText, embedWeaselMetadataInSvg, extractWeaselClipboardFromSvg, parseWeaselClipboardText, sniffWeaselClipboardText, useClipboardOps };

package/dist/clipboard.js

@@ -0,0 +1,6 @@
+export { WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, buildWeaselClipboardText, embedWeaselMetadataInSvg, extractWeaselClipboardFromSvg, parseWeaselClipboardText, sniffWeaselClipboardText, useClipboardOps } from './chunk-775XXAHR.js';
+import './chunk-BHVYVFGV.js';
+import './chunk-GVCNT7UH.js';
+import './chunk-PZ5AY32C.js';
+//# sourceMappingURL=clipboard.js.map
+//# sourceMappingURL=clipboard.js.map

package/dist/clipboard.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"clipboard.js"}

package/dist/clone.d.ts

@@ -0,0 +1,8 @@
+import { C as CloneBehavior } from './types-BjUi2vA-.js';
+import '@weasel-js/history';
+import './types-B_-khFM0.js';
+
+/** Clone-on-alt-drag behavior for `useClone`; activates when Alt/Option is held at drag start. */
+declare function cloneByAltDrag(): CloneBehavior;
+
+export { cloneByAltDrag };

package/dist/clone.js

@@ -0,0 +1,6 @@
+export { cloneByAltDrag } from './chunk-UGFFCMQP.js';
+import './chunk-BHVYVFGV.js';
+import './chunk-GVCNT7UH.js';
+import './chunk-PZ5AY32C.js';
+//# sourceMappingURL=clone.js.map
+//# sourceMappingURL=clone.js.map

package/dist/clone.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"clone.js"}

package/dist/fitViewToBounds-evGsnR8Q.d.ts

@@ -0,0 +1,62 @@
+import { V as View } from './view-DSQgxBJB.js';
+
+/**
+ * Axis-aligned rectangle in world space. Kit-wide `Bounds` shape used by
+ * selection, group, and viewport helpers. The optional `rotation` field
+ * (radians, around the AABB center) lets selection chrome attach a rotated
+ * orientation to an otherwise axis-aligned rect without needing a parallel
+ * type.
+ */
+interface Bounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation?: number;
+}
+/** Pixel dimensions of the canvas viewport. */
+interface ViewportDims {
+    width: number;
+    height: number;
+}
+/** Options for {@link fitViewToBounds}. */
+interface FitViewToBoundsOptions {
+    /** Inset (in CSS px) around the bounds. Default 16. */
+    padding?: number;
+    /**
+     * Override the kit's system max scale. Defaults to the kit-wide max zoom
+     * used by `computeWheelAction` / `useZoom` (currently `10`).
+     */
+    maxScale?: number;
+    /**
+     * Override the kit's system min scale. Defaults to the kit-wide min zoom
+     * used by `computeWheelAction` / `useZoom` (currently `0.1`).
+     */
+    minScale?: number;
+    /**
+     * Fit mode:
+     * - `'contain'` (default): uniform scale = `min(availW/w, availH/h)`. Bounds fit entirely; one axis has letterboxing.
+     * - `'fill'`: uniform scale = `max(...)`. Bounds overflow viewport on one axis.
+     * - `'stretch'`: per-axis scale. Bounds match viewport exactly; scale is non-uniform.
+     */
+    mode?: 'contain' | 'fill' | 'stretch';
+}
+/**
+ * Compute the target {@link View} that fits `bounds` (world space) inside
+ * `viewportDims` (CSS px). The bounds are centered in the viewport with
+ * uniform padding on all sides; the resulting scale is clamped to the
+ * configured min/max.
+ *
+ * View semantics: `view.x` / `view.y` is the world point currently drawn at
+ * the canvas top-left, and `view.scale.{x,y}` is pixels per world unit on
+ * each axis (see `view.ts`). So:
+ *   screenX = (worldX - view.x) * view.scale.x
+ *   screenY = (worldY - view.y) * view.scale.y
+ *
+ * Empty / zero-sized bounds or viewports cannot be fit — in that case this
+ * returns `currentView` unchanged and logs a `console.warn`. Callers that
+ * want to no-op silently can detect zero area themselves before calling.
+ */
+declare function fitViewToBounds(bounds: Bounds, viewportDims: ViewportDims, currentView: View, opts?: FitViewToBoundsOptions): View;
+
+export { type Bounds as B, type FitViewToBoundsOptions as F, type ViewportDims as V, fitViewToBounds as f };

package/dist/grid-Cf87knjU.d.ts

@@ -0,0 +1,153 @@
+import { a as MoveBehavior, S as SnapStrategy } from './types-BjUi2vA-.js';
+import { D as DebugSink } from './types-BJ8_cyT7.js';
+
+/**
+ * Units — a tiny customizable unit system for canvas-kit APIs.
+ *
+ * The kit stores all coordinates as bare numbers in a single base unit
+ * chosen by the consumer app. To make API call sites self-documenting,
+ * the public surface accepts `UnitValue` — either a bare number (interpreted
+ * as base units) or a `{ value, unit }` tag that's resolved against a
+ * `UnitSystem` at the API boundary. Internals never see units.
+ *
+ * Linear factors only. No per-axis units. No mixed-unit arithmetic.
+ */
+/** A unit name (e.g. `'in'`, `'ft'`, `'mm'`). Looked up in a `UnitSystem`. */
+type Unit = string;
+/** Conversion table mapping unit names to factors against a base unit. */
+interface UnitSystem {
+    /** Name of the base unit, e.g. 'in'. All conversions resolve to this. */
+    base: Unit;
+    /** Factor to multiply a value in `unit` by to get base units. base unit's factor is 1. */
+    units: Record<Unit, number>;
+}
+/** Value at a unit-aware API boundary: bare number (in base units) or `{ value, unit }` tag. */
+type UnitValue = number | {
+    value: number;
+    unit: Unit;
+};
+/**
+ * Resolve a UnitValue to a number in base units.
+ *  - bare number: returned as-is (assumed base)
+ *  - tagged: looks up factor; throws if unit not in unit system
+ */
+declare function resolveUnit(v: UnitValue, unitSystem?: UnitSystem): number;
+/**
+ * Format a base-unit number as a string in the named display unit.
+ *  e.g. formatUnit(36, 'ft', IMPERIAL_INCHES) => '3ft'
+ *  Default precision: 2. Trailing zeros trimmed.
+ */
+declare function formatUnit(baseValue: number, displayUnit: Unit, unitSystem: UnitSystem, opts?: {
+    precision?: number;
+    suffix?: boolean;
+}): string;
+/** Imperial unit system with base 'in'. */
+declare const IMPERIAL_INCHES: UnitSystem;
+/** Metric unit system with base 'mm'. */
+declare const METRIC_MM: UnitSystem;
+/** Pixel unit system — sole unit is the base. */
+declare const PIXELS: UnitSystem;
+
+/** Option surface for the `move` action.
+ *
+ *  Lives in a sibling file (not `move.ts`) so the type contract stays stable
+ *  even after the legacy `useMove` hook is gone.
+ *  Consumers should import from here directly; `move.ts` re-exports the
+ *  same symbol for back-compat. */
+
+interface UseMoveOptions<TPose> {
+    /** How to apply a `(dx, dy)` translation to a pose. Defaults to
+     *  `translateRectPose`, which assumes the pose carries top-level
+     *  `x`/`y` (the common rect-shaped case). Override for non-rect poses
+     *  (e.g. `Path` → `translatePath`). */
+    translatePose?: (pose: TPose, dx: number, dy: number) => TPose;
+    behaviors?: MoveBehavior<TPose>[];
+    dragThresholdPx?: number;
+    moveLabel?: string;
+    /** Reserved for transient gestures (no history entry). Move is never transient
+     *  in practice; accepted for API consistency but ignored. */
+    transient?: boolean;
+    onGestureStart?(ids: string[]): void;
+    onGestureEnd?(committed: boolean): void;
+    /** Optional: expand the incoming id list before pose lookups. Used for
+     *  group expansion (groups have no pose; their leaves do).
+     *  Called once at `start()`. The returned list flows through ctx,
+     *  overlay (`overlay.draggedIds` is the **expanded** leaves), and op
+     *  generation. Returning `[]` aborts the gesture cleanly.
+     *  Default: identity. */
+    expandIds?: (ids: string[]) => string[];
+    /** Optional: lookup a world-space pose by id. When supplied alongside
+     *  `adapter.getChildren`, the hook walks each dragged id's descendants and
+     *  includes them in the live overlay (translated by the same drag delta
+     *  and added to `overlay.hideIds`) so structurally-grouped children visually
+     *  follow the parent during the gesture. No transform ops are generated
+     *  for cascaded ids — under local-pose semantics, a child's local pose is
+     *  unchanged when its parent's local pose moves, so the post-commit scene
+     *  is already correct.
+     *
+     *  Pair with `worldPoseLookup(adapter, composeRectPose)` from
+     *  `@weasel-js/core/transforms` for the standard rect case. Returning
+     *  `null` for an id (e.g., one removed mid-render) skips it. */
+    cascadeWorldPose?: (id: string) => TPose | null;
+}
+
+/**
+ * Projection used by `gridSnapStrategy` when `TPose` doesn't expose `{x,y}`
+ * directly (Path, polygon, etc.). The strategy reads the snap point via
+ * `getOrigin`, rounds it to the grid, then asks `translate` to move the
+ * pose by the resulting delta.
+ */
+interface OriginProjection<TPose> {
+    getOrigin(pose: TPose): {
+        x: number;
+        y: number;
+    };
+    translate(pose: TPose, dx: number, dy: number): TPose;
+}
+/** Identity projection for `TPose extends { x; y }`. */
+declare const RECT_ORIGIN_PROJECTION: OriginProjection<{
+    x: number;
+    y: number;
+}>;
+/** Snap-strategy that rounds the pose's origin to the nearest multiple of
+ *  `spacing` (resolved through `unitSystem`). For non-rect TPose pass an
+ *  `OriginProjection` so the strategy knows how to read/write the origin. */
+declare function gridSnapStrategy<TPose>(spacing: UnitValue, unitSystem?: UnitSystem): SnapStrategy<TPose>;
+declare function gridSnapStrategy<TPose>(spacing: UnitValue, opts: {
+    unitSystem?: UnitSystem;
+    debug?: DebugSink;
+}): SnapStrategy<TPose>;
+declare function gridSnapStrategy<TPose>(spacing: UnitValue, opts: {
+    unitSystem?: UnitSystem;
+    origin: OriginProjection<TPose>;
+    debug?: DebugSink;
+}): SnapStrategy<TPose>;
+/**
+ * Compute the integer cell `{col, row}` that contains `point`, given a grid
+ * `spacing` and optional `origin` and `unitSystem`. Pair with
+ * `createCellHighlightLayer` (its `getCell` callback) to draw a snap-target
+ * preview that uses the same spacing as `gridSnapStrategy` — so the visual
+ * and behavioral grids stay in lockstep:
+ *
+ *     const SPACING = 20;
+ *     const snap = gridSnapStrategy(SPACING);
+ *     // visual grid:
+ *     createGridLayer({ spacing: SPACING, bounds: () => ... });
+ *     // hover-preview overlay:
+ *     createCellHighlightLayer({
+ *       spacing: SPACING,
+ *       getCell: () => hoverPoint && pointToGridCell(hoverPoint, SPACING),
+ *     });
+ */
+declare function pointToGridCell(point: {
+    x: number;
+    y: number;
+}, spacing: UnitValue, unitSystem?: UnitSystem, origin?: {
+    x: number;
+    y: number;
+}): {
+    col: number;
+    row: number;
+};
+
+export { IMPERIAL_INCHES as I, METRIC_MM as M, type OriginProjection as O, PIXELS as P, RECT_ORIGIN_PROJECTION as R, type UseMoveOptions as U, type UnitValue as a, type UnitSystem as b, type Unit as c, formatUnit as f, gridSnapStrategy as g, pointToGridCell as p, resolveUnit as r };