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

package/dist/stamp.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stamp.cjs","sources":["../src/stamp.ts"],"sourcesContent":["/**\n * @embedpdf/vue/stamp: the Vue view of `@embedpdf/plugin-stamp`.\n *\n * Thin by design: the plugin owns the libraries, their stamps and the cached\n * previews; this entry gives them to Vue as refs, and owns the one DOM\n * resource a picker needs, the object URL of a stamp's preview. Placing needs\n * no component here: an armed stamp rides the annotation plugin, whose\n * `<AnnotationLayer>` draws the ghost under the pointer.\n *\n *   const stamp = useStamp();\n *   const assets = useStampAssets(() => ({ libraryId: props.libraryId }));\n *   const { armedAsset } = useStampState();\n *   await stamp.armAsset(assetId); // the next click places it\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-stamp';\n// The browser store for `persistStampLibraries` / `restoreStampLibraries`\n// (structurally the plugin's `StampLibraryStore`), written once in `@embedpdf/web`.\nexport { indexedDbByteStore } from '@embedpdf/web';\nexport type { ByteStore } from '@embedpdf/web';\nimport { shallowRef, toValue, watch } from 'vue';\nimport type { MaybeRefOrGetter, Ref } from 'vue';\nimport { objectUrlOf } from '@embedpdf/web';\nimport { shallowEqual } from '@embedpdf/core';\nimport type { EventHook } from '@embedpdf/core';\nimport { StampToken, stampState } from '@embedpdf/plugin-stamp';\nimport type {\n  StampAsset,\n  StampAssetFilter,\n  StampCapability,\n  StampLibrary,\n  StampLibraryFilter,\n} from '@embedpdf/plugin-stamp';\nimport {\n  useCapability,\n  useCapabilityEvent,\n  useOptionalSelector,\n  useSelector,\n} from './runtime/capabilities';\nimport { settingsComposable, stateComposable } from './state';\n\n/**\n * The stamp API. Libraries are shared by every document; the placing verbs\n * (`armAsset`, `placeAsset`, …) act on the nearest `<DocumentScope>`'s\n * document, else the active one. The object never changes, so keep it whole:\n * `stamp.armAsset(id)`.\n */\nexport function useStamp(): StampCapability {\n  return useCapability(StampToken);\n}\n\n/** Subscribe to one stamp event while the component lives: `useStampEvent((stamp) => stamp.onLibraryChanged, handler)`. */\nexport function useStampEvent<Event>(\n  select: (stamp: StampCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(StampToken, select, handler);\n}\n\n/**\n * The stamps' state for this component's document as refs: the armed stamp\n * (the page's State table, declared once in `stampState`). With a selector,\n * one ref that updates only when the value it picks changes.\n */\nexport const useStampState = stateComposable(stampState);\n\n/** The stamp settings (`assetEngine`, `previewWidth`, `dynamic`), with or without a document, as refs. Takes a selector. */\nexport const useStampSettings = settingsComposable(StampToken);\n\n/**\n * The libraries as a ref, optionally of one kind or several\n * (`{ kind: 'stamps' }`, `{ kind: ['stamps', 'legal-seals'] }`; a getter to\n * follow a prop). It updates when a library is added, renamed or removed.\n */\nexport function useStampLibraries(\n  filter?: MaybeRefOrGetter<StampLibraryFilter | undefined>,\n): Readonly<Ref<readonly StampLibrary[]>> {\n  // Every read is a new array: compared item by item, the ref updates only\n  // when the libraries themselves change.\n  return useSelector(StampToken, (stamp) => stamp.listLibraries(toValue(filter)), shallowEqual);\n}\n\n/**\n * The stamps as a ref: one library's (`{ libraryId }`), one kind's or\n * category's, or every stamp, in the order a picker shows them. Pass a getter\n * to follow a prop or a ref: `useStampAssets(() => ({ libraryId: library.value?.id }))`.\n */\nexport function useStampAssets(\n  filter?: MaybeRefOrGetter<StampAssetFilter | undefined>,\n): Readonly<Ref<readonly StampAsset[]>> {\n  // Compared item by item, like the libraries: every read is a new array.\n  return useSelector(StampToken, (stamp) => stamp.listAssets(toValue(filter)), shallowEqual);\n}\n\n/**\n * An image URL for a stamp's cached preview (a gallery thumbnail), as a ref,\n * or null while there is none. Pass a getter to follow a prop:\n * `useStampAssetPreviewUrl(() => props.assetId)`.\n *\n * The plugin holds the preview's bytes; the URL is a DOM resource, so it is\n * made here and revoked when the asset changes or the component unmounts,\n * the same rule `<AnnotationLayer>` follows for the pictures it shows.\n */\nexport function useStampAssetPreviewUrl(\n  assetId: MaybeRefOrGetter<string | null>,\n): Readonly<Ref<string | null>> {\n  // The preview itself, read on every change: it follows the asset, and a\n  // preview that arrives after the asset does.\n  const preview = useOptionalSelector(\n    StampToken,\n    (stamp) => {\n      const id = toValue(assetId);\n      return id ? stamp.getAssetPreview(id) : null;\n    },\n    null,\n  );\n  const url = shallowRef<string | null>(null);\n  watch(\n    preview,\n    (current, _previous, onCleanup) => {\n      if (!current) {\n        url.value = null;\n        return;\n      }\n      const objectUrl = objectUrlOf(current);\n      url.value = objectUrl.url;\n      onCleanup(() => {\n        objectUrl.revoke();\n        url.value = null;\n      });\n    },\n    { immediate: true },\n  );\n  return url;\n}\n"],"names":["useCapability","StampToken","useCapabilityEvent","stateComposable","stampState","settingsComposable","useSelector","toValue","shallowEqual","useOptionalSelector","shallowRef","watch","objectUrlOf"],"mappings":";;;;;;;;AAgDO,SAAS,WAA4B;AAC1C,SAAOA,aAAAA,cAAcC,YAAAA,UAAU;AACjC;AAGO,SAAS,cACd,QACA,SACM;AACNC,kCAAmBD,YAAAA,YAAY,QAAQ,OAAO;AAChD;AAOO,MAAM,gBAAgBE,MAAAA,gBAAgBC,YAAAA,UAAU;AAGhD,MAAM,mBAAmBC,MAAAA,mBAAmBJ,YAAAA,UAAU;AAOtD,SAAS,kBACd,QACwC;AAGxC,SAAOK,aAAAA,YAAYL,wBAAY,CAAC,UAAU,MAAM,cAAcM,YAAQ,MAAM,CAAC,GAAGC,iBAAY;AAC9F;AAOO,SAAS,eACd,QACsC;AAEtC,SAAOF,aAAAA,YAAYL,wBAAY,CAAC,UAAU,MAAM,WAAWM,YAAQ,MAAM,CAAC,GAAGC,iBAAY;AAC3F;AAWO,SAAS,wBACd,SAC8B;AAG9B,QAAM,UAAUC,aAAAA;AAAAA,IACdR,YAAAA;AAAAA,IACA,CAAC,UAAU;AACT,YAAM,KAAKM,IAAAA,QAAQ,OAAO;AAC1B,aAAO,KAAK,MAAM,gBAAgB,EAAE,IAAI;AAAA,IAC1C;AAAA,IACA;AAAA,EAAA;AAEF,QAAM,MAAMG,IAAAA,WAA0B,IAAI;AAC1CC,MAAAA;AAAAA,IACE;AAAA,IACA,CAAC,SAAS,WAAW,cAAc;AACjC,UAAI,CAAC,SAAS;AACZ,YAAI,QAAQ;AACZ;AAAA,MACF;AACA,YAAM,YAAYC,IAAAA,YAAY,OAAO;AACrC,UAAI,QAAQ,UAAU;AACtB,gBAAU,MAAM;AACd,kBAAU,OAAA;AACV,YAAI,QAAQ;AAAA,MACd,CAAC;AAAA,IACH;AAAA,IACA,EAAE,WAAW,KAAA;AAAA,EAAK;AAEpB,SAAO;AACT;;;;;;;;;;;;;;;;;;"}

package/dist/stamp.d.cts

@@ -0,0 +1,61 @@
+/**
+ * @embedpdf/vue/stamp: the Vue view of `@embedpdf/plugin-stamp`.
+ *
+ * Thin by design: the plugin owns the libraries, their stamps and the cached
+ * previews; this entry gives them to Vue as refs, and owns the one DOM
+ * resource a picker needs, the object URL of a stamp's preview. Placing needs
+ * no component here: an armed stamp rides the annotation plugin, whose
+ * `<AnnotationLayer>` draws the ghost under the pointer.
+ *
+ *   const stamp = useStamp();
+ *   const assets = useStampAssets(() => ({ libraryId: props.libraryId }));
+ *   const { armedAsset } = useStampState();
+ *   await stamp.armAsset(assetId); // the next click places it
+ */
+export * from '@embedpdf/plugin-stamp';
+export { indexedDbByteStore } from '@embedpdf/web';
+export type { ByteStore } from '@embedpdf/web';
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { EventHook } from '@embedpdf/core';
+import type { StampAsset, StampAssetFilter, StampCapability, StampLibrary, StampLibraryFilter } from '@embedpdf/plugin-stamp';
+/**
+ * The stamp API. Libraries are shared by every document; the placing verbs
+ * (`armAsset`, `placeAsset`, …) act on the nearest `<DocumentScope>`'s
+ * document, else the active one. The object never changes, so keep it whole:
+ * `stamp.armAsset(id)`.
+ */
+export declare function useStamp(): StampCapability;
+/** Subscribe to one stamp event while the component lives: `useStampEvent((stamp) => stamp.onLibraryChanged, handler)`. */
+export declare function useStampEvent<Event>(select: (stamp: StampCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The stamps' state for this component's document as refs: the armed stamp
+ * (the page's State table, declared once in `stampState`). With a selector,
+ * one ref that updates only when the value it picks changes.
+ */
+export declare const useStampState: import("./state.cjs").StateComposable<{
+    armedAsset: StampAsset | null;
+}>;
+/** The stamp settings (`assetEngine`, `previewWidth`, `dynamic`), with or without a document, as refs. Takes a selector. */
+export declare const useStampSettings: import("./state.cjs").SettingsComposable<import("@embedpdf/plugin-stamp").StampSettings & object>;
+/**
+ * The libraries as a ref, optionally of one kind or several
+ * (`{ kind: 'stamps' }`, `{ kind: ['stamps', 'legal-seals'] }`; a getter to
+ * follow a prop). It updates when a library is added, renamed or removed.
+ */
+export declare function useStampLibraries(filter?: MaybeRefOrGetter<StampLibraryFilter | undefined>): Readonly<Ref<readonly StampLibrary[]>>;
+/**
+ * The stamps as a ref: one library's (`{ libraryId }`), one kind's or
+ * category's, or every stamp, in the order a picker shows them. Pass a getter
+ * to follow a prop or a ref: `useStampAssets(() => ({ libraryId: library.value?.id }))`.
+ */
+export declare function useStampAssets(filter?: MaybeRefOrGetter<StampAssetFilter | undefined>): Readonly<Ref<readonly StampAsset[]>>;
+/**
+ * An image URL for a stamp's cached preview (a gallery thumbnail), as a ref,
+ * or null while there is none. Pass a getter to follow a prop:
+ * `useStampAssetPreviewUrl(() => props.assetId)`.
+ *
+ * The plugin holds the preview's bytes; the URL is a DOM resource, so it is
+ * made here and revoked when the asset changes or the component unmounts,
+ * the same rule `<AnnotationLayer>` follows for the pictures it shows.
+ */
+export declare function useStampAssetPreviewUrl(assetId: MaybeRefOrGetter<string | null>): Readonly<Ref<string | null>>;

package/dist/stamp.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @embedpdf/vue/stamp: the Vue view of `@embedpdf/plugin-stamp`.
+ *
+ * Thin by design: the plugin owns the libraries, their stamps and the cached
+ * previews; this entry gives them to Vue as refs, and owns the one DOM
+ * resource a picker needs, the object URL of a stamp's preview. Placing needs
+ * no component here: an armed stamp rides the annotation plugin, whose
+ * `<AnnotationLayer>` draws the ghost under the pointer.
+ *
+ *   const stamp = useStamp();
+ *   const assets = useStampAssets(() => ({ libraryId: props.libraryId }));
+ *   const { armedAsset } = useStampState();
+ *   await stamp.armAsset(assetId); // the next click places it
+ */
+export * from '@embedpdf/plugin-stamp';
+export { indexedDbByteStore } from '@embedpdf/web';
+export type { ByteStore } from '@embedpdf/web';
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { EventHook } from '@embedpdf/core';
+import type { StampAsset, StampAssetFilter, StampCapability, StampLibrary, StampLibraryFilter } from '@embedpdf/plugin-stamp';
+/**
+ * The stamp API. Libraries are shared by every document; the placing verbs
+ * (`armAsset`, `placeAsset`, …) act on the nearest `<DocumentScope>`'s
+ * document, else the active one. The object never changes, so keep it whole:
+ * `stamp.armAsset(id)`.
+ */
+export declare function useStamp(): StampCapability;
+/** Subscribe to one stamp event while the component lives: `useStampEvent((stamp) => stamp.onLibraryChanged, handler)`. */
+export declare function useStampEvent<Event>(select: (stamp: StampCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The stamps' state for this component's document as refs: the armed stamp
+ * (the page's State table, declared once in `stampState`). With a selector,
+ * one ref that updates only when the value it picks changes.
+ */
+export declare const useStampState: import("./state.js").StateComposable<{
+    armedAsset: StampAsset | null;
+}>;
+/** The stamp settings (`assetEngine`, `previewWidth`, `dynamic`), with or without a document, as refs. Takes a selector. */
+export declare const useStampSettings: import("./state.js").SettingsComposable<import("@embedpdf/plugin-stamp").StampSettings & object>;
+/**
+ * The libraries as a ref, optionally of one kind or several
+ * (`{ kind: 'stamps' }`, `{ kind: ['stamps', 'legal-seals'] }`; a getter to
+ * follow a prop). It updates when a library is added, renamed or removed.
+ */
+export declare function useStampLibraries(filter?: MaybeRefOrGetter<StampLibraryFilter | undefined>): Readonly<Ref<readonly StampLibrary[]>>;
+/**
+ * The stamps as a ref: one library's (`{ libraryId }`), one kind's or
+ * category's, or every stamp, in the order a picker shows them. Pass a getter
+ * to follow a prop or a ref: `useStampAssets(() => ({ libraryId: library.value?.id }))`.
+ */
+export declare function useStampAssets(filter?: MaybeRefOrGetter<StampAssetFilter | undefined>): Readonly<Ref<readonly StampAsset[]>>;
+/**
+ * An image URL for a stamp's cached preview (a gallery thumbnail), as a ref,
+ * or null while there is none. Pass a getter to follow a prop:
+ * `useStampAssetPreviewUrl(() => props.assetId)`.
+ *
+ * The plugin holds the preview's bytes; the URL is a DOM resource, so it is
+ * made here and revoked when the asset changes or the component unmounts,
+ * the same rule `<AnnotationLayer>` follows for the pictures it shows.
+ */
+export declare function useStampAssetPreviewUrl(assetId: MaybeRefOrGetter<string | null>): Readonly<Ref<string | null>>;

package/dist/stamp.js

@@ -0,0 +1,61 @@
+import { StampToken, stampState } from "@embedpdf/plugin-stamp";
+export * from "@embedpdf/plugin-stamp";
+import { objectUrlOf } from "@embedpdf/web";
+import { indexedDbByteStore } from "@embedpdf/web";
+import { shallowRef, watch, toValue } from "vue";
+import { shallowEqual } from "@embedpdf/core";
+import { a as useCapability, i as useOptionalSelector, j as useSelector, b as useCapabilityEvent } from "./capabilities-C7YzgPCX.js";
+import { s as settingsComposable, a as stateComposable } from "./state-DZg8q3v6.js";
+function useStamp() {
+  return useCapability(StampToken);
+}
+function useStampEvent(select, handler) {
+  useCapabilityEvent(StampToken, select, handler);
+}
+const useStampState = stateComposable(stampState);
+const useStampSettings = settingsComposable(StampToken);
+function useStampLibraries(filter) {
+  return useSelector(StampToken, (stamp) => stamp.listLibraries(toValue(filter)), shallowEqual);
+}
+function useStampAssets(filter) {
+  return useSelector(StampToken, (stamp) => stamp.listAssets(toValue(filter)), shallowEqual);
+}
+function useStampAssetPreviewUrl(assetId) {
+  const preview = useOptionalSelector(
+    StampToken,
+    (stamp) => {
+      const id = toValue(assetId);
+      return id ? stamp.getAssetPreview(id) : null;
+    },
+    null
+  );
+  const url = shallowRef(null);
+  watch(
+    preview,
+    (current, _previous, onCleanup) => {
+      if (!current) {
+        url.value = null;
+        return;
+      }
+      const objectUrl = objectUrlOf(current);
+      url.value = objectUrl.url;
+      onCleanup(() => {
+        objectUrl.revoke();
+        url.value = null;
+      });
+    },
+    { immediate: true }
+  );
+  return url;
+}
+export {
+  indexedDbByteStore,
+  useStamp,
+  useStampAssetPreviewUrl,
+  useStampAssets,
+  useStampEvent,
+  useStampLibraries,
+  useStampSettings,
+  useStampState
+};
+//# sourceMappingURL=stamp.js.map

package/dist/stamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stamp.js","sources":["../src/stamp.ts"],"sourcesContent":["/**\n * @embedpdf/vue/stamp: the Vue view of `@embedpdf/plugin-stamp`.\n *\n * Thin by design: the plugin owns the libraries, their stamps and the cached\n * previews; this entry gives them to Vue as refs, and owns the one DOM\n * resource a picker needs, the object URL of a stamp's preview. Placing needs\n * no component here: an armed stamp rides the annotation plugin, whose\n * `<AnnotationLayer>` draws the ghost under the pointer.\n *\n *   const stamp = useStamp();\n *   const assets = useStampAssets(() => ({ libraryId: props.libraryId }));\n *   const { armedAsset } = useStampState();\n *   await stamp.armAsset(assetId); // the next click places it\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-stamp';\n// The browser store for `persistStampLibraries` / `restoreStampLibraries`\n// (structurally the plugin's `StampLibraryStore`), written once in `@embedpdf/web`.\nexport { indexedDbByteStore } from '@embedpdf/web';\nexport type { ByteStore } from '@embedpdf/web';\nimport { shallowRef, toValue, watch } from 'vue';\nimport type { MaybeRefOrGetter, Ref } from 'vue';\nimport { objectUrlOf } from '@embedpdf/web';\nimport { shallowEqual } from '@embedpdf/core';\nimport type { EventHook } from '@embedpdf/core';\nimport { StampToken, stampState } from '@embedpdf/plugin-stamp';\nimport type {\n  StampAsset,\n  StampAssetFilter,\n  StampCapability,\n  StampLibrary,\n  StampLibraryFilter,\n} from '@embedpdf/plugin-stamp';\nimport {\n  useCapability,\n  useCapabilityEvent,\n  useOptionalSelector,\n  useSelector,\n} from './runtime/capabilities';\nimport { settingsComposable, stateComposable } from './state';\n\n/**\n * The stamp API. Libraries are shared by every document; the placing verbs\n * (`armAsset`, `placeAsset`, …) act on the nearest `<DocumentScope>`'s\n * document, else the active one. The object never changes, so keep it whole:\n * `stamp.armAsset(id)`.\n */\nexport function useStamp(): StampCapability {\n  return useCapability(StampToken);\n}\n\n/** Subscribe to one stamp event while the component lives: `useStampEvent((stamp) => stamp.onLibraryChanged, handler)`. */\nexport function useStampEvent<Event>(\n  select: (stamp: StampCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(StampToken, select, handler);\n}\n\n/**\n * The stamps' state for this component's document as refs: the armed stamp\n * (the page's State table, declared once in `stampState`). With a selector,\n * one ref that updates only when the value it picks changes.\n */\nexport const useStampState = stateComposable(stampState);\n\n/** The stamp settings (`assetEngine`, `previewWidth`, `dynamic`), with or without a document, as refs. Takes a selector. */\nexport const useStampSettings = settingsComposable(StampToken);\n\n/**\n * The libraries as a ref, optionally of one kind or several\n * (`{ kind: 'stamps' }`, `{ kind: ['stamps', 'legal-seals'] }`; a getter to\n * follow a prop). It updates when a library is added, renamed or removed.\n */\nexport function useStampLibraries(\n  filter?: MaybeRefOrGetter<StampLibraryFilter | undefined>,\n): Readonly<Ref<readonly StampLibrary[]>> {\n  // Every read is a new array: compared item by item, the ref updates only\n  // when the libraries themselves change.\n  return useSelector(StampToken, (stamp) => stamp.listLibraries(toValue(filter)), shallowEqual);\n}\n\n/**\n * The stamps as a ref: one library's (`{ libraryId }`), one kind's or\n * category's, or every stamp, in the order a picker shows them. Pass a getter\n * to follow a prop or a ref: `useStampAssets(() => ({ libraryId: library.value?.id }))`.\n */\nexport function useStampAssets(\n  filter?: MaybeRefOrGetter<StampAssetFilter | undefined>,\n): Readonly<Ref<readonly StampAsset[]>> {\n  // Compared item by item, like the libraries: every read is a new array.\n  return useSelector(StampToken, (stamp) => stamp.listAssets(toValue(filter)), shallowEqual);\n}\n\n/**\n * An image URL for a stamp's cached preview (a gallery thumbnail), as a ref,\n * or null while there is none. Pass a getter to follow a prop:\n * `useStampAssetPreviewUrl(() => props.assetId)`.\n *\n * The plugin holds the preview's bytes; the URL is a DOM resource, so it is\n * made here and revoked when the asset changes or the component unmounts,\n * the same rule `<AnnotationLayer>` follows for the pictures it shows.\n */\nexport function useStampAssetPreviewUrl(\n  assetId: MaybeRefOrGetter<string | null>,\n): Readonly<Ref<string | null>> {\n  // The preview itself, read on every change: it follows the asset, and a\n  // preview that arrives after the asset does.\n  const preview = useOptionalSelector(\n    StampToken,\n    (stamp) => {\n      const id = toValue(assetId);\n      return id ? stamp.getAssetPreview(id) : null;\n    },\n    null,\n  );\n  const url = shallowRef<string | null>(null);\n  watch(\n    preview,\n    (current, _previous, onCleanup) => {\n      if (!current) {\n        url.value = null;\n        return;\n      }\n      const objectUrl = objectUrlOf(current);\n      url.value = objectUrl.url;\n      onCleanup(() => {\n        objectUrl.revoke();\n        url.value = null;\n      });\n    },\n    { immediate: true },\n  );\n  return url;\n}\n"],"names":[],"mappings":";;;;;;;;AAgDO,SAAS,WAA4B;AAC1C,SAAO,cAAc,UAAU;AACjC;AAGO,SAAS,cACd,QACA,SACM;AACN,qBAAmB,YAAY,QAAQ,OAAO;AAChD;AAOO,MAAM,gBAAgB,gBAAgB,UAAU;AAGhD,MAAM,mBAAmB,mBAAmB,UAAU;AAOtD,SAAS,kBACd,QACwC;AAGxC,SAAO,YAAY,YAAY,CAAC,UAAU,MAAM,cAAc,QAAQ,MAAM,CAAC,GAAG,YAAY;AAC9F;AAOO,SAAS,eACd,QACsC;AAEtC,SAAO,YAAY,YAAY,CAAC,UAAU,MAAM,WAAW,QAAQ,MAAM,CAAC,GAAG,YAAY;AAC3F;AAWO,SAAS,wBACd,SAC8B;AAG9B,QAAM,UAAU;AAAA,IACd;AAAA,IACA,CAAC,UAAU;AACT,YAAM,KAAK,QAAQ,OAAO;AAC1B,aAAO,KAAK,MAAM,gBAAgB,EAAE,IAAI;AAAA,IAC1C;AAAA,IACA;AAAA,EAAA;AAEF,QAAM,MAAM,WAA0B,IAAI;AAC1C;AAAA,IACE;AAAA,IACA,CAAC,SAAS,WAAW,cAAc;AACjC,UAAI,CAAC,SAAS;AACZ,YAAI,QAAQ;AACZ;AAAA,MACF;AACA,YAAM,YAAY,YAAY,OAAO;AACrC,UAAI,QAAQ,UAAU;AACtB,gBAAU,MAAM;AACd,kBAAU,OAAA;AACV,YAAI,QAAQ;AAAA,MACd,CAAC;AAAA,IACH;AAAA,IACA,EAAE,WAAW,KAAA;AAAA,EAAK;AAEpB,SAAO;AACT;"}

package/dist/state-DZg8q3v6.js

@@ -0,0 +1,52 @@
+import { shallowEqual } from "@embedpdf/core";
+import { computed, watch } from "vue";
+import { g as useKernelValue, e as useDocumentScope } from "./capabilities-C7YzgPCX.js";
+function fieldRefs(whole, keys = Object.keys(whole.value)) {
+  return Object.freeze(
+    Object.fromEntries(
+      keys.map((key) => [key, computed(() => whole.value[key])])
+    )
+  );
+}
+function stateComposable(declaration) {
+  function useDeclaredState(select) {
+    const scope = useDocumentScope();
+    const { ensure } = declaration;
+    if (ensure) {
+      const capability = useKernelValue(
+        (kernel) => kernel.tryCapability(declaration.token, scope.value ?? void 0)
+      );
+      watch(
+        capability,
+        (current) => {
+          if (current) ensure(current).catch(() => {
+          });
+        },
+        { immediate: true }
+      );
+    }
+    const value = useKernelValue((kernel) => {
+      const capability = kernel.tryCapability(declaration.token, scope.value ?? void 0);
+      const state = capability ? declaration.read(capability) : declaration.empty;
+      return select ? select(state) : state;
+    }, shallowEqual);
+    return select ? value : fieldRefs(value, Object.keys(declaration.empty));
+  }
+  return useDeclaredState;
+}
+function settingsComposable(token) {
+  function useSettings(select) {
+    const value = useKernelValue((kernel) => {
+      const settings = kernel.settingsOf(token).getSettings();
+      return select ? select(settings) : settings;
+    }, shallowEqual);
+    return select ? value : fieldRefs(value);
+  }
+  return useSettings;
+}
+export {
+  stateComposable as a,
+  fieldRefs as f,
+  settingsComposable as s
+};
+//# sourceMappingURL=state-DZg8q3v6.js.map

package/dist/state-DZg8q3v6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-DZg8q3v6.js","sources":["../src/runtime/refs.ts","../src/state.ts"],"sourcesContent":["/**\n * A record read as refs, one per field: what a state or settings composable\n * returns without a selector, so `const { zoomLevel } = useStageState()` keeps\n * `zoomLevel` reactive after destructuring, and a template reads it unwrapped.\n */\nimport { computed } from 'vue';\nimport type { Ref } from 'vue';\n\n/** One read-only ref per field of `Value`. */\nexport type FieldRefs<Value extends object> = {\n  readonly [Key in keyof Value]-?: Readonly<Ref<Value[Key]>>;\n};\n\n/**\n * One computed ref per field of `whole`. Each field updates only when its own\n * value changes. The fields are the ones `whole` has now (`keys` names them\n * when they are known without a value): records read this way keep their\n * fields.\n */\nexport function fieldRefs<Value extends object>(\n  whole: Readonly<Ref<Value>>,\n  keys: readonly string[] = Object.keys(whole.value),\n): FieldRefs<Value> {\n  return Object.freeze(\n    Object.fromEntries(\n      keys.map((key) => [key, computed(() => (whole.value as Record<string, unknown>)[key])]),\n    ),\n  ) as unknown as FieldRefs<Value>;\n}\n","/**\n * Declared state and settings as Vue composables. A plugin declares its state\n * once with `defineState` and its settings once in its definition (both in\n * `@embedpdf/core`), and its Vue bindings are one line each:\n *\n *   export const useSearchState = stateComposable(searchState);\n *   export const useSearchSettings = settingsComposable(SearchToken);\n *\n * Without a selector they return one ref per field; with one, a single ref.\n */\nimport { shallowEqual } from '@embedpdf/core';\nimport type { CapabilityToken, SettingsOf, StateDeclaration } from '@embedpdf/core';\nimport { watch, type Ref } from 'vue';\nimport { useDocumentScope, useKernelValue } from './runtime/kernel';\nimport { fieldRefs } from './runtime/refs';\nimport type { FieldRefs } from './runtime/refs';\n\nexport type { FieldRefs } from './runtime/refs';\n\n/** A declared state's composable: refs for every field, or one ref for the value `select` picks. */\nexport interface StateComposable<State extends object> {\n  (): FieldRefs<State>;\n  <Selected>(select: (state: State) => Selected): Readonly<Ref<Selected>>;\n}\n\n/** A plugin's settings composable: refs for every setting, or one ref for the value `select` picks. */\nexport interface SettingsComposable<Settings extends object> {\n  (): FieldRefs<Settings>;\n  <Selected>(select: (settings: Settings) => Selected): Readonly<Ref<Selected>>;\n}\n\n/**\n * Turn a state declaration into its composable. It reads this subtree's\n * document (the nearest `<DocumentScope>`, else the active one) and reads the\n * declaration's `empty` while that document is missing or not ready, so it\n * works anywhere. A ref updates only when its value changes: the state, or the\n * value `select` picks from it, is compared with {@link shallowEqual}. State the\n * plugin loads on demand (the declaration's `ensure`) loads once a ready\n * document's capability is in scope, for every document the composable reads.\n */\nexport function stateComposable<Capability, State extends object>(\n  declaration: StateDeclaration<Capability, State>,\n): StateComposable<State> {\n  function useDeclaredState(): FieldRefs<State>;\n  function useDeclaredState<Selected>(select: (state: State) => Selected): Readonly<Ref<Selected>>;\n  function useDeclaredState<Selected>(select?: (state: State) => Selected) {\n    const scope = useDocumentScope();\n    const { ensure } = declaration;\n    if (ensure) {\n      const capability = useKernelValue((kernel) =>\n        kernel.tryCapability(declaration.token, scope.value ?? undefined),\n      );\n      // The state says when the load fails (its status), so the rejection has nothing to add.\n      watch(\n        capability,\n        (current) => {\n          if (current) ensure(current).catch(() => {});\n        },\n        { immediate: true },\n      );\n    }\n    // Resolved on every read: a document that closes reads as `empty` from\n    // then on, never through its closed capability.\n    const value = useKernelValue((kernel) => {\n      const capability = kernel.tryCapability(declaration.token, scope.value ?? undefined);\n      const state = capability ? declaration.read(capability) : declaration.empty;\n      return select ? select(state) : state;\n    }, shallowEqual);\n    return select\n      ? value\n      : fieldRefs(value as Readonly<Ref<State>>, Object.keys(declaration.empty));\n  }\n  return useDeclaredState;\n}\n\n/**\n * Turn a plugin's token into its settings composable. A plugin's settings\n * belong to the plugin as the app registered it, not to a document, so it\n * reads them through the kernel (`kernel.settingsOf`): it works before the\n * first document opens, and every document shows the same settings. A token\n * whose plugin isn't installed, or has no settings, throws: a setup mistake.\n */\nexport function settingsComposable<Capability>(\n  token: CapabilityToken<Capability>,\n): SettingsComposable<SettingsOf<Capability> & object> {\n  type Settings = SettingsOf<Capability> & object;\n  function useSettings(): FieldRefs<Settings>;\n  function useSettings<Selected>(select: (settings: Settings) => Selected): Readonly<Ref<Selected>>;\n  function useSettings<Selected>(select?: (settings: Settings) => Selected) {\n    const value = useKernelValue((kernel) => {\n      const settings = kernel.settingsOf(token).getSettings() as Settings;\n      return select ? select(settings) : settings;\n    }, shallowEqual);\n    return select ? value : fieldRefs(value as Readonly<Ref<Settings>>);\n  }\n  return useSettings;\n}\n"],"names":[],"mappings":";;;AAmBO,SAAS,UACd,OACA,OAA0B,OAAO,KAAK,MAAM,KAAK,GAC/B;AAClB,SAAO,OAAO;AAAA,IACZ,OAAO;AAAA,MACL,KAAK,IAAI,CAAC,QAAQ,CAAC,KAAK,SAAS,MAAO,MAAM,MAAkC,GAAG,CAAC,CAAC,CAAC;AAAA,IAAA;AAAA,EACxF;AAEJ;ACYO,SAAS,gBACd,aACwB;AAGxB,WAAS,iBAA2B,QAAqC;AACvE,UAAM,QAAQ,iBAAA;AACd,UAAM,EAAE,WAAW;AACnB,QAAI,QAAQ;AACV,YAAM,aAAa;AAAA,QAAe,CAAC,WACjC,OAAO,cAAc,YAAY,OAAO,MAAM,SAAS,MAAS;AAAA,MAAA;AAGlE;AAAA,QACE;AAAA,QACA,CAAC,YAAY;AACX,cAAI,QAAS,QAAO,OAAO,EAAE,MAAM,MAAM;AAAA,UAAC,CAAC;AAAA,QAC7C;AAAA,QACA,EAAE,WAAW,KAAA;AAAA,MAAK;AAAA,IAEtB;AAGA,UAAM,QAAQ,eAAe,CAAC,WAAW;AACvC,YAAM,aAAa,OAAO,cAAc,YAAY,OAAO,MAAM,SAAS,MAAS;AACnF,YAAM,QAAQ,aAAa,YAAY,KAAK,UAAU,IAAI,YAAY;AACtE,aAAO,SAAS,OAAO,KAAK,IAAI;AAAA,IAClC,GAAG,YAAY;AACf,WAAO,SACH,QACA,UAAU,OAA+B,OAAO,KAAK,YAAY,KAAK,CAAC;AAAA,EAC7E;AACA,SAAO;AACT;AASO,SAAS,mBACd,OACqD;AAIrD,WAAS,YAAsB,QAA2C;AACxE,UAAM,QAAQ,eAAe,CAAC,WAAW;AACvC,YAAM,WAAW,OAAO,WAAW,KAAK,EAAE,YAAA;AAC1C,aAAO,SAAS,OAAO,QAAQ,IAAI;AAAA,IACrC,GAAG,YAAY;AACf,WAAO,SAAS,QAAQ,UAAU,KAAgC;AAAA,EACpE;AACA,SAAO;AACT;"}

package/dist/state-M22NDJQo.cjs

@@ -0,0 +1,51 @@
+"use strict";
+const core = require("@embedpdf/core");
+const vue = require("vue");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+function fieldRefs(whole, keys = Object.keys(whole.value)) {
+  return Object.freeze(
+    Object.fromEntries(
+      keys.map((key) => [key, vue.computed(() => whole.value[key])])
+    )
+  );
+}
+function stateComposable(declaration) {
+  function useDeclaredState(select) {
+    const scope = capabilities.useDocumentScope();
+    const { ensure } = declaration;
+    if (ensure) {
+      const capability = capabilities.useKernelValue(
+        (kernel) => kernel.tryCapability(declaration.token, scope.value ?? void 0)
+      );
+      vue.watch(
+        capability,
+        (current) => {
+          if (current) ensure(current).catch(() => {
+          });
+        },
+        { immediate: true }
+      );
+    }
+    const value = capabilities.useKernelValue((kernel) => {
+      const capability = kernel.tryCapability(declaration.token, scope.value ?? void 0);
+      const state = capability ? declaration.read(capability) : declaration.empty;
+      return select ? select(state) : state;
+    }, core.shallowEqual);
+    return select ? value : fieldRefs(value, Object.keys(declaration.empty));
+  }
+  return useDeclaredState;
+}
+function settingsComposable(token) {
+  function useSettings(select) {
+    const value = capabilities.useKernelValue((kernel) => {
+      const settings = kernel.settingsOf(token).getSettings();
+      return select ? select(settings) : settings;
+    }, core.shallowEqual);
+    return select ? value : fieldRefs(value);
+  }
+  return useSettings;
+}
+exports.fieldRefs = fieldRefs;
+exports.settingsComposable = settingsComposable;
+exports.stateComposable = stateComposable;
+//# sourceMappingURL=state-M22NDJQo.cjs.map

package/dist/state-M22NDJQo.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-M22NDJQo.cjs","sources":["../src/runtime/refs.ts","../src/state.ts"],"sourcesContent":["/**\n * A record read as refs, one per field: what a state or settings composable\n * returns without a selector, so `const { zoomLevel } = useStageState()` keeps\n * `zoomLevel` reactive after destructuring, and a template reads it unwrapped.\n */\nimport { computed } from 'vue';\nimport type { Ref } from 'vue';\n\n/** One read-only ref per field of `Value`. */\nexport type FieldRefs<Value extends object> = {\n  readonly [Key in keyof Value]-?: Readonly<Ref<Value[Key]>>;\n};\n\n/**\n * One computed ref per field of `whole`. Each field updates only when its own\n * value changes. The fields are the ones `whole` has now (`keys` names them\n * when they are known without a value): records read this way keep their\n * fields.\n */\nexport function fieldRefs<Value extends object>(\n  whole: Readonly<Ref<Value>>,\n  keys: readonly string[] = Object.keys(whole.value),\n): FieldRefs<Value> {\n  return Object.freeze(\n    Object.fromEntries(\n      keys.map((key) => [key, computed(() => (whole.value as Record<string, unknown>)[key])]),\n    ),\n  ) as unknown as FieldRefs<Value>;\n}\n","/**\n * Declared state and settings as Vue composables. A plugin declares its state\n * once with `defineState` and its settings once in its definition (both in\n * `@embedpdf/core`), and its Vue bindings are one line each:\n *\n *   export const useSearchState = stateComposable(searchState);\n *   export const useSearchSettings = settingsComposable(SearchToken);\n *\n * Without a selector they return one ref per field; with one, a single ref.\n */\nimport { shallowEqual } from '@embedpdf/core';\nimport type { CapabilityToken, SettingsOf, StateDeclaration } from '@embedpdf/core';\nimport { watch, type Ref } from 'vue';\nimport { useDocumentScope, useKernelValue } from './runtime/kernel';\nimport { fieldRefs } from './runtime/refs';\nimport type { FieldRefs } from './runtime/refs';\n\nexport type { FieldRefs } from './runtime/refs';\n\n/** A declared state's composable: refs for every field, or one ref for the value `select` picks. */\nexport interface StateComposable<State extends object> {\n  (): FieldRefs<State>;\n  <Selected>(select: (state: State) => Selected): Readonly<Ref<Selected>>;\n}\n\n/** A plugin's settings composable: refs for every setting, or one ref for the value `select` picks. */\nexport interface SettingsComposable<Settings extends object> {\n  (): FieldRefs<Settings>;\n  <Selected>(select: (settings: Settings) => Selected): Readonly<Ref<Selected>>;\n}\n\n/**\n * Turn a state declaration into its composable. It reads this subtree's\n * document (the nearest `<DocumentScope>`, else the active one) and reads the\n * declaration's `empty` while that document is missing or not ready, so it\n * works anywhere. A ref updates only when its value changes: the state, or the\n * value `select` picks from it, is compared with {@link shallowEqual}. State the\n * plugin loads on demand (the declaration's `ensure`) loads once a ready\n * document's capability is in scope, for every document the composable reads.\n */\nexport function stateComposable<Capability, State extends object>(\n  declaration: StateDeclaration<Capability, State>,\n): StateComposable<State> {\n  function useDeclaredState(): FieldRefs<State>;\n  function useDeclaredState<Selected>(select: (state: State) => Selected): Readonly<Ref<Selected>>;\n  function useDeclaredState<Selected>(select?: (state: State) => Selected) {\n    const scope = useDocumentScope();\n    const { ensure } = declaration;\n    if (ensure) {\n      const capability = useKernelValue((kernel) =>\n        kernel.tryCapability(declaration.token, scope.value ?? undefined),\n      );\n      // The state says when the load fails (its status), so the rejection has nothing to add.\n      watch(\n        capability,\n        (current) => {\n          if (current) ensure(current).catch(() => {});\n        },\n        { immediate: true },\n      );\n    }\n    // Resolved on every read: a document that closes reads as `empty` from\n    // then on, never through its closed capability.\n    const value = useKernelValue((kernel) => {\n      const capability = kernel.tryCapability(declaration.token, scope.value ?? undefined);\n      const state = capability ? declaration.read(capability) : declaration.empty;\n      return select ? select(state) : state;\n    }, shallowEqual);\n    return select\n      ? value\n      : fieldRefs(value as Readonly<Ref<State>>, Object.keys(declaration.empty));\n  }\n  return useDeclaredState;\n}\n\n/**\n * Turn a plugin's token into its settings composable. A plugin's settings\n * belong to the plugin as the app registered it, not to a document, so it\n * reads them through the kernel (`kernel.settingsOf`): it works before the\n * first document opens, and every document shows the same settings. A token\n * whose plugin isn't installed, or has no settings, throws: a setup mistake.\n */\nexport function settingsComposable<Capability>(\n  token: CapabilityToken<Capability>,\n): SettingsComposable<SettingsOf<Capability> & object> {\n  type Settings = SettingsOf<Capability> & object;\n  function useSettings(): FieldRefs<Settings>;\n  function useSettings<Selected>(select: (settings: Settings) => Selected): Readonly<Ref<Selected>>;\n  function useSettings<Selected>(select?: (settings: Settings) => Selected) {\n    const value = useKernelValue((kernel) => {\n      const settings = kernel.settingsOf(token).getSettings() as Settings;\n      return select ? select(settings) : settings;\n    }, shallowEqual);\n    return select ? value : fieldRefs(value as Readonly<Ref<Settings>>);\n  }\n  return useSettings;\n}\n"],"names":["computed","useDocumentScope","useKernelValue","watch","shallowEqual"],"mappings":";;;;AAmBO,SAAS,UACd,OACA,OAA0B,OAAO,KAAK,MAAM,KAAK,GAC/B;AAClB,SAAO,OAAO;AAAA,IACZ,OAAO;AAAA,MACL,KAAK,IAAI,CAAC,QAAQ,CAAC,KAAKA,aAAS,MAAO,MAAM,MAAkC,GAAG,CAAC,CAAC,CAAC;AAAA,IAAA;AAAA,EACxF;AAEJ;ACYO,SAAS,gBACd,aACwB;AAGxB,WAAS,iBAA2B,QAAqC;AACvE,UAAM,QAAQC,aAAAA,iBAAA;AACd,UAAM,EAAE,WAAW;AACnB,QAAI,QAAQ;AACV,YAAM,aAAaC,aAAAA;AAAAA,QAAe,CAAC,WACjC,OAAO,cAAc,YAAY,OAAO,MAAM,SAAS,MAAS;AAAA,MAAA;AAGlEC,UAAAA;AAAAA,QACE;AAAA,QACA,CAAC,YAAY;AACX,cAAI,QAAS,QAAO,OAAO,EAAE,MAAM,MAAM;AAAA,UAAC,CAAC;AAAA,QAC7C;AAAA,QACA,EAAE,WAAW,KAAA;AAAA,MAAK;AAAA,IAEtB;AAGA,UAAM,QAAQD,4BAAe,CAAC,WAAW;AACvC,YAAM,aAAa,OAAO,cAAc,YAAY,OAAO,MAAM,SAAS,MAAS;AACnF,YAAM,QAAQ,aAAa,YAAY,KAAK,UAAU,IAAI,YAAY;AACtE,aAAO,SAAS,OAAO,KAAK,IAAI;AAAA,IAClC,GAAGE,KAAAA,YAAY;AACf,WAAO,SACH,QACA,UAAU,OAA+B,OAAO,KAAK,YAAY,KAAK,CAAC;AAAA,EAC7E;AACA,SAAO;AACT;AASO,SAAS,mBACd,OACqD;AAIrD,WAAS,YAAsB,QAA2C;AACxE,UAAM,QAAQF,4BAAe,CAAC,WAAW;AACvC,YAAM,WAAW,OAAO,WAAW,KAAK,EAAE,YAAA;AAC1C,aAAO,SAAS,OAAO,QAAQ,IAAI;AAAA,IACrC,GAAGE,KAAAA,YAAY;AACf,WAAO,SAAS,QAAQ,UAAU,KAAgC;AAAA,EACpE;AACA,SAAO;AACT;;;;"}

package/dist/state.d.cts

@@ -0,0 +1,32 @@
+import type { CapabilityToken, SettingsOf, StateDeclaration } from '@embedpdf/core';
+import { type Ref } from 'vue';
+import type { FieldRefs } from './runtime/refs.cjs';
+export type { FieldRefs } from './runtime/refs.cjs';
+/** A declared state's composable: refs for every field, or one ref for the value `select` picks. */
+export interface StateComposable<State extends object> {
+    (): FieldRefs<State>;
+    <Selected>(select: (state: State) => Selected): Readonly<Ref<Selected>>;
+}
+/** A plugin's settings composable: refs for every setting, or one ref for the value `select` picks. */
+export interface SettingsComposable<Settings extends object> {
+    (): FieldRefs<Settings>;
+    <Selected>(select: (settings: Settings) => Selected): Readonly<Ref<Selected>>;
+}
+/**
+ * Turn a state declaration into its composable. It reads this subtree's
+ * document (the nearest `<DocumentScope>`, else the active one) and reads the
+ * declaration's `empty` while that document is missing or not ready, so it
+ * works anywhere. A ref updates only when its value changes: the state, or the
+ * value `select` picks from it, is compared with {@link shallowEqual}. State the
+ * plugin loads on demand (the declaration's `ensure`) loads once a ready
+ * document's capability is in scope, for every document the composable reads.
+ */
+export declare function stateComposable<Capability, State extends object>(declaration: StateDeclaration<Capability, State>): StateComposable<State>;
+/**
+ * Turn a plugin's token into its settings composable. A plugin's settings
+ * belong to the plugin as the app registered it, not to a document, so it
+ * reads them through the kernel (`kernel.settingsOf`): it works before the
+ * first document opens, and every document shows the same settings. A token
+ * whose plugin isn't installed, or has no settings, throws: a setup mistake.
+ */
+export declare function settingsComposable<Capability>(token: CapabilityToken<Capability>): SettingsComposable<SettingsOf<Capability> & object>;

package/dist/state.d.ts

@@ -0,0 +1,32 @@
+import type { CapabilityToken, SettingsOf, StateDeclaration } from '@embedpdf/core';
+import { type Ref } from 'vue';
+import type { FieldRefs } from './runtime/refs.js';
+export type { FieldRefs } from './runtime/refs.js';
+/** A declared state's composable: refs for every field, or one ref for the value `select` picks. */
+export interface StateComposable<State extends object> {
+    (): FieldRefs<State>;
+    <Selected>(select: (state: State) => Selected): Readonly<Ref<Selected>>;
+}
+/** A plugin's settings composable: refs for every setting, or one ref for the value `select` picks. */
+export interface SettingsComposable<Settings extends object> {
+    (): FieldRefs<Settings>;
+    <Selected>(select: (settings: Settings) => Selected): Readonly<Ref<Selected>>;
+}
+/**
+ * Turn a state declaration into its composable. It reads this subtree's
+ * document (the nearest `<DocumentScope>`, else the active one) and reads the
+ * declaration's `empty` while that document is missing or not ready, so it
+ * works anywhere. A ref updates only when its value changes: the state, or the
+ * value `select` picks from it, is compared with {@link shallowEqual}. State the
+ * plugin loads on demand (the declaration's `ensure`) loads once a ready
+ * document's capability is in scope, for every document the composable reads.
+ */
+export declare function stateComposable<Capability, State extends object>(declaration: StateDeclaration<Capability, State>): StateComposable<State>;
+/**
+ * Turn a plugin's token into its settings composable. A plugin's settings
+ * belong to the plugin as the app registered it, not to a document, so it
+ * reads them through the kernel (`kernel.settingsOf`): it works before the
+ * first document opens, and every document shows the same settings. A token
+ * whose plugin isn't installed, or has no settings, throws: a setup mistake.
+ */
+export declare function settingsComposable<Capability>(token: CapabilityToken<Capability>): SettingsComposable<SettingsOf<Capability> & object>;