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

package/dist/stage/Stage.vue.d.ts

@@ -0,0 +1,44 @@
+import type { PageContextValue } from '../runtime/page.js';
+import type { StageTokenProp } from './scope.js';
+type __VLS_Props = {
+    /** The stage lens to drive: the nearest `<StageScope>`'s, else the main `StageToken`. */
+    token?: StageTokenProp;
+    /** `v-model:page`: the current page's index, from 0. Setting it goes to that page. */
+    page?: number;
+    /** `v-model:zoom`: the zoom level, `1` is 100%. Setting it zooms there. */
+    zoom?: number;
+    /**
+     * `v-model:tool`: while set, the active tool follows it (again when the
+     * document changes), and every tool change is reported back.
+     */
+    tool?: string;
+};
+type __VLS_Slots = {
+    /** A visible page's content: layers in page coordinates, turned with the page. */
+    page(props: {
+        page: PageContextValue;
+    }): unknown;
+    /** A visible page's chrome: its box and the reserved `pageFrame`, never turned. */
+    'page-chrome'?(props: {
+        page: PageContextValue;
+    }): unknown;
+    /** The view: menus, controls and `<Anchored>` UI above the pages. */
+    overlay?(): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:page": (pageIndex: number) => any;
+    "update:zoom": (level: number) => any;
+    "update:tool": (toolId: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:page"?: ((pageIndex: number) => any) | undefined;
+    "onUpdate:zoom"?: ((level: number) => any) | undefined;
+    "onUpdate:tool"?: ((toolId: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/stage/StageScope.vue.d.cts

@@ -0,0 +1,17 @@
+import type { StageTokenProp } from './scope.cjs';
+type __VLS_Props = {
+    /** The lens: a second view's token, from `createCapabilityToken`. */
+    token: StageTokenProp;
+};
+type __VLS_Slots = {
+    default?(): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/stage/StageScope.vue.d.ts

@@ -0,0 +1,17 @@
+import type { StageTokenProp } from './scope.js';
+type __VLS_Props = {
+    /** The lens: a second view's token, from `createCapabilityToken`. */
+    token: StageTokenProp;
+};
+type __VLS_Slots = {
+    default?(): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/stage/composables.d.cts

@@ -0,0 +1,41 @@
+import type { CapabilityToken, EventHook } from '@embedpdf/core';
+import { stageState } from '@embedpdf/plugin-stage';
+import type { StageCapability, StageSettings } from '@embedpdf/plugin-stage';
+import type { ScrollMetrics, StageHostCapability } from '@embedpdf/plugin-stage/contract/host';
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { FieldRefs } from '../runtime/refs.cjs';
+import type { StageTokenProp } from './scope.cjs';
+/** A stage token, or a ref or getter of one: for a view chosen by a prop. */
+export type StageTokenSource = MaybeRefOrGetter<StageTokenProp | undefined>;
+/** What `useStageState()` reads: the Stage page's State table. */
+export type StageStateValue = (typeof stageState)['empty'];
+/** The Stage's API (zoom, navigation, reveal, settings), for app chrome. The object never changes. */
+export declare function useStage(token?: StageTokenSource): StageCapability;
+/** Subscribe to one stage event while the component lives: `useStageEvent((stage) => stage.onZoomChanged, handler)`. */
+export declare function useStageEvent<Event>(select: (stage: StageCapability) => EventHook<Event>, handler: (event: Event) => void, token?: StageTokenSource): void;
+/**
+ * The view's state as refs: the zoom, the current page, the page count, the
+ * view rotation and the responsive rules that apply (the page's State table,
+ * declared once in `stageState`). With a selector, one ref for the value it
+ * picks, which updates only when that value changes. Without a document it
+ * reads `stageState.empty`.
+ */
+export declare function useStageState(select?: undefined, token?: StageTokenSource): FieldRefs<StageStateValue>;
+export declare function useStageState<Selected>(select: (state: StageStateValue) => Selected, token?: StageTokenSource): Readonly<Ref<Selected>>;
+/**
+ * The view's settings as refs, or one ref for the value `select` picks. They
+ * belong to the view, so without a document there is none yet and this reads
+ * the defaults. Change them with `useStage().updateSettings()`.
+ */
+export declare function useStageSettings(select?: undefined, token?: StageTokenSource): FieldRefs<StageSettings>;
+export declare function useStageSettings<Selected>(select: (settings: StageSettings) => Selected, token?: StageTokenSource): Readonly<Ref<Selected>>;
+export declare const asHost: (token: CapabilityToken<StageCapability>) => CapabilityToken<StageHostCapability>;
+/** The metrics of a lens, as one ref: for the `<Scrollbar>` and the field refs below. */
+export declare function useScrollMetricsValue(token?: StageTokenSource): Readonly<Ref<ScrollMetrics>>;
+/**
+ * The view's scroll position as a scrolling element has it, as refs:
+ * `scrollTop`, `scrollHeight`, `clientHeight` and their horizontal twins, in
+ * screen pixels. The raw material for scroll UI of your own; all zero without
+ * a document.
+ */
+export declare function useScrollMetrics(token?: StageTokenSource): FieldRefs<ScrollMetrics>;

package/dist/stage/composables.d.ts

@@ -0,0 +1,41 @@
+import type { CapabilityToken, EventHook } from '@embedpdf/core';
+import { stageState } from '@embedpdf/plugin-stage';
+import type { StageCapability, StageSettings } from '@embedpdf/plugin-stage';
+import type { ScrollMetrics, StageHostCapability } from '@embedpdf/plugin-stage/contract/host';
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { FieldRefs } from '../runtime/refs.js';
+import type { StageTokenProp } from './scope.js';
+/** A stage token, or a ref or getter of one: for a view chosen by a prop. */
+export type StageTokenSource = MaybeRefOrGetter<StageTokenProp | undefined>;
+/** What `useStageState()` reads: the Stage page's State table. */
+export type StageStateValue = (typeof stageState)['empty'];
+/** The Stage's API (zoom, navigation, reveal, settings), for app chrome. The object never changes. */
+export declare function useStage(token?: StageTokenSource): StageCapability;
+/** Subscribe to one stage event while the component lives: `useStageEvent((stage) => stage.onZoomChanged, handler)`. */
+export declare function useStageEvent<Event>(select: (stage: StageCapability) => EventHook<Event>, handler: (event: Event) => void, token?: StageTokenSource): void;
+/**
+ * The view's state as refs: the zoom, the current page, the page count, the
+ * view rotation and the responsive rules that apply (the page's State table,
+ * declared once in `stageState`). With a selector, one ref for the value it
+ * picks, which updates only when that value changes. Without a document it
+ * reads `stageState.empty`.
+ */
+export declare function useStageState(select?: undefined, token?: StageTokenSource): FieldRefs<StageStateValue>;
+export declare function useStageState<Selected>(select: (state: StageStateValue) => Selected, token?: StageTokenSource): Readonly<Ref<Selected>>;
+/**
+ * The view's settings as refs, or one ref for the value `select` picks. They
+ * belong to the view, so without a document there is none yet and this reads
+ * the defaults. Change them with `useStage().updateSettings()`.
+ */
+export declare function useStageSettings(select?: undefined, token?: StageTokenSource): FieldRefs<StageSettings>;
+export declare function useStageSettings<Selected>(select: (settings: StageSettings) => Selected, token?: StageTokenSource): Readonly<Ref<Selected>>;
+export declare const asHost: (token: CapabilityToken<StageCapability>) => CapabilityToken<StageHostCapability>;
+/** The metrics of a lens, as one ref: for the `<Scrollbar>` and the field refs below. */
+export declare function useScrollMetricsValue(token?: StageTokenSource): Readonly<Ref<ScrollMetrics>>;
+/**
+ * The view's scroll position as a scrolling element has it, as refs:
+ * `scrollTop`, `scrollHeight`, `clientHeight` and their horizontal twins, in
+ * screen pixels. The raw material for scroll UI of your own; all zero without
+ * a document.
+ */
+export declare function useScrollMetrics(token?: StageTokenSource): FieldRefs<ScrollMetrics>;

package/dist/stage/scope.d.cts

@@ -0,0 +1,12 @@
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { CapabilityToken } from '@embedpdf/core';
+import type { StageCapability } from '@embedpdf/plugin-stage/contract';
+/** Which stage lens to bind to: the main `StageToken`, or the token of a second view. */
+export type StageTokenProp = CapabilityToken<StageCapability>;
+/** Bind this subtree to a stage lens: what `<Stage>` and `<StageScope>` do. */
+export declare function provideStageToken(token: MaybeRefOrGetter<StageTokenProp>): void;
+/**
+ * The lens a stage composable binds to: the explicit argument, else the
+ * nearest `<StageScope>` / `<Stage>`, else the main lens.
+ */
+export declare function useStageToken(explicit?: MaybeRefOrGetter<StageTokenProp | undefined>): Readonly<Ref<StageTokenProp>>;

package/dist/stage/scope.d.ts

@@ -0,0 +1,12 @@
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { CapabilityToken } from '@embedpdf/core';
+import type { StageCapability } from '@embedpdf/plugin-stage/contract';
+/** Which stage lens to bind to: the main `StageToken`, or the token of a second view. */
+export type StageTokenProp = CapabilityToken<StageCapability>;
+/** Bind this subtree to a stage lens: what `<Stage>` and `<StageScope>` do. */
+export declare function provideStageToken(token: MaybeRefOrGetter<StageTokenProp>): void;
+/**
+ * The lens a stage composable binds to: the explicit argument, else the
+ * nearest `<StageScope>` / `<Stage>`, else the main lens.
+ */
+export declare function useStageToken(explicit?: MaybeRefOrGetter<StageTokenProp | undefined>): Readonly<Ref<StageTokenProp>>;

package/dist/stage.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginStage = require("@embedpdf/plugin-stage");
+const Scrollbar_vue_vue_type_script_setup_true_lang = require("./Scrollbar.vue_vue_type_script_setup_true_lang-DrOORC1H.cjs");
+const scope = require("./scope-BQA4toWB.cjs");
+exports.Scrollbar = Scrollbar_vue_vue_type_script_setup_true_lang._sfc_main;
+exports.Stage = Scrollbar_vue_vue_type_script_setup_true_lang._sfc_main$1;
+exports.StageScope = Scrollbar_vue_vue_type_script_setup_true_lang._sfc_main$2;
+exports.useScrollMetrics = Scrollbar_vue_vue_type_script_setup_true_lang.useScrollMetrics;
+exports.useStage = Scrollbar_vue_vue_type_script_setup_true_lang.useStage;
+exports.useStageEvent = Scrollbar_vue_vue_type_script_setup_true_lang.useStageEvent;
+exports.useStageSettings = Scrollbar_vue_vue_type_script_setup_true_lang.useStageSettings;
+exports.useStageState = Scrollbar_vue_vue_type_script_setup_true_lang.useStageState;
+exports.useStageToken = scope.useStageToken;
+Object.keys(pluginStage).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginStage[k]
+  });
+});
+//# sourceMappingURL=stage.cjs.map

package/dist/stage.cjs.map

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

package/dist/stage.d.cts

@@ -0,0 +1,17 @@
+/**
+ * @embedpdf/vue/stage: the Stage and its composables.
+ *
+ * `<Stage>` virtualizes and positions page surfaces by the camera, and hands
+ * each one to your `#page` slot: you bring the layers. The composables are the
+ * plugin's four, `useStage()` (the API), `useStageState()`, `useStageEvent()`
+ * and `useStageSettings()`; `<Scrollbar>` and `useScrollMetrics()` are the
+ * Stage's too.
+ */
+export * from '@embedpdf/plugin-stage';
+export { default as Stage } from './stage/Stage.vue.cjs';
+export { default as StageScope } from './stage/StageScope.vue.cjs';
+export { default as Scrollbar } from './stage/Scrollbar.vue.cjs';
+export { useStageToken } from './stage/scope.cjs';
+export type { StageTokenProp } from './stage/scope.cjs';
+export { useScrollMetrics, useStage, useStageEvent, useStageSettings, useStageState, } from './stage/composables.cjs';
+export type { StageStateValue, StageTokenSource } from './stage/composables.cjs';

package/dist/stage.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @embedpdf/vue/stage: the Stage and its composables.
+ *
+ * `<Stage>` virtualizes and positions page surfaces by the camera, and hands
+ * each one to your `#page` slot: you bring the layers. The composables are the
+ * plugin's four, `useStage()` (the API), `useStageState()`, `useStageEvent()`
+ * and `useStageSettings()`; `<Scrollbar>` and `useScrollMetrics()` are the
+ * Stage's too.
+ */
+export * from '@embedpdf/plugin-stage';
+export { default as Stage } from './stage/Stage.vue.js';
+export { default as StageScope } from './stage/StageScope.vue.js';
+export { default as Scrollbar } from './stage/Scrollbar.vue.js';
+export { useStageToken } from './stage/scope.js';
+export type { StageTokenProp } from './stage/scope.js';
+export { useScrollMetrics, useStage, useStageEvent, useStageSettings, useStageState, } from './stage/composables.js';
+export type { StageStateValue, StageTokenSource } from './stage/composables.js';

package/dist/stage.js

@@ -0,0 +1,15 @@
+export * from "@embedpdf/plugin-stage";
+import { _, a, b, u, c, d, e, f } from "./Scrollbar.vue_vue_type_script_setup_true_lang-HbCryx1B.js";
+import { u as u2 } from "./scope-BgdCqnYb.js";
+export {
+  _ as Scrollbar,
+  a as Stage,
+  b as StageScope,
+  u as useScrollMetrics,
+  c as useStage,
+  d as useStageEvent,
+  e as useStageSettings,
+  f as useStageState,
+  u2 as useStageToken
+};
+//# sourceMappingURL=stage.js.map

package/dist/stage.js.map

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

package/dist/stamp.cjs

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginStamp = require("@embedpdf/plugin-stamp");
+const web = require("@embedpdf/web");
+const vue = require("vue");
+const core = require("@embedpdf/core");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+const state = require("./state-M22NDJQo.cjs");
+function useStamp() {
+  return capabilities.useCapability(pluginStamp.StampToken);
+}
+function useStampEvent(select, handler) {
+  capabilities.useCapabilityEvent(pluginStamp.StampToken, select, handler);
+}
+const useStampState = state.stateComposable(pluginStamp.stampState);
+const useStampSettings = state.settingsComposable(pluginStamp.StampToken);
+function useStampLibraries(filter) {
+  return capabilities.useSelector(pluginStamp.StampToken, (stamp) => stamp.listLibraries(vue.toValue(filter)), core.shallowEqual);
+}
+function useStampAssets(filter) {
+  return capabilities.useSelector(pluginStamp.StampToken, (stamp) => stamp.listAssets(vue.toValue(filter)), core.shallowEqual);
+}
+function useStampAssetPreviewUrl(assetId) {
+  const preview = capabilities.useOptionalSelector(
+    pluginStamp.StampToken,
+    (stamp) => {
+      const id = vue.toValue(assetId);
+      return id ? stamp.getAssetPreview(id) : null;
+    },
+    null
+  );
+  const url = vue.shallowRef(null);
+  vue.watch(
+    preview,
+    (current, _previous, onCleanup) => {
+      if (!current) {
+        url.value = null;
+        return;
+      }
+      const objectUrl = web.objectUrlOf(current);
+      url.value = objectUrl.url;
+      onCleanup(() => {
+        objectUrl.revoke();
+        url.value = null;
+      });
+    },
+    { immediate: true }
+  );
+  return url;
+}
+Object.defineProperty(exports, "indexedDbByteStore", {
+  enumerable: true,
+  get: () => web.indexedDbByteStore
+});
+exports.useStamp = useStamp;
+exports.useStampAssetPreviewUrl = useStampAssetPreviewUrl;
+exports.useStampAssets = useStampAssets;
+exports.useStampEvent = useStampEvent;
+exports.useStampLibraries = useStampLibraries;
+exports.useStampSettings = useStampSettings;
+exports.useStampState = useStampState;
+Object.keys(pluginStamp).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginStamp[k]
+  });
+});
+//# sourceMappingURL=stamp.cjs.map

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