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

package/dist/annotation.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginAnnotation = require("@embedpdf/plugin-annotation");
+const composables = require("./composables-BuHvnUlo.cjs");
+exports.AnnotationDraftMenu = composables._sfc_main;
+exports.AnnotationLayer = composables._sfc_main$1;
+exports.AnnotationMenu = composables._sfc_main$2;
+exports.AnnotationRotationBadge = composables._sfc_main$3;
+exports.filePickerProvider = composables.filePickerProvider;
+exports.useAnnotation = composables.useAnnotation;
+exports.useAnnotationAnchor = composables.useAnnotationAnchor;
+exports.useAnnotationDefaults = composables.useAnnotationDefaults;
+exports.useAnnotationEvent = composables.useAnnotationEvent;
+exports.useAnnotationList = composables.useAnnotationList;
+exports.useAnnotationProperties = composables.useAnnotationProperties;
+exports.useAnnotationSettings = composables.useAnnotationSettings;
+exports.useAnnotationState = composables.useAnnotationState;
+exports.useCommentThread = composables.useCommentThread;
+exports.useCommentThreads = composables.useCommentThreads;
+exports.useComments = composables.useComments;
+exports.useFilePickerProvider = composables.useFilePickerProvider;
+exports.useRichTextEditor = composables.useRichTextEditor;
+Object.keys(pluginAnnotation).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginAnnotation[k]
+  });
+});
+//# sourceMappingURL=annotation.cjs.map

package/dist/annotation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotation.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/annotation.d.cts

@@ -0,0 +1,35 @@
+/**
+ * @embedpdf/vue/annotation: the Vue view of `@embedpdf/plugin-annotation`.
+ *
+ * `<AnnotationLayer>` draws a page's annotations, the selection's handles,
+ * the tool's preview and the text boxes being typed in, with `renderers` for
+ * your own looks and `#handle` / `#rotation-handle` slots for your own
+ * handles. `<AnnotationMenu>`, `<AnnotationDraftMenu>` and
+ * `<AnnotationRotationBadge>` float your UI over the selection, a shape being
+ * drawn and a turn in progress.
+ *
+ * The composables follow every plugin's four: `useAnnotation()` (the API),
+ * `useAnnotationState()` (status, selected, hovered, editing),
+ * `useAnnotationEvent()` and `useAnnotationSettings()`; the reads a component
+ * follows on their own are refs: `useAnnotationList()`,
+ * `useAnnotationDefaults()`, `useAnnotationProperties()`,
+ * `useAnnotationAnchor()`, and the comments' `useCommentThreads()` and
+ * `useCommentThread()`. `useRichTextEditor()` makes your element a text box's
+ * editor, and `useFilePickerProvider()` installs the file dialog behind
+ * click-then-pick tools.
+ *
+ * What isn't Vue lives in `@embedpdf/web`, the same for every framework: the
+ * scene as SVG elements, the chrome's paint and pixels, the text box editor,
+ * which drawing each annotation gets and the behaviors renderers register,
+ * and the object URLs of baked appearances and the stamp ghost.
+ */
+export * from '@embedpdf/plugin-annotation';
+export type { CreationDraftAnchor, RenderItem, LineEnding, LineEndings, Style, AnnotationFlags, FieldValues, TextAlign, TextStyle, } from '@embedpdf/core-annotation';
+export { default as AnnotationLayer } from './annotation/AnnotationLayer.vue.cjs';
+export { default as AnnotationMenu } from './annotation/AnnotationMenu.vue.cjs';
+export { default as AnnotationDraftMenu } from './annotation/AnnotationDraftMenu.vue.cjs';
+export { default as AnnotationRotationBadge } from './annotation/AnnotationRotationBadge.vue.cjs';
+export { useAnnotationSettings, useAnnotationState } from './annotation/state.cjs';
+export { filePickerProvider, useAnnotation, useAnnotationAnchor, useAnnotationDefaults, useAnnotationEvent, useAnnotationList, useAnnotationProperties, useCommentThread, useCommentThreads, useComments, useFilePickerProvider, } from './annotation/composables.cjs';
+export { useRichTextEditor } from './annotation/text-box.cjs';
+export type { AnnotationFrame, AnnotationInteractiveContext, AnnotationRenderer, AnnotationRendererProps, BehaviorRendererProps, CommentThreadView, HandleProps, RichTextEditor, RotationHandleProps, } from './annotation/types.cjs';

package/dist/annotation.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @embedpdf/vue/annotation: the Vue view of `@embedpdf/plugin-annotation`.
+ *
+ * `<AnnotationLayer>` draws a page's annotations, the selection's handles,
+ * the tool's preview and the text boxes being typed in, with `renderers` for
+ * your own looks and `#handle` / `#rotation-handle` slots for your own
+ * handles. `<AnnotationMenu>`, `<AnnotationDraftMenu>` and
+ * `<AnnotationRotationBadge>` float your UI over the selection, a shape being
+ * drawn and a turn in progress.
+ *
+ * The composables follow every plugin's four: `useAnnotation()` (the API),
+ * `useAnnotationState()` (status, selected, hovered, editing),
+ * `useAnnotationEvent()` and `useAnnotationSettings()`; the reads a component
+ * follows on their own are refs: `useAnnotationList()`,
+ * `useAnnotationDefaults()`, `useAnnotationProperties()`,
+ * `useAnnotationAnchor()`, and the comments' `useCommentThreads()` and
+ * `useCommentThread()`. `useRichTextEditor()` makes your element a text box's
+ * editor, and `useFilePickerProvider()` installs the file dialog behind
+ * click-then-pick tools.
+ *
+ * What isn't Vue lives in `@embedpdf/web`, the same for every framework: the
+ * scene as SVG elements, the chrome's paint and pixels, the text box editor,
+ * which drawing each annotation gets and the behaviors renderers register,
+ * and the object URLs of baked appearances and the stamp ghost.
+ */
+export * from '@embedpdf/plugin-annotation';
+export type { CreationDraftAnchor, RenderItem, LineEnding, LineEndings, Style, AnnotationFlags, FieldValues, TextAlign, TextStyle, } from '@embedpdf/core-annotation';
+export { default as AnnotationLayer } from './annotation/AnnotationLayer.vue.js';
+export { default as AnnotationMenu } from './annotation/AnnotationMenu.vue.js';
+export { default as AnnotationDraftMenu } from './annotation/AnnotationDraftMenu.vue.js';
+export { default as AnnotationRotationBadge } from './annotation/AnnotationRotationBadge.vue.js';
+export { useAnnotationSettings, useAnnotationState } from './annotation/state.js';
+export { filePickerProvider, useAnnotation, useAnnotationAnchor, useAnnotationDefaults, useAnnotationEvent, useAnnotationList, useAnnotationProperties, useCommentThread, useCommentThreads, useComments, useFilePickerProvider, } from './annotation/composables.js';
+export { useRichTextEditor } from './annotation/text-box.js';
+export type { AnnotationFrame, AnnotationInteractiveContext, AnnotationRenderer, AnnotationRendererProps, BehaviorRendererProps, CommentThreadView, HandleProps, RichTextEditor, RotationHandleProps, } from './annotation/types.js';

package/dist/annotation.js

@@ -0,0 +1,23 @@
+export * from "@embedpdf/plugin-annotation";
+import { _, a, b, c, f, u, d, e, g, h, i, j, k, l, m, n, o, p } from "./composables-CIkhKwAg.js";
+export {
+  _ as AnnotationDraftMenu,
+  a as AnnotationLayer,
+  b as AnnotationMenu,
+  c as AnnotationRotationBadge,
+  f as filePickerProvider,
+  u as useAnnotation,
+  d as useAnnotationAnchor,
+  e as useAnnotationDefaults,
+  g as useAnnotationEvent,
+  h as useAnnotationList,
+  i as useAnnotationProperties,
+  j as useAnnotationSettings,
+  k as useAnnotationState,
+  l as useCommentThread,
+  m as useCommentThreads,
+  n as useComments,
+  o as useFilePickerProvider,
+  p as useRichTextEditor
+};
+//# sourceMappingURL=annotation.js.map

package/dist/annotation.js.map

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

package/dist/capabilities-C7YzgPCX.js

@@ -0,0 +1,164 @@
+import { provide, computed, toValue, inject, watch, markRaw } from "vue";
+import { standInFor, isReadMember } from "@embedpdf/core";
+const ViewerKey = Symbol("embedpdf viewer");
+const DocumentScopeKey = Symbol(
+  "embedpdf document scope"
+);
+function provideViewer(binding) {
+  provide(ViewerKey, binding);
+}
+function useViewerBinding() {
+  const binding = inject(ViewerKey, null);
+  if (!(binding == null ? void 0 : binding.kernel)) {
+    throw new Error(
+      "No <Viewer> above this component: EmbedPDF composables work in components rendered inside <Viewer>, not in the component that renders it."
+    );
+  }
+  return binding;
+}
+function useKernel() {
+  return useViewerBinding().kernel;
+}
+function useKernelValue(select, isEqual = Object.is) {
+  const { kernel, track } = useViewerBinding();
+  return computed((previous) => {
+    track();
+    const next = select(kernel);
+    return previous !== void 0 && isEqual(previous, next) ? previous : next;
+  });
+}
+const NO_SCOPE = computed(() => null);
+function provideDocumentScope(id) {
+  provide(
+    DocumentScopeKey,
+    computed(() => toValue(id))
+  );
+}
+function useDocumentScope() {
+  return inject(DocumentScopeKey, NO_SCOPE);
+}
+function useActiveDocumentId() {
+  return useKernelValue((kernel) => kernel.documents.getActiveId());
+}
+function useDocumentId() {
+  const scope = useDocumentScope();
+  const active = useActiveDocumentId();
+  return computed(() => scope.value ?? active.value);
+}
+function useOptionalCapability(token) {
+  const scope = useDocumentScope();
+  return useKernelValue((kernel) => kernel.tryCapability(toValue(token), scope.value ?? void 0));
+}
+function useCapabilityRef(token) {
+  const kernel = useKernel();
+  const resolved = useOptionalCapability(token);
+  const capability = computed(() => {
+    const current = resolved.value;
+    if (current) return current;
+    const wanted = toValue(token);
+    if (kernel.scopeOf(wanted) === "document") return standInFor(kernel, wanted);
+    return kernel.capability(wanted);
+  });
+  void capability.value;
+  return capability;
+}
+function useCapability(token) {
+  return liveCapability(useCapabilityRef(token), useViewerBinding().track);
+}
+const isVueFlag = (key) => typeof key === "string" && key.startsWith("__v_");
+function liveCapability(current, track) {
+  let latest = current.value;
+  watch(current, (capability) => latest = capability, { flush: "sync" });
+  const resolve = (tracked) => tracked ? current.value : latest;
+  return liveMember(resolve, track, null);
+}
+function liveMember(resolve, track, call) {
+  const members = /* @__PURE__ */ new Map();
+  const target = markRaw(call ? function member() {
+  } : {});
+  return new Proxy(target, {
+    apply: (_target, _this, args) => call(args),
+    has: (_target, key) => {
+      const value = resolve(false);
+      return (typeof value === "object" || typeof value === "function") && value !== null ? key in value : false;
+    },
+    get(_target, key) {
+      var _a;
+      if (isVueFlag(key)) return Reflect.get(target, key);
+      if (typeof key === "symbol" || key === "then") return void 0;
+      const value = (_a = resolve(false)) == null ? void 0 : _a[key];
+      if (typeof value !== "function" && (typeof value !== "object" || value === null)) {
+        return value;
+      }
+      let member = members.get(key);
+      if (!member) {
+        const invoke = (tracked, args) => {
+          const owner = resolve(tracked);
+          return Reflect.apply(owner[key], owner, args);
+        };
+        member = liveMember(
+          (tracked) => resolve(tracked)[key],
+          track,
+          isReadMember(key) ? (
+            // A computed of its own for each call: its reader wakes when the answer changes.
+            ((args) => computed(() => {
+              track();
+              return invoke(true, args);
+            }).value)
+          ) : (args) => invoke(false, args)
+        );
+        members.set(key, member);
+      }
+      return member;
+    }
+  });
+}
+function useSelector(token, select, isEqual = Object.is) {
+  const scope = useDocumentScope();
+  return useKernelValue((kernel) => {
+    const wanted = toValue(token);
+    const documentId = scope.value ?? void 0;
+    const capability = kernel.tryCapability(wanted, documentId) ?? kernel.capability(wanted, documentId);
+    return select(capability);
+  }, isEqual);
+}
+function useOptionalSelector(token, select, fallback, isEqual = Object.is) {
+  const scope = useDocumentScope();
+  return useKernelValue((kernel) => {
+    const capability = kernel.tryCapability(toValue(token), scope.value ?? void 0);
+    if (capability === null) return fallback;
+    try {
+      return select(capability);
+    } catch {
+      return fallback;
+    }
+  }, isEqual);
+}
+function useCapabilityEvent(token, select, handler) {
+  const capability = useOptionalCapability(token);
+  watch(
+    capability,
+    (current, _previous, onCleanup) => {
+      if (!current) return;
+      onCleanup(select(current)((event) => handler(event)));
+    },
+    { immediate: true, flush: "sync" }
+  );
+}
+export {
+  useCapability as a,
+  useCapabilityEvent as b,
+  useCapabilityRef as c,
+  useDocumentId as d,
+  useDocumentScope as e,
+  useKernel as f,
+  useKernelValue as g,
+  useOptionalCapability as h,
+  useOptionalSelector as i,
+  useSelector as j,
+  provideViewer as k,
+  useViewerBinding as l,
+  provideDocumentScope as p,
+  useActiveDocumentId as u
+};
+//# sourceMappingURL=capabilities-C7YzgPCX.js.map

package/dist/capabilities-C7YzgPCX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities-C7YzgPCX.js","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":[],"mappings":"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"}

package/dist/capabilities-DVNJmgy7.cjs

@@ -0,0 +1,163 @@
+"use strict";
+const vue = require("vue");
+const core = require("@embedpdf/core");
+const ViewerKey = Symbol("embedpdf viewer");
+const DocumentScopeKey = Symbol(
+  "embedpdf document scope"
+);
+function provideViewer(binding) {
+  vue.provide(ViewerKey, binding);
+}
+function useViewerBinding() {
+  const binding = vue.inject(ViewerKey, null);
+  if (!(binding == null ? void 0 : binding.kernel)) {
+    throw new Error(
+      "No <Viewer> above this component: EmbedPDF composables work in components rendered inside <Viewer>, not in the component that renders it."
+    );
+  }
+  return binding;
+}
+function useKernel() {
+  return useViewerBinding().kernel;
+}
+function useKernelValue(select, isEqual = Object.is) {
+  const { kernel, track } = useViewerBinding();
+  return vue.computed((previous) => {
+    track();
+    const next = select(kernel);
+    return previous !== void 0 && isEqual(previous, next) ? previous : next;
+  });
+}
+const NO_SCOPE = vue.computed(() => null);
+function provideDocumentScope(id) {
+  vue.provide(
+    DocumentScopeKey,
+    vue.computed(() => vue.toValue(id))
+  );
+}
+function useDocumentScope() {
+  return vue.inject(DocumentScopeKey, NO_SCOPE);
+}
+function useActiveDocumentId() {
+  return useKernelValue((kernel) => kernel.documents.getActiveId());
+}
+function useDocumentId() {
+  const scope = useDocumentScope();
+  const active = useActiveDocumentId();
+  return vue.computed(() => scope.value ?? active.value);
+}
+function useOptionalCapability(token) {
+  const scope = useDocumentScope();
+  return useKernelValue((kernel) => kernel.tryCapability(vue.toValue(token), scope.value ?? void 0));
+}
+function useCapabilityRef(token) {
+  const kernel = useKernel();
+  const resolved = useOptionalCapability(token);
+  const capability = vue.computed(() => {
+    const current = resolved.value;
+    if (current) return current;
+    const wanted = vue.toValue(token);
+    if (kernel.scopeOf(wanted) === "document") return core.standInFor(kernel, wanted);
+    return kernel.capability(wanted);
+  });
+  void capability.value;
+  return capability;
+}
+function useCapability(token) {
+  return liveCapability(useCapabilityRef(token), useViewerBinding().track);
+}
+const isVueFlag = (key) => typeof key === "string" && key.startsWith("__v_");
+function liveCapability(current, track) {
+  let latest = current.value;
+  vue.watch(current, (capability) => latest = capability, { flush: "sync" });
+  const resolve = (tracked) => tracked ? current.value : latest;
+  return liveMember(resolve, track, null);
+}
+function liveMember(resolve, track, call) {
+  const members = /* @__PURE__ */ new Map();
+  const target = vue.markRaw(call ? function member() {
+  } : {});
+  return new Proxy(target, {
+    apply: (_target, _this, args) => call(args),
+    has: (_target, key) => {
+      const value = resolve(false);
+      return (typeof value === "object" || typeof value === "function") && value !== null ? key in value : false;
+    },
+    get(_target, key) {
+      var _a;
+      if (isVueFlag(key)) return Reflect.get(target, key);
+      if (typeof key === "symbol" || key === "then") return void 0;
+      const value = (_a = resolve(false)) == null ? void 0 : _a[key];
+      if (typeof value !== "function" && (typeof value !== "object" || value === null)) {
+        return value;
+      }
+      let member = members.get(key);
+      if (!member) {
+        const invoke = (tracked, args) => {
+          const owner = resolve(tracked);
+          return Reflect.apply(owner[key], owner, args);
+        };
+        member = liveMember(
+          (tracked) => resolve(tracked)[key],
+          track,
+          core.isReadMember(key) ? (
+            // A computed of its own for each call: its reader wakes when the answer changes.
+            ((args) => vue.computed(() => {
+              track();
+              return invoke(true, args);
+            }).value)
+          ) : (args) => invoke(false, args)
+        );
+        members.set(key, member);
+      }
+      return member;
+    }
+  });
+}
+function useSelector(token, select, isEqual = Object.is) {
+  const scope = useDocumentScope();
+  return useKernelValue((kernel) => {
+    const wanted = vue.toValue(token);
+    const documentId = scope.value ?? void 0;
+    const capability = kernel.tryCapability(wanted, documentId) ?? kernel.capability(wanted, documentId);
+    return select(capability);
+  }, isEqual);
+}
+function useOptionalSelector(token, select, fallback, isEqual = Object.is) {
+  const scope = useDocumentScope();
+  return useKernelValue((kernel) => {
+    const capability = kernel.tryCapability(vue.toValue(token), scope.value ?? void 0);
+    if (capability === null) return fallback;
+    try {
+      return select(capability);
+    } catch {
+      return fallback;
+    }
+  }, isEqual);
+}
+function useCapabilityEvent(token, select, handler) {
+  const capability = useOptionalCapability(token);
+  vue.watch(
+    capability,
+    (current, _previous, onCleanup) => {
+      if (!current) return;
+      onCleanup(select(current)((event) => handler(event)));
+    },
+    { immediate: true, flush: "sync" }
+  );
+}
+exports.provideDocumentScope = provideDocumentScope;
+exports.provideViewer = provideViewer;
+exports.useActiveDocumentId = useActiveDocumentId;
+exports.useCapability = useCapability;
+exports.useCapabilityEvent = useCapabilityEvent;
+exports.useCapabilityRef = useCapabilityRef;
+exports.useDocumentId = useDocumentId;
+exports.useDocumentScope = useDocumentScope;
+exports.useKernel = useKernel;
+exports.useKernelValue = useKernelValue;
+exports.useOptionalCapability = useOptionalCapability;
+exports.useOptionalSelector = useOptionalSelector;
+exports.useSelector = useSelector;
+exports.useViewerBinding = useViewerBinding;
+//# sourceMappingURL=capabilities-DVNJmgy7.cjs.map

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;;;;;;;;;;;;;;"}