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

package/dist/search.d.cts

@@ -0,0 +1,10 @@
+/**
+ * @embedpdf/vue/search: the Vue surface of `@embedpdf/plugin-search`.
+ *
+ * `<SearchLayer>` paints the matches on a page; search is driven from your own
+ * chrome with `useSearch()`, shown with `useSearchState()` and
+ * `useSearchHits()`, and followed with `useSearchEvent()`.
+ */
+export * from '@embedpdf/plugin-search';
+export { default as SearchLayer } from './search/SearchLayer.vue.cjs';
+export { useSearch, useSearchEvent, useSearchHits, useSearchSettings, useSearchState, } from './search/composables.cjs';

package/dist/search.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @embedpdf/vue/search: the Vue surface of `@embedpdf/plugin-search`.
+ *
+ * `<SearchLayer>` paints the matches on a page; search is driven from your own
+ * chrome with `useSearch()`, shown with `useSearchState()` and
+ * `useSearchHits()`, and followed with `useSearchEvent()`.
+ */
+export * from '@embedpdf/plugin-search';
+export { default as SearchLayer } from './search/SearchLayer.vue.js';
+export { useSearch, useSearchEvent, useSearchHits, useSearchSettings, useSearchState, } from './search/composables.js';

package/dist/search.js

@@ -0,0 +1,11 @@
+export * from "@embedpdf/plugin-search";
+import { _, u, a, b, c, d } from "./SearchLayer.vue_vue_type_script_setup_true_lang-BlLIPH1B.js";
+export {
+  _ as SearchLayer,
+  u as useSearch,
+  a as useSearchEvent,
+  b as useSearchHits,
+  c as useSearchSettings,
+  d as useSearchState
+};
+//# sourceMappingURL=search.js.map

package/dist/search.js.map

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

package/dist/selection/SelectionClipboard.vue.d.cts

@@ -0,0 +1,24 @@
+import { type MaybeRefOrGetter } from 'vue';
+type __VLS_Props = {
+    /**
+     * Fetch the selected text as soon as the selection settles (default true).
+     * The browser's `copy` event must be answered at once, so without it only
+     * Ctrl+C / Cmd+C copies, a moment later.
+     */
+    prefetch?: boolean;
+    /**
+     * Copy only while focus is inside this element (a template ref), for a
+     * page with more than one viewer. Copying works once it has mounted.
+     * Default: anywhere on the page.
+     */
+    target?: MaybeRefOrGetter<HTMLElement | null | undefined>;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    refused: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRefused?: (() => any) | undefined;
+}>, {
+    prefetch: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/selection/SelectionClipboard.vue.d.ts

@@ -0,0 +1,24 @@
+import { type MaybeRefOrGetter } from 'vue';
+type __VLS_Props = {
+    /**
+     * Fetch the selected text as soon as the selection settles (default true).
+     * The browser's `copy` event must be answered at once, so without it only
+     * Ctrl+C / Cmd+C copies, a moment later.
+     */
+    prefetch?: boolean;
+    /**
+     * Copy only while focus is inside this element (a template ref), for a
+     * page with more than one viewer. Copying works once it has mounted.
+     * Default: anywhere on the page.
+     */
+    target?: MaybeRefOrGetter<HTMLElement | null | undefined>;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    refused: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRefused?: (() => any) | undefined;
+}>, {
+    prefetch: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/selection/SelectionHandles.vue.d.cts

@@ -0,0 +1,8 @@
+import type { StageTokenProp } from '../stage/scope.cjs';
+type __VLS_Props = {
+    /** The stage view this overlay belongs to. Default: the enclosing `<Stage>`'s. */
+    token?: StageTokenProp;
+};
+declare const __VLS_export: 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 _default: typeof __VLS_export;
+export default _default;

package/dist/selection/SelectionHandles.vue.d.ts

@@ -0,0 +1,8 @@
+import type { StageTokenProp } from '../stage/scope.js';
+type __VLS_Props = {
+    /** The stage view this overlay belongs to. Default: the enclosing `<Stage>`'s. */
+    token?: StageTokenProp;
+};
+declare const __VLS_export: 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 _default: typeof __VLS_export;
+export default _default;

package/dist/selection/SelectionLayer.vue.d.cts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/selection/SelectionLayer.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/selection/SelectionMenu.vue.d.cts

@@ -0,0 +1,23 @@
+import type { AnchoredPlacement } from '@embedpdf/web';
+type __VLS_Props = {
+    /** Gap in screen px between the selection and the menu. Default 8. */
+    gap?: number;
+    /** Where the menu sits around the selection. Default `'top'`. */
+    placement?: AnchoredPlacement;
+};
+type __VLS_Slots = {
+    /** The menu: compose it from `useSelection()`, `copySelection`, an annotation call. */
+    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<{}>, {
+    gap: number;
+    placement: AnchoredPlacement;
+}, {}, {}, {}, 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/selection/SelectionMenu.vue.d.ts

@@ -0,0 +1,23 @@
+import type { AnchoredPlacement } from '@embedpdf/web';
+type __VLS_Props = {
+    /** Gap in screen px between the selection and the menu. Default 8. */
+    gap?: number;
+    /** Where the menu sits around the selection. Default `'top'`. */
+    placement?: AnchoredPlacement;
+};
+type __VLS_Slots = {
+    /** The menu: compose it from `useSelection()`, `copySelection`, an annotation call. */
+    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<{}>, {
+    gap: number;
+    placement: AnchoredPlacement;
+}, {}, {}, {}, 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/selection/composables.d.cts

@@ -0,0 +1,24 @@
+import type { SelectionCapability } from '@embedpdf/plugin-selection';
+import type { EventHook } from '@embedpdf/core';
+/**
+ * The selection API (`select()`, `readText()`, `canCopy()`, …) for your
+ * chrome: toolbars, context menus, automation. The object never changes.
+ */
+export declare function useSelection(): SelectionCapability;
+/** Subscribe to one selection event while the component lives: `useSelectionEvent((selection) => selection.onCommitted, handler)`. */
+export declare function useSelectionEvent<Event>(select: (selection: SelectionCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The selection's state as refs: whether anything is selected, whether the
+ * user is still selecting, the range and the pages it's on (the page's State
+ * table, declared once in `selectionState`). With a selector, one ref that
+ * updates only when the value it picks changes. The empty state without a
+ * document.
+ */
+export declare const useSelectionState: import("../index.cjs").StateComposable<{
+    hasSelection: boolean;
+    isSelecting: boolean;
+    range: import("@embedpdf/plugin-selection").TextRange | null;
+    pages: readonly import("@embedpdf/core").PageRef[];
+}>;
+/** The selection settings (`dragThreshold`, `color`, `handles`), with or without a document, as refs. Takes a selector. */
+export declare const useSelectionSettings: import("../index.cjs").SettingsComposable<import("@embedpdf/plugin-selection").SelectionSettings & object>;

package/dist/selection/composables.d.ts

@@ -0,0 +1,24 @@
+import type { SelectionCapability } from '@embedpdf/plugin-selection';
+import type { EventHook } from '@embedpdf/core';
+/**
+ * The selection API (`select()`, `readText()`, `canCopy()`, …) for your
+ * chrome: toolbars, context menus, automation. The object never changes.
+ */
+export declare function useSelection(): SelectionCapability;
+/** Subscribe to one selection event while the component lives: `useSelectionEvent((selection) => selection.onCommitted, handler)`. */
+export declare function useSelectionEvent<Event>(select: (selection: SelectionCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The selection's state as refs: whether anything is selected, whether the
+ * user is still selecting, the range and the pages it's on (the page's State
+ * table, declared once in `selectionState`). With a selector, one ref that
+ * updates only when the value it picks changes. The empty state without a
+ * document.
+ */
+export declare const useSelectionState: import("../index.js").StateComposable<{
+    hasSelection: boolean;
+    isSelecting: boolean;
+    range: import("@embedpdf/plugin-selection").TextRange | null;
+    pages: readonly import("@embedpdf/core").PageRef[];
+}>;
+/** The selection settings (`dragThreshold`, `color`, `handles`), with or without a document, as refs. Takes a selector. */
+export declare const useSelectionSettings: import("../index.js").SettingsComposable<import("@embedpdf/plugin-selection").SelectionSettings & object>;

package/dist/selection.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginSelection = require("@embedpdf/plugin-selection");
+const web = require("@embedpdf/web");
+const SelectionClipboard_vue_vue_type_script_setup_true_lang = require("./SelectionClipboard.vue_vue_type_script_setup_true_lang-C8T9q6Kb.cjs");
+Object.defineProperty(exports, "copySelection", {
+  enumerable: true,
+  get: () => web.copySelection
+});
+exports.SelectionClipboard = SelectionClipboard_vue_vue_type_script_setup_true_lang._sfc_main;
+exports.SelectionHandles = SelectionClipboard_vue_vue_type_script_setup_true_lang._sfc_main$1;
+exports.SelectionLayer = SelectionClipboard_vue_vue_type_script_setup_true_lang._sfc_main$2;
+exports.SelectionMenu = SelectionClipboard_vue_vue_type_script_setup_true_lang._sfc_main$3;
+exports.useSelection = SelectionClipboard_vue_vue_type_script_setup_true_lang.useSelection;
+exports.useSelectionEvent = SelectionClipboard_vue_vue_type_script_setup_true_lang.useSelectionEvent;
+exports.useSelectionSettings = SelectionClipboard_vue_vue_type_script_setup_true_lang.useSelectionSettings;
+exports.useSelectionState = SelectionClipboard_vue_vue_type_script_setup_true_lang.useSelectionState;
+Object.keys(pluginSelection).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginSelection[k]
+  });
+});
+//# sourceMappingURL=selection.cjs.map

package/dist/selection.cjs.map

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

package/dist/selection.d.cts

@@ -0,0 +1,16 @@
+/**
+ * @embedpdf/vue/selection: the Vue surface of `@embedpdf/plugin-selection`.
+ *
+ * `<SelectionLayer>` paints the selected text on a page, `<SelectionMenu>`
+ * floats your menu over it, `<SelectionHandles>` adds the grips touch screens
+ * need, and `<SelectionClipboard>` wires Ctrl+C / Cmd+C. The composables are
+ * the plugin's four: `useSelection()`, `useSelectionState()`,
+ * `useSelectionSettings()` and `useSelectionEvent()`.
+ */
+export * from '@embedpdf/plugin-selection';
+export { copySelection } from '@embedpdf/web';
+export { default as SelectionLayer } from './selection/SelectionLayer.vue.cjs';
+export { default as SelectionMenu } from './selection/SelectionMenu.vue.cjs';
+export { default as SelectionHandles } from './selection/SelectionHandles.vue.cjs';
+export { default as SelectionClipboard } from './selection/SelectionClipboard.vue.cjs';
+export { useSelection, useSelectionEvent, useSelectionSettings, useSelectionState, } from './selection/composables.cjs';

package/dist/selection.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @embedpdf/vue/selection: the Vue surface of `@embedpdf/plugin-selection`.
+ *
+ * `<SelectionLayer>` paints the selected text on a page, `<SelectionMenu>`
+ * floats your menu over it, `<SelectionHandles>` adds the grips touch screens
+ * need, and `<SelectionClipboard>` wires Ctrl+C / Cmd+C. The composables are
+ * the plugin's four: `useSelection()`, `useSelectionState()`,
+ * `useSelectionSettings()` and `useSelectionEvent()`.
+ */
+export * from '@embedpdf/plugin-selection';
+export { copySelection } from '@embedpdf/web';
+export { default as SelectionLayer } from './selection/SelectionLayer.vue.js';
+export { default as SelectionMenu } from './selection/SelectionMenu.vue.js';
+export { default as SelectionHandles } from './selection/SelectionHandles.vue.js';
+export { default as SelectionClipboard } from './selection/SelectionClipboard.vue.js';
+export { useSelection, useSelectionEvent, useSelectionSettings, useSelectionState, } from './selection/composables.js';

package/dist/selection.js

@@ -0,0 +1,15 @@
+export * from "@embedpdf/plugin-selection";
+import { copySelection } from "@embedpdf/web";
+import { _, a, b, c, u, d, e, f } from "./SelectionClipboard.vue_vue_type_script_setup_true_lang-C4TUDuyu.js";
+export {
+  _ as SelectionClipboard,
+  a as SelectionHandles,
+  b as SelectionLayer,
+  c as SelectionMenu,
+  copySelection,
+  u as useSelection,
+  d as useSelectionEvent,
+  e as useSelectionSettings,
+  f as useSelectionState
+};
+//# sourceMappingURL=selection.js.map

package/dist/selection.js.map

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

package/dist/shell.cjs

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginShell = require("@embedpdf/plugin-shell");
+const vue = require("vue");
+const web = require("@embedpdf/web");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+const state = require("./state-M22NDJQo.cjs");
+function useShell() {
+  return capabilities.useCapability(pluginShell.ShellToken);
+}
+function useShellEvent(select, handler) {
+  capabilities.useCapabilityEvent(pluginShell.ShellToken, select, handler);
+}
+const useShellState = state.stateComposable(pluginShell.shellState);
+const NO_PROPS = Object.freeze({});
+function useSurface(id) {
+  const shell = capabilities.useOptionalCapability(pluginShell.ShellToken);
+  const isOpen = capabilities.useOptionalSelector(pluginShell.ShellToken, (current) => current.isOpen(vue.toValue(id)), false);
+  const props = capabilities.useOptionalSelector(
+    pluginShell.ShellToken,
+    (current) => {
+      var _a;
+      return ((_a = current.getSurface(vue.toValue(id))) == null ? void 0 : _a.props) ?? NO_PROPS;
+    },
+    NO_PROPS
+  );
+  return Object.freeze({
+    isOpen,
+    props,
+    open: (options) => {
+      var _a;
+      return (_a = shell.value) == null ? void 0 : _a.open(vue.toValue(id), options);
+    },
+    close: () => {
+      var _a;
+      return (_a = shell.value) == null ? void 0 : _a.close(vue.toValue(id));
+    },
+    toggle: (options) => {
+      var _a;
+      return (_a = shell.value) == null ? void 0 : _a.toggle(vue.toValue(id), options);
+    }
+  });
+}
+function useSurfaceFocus(id, element, options = {}) {
+  const shell = capabilities.useOptionalCapability(pluginShell.ShellToken);
+  const request = capabilities.useOptionalSelector(
+    pluginShell.ShellToken,
+    (current) => {
+      var _a;
+      return ((_a = current.getSurface(vue.toValue(id))) == null ? void 0 : _a.focusRequest) ?? 0;
+    },
+    0
+  );
+  const follower = web.createSurfaceFocusFollower();
+  vue.watch(
+    () => [vue.toValue(element) ?? null, shell.value, request.value],
+    ([target, current, value]) => follower.follow(target, current, value, options),
+    { flush: "post", immediate: true }
+  );
+}
+exports.useShell = useShell;
+exports.useShellEvent = useShellEvent;
+exports.useShellState = useShellState;
+exports.useSurface = useSurface;
+exports.useSurfaceFocus = useSurfaceFocus;
+Object.keys(pluginShell).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginShell[k]
+  });
+});
+//# sourceMappingURL=shell.cjs.map

package/dist/shell.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell.cjs","sources":["../src/shell.ts"],"sourcesContent":["/**\n * @embedpdf/vue/shell: the Vue surface of `@embedpdf/plugin-shell`. The app\n * owns every surface's DOM; these composables bind its open/closed state to the\n * kernel, so commands can drive it and an app can save and restore it.\n *\n * They work without a document: shell state is per document, and chrome that\n * uses it (panel buttons, menu anchors) stays mounted across the empty\n * workspace. With no document every surface reads as closed, no menu as open,\n * and `useSurface`'s verbs do nothing; `useShell()` is then the stand-in, whose\n * methods throw `not-ready`.\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-shell';\nimport { toValue, watch } from 'vue';\nimport type { MaybeRefOrGetter, Ref } from 'vue';\nimport { ShellToken, shellState } from '@embedpdf/plugin-shell';\nimport type { OpenSurfaceOptions, ShellCapability, SurfaceProps } from '@embedpdf/plugin-shell';\nimport type { EventHook } from '@embedpdf/core';\nimport { createSurfaceFocusFollower, type SurfaceFocusOptions } from '@embedpdf/web';\nimport {\n  useCapability,\n  useCapabilityEvent,\n  useOptionalCapability,\n  useOptionalSelector,\n} from './runtime/capabilities';\nimport { stateComposable } from './state';\n\n/** The shell API: open and close panels, dialogs and menus. Without a document its methods throw `not-ready`. */\nexport function useShell(): ShellCapability {\n  return useCapability(ShellToken);\n}\n\n/** Subscribe to one shell event while the component lives: `useShellEvent((shell) => shell.onSurfaceOpened, handler)`. */\nexport function useShellEvent<Event>(\n  select: (shell: ShellCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(ShellToken, select, handler);\n}\n\n/**\n * Which panels, dialogs and menus are open, as refs (the page's State table,\n * declared once in `shellState`). With a selector, one ref, which updates only\n * when what it picks changes. Without a document nothing is open.\n */\nexport const useShellState = stateComposable(shellState);\n\n/** One surface, as {@link useSurface} gives it: its state as refs, and the verbs. */\nexport interface SurfaceHandle {\n  /** Whether the surface is open. */\n  readonly isOpen: Readonly<Ref<boolean>>;\n  /** The props the surface was opened with, or updated to; empty when it has none. */\n  readonly props: Readonly<Ref<SurfaceProps>>;\n  open(options?: OpenSurfaceOptions): void;\n  close(): void;\n  toggle(options?: OpenSurfaceOptions): void;\n}\n\nconst NO_PROPS: SurfaceProps = Object.freeze({});\n\n/**\n * One named surface (a panel, a dialog, an overlay) of this subtree's\n * document: `const { isOpen, toggle } = useSurface('comments')`. Its state is\n * refs, so destructuring keeps them reactive; pass a getter for an id that\n * changes. Reads as closed, and its verbs do nothing, while no document is open.\n */\nexport function useSurface(id: MaybeRefOrGetter<string>): SurfaceHandle {\n  const shell = useOptionalCapability(ShellToken);\n  const isOpen = useOptionalSelector(ShellToken, (current) => current.isOpen(toValue(id)), false);\n  const props = useOptionalSelector(\n    ShellToken,\n    (current) => current.getSurface(toValue(id))?.props ?? NO_PROPS,\n    NO_PROPS,\n  );\n  return Object.freeze({\n    isOpen,\n    props,\n    open: (options?: OpenSurfaceOptions) => shell.value?.open(toValue(id), options),\n    close: () => shell.value?.close(toValue(id)),\n    toggle: (options?: OpenSurfaceOptions) => shell.value?.toggle(toValue(id), options),\n  });\n}\n\nexport type { SurfaceFocusOptions };\n\n/**\n * Put the cursor in an element when the surface `id` asks for it: on every\n * `open(id, { focus: true })`, a command whose panel says `focus` among them, and\n * when the element mounts while the request is up (the panel opened, or its code\n * loaded, because of it). A plain open never moves it. `element` is a template\n * ref (`useTemplateRef('field')`); `select` selects an input's text, so typing\n * replaces it. Reads the surface of this subtree's document.\n */\nexport function useSurfaceFocus(\n  id: MaybeRefOrGetter<string>,\n  element: MaybeRefOrGetter<HTMLElement | null | undefined>,\n  options: SurfaceFocusOptions = {},\n): void {\n  const shell = useOptionalCapability(ShellToken);\n  const request = useOptionalSelector(\n    ShellToken,\n    (current) => current.getSurface(toValue(id))?.focusRequest ?? 0,\n    0,\n  );\n  const follower = createSurfaceFocusFollower();\n  // After the DOM updates, so an element that has just mounted is there to take focus.\n  watch(\n    () => [toValue(element) ?? null, shell.value, request.value] as const,\n    ([target, current, value]) => follower.follow(target, current, value, options),\n    { flush: 'post', immediate: true },\n  );\n}\n"],"names":["useCapability","ShellToken","useCapabilityEvent","stateComposable","shellState","useOptionalCapability","useOptionalSelector","toValue","createSurfaceFocusFollower","watch"],"mappings":";;;;;;;AA6BO,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;AAavD,MAAM,WAAyB,OAAO,OAAO,EAAE;AAQxC,SAAS,WAAW,IAA6C;AACtE,QAAM,QAAQC,aAAAA,sBAAsBJ,sBAAU;AAC9C,QAAM,SAASK,aAAAA,oBAAoBL,YAAAA,YAAY,CAAC,YAAY,QAAQ,OAAOM,IAAAA,QAAQ,EAAE,CAAC,GAAG,KAAK;AAC9F,QAAM,QAAQD,aAAAA;AAAAA,IACZL,YAAAA;AAAAA,IACA,CAAC;;AAAY,4BAAQ,WAAWM,IAAAA,QAAQ,EAAE,CAAC,MAA9B,mBAAiC,UAAS;AAAA;AAAA,IACvD;AAAA,EAAA;AAEF,SAAO,OAAO,OAAO;AAAA,IACnB;AAAA,IACA;AAAA,IACA,MAAM,CAAC,YAAA;;AAAiC,yBAAM,UAAN,mBAAa,KAAKA,IAAAA,QAAQ,EAAE,GAAG;AAAA;AAAA,IACvE,OAAO,MAAA;;AAAM,yBAAM,UAAN,mBAAa,MAAMA,IAAAA,QAAQ,EAAE;AAAA;AAAA,IAC1C,QAAQ,CAAC,YAAA;;AAAiC,yBAAM,UAAN,mBAAa,OAAOA,IAAAA,QAAQ,EAAE,GAAG;AAAA;AAAA,EAAO,CACnF;AACH;AAYO,SAAS,gBACd,IACA,SACA,UAA+B,CAAA,GACzB;AACN,QAAM,QAAQF,aAAAA,sBAAsBJ,sBAAU;AAC9C,QAAM,UAAUK,aAAAA;AAAAA,IACdL,YAAAA;AAAAA,IACA,CAAC;;AAAY,4BAAQ,WAAWM,IAAAA,QAAQ,EAAE,CAAC,MAA9B,mBAAiC,iBAAgB;AAAA;AAAA,IAC9D;AAAA,EAAA;AAEF,QAAM,WAAWC,IAAAA,2BAAA;AAEjBC,MAAAA;AAAAA,IACE,MAAM,CAACF,IAAAA,QAAQ,OAAO,KAAK,MAAM,MAAM,OAAO,QAAQ,KAAK;AAAA,IAC3D,CAAC,CAAC,QAAQ,SAAS,KAAK,MAAM,SAAS,OAAO,QAAQ,SAAS,OAAO,OAAO;AAAA,IAC7E,EAAE,OAAO,QAAQ,WAAW,KAAA;AAAA,EAAK;AAErC;;;;;;;;;;;;"}

package/dist/shell.d.cts

@@ -0,0 +1,56 @@
+/**
+ * @embedpdf/vue/shell: the Vue surface of `@embedpdf/plugin-shell`. The app
+ * owns every surface's DOM; these composables bind its open/closed state to the
+ * kernel, so commands can drive it and an app can save and restore it.
+ *
+ * They work without a document: shell state is per document, and chrome that
+ * uses it (panel buttons, menu anchors) stays mounted across the empty
+ * workspace. With no document every surface reads as closed, no menu as open,
+ * and `useSurface`'s verbs do nothing; `useShell()` is then the stand-in, whose
+ * methods throw `not-ready`.
+ */
+export * from '@embedpdf/plugin-shell';
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { OpenSurfaceOptions, ShellCapability, SurfaceProps } from '@embedpdf/plugin-shell';
+import type { EventHook } from '@embedpdf/core';
+import { type SurfaceFocusOptions } from '@embedpdf/web';
+/** The shell API: open and close panels, dialogs and menus. Without a document its methods throw `not-ready`. */
+export declare function useShell(): ShellCapability;
+/** Subscribe to one shell event while the component lives: `useShellEvent((shell) => shell.onSurfaceOpened, handler)`. */
+export declare function useShellEvent<Event>(select: (shell: ShellCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * Which panels, dialogs and menus are open, as refs (the page's State table,
+ * declared once in `shellState`). With a selector, one ref, which updates only
+ * when what it picks changes. Without a document nothing is open.
+ */
+export declare const useShellState: import("./state.cjs").StateComposable<{
+    openSurfaces: readonly import("@embedpdf/plugin-shell").SurfaceState[];
+    openMenus: readonly string[];
+}>;
+/** One surface, as {@link useSurface} gives it: its state as refs, and the verbs. */
+export interface SurfaceHandle {
+    /** Whether the surface is open. */
+    readonly isOpen: Readonly<Ref<boolean>>;
+    /** The props the surface was opened with, or updated to; empty when it has none. */
+    readonly props: Readonly<Ref<SurfaceProps>>;
+    open(options?: OpenSurfaceOptions): void;
+    close(): void;
+    toggle(options?: OpenSurfaceOptions): void;
+}
+/**
+ * One named surface (a panel, a dialog, an overlay) of this subtree's
+ * document: `const { isOpen, toggle } = useSurface('comments')`. Its state is
+ * refs, so destructuring keeps them reactive; pass a getter for an id that
+ * changes. Reads as closed, and its verbs do nothing, while no document is open.
+ */
+export declare function useSurface(id: MaybeRefOrGetter<string>): SurfaceHandle;
+export type { SurfaceFocusOptions };
+/**
+ * Put the cursor in an element when the surface `id` asks for it: on every
+ * `open(id, { focus: true })`, a command whose panel says `focus` among them, and
+ * when the element mounts while the request is up (the panel opened, or its code
+ * loaded, because of it). A plain open never moves it. `element` is a template
+ * ref (`useTemplateRef('field')`); `select` selects an input's text, so typing
+ * replaces it. Reads the surface of this subtree's document.
+ */
+export declare function useSurfaceFocus(id: MaybeRefOrGetter<string>, element: MaybeRefOrGetter<HTMLElement | null | undefined>, options?: SurfaceFocusOptions): void;

package/dist/shell.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @embedpdf/vue/shell: the Vue surface of `@embedpdf/plugin-shell`. The app
+ * owns every surface's DOM; these composables bind its open/closed state to the
+ * kernel, so commands can drive it and an app can save and restore it.
+ *
+ * They work without a document: shell state is per document, and chrome that
+ * uses it (panel buttons, menu anchors) stays mounted across the empty
+ * workspace. With no document every surface reads as closed, no menu as open,
+ * and `useSurface`'s verbs do nothing; `useShell()` is then the stand-in, whose
+ * methods throw `not-ready`.
+ */
+export * from '@embedpdf/plugin-shell';
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { OpenSurfaceOptions, ShellCapability, SurfaceProps } from '@embedpdf/plugin-shell';
+import type { EventHook } from '@embedpdf/core';
+import { type SurfaceFocusOptions } from '@embedpdf/web';
+/** The shell API: open and close panels, dialogs and menus. Without a document its methods throw `not-ready`. */
+export declare function useShell(): ShellCapability;
+/** Subscribe to one shell event while the component lives: `useShellEvent((shell) => shell.onSurfaceOpened, handler)`. */
+export declare function useShellEvent<Event>(select: (shell: ShellCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * Which panels, dialogs and menus are open, as refs (the page's State table,
+ * declared once in `shellState`). With a selector, one ref, which updates only
+ * when what it picks changes. Without a document nothing is open.
+ */
+export declare const useShellState: import("./state.js").StateComposable<{
+    openSurfaces: readonly import("@embedpdf/plugin-shell").SurfaceState[];
+    openMenus: readonly string[];
+}>;
+/** One surface, as {@link useSurface} gives it: its state as refs, and the verbs. */
+export interface SurfaceHandle {
+    /** Whether the surface is open. */
+    readonly isOpen: Readonly<Ref<boolean>>;
+    /** The props the surface was opened with, or updated to; empty when it has none. */
+    readonly props: Readonly<Ref<SurfaceProps>>;
+    open(options?: OpenSurfaceOptions): void;
+    close(): void;
+    toggle(options?: OpenSurfaceOptions): void;
+}
+/**
+ * One named surface (a panel, a dialog, an overlay) of this subtree's
+ * document: `const { isOpen, toggle } = useSurface('comments')`. Its state is
+ * refs, so destructuring keeps them reactive; pass a getter for an id that
+ * changes. Reads as closed, and its verbs do nothing, while no document is open.
+ */
+export declare function useSurface(id: MaybeRefOrGetter<string>): SurfaceHandle;
+export type { SurfaceFocusOptions };
+/**
+ * Put the cursor in an element when the surface `id` asks for it: on every
+ * `open(id, { focus: true })`, a command whose panel says `focus` among them, and
+ * when the element mounts while the request is up (the panel opened, or its code
+ * loaded, because of it). A plain open never moves it. `element` is a template
+ * ref (`useTemplateRef('field')`); `select` selects an input's text, so typing
+ * replaces it. Reads the surface of this subtree's document.
+ */
+export declare function useSurfaceFocus(id: MaybeRefOrGetter<string>, element: MaybeRefOrGetter<HTMLElement | null | undefined>, options?: SurfaceFocusOptions): void;

package/dist/shell.js

@@ -0,0 +1,67 @@
+import { ShellToken, shellState } from "@embedpdf/plugin-shell";
+export * from "@embedpdf/plugin-shell";
+import { toValue, watch } from "vue";
+import { createSurfaceFocusFollower } from "@embedpdf/web";
+import { a as useCapability, b as useCapabilityEvent, h as useOptionalCapability, i as useOptionalSelector } from "./capabilities-C7YzgPCX.js";
+import { a as stateComposable } from "./state-DZg8q3v6.js";
+function useShell() {
+  return useCapability(ShellToken);
+}
+function useShellEvent(select, handler) {
+  useCapabilityEvent(ShellToken, select, handler);
+}
+const useShellState = stateComposable(shellState);
+const NO_PROPS = Object.freeze({});
+function useSurface(id) {
+  const shell = useOptionalCapability(ShellToken);
+  const isOpen = useOptionalSelector(ShellToken, (current) => current.isOpen(toValue(id)), false);
+  const props = useOptionalSelector(
+    ShellToken,
+    (current) => {
+      var _a;
+      return ((_a = current.getSurface(toValue(id))) == null ? void 0 : _a.props) ?? NO_PROPS;
+    },
+    NO_PROPS
+  );
+  return Object.freeze({
+    isOpen,
+    props,
+    open: (options) => {
+      var _a;
+      return (_a = shell.value) == null ? void 0 : _a.open(toValue(id), options);
+    },
+    close: () => {
+      var _a;
+      return (_a = shell.value) == null ? void 0 : _a.close(toValue(id));
+    },
+    toggle: (options) => {
+      var _a;
+      return (_a = shell.value) == null ? void 0 : _a.toggle(toValue(id), options);
+    }
+  });
+}
+function useSurfaceFocus(id, element, options = {}) {
+  const shell = useOptionalCapability(ShellToken);
+  const request = useOptionalSelector(
+    ShellToken,
+    (current) => {
+      var _a;
+      return ((_a = current.getSurface(toValue(id))) == null ? void 0 : _a.focusRequest) ?? 0;
+    },
+    0
+  );
+  const follower = createSurfaceFocusFollower();
+  watch(
+    () => [toValue(element) ?? null, shell.value, request.value],
+    ([target, current, value]) => follower.follow(target, current, value, options),
+    { flush: "post", immediate: true }
+  );
+}
+export {
+  useShell,
+  useShellEvent,
+  useShellState,
+  useSurface,
+  useSurfaceFocus
+};
+//# sourceMappingURL=shell.js.map

package/dist/shell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell.js","sources":["../src/shell.ts"],"sourcesContent":["/**\n * @embedpdf/vue/shell: the Vue surface of `@embedpdf/plugin-shell`. The app\n * owns every surface's DOM; these composables bind its open/closed state to the\n * kernel, so commands can drive it and an app can save and restore it.\n *\n * They work without a document: shell state is per document, and chrome that\n * uses it (panel buttons, menu anchors) stays mounted across the empty\n * workspace. With no document every surface reads as closed, no menu as open,\n * and `useSurface`'s verbs do nothing; `useShell()` is then the stand-in, whose\n * methods throw `not-ready`.\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-shell';\nimport { toValue, watch } from 'vue';\nimport type { MaybeRefOrGetter, Ref } from 'vue';\nimport { ShellToken, shellState } from '@embedpdf/plugin-shell';\nimport type { OpenSurfaceOptions, ShellCapability, SurfaceProps } from '@embedpdf/plugin-shell';\nimport type { EventHook } from '@embedpdf/core';\nimport { createSurfaceFocusFollower, type SurfaceFocusOptions } from '@embedpdf/web';\nimport {\n  useCapability,\n  useCapabilityEvent,\n  useOptionalCapability,\n  useOptionalSelector,\n} from './runtime/capabilities';\nimport { stateComposable } from './state';\n\n/** The shell API: open and close panels, dialogs and menus. Without a document its methods throw `not-ready`. */\nexport function useShell(): ShellCapability {\n  return useCapability(ShellToken);\n}\n\n/** Subscribe to one shell event while the component lives: `useShellEvent((shell) => shell.onSurfaceOpened, handler)`. */\nexport function useShellEvent<Event>(\n  select: (shell: ShellCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(ShellToken, select, handler);\n}\n\n/**\n * Which panels, dialogs and menus are open, as refs (the page's State table,\n * declared once in `shellState`). With a selector, one ref, which updates only\n * when what it picks changes. Without a document nothing is open.\n */\nexport const useShellState = stateComposable(shellState);\n\n/** One surface, as {@link useSurface} gives it: its state as refs, and the verbs. */\nexport interface SurfaceHandle {\n  /** Whether the surface is open. */\n  readonly isOpen: Readonly<Ref<boolean>>;\n  /** The props the surface was opened with, or updated to; empty when it has none. */\n  readonly props: Readonly<Ref<SurfaceProps>>;\n  open(options?: OpenSurfaceOptions): void;\n  close(): void;\n  toggle(options?: OpenSurfaceOptions): void;\n}\n\nconst NO_PROPS: SurfaceProps = Object.freeze({});\n\n/**\n * One named surface (a panel, a dialog, an overlay) of this subtree's\n * document: `const { isOpen, toggle } = useSurface('comments')`. Its state is\n * refs, so destructuring keeps them reactive; pass a getter for an id that\n * changes. Reads as closed, and its verbs do nothing, while no document is open.\n */\nexport function useSurface(id: MaybeRefOrGetter<string>): SurfaceHandle {\n  const shell = useOptionalCapability(ShellToken);\n  const isOpen = useOptionalSelector(ShellToken, (current) => current.isOpen(toValue(id)), false);\n  const props = useOptionalSelector(\n    ShellToken,\n    (current) => current.getSurface(toValue(id))?.props ?? NO_PROPS,\n    NO_PROPS,\n  );\n  return Object.freeze({\n    isOpen,\n    props,\n    open: (options?: OpenSurfaceOptions) => shell.value?.open(toValue(id), options),\n    close: () => shell.value?.close(toValue(id)),\n    toggle: (options?: OpenSurfaceOptions) => shell.value?.toggle(toValue(id), options),\n  });\n}\n\nexport type { SurfaceFocusOptions };\n\n/**\n * Put the cursor in an element when the surface `id` asks for it: on every\n * `open(id, { focus: true })`, a command whose panel says `focus` among them, and\n * when the element mounts while the request is up (the panel opened, or its code\n * loaded, because of it). A plain open never moves it. `element` is a template\n * ref (`useTemplateRef('field')`); `select` selects an input's text, so typing\n * replaces it. Reads the surface of this subtree's document.\n */\nexport function useSurfaceFocus(\n  id: MaybeRefOrGetter<string>,\n  element: MaybeRefOrGetter<HTMLElement | null | undefined>,\n  options: SurfaceFocusOptions = {},\n): void {\n  const shell = useOptionalCapability(ShellToken);\n  const request = useOptionalSelector(\n    ShellToken,\n    (current) => current.getSurface(toValue(id))?.focusRequest ?? 0,\n    0,\n  );\n  const follower = createSurfaceFocusFollower();\n  // After the DOM updates, so an element that has just mounted is there to take focus.\n  watch(\n    () => [toValue(element) ?? null, shell.value, request.value] as const,\n    ([target, current, value]) => follower.follow(target, current, value, options),\n    { flush: 'post', immediate: true },\n  );\n}\n"],"names":[],"mappings":";;;;;;AA6BO,SAAS,WAA4B;AAC1C,SAAO,cAAc,UAAU;AACjC;AAGO,SAAS,cACd,QACA,SACM;AACN,qBAAmB,YAAY,QAAQ,OAAO;AAChD;AAOO,MAAM,gBAAgB,gBAAgB,UAAU;AAavD,MAAM,WAAyB,OAAO,OAAO,EAAE;AAQxC,SAAS,WAAW,IAA6C;AACtE,QAAM,QAAQ,sBAAsB,UAAU;AAC9C,QAAM,SAAS,oBAAoB,YAAY,CAAC,YAAY,QAAQ,OAAO,QAAQ,EAAE,CAAC,GAAG,KAAK;AAC9F,QAAM,QAAQ;AAAA,IACZ;AAAA,IACA,CAAC;;AAAY,4BAAQ,WAAW,QAAQ,EAAE,CAAC,MAA9B,mBAAiC,UAAS;AAAA;AAAA,IACvD;AAAA,EAAA;AAEF,SAAO,OAAO,OAAO;AAAA,IACnB;AAAA,IACA;AAAA,IACA,MAAM,CAAC,YAAA;;AAAiC,yBAAM,UAAN,mBAAa,KAAK,QAAQ,EAAE,GAAG;AAAA;AAAA,IACvE,OAAO,MAAA;;AAAM,yBAAM,UAAN,mBAAa,MAAM,QAAQ,EAAE;AAAA;AAAA,IAC1C,QAAQ,CAAC,YAAA;;AAAiC,yBAAM,UAAN,mBAAa,OAAO,QAAQ,EAAE,GAAG;AAAA;AAAA,EAAO,CACnF;AACH;AAYO,SAAS,gBACd,IACA,SACA,UAA+B,CAAA,GACzB;AACN,QAAM,QAAQ,sBAAsB,UAAU;AAC9C,QAAM,UAAU;AAAA,IACd;AAAA,IACA,CAAC;;AAAY,4BAAQ,WAAW,QAAQ,EAAE,CAAC,MAA9B,mBAAiC,iBAAgB;AAAA;AAAA,IAC9D;AAAA,EAAA;AAEF,QAAM,WAAW,2BAAA;AAEjB;AAAA,IACE,MAAM,CAAC,QAAQ,OAAO,KAAK,MAAM,MAAM,OAAO,QAAQ,KAAK;AAAA,IAC3D,CAAC,CAAC,QAAQ,SAAS,KAAK,MAAM,SAAS,OAAO,QAAQ,SAAS,OAAO,OAAO;AAAA,IAC7E,EAAE,OAAO,QAAQ,WAAW,KAAA;AAAA,EAAK;AAErC;"}

package/dist/signature/composables.d.cts

@@ -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.cjs';
+/**
+ * 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.cjs").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[]>>;