@grida/svg-editor 1.0.0-alpha.2 → 1.0.0-alpha.3

package/dist/{editor-klT8wu-x.d.ts → editor-Da446SPO.d.ts}

@@ -1,113 +1,7 @@
+import cmath from "@grida/cmath";
 import * as _$_grida_history0 from "@grida/history";
 import { Keybinding, Platform } from "@grida/keybinding";
 
-//#region src/commands/registry.d.ts
-/**
- * Command registry.
- *
- * A passive id-keyed registry of handlers. Built so that:
- *
- *  - keybindings (in `src/keymap`) can address commands by stable id;
- *  - new commands can be added in ONE place (`src/commands/defaults.ts`)
- *    without growing the public surface of the editor;
- *  - "one key, many meanings" can be expressed via chain semantics: a
- *    handler returns `true` if it consumed, `false`/`void` otherwise,
- *    and the dispatcher tries the next candidate in the chain.
- *
- * Handlers are plain closures — they capture whatever editor reference
- * they need. The registry itself stays unaware of the editor's type,
- * which avoids a circular type dependency between editor and registry.
- */
-/** Stable, dotted id for a command, e.g. `"history.undo"`. */
-type CommandId = string;
-/**
- * A command handler.
- *
- * Return `true` if the handler consumed the invocation. Return `false`
- * or `undefined` to signal "did not apply" — the dispatcher will try
- * the next candidate registered for the same key.
- *
- * Handlers are closures: they capture their editor reference. No
- * editor parameter is passed — keep handlers self-contained.
- */
-type CommandHandler = (args?: unknown) => boolean | void;
-declare class CommandRegistry {
-  private readonly map;
-  /**
-   * Register a command. Returns an unregister function. Re-registering
-   * the same id replaces the previous handler (last writer wins).
-   */
-  register(id: CommandId, handler: CommandHandler): () => void;
-  /**
-   * Invoke a command by id. Returns `true` if the handler consumed,
-   * `false` otherwise (including unknown ids and handlers that returned
-   * `false`/`undefined`).
-   */
-  invoke(id: CommandId, args?: unknown): boolean;
-  has(id: CommandId): boolean;
-  /** All registered ids, for debugging / introspection. */
-  ids(): readonly CommandId[];
-}
-//#endregion
-//#region src/keymap/keymap.d.ts
-type KeymapBinding = {
-  /** Declarative key combination. Build with `kb()` / `c()` / `seq()`. */keybinding: Keybinding; /** Command id to invoke on match. */
-  command: CommandId; /** Forwarded as the `args` parameter to the command handler. */
-  args?: unknown; /** Higher priorities run first in the chain. Default 0. */
-  priority?: number;
-  /**
-   * Reserved for V2; not honored by the V1 dispatcher. When added, this
-   * will be evaluated before the handler runs; if false, the binding is
-   * skipped without invoking the handler.
-   */
-  when?: (ctx: unknown) => boolean;
-};
-declare class Keymap {
-  private readonly commands;
-  private readonly platformGetter;
-  /**
-   * Bindings bucketed by canonical chunk-key hash, computed per
-   * `@grida/keybinding`'s `chunkKey`. Each list is the chain for that
-   * key, sorted in dispatch order (priority desc, then registration
-   * order).
-   */
-  private readonly buckets;
-  /** Insert order, so ties on priority are deterministic. */
-  private seq;
-  constructor(commands: CommandRegistry, platformGetter?: () => Platform);
-  /**
-   * Bind a key combination to a command. Returns an unbind function.
-   * The same `Keybinding` can be bound to multiple commands — they will
-   * all be tried in chain order on dispatch.
-   */
-  bind(binding: KeymapBinding): () => void;
-  /**
-   * Remove bindings matching the spec. If both filters are passed, only
-   * bindings that match BOTH are removed.
-   */
-  unbind(spec: {
-    keybinding?: Keybinding;
-    command?: CommandId;
-  }): void;
-  /** All registered bindings, for introspection. Order is not guaranteed. */
-  bindings(): readonly KeymapBinding[];
-  /**
-   * Match the event against bound chunks, then run candidates in chain
-   * order. Returns `true` and calls `preventDefault()` on the first
-   * handler that consumes; returns `false` if nothing matched or all
-   * matches fell through.
-   */
-  dispatch(event: KeyboardEvent): boolean;
-  /**
-   * Compute the set of canonical hashes a `Keybinding` lights up. A
-   * binding with aliases (multiple sequences) contributes one hash per
-   * single-chunk alias; multi-chunk sequences (chords) are skipped in
-   * V1.
-   */
-  private chunkKeysFor;
-  private has_safe_mod;
-}
-//#endregion
 //#region src/types.d.ts
 /**
  * Stable identifier for a node in the editor's document model.
@@ -278,6 +172,206 @@ type PaintPreviewSession = {
   discard(): void;
 };
 //#endregion
+//#region src/core/camera.d.ts
+/**
+ * Returns world-space bounds for the given target, or `null` when
+ * unresolvable (e.g. empty selection, unknown node id). Implemented by the
+ * surface — the camera itself has no view into the document.
+ *
+ * Only string targets are passed to the resolver — `Rect` targets are
+ * handled by the camera as identity (the rect IS its own bounds).
+ */
+type BoundsResolver = (target: "<root>" | "<selection>" | NodeId) => Rect | null;
+type CameraOptions = {
+  resolve_bounds: BoundsResolver;
+  initial?: cmath.Transform;
+};
+/**
+ * Surface-scoped pan/zoom state.
+ *
+ * The public shape leads with the peer convention (`center` / `zoom` /
+ * `bounds`) and keeps the matrix as an advanced read. Methods mirror
+ * Figma/Penpot where they overlap.
+ */
+declare class Camera {
+  private _transform;
+  private viewport_w;
+  private viewport_h;
+  private listeners;
+  private resolve_bounds;
+  constructor(opts: CameraOptions);
+  /** Underlying 2D affine. World→screen. */
+  get transform(): cmath.Transform;
+  /** Uniform scale factor. 1 = 100 %. */
+  get zoom(): number;
+  /** World-space point currently at viewport center. */
+  get center(): Vec2;
+  /** World-space rectangle visible in the viewport. */
+  get bounds(): Rect;
+  /** Translate the camera by a screen-space delta. */
+  pan(delta_screen: Vec2): void;
+  /**
+   * Multiply zoom by `factor` keeping `origin_screen` fixed in world space.
+   * Used by wheel-zoom-at-cursor and pinch-zoom.
+   */
+  zoom_at(factor: number, origin_screen: Vec2): void;
+  /** Pan so `c` lands at the viewport center. Zoom unchanged. */
+  set_center(c: Vec2): void;
+  /** Set zoom directly; pivot defaults to viewport center. */
+  set_zoom(z: number, pivot_screen?: Vec2): void;
+  /**
+   * Replace the entire transform.
+   *
+   * Idempotent: when the new transform is element-wise equal to the current
+   * one, this is a no-op (no notification fires). This is the seam that
+   * makes external constraint loops (e.g. "subscribe → compute clamped →
+   * set_transform") terminate: the clamp re-emits the same transform on
+   * the second pass, set_transform short-circuits, no recursion.
+   */
+  set_transform(t: cmath.Transform): void;
+  /** Viewport size in screen pixels. Read by host code computing constraints. */
+  get viewport_size(): {
+    width: number;
+    height: number;
+  };
+  /**
+   * Fit a target into the viewport.
+   *
+   * - `"<root>"` — the document root's content bounds (host-resolved).
+   * - `"<selection>"` — current editor.state.selection's union bounds.
+   * - `NodeId` — that node's content bounds.
+   * - `Rect` — an explicit world-space rectangle.
+   *
+   * No-ops if the target resolves to `null` (e.g. empty selection) or if
+   * the viewport size is 0 (no container).
+   */
+  fit(target: "<root>" | "<selection>" | NodeId | Rect, opts?: {
+    margin?: number;
+  }): void;
+  /** Snap back to identity. */
+  reset(): void;
+  /**
+   * Subscribe to camera changes. Fires on every mutation. Cheap channel —
+   * does NOT bump `editor.state.version`. Same pattern as
+   * `editor.subscribe_surface_hover`.
+   */
+  subscribe(cb: () => void): Unsubscribe;
+  /** @internal Surface drives this on container resize. */
+  _set_viewport_size(w: number, h: number): void;
+  /** Convert a screen-space point to world-space. */
+  screen_to_world(p: Vec2): Vec2;
+  /** Convert a world-space point to screen-space. */
+  world_to_screen(p: Vec2): Vec2;
+  private notify;
+}
+//#endregion
+//#region src/commands/registry.d.ts
+/**
+ * Command registry.
+ *
+ * A passive id-keyed registry of handlers. Built so that:
+ *
+ *  - keybindings (in `src/keymap`) can address commands by stable id;
+ *  - new commands can be added in ONE place (`src/commands/defaults.ts`)
+ *    without growing the public surface of the editor;
+ *  - "one key, many meanings" can be expressed via chain semantics: a
+ *    handler returns `true` if it consumed, `false`/`void` otherwise,
+ *    and the dispatcher tries the next candidate in the chain.
+ *
+ * Handlers are plain closures — they capture whatever editor reference
+ * they need. The registry itself stays unaware of the editor's type,
+ * which avoids a circular type dependency between editor and registry.
+ */
+/** Stable, dotted id for a command, e.g. `"history.undo"`. */
+type CommandId = string;
+/**
+ * A command handler.
+ *
+ * Return `true` if the handler consumed the invocation. Return `false`
+ * or `undefined` to signal "did not apply" — the dispatcher will try
+ * the next candidate registered for the same key.
+ *
+ * Handlers are closures: they capture their editor reference. No
+ * editor parameter is passed — keep handlers self-contained.
+ */
+type CommandHandler = (args?: unknown) => boolean | void;
+declare class CommandRegistry {
+  private readonly map;
+  /**
+   * Register a command. Returns an unregister function. Re-registering
+   * the same id replaces the previous handler (last writer wins).
+   */
+  register(id: CommandId, handler: CommandHandler): () => void;
+  /**
+   * Invoke a command by id. Returns `true` if the handler consumed,
+   * `false` otherwise (including unknown ids and handlers that returned
+   * `false`/`undefined`).
+   */
+  invoke(id: CommandId, args?: unknown): boolean;
+  has(id: CommandId): boolean;
+  /** All registered ids, for debugging / introspection. */
+  ids(): readonly CommandId[];
+}
+//#endregion
+//#region src/keymap/keymap.d.ts
+type KeymapBinding = {
+  /** Declarative key combination. Build with `kb()` / `c()` / `seq()`. */keybinding: Keybinding; /** Command id to invoke on match. */
+  command: CommandId; /** Forwarded as the `args` parameter to the command handler. */
+  args?: unknown; /** Higher priorities run first in the chain. Default 0. */
+  priority?: number;
+  /**
+   * Reserved for V2; not honored by the V1 dispatcher. When added, this
+   * will be evaluated before the handler runs; if false, the binding is
+   * skipped without invoking the handler.
+   */
+  when?: (ctx: unknown) => boolean;
+};
+declare class Keymap {
+  private readonly commands;
+  private readonly platformGetter;
+  /**
+   * Bindings bucketed by canonical chunk-key hash, computed per
+   * `@grida/keybinding`'s `chunkKey`. Each list is the chain for that
+   * key, sorted in dispatch order (priority desc, then registration
+   * order).
+   */
+  private readonly buckets;
+  /** Insert order, so ties on priority are deterministic. */
+  private seq;
+  constructor(commands: CommandRegistry, platformGetter?: () => Platform);
+  /**
+   * Bind a key combination to a command. Returns an unbind function.
+   * The same `Keybinding` can be bound to multiple commands — they will
+   * all be tried in chain order on dispatch.
+   */
+  bind(binding: KeymapBinding): () => void;
+  /**
+   * Remove bindings matching the spec. If both filters are passed, only
+   * bindings that match BOTH are removed.
+   */
+  unbind(spec: {
+    keybinding?: Keybinding;
+    command?: CommandId;
+  }): void;
+  /** All registered bindings, for introspection. Order is not guaranteed. */
+  bindings(): readonly KeymapBinding[];
+  /**
+   * Match the event against bound chunks, then run candidates in chain
+   * order. Returns `true` and calls `preventDefault()` on the first
+   * handler that consumes; returns `false` if nothing matched or all
+   * matches fell through.
+   */
+  dispatch(event: KeyboardEvent): boolean;
+  /**
+   * Compute the set of canonical hashes a `Keybinding` lights up. A
+   * binding with aliases (multiple sequences) contributes one hash per
+   * single-chunk alias; multi-chunk sequences (chords) are skipped in
+   * V1.
+   */
+  private chunkKeysFor;
+  private has_safe_mod;
+}
+//#endregion
 //#region src/core/parser.d.ts
 type AttrToken = {
   /** Verbatim source name including any prefix, e.g. "xlink:href". */raw_name: string; /** Prefix or null. */
@@ -439,6 +533,62 @@ type Defs = {
 //#region src/core/properties.d.ts
 declare function read_property(doc: SvgDocument, id: NodeId, property: string): PropertyValue;
 //#endregion
+//#region src/gestures/gestures.d.ts
+/** Stable identifier for a gesture binding. Used by `unbind({ id })`. */
+type GestureId = string;
+/**
+ * Context passed to every installer. Exposes the seams a gesture needs:
+ * the container element to listen on, the camera to mutate, and the
+ * editor for keymap dispatch / state reads.
+ *
+ * Surface authors construct this once at attach; bindings receive it on
+ * every `install(...)` call.
+ */
+type GestureContext = {
+  /** Container element listeners attach to. */container: HTMLElement; /** SVG element being framed by the camera. Useful for hit-testing. */
+  svg_root: () => SVGSVGElement | null; /** HUD canvas overlay; sits on top of the SVG. */
+  hud_canvas: HTMLCanvasElement; /** Camera the binding mutates. */
+  camera: Camera; /** Editor for keymap dispatch / state reads. */
+  editor: SvgEditor; /** Handle for advanced bindings (e.g. wanting `camera.fit("<selection>")`). */
+  handle: SurfaceHandle;
+};
+type GestureBinding = {
+  /** Stable id used by `unbind` / `bindings()`. */id: GestureId;
+  /**
+   * Wire DOM listeners (or any side-effect) needed for this gesture.
+   * Returns the uninstaller — called on `unbind` or surface detach.
+   */
+  install(ctx: GestureContext): () => void;
+};
+/**
+ * Sibling to `Keymap`. Owns a list of installed gesture bindings; each
+ * binding's `install(ctx)` is called eagerly when bound and uninstalled
+ * on `unbind` or surface detach.
+ */
+declare class Gestures {
+  private readonly ctx;
+  private entries;
+  constructor(ctx: GestureContext);
+  /**
+   * Install a gesture binding. Returns an unbind function.
+   * Re-binding the same `id` does NOT replace — both will be active.
+   * Use `unbind({ id })` first if you want a clean swap.
+   */
+  bind(binding: GestureBinding): () => void;
+  /**
+   * Remove bindings matching the spec. With `{ id }`, all bindings with
+   * that id are uninstalled. With no spec, this is a no-op (use
+   * `dispose()` to nuke everything).
+   */
+  unbind(spec: {
+    id?: GestureId;
+  }): void;
+  /** All currently installed bindings. Order is registration order. */
+  bindings(): readonly GestureBinding[];
+  /** @internal Uninstall every binding. Surface calls on detach. */
+  _dispose(): void;
+}
+//#endregion
 //#region src/core/editor.d.ts
 /** Resolved paint from the DOM-attached cascade. `resolved_paint` mirrors the
  *  shape of `PaintValue.computed` so consumers can treat it uniformly with
@@ -609,4 +759,4 @@ declare function createSvgEditor(opts: CreateSvgEditorOptions): {
   keymap: Keymap;
 };
 //#endregion
-export { RadialGradientDefinition as A, PaintFallback as C, PropertyValue as D, PreviewSession as E, KeymapBinding as F, CommandHandler as I, CommandId as L, ReorderDirection as M, Unsubscribe as N, Provenance as O, Vec2 as P, Paint as S, PaintValue as T, GradientStop as _, SurfaceHandle as a, Mode as b, ClipboardProvider as c, EditorState as d, EditorStyle as f, GradientEntry as g, GradientDefinition as h, DomComputedResolver as i, Rect as j, Providers as k, Color as l, FontResolver as m, CreateSvgEditorOptions as n, SvgEditor as o, FileIOProvider as p, DomComputedPaint as r, createSvgEditor as s, Commands as t, DEFAULT_STYLE as u, InvalidComputedValue as v, PaintPreviewSession as w, NodeId as x, LinearGradientDefinition as y };
+export { Mode as A, RadialGradientDefinition as B, FileIOProvider as C, GradientStop as D, GradientEntry as E, PaintValue as F, ReorderDirection as H, PreviewSession as I, PropertyValue as L, Paint as M, PaintFallback as N, InvalidComputedValue as O, PaintPreviewSession as P, Provenance as R, EditorStyle as S, GradientDefinition as T, Unsubscribe as U, Rect as V, Vec2 as W, CameraOptions as _, SurfaceHandle as a, DEFAULT_STYLE as b, GestureBinding as c, Gestures as d, KeymapBinding as f, Camera as g, BoundsResolver as h, DomComputedResolver as i, NodeId as j, LinearGradientDefinition as k, GestureContext as l, CommandId as m, CreateSvgEditorOptions as n, SvgEditor as o, CommandHandler as p, DomComputedPaint as r, createSvgEditor as s, Commands as t, GestureId as u, ClipboardProvider as v, FontResolver as w, EditorState as x, Color as y, Providers as z };

package/dist/{editor-DllAMsDu.js → editor-Eon0043Z.js}

@@ -1,5 +1,5 @@
-require("./dom-CfP_ZURh.js");
-const require_paint = require("./paint-DHq_3iwU.js");
+require("./dom-BlJZWpR_.js");
+const require_paint = require("./paint-CVLZazOa.js");
 let _grida_history = require("@grida/history");
 let _grida_keybinding = require("@grida/keybinding");
 //#region src/commands/registry.ts
@@ -112,15 +112,6 @@ const TEXT_INPUT_SAFE_MODS = new Set([
 	_grida_keybinding.KeyCode.Ctrl,
 	_grida_keybinding.KeyCode.Alt
 ]);
-function is_text_input_focused() {
-	if (typeof document === "undefined") return false;
-	const el = document.activeElement;
-	if (!el) return false;
-	const tag = el.tagName;
-	if (tag === "INPUT" || tag === "TEXTAREA") return true;
-	if (el.isContentEditable) return true;
-	return false;
-}
 var Keymap = class {
 	constructor(commands, platformGetter = _grida_keybinding.getKeyboardOS) {
 		this.commands = commands;
@@ -189,7 +180,7 @@ var Keymap = class {
 		const hash = (0, _grida_keybinding.chunkKey)(chunk);
 		const list = this.buckets.get(hash);
 		if (!list || list.length === 0) return false;
-		const text_focused = is_text_input_focused();
+		const text_focused = require_paint.is_text_input_focused();
 		for (const { binding } of list) {
 			if (text_focused && !this.has_safe_mod(chunk.mods)) continue;
 			if (this.commands.invoke(binding.command, binding.args)) {

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { A as RadialGradientDefinition, C as PaintFallback, D as PropertyValue, E as PreviewSession, F as KeymapBinding, I as CommandHandler, L as CommandId, M as ReorderDirection, N as Unsubscribe, O as Provenance, P as Vec2, S as Paint, T as PaintValue, _ as GradientStop, a as SurfaceHandle, b as Mode, c as ClipboardProvider, d as EditorState, f as EditorStyle, g as GradientEntry, h as GradientDefinition, i as DomComputedResolver, j as Rect, k as Providers, l as Color, m as FontResolver, n as CreateSvgEditorOptions, o as SvgEditor, p as FileIOProvider, r as DomComputedPaint, s as createSvgEditor, t as Commands, u as DEFAULT_STYLE, v as InvalidComputedValue, w as PaintPreviewSession, x as NodeId, y as LinearGradientDefinition } from "./editor-BryibVvr.mjs";
-export { type ClipboardProvider, type Color, type CommandHandler, type CommandId, type Commands, type CreateSvgEditorOptions, DEFAULT_STYLE, type DomComputedPaint, type DomComputedResolver, type EditorState, type EditorStyle, type FileIOProvider, type FontResolver, type GradientDefinition, type GradientEntry, type GradientStop, type InvalidComputedValue, type KeymapBinding, type LinearGradientDefinition, type Mode, type NodeId, type Paint, type PaintFallback, type PaintPreviewSession, type PaintValue, type PreviewSession, type PropertyValue, type Provenance, type Providers, type RadialGradientDefinition, type Rect, type ReorderDirection, type SurfaceHandle, type SvgEditor, type Unsubscribe, type Vec2, createSvgEditor };
+import { A as Mode, B as RadialGradientDefinition, C as FileIOProvider, D as GradientStop, E as GradientEntry, F as PaintValue, H as ReorderDirection, I as PreviewSession, L as PropertyValue, M as Paint, N as PaintFallback, O as InvalidComputedValue, P as PaintPreviewSession, R as Provenance, S as EditorStyle, T as GradientDefinition, U as Unsubscribe, V as Rect, W as Vec2, _ as CameraOptions, a as SurfaceHandle, b as DEFAULT_STYLE, c as GestureBinding, d as Gestures, f as KeymapBinding, g as Camera, h as BoundsResolver, i as DomComputedResolver, j as NodeId, k as LinearGradientDefinition, l as GestureContext, m as CommandId, n as CreateSvgEditorOptions, o as SvgEditor, p as CommandHandler, r as DomComputedPaint, s as createSvgEditor, t as Commands, u as GestureId, v as ClipboardProvider, w as FontResolver, x as EditorState, y as Color, z as Providers } from "./editor-DSADZszj.mjs";
+export { type BoundsResolver, type Camera, type CameraOptions, type ClipboardProvider, type Color, type CommandHandler, type CommandId, type Commands, type CreateSvgEditorOptions, DEFAULT_STYLE, type DomComputedPaint, type DomComputedResolver, type EditorState, type EditorStyle, type FileIOProvider, type FontResolver, type GestureBinding, type GestureContext, type GestureId, type Gestures, type GradientDefinition, type GradientEntry, type GradientStop, type InvalidComputedValue, type KeymapBinding, type LinearGradientDefinition, type Mode, type NodeId, type Paint, type PaintFallback, type PaintPreviewSession, type PaintValue, type PreviewSession, type PropertyValue, type Provenance, type Providers, type RadialGradientDefinition, type Rect, type ReorderDirection, type SurfaceHandle, type SvgEditor, type Unsubscribe, type Vec2, createSvgEditor };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { A as RadialGradientDefinition, C as PaintFallback, D as PropertyValue, E as PreviewSession, F as KeymapBinding, I as CommandHandler, L as CommandId, M as ReorderDirection, N as Unsubscribe, O as Provenance, P as Vec2, S as Paint, T as PaintValue, _ as GradientStop, a as SurfaceHandle, b as Mode, c as ClipboardProvider, d as EditorState, f as EditorStyle, g as GradientEntry, h as GradientDefinition, i as DomComputedResolver, j as Rect, k as Providers, l as Color, m as FontResolver, n as CreateSvgEditorOptions, o as SvgEditor, p as FileIOProvider, r as DomComputedPaint, s as createSvgEditor, t as Commands, u as DEFAULT_STYLE, v as InvalidComputedValue, w as PaintPreviewSession, x as NodeId, y as LinearGradientDefinition } from "./editor-klT8wu-x.js";
-export { type ClipboardProvider, type Color, type CommandHandler, type CommandId, type Commands, type CreateSvgEditorOptions, DEFAULT_STYLE, type DomComputedPaint, type DomComputedResolver, type EditorState, type EditorStyle, type FileIOProvider, type FontResolver, type GradientDefinition, type GradientEntry, type GradientStop, type InvalidComputedValue, type KeymapBinding, type LinearGradientDefinition, type Mode, type NodeId, type Paint, type PaintFallback, type PaintPreviewSession, type PaintValue, type PreviewSession, type PropertyValue, type Provenance, type Providers, type RadialGradientDefinition, type Rect, type ReorderDirection, type SurfaceHandle, type SvgEditor, type Unsubscribe, type Vec2, createSvgEditor };
+import { A as Mode, B as RadialGradientDefinition, C as FileIOProvider, D as GradientStop, E as GradientEntry, F as PaintValue, H as ReorderDirection, I as PreviewSession, L as PropertyValue, M as Paint, N as PaintFallback, O as InvalidComputedValue, P as PaintPreviewSession, R as Provenance, S as EditorStyle, T as GradientDefinition, U as Unsubscribe, V as Rect, W as Vec2, _ as CameraOptions, a as SurfaceHandle, b as DEFAULT_STYLE, c as GestureBinding, d as Gestures, f as KeymapBinding, g as Camera, h as BoundsResolver, i as DomComputedResolver, j as NodeId, k as LinearGradientDefinition, l as GestureContext, m as CommandId, n as CreateSvgEditorOptions, o as SvgEditor, p as CommandHandler, r as DomComputedPaint, s as createSvgEditor, t as Commands, u as GestureId, v as ClipboardProvider, w as FontResolver, x as EditorState, y as Color, z as Providers } from "./editor-Da446SPO.js";
+export { type BoundsResolver, type Camera, type CameraOptions, type ClipboardProvider, type Color, type CommandHandler, type CommandId, type Commands, type CreateSvgEditorOptions, DEFAULT_STYLE, type DomComputedPaint, type DomComputedResolver, type EditorState, type EditorStyle, type FileIOProvider, type FontResolver, type GestureBinding, type GestureContext, type GestureId, type Gestures, type GradientDefinition, type GradientEntry, type GradientStop, type InvalidComputedValue, type KeymapBinding, type LinearGradientDefinition, type Mode, type NodeId, type Paint, type PaintFallback, type PaintPreviewSession, type PaintValue, type PreviewSession, type PropertyValue, type Provenance, type Providers, type RadialGradientDefinition, type Rect, type ReorderDirection, type SurfaceHandle, type SvgEditor, type Unsubscribe, type Vec2, createSvgEditor };

package/dist/index.js

@@ -1,4 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_editor = require("./editor-DllAMsDu.js");
+const require_editor = require("./editor-Eon0043Z.js");
 exports.DEFAULT_STYLE = require_editor.DEFAULT_STYLE;
 exports.createSvgEditor = require_editor.createSvgEditor;

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { n as DEFAULT_STYLE, t as createSvgEditor } from "./editor-M6j8XGO5.mjs";
+import { n as DEFAULT_STYLE, t as createSvgEditor } from "./editor-DP36h-SE.mjs";
 export { DEFAULT_STYLE, createSvgEditor };

package/dist/{paint-DuCg6Y-K.mjs → paint-BTKvRItP.mjs}

@@ -1,4 +1,20 @@
 import { SVGPathData, SVGPathDataTransformer } from "svg-pathdata";
+//#region src/util/dom.ts
+/**
+* `true` when the document's active element is a text-input-like control
+* (input / textarea / contentEditable). Used by keymap + gesture defaults
+* to avoid hijacking keystrokes while the user is typing.
+*/
+function is_text_input_focused() {
+	if (typeof document === "undefined") return false;
+	const el = document.activeElement;
+	if (!el) return false;
+	const tag = el.tagName;
+	if (tag === "INPUT" || tag === "TEXTAREA") return true;
+	if (el.isContentEditable) return true;
+	return false;
+}
+//#endregion
 //#region src/core/intents.ts
 function num(doc, id, name, fallback = 0) {
 	const v = doc.get_attr(id, name);
@@ -458,4 +474,4 @@ function serialize_paint(paint) {
 	}
 }
 //#endregion
-export { capture_resize_baseline as a, is_resizable as c, apply_translate as i, serialize_paint as n, capture_translate_baseline as o, apply_resize as r, compute_resize_factors as s, parse_paint as t };
+export { capture_resize_baseline as a, is_resizable as c, apply_translate as i, is_text_input_focused as l, serialize_paint as n, capture_translate_baseline as o, apply_resize as r, compute_resize_factors as s, parse_paint as t };

package/dist/{paint-DHq_3iwU.js → paint-CVLZazOa.js}

@@ -1,5 +1,21 @@
-require("./dom-CfP_ZURh.js");
+require("./dom-BlJZWpR_.js");
 let svg_pathdata = require("svg-pathdata");
+//#region src/util/dom.ts
+/**
+* `true` when the document's active element is a text-input-like control
+* (input / textarea / contentEditable). Used by keymap + gesture defaults
+* to avoid hijacking keystrokes while the user is typing.
+*/
+function is_text_input_focused() {
+	if (typeof document === "undefined") return false;
+	const el = document.activeElement;
+	if (!el) return false;
+	const tag = el.tagName;
+	if (tag === "INPUT" || tag === "TEXTAREA") return true;
+	if (el.isContentEditable) return true;
+	return false;
+}
+//#endregion
 //#region src/core/intents.ts
 function num(doc, id, name, fallback = 0) {
 	const v = doc.get_attr(id, name);
@@ -495,6 +511,12 @@ Object.defineProperty(exports, "is_resizable", {
 		return is_resizable;
 	}
 });
+Object.defineProperty(exports, "is_text_input_focused", {
+	enumerable: true,
+	get: function() {
+		return is_text_input_focused;
+	}
+});
 Object.defineProperty(exports, "parse_paint", {
 	enumerable: true,
 	get: function() {

package/dist/react.d.mts

@@ -1,4 +1,6 @@
-import { d as EditorState, f as EditorStyle, k as Providers, o as SvgEditor, t as Commands } from "./editor-BryibVvr.mjs";
+import { S as EditorStyle, o as SvgEditor, t as Commands, x as EditorState, z as Providers } from "./editor-DSADZszj.mjs";
+import { DomSurfaceHandle } from "./dom.mjs";
+import cmath from "@grida/cmath";
 import { ReactNode } from "react";
 import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 
@@ -22,17 +24,40 @@ declare function SvgEditorProvider({
 type SvgEditorCanvasProps = {
   className?: string;
   style?: React.CSSProperties;
+  /**
+   * Install the default gesture set. Default `true`. See
+   * `DomSurfaceOptions.gestures`.
+   */
+  gestures?: boolean;
+  /**
+   * Auto-fit the document on initial attach. Default `false`. See
+   * `DomSurfaceOptions.fit`.
+   */
+  fit?: boolean; /** Initial camera transform. Default identity. */
+  initial_camera?: cmath.Transform;
+  /**
+   * Receives the `DomSurfaceHandle` once the surface is attached, and
+   * `null` on unmount/detach. Use this to thread `handle.camera` /
+   * `handle.gestures` into surrounding chrome (toolbars, badges, etc.).
+   */
+  onAttach?: (handle: DomSurfaceHandle | null) => void;
 };
 /**
  * Renders the editor's SVG into a `div` and wires it to the DOM surface.
  *
- * Internally calls `attach_dom_surface(editor, { container })` on mount and
- * `handle.detach()` on unmount. This is the only UI component the package
- * ships; everything else (toolbar, property panel, etc.) is consumer-built.
+ * Internally calls `attach_dom_surface(editor, { container, ... })` on
+ * mount and `handle.detach()` on unmount. Surface-scoped concerns (camera,
+ * gestures) are reached via the `onAttach` callback — there is no global
+ * context for them, because a host may mount multiple canvases in the
+ * same editor session.
  */
 declare function SvgEditorCanvas({
   className,
-  style
+  style,
+  gestures,
+  fit,
+  initial_camera,
+  onAttach
 }: SvgEditorCanvasProps): _$react_jsx_runtime0.JSX.Element;
 declare function useSvgEditor(): SvgEditor;
 /**
@@ -45,5 +70,23 @@ declare function useEditorState<T>(selector: (state: EditorState) => T, equals?:
  * re-renders (commands themselves don't change identity).
  */
 declare function useCommands(): Commands;
+/**
+ * Subscribe to a slice of `handle.camera` from a `DomSurfaceHandle`. Pass
+ * the handle (or null if it isn't attached yet) and a selector that reads
+ * what you need from the camera. The returned value updates on every
+ * camera mutation — does NOT bump `editor.state.version`.
+ *
+ * Typical use: zoom badge in a toolbar.
+ *
+ * ```tsx
+ * const zoom = useCameraSnapshot(handle, (c) => c.zoom, 1);
+ * return <div>{Math.round(zoom * 100)}%</div>;
+ * ```
+ *
+ * The `fallback` is what's returned when `handle` is `null` (before mount /
+ * after detach). It's also the SSR snapshot value — anything that won't
+ * mismatch with the first client render.
+ */
+declare function useCameraSnapshot<T>(handle: DomSurfaceHandle | null, selector: (camera: DomSurfaceHandle["camera"]) => T, fallback: T): T;
 //#endregion
-export { SvgEditorCanvas, SvgEditorCanvasProps, SvgEditorProvider, SvgEditorProviderProps, useCommands, useEditorState, useSvgEditor };
+export { SvgEditorCanvas, SvgEditorCanvasProps, SvgEditorProvider, SvgEditorProviderProps, useCameraSnapshot, useCommands, useEditorState, useSvgEditor };