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

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-Bi6QvJpj.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-DK3lwh38.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/attachment.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginAttachment = require("@embedpdf/plugin-attachment");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+const state = require("./state-M22NDJQo.cjs");
+function useAttachment() {
+  return capabilities.useCapability(pluginAttachment.AttachmentToken);
+}
+const useAttachmentState = state.stateComposable(pluginAttachment.attachmentState);
+function useAttachmentEvent(select, handler) {
+  capabilities.useCapabilityEvent(pluginAttachment.AttachmentToken, select, handler);
+}
+exports.useAttachment = useAttachment;
+exports.useAttachmentEvent = useAttachmentEvent;
+exports.useAttachmentState = useAttachmentState;
+Object.keys(pluginAttachment).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginAttachment[k]
+  });
+});
+//# sourceMappingURL=attachment.cjs.map

package/dist/attachment.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachment.cjs","sources":["../src/attachment.ts"],"sourcesContent":["/**\n * @embedpdf/vue/attachment: the Vue view of `@embedpdf/plugin-attachment`.\n * Reading the state reads the document's attachments; the plugin keeps them\n * live off the document's event stream, lists the pages' files with them, and\n * shows your own adds and removes at once.\n *\n *   const attachment = useAttachment();\n *   const { files, canAdd } = useAttachmentState();\n *   const { bytes, name, mimeType } = await attachment.download(file);\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-attachment';\nimport type { EventHook } from '@embedpdf/core';\nimport { AttachmentToken, attachmentState } from '@embedpdf/plugin-attachment';\nimport type { AttachmentCapability } from '@embedpdf/plugin-attachment';\n\nimport { useCapability, useCapabilityEvent } from './runtime/capabilities';\nimport { stateComposable } from './state';\n\n/**\n * The attachment API (add, remove, download, reveal) of the nearest\n * `<DocumentScope>`'s document, else the active one. The object never\n * changes; outside a document every method throws `not-ready`.\n */\nexport function useAttachment(): AttachmentCapability {\n  return useCapability(AttachmentToken);\n}\n\n/**\n * The files the document carries, the load state, and whether you may add and\n * save files, as refs (the page's State table, declared once in\n * `attachmentState`). With a selector, one ref for the value it picks, which\n * updates only when that value changes.\n */\nexport const useAttachmentState = stateComposable(attachmentState);\n\n/** Subscribe to one attachment event while the component lives: `useAttachmentEvent((attachment) => attachment.onChanged, handler)`. */\nexport function useAttachmentEvent<Event>(\n  select: (attachment: AttachmentCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(AttachmentToken, select, handler);\n}\n"],"names":["useCapability","AttachmentToken","stateComposable","attachmentState","useCapabilityEvent"],"mappings":";;;;;AAyBO,SAAS,gBAAsC;AACpD,SAAOA,aAAAA,cAAcC,iBAAAA,eAAe;AACtC;AAQO,MAAM,qBAAqBC,MAAAA,gBAAgBC,iBAAAA,eAAe;AAG1D,SAAS,mBACd,QACA,SACM;AACNC,kCAAmBH,iBAAAA,iBAAiB,QAAQ,OAAO;AACrD;;;;;;;;;;"}

package/dist/attachment.d.cts

@@ -0,0 +1,34 @@
+/**
+ * @embedpdf/vue/attachment: the Vue view of `@embedpdf/plugin-attachment`.
+ * Reading the state reads the document's attachments; the plugin keeps them
+ * live off the document's event stream, lists the pages' files with them, and
+ * shows your own adds and removes at once.
+ *
+ *   const attachment = useAttachment();
+ *   const { files, canAdd } = useAttachmentState();
+ *   const { bytes, name, mimeType } = await attachment.download(file);
+ */
+export * from '@embedpdf/plugin-attachment';
+import type { EventHook } from '@embedpdf/core';
+import type { AttachmentCapability } from '@embedpdf/plugin-attachment';
+/**
+ * The attachment API (add, remove, download, reveal) of the nearest
+ * `<DocumentScope>`'s document, else the active one. The object never
+ * changes; outside a document every method throws `not-ready`.
+ */
+export declare function useAttachment(): AttachmentCapability;
+/**
+ * The files the document carries, the load state, and whether you may add and
+ * save files, as refs (the page's State table, declared once in
+ * `attachmentState`). With a selector, one ref for the value it picks, which
+ * updates only when that value changes.
+ */
+export declare const useAttachmentState: import("./state.cjs").StateComposable<{
+    files: readonly import("@embedpdf/plugin-attachment").AttachedFile[];
+    selected: readonly import("@embedpdf/plugin-attachment").AttachedFile[];
+    status: import("@embedpdf/core").ResourceStatus;
+    canAdd: boolean;
+    canDownload: boolean;
+}>;
+/** Subscribe to one attachment event while the component lives: `useAttachmentEvent((attachment) => attachment.onChanged, handler)`. */
+export declare function useAttachmentEvent<Event>(select: (attachment: AttachmentCapability) => EventHook<Event>, handler: (event: Event) => void): void;

package/dist/attachment.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @embedpdf/vue/attachment: the Vue view of `@embedpdf/plugin-attachment`.
+ * Reading the state reads the document's attachments; the plugin keeps them
+ * live off the document's event stream, lists the pages' files with them, and
+ * shows your own adds and removes at once.
+ *
+ *   const attachment = useAttachment();
+ *   const { files, canAdd } = useAttachmentState();
+ *   const { bytes, name, mimeType } = await attachment.download(file);
+ */
+export * from '@embedpdf/plugin-attachment';
+import type { EventHook } from '@embedpdf/core';
+import type { AttachmentCapability } from '@embedpdf/plugin-attachment';
+/**
+ * The attachment API (add, remove, download, reveal) of the nearest
+ * `<DocumentScope>`'s document, else the active one. The object never
+ * changes; outside a document every method throws `not-ready`.
+ */
+export declare function useAttachment(): AttachmentCapability;
+/**
+ * The files the document carries, the load state, and whether you may add and
+ * save files, as refs (the page's State table, declared once in
+ * `attachmentState`). With a selector, one ref for the value it picks, which
+ * updates only when that value changes.
+ */
+export declare const useAttachmentState: import("./state.js").StateComposable<{
+    files: readonly import("@embedpdf/plugin-attachment").AttachedFile[];
+    selected: readonly import("@embedpdf/plugin-attachment").AttachedFile[];
+    status: import("@embedpdf/core").ResourceStatus;
+    canAdd: boolean;
+    canDownload: boolean;
+}>;
+/** Subscribe to one attachment event while the component lives: `useAttachmentEvent((attachment) => attachment.onChanged, handler)`. */
+export declare function useAttachmentEvent<Event>(select: (attachment: AttachmentCapability) => EventHook<Event>, handler: (event: Event) => void): void;

package/dist/attachment.js

@@ -0,0 +1,17 @@
+import { AttachmentToken, attachmentState } from "@embedpdf/plugin-attachment";
+export * from "@embedpdf/plugin-attachment";
+import { a as useCapability, b as useCapabilityEvent } from "./capabilities-C7YzgPCX.js";
+import { a as stateComposable } from "./state-DZg8q3v6.js";
+function useAttachment() {
+  return useCapability(AttachmentToken);
+}
+const useAttachmentState = stateComposable(attachmentState);
+function useAttachmentEvent(select, handler) {
+  useCapabilityEvent(AttachmentToken, select, handler);
+}
+export {
+  useAttachment,
+  useAttachmentEvent,
+  useAttachmentState
+};
+//# sourceMappingURL=attachment.js.map

package/dist/attachment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachment.js","sources":["../src/attachment.ts"],"sourcesContent":["/**\n * @embedpdf/vue/attachment: the Vue view of `@embedpdf/plugin-attachment`.\n * Reading the state reads the document's attachments; the plugin keeps them\n * live off the document's event stream, lists the pages' files with them, and\n * shows your own adds and removes at once.\n *\n *   const attachment = useAttachment();\n *   const { files, canAdd } = useAttachmentState();\n *   const { bytes, name, mimeType } = await attachment.download(file);\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-attachment';\nimport type { EventHook } from '@embedpdf/core';\nimport { AttachmentToken, attachmentState } from '@embedpdf/plugin-attachment';\nimport type { AttachmentCapability } from '@embedpdf/plugin-attachment';\n\nimport { useCapability, useCapabilityEvent } from './runtime/capabilities';\nimport { stateComposable } from './state';\n\n/**\n * The attachment API (add, remove, download, reveal) of the nearest\n * `<DocumentScope>`'s document, else the active one. The object never\n * changes; outside a document every method throws `not-ready`.\n */\nexport function useAttachment(): AttachmentCapability {\n  return useCapability(AttachmentToken);\n}\n\n/**\n * The files the document carries, the load state, and whether you may add and\n * save files, as refs (the page's State table, declared once in\n * `attachmentState`). With a selector, one ref for the value it picks, which\n * updates only when that value changes.\n */\nexport const useAttachmentState = stateComposable(attachmentState);\n\n/** Subscribe to one attachment event while the component lives: `useAttachmentEvent((attachment) => attachment.onChanged, handler)`. */\nexport function useAttachmentEvent<Event>(\n  select: (attachment: AttachmentCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(AttachmentToken, select, handler);\n}\n"],"names":[],"mappings":";;;;AAyBO,SAAS,gBAAsC;AACpD,SAAO,cAAc,eAAe;AACtC;AAQO,MAAM,qBAAqB,gBAAgB,eAAe;AAG1D,SAAS,mBACd,QACA,SACM;AACN,qBAAmB,iBAAiB,QAAQ,OAAO;AACrD;"}

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