@embedpdf/react 3.0.0-next.14 → 3.0.0-next.16

package/dist/shell.d.ts

@@ -1,27 +1,42 @@
-import { OpenSurfaceOptions, ShellCapability } from "@embedpdf/plugin-shell";
+import { n as StateHook } from "./state-0K1I5cM4.js";
+import { EventHook } from "@embedpdf/core";
+import { SurfaceFocusOptions } from "@embedpdf/web";
+import { RefObject } from "react";
+import { OpenSurfaceOptions, ShellCapability, SurfaceProps } from "@embedpdf/plugin-shell";
 export * from "@embedpdf/plugin-shell";
 //#region src/shell.d.ts
-/** The raw capability — throws without a document; for gated subtrees. */
+/** The shell capability: open and close panels, dialogs and menus. Without a document its methods throw `not-ready`. */
 declare function useShell(): ShellCapability;
+/** Subscribe to one shell event for the mounted lifetime: `useShellEvent((shell) => shell.onSurfaceOpened, handler)`. */
+declare function useShellEvent<T>(select: (shell: ShellCapability) => EventHook<T>, handler: (event: T) => void): void;
+/**
+ * Which panels, dialogs and menus are open (the page's State table, declared
+ * once in `shellState`). Takes a selector, and re-renders only when what it
+ * returns changes. Without a document nothing is open.
+ */
+declare const useShellState: StateHook<{
+  openSurfaces: readonly import("@embedpdf/plugin-shell").SurfaceState[];
+  openMenus: readonly string[];
+}>;
 interface SurfaceHandle {
   readonly isOpen: boolean;
-  readonly props: Readonly<Record<string, unknown>> | undefined;
-  open(opts?: OpenSurfaceOptions): void;
+  /** The props the surface was opened with, or updated to; empty when it has none. */
+  readonly props: SurfaceProps;
+  open(options?: OpenSurfaceOptions): void;
   close(): void;
-  toggle(opts?: OpenSurfaceOptions): void;
+  toggle(options?: OpenSurfaceOptions): void;
 }
-/** One named surface (panel / modal / overlay), bound to this subtree's
- *  document. Reads as closed — and intents no-op — while no document is open. */
+/** One named surface (panel, dialog, overlay) of this subtree's document. Reads as closed, and its verbs do nothing, while no document is open. */
 declare function useSurface(id: string): SurfaceHandle;
-interface MenusHandle {
-  readonly open: readonly string[];
-  isOpen(id: string): boolean;
-  toggle(id: string): void;
-  close(id: string): void;
-  closeAll(): void;
-}
-/** The dropdown-menu stack for this subtree's document (empty without one). */
-declare function useMenus(): MenusHandle;
+/**
+ * Put the cursor in `ref`'s element when the surface `id` asks for it: on every
+ * `open(id, { focus: true })`, a command whose panel says `focus` among them, and
+ * when the element mounts while the request is up (the panel opened, or its code
+ * loaded, because of it). A plain open never moves it. `select` selects an input's
+ * text, so typing replaces it. Reads the surface of this subtree's document; use
+ * it in the component that renders the element.
+ */
+declare function useSurfaceFocus(id: string, ref: RefObject<HTMLElement | null>, options?: SurfaceFocusOptions): void;
 //#endregion
-export { MenusHandle, SurfaceHandle, useMenus, useShell, useSurface };
+export { type SurfaceFocusOptions, SurfaceHandle, useShell, useShellEvent, useShellState, useSurface, useSurfaceFocus };
 //# sourceMappingURL=shell.d.ts.map

package/dist/shell.js

@@ -1,25 +1,36 @@
-import "./rolldown-runtime-BBjsoOtd.js";
-import { useCapability, useOptionalCapability, useOptionalSelector } from "./runtime.js";
-import { useMemo } from "react";
-import { ShellToken } from "@embedpdf/plugin-shell";
+import { C as useOptionalSelector, S as useOptionalCapability, f as useCapability, p as useCapabilityEvent } from "./runtime-tD5iJU83.js";
+import { n as stateHook } from "./state-CzI2KlZb.js";
+import { createSurfaceFocusFollower } from "@embedpdf/web";
+import { useEffect, useMemo, useState } from "react";
+import { ShellToken, shellState } from "@embedpdf/plugin-shell";
 export * from "@embedpdf/plugin-shell";
 //#region src/shell.ts
-/** The raw capability — throws without a document; for gated subtrees. */
+/** The shell capability: open and close panels, dialogs and menus. Without a document its methods throw `not-ready`. */
 function useShell() {
 	return useCapability(ShellToken);
 }
-/** One named surface (panel / modal / overlay), bound to this subtree's
-*  document. Reads as closed — and intents no-op — while no document is open. */
+/** Subscribe to one shell event for the mounted lifetime: `useShellEvent((shell) => shell.onSurfaceOpened, handler)`. */
+function useShellEvent(select, handler) {
+	useCapabilityEvent(ShellToken, select, handler);
+}
+/**
+* Which panels, dialogs and menus are open (the page's State table, declared
+* once in `shellState`). Takes a selector, and re-renders only when what it
+* returns changes. Without a document nothing is open.
+*/
+const useShellState = stateHook(shellState);
+const NO_PROPS = Object.freeze({});
+/** One named surface (panel, dialog, overlay) of this subtree's document. Reads as closed, and its verbs do nothing, while no document is open. */
 function useSurface(id) {
 	const shell = useOptionalCapability(ShellToken);
-	const isOpen = useOptionalSelector(ShellToken, (s) => s.isOpen(id), false);
-	const props = useOptionalSelector(ShellToken, (s) => s.surfaceProps(id), void 0);
+	const isOpen = useOptionalSelector(ShellToken, (shell) => shell.isOpen(id), false);
+	const props = useOptionalSelector(ShellToken, (shell) => shell.getSurface(id)?.props ?? NO_PROPS, NO_PROPS);
 	return useMemo(() => ({
 		isOpen,
 		props,
-		open: (opts) => shell?.open(id, opts),
+		open: (options) => shell?.open(id, options),
 		close: () => shell?.close(id),
-		toggle: (opts) => shell?.toggle(id, opts)
+		toggle: (options) => shell?.toggle(id, options)
 	}), [
 		shell,
 		id,
@@ -27,21 +38,22 @@ function useSurface(id) {
 		props
 	]);
 }
-const NO_MENUS = [];
-const stringArrayEqual = (a, b) => a === b || a.length === b.length && a.every((x, i) => x === b[i]);
-/** The dropdown-menu stack for this subtree's document (empty without one). */
-function useMenus() {
+/**
+* Put the cursor in `ref`'s element when the surface `id` asks for it: on every
+* `open(id, { focus: true })`, a command whose panel says `focus` among them, and
+* when the element mounts while the request is up (the panel opened, or its code
+* loaded, because of it). A plain open never moves it. `select` selects an input's
+* text, so typing replaces it. Reads the surface of this subtree's document; use
+* it in the component that renders the element.
+*/
+function useSurfaceFocus(id, ref, options = {}) {
 	const shell = useOptionalCapability(ShellToken);
-	const open = useOptionalSelector(ShellToken, (s) => s.openMenus(), NO_MENUS, stringArrayEqual);
-	return useMemo(() => ({
-		open,
-		isOpen: (id) => open.includes(id),
-		toggle: (id) => shell?.toggleMenu(id),
-		close: (id) => shell?.closeMenu(id),
-		closeAll: () => shell?.closeAllMenus()
-	}), [shell, open]);
+	const request = useOptionalSelector(ShellToken, (current) => current.getSurface(id)?.focusRequest ?? 0, 0);
+	const [follower] = useState(createSurfaceFocusFollower);
+	const select = options.select ?? false;
+	useEffect(() => follower.follow(ref.current, shell, request, { select }));
 }
 //#endregion
-export { useMenus, useShell, useSurface };
+export { useShell, useShellEvent, useShellState, useSurface, useSurfaceFocus };
 
 //# sourceMappingURL=shell.js.map

package/dist/shell.js.map

@@ -1 +1 @@
-{"version":3,"file":"shell.js","names":[],"sources":["../src/shell.ts"],"sourcesContent":["/**\n * The React surface for @embedpdf/plugin-shell. The app owns every\n * surface's DOM; these hooks bind its open/closed state to the kernel so\n * commands can drive it and applications can restore it.\n *\n * These hooks are TOTAL: shell state is document-scoped, and chrome that uses\n * it (panel buttons, mode bands, menu anchors) stays mounted across the\n * empty-workspace state. With no document, surfaces read as closed, menus as\n * none, and intents no-op — mirroring how command execution `tryGet`s the\n * shell. Use the raw capability (`useShell`) when you need fail-fast access\n * inside a <DocumentGate>.\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-shell';\nimport { useMemo } from 'react';\nimport { ShellToken } from '@embedpdf/plugin-shell';\nimport type { OpenSurfaceOptions, ShellCapability } from '@embedpdf/plugin-shell';\nimport { useCapability, useOptionalCapability, useOptionalSelector } from './runtime';\n\n/** The raw capability — throws without a document; for gated subtrees. */\nexport function useShell(): ShellCapability {\n  return useCapability(ShellToken);\n}\n\nexport interface SurfaceHandle {\n  readonly isOpen: boolean;\n  readonly props: Readonly<Record<string, unknown>> | undefined;\n  open(opts?: OpenSurfaceOptions): void;\n  close(): void;\n  toggle(opts?: OpenSurfaceOptions): void;\n}\n\n/** One named surface (panel / modal / overlay), bound to this subtree's\n *  document. Reads as closed — and intents no-op — while no document is open. */\nexport function useSurface(id: string): SurfaceHandle {\n  const shell = useOptionalCapability(ShellToken);\n  const isOpen = useOptionalSelector(ShellToken, (s) => s.isOpen(id), false);\n  const props = useOptionalSelector(ShellToken, (s) => s.surfaceProps(id), undefined);\n  return useMemo(\n    () => ({\n      isOpen,\n      props,\n      open: (opts?: OpenSurfaceOptions) => shell?.open(id, opts),\n      close: () => shell?.close(id),\n      toggle: (opts?: OpenSurfaceOptions) => shell?.toggle(id, opts),\n    }),\n    [shell, id, isOpen, props],\n  );\n}\n\nexport interface MenusHandle {\n  readonly open: readonly string[];\n  isOpen(id: string): boolean;\n  toggle(id: string): void;\n  close(id: string): void;\n  closeAll(): void;\n}\n\nconst NO_MENUS: readonly string[] = [];\nconst stringArrayEqual = (a: readonly string[], b: readonly string[]) =>\n  a === b || (a.length === b.length && a.every((x, i) => x === b[i]));\n\n/** The dropdown-menu stack for this subtree's document (empty without one). */\nexport function useMenus(): MenusHandle {\n  const shell = useOptionalCapability(ShellToken);\n  const open = useOptionalSelector(ShellToken, (s) => s.openMenus(), NO_MENUS, stringArrayEqual);\n  return useMemo(\n    () => ({\n      open,\n      isOpen: (id: string) => open.includes(id),\n      toggle: (id: string) => shell?.toggleMenu(id),\n      close: (id: string) => shell?.closeMenu(id),\n      closeAll: () => shell?.closeAllMenus(),\n    }),\n    [shell, open],\n  );\n}\n"],"mappings":";;;;;;;AAqBA,SAAgB,WAA4B;CAC1C,OAAO,cAAc,UAAU;AACjC;;;AAYA,SAAgB,WAAW,IAA2B;CACpD,MAAM,QAAQ,sBAAsB,UAAU;CAC9C,MAAM,SAAS,oBAAoB,aAAa,MAAM,EAAE,OAAO,EAAE,GAAG,KAAK;CACzE,MAAM,QAAQ,oBAAoB,aAAa,MAAM,EAAE,aAAa,EAAE,GAAG,KAAA,CAAS;CAClF,OAAO,eACE;EACL;EACA;EACA,OAAO,SAA8B,OAAO,KAAK,IAAI,IAAI;EACzD,aAAa,OAAO,MAAM,EAAE;EAC5B,SAAS,SAA8B,OAAO,OAAO,IAAI,IAAI;CAC/D,IACA;EAAC;EAAO;EAAI;EAAQ;CAAK,CAC3B;AACF;AAUA,MAAM,WAA8B,CAAC;AACrC,MAAM,oBAAoB,GAAsB,MAC9C,MAAM,KAAM,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,GAAG,MAAM,MAAM,EAAE,EAAE;;AAGnE,SAAgB,WAAwB;CACtC,MAAM,QAAQ,sBAAsB,UAAU;CAC9C,MAAM,OAAO,oBAAoB,aAAa,MAAM,EAAE,UAAU,GAAG,UAAU,gBAAgB;CAC7F,OAAO,eACE;EACL;EACA,SAAS,OAAe,KAAK,SAAS,EAAE;EACxC,SAAS,OAAe,OAAO,WAAW,EAAE;EAC5C,QAAQ,OAAe,OAAO,UAAU,EAAE;EAC1C,gBAAgB,OAAO,cAAc;CACvC,IACA,CAAC,OAAO,IAAI,CACd;AACF"}
+{"version":3,"file":"shell.js","names":[],"sources":["../src/shell.ts"],"sourcesContent":["/**\n * The React surface for @embedpdf/plugin-shell. The app owns every\n * surface's DOM; these hooks bind its open/closed state to the kernel so\n * commands can drive it and applications can restore it.\n *\n * The state hooks work without a document: shell state is document-scoped,\n * and chrome that uses it (panel buttons, menu anchors) stays mounted across\n * the empty workspace. With no document every surface reads as closed, no menu\n * as open, and `useSurface`'s verbs do nothing. `useShell()` then returns the\n * stand-in, whose methods throw `not-ready`.\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-shell';\nimport { useEffect, useMemo, useState, type RefObject } from 'react';\nimport { ShellToken, shellState } from '@embedpdf/plugin-shell';\nimport type { OpenSurfaceOptions, ShellCapability, SurfaceProps } from '@embedpdf/plugin-shell';\nimport type { EventHook } from '@embedpdf/core';\nimport { createSurfaceFocusFollower, type SurfaceFocusOptions } from '@embedpdf/web';\nimport {\n  useCapability,\n  useCapabilityEvent,\n  useOptionalCapability,\n  useOptionalSelector,\n} from './runtime';\nimport { stateHook } from './state';\n\n/** The shell capability: open and close panels, dialogs and menus. Without a document its methods throw `not-ready`. */\nexport function useShell(): ShellCapability {\n  return useCapability(ShellToken);\n}\n\n/** Subscribe to one shell event for the mounted lifetime: `useShellEvent((shell) => shell.onSurfaceOpened, handler)`. */\nexport function useShellEvent<T>(\n  select: (shell: ShellCapability) => EventHook<T>,\n  handler: (event: T) => void,\n): void {\n  useCapabilityEvent(ShellToken, select, handler);\n}\n\n/**\n * Which panels, dialogs and menus are open (the page's State table, declared\n * once in `shellState`). Takes a selector, and re-renders only when what it\n * returns changes. Without a document nothing is open.\n */\nexport const useShellState = stateHook(shellState);\n\nexport interface SurfaceHandle {\n  readonly isOpen: boolean;\n  /** The props the surface was opened with, or updated to; empty when it has none. */\n  readonly props: SurfaceProps;\n  open(options?: OpenSurfaceOptions): void;\n  close(): void;\n  toggle(options?: OpenSurfaceOptions): void;\n}\n\nconst NO_PROPS: SurfaceProps = Object.freeze({});\n\n/** One named surface (panel, dialog, overlay) of this subtree's document. Reads as closed, and its verbs do nothing, while no document is open. */\nexport function useSurface(id: string): SurfaceHandle {\n  const shell = useOptionalCapability(ShellToken);\n  const isOpen = useOptionalSelector(ShellToken, (shell) => shell.isOpen(id), false);\n  const props = useOptionalSelector(\n    ShellToken,\n    (shell) => shell.getSurface(id)?.props ?? NO_PROPS,\n    NO_PROPS,\n  );\n  return useMemo(\n    () => ({\n      isOpen,\n      props,\n      open: (options?: OpenSurfaceOptions) => shell?.open(id, options),\n      close: () => shell?.close(id),\n      toggle: (options?: OpenSurfaceOptions) => shell?.toggle(id, options),\n    }),\n    [shell, id, isOpen, props],\n  );\n}\n\nexport type { SurfaceFocusOptions };\n\n/**\n * Put the cursor in `ref`'s element when the surface `id` asks for it: on every\n * `open(id, { focus: true })`, a command whose panel says `focus` among them, and\n * when the element mounts while the request is up (the panel opened, or its code\n * loaded, because of it). A plain open never moves it. `select` selects an input's\n * text, so typing replaces it. Reads the surface of this subtree's document; use\n * it in the component that renders the element.\n */\nexport function useSurfaceFocus(\n  id: string,\n  ref: RefObject<HTMLElement | null>,\n  options: SurfaceFocusOptions = {},\n): void {\n  const shell = useOptionalCapability(ShellToken);\n  const request = useOptionalSelector(\n    ShellToken,\n    (current) => current.getSurface(id)?.focusRequest ?? 0,\n    0,\n  );\n  const [follower] = useState(createSurfaceFocusFollower);\n  const select = options.select ?? false;\n  // After every render, so an element that has just appeared is seen, and after the layout\n  // effects, so a panel's frame has placed and shown it (a sheet's layer is hidden until then).\n  useEffect(() => follower.follow(ref.current, shell, request, { select }));\n}\n"],"mappings":";;;;;;;;AA4BA,SAAgB,WAA4B;CAC1C,OAAO,cAAc,UAAU;AACjC;;AAGA,SAAgB,cACd,QACA,SACM;CACN,mBAAmB,YAAY,QAAQ,OAAO;AAChD;;;;;;AAOA,MAAa,gBAAgB,UAAU,UAAU;AAWjD,MAAM,WAAyB,OAAO,OAAO,CAAC,CAAC;;AAG/C,SAAgB,WAAW,IAA2B;CACpD,MAAM,QAAQ,sBAAsB,UAAU;CAC9C,MAAM,SAAS,oBAAoB,aAAa,UAAU,MAAM,OAAO,EAAE,GAAG,KAAK;CACjF,MAAM,QAAQ,oBACZ,aACC,UAAU,MAAM,WAAW,EAAE,CAAC,EAAE,SAAS,UAC1C,QACF;CACA,OAAO,eACE;EACL;EACA;EACA,OAAO,YAAiC,OAAO,KAAK,IAAI,OAAO;EAC/D,aAAa,OAAO,MAAM,EAAE;EAC5B,SAAS,YAAiC,OAAO,OAAO,IAAI,OAAO;CACrE,IACA;EAAC;EAAO;EAAI;EAAQ;CAAK,CAC3B;AACF;;;;;;;;;AAYA,SAAgB,gBACd,IACA,KACA,UAA+B,CAAC,GAC1B;CACN,MAAM,QAAQ,sBAAsB,UAAU;CAC9C,MAAM,UAAU,oBACd,aACC,YAAY,QAAQ,WAAW,EAAE,CAAC,EAAE,gBAAgB,GACrD,CACF;CACA,MAAM,CAAC,YAAY,SAAS,0BAA0B;CACtD,MAAM,SAAS,QAAQ,UAAU;CAGjC,gBAAgB,SAAS,OAAO,IAAI,SAAS,OAAO,SAAS,EAAE,OAAO,CAAC,CAAC;AAC1E"}

package/dist/signature.cjs

@@ -1,73 +1,54 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./rolldown-runtime-DDXJien1.cjs");
-const require_runtime = require("./runtime.cjs");
+const require_runtime = require("./runtime-BfnpyfY0.cjs");
+const require_state = require("./state-Dtf8HAue.cjs");
 const require_stamp = require("./stamp.cjs");
 let react = require("react");
 let _embedpdf_plugin_signature = require("@embedpdf/plugin-signature");
-let _embedpdf_plugin_stamp_contract = require("@embedpdf/plugin-stamp/contract");
 //#region src/signature.tsx
 /**
-* The React view of @embedpdf/plugin-signature: the act of signing for the
-* surrounding `DocumentScope`, its live facts (snapshot, verdicts,
-* protection, target), and the one derivation a signatures panel needs —
-* the people (libraries of kind `signatures`) with their marks.
+* The React view of @embedpdf/plugin-signature: signing for the surrounding
+* document, its state (the signatures with their verdicts, what they allow,
+* the target, a two-step signing in progress), and the one derivation a
+* signatures panel needs: the people (libraries of kind `signatures`) with
+* their marks.
 *
 *   const signature = useSignature();
-*   await signature.placeMark({ assetId }, { field: target });   // sign / fill / ask, by mode
+*   await signature.placeMark({ assetId }, { field: target }); // sign, fill or ask, by mode
 */
-/** The signature capability for the surrounding document. */
+/** The signature API for the surrounding document. */
 function useSignature() {
 	return require_runtime.useCapability(_embedpdf_plugin_signature.SignatureToken);
 }
-/** The last signature snapshot (null until the first read lands). */
-function useSignatureSnapshot() {
-	return require_runtime.useSelector(_embedpdf_plugin_signature.SignatureToken, (c) => c.snapshot());
-}
-/** The last validation (null until one ran). */
-function useSignatureVerdicts() {
-	return require_runtime.useSelector(_embedpdf_plugin_signature.SignatureToken, (c) => c.verdicts());
-}
-/** What the document's signatures forbid (null when nothing is signed or not yet read). */
-function useDocumentProtection() {
-	return require_runtime.useSelector(_embedpdf_plugin_signature.SignatureToken, (c) => c.protection());
-}
-/** The field the next picked mark goes to, and whether a sign/fill is in flight. */
-function useSignatureTarget() {
-	return {
-		target: require_runtime.useSelector(_embedpdf_plugin_signature.SignatureToken, (c) => c.target()),
-		busy: require_runtime.useSelector(_embedpdf_plugin_signature.SignatureToken, (c) => c.busy())
-	};
-}
-/** Subscribe to the plugin's change events (signed / filled / ask / inspect / target / validated …). */
-function useSignatureEvent(handler) {
-	require_runtime.useCapabilityEvent(_embedpdf_plugin_signature.SignatureToken, (c) => c.onChanged, handler);
+/**
+* The signatures' state: the signed fields with their verdicts, what they
+* allow, the target, whether a signing runs, a two-step signing in progress,
+* and whether they're read (the page's State table, declared once in
+* `signatureState`). Takes a selector, and re-renders only when what it
+* returns changes.
+*/
+const useSignatureState = require_state.stateHook(_embedpdf_plugin_signature.signatureState);
+/** The signature settings (`key`, `mode`, `trust`, `allowCertify`), with or without a document. Takes a selector. */
+const useSignatureSettings = require_state.settingsHook(_embedpdf_plugin_signature.SignatureToken);
+/** Subscribe to one of the plugin's events while mounted: `useSignatureEvent((signature) => signature.onSigned, handler)`. */
+function useSignatureEvent(select, handler) {
+	require_runtime.useCapabilityEvent(_embedpdf_plugin_signature.SignatureToken, select, handler);
 }
 /**
-* The people whose marks this browser holds — one row per library of kind
-* `signatures`. Purely derived from the stamp plugin: rename, delete, and
-* export are the library verbs; nothing is stored beyond the file.
+* The people whose marks this browser holds, one row per library of kind
+* `signatures`, for a picker. Derived from the stamp plugin: rename, delete
+* and export are the library verbs; nothing is stored beyond the file.
 */
 function useSignerRows() {
 	const libraries = require_stamp.useStampLibraries({ kind: _embedpdf_plugin_signature.SIGNATURES_LIBRARY_KIND });
-	const assets = require_runtime.useSelector(_embedpdf_plugin_stamp_contract.StampToken, (c) => c.assets(), require_runtime.shallowArray);
-	return (0, react.useMemo)(() => libraries.map((library) => {
-		const own = assets.filter((asset) => asset.libraryId === library.id);
-		return {
-			libraryId: library.id,
-			name: library.name,
-			library,
-			signatures: own.filter((asset) => (0, _embedpdf_plugin_signature.markRoleOf)(asset) === "signature"),
-			initials: own.find((asset) => (0, _embedpdf_plugin_signature.markRoleOf)(asset) === "initials") ?? null
-		};
-	}), [libraries, assets]);
+	const assets = require_stamp.useStampAssets();
+	return (0, react.useMemo)(() => (0, _embedpdf_plugin_signature.signerRowsOf)(libraries, assets), [libraries, assets]);
 }
 //#endregion
-exports.useDocumentProtection = useDocumentProtection;
 exports.useSignature = useSignature;
 exports.useSignatureEvent = useSignatureEvent;
-exports.useSignatureSnapshot = useSignatureSnapshot;
-exports.useSignatureTarget = useSignatureTarget;
-exports.useSignatureVerdicts = useSignatureVerdicts;
+exports.useSignatureSettings = useSignatureSettings;
+exports.useSignatureState = useSignatureState;
 exports.useSignerRows = useSignerRows;
 Object.keys(_embedpdf_plugin_signature).forEach(function(k) {
 	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {

package/dist/signature.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"signature.cjs","names":["useCapability","SignatureToken","useSelector","useStampLibraries","SIGNATURES_LIBRARY_KIND","StampToken","shallowArray"],"sources":["../src/signature.tsx"],"sourcesContent":["/**\n * The React view of @embedpdf/plugin-signature: the act of signing for the\n * surrounding `DocumentScope`, its live facts (snapshot, verdicts,\n * protection, target), and the one derivation a signatures panel needs —\n * the people (libraries of kind `signatures`) with their marks.\n *\n *   const signature = useSignature();\n *   await signature.placeMark({ assetId }, { field: target });   // sign / fill / ask, by mode\n */\nimport { useMemo } from 'react';\nimport {\n  markRoleOf,\n  SIGNATURES_LIBRARY_KIND,\n  SignatureToken,\n  type DocumentProtection,\n  type FormFieldRef,\n  type SignatureCapability,\n  type SignatureChange,\n  type SignatureSnapshot,\n  type SignatureVerdict,\n} from '@embedpdf/plugin-signature';\nimport { StampToken, type StampAsset, type StampLibrary } from '@embedpdf/plugin-stamp/contract';\n\nimport { shallowArray, useCapability, useCapabilityEvent, useSelector } from './runtime';\nimport { useStampLibraries } from './stamp';\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-signature';\n\n/** The signature capability for the surrounding document. */\nexport function useSignature(): SignatureCapability {\n  return useCapability(SignatureToken);\n}\n\n/** The last signature snapshot (null until the first read lands). */\nexport function useSignatureSnapshot(): SignatureSnapshot | null {\n  return useSelector(SignatureToken, (c) => c.snapshot());\n}\n\n/** The last validation (null until one ran). */\nexport function useSignatureVerdicts(): SignatureVerdict[] | null {\n  return useSelector(SignatureToken, (c) => c.verdicts());\n}\n\n/** What the document's signatures forbid (null when nothing is signed or not yet read). */\nexport function useDocumentProtection(): DocumentProtection | null {\n  return useSelector(SignatureToken, (c) => c.protection());\n}\n\n/** The field the next picked mark goes to, and whether a sign/fill is in flight. */\nexport function useSignatureTarget(): { target: FormFieldRef | null; busy: boolean } {\n  const target = useSelector(SignatureToken, (c) => c.target());\n  const busy = useSelector(SignatureToken, (c) => c.busy());\n  return { target, busy };\n}\n\n/** Subscribe to the plugin's change events (signed / filled / ask / inspect / target / validated …). */\nexport function useSignatureEvent(handler: (event: SignatureChange) => void): void {\n  useCapabilityEvent(SignatureToken, (c) => c.onChanged, handler);\n}\n\n/** One person: a library of kind `signatures` with its marks split by role. */\nexport interface SignerRow {\n  libraryId: string;\n  name: string;\n  library: StampLibrary;\n  signatures: StampAsset[];\n  initials: StampAsset | null;\n}\n\n/**\n * The people whose marks this browser holds — one row per library of kind\n * `signatures`. Purely derived from the stamp plugin: rename, delete, and\n * export are the library verbs; nothing is stored beyond the file.\n */\nexport function useSignerRows(): SignerRow[] {\n  const libraries = useStampLibraries({ kind: SIGNATURES_LIBRARY_KIND });\n  const assets = useSelector(StampToken, (c) => c.assets(), shallowArray);\n  return useMemo(\n    () =>\n      libraries.map((library) => {\n        const own = assets.filter((asset) => asset.libraryId === library.id);\n        return {\n          libraryId: library.id,\n          name: library.name,\n          library,\n          signatures: own.filter((asset) => markRoleOf(asset) === 'signature'),\n          initials: own.find((asset) => markRoleOf(asset) === 'initials') ?? null,\n        };\n      }),\n    [libraries, assets],\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA8BA,SAAgB,eAAoC;CAClD,OAAOA,gBAAAA,cAAcC,2BAAAA,cAAc;AACrC;;AAGA,SAAgB,uBAAiD;CAC/D,OAAOC,gBAAAA,YAAYD,2BAAAA,iBAAiB,MAAM,EAAE,SAAS,CAAC;AACxD;;AAGA,SAAgB,uBAAkD;CAChE,OAAOC,gBAAAA,YAAYD,2BAAAA,iBAAiB,MAAM,EAAE,SAAS,CAAC;AACxD;;AAGA,SAAgB,wBAAmD;CACjE,OAAOC,gBAAAA,YAAYD,2BAAAA,iBAAiB,MAAM,EAAE,WAAW,CAAC;AAC1D;;AAGA,SAAgB,qBAAqE;CAGnF,OAAO;EAAE,QAFMC,gBAAAA,YAAYD,2BAAAA,iBAAiB,MAAM,EAAE,OAAO,CAE7C;EAAG,MADJC,gBAAAA,YAAYD,2BAAAA,iBAAiB,MAAM,EAAE,KAAK,CACnC;CAAE;AACxB;;AAGA,SAAgB,kBAAkB,SAAiD;CACjF,gBAAA,mBAAmBA,2BAAAA,iBAAiB,MAAM,EAAE,WAAW,OAAO;AAChE;;;;;;AAgBA,SAAgB,gBAA6B;CAC3C,MAAM,YAAYE,cAAAA,kBAAkB,EAAE,MAAMC,2BAAAA,wBAAwB,CAAC;CACrE,MAAM,SAASF,gBAAAA,YAAYG,gCAAAA,aAAa,MAAM,EAAE,OAAO,GAAGC,gBAAAA,YAAY;CACtE,QAAA,GAAA,MAAA,QAAA,OAEI,UAAU,KAAK,YAAY;EACzB,MAAM,MAAM,OAAO,QAAQ,UAAU,MAAM,cAAc,QAAQ,EAAE;EACnE,OAAO;GACL,WAAW,QAAQ;GACnB,MAAM,QAAQ;GACd;GACA,YAAY,IAAI,QAAQ,WAAA,GAAA,2BAAA,WAAA,CAAqB,KAAK,MAAM,WAAW;GACnE,UAAU,IAAI,MAAM,WAAA,GAAA,2BAAA,WAAA,CAAqB,KAAK,MAAM,UAAU,KAAK;EACrE;CACF,CAAC,GACH,CAAC,WAAW,MAAM,CACpB;AACF"}
+{"version":3,"file":"signature.cjs","names":["useCapability","SignatureToken","stateHook","signatureState","settingsHook","useStampLibraries","SIGNATURES_LIBRARY_KIND","useStampAssets"],"sources":["../src/signature.tsx"],"sourcesContent":["/**\n * The React view of @embedpdf/plugin-signature: signing for the surrounding\n * document, its state (the signatures with their verdicts, what they allow,\n * the target, a two-step signing in progress), and the one derivation a\n * signatures panel needs: the people (libraries of kind `signatures`) with\n * their marks.\n *\n *   const signature = useSignature();\n *   await signature.placeMark({ assetId }, { field: target }); // sign, fill or ask, by mode\n */\nimport { useMemo } from 'react';\nimport type { EventHook } from '@embedpdf/core';\nimport {\n  signatureState,\n  signerRowsOf,\n  SIGNATURES_LIBRARY_KIND,\n  SignatureToken,\n  type SignatureCapability,\n  type SignerRow,\n} from '@embedpdf/plugin-signature';\n\nimport { useCapability, useCapabilityEvent } from './runtime';\nimport { useStampAssets, useStampLibraries } from './stamp';\nimport { settingsHook, stateHook } from './state';\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-signature';\n\n/** The signature API for the surrounding document. */\nexport function useSignature(): SignatureCapability {\n  return useCapability(SignatureToken);\n}\n\n/**\n * The signatures' state: the signed fields with their verdicts, what they\n * allow, the target, whether a signing runs, a two-step signing in progress,\n * and whether they're read (the page's State table, declared once in\n * `signatureState`). Takes a selector, and re-renders only when what it\n * returns changes.\n */\nexport const useSignatureState = stateHook(signatureState);\n\n/** The signature settings (`key`, `mode`, `trust`, `allowCertify`), with or without a document. Takes a selector. */\nexport const useSignatureSettings = settingsHook(SignatureToken);\n\n/** Subscribe to one of the plugin's events while mounted: `useSignatureEvent((signature) => signature.onSigned, handler)`. */\nexport function useSignatureEvent<T>(\n  select: (signature: SignatureCapability) => EventHook<T>,\n  handler: (event: T) => void,\n): void {\n  useCapabilityEvent(SignatureToken, select, handler);\n}\n\n/**\n * The people whose marks this browser holds, one row per library of kind\n * `signatures`, for a picker. Derived from the stamp plugin: rename, delete\n * and export are the library verbs; nothing is stored beyond the file.\n */\nexport function useSignerRows(): SignerRow[] {\n  const libraries = useStampLibraries({ kind: SIGNATURES_LIBRARY_KIND });\n  const assets = useStampAssets();\n  return useMemo(() => signerRowsOf(libraries, assets), [libraries, assets]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,eAAoC;CAClD,OAAOA,gBAAAA,cAAcC,2BAAAA,cAAc;AACrC;;;;;;;;AASA,MAAa,oBAAoBC,cAAAA,UAAUC,2BAAAA,cAAc;;AAGzD,MAAa,uBAAuBC,cAAAA,aAAaH,2BAAAA,cAAc;;AAG/D,SAAgB,kBACd,QACA,SACM;CACN,gBAAA,mBAAmBA,2BAAAA,gBAAgB,QAAQ,OAAO;AACpD;;;;;;AAOA,SAAgB,gBAA6B;CAC3C,MAAM,YAAYI,cAAAA,kBAAkB,EAAE,MAAMC,2BAAAA,wBAAwB,CAAC;CACrE,MAAM,SAASC,cAAAA,eAAe;CAC9B,QAAA,GAAA,MAAA,QAAA,QAAA,GAAA,2BAAA,aAAA,CAAkC,WAAW,MAAM,GAAG,CAAC,WAAW,MAAM,CAAC;AAC3E"}

package/dist/signature.d.cts

@@ -1,36 +1,36 @@
-import { DocumentProtection, FormFieldRef, SignatureCapability, SignatureChange, SignatureSnapshot, SignatureVerdict } from "@embedpdf/plugin-signature";
-import { StampAsset, StampLibrary } from "@embedpdf/plugin-stamp/contract";
+import { n as StateHook, t as SettingsHook } from "./state-0K1I5cM4.cjs";
+import { r as FormFieldRef, t as DocumentProtection } from "./AnnotationList-DcyhF2kU-CiBFOq1z.cjs";
+import { EventHook } from "@embedpdf/core";
+import { SignatureCapability, SignerRow } from "@embedpdf/plugin-signature";
 export * from "@embedpdf/plugin-signature";
 //#region src/signature.d.ts
-/** The signature capability for the surrounding document. */
+/** The signature API for the surrounding document. */
 declare function useSignature(): SignatureCapability;
-/** The last signature snapshot (null until the first read lands). */
-declare function useSignatureSnapshot(): SignatureSnapshot | null;
-/** The last validation (null until one ran). */
-declare function useSignatureVerdicts(): SignatureVerdict[] | null;
-/** What the document's signatures forbid (null when nothing is signed or not yet read). */
-declare function useDocumentProtection(): DocumentProtection | null;
-/** The field the next picked mark goes to, and whether a sign/fill is in flight. */
-declare function useSignatureTarget(): {
+/**
+ * The signatures' state: the signed fields with their verdicts, what they
+ * allow, the target, whether a signing runs, a two-step signing in progress,
+ * and whether they're read (the page's State table, declared once in
+ * `signatureState`). Takes a selector, and re-renders only when what it
+ * returns changes.
+ */
+declare const useSignatureState: StateHook<{
+  signatures: readonly import("@embedpdf/plugin-signature").SignatureInfo[];
+  protection: DocumentProtection | null;
   target: FormFieldRef | null;
   busy: boolean;
-};
-/** Subscribe to the plugin's change events (signed / filled / ask / inspect / target / validated …). */
-declare function useSignatureEvent(handler: (event: SignatureChange) => void): void;
-/** One person: a library of kind `signatures` with its marks split by role. */
-interface SignerRow {
-  libraryId: string;
-  name: string;
-  library: StampLibrary;
-  signatures: StampAsset[];
-  initials: StampAsset | null;
-}
+  pending: import("@embedpdf/plugin-signature").SignaturePending | null;
+  status: import("@embedpdf/core").ResourceStatus;
+}>;
+/** The signature settings (`key`, `mode`, `trust`, `allowCertify`), with or without a document. Takes a selector. */
+declare const useSignatureSettings: SettingsHook<import("@embedpdf/plugin-signature").SignatureSettings>;
+/** Subscribe to one of the plugin's events while mounted: `useSignatureEvent((signature) => signature.onSigned, handler)`. */
+declare function useSignatureEvent<T>(select: (signature: SignatureCapability) => EventHook<T>, handler: (event: T) => void): void;
 /**
- * The people whose marks this browser holds — one row per library of kind
- * `signatures`. Purely derived from the stamp plugin: rename, delete, and
- * export are the library verbs; nothing is stored beyond the file.
+ * The people whose marks this browser holds, one row per library of kind
+ * `signatures`, for a picker. Derived from the stamp plugin: rename, delete
+ * and export are the library verbs; nothing is stored beyond the file.
  */
 declare function useSignerRows(): SignerRow[];
 //#endregion
-export { SignerRow, useDocumentProtection, useSignature, useSignatureEvent, useSignatureSnapshot, useSignatureTarget, useSignatureVerdicts, useSignerRows };
+export { useSignature, useSignatureEvent, useSignatureSettings, useSignatureState, useSignerRows };
 //# sourceMappingURL=signature.d.cts.map

package/dist/signature.d.ts

@@ -1,36 +1,36 @@
-import { DocumentProtection, FormFieldRef, SignatureCapability, SignatureChange, SignatureSnapshot, SignatureVerdict } from "@embedpdf/plugin-signature";
-import { StampAsset, StampLibrary } from "@embedpdf/plugin-stamp/contract";
+import { n as StateHook, t as SettingsHook } from "./state-0K1I5cM4.js";
+import { r as FormFieldRef, t as DocumentProtection } from "./AnnotationList-DcyhF2kU-CiBFOq1z.js";
+import { EventHook } from "@embedpdf/core";
+import { SignatureCapability, SignerRow } from "@embedpdf/plugin-signature";
 export * from "@embedpdf/plugin-signature";
 //#region src/signature.d.ts
-/** The signature capability for the surrounding document. */
+/** The signature API for the surrounding document. */
 declare function useSignature(): SignatureCapability;
-/** The last signature snapshot (null until the first read lands). */
-declare function useSignatureSnapshot(): SignatureSnapshot | null;
-/** The last validation (null until one ran). */
-declare function useSignatureVerdicts(): SignatureVerdict[] | null;
-/** What the document's signatures forbid (null when nothing is signed or not yet read). */
-declare function useDocumentProtection(): DocumentProtection | null;
-/** The field the next picked mark goes to, and whether a sign/fill is in flight. */
-declare function useSignatureTarget(): {
+/**
+ * The signatures' state: the signed fields with their verdicts, what they
+ * allow, the target, whether a signing runs, a two-step signing in progress,
+ * and whether they're read (the page's State table, declared once in
+ * `signatureState`). Takes a selector, and re-renders only when what it
+ * returns changes.
+ */
+declare const useSignatureState: StateHook<{
+  signatures: readonly import("@embedpdf/plugin-signature").SignatureInfo[];
+  protection: DocumentProtection | null;
   target: FormFieldRef | null;
   busy: boolean;
-};
-/** Subscribe to the plugin's change events (signed / filled / ask / inspect / target / validated …). */
-declare function useSignatureEvent(handler: (event: SignatureChange) => void): void;
-/** One person: a library of kind `signatures` with its marks split by role. */
-interface SignerRow {
-  libraryId: string;
-  name: string;
-  library: StampLibrary;
-  signatures: StampAsset[];
-  initials: StampAsset | null;
-}
+  pending: import("@embedpdf/plugin-signature").SignaturePending | null;
+  status: import("@embedpdf/core").ResourceStatus;
+}>;
+/** The signature settings (`key`, `mode`, `trust`, `allowCertify`), with or without a document. Takes a selector. */
+declare const useSignatureSettings: SettingsHook<import("@embedpdf/plugin-signature").SignatureSettings>;
+/** Subscribe to one of the plugin's events while mounted: `useSignatureEvent((signature) => signature.onSigned, handler)`. */
+declare function useSignatureEvent<T>(select: (signature: SignatureCapability) => EventHook<T>, handler: (event: T) => void): void;
 /**
- * The people whose marks this browser holds — one row per library of kind
- * `signatures`. Purely derived from the stamp plugin: rename, delete, and
- * export are the library verbs; nothing is stored beyond the file.
+ * The people whose marks this browser holds, one row per library of kind
+ * `signatures`, for a picker. Derived from the stamp plugin: rename, delete
+ * and export are the library verbs; nothing is stored beyond the file.
  */
 declare function useSignerRows(): SignerRow[];
 //#endregion
-export { SignerRow, useDocumentProtection, useSignature, useSignatureEvent, useSignatureSnapshot, useSignatureTarget, useSignatureVerdicts, useSignerRows };
+export { useSignature, useSignatureEvent, useSignatureSettings, useSignatureState, useSignerRows };
 //# sourceMappingURL=signature.d.ts.map

package/dist/signature.js

@@ -1,67 +1,49 @@
-import "./rolldown-runtime-BBjsoOtd.js";
-import { shallowArray, useCapability, useCapabilityEvent, useSelector } from "./runtime.js";
-import { useStampLibraries } from "./stamp.js";
+import { f as useCapability, p as useCapabilityEvent } from "./runtime-tD5iJU83.js";
+import { n as stateHook, t as settingsHook } from "./state-CzI2KlZb.js";
+import { useStampAssets, useStampLibraries } from "./stamp.js";
 import { useMemo } from "react";
-import { SIGNATURES_LIBRARY_KIND, SignatureToken, markRoleOf } from "@embedpdf/plugin-signature";
-import { StampToken } from "@embedpdf/plugin-stamp/contract";
+import { SIGNATURES_LIBRARY_KIND, SignatureToken, signatureState, signerRowsOf } from "@embedpdf/plugin-signature";
 export * from "@embedpdf/plugin-signature";
 //#region src/signature.tsx
 /**
-* The React view of @embedpdf/plugin-signature: the act of signing for the
-* surrounding `DocumentScope`, its live facts (snapshot, verdicts,
-* protection, target), and the one derivation a signatures panel needs —
-* the people (libraries of kind `signatures`) with their marks.
+* The React view of @embedpdf/plugin-signature: signing for the surrounding
+* document, its state (the signatures with their verdicts, what they allow,
+* the target, a two-step signing in progress), and the one derivation a
+* signatures panel needs: the people (libraries of kind `signatures`) with
+* their marks.
 *
 *   const signature = useSignature();
-*   await signature.placeMark({ assetId }, { field: target });   // sign / fill / ask, by mode
+*   await signature.placeMark({ assetId }, { field: target }); // sign, fill or ask, by mode
 */
-/** The signature capability for the surrounding document. */
+/** The signature API for the surrounding document. */
 function useSignature() {
 	return useCapability(SignatureToken);
 }
-/** The last signature snapshot (null until the first read lands). */
-function useSignatureSnapshot() {
-	return useSelector(SignatureToken, (c) => c.snapshot());
-}
-/** The last validation (null until one ran). */
-function useSignatureVerdicts() {
-	return useSelector(SignatureToken, (c) => c.verdicts());
-}
-/** What the document's signatures forbid (null when nothing is signed or not yet read). */
-function useDocumentProtection() {
-	return useSelector(SignatureToken, (c) => c.protection());
-}
-/** The field the next picked mark goes to, and whether a sign/fill is in flight. */
-function useSignatureTarget() {
-	return {
-		target: useSelector(SignatureToken, (c) => c.target()),
-		busy: useSelector(SignatureToken, (c) => c.busy())
-	};
-}
-/** Subscribe to the plugin's change events (signed / filled / ask / inspect / target / validated …). */
-function useSignatureEvent(handler) {
-	useCapabilityEvent(SignatureToken, (c) => c.onChanged, handler);
+/**
+* The signatures' state: the signed fields with their verdicts, what they
+* allow, the target, whether a signing runs, a two-step signing in progress,
+* and whether they're read (the page's State table, declared once in
+* `signatureState`). Takes a selector, and re-renders only when what it
+* returns changes.
+*/
+const useSignatureState = stateHook(signatureState);
+/** The signature settings (`key`, `mode`, `trust`, `allowCertify`), with or without a document. Takes a selector. */
+const useSignatureSettings = settingsHook(SignatureToken);
+/** Subscribe to one of the plugin's events while mounted: `useSignatureEvent((signature) => signature.onSigned, handler)`. */
+function useSignatureEvent(select, handler) {
+	useCapabilityEvent(SignatureToken, select, handler);
 }
 /**
-* The people whose marks this browser holds — one row per library of kind
-* `signatures`. Purely derived from the stamp plugin: rename, delete, and
-* export are the library verbs; nothing is stored beyond the file.
+* The people whose marks this browser holds, one row per library of kind
+* `signatures`, for a picker. Derived from the stamp plugin: rename, delete
+* and export are the library verbs; nothing is stored beyond the file.
 */
 function useSignerRows() {
 	const libraries = useStampLibraries({ kind: SIGNATURES_LIBRARY_KIND });
-	const assets = useSelector(StampToken, (c) => c.assets(), shallowArray);
-	return useMemo(() => libraries.map((library) => {
-		const own = assets.filter((asset) => asset.libraryId === library.id);
-		return {
-			libraryId: library.id,
-			name: library.name,
-			library,
-			signatures: own.filter((asset) => markRoleOf(asset) === "signature"),
-			initials: own.find((asset) => markRoleOf(asset) === "initials") ?? null
-		};
-	}), [libraries, assets]);
+	const assets = useStampAssets();
+	return useMemo(() => signerRowsOf(libraries, assets), [libraries, assets]);
 }
 //#endregion
-export { useDocumentProtection, useSignature, useSignatureEvent, useSignatureSnapshot, useSignatureTarget, useSignatureVerdicts, useSignerRows };
+export { useSignature, useSignatureEvent, useSignatureSettings, useSignatureState, useSignerRows };
 
 //# sourceMappingURL=signature.js.map

package/dist/signature.js.map

@@ -1 +1 @@
-{"version":3,"file":"signature.js","names":[],"sources":["../src/signature.tsx"],"sourcesContent":["/**\n * The React view of @embedpdf/plugin-signature: the act of signing for the\n * surrounding `DocumentScope`, its live facts (snapshot, verdicts,\n * protection, target), and the one derivation a signatures panel needs —\n * the people (libraries of kind `signatures`) with their marks.\n *\n *   const signature = useSignature();\n *   await signature.placeMark({ assetId }, { field: target });   // sign / fill / ask, by mode\n */\nimport { useMemo } from 'react';\nimport {\n  markRoleOf,\n  SIGNATURES_LIBRARY_KIND,\n  SignatureToken,\n  type DocumentProtection,\n  type FormFieldRef,\n  type SignatureCapability,\n  type SignatureChange,\n  type SignatureSnapshot,\n  type SignatureVerdict,\n} from '@embedpdf/plugin-signature';\nimport { StampToken, type StampAsset, type StampLibrary } from '@embedpdf/plugin-stamp/contract';\n\nimport { shallowArray, useCapability, useCapabilityEvent, useSelector } from './runtime';\nimport { useStampLibraries } from './stamp';\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-signature';\n\n/** The signature capability for the surrounding document. */\nexport function useSignature(): SignatureCapability {\n  return useCapability(SignatureToken);\n}\n\n/** The last signature snapshot (null until the first read lands). */\nexport function useSignatureSnapshot(): SignatureSnapshot | null {\n  return useSelector(SignatureToken, (c) => c.snapshot());\n}\n\n/** The last validation (null until one ran). */\nexport function useSignatureVerdicts(): SignatureVerdict[] | null {\n  return useSelector(SignatureToken, (c) => c.verdicts());\n}\n\n/** What the document's signatures forbid (null when nothing is signed or not yet read). */\nexport function useDocumentProtection(): DocumentProtection | null {\n  return useSelector(SignatureToken, (c) => c.protection());\n}\n\n/** The field the next picked mark goes to, and whether a sign/fill is in flight. */\nexport function useSignatureTarget(): { target: FormFieldRef | null; busy: boolean } {\n  const target = useSelector(SignatureToken, (c) => c.target());\n  const busy = useSelector(SignatureToken, (c) => c.busy());\n  return { target, busy };\n}\n\n/** Subscribe to the plugin's change events (signed / filled / ask / inspect / target / validated …). */\nexport function useSignatureEvent(handler: (event: SignatureChange) => void): void {\n  useCapabilityEvent(SignatureToken, (c) => c.onChanged, handler);\n}\n\n/** One person: a library of kind `signatures` with its marks split by role. */\nexport interface SignerRow {\n  libraryId: string;\n  name: string;\n  library: StampLibrary;\n  signatures: StampAsset[];\n  initials: StampAsset | null;\n}\n\n/**\n * The people whose marks this browser holds — one row per library of kind\n * `signatures`. Purely derived from the stamp plugin: rename, delete, and\n * export are the library verbs; nothing is stored beyond the file.\n */\nexport function useSignerRows(): SignerRow[] {\n  const libraries = useStampLibraries({ kind: SIGNATURES_LIBRARY_KIND });\n  const assets = useSelector(StampToken, (c) => c.assets(), shallowArray);\n  return useMemo(\n    () =>\n      libraries.map((library) => {\n        const own = assets.filter((asset) => asset.libraryId === library.id);\n        return {\n          libraryId: library.id,\n          name: library.name,\n          library,\n          signatures: own.filter((asset) => markRoleOf(asset) === 'signature'),\n          initials: own.find((asset) => markRoleOf(asset) === 'initials') ?? null,\n        };\n      }),\n    [libraries, assets],\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA8BA,SAAgB,eAAoC;CAClD,OAAO,cAAc,cAAc;AACrC;;AAGA,SAAgB,uBAAiD;CAC/D,OAAO,YAAY,iBAAiB,MAAM,EAAE,SAAS,CAAC;AACxD;;AAGA,SAAgB,uBAAkD;CAChE,OAAO,YAAY,iBAAiB,MAAM,EAAE,SAAS,CAAC;AACxD;;AAGA,SAAgB,wBAAmD;CACjE,OAAO,YAAY,iBAAiB,MAAM,EAAE,WAAW,CAAC;AAC1D;;AAGA,SAAgB,qBAAqE;CAGnF,OAAO;EAAE,QAFM,YAAY,iBAAiB,MAAM,EAAE,OAAO,CAE7C;EAAG,MADJ,YAAY,iBAAiB,MAAM,EAAE,KAAK,CACnC;CAAE;AACxB;;AAGA,SAAgB,kBAAkB,SAAiD;CACjF,mBAAmB,iBAAiB,MAAM,EAAE,WAAW,OAAO;AAChE;;;;;;AAgBA,SAAgB,gBAA6B;CAC3C,MAAM,YAAY,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;CACrE,MAAM,SAAS,YAAY,aAAa,MAAM,EAAE,OAAO,GAAG,YAAY;CACtE,OAAO,cAEH,UAAU,KAAK,YAAY;EACzB,MAAM,MAAM,OAAO,QAAQ,UAAU,MAAM,cAAc,QAAQ,EAAE;EACnE,OAAO;GACL,WAAW,QAAQ;GACnB,MAAM,QAAQ;GACd;GACA,YAAY,IAAI,QAAQ,UAAU,WAAW,KAAK,MAAM,WAAW;GACnE,UAAU,IAAI,MAAM,UAAU,WAAW,KAAK,MAAM,UAAU,KAAK;EACrE;CACF,CAAC,GACH,CAAC,WAAW,MAAM,CACpB;AACF"}
+{"version":3,"file":"signature.js","names":[],"sources":["../src/signature.tsx"],"sourcesContent":["/**\n * The React view of @embedpdf/plugin-signature: signing for the surrounding\n * document, its state (the signatures with their verdicts, what they allow,\n * the target, a two-step signing in progress), and the one derivation a\n * signatures panel needs: the people (libraries of kind `signatures`) with\n * their marks.\n *\n *   const signature = useSignature();\n *   await signature.placeMark({ assetId }, { field: target }); // sign, fill or ask, by mode\n */\nimport { useMemo } from 'react';\nimport type { EventHook } from '@embedpdf/core';\nimport {\n  signatureState,\n  signerRowsOf,\n  SIGNATURES_LIBRARY_KIND,\n  SignatureToken,\n  type SignatureCapability,\n  type SignerRow,\n} from '@embedpdf/plugin-signature';\n\nimport { useCapability, useCapabilityEvent } from './runtime';\nimport { useStampAssets, useStampLibraries } from './stamp';\nimport { settingsHook, stateHook } from './state';\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-signature';\n\n/** The signature API for the surrounding document. */\nexport function useSignature(): SignatureCapability {\n  return useCapability(SignatureToken);\n}\n\n/**\n * The signatures' state: the signed fields with their verdicts, what they\n * allow, the target, whether a signing runs, a two-step signing in progress,\n * and whether they're read (the page's State table, declared once in\n * `signatureState`). Takes a selector, and re-renders only when what it\n * returns changes.\n */\nexport const useSignatureState = stateHook(signatureState);\n\n/** The signature settings (`key`, `mode`, `trust`, `allowCertify`), with or without a document. Takes a selector. */\nexport const useSignatureSettings = settingsHook(SignatureToken);\n\n/** Subscribe to one of the plugin's events while mounted: `useSignatureEvent((signature) => signature.onSigned, handler)`. */\nexport function useSignatureEvent<T>(\n  select: (signature: SignatureCapability) => EventHook<T>,\n  handler: (event: T) => void,\n): void {\n  useCapabilityEvent(SignatureToken, select, handler);\n}\n\n/**\n * The people whose marks this browser holds, one row per library of kind\n * `signatures`, for a picker. Derived from the stamp plugin: rename, delete\n * and export are the library verbs; nothing is stored beyond the file.\n */\nexport function useSignerRows(): SignerRow[] {\n  const libraries = useStampLibraries({ kind: SIGNATURES_LIBRARY_KIND });\n  const assets = useStampAssets();\n  return useMemo(() => signerRowsOf(libraries, assets), [libraries, assets]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA6BA,SAAgB,eAAoC;CAClD,OAAO,cAAc,cAAc;AACrC;;;;;;;;AASA,MAAa,oBAAoB,UAAU,cAAc;;AAGzD,MAAa,uBAAuB,aAAa,cAAc;;AAG/D,SAAgB,kBACd,QACA,SACM;CACN,mBAAmB,gBAAgB,QAAQ,OAAO;AACpD;;;;;;AAOA,SAAgB,gBAA6B;CAC3C,MAAM,YAAY,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;CACrE,MAAM,SAAS,eAAe;CAC9B,OAAO,cAAc,aAAa,WAAW,MAAM,GAAG,CAAC,WAAW,MAAM,CAAC;AAC3E"}