@embedpdf/vue 0.0.0-stage → 3.0.0-next.16

package/dist/capabilities-DVNJmgy7.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities-DVNJmgy7.cjs","sources":["../src/runtime/kernel.ts","../src/runtime/capabilities.ts"],"sourcesContent":["/**\n * The kernel as Vue reads it. `<Viewer>` provides one {@link ViewerBinding}:\n * the kernel and a `track()` that makes a computed depend on the kernel's one\n * change stream. Every reader in the package is a computed over it\n * ({@link useKernelValue}), cached by an equality, so a component updates only\n * when the value it reads changed. `<DocumentScope>` provides the document a\n * subtree talks to.\n */\nimport { computed, inject, provide, toValue } from 'vue';\nimport type { InjectionKey, MaybeRefOrGetter, Ref } from 'vue';\nimport type { Kernel } from '@embedpdf/core';\n\n/** What `<Viewer>` gives the components inside it. */\nexport interface ViewerBinding {\n  /** The kernel, from the moment `<Viewer>` creates it; null before that. */\n  readonly kernel: Kernel | null;\n  /** Read inside a computed: the computed runs again on every change the kernel announces. */\n  track(): void;\n}\n\nconst ViewerKey: InjectionKey<ViewerBinding> = Symbol('embedpdf viewer');\nconst DocumentScopeKey: InjectionKey<Readonly<Ref<string | null>>> = Symbol(\n  'embedpdf document scope',\n);\n\n/** Installed by `<Viewer>`, not by app code. */\nexport function provideViewer(binding: ViewerBinding): void {\n  provide(ViewerKey, binding);\n}\n\n/** The binding of the nearest `<Viewer>`, with its kernel. */\nexport function useViewerBinding(): ViewerBinding & { readonly kernel: Kernel } {\n  const binding = inject(ViewerKey, null);\n  if (!binding?.kernel) {\n    // The usual cause in Vue: a composable called in the component that renders\n    // <Viewer>, which can't inject what its own child provides.\n    throw new Error(\n      'No <Viewer> above this component: EmbedPDF composables work in components rendered ' +\n        'inside <Viewer>, not in the component that renders it.',\n    );\n  }\n  return binding as ViewerBinding & { readonly kernel: Kernel };\n}\n\n/** The kernel of the nearest `<Viewer>`. */\nexport function useKernel(): Kernel {\n  return useViewerBinding().kernel;\n}\n\n/**\n * A value derived from the kernel, as a ref. `select` runs again on every\n * kernel change and on a change to any ref it reads; the ref keeps its value\n * while `isEqual` says the new one is the same, so nothing that reads it\n * updates.\n */\nexport function useKernelValue<Value>(\n  select: (kernel: Kernel) => Value,\n  isEqual: (left: Value, right: Value) => boolean = Object.is,\n): Readonly<Ref<Value>> {\n  const { kernel, track } = useViewerBinding();\n  // `previous` is undefined only on the first run, which has nothing to keep.\n  return computed((previous: Value | undefined) => {\n    track();\n    const next = select(kernel);\n    return previous !== undefined && isEqual(previous, next) ? previous : next;\n  });\n}\n\nconst NO_SCOPE = computed((): string | null => null);\n\n/** Installed by `<DocumentScope>`: the document the subtree talks to. */\nexport function provideDocumentScope(id: MaybeRefOrGetter<string | null>): void {\n  provide(\n    DocumentScopeKey,\n    computed(() => toValue(id)),\n  );\n}\n\n/**\n * The document the nearest `<DocumentScope>` binds this subtree to, or null\n * when it follows the active document. For readers that pass it to\n * `kernel.tryCapability`; UI that needs the id itself uses {@link useDocumentId}.\n */\nexport function useDocumentScope(): Readonly<Ref<string | null>> {\n  return inject(DocumentScopeKey, NO_SCOPE);\n}\n\n/** The active document's id, or null with none open. */\nexport function useActiveDocumentId(): Readonly<Ref<string | null>> {\n  return useKernelValue((kernel) => kernel.documents.getActiveId());\n}\n\n/** The document id for this subtree: the nearest `<DocumentScope>`, else the active document. */\nexport function useDocumentId(): Readonly<Ref<string | null>> {\n  const scope = useDocumentScope();\n  const active = useActiveDocumentId();\n  return computed(() => scope.value ?? active.value);\n}\n","/**\n * Capabilities as Vue reads them. A component's setup runs once, so the object\n * `useCapability()` returns is live: every call reaches the capability the\n * subtree resolves to now (the document in scope, or a stand-in while there is\n * none), and the object itself never changes. Selectors are refs, and an event\n * subscription follows the capability and ends with the component.\n *\n * Reads follow the capability vocabulary (docs/conventions/naming.md): a\n * method named `get*`, `list*`, `is*`, `has*` or `can*` reads state, so a call\n * to it in a template, a `computed` or a `watchEffect` updates when its answer\n * changes: `v-if=\"annotation.canCreate()\"` follows the permissions. Every other\n * method tracks nothing: a `watchEffect` that calls `stage.reveal(index)` runs\n * again only when `index` changes.\n */\nimport { computed, markRaw, toValue, watch } from 'vue';\nimport type { MaybeRefOrGetter, Ref } from 'vue';\nimport { isReadMember, standInFor } from '@embedpdf/core';\nimport type { CapabilityToken, EventHook } from '@embedpdf/core';\nimport { useDocumentScope, useKernel, useKernelValue, useViewerBinding } from './kernel';\n\n/**\n * Like {@link useCapability}, but a ref that is null while the token can't\n * resolve: no plugin, no document, or a document that isn't ready yet. It\n * changes when the subtree's document does, so a `watch` on it rebinds.\n */\nexport function useOptionalCapability<Capability>(\n  token: MaybeRefOrGetter<CapabilityToken<Capability>>,\n): Readonly<Ref<Capability | null>> {\n  const scope = useDocumentScope();\n  return useKernelValue((kernel) => kernel.tryCapability(toValue(token), scope.value ?? undefined));\n}\n\n/**\n * The capability a subtree resolves to, as a ref: the document's while one is\n * ready, else the stand-in for a document plugin. A token no plugin provides\n * throws here, at setup: that is a setup mistake.\n */\nexport function useCapabilityRef<Capability>(\n  token: MaybeRefOrGetter<CapabilityToken<Capability>>,\n): Readonly<Ref<Capability>> {\n  const kernel = useKernel();\n  const resolved = useOptionalCapability(token);\n  const capability = computed(() => {\n    const current = resolved.value;\n    if (current) return current;\n    const wanted = toValue(token);\n    if (kernel.scopeOf(wanted) === 'document') return standInFor(kernel, wanted);\n    return kernel.capability(wanted);\n  });\n  // Resolve once now, so a missing plugin fails where it is used.\n  void capability.value;\n  return capability;\n}\n\n/**\n * A plugin's API for this subtree: `const stage = useCapability(StageToken)`,\n * then `stage.zoomIn()` in a handler or a template. The object stays the same\n * for the component's life and always calls the capability of the document in\n * scope, so it is safe to keep in a closure. A read (`stage.getZoomLevel()`)\n * in a template or a computed updates when its answer changes.\n *\n * Outside a document (none open, not ready yet, or none in scope), a document\n * plugin's members belong to its stand-in: reading one never throws, so chrome\n * renders before the first document opens, and calling one refuses with\n * `PluginError('not-ready')`: a method that returns a promise rejects, the\n * others throw.\n */\nexport function useCapability<Capability>(\n  token: MaybeRefOrGetter<CapabilityToken<Capability>>,\n): Capability {\n  return liveCapability(useCapabilityRef(token), useViewerBinding().track);\n}\n\n/** Vue's own flags (`__v_skip`, `__v_isRef`): answered by the target, so Vue never wraps the object. */\nconst isVueFlag = (key: string | symbol): boolean =>\n  typeof key === 'string' && key.startsWith('__v_');\n\ntype Members = Record<string, unknown>;\ntype Method = (...args: unknown[]) => unknown;\n\n/**\n * The object {@link useCapability} returns, over `current`, the capability the\n * subtree resolves to. A read resolves it in a `computed` of its own that also\n * follows the kernel, so whoever reads the call depends on its answer; a verb\n * resolves the capability as it is now, without making the caller depend on\n * anything.\n */\nfunction liveCapability<Capability>(\n  current: Readonly<Ref<Capability>>,\n  track: () => void,\n): Capability {\n  // The capability now, kept without a dependency: what a verb calls.\n  let latest = current.value;\n  watch(current, (capability) => (latest = capability), { flush: 'sync' });\n  const resolve = (tracked: boolean): unknown => (tracked ? current.value : latest);\n  return liveMember(resolve, track, null) as Capability;\n}\n\n/**\n * A live member over `resolve(tracked)`: the capability, or a namespace in it\n * (`annotation.comments`). Members are cached by name, so `stage.zoomIn` is the\n * same function every time; a member that is a plain value is read as it is\n * now. Marked raw, so Vue never makes it reactive.\n */\nfunction liveMember(\n  resolve: (tracked: boolean) => unknown,\n  track: () => void,\n  call: ((args: unknown[]) => unknown) | null,\n): object {\n  const members = new Map<string, object>();\n  // A function target, so a member can be called and can have members of its own.\n  const target = markRaw(call ? function member() {} : {});\n  return new Proxy(target, {\n    apply: (_target, _this, args) => call!(args),\n    has: (_target, key) => {\n      const value = resolve(false);\n      return (typeof value === 'object' || typeof value === 'function') && value !== null\n        ? key in value\n        : false;\n    },\n    get(_target, key) {\n      if (isVueFlag(key)) return Reflect.get(target, key);\n      // Not a thenable, and inspecting it never resolves anything.\n      if (typeof key === 'symbol' || key === 'then') return undefined;\n      const value = (resolve(false) as Members | null)?.[key];\n      if (typeof value !== 'function' && (typeof value !== 'object' || value === null)) {\n        return value;\n      }\n      let member = members.get(key);\n      if (!member) {\n        const invoke = (tracked: boolean, args: unknown[]): unknown => {\n          const owner = resolve(tracked) as Members;\n          // `Reflect.apply`, not `.apply`: a stand-in's member answers every property, `apply` too.\n          return Reflect.apply(owner[key] as Method, owner, args);\n        };\n        member = liveMember(\n          (tracked) => (resolve(tracked) as Members)[key],\n          track,\n          isReadMember(key)\n            ? // A computed of its own for each call: its reader wakes when the answer changes.\n              (args) =>\n                computed(() => {\n                  track();\n                  return invoke(true, args);\n                }).value\n            : (args) => invoke(false, args),\n        );\n        members.set(key, member);\n      }\n      return member;\n    },\n  });\n}\n\n/**\n * A value read from a capability, as a ref. Strict: while the token can't\n * resolve, reading it throws the kernel's reason (`no document`, `document is\n * loading`), for code that knows a document exists, such as anything inside a\n * `<DocumentGate>`. {@link useOptionalSelector} is its total twin.\n */\nexport function useSelector<Capability, Value>(\n  token: MaybeRefOrGetter<CapabilityToken<Capability>>,\n  select: (capability: Capability) => Value,\n  isEqual: (left: Value, right: Value) => boolean = Object.is,\n): Readonly<Ref<Value>> {\n  const scope = useDocumentScope();\n  return useKernelValue((kernel) => {\n    const wanted = toValue(token);\n    const documentId = scope.value ?? undefined;\n    const capability =\n      kernel.tryCapability(wanted, documentId) ?? kernel.capability(wanted, documentId);\n    return select(capability);\n  }, isEqual);\n}\n\n/**\n * Null-safe {@link useSelector}: `fallback` whenever the token can't resolve\n * (no provider, or a document-scoped token with no document). For chrome that\n * stays mounted across the empty workspace (a zoom readout, a mode band). A\n * read through a capability whose document closed a moment ago is `fallback`\n * too.\n */\nexport function useOptionalSelector<Capability, Value>(\n  token: MaybeRefOrGetter<CapabilityToken<Capability>>,\n  select: (capability: Capability) => Value,\n  fallback: Value,\n  isEqual: (left: Value, right: Value) => boolean = Object.is,\n): Readonly<Ref<Value>> {\n  const scope = useDocumentScope();\n  return useKernelValue((kernel) => {\n    const capability = kernel.tryCapability(toValue(token), scope.value ?? undefined);\n    if (capability === null) return fallback;\n    try {\n      return select(capability);\n    } catch {\n      return fallback;\n    }\n  }, isEqual);\n}\n\n/**\n * Subscribe to a capability's {@link EventHook} while the component lives:\n * `useCapabilityEvent(ActionsToken, (actions) => actions.onExecuted, handler)`.\n * Events carry occurrences, never state (a late subscriber that needs the\n * current value uses a selector). It subscribes to the document in scope, again\n * when that document changes, and ends with the component. Null-safe: with no\n * plugin or no document there is no subscription.\n */\nexport function useCapabilityEvent<Capability, Event>(\n  token: MaybeRefOrGetter<CapabilityToken<Capability>>,\n  select: (capability: Capability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  const capability = useOptionalCapability(token);\n  // `sync`: subscribed in the same change that made the capability resolvable,\n  // so no event between that change and the next render is missed.\n  watch(\n    capability,\n    (current, _previous, onCleanup) => {\n      if (!current) return;\n      onCleanup(select(current)((event) => handler(event)));\n    },\n    { immediate: true, flush: 'sync' },\n  );\n}\n"],"names":["provide","inject","computed","toValue","standInFor","watch","markRaw","isReadMember"],"mappings":"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"}

package/dist/commands.cjs

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginCommands = require("@embedpdf/plugin-commands");
+const vue = require("vue");
+const coreUi = require("@embedpdf/core-ui");
+const host = require("@embedpdf/plugin-commands/contract/host");
+const standard = require("@embedpdf/plugin-commands/standard");
+const web = require("@embedpdf/web");
+const dev = require("./dev-eeIS2B4c.cjs");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+const state = require("./state-M22NDJQo.cjs");
+const standardCommands = /* @__PURE__ */ standard.createStandardCommands(web.standardCommandsBrowser);
+function useCommands() {
+  return capabilities.useCapability(pluginCommands.CommandsToken);
+}
+function useCommandsEvent(select, handler) {
+  capabilities.useCapabilityEvent(pluginCommands.CommandsToken, select, handler);
+}
+const useCommandsSettings = state.settingsComposable(pluginCommands.CommandsToken);
+function formatShortcut(shortcut, options = {}) {
+  return coreUi.formatShortcut(shortcut, { isMac: options.isMac ?? web.isMacPlatform() });
+}
+function useCommand(id) {
+  const commands = capabilities.useCapability(pluginCommands.CommandsToken);
+  const documentId = capabilities.useDocumentId();
+  const resolved = capabilities.useKernelValue(
+    () => commands.resolveCommand(vue.toValue(id), documentId.value ?? void 0),
+    pluginCommands.resolvedCommandsEqual
+  );
+  return vue.computed(() => {
+    const command = resolved.value;
+    const requested = vue.toValue(id);
+    if (command === null) {
+      dev.devWarn(
+        `useCommand:${requested}`,
+        `useCommand(): ${pluginCommands.unknownCommandWarning(requested, commands.listCommandIds())}`
+      );
+    }
+    const scope = documentId.value ?? void 0;
+    return pluginCommands.boundCommandOf(
+      command ?? pluginCommands.unregisteredCommand(requested),
+      (commandId) => commands.execute(commandId, { documentId: scope }),
+      { isMac: web.isMacPlatform() }
+    );
+  });
+}
+function useCommandShortcuts(options = {}) {
+  const commands = capabilities.useCapability(host.CommandsToken);
+  const scoped = options.target !== void 0;
+  vue.watch(
+    () => [vue.toValue(options.isMac), vue.toValue(options.target)],
+    ([isMac, target], _previous, onCleanup) => {
+      if (scoped && !target) return;
+      onCleanup(
+        web.bindCommandShortcuts(commands, {
+          isMac,
+          target: target ?? void 0,
+          onRefused: (commandId, refusal) => {
+            var _a;
+            return (_a = options.onRefused) == null ? void 0 : _a.call(options, commandId, refusal);
+          }
+        })
+      );
+    },
+    { immediate: true, flush: "post" }
+  );
+}
+exports.formatShortcut = formatShortcut;
+exports.standardCommands = standardCommands;
+exports.useCommand = useCommand;
+exports.useCommandShortcuts = useCommandShortcuts;
+exports.useCommands = useCommands;
+exports.useCommandsEvent = useCommandsEvent;
+exports.useCommandsSettings = useCommandsSettings;
+Object.keys(pluginCommands).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginCommands[k]
+  });
+});
+//# sourceMappingURL=commands.cjs.map

package/dist/commands.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.cjs","sources":["../src/commands.ts"],"sourcesContent":["/**\n * @embedpdf/vue/commands: the Vue surface of `@embedpdf/plugin-commands`. The\n * standard commands, a command as a button needs it, the settings, and keyboard\n * shortcuts. A command's state is derived from live state on read, so\n * `useCommand` re-reads it on the kernel's one change stream and its ref\n * changes only when what the command shows changed.\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-commands';\nimport { computed, toValue, watch } from 'vue';\nimport type { MaybeRefOrGetter, Ref } from 'vue';\nimport { formatShortcut as formatKeys } from '@embedpdf/core-ui';\nimport {\n  CommandsToken,\n  boundCommandOf,\n  resolvedCommandsEqual,\n  unknownCommandWarning,\n  unregisteredCommand,\n} from '@embedpdf/plugin-commands';\nimport type {\n  BoundCommand,\n  CommandId,\n  CommandRefusal,\n  CommandsCapability,\n} from '@embedpdf/plugin-commands';\nimport { CommandsToken as CommandsHostToken } from '@embedpdf/plugin-commands/contract/host';\nimport { createStandardCommands } from '@embedpdf/plugin-commands/standard';\nimport type { EventHook } from '@embedpdf/core';\nimport { bindCommandShortcuts, isMacPlatform, standardCommandsBrowser } from '@embedpdf/web';\nimport { devWarn } from './dev';\nimport { useCapability, useCapabilityEvent } from './runtime/capabilities';\nimport { useDocumentId, useKernelValue } from './runtime/kernel';\nimport { settingsComposable } from './state';\n\n/**\n * The commands every viewer has: zoom, pages, view rotation, `tool:<id>` for every tool, copy,\n * delete, download and print, with shortcuts and labels in EmbedPDF's eight languages. Spread\n * them into `commandsPlugin({ commands })`.\n */\nexport const standardCommands = /* @__PURE__ */ createStandardCommands(standardCommandsBrowser);\n\n/** The commands API: `execute`, `searchCommands`, `registerCommand`, the categories, the settings calls. The object never changes. */\nexport function useCommands(): CommandsCapability {\n  return useCapability(CommandsToken);\n}\n\n/** Subscribe to one commands event while the component lives: `useCommandsEvent((commands) => commands.onExecuted, handler)`. */\nexport function useCommandsEvent<Event>(\n  select: (commands: CommandsCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(CommandsToken, select, handler);\n}\n\n/**\n * The commands settings (`commands`, `disabledCategories`, `disabledCommands`, `notAllowed`) as refs,\n * with or without a document. Takes a selector.\n */\nexport const useCommandsSettings = settingsComposable(CommandsToken);\n\n/** A shortcut as a tooltip shows it, for this platform: `'⌘K'` on a Mac, `'Ctrl+K'` elsewhere. */\nexport function formatShortcut(shortcut: string, options: { isMac?: boolean } = {}): string {\n  return formatKeys(shortcut, { isMac: options.isMac ?? isMacPlatform() });\n}\n\n/**\n * A command for this component's document (the nearest `<DocumentScope>`, else\n * the active one), as a ref: its label, icon, state, `run` and `shortcut`. Pass\n * a getter to follow a prop: `useCommand(() => props.id)`. The ref changes only\n * when what the command shows does. Always a command: an id no plugin\n * registered is labelled with its id, neither visible nor enabled, and warns\n * once in development.\n */\nexport function useCommand(id: MaybeRefOrGetter<string>): Readonly<Ref<BoundCommand>> {\n  const commands = useCapability(CommandsToken);\n  const documentId = useDocumentId();\n  const resolved = useKernelValue(\n    () => commands.resolveCommand(toValue(id), documentId.value ?? undefined),\n    resolvedCommandsEqual,\n  );\n  return computed(() => {\n    const command = resolved.value;\n    const requested = toValue(id);\n    if (command === null) {\n      devWarn(\n        `useCommand:${requested}`,\n        `useCommand(): ${unknownCommandWarning(requested, commands.listCommandIds())}`,\n      );\n    }\n    const scope = documentId.value ?? undefined;\n    return boundCommandOf(\n      command ?? unregisteredCommand(requested),\n      (commandId) => commands.execute(commandId, { documentId: scope }),\n      { isMac: isMacPlatform() },\n    );\n  });\n}\n\n/** Where {@link useCommandShortcuts} listens, and how it reads `Mod`. */\nexport interface CommandShortcutsOptions {\n  /** Whether `Mod` is Cmd (a Mac) or Ctrl. Default: what the browser says. */\n  isMac?: MaybeRefOrGetter<boolean | undefined>;\n  /**\n   * Listen only while focus is inside this element (a template ref), for a\n   * page with more than one viewer. The keys work once it has mounted.\n   */\n  target?: MaybeRefOrGetter<HTMLElement | null | undefined>;\n  /** Called when a key's command is turned off or not allowed, with why: say so to the user. */\n  onRefused?: (commandId: CommandId, refusal: CommandRefusal) => void;\n}\n\n/**\n * Turn every command's shortcut into a working key, for the active document.\n * Call it once, near the top of your viewer. Keys typed into text fields are\n * left alone, and so is a key whose command can't run right now. A command\n * that's turned off or not allowed still takes its key, and `onRefused` says\n * why. The keys work anywhere on the page; with `target`, only while focus is\n * inside that element.\n * They stop when the component unmounts.\n */\nexport function useCommandShortcuts(options: CommandShortcutsOptions = {}): void {\n  const commands = useCapability(CommandsHostToken);\n  const scoped = options.target !== undefined;\n  watch(\n    () => [toValue(options.isMac), toValue(options.target)] as const,\n    ([isMac, target], _previous, onCleanup) => {\n      // A target that hasn't mounted yet binds nothing; its ref being set runs this again.\n      if (scoped && !target) return;\n      onCleanup(\n        bindCommandShortcuts(commands, {\n          isMac,\n          target: target ?? undefined,\n          onRefused: (commandId, refusal) => options.onRefused?.(commandId, refusal),\n        }),\n      );\n    },\n    { immediate: true, flush: 'post' },\n  );\n}\n"],"names":["standardCommandsBrowser","useCapability","CommandsToken","useCapabilityEvent","settingsComposable","formatKeys","isMacPlatform","useDocumentId","useKernelValue","toValue","resolvedCommandsEqual","computed","devWarn","unknownCommandWarning","boundCommandOf","unregisteredCommand","CommandsHostToken","watch","bindCommandShortcuts"],"mappings":";;;;;;;;;;;AAwCO,MAAM,mEAA0DA,IAAAA,uBAAuB;AAGvF,SAAS,cAAkC;AAChD,SAAOC,aAAAA,cAAcC,eAAAA,aAAa;AACpC;AAGO,SAAS,iBACd,QACA,SACM;AACNC,kCAAmBD,eAAAA,eAAe,QAAQ,OAAO;AACnD;AAMO,MAAM,sBAAsBE,MAAAA,mBAAmBF,eAAAA,aAAa;AAG5D,SAAS,eAAe,UAAkB,UAA+B,IAAY;AAC1F,SAAOG,OAAAA,eAAW,UAAU,EAAE,OAAO,QAAQ,SAASC,IAAAA,cAAA,GAAiB;AACzE;AAUO,SAAS,WAAW,IAA2D;AACpF,QAAM,WAAWL,aAAAA,cAAcC,4BAAa;AAC5C,QAAM,aAAaK,aAAAA,cAAA;AACnB,QAAM,WAAWC,aAAAA;AAAAA,IACf,MAAM,SAAS,eAAeC,IAAAA,QAAQ,EAAE,GAAG,WAAW,SAAS,MAAS;AAAA,IACxEC,eAAAA;AAAAA,EAAA;AAEF,SAAOC,IAAAA,SAAS,MAAM;AACpB,UAAM,UAAU,SAAS;AACzB,UAAM,YAAYF,IAAAA,QAAQ,EAAE;AAC5B,QAAI,YAAY,MAAM;AACpBG,UAAAA;AAAAA,QACE,cAAc,SAAS;AAAA,QACvB,iBAAiBC,eAAAA,sBAAsB,WAAW,SAAS,eAAA,CAAgB,CAAC;AAAA,MAAA;AAAA,IAEhF;AACA,UAAM,QAAQ,WAAW,SAAS;AAClC,WAAOC,eAAAA;AAAAA,MACL,WAAWC,eAAAA,oBAAoB,SAAS;AAAA,MACxC,CAAC,cAAc,SAAS,QAAQ,WAAW,EAAE,YAAY,OAAO;AAAA,MAChE,EAAE,OAAOT,IAAAA,cAAA,EAAc;AAAA,IAAE;AAAA,EAE7B,CAAC;AACH;AAwBO,SAAS,oBAAoB,UAAmC,IAAU;AAC/E,QAAM,WAAWL,aAAAA,cAAce,kBAAiB;AAChD,QAAM,SAAS,QAAQ,WAAW;AAClCC,MAAAA;AAAAA,IACE,MAAM,CAACR,IAAAA,QAAQ,QAAQ,KAAK,GAAGA,YAAQ,QAAQ,MAAM,CAAC;AAAA,IACtD,CAAC,CAAC,OAAO,MAAM,GAAG,WAAW,cAAc;AAEzC,UAAI,UAAU,CAAC,OAAQ;AACvB;AAAA,QACES,IAAAA,qBAAqB,UAAU;AAAA,UAC7B;AAAA,UACA,QAAQ,UAAU;AAAA,UAClB,WAAW,CAAC,WAAW;;AAAY,iCAAQ,cAAR,iCAAoB,WAAW;AAAA;AAAA,QAAO,CAC1E;AAAA,MAAA;AAAA,IAEL;AAAA,IACA,EAAE,WAAW,MAAM,OAAO,OAAA;AAAA,EAAO;AAErC;;;;;;;;;;;;;;"}

package/dist/commands.d.cts

@@ -0,0 +1,61 @@
+/**
+ * @embedpdf/vue/commands: the Vue surface of `@embedpdf/plugin-commands`. The
+ * standard commands, a command as a button needs it, the settings, and keyboard
+ * shortcuts. A command's state is derived from live state on read, so
+ * `useCommand` re-reads it on the kernel's one change stream and its ref
+ * changes only when what the command shows changed.
+ */
+export * from '@embedpdf/plugin-commands';
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { BoundCommand, CommandId, CommandRefusal, CommandsCapability } from '@embedpdf/plugin-commands';
+import type { EventHook } from '@embedpdf/core';
+/**
+ * The commands every viewer has: zoom, pages, view rotation, `tool:<id>` for every tool, copy,
+ * delete, download and print, with shortcuts and labels in EmbedPDF's eight languages. Spread
+ * them into `commandsPlugin({ commands })`.
+ */
+export declare const standardCommands: readonly (import("@embedpdf/plugin-commands").CommandDef | import("@embedpdf/plugin-commands").CommandFamily)[];
+/** The commands API: `execute`, `searchCommands`, `registerCommand`, the categories, the settings calls. The object never changes. */
+export declare function useCommands(): CommandsCapability;
+/** Subscribe to one commands event while the component lives: `useCommandsEvent((commands) => commands.onExecuted, handler)`. */
+export declare function useCommandsEvent<Event>(select: (commands: CommandsCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The commands settings (`commands`, `disabledCategories`, `disabledCommands`, `notAllowed`) as refs,
+ * with or without a document. Takes a selector.
+ */
+export declare const useCommandsSettings: import("./state.cjs").SettingsComposable<import("@embedpdf/plugin-commands").CommandsSettings & object>;
+/** A shortcut as a tooltip shows it, for this platform: `'⌘K'` on a Mac, `'Ctrl+K'` elsewhere. */
+export declare function formatShortcut(shortcut: string, options?: {
+    isMac?: boolean;
+}): string;
+/**
+ * A command for this component's document (the nearest `<DocumentScope>`, else
+ * the active one), as a ref: its label, icon, state, `run` and `shortcut`. Pass
+ * a getter to follow a prop: `useCommand(() => props.id)`. The ref changes only
+ * when what the command shows does. Always a command: an id no plugin
+ * registered is labelled with its id, neither visible nor enabled, and warns
+ * once in development.
+ */
+export declare function useCommand(id: MaybeRefOrGetter<string>): Readonly<Ref<BoundCommand>>;
+/** Where {@link useCommandShortcuts} listens, and how it reads `Mod`. */
+export interface CommandShortcutsOptions {
+    /** Whether `Mod` is Cmd (a Mac) or Ctrl. Default: what the browser says. */
+    isMac?: MaybeRefOrGetter<boolean | undefined>;
+    /**
+     * Listen only while focus is inside this element (a template ref), for a
+     * page with more than one viewer. The keys work once it has mounted.
+     */
+    target?: MaybeRefOrGetter<HTMLElement | null | undefined>;
+    /** Called when a key's command is turned off or not allowed, with why: say so to the user. */
+    onRefused?: (commandId: CommandId, refusal: CommandRefusal) => void;
+}
+/**
+ * Turn every command's shortcut into a working key, for the active document.
+ * Call it once, near the top of your viewer. Keys typed into text fields are
+ * left alone, and so is a key whose command can't run right now. A command
+ * that's turned off or not allowed still takes its key, and `onRefused` says
+ * why. The keys work anywhere on the page; with `target`, only while focus is
+ * inside that element.
+ * They stop when the component unmounts.
+ */
+export declare function useCommandShortcuts(options?: CommandShortcutsOptions): void;

package/dist/commands.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @embedpdf/vue/commands: the Vue surface of `@embedpdf/plugin-commands`. The
+ * standard commands, a command as a button needs it, the settings, and keyboard
+ * shortcuts. A command's state is derived from live state on read, so
+ * `useCommand` re-reads it on the kernel's one change stream and its ref
+ * changes only when what the command shows changed.
+ */
+export * from '@embedpdf/plugin-commands';
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { BoundCommand, CommandId, CommandRefusal, CommandsCapability } from '@embedpdf/plugin-commands';
+import type { EventHook } from '@embedpdf/core';
+/**
+ * The commands every viewer has: zoom, pages, view rotation, `tool:<id>` for every tool, copy,
+ * delete, download and print, with shortcuts and labels in EmbedPDF's eight languages. Spread
+ * them into `commandsPlugin({ commands })`.
+ */
+export declare const standardCommands: readonly (import("@embedpdf/plugin-commands").CommandDef | import("@embedpdf/plugin-commands").CommandFamily)[];
+/** The commands API: `execute`, `searchCommands`, `registerCommand`, the categories, the settings calls. The object never changes. */
+export declare function useCommands(): CommandsCapability;
+/** Subscribe to one commands event while the component lives: `useCommandsEvent((commands) => commands.onExecuted, handler)`. */
+export declare function useCommandsEvent<Event>(select: (commands: CommandsCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The commands settings (`commands`, `disabledCategories`, `disabledCommands`, `notAllowed`) as refs,
+ * with or without a document. Takes a selector.
+ */
+export declare const useCommandsSettings: import("./state.js").SettingsComposable<import("@embedpdf/plugin-commands").CommandsSettings & object>;
+/** A shortcut as a tooltip shows it, for this platform: `'⌘K'` on a Mac, `'Ctrl+K'` elsewhere. */
+export declare function formatShortcut(shortcut: string, options?: {
+    isMac?: boolean;
+}): string;
+/**
+ * A command for this component's document (the nearest `<DocumentScope>`, else
+ * the active one), as a ref: its label, icon, state, `run` and `shortcut`. Pass
+ * a getter to follow a prop: `useCommand(() => props.id)`. The ref changes only
+ * when what the command shows does. Always a command: an id no plugin
+ * registered is labelled with its id, neither visible nor enabled, and warns
+ * once in development.
+ */
+export declare function useCommand(id: MaybeRefOrGetter<string>): Readonly<Ref<BoundCommand>>;
+/** Where {@link useCommandShortcuts} listens, and how it reads `Mod`. */
+export interface CommandShortcutsOptions {
+    /** Whether `Mod` is Cmd (a Mac) or Ctrl. Default: what the browser says. */
+    isMac?: MaybeRefOrGetter<boolean | undefined>;
+    /**
+     * Listen only while focus is inside this element (a template ref), for a
+     * page with more than one viewer. The keys work once it has mounted.
+     */
+    target?: MaybeRefOrGetter<HTMLElement | null | undefined>;
+    /** Called when a key's command is turned off or not allowed, with why: say so to the user. */
+    onRefused?: (commandId: CommandId, refusal: CommandRefusal) => void;
+}
+/**
+ * Turn every command's shortcut into a working key, for the active document.
+ * Call it once, near the top of your viewer. Keys typed into text fields are
+ * left alone, and so is a key whose command can't run right now. A command
+ * that's turned off or not allowed still takes its key, and `onRefused` says
+ * why. The keys work anywhere on the page; with `target`, only while focus is
+ * inside that element.
+ * They stop when the component unmounts.
+ */
+export declare function useCommandShortcuts(options?: CommandShortcutsOptions): void;

package/dist/commands.js

@@ -0,0 +1,76 @@
+import { resolvedCommandsEqual, unknownCommandWarning, boundCommandOf, unregisteredCommand, CommandsToken } from "@embedpdf/plugin-commands";
+export * from "@embedpdf/plugin-commands";
+import { toValue, computed, watch } from "vue";
+import { formatShortcut as formatShortcut$1 } from "@embedpdf/core-ui";
+import { CommandsToken as CommandsToken$1 } from "@embedpdf/plugin-commands/contract/host";
+import { createStandardCommands } from "@embedpdf/plugin-commands/standard";
+import { isMacPlatform, standardCommandsBrowser, bindCommandShortcuts } from "@embedpdf/web";
+import { d as devWarn } from "./dev-CtMlvxjZ.js";
+import { a as useCapability, d as useDocumentId, g as useKernelValue, b as useCapabilityEvent } from "./capabilities-C7YzgPCX.js";
+import { s as settingsComposable } from "./state-DZg8q3v6.js";
+const standardCommands = /* @__PURE__ */ createStandardCommands(standardCommandsBrowser);
+function useCommands() {
+  return useCapability(CommandsToken);
+}
+function useCommandsEvent(select, handler) {
+  useCapabilityEvent(CommandsToken, select, handler);
+}
+const useCommandsSettings = settingsComposable(CommandsToken);
+function formatShortcut(shortcut, options = {}) {
+  return formatShortcut$1(shortcut, { isMac: options.isMac ?? isMacPlatform() });
+}
+function useCommand(id) {
+  const commands = useCapability(CommandsToken);
+  const documentId = useDocumentId();
+  const resolved = useKernelValue(
+    () => commands.resolveCommand(toValue(id), documentId.value ?? void 0),
+    resolvedCommandsEqual
+  );
+  return computed(() => {
+    const command = resolved.value;
+    const requested = toValue(id);
+    if (command === null) {
+      devWarn(
+        `useCommand:${requested}`,
+        `useCommand(): ${unknownCommandWarning(requested, commands.listCommandIds())}`
+      );
+    }
+    const scope = documentId.value ?? void 0;
+    return boundCommandOf(
+      command ?? unregisteredCommand(requested),
+      (commandId) => commands.execute(commandId, { documentId: scope }),
+      { isMac: isMacPlatform() }
+    );
+  });
+}
+function useCommandShortcuts(options = {}) {
+  const commands = useCapability(CommandsToken$1);
+  const scoped = options.target !== void 0;
+  watch(
+    () => [toValue(options.isMac), toValue(options.target)],
+    ([isMac, target], _previous, onCleanup) => {
+      if (scoped && !target) return;
+      onCleanup(
+        bindCommandShortcuts(commands, {
+          isMac,
+          target: target ?? void 0,
+          onRefused: (commandId, refusal) => {
+            var _a;
+            return (_a = options.onRefused) == null ? void 0 : _a.call(options, commandId, refusal);
+          }
+        })
+      );
+    },
+    { immediate: true, flush: "post" }
+  );
+}
+export {
+  formatShortcut,
+  standardCommands,
+  useCommand,
+  useCommandShortcuts,
+  useCommands,
+  useCommandsEvent,
+  useCommandsSettings
+};
+//# sourceMappingURL=commands.js.map

package/dist/commands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.js","sources":["../src/commands.ts"],"sourcesContent":["/**\n * @embedpdf/vue/commands: the Vue surface of `@embedpdf/plugin-commands`. The\n * standard commands, a command as a button needs it, the settings, and keyboard\n * shortcuts. A command's state is derived from live state on read, so\n * `useCommand` re-reads it on the kernel's one change stream and its ref\n * changes only when what the command shows changed.\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-commands';\nimport { computed, toValue, watch } from 'vue';\nimport type { MaybeRefOrGetter, Ref } from 'vue';\nimport { formatShortcut as formatKeys } from '@embedpdf/core-ui';\nimport {\n  CommandsToken,\n  boundCommandOf,\n  resolvedCommandsEqual,\n  unknownCommandWarning,\n  unregisteredCommand,\n} from '@embedpdf/plugin-commands';\nimport type {\n  BoundCommand,\n  CommandId,\n  CommandRefusal,\n  CommandsCapability,\n} from '@embedpdf/plugin-commands';\nimport { CommandsToken as CommandsHostToken } from '@embedpdf/plugin-commands/contract/host';\nimport { createStandardCommands } from '@embedpdf/plugin-commands/standard';\nimport type { EventHook } from '@embedpdf/core';\nimport { bindCommandShortcuts, isMacPlatform, standardCommandsBrowser } from '@embedpdf/web';\nimport { devWarn } from './dev';\nimport { useCapability, useCapabilityEvent } from './runtime/capabilities';\nimport { useDocumentId, useKernelValue } from './runtime/kernel';\nimport { settingsComposable } from './state';\n\n/**\n * The commands every viewer has: zoom, pages, view rotation, `tool:<id>` for every tool, copy,\n * delete, download and print, with shortcuts and labels in EmbedPDF's eight languages. Spread\n * them into `commandsPlugin({ commands })`.\n */\nexport const standardCommands = /* @__PURE__ */ createStandardCommands(standardCommandsBrowser);\n\n/** The commands API: `execute`, `searchCommands`, `registerCommand`, the categories, the settings calls. The object never changes. */\nexport function useCommands(): CommandsCapability {\n  return useCapability(CommandsToken);\n}\n\n/** Subscribe to one commands event while the component lives: `useCommandsEvent((commands) => commands.onExecuted, handler)`. */\nexport function useCommandsEvent<Event>(\n  select: (commands: CommandsCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(CommandsToken, select, handler);\n}\n\n/**\n * The commands settings (`commands`, `disabledCategories`, `disabledCommands`, `notAllowed`) as refs,\n * with or without a document. Takes a selector.\n */\nexport const useCommandsSettings = settingsComposable(CommandsToken);\n\n/** A shortcut as a tooltip shows it, for this platform: `'⌘K'` on a Mac, `'Ctrl+K'` elsewhere. */\nexport function formatShortcut(shortcut: string, options: { isMac?: boolean } = {}): string {\n  return formatKeys(shortcut, { isMac: options.isMac ?? isMacPlatform() });\n}\n\n/**\n * A command for this component's document (the nearest `<DocumentScope>`, else\n * the active one), as a ref: its label, icon, state, `run` and `shortcut`. Pass\n * a getter to follow a prop: `useCommand(() => props.id)`. The ref changes only\n * when what the command shows does. Always a command: an id no plugin\n * registered is labelled with its id, neither visible nor enabled, and warns\n * once in development.\n */\nexport function useCommand(id: MaybeRefOrGetter<string>): Readonly<Ref<BoundCommand>> {\n  const commands = useCapability(CommandsToken);\n  const documentId = useDocumentId();\n  const resolved = useKernelValue(\n    () => commands.resolveCommand(toValue(id), documentId.value ?? undefined),\n    resolvedCommandsEqual,\n  );\n  return computed(() => {\n    const command = resolved.value;\n    const requested = toValue(id);\n    if (command === null) {\n      devWarn(\n        `useCommand:${requested}`,\n        `useCommand(): ${unknownCommandWarning(requested, commands.listCommandIds())}`,\n      );\n    }\n    const scope = documentId.value ?? undefined;\n    return boundCommandOf(\n      command ?? unregisteredCommand(requested),\n      (commandId) => commands.execute(commandId, { documentId: scope }),\n      { isMac: isMacPlatform() },\n    );\n  });\n}\n\n/** Where {@link useCommandShortcuts} listens, and how it reads `Mod`. */\nexport interface CommandShortcutsOptions {\n  /** Whether `Mod` is Cmd (a Mac) or Ctrl. Default: what the browser says. */\n  isMac?: MaybeRefOrGetter<boolean | undefined>;\n  /**\n   * Listen only while focus is inside this element (a template ref), for a\n   * page with more than one viewer. The keys work once it has mounted.\n   */\n  target?: MaybeRefOrGetter<HTMLElement | null | undefined>;\n  /** Called when a key's command is turned off or not allowed, with why: say so to the user. */\n  onRefused?: (commandId: CommandId, refusal: CommandRefusal) => void;\n}\n\n/**\n * Turn every command's shortcut into a working key, for the active document.\n * Call it once, near the top of your viewer. Keys typed into text fields are\n * left alone, and so is a key whose command can't run right now. A command\n * that's turned off or not allowed still takes its key, and `onRefused` says\n * why. The keys work anywhere on the page; with `target`, only while focus is\n * inside that element.\n * They stop when the component unmounts.\n */\nexport function useCommandShortcuts(options: CommandShortcutsOptions = {}): void {\n  const commands = useCapability(CommandsHostToken);\n  const scoped = options.target !== undefined;\n  watch(\n    () => [toValue(options.isMac), toValue(options.target)] as const,\n    ([isMac, target], _previous, onCleanup) => {\n      // A target that hasn't mounted yet binds nothing; its ref being set runs this again.\n      if (scoped && !target) return;\n      onCleanup(\n        bindCommandShortcuts(commands, {\n          isMac,\n          target: target ?? undefined,\n          onRefused: (commandId, refusal) => options.onRefused?.(commandId, refusal),\n        }),\n      );\n    },\n    { immediate: true, flush: 'post' },\n  );\n}\n"],"names":["formatKeys","CommandsHostToken"],"mappings":";;;;;;;;;;AAwCO,MAAM,0DAA0D,uBAAuB;AAGvF,SAAS,cAAkC;AAChD,SAAO,cAAc,aAAa;AACpC;AAGO,SAAS,iBACd,QACA,SACM;AACN,qBAAmB,eAAe,QAAQ,OAAO;AACnD;AAMO,MAAM,sBAAsB,mBAAmB,aAAa;AAG5D,SAAS,eAAe,UAAkB,UAA+B,IAAY;AAC1F,SAAOA,iBAAW,UAAU,EAAE,OAAO,QAAQ,SAAS,cAAA,GAAiB;AACzE;AAUO,SAAS,WAAW,IAA2D;AACpF,QAAM,WAAW,cAAc,aAAa;AAC5C,QAAM,aAAa,cAAA;AACnB,QAAM,WAAW;AAAA,IACf,MAAM,SAAS,eAAe,QAAQ,EAAE,GAAG,WAAW,SAAS,MAAS;AAAA,IACxE;AAAA,EAAA;AAEF,SAAO,SAAS,MAAM;AACpB,UAAM,UAAU,SAAS;AACzB,UAAM,YAAY,QAAQ,EAAE;AAC5B,QAAI,YAAY,MAAM;AACpB;AAAA,QACE,cAAc,SAAS;AAAA,QACvB,iBAAiB,sBAAsB,WAAW,SAAS,eAAA,CAAgB,CAAC;AAAA,MAAA;AAAA,IAEhF;AACA,UAAM,QAAQ,WAAW,SAAS;AAClC,WAAO;AAAA,MACL,WAAW,oBAAoB,SAAS;AAAA,MACxC,CAAC,cAAc,SAAS,QAAQ,WAAW,EAAE,YAAY,OAAO;AAAA,MAChE,EAAE,OAAO,cAAA,EAAc;AAAA,IAAE;AAAA,EAE7B,CAAC;AACH;AAwBO,SAAS,oBAAoB,UAAmC,IAAU;AAC/E,QAAM,WAAW,cAAcC,eAAiB;AAChD,QAAM,SAAS,QAAQ,WAAW;AAClC;AAAA,IACE,MAAM,CAAC,QAAQ,QAAQ,KAAK,GAAG,QAAQ,QAAQ,MAAM,CAAC;AAAA,IACtD,CAAC,CAAC,OAAO,MAAM,GAAG,WAAW,cAAc;AAEzC,UAAI,UAAU,CAAC,OAAQ;AACvB;AAAA,QACE,qBAAqB,UAAU;AAAA,UAC7B;AAAA,UACA,QAAQ,UAAU;AAAA,UAClB,WAAW,CAAC,WAAW;;AAAY,iCAAQ,cAAR,iCAAoB,WAAW;AAAA;AAAA,QAAO,CAC1E;AAAA,MAAA;AAAA,IAEL;AAAA,IACA,EAAE,WAAW,MAAM,OAAO,OAAA;AAAA,EAAO;AAErC;"}

package/dist/composables-BGBsNDf9.cjs

@@ -0,0 +1,25 @@
+"use strict";
+const vue = require("vue");
+const pluginSignature = require("@embedpdf/plugin-signature");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+const stamp = require("./stamp.cjs");
+const state = require("./state-M22NDJQo.cjs");
+function useSignature() {
+  return capabilities.useCapability(pluginSignature.SignatureToken);
+}
+const useSignatureState = state.stateComposable(pluginSignature.signatureState);
+const useSignatureSettings = state.settingsComposable(pluginSignature.SignatureToken);
+function useSignatureEvent(select, handler) {
+  capabilities.useCapabilityEvent(pluginSignature.SignatureToken, select, handler);
+}
+function useSignerRows() {
+  const libraries = stamp.useStampLibraries({ kind: pluginSignature.SIGNATURES_LIBRARY_KIND });
+  const assets = stamp.useStampAssets();
+  return vue.computed(() => pluginSignature.signerRowsOf(libraries.value, assets.value));
+}
+exports.useSignature = useSignature;
+exports.useSignatureEvent = useSignatureEvent;
+exports.useSignatureSettings = useSignatureSettings;
+exports.useSignatureState = useSignatureState;
+exports.useSignerRows = useSignerRows;
+//# sourceMappingURL=composables-BGBsNDf9.cjs.map

package/dist/composables-BGBsNDf9.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"composables-BGBsNDf9.cjs","sources":["../src/signature/composables.ts"],"sourcesContent":["/**\n * The signature composables: `useSignature()` (the API), the state and the\n * settings as refs, `useSignatureEvent()`, and `useSignerRows()`, the people\n * whose marks this browser holds, for a signature picker.\n */\nimport { computed } from 'vue';\nimport type { Ref } from 'vue';\nimport type { EventHook } from '@embedpdf/core';\nimport {\n  signatureState,\n  signerRowsOf,\n  SIGNATURES_LIBRARY_KIND,\n  SignatureToken,\n} from '@embedpdf/plugin-signature';\nimport type { SignatureCapability, SignerRow } from '@embedpdf/plugin-signature';\nimport { useCapability, useCapabilityEvent } from '../runtime/capabilities';\nimport { useStampAssets, useStampLibraries } from '../stamp';\nimport { settingsComposable, stateComposable } from '../state';\nimport type { StateComposable } from '../state';\n\n/**\n * The signature API for the document in scope: sign, place a mark, fill or\n * clear a field, check the signatures. The object never changes, so it's\n * safe to keep in a closure; keep it whole (`signature.sign(…)`), since a\n * member taken out of it once stays the one of that moment.\n */\nexport function useSignature(): SignatureCapability {\n  return useCapability(SignatureToken);\n}\n\n/**\n * The signatures' state as refs: the signed fields with their verdicts\n * (`signatures`), what they allow, the `target`, whether a signing runs\n * (`busy`), a two-step signing in progress, and whether they're read,\n * declared once in `signatureState`. With a selector, one ref that updates\n * only when the value it picks changes. Empty without a document.\n *\n * Typed through the declaration, so the published types name it from\n * `@embedpdf/plugin-signature`, a dependency of this package, and not from the\n * engine package `protection`'s type comes from, which isn't one.\n */\nexport const useSignatureState: StateComposable<ReturnType<typeof signatureState.read>> =\n  stateComposable(signatureState);\n\n/**\n * The signature settings (`key`, `mode`, `trust`, `allowCertify`) as refs, or\n * one ref for the value `select` picks. They belong to the plugin, so they\n * read without a document.\n */\nexport const useSignatureSettings = settingsComposable(SignatureToken);\n\n/** Subscribe to one signature event while the component lives: `useSignatureEvent((signature) => signature.onSigned, handler)`. */\nexport function useSignatureEvent<Event>(\n  select: (signature: SignatureCapability) => EventHook<Event>,\n  handler: (event: Event) => 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, as a ref: `const rows = useSignerRows()`.\n * Derived from the stamp plugin, so it needs `stampPlugin()`: rename, delete\n * and export are the library verbs, and nothing is stored beyond the file.\n */\nexport function useSignerRows(): Readonly<Ref<readonly SignerRow[]>> {\n  const libraries = useStampLibraries({ kind: SIGNATURES_LIBRARY_KIND });\n  const assets = useStampAssets();\n  return computed(() => signerRowsOf(libraries.value, assets.value));\n}\n"],"names":["useCapability","SignatureToken","stateComposable","signatureState","settingsComposable","useCapabilityEvent","useStampLibraries","SIGNATURES_LIBRARY_KIND","useStampAssets","computed","signerRowsOf"],"mappings":";;;;;;AA0BO,SAAS,eAAoC;AAClD,SAAOA,aAAAA,cAAcC,gBAAAA,cAAc;AACrC;AAaO,MAAM,oBACXC,MAAAA,gBAAgBC,gBAAAA,cAAc;AAOzB,MAAM,uBAAuBC,MAAAA,mBAAmBH,gBAAAA,cAAc;AAG9D,SAAS,kBACd,QACA,SACM;AACNI,kCAAmBJ,gBAAAA,gBAAgB,QAAQ,OAAO;AACpD;AAQO,SAAS,gBAAqD;AACnE,QAAM,YAAYK,MAAAA,kBAAkB,EAAE,MAAMC,gBAAAA,yBAAyB;AACrE,QAAM,SAASC,MAAAA,eAAA;AACf,SAAOC,IAAAA,SAAS,MAAMC,6BAAa,UAAU,OAAO,OAAO,KAAK,CAAC;AACnE;;;;;;"}