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

package/dist/signature/composables.d.ts

@@ -0,0 +1,39 @@
+import type { Ref } from 'vue';
+import type { EventHook } from '@embedpdf/core';
+import { signatureState } from '@embedpdf/plugin-signature';
+import type { SignatureCapability, SignerRow } from '@embedpdf/plugin-signature';
+import type { StateComposable } from '../state.js';
+/**
+ * The signature API for the document in scope: sign, place a mark, fill or
+ * clear a field, check the signatures. The object never changes, so it's
+ * safe to keep in a closure; keep it whole (`signature.sign(…)`), since a
+ * member taken out of it once stays the one of that moment.
+ */
+export declare function useSignature(): SignatureCapability;
+/**
+ * The signatures' state as refs: the signed fields with their verdicts
+ * (`signatures`), what they allow, the `target`, whether a signing runs
+ * (`busy`), a two-step signing in progress, and whether they're read,
+ * declared once in `signatureState`. With a selector, one ref that updates
+ * only when the value it picks changes. Empty without a document.
+ *
+ * Typed through the declaration, so the published types name it from
+ * `@embedpdf/plugin-signature`, a dependency of this package, and not from the
+ * engine package `protection`'s type comes from, which isn't one.
+ */
+export declare const useSignatureState: StateComposable<ReturnType<typeof signatureState.read>>;
+/**
+ * The signature settings (`key`, `mode`, `trust`, `allowCertify`) as refs, or
+ * one ref for the value `select` picks. They belong to the plugin, so they
+ * read without a document.
+ */
+export declare const useSignatureSettings: import("../index.js").SettingsComposable<import("@embedpdf/plugin-signature").SignatureSettings & object>;
+/** Subscribe to one signature event while the component lives: `useSignatureEvent((signature) => signature.onSigned, handler)`. */
+export declare function useSignatureEvent<Event>(select: (signature: SignatureCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The people whose marks this browser holds, one row per library of kind
+ * `signatures`, for a picker, as a ref: `const rows = useSignerRows()`.
+ * Derived from the stamp plugin, so it needs `stampPlugin()`: rename, delete
+ * and export are the library verbs, and nothing is stored beyond the file.
+ */
+export declare function useSignerRows(): Readonly<Ref<readonly SignerRow[]>>;

package/dist/signature.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginSignature = require("@embedpdf/plugin-signature");
+const composables = require("./composables-BGBsNDf9.cjs");
+exports.useSignature = composables.useSignature;
+exports.useSignatureEvent = composables.useSignatureEvent;
+exports.useSignatureSettings = composables.useSignatureSettings;
+exports.useSignatureState = composables.useSignatureState;
+exports.useSignerRows = composables.useSignerRows;
+Object.keys(pluginSignature).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginSignature[k]
+  });
+});
+//# sourceMappingURL=signature.cjs.map

package/dist/signature.cjs.map

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

package/dist/signature.d.cts

@@ -0,0 +1,15 @@
+/**
+ * @embedpdf/vue/signature: the Vue surface of `@embedpdf/plugin-signature`.
+ *
+ * Signing for the document in scope (`useSignature()`), its state as refs (the
+ * signatures with their verdicts, what they allow, the target, a two-step
+ * signing in progress), the settings, the events, and the one derivation a
+ * signatures panel needs: the people (libraries of kind `signatures`) with
+ * their marks (`useSignerRows()`). The signers (`personalSigner`,
+ * `webCryptoSigner`, `remoteSigner`, `createTestSigner`) come with the plugin.
+ *
+ *   const signature = useSignature();
+ *   await signature.placeMark({ assetId }, { field: target }); // sign, fill or ask, by mode
+ */
+export * from '@embedpdf/plugin-signature';
+export { useSignature, useSignatureEvent, useSignatureSettings, useSignatureState, useSignerRows, } from './signature/composables.cjs';

package/dist/signature.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @embedpdf/vue/signature: the Vue surface of `@embedpdf/plugin-signature`.
+ *
+ * Signing for the document in scope (`useSignature()`), its state as refs (the
+ * signatures with their verdicts, what they allow, the target, a two-step
+ * signing in progress), the settings, the events, and the one derivation a
+ * signatures panel needs: the people (libraries of kind `signatures`) with
+ * their marks (`useSignerRows()`). The signers (`personalSigner`,
+ * `webCryptoSigner`, `remoteSigner`, `createTestSigner`) come with the plugin.
+ *
+ *   const signature = useSignature();
+ *   await signature.placeMark({ assetId }, { field: target }); // sign, fill or ask, by mode
+ */
+export * from '@embedpdf/plugin-signature';
+export { useSignature, useSignatureEvent, useSignatureSettings, useSignatureState, useSignerRows, } from './signature/composables.js';

package/dist/signature.js

@@ -0,0 +1,10 @@
+export * from "@embedpdf/plugin-signature";
+import { u, a, b, c, d } from "./composables-DwsZdg06.js";
+export {
+  u as useSignature,
+  a as useSignatureEvent,
+  b as useSignatureSettings,
+  c as useSignatureState,
+  d as useSignerRows
+};
+//# sourceMappingURL=signature.js.map

package/dist/signature.js.map

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

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

@@ -0,0 +1,29 @@
+import type { PageFrame } from '@embedpdf/core-geometry';
+import type { VisiblePage } from '@embedpdf/plugin-stage';
+import type { StageHostCapability } from '@embedpdf/plugin-stage/contract/host';
+import type { PageContextValue } from '../runtime/page.cjs';
+type __VLS_Props = {
+    documentId: string;
+    page: VisiblePage;
+    /** Reserved chrome bands around the page (screen px); the layout reserved the space. */
+    frame: PageFrame;
+    /** The stage lens: the page's view demand reads its visibility live. */
+    stage: StageHostCapability;
+};
+type __VLS_Slots = {
+    default?(props: {
+        page: PageContextValue;
+    }): unknown;
+    chrome?(props: {
+        page: PageContextValue;
+    }): 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/PageSurface.vue.d.ts

@@ -0,0 +1,29 @@
+import type { PageFrame } from '@embedpdf/core-geometry';
+import type { VisiblePage } from '@embedpdf/plugin-stage';
+import type { StageHostCapability } from '@embedpdf/plugin-stage/contract/host';
+import type { PageContextValue } from '../runtime/page.js';
+type __VLS_Props = {
+    documentId: string;
+    page: VisiblePage;
+    /** Reserved chrome bands around the page (screen px); the layout reserved the space. */
+    frame: PageFrame;
+    /** The stage lens: the page's view demand reads its visibility live. */
+    stage: StageHostCapability;
+};
+type __VLS_Slots = {
+    default?(props: {
+        page: PageContextValue;
+    }): unknown;
+    chrome?(props: {
+        page: PageContextValue;
+    }): 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/Scrollbar.vue.d.cts

@@ -0,0 +1,32 @@
+import type { StyleValue } from 'vue';
+import type { StageTokenProp } from './scope.cjs';
+type __VLS_Props = {
+    axis: 'x' | 'y';
+    /** The stage lens to scroll: the nearest `<StageScope>` / `<Stage>`'s, else the main StageToken. */
+    token?: StageTokenProp;
+    /**
+     * Overlay auto-hide: fade this many ms after the view stops moving (drags
+     * and hover keep it visible; a hidden bar ignores the pointer, like macOS).
+     * `false` keeps it visible. Published as `data-state="visible|hidden"`.
+     */
+    autoHide?: number | false;
+    /** Minimum thumb length in px, so the bar never vanishes on long documents. */
+    minThumbSize?: number;
+    /**
+     * Pressing the track: 'page' steps by 90% of a view toward the pointer,
+     * repeats while held, and stops when the thumb reaches the pointer; 'jump'
+     * centres the thumb at the pointer and hands off to a drag.
+     */
+    trackPress?: 'page' | 'jump';
+    /** The thumb's class. */
+    thumbClass?: string;
+    /** The thumb's style, over its defaults. */
+    thumbStyle?: StyleValue;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    autoHide: number | false;
+    minThumbSize: number;
+    trackPress: "page" | "jump";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,32 @@
+import type { StyleValue } from 'vue';
+import type { StageTokenProp } from './scope.js';
+type __VLS_Props = {
+    axis: 'x' | 'y';
+    /** The stage lens to scroll: the nearest `<StageScope>` / `<Stage>`'s, else the main StageToken. */
+    token?: StageTokenProp;
+    /**
+     * Overlay auto-hide: fade this many ms after the view stops moving (drags
+     * and hover keep it visible; a hidden bar ignores the pointer, like macOS).
+     * `false` keeps it visible. Published as `data-state="visible|hidden"`.
+     */
+    autoHide?: number | false;
+    /** Minimum thumb length in px, so the bar never vanishes on long documents. */
+    minThumbSize?: number;
+    /**
+     * Pressing the track: 'page' steps by 90% of a view toward the pointer,
+     * repeats while held, and stops when the thumb reaches the pointer; 'jump'
+     * centres the thumb at the pointer and hands off to a drag.
+     */
+    trackPress?: 'page' | 'jump';
+    /** The thumb's class. */
+    thumbClass?: string;
+    /** The thumb's style, over its defaults. */
+    thumbStyle?: StyleValue;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    autoHide: number | false;
+    minThumbSize: number;
+    trackPress: "page" | "jump";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,44 @@
+import type { PageContextValue } from '../runtime/page.cjs';
+import type { StageTokenProp } from './scope.cjs';
+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/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