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

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[]>>;

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