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

package/dist/interaction/PagePointerSource.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/interaction/PagePointerSource.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/interaction.cjs

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginInteraction = require("@embedpdf/plugin-interaction");
+const web = require("@embedpdf/web");
+const vue = require("vue");
+const host = require("@embedpdf/plugin-interaction/contract/host");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+const state = require("./state-M22NDJQo.cjs");
+const PagePointerSource_vue_vue_type_script_setup_true_lang = require("./PagePointerSource.vue_vue_type_script_setup_true_lang-Cw29c8Oa.cjs");
+function useInteraction() {
+  return capabilities.useCapability(pluginInteraction.InteractionToken);
+}
+function useInteractionEvent(select, handler) {
+  capabilities.useCapabilityEvent(pluginInteraction.InteractionToken, select, handler);
+}
+const useInteractionState = state.stateComposable(pluginInteraction.interactionState);
+const useInteractionSettings = state.settingsComposable(pluginInteraction.InteractionToken);
+function useToolCursor(spec) {
+  const interaction = capabilities.useOptionalCapability(host.InteractionToken);
+  const key = vue.computed(() => {
+    const current = vue.toValue(spec);
+    return current ? JSON.stringify(current) : null;
+  });
+  vue.watch(
+    [interaction, key],
+    ([hub, json], _previous, onCleanup) => {
+      if (!hub || !json) return;
+      const { toolId, cursors } = JSON.parse(json);
+      hub.setToolCursor(toolId, web.toolCursorsOf(cursors));
+      onCleanup(() => hub.setToolCursor(toolId, null));
+    },
+    { immediate: true }
+  );
+}
+Object.defineProperty(exports, "createClickCounter", {
+  enumerable: true,
+  get: () => web.createClickCounter
+});
+Object.defineProperty(exports, "svgCursor", {
+  enumerable: true,
+  get: () => web.svgCursor
+});
+Object.defineProperty(exports, "vibrationFeedback", {
+  enumerable: true,
+  get: () => web.vibrationFeedback
+});
+Object.defineProperty(exports, "wkFeedback", {
+  enumerable: true,
+  get: () => web.wkFeedback
+});
+exports.PagePointerSource = PagePointerSource_vue_vue_type_script_setup_true_lang._sfc_main;
+exports.useInteraction = useInteraction;
+exports.useInteractionEvent = useInteractionEvent;
+exports.useInteractionSettings = useInteractionSettings;
+exports.useInteractionState = useInteractionState;
+exports.useToolCursor = useToolCursor;
+Object.keys(pluginInteraction).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginInteraction[k]
+  });
+});
+//# sourceMappingURL=interaction.cjs.map

package/dist/interaction.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction.cjs","sources":["../src/interaction.ts"],"sourcesContent":["/**\n * @embedpdf/vue/interaction: the Vue surface of `@embedpdf/plugin-interaction`.\n * `<PagePointerSource>` is a page's one pointer listener; the composables switch\n * tools, read the tools' state and settings, follow the hub's events, and give\n * a tool its own cursor.\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-interaction';\n// The browser helpers live in @embedpdf/web (the plugin is DOM-free); they are\n// re-exported here so app code has one import for the feature.\nexport { createClickCounter, svgCursor, vibrationFeedback, wkFeedback } from '@embedpdf/web';\nexport type { SvgCursorOptions, ToolCursorImage, ToolCursorSpec } from '@embedpdf/web';\nimport { computed, toValue, watch } from 'vue';\nimport type { MaybeRefOrGetter } from 'vue';\nimport { InteractionToken as InteractionHostToken } from '@embedpdf/plugin-interaction/contract/host';\nimport { InteractionToken, interactionState } from '@embedpdf/plugin-interaction';\nimport type { InteractionCapability } from '@embedpdf/plugin-interaction';\nimport type { EventHook } from '@embedpdf/core';\nimport { toolCursorsOf } from '@embedpdf/web';\nimport type { ToolCursorSpec } from '@embedpdf/web';\nimport { useCapability, useCapabilityEvent, useOptionalCapability } from './runtime/capabilities';\nimport { settingsComposable, stateComposable } from './state';\n\nexport { default as PagePointerSource } from './interaction/PagePointerSource.vue';\n\n/** The interaction API: switch tools, add your own, set their cursors. The object never changes. */\nexport function useInteraction(): InteractionCapability {\n  return useCapability(InteractionToken);\n}\n\n/** Subscribe to one interaction event while the component lives: `useInteractionEvent((interaction) => interaction.onGestureStarted, handler)`. */\nexport function useInteractionEvent<Event>(\n  select: (interaction: InteractionCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(InteractionToken, select, handler);\n}\n\n/**\n * The tools' state as refs: the active tool's id and every tool you can\n * switch to (the page's State table, declared once in `interactionState`).\n * With a selector, one ref. Without a document there is no active tool\n * (`null`) and no tool.\n */\nexport const useInteractionState = stateComposable(interactionState);\n\n/** The interaction settings (`defaultTool`, `tools`), with or without a document, as refs. Takes a selector. */\nexport const useInteractionSettings = settingsComposable(InteractionToken);\n\n/**\n * Give a tool image cursors: the armed-tool indicator. The hub already decides\n * which cursor shows (hover claims over annotations and text win, the gaps\n * between pages show the tool's `gapCursor`), so nothing chases the pointer in\n * the DOM. Pass a getter to follow your values: a new spec rebuilds the cursor\n * (a color picked in your toolbar), and the component's unmount restores the\n * tool's own cursors. `null` installs nothing; without a document it installs\n * nothing until one is ready.\n */\nexport function useToolCursor(spec: MaybeRefOrGetter<ToolCursorSpec | null>): void {\n  const interaction = useOptionalCapability(InteractionHostToken);\n  // By value: a getter builds a new object each time, and an equal one must\n  // not rebuild the cursor.\n  const key = computed(() => {\n    const current = toValue(spec);\n    return current ? JSON.stringify(current) : null;\n  });\n  watch(\n    [interaction, key],\n    ([hub, json], _previous, onCleanup) => {\n      if (!hub || !json) return;\n      const { toolId, cursors } = JSON.parse(json) as ToolCursorSpec;\n      hub.setToolCursor(toolId, toolCursorsOf(cursors));\n      onCleanup(() => hub.setToolCursor(toolId, null));\n    },\n    { immediate: true },\n  );\n}\n"],"names":["useCapability","InteractionToken","useCapabilityEvent","stateComposable","interactionState","settingsComposable","useOptionalCapability","InteractionHostToken","computed","toValue","watch","toolCursorsOf"],"mappings":";;;;;;;;;AA2BO,SAAS,iBAAwC;AACtD,SAAOA,aAAAA,cAAcC,kBAAAA,gBAAgB;AACvC;AAGO,SAAS,oBACd,QACA,SACM;AACNC,kCAAmBD,kBAAAA,kBAAkB,QAAQ,OAAO;AACtD;AAQO,MAAM,sBAAsBE,MAAAA,gBAAgBC,kBAAAA,gBAAgB;AAG5D,MAAM,yBAAyBC,MAAAA,mBAAmBJ,kBAAAA,gBAAgB;AAWlE,SAAS,cAAc,MAAqD;AACjF,QAAM,cAAcK,aAAAA,sBAAsBC,qBAAoB;AAG9D,QAAM,MAAMC,IAAAA,SAAS,MAAM;AACzB,UAAM,UAAUC,IAAAA,QAAQ,IAAI;AAC5B,WAAO,UAAU,KAAK,UAAU,OAAO,IAAI;AAAA,EAC7C,CAAC;AACDC,MAAAA;AAAAA,IACE,CAAC,aAAa,GAAG;AAAA,IACjB,CAAC,CAAC,KAAK,IAAI,GAAG,WAAW,cAAc;AACrC,UAAI,CAAC,OAAO,CAAC,KAAM;AACnB,YAAM,EAAE,QAAQ,QAAA,IAAY,KAAK,MAAM,IAAI;AAC3C,UAAI,cAAc,QAAQC,IAAAA,cAAc,OAAO,CAAC;AAChD,gBAAU,MAAM,IAAI,cAAc,QAAQ,IAAI,CAAC;AAAA,IACjD;AAAA,IACA,EAAE,WAAW,KAAA;AAAA,EAAK;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/interaction.d.cts

@@ -0,0 +1,40 @@
+/**
+ * @embedpdf/vue/interaction: the Vue surface of `@embedpdf/plugin-interaction`.
+ * `<PagePointerSource>` is a page's one pointer listener; the composables switch
+ * tools, read the tools' state and settings, follow the hub's events, and give
+ * a tool its own cursor.
+ */
+export * from '@embedpdf/plugin-interaction';
+export { createClickCounter, svgCursor, vibrationFeedback, wkFeedback } from '@embedpdf/web';
+export type { SvgCursorOptions, ToolCursorImage, ToolCursorSpec } from '@embedpdf/web';
+import type { MaybeRefOrGetter } from 'vue';
+import type { InteractionCapability } from '@embedpdf/plugin-interaction';
+import type { EventHook } from '@embedpdf/core';
+import type { ToolCursorSpec } from '@embedpdf/web';
+export { default as PagePointerSource } from './interaction/PagePointerSource.vue.cjs';
+/** The interaction API: switch tools, add your own, set their cursors. The object never changes. */
+export declare function useInteraction(): InteractionCapability;
+/** Subscribe to one interaction event while the component lives: `useInteractionEvent((interaction) => interaction.onGestureStarted, handler)`. */
+export declare function useInteractionEvent<Event>(select: (interaction: InteractionCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The tools' state as refs: the active tool's id and every tool you can
+ * switch to (the page's State table, declared once in `interactionState`).
+ * With a selector, one ref. Without a document there is no active tool
+ * (`null`) and no tool.
+ */
+export declare const useInteractionState: import("./state.cjs").StateComposable<{
+    activeToolId: import("@embedpdf/plugin-interaction").ToolId | null;
+    tools: readonly import("@embedpdf/plugin-interaction").Tool[];
+}>;
+/** The interaction settings (`defaultTool`, `tools`), with or without a document, as refs. Takes a selector. */
+export declare const useInteractionSettings: import("./state.cjs").SettingsComposable<import("@embedpdf/plugin-interaction").InteractionSettings & object>;
+/**
+ * Give a tool image cursors: the armed-tool indicator. The hub already decides
+ * which cursor shows (hover claims over annotations and text win, the gaps
+ * between pages show the tool's `gapCursor`), so nothing chases the pointer in
+ * the DOM. Pass a getter to follow your values: a new spec rebuilds the cursor
+ * (a color picked in your toolbar), and the component's unmount restores the
+ * tool's own cursors. `null` installs nothing; without a document it installs
+ * nothing until one is ready.
+ */
+export declare function useToolCursor(spec: MaybeRefOrGetter<ToolCursorSpec | null>): void;

package/dist/interaction.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @embedpdf/vue/interaction: the Vue surface of `@embedpdf/plugin-interaction`.
+ * `<PagePointerSource>` is a page's one pointer listener; the composables switch
+ * tools, read the tools' state and settings, follow the hub's events, and give
+ * a tool its own cursor.
+ */
+export * from '@embedpdf/plugin-interaction';
+export { createClickCounter, svgCursor, vibrationFeedback, wkFeedback } from '@embedpdf/web';
+export type { SvgCursorOptions, ToolCursorImage, ToolCursorSpec } from '@embedpdf/web';
+import type { MaybeRefOrGetter } from 'vue';
+import type { InteractionCapability } from '@embedpdf/plugin-interaction';
+import type { EventHook } from '@embedpdf/core';
+import type { ToolCursorSpec } from '@embedpdf/web';
+export { default as PagePointerSource } from './interaction/PagePointerSource.vue.js';
+/** The interaction API: switch tools, add your own, set their cursors. The object never changes. */
+export declare function useInteraction(): InteractionCapability;
+/** Subscribe to one interaction event while the component lives: `useInteractionEvent((interaction) => interaction.onGestureStarted, handler)`. */
+export declare function useInteractionEvent<Event>(select: (interaction: InteractionCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The tools' state as refs: the active tool's id and every tool you can
+ * switch to (the page's State table, declared once in `interactionState`).
+ * With a selector, one ref. Without a document there is no active tool
+ * (`null`) and no tool.
+ */
+export declare const useInteractionState: import("./state.js").StateComposable<{
+    activeToolId: import("@embedpdf/plugin-interaction").ToolId | null;
+    tools: readonly import("@embedpdf/plugin-interaction").Tool[];
+}>;
+/** The interaction settings (`defaultTool`, `tools`), with or without a document, as refs. Takes a selector. */
+export declare const useInteractionSettings: import("./state.js").SettingsComposable<import("@embedpdf/plugin-interaction").InteractionSettings & object>;
+/**
+ * Give a tool image cursors: the armed-tool indicator. The hub already decides
+ * which cursor shows (hover claims over annotations and text win, the gaps
+ * between pages show the tool's `gapCursor`), so nothing chases the pointer in
+ * the DOM. Pass a getter to follow your values: a new spec rebuilds the cursor
+ * (a color picked in your toolbar), and the component's unmount restores the
+ * tool's own cursors. `null` installs nothing; without a document it installs
+ * nothing until one is ready.
+ */
+export declare function useToolCursor(spec: MaybeRefOrGetter<ToolCursorSpec | null>): void;

package/dist/interaction.js

@@ -0,0 +1,47 @@
+import { InteractionToken, interactionState } from "@embedpdf/plugin-interaction";
+export * from "@embedpdf/plugin-interaction";
+import { toolCursorsOf } from "@embedpdf/web";
+import { createClickCounter, svgCursor, vibrationFeedback, wkFeedback } from "@embedpdf/web";
+import { computed, toValue, watch } from "vue";
+import { InteractionToken as InteractionToken$1 } from "@embedpdf/plugin-interaction/contract/host";
+import { a as useCapability, b as useCapabilityEvent, h as useOptionalCapability } from "./capabilities-C7YzgPCX.js";
+import { s as settingsComposable, a as stateComposable } from "./state-DZg8q3v6.js";
+import { _ } from "./PagePointerSource.vue_vue_type_script_setup_true_lang-CJt3vdBW.js";
+function useInteraction() {
+  return useCapability(InteractionToken);
+}
+function useInteractionEvent(select, handler) {
+  useCapabilityEvent(InteractionToken, select, handler);
+}
+const useInteractionState = stateComposable(interactionState);
+const useInteractionSettings = settingsComposable(InteractionToken);
+function useToolCursor(spec) {
+  const interaction = useOptionalCapability(InteractionToken$1);
+  const key = computed(() => {
+    const current = toValue(spec);
+    return current ? JSON.stringify(current) : null;
+  });
+  watch(
+    [interaction, key],
+    ([hub, json], _previous, onCleanup) => {
+      if (!hub || !json) return;
+      const { toolId, cursors } = JSON.parse(json);
+      hub.setToolCursor(toolId, toolCursorsOf(cursors));
+      onCleanup(() => hub.setToolCursor(toolId, null));
+    },
+    { immediate: true }
+  );
+}
+export {
+  _ as PagePointerSource,
+  createClickCounter,
+  svgCursor,
+  useInteraction,
+  useInteractionEvent,
+  useInteractionSettings,
+  useInteractionState,
+  useToolCursor,
+  vibrationFeedback,
+  wkFeedback
+};
+//# sourceMappingURL=interaction.js.map

package/dist/interaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction.js","sources":["../src/interaction.ts"],"sourcesContent":["/**\n * @embedpdf/vue/interaction: the Vue surface of `@embedpdf/plugin-interaction`.\n * `<PagePointerSource>` is a page's one pointer listener; the composables switch\n * tools, read the tools' state and settings, follow the hub's events, and give\n * a tool its own cursor.\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-interaction';\n// The browser helpers live in @embedpdf/web (the plugin is DOM-free); they are\n// re-exported here so app code has one import for the feature.\nexport { createClickCounter, svgCursor, vibrationFeedback, wkFeedback } from '@embedpdf/web';\nexport type { SvgCursorOptions, ToolCursorImage, ToolCursorSpec } from '@embedpdf/web';\nimport { computed, toValue, watch } from 'vue';\nimport type { MaybeRefOrGetter } from 'vue';\nimport { InteractionToken as InteractionHostToken } from '@embedpdf/plugin-interaction/contract/host';\nimport { InteractionToken, interactionState } from '@embedpdf/plugin-interaction';\nimport type { InteractionCapability } from '@embedpdf/plugin-interaction';\nimport type { EventHook } from '@embedpdf/core';\nimport { toolCursorsOf } from '@embedpdf/web';\nimport type { ToolCursorSpec } from '@embedpdf/web';\nimport { useCapability, useCapabilityEvent, useOptionalCapability } from './runtime/capabilities';\nimport { settingsComposable, stateComposable } from './state';\n\nexport { default as PagePointerSource } from './interaction/PagePointerSource.vue';\n\n/** The interaction API: switch tools, add your own, set their cursors. The object never changes. */\nexport function useInteraction(): InteractionCapability {\n  return useCapability(InteractionToken);\n}\n\n/** Subscribe to one interaction event while the component lives: `useInteractionEvent((interaction) => interaction.onGestureStarted, handler)`. */\nexport function useInteractionEvent<Event>(\n  select: (interaction: InteractionCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(InteractionToken, select, handler);\n}\n\n/**\n * The tools' state as refs: the active tool's id and every tool you can\n * switch to (the page's State table, declared once in `interactionState`).\n * With a selector, one ref. Without a document there is no active tool\n * (`null`) and no tool.\n */\nexport const useInteractionState = stateComposable(interactionState);\n\n/** The interaction settings (`defaultTool`, `tools`), with or without a document, as refs. Takes a selector. */\nexport const useInteractionSettings = settingsComposable(InteractionToken);\n\n/**\n * Give a tool image cursors: the armed-tool indicator. The hub already decides\n * which cursor shows (hover claims over annotations and text win, the gaps\n * between pages show the tool's `gapCursor`), so nothing chases the pointer in\n * the DOM. Pass a getter to follow your values: a new spec rebuilds the cursor\n * (a color picked in your toolbar), and the component's unmount restores the\n * tool's own cursors. `null` installs nothing; without a document it installs\n * nothing until one is ready.\n */\nexport function useToolCursor(spec: MaybeRefOrGetter<ToolCursorSpec | null>): void {\n  const interaction = useOptionalCapability(InteractionHostToken);\n  // By value: a getter builds a new object each time, and an equal one must\n  // not rebuild the cursor.\n  const key = computed(() => {\n    const current = toValue(spec);\n    return current ? JSON.stringify(current) : null;\n  });\n  watch(\n    [interaction, key],\n    ([hub, json], _previous, onCleanup) => {\n      if (!hub || !json) return;\n      const { toolId, cursors } = JSON.parse(json) as ToolCursorSpec;\n      hub.setToolCursor(toolId, toolCursorsOf(cursors));\n      onCleanup(() => hub.setToolCursor(toolId, null));\n    },\n    { immediate: true },\n  );\n}\n"],"names":["InteractionHostToken"],"mappings":";;;;;;;;;AA2BO,SAAS,iBAAwC;AACtD,SAAO,cAAc,gBAAgB;AACvC;AAGO,SAAS,oBACd,QACA,SACM;AACN,qBAAmB,kBAAkB,QAAQ,OAAO;AACtD;AAQO,MAAM,sBAAsB,gBAAgB,gBAAgB;AAG5D,MAAM,yBAAyB,mBAAmB,gBAAgB;AAWlE,SAAS,cAAc,MAAqD;AACjF,QAAM,cAAc,sBAAsBA,kBAAoB;AAG9D,QAAM,MAAM,SAAS,MAAM;AACzB,UAAM,UAAU,QAAQ,IAAI;AAC5B,WAAO,UAAU,KAAK,UAAU,OAAO,IAAI;AAAA,EAC7C,CAAC;AACD;AAAA,IACE,CAAC,aAAa,GAAG;AAAA,IACjB,CAAC,CAAC,KAAK,IAAI,GAAG,WAAW,cAAc;AACrC,UAAI,CAAC,OAAO,CAAC,KAAM;AACnB,YAAM,EAAE,QAAQ,QAAA,IAAY,KAAK,MAAM,IAAI;AAC3C,UAAI,cAAc,QAAQ,cAAc,OAAO,CAAC;AAChD,gBAAU,MAAM,IAAI,cAAc,QAAQ,IAAI,CAAC;AAAA,IACjD;AAAA,IACA,EAAE,WAAW,KAAA;AAAA,EAAK;AAEtB;"}

package/dist/link/LinkAnchor.vue.d.cts

@@ -0,0 +1,9 @@
+import type { Link } from '@embedpdf/plugin-link';
+import type { LinkLayerContext } from './composables.cjs';
+type __VLS_Props = {
+    item: Link;
+    layer: LinkLayerContext;
+};
+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/link/LinkAnchor.vue.d.ts

@@ -0,0 +1,9 @@
+import type { Link } from '@embedpdf/plugin-link';
+import type { LinkLayerContext } from './composables.js';
+type __VLS_Props = {
+    item: Link;
+    layer: LinkLayerContext;
+};
+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/link/LinkLayer.vue.d.cts

@@ -0,0 +1,22 @@
+import type { FunctionalComponent } from 'vue';
+import type { Link } from '@embedpdf/plugin-link';
+type __VLS_Slots = {
+    /**
+     * Draw a link yourself, usually around `native`, the layer's own clickable
+     * area: `<component :is="native" />` keeps what a click does. For a link you
+     * don't want to change, show `native` alone.
+     */
+    link?(props: {
+        link: Link;
+        native: FunctionalComponent;
+    }): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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/link/LinkLayer.vue.d.ts

@@ -0,0 +1,22 @@
+import type { FunctionalComponent } from 'vue';
+import type { Link } from '@embedpdf/plugin-link';
+type __VLS_Slots = {
+    /**
+     * Draw a link yourself, usually around `native`, the layer's own clickable
+     * area: `<component :is="native" />` keeps what a click does. For a link you
+     * don't want to change, show `native` alone.
+     */
+    link?(props: {
+        link: Link;
+        native: FunctionalComponent;
+    }): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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/link/composables.d.cts

@@ -0,0 +1,29 @@
+import type { EventHook } from '@embedpdf/core';
+import type { ActionsCapability, HoverPump } from '@embedpdf/plugin-actions/contract';
+import type { LinkCapability } from '@embedpdf/plugin-link';
+import type { StageCapability } from '@embedpdf/plugin-stage/contract';
+/** What every anchor of one `<LinkLayer>` shares. */
+export interface LinkLayerContext {
+    link: LinkCapability;
+    /** The view a page destination moves, when the page is on a Stage. */
+    stage: StageCapability | null;
+    /** The actions plugin, for the links' own PDF events; null without it. */
+    actions: ActionsCapability | null;
+    /** One per layer, so leaving one link and entering the next stay in order. */
+    pump: HoverPump | null;
+}
+/**
+ * Hand the link plugin this binding's website opener (`openExternalUri`)
+ * while the component lives: an allowed address opens in a new tab, anything
+ * else is refused and the plugin reports it. Registered again for another
+ * document.
+ */
+export declare function useUriOpener(): void;
+/**
+ * The link API (`listLinks`, `activate`, …) for app code. The object never
+ * changes. While a component uses it, `activate()` opens a website in a new
+ * tab.
+ */
+export declare function useLink(): LinkCapability;
+/** Subscribe to one link event while the component lives: `useLinkEvent((link) => link.onActivated, handler)`. */
+export declare function useLinkEvent<Event>(select: (link: LinkCapability) => EventHook<Event>, handler: (event: Event) => void): void;

package/dist/link/composables.d.ts

@@ -0,0 +1,29 @@
+import type { EventHook } from '@embedpdf/core';
+import type { ActionsCapability, HoverPump } from '@embedpdf/plugin-actions/contract';
+import type { LinkCapability } from '@embedpdf/plugin-link';
+import type { StageCapability } from '@embedpdf/plugin-stage/contract';
+/** What every anchor of one `<LinkLayer>` shares. */
+export interface LinkLayerContext {
+    link: LinkCapability;
+    /** The view a page destination moves, when the page is on a Stage. */
+    stage: StageCapability | null;
+    /** The actions plugin, for the links' own PDF events; null without it. */
+    actions: ActionsCapability | null;
+    /** One per layer, so leaving one link and entering the next stay in order. */
+    pump: HoverPump | null;
+}
+/**
+ * Hand the link plugin this binding's website opener (`openExternalUri`)
+ * while the component lives: an allowed address opens in a new tab, anything
+ * else is refused and the plugin reports it. Registered again for another
+ * document.
+ */
+export declare function useUriOpener(): void;
+/**
+ * The link API (`listLinks`, `activate`, …) for app code. The object never
+ * changes. While a component uses it, `activate()` opens a website in a new
+ * tab.
+ */
+export declare function useLink(): LinkCapability;
+/** Subscribe to one link event while the component lives: `useLinkEvent((link) => link.onActivated, handler)`. */
+export declare function useLinkEvent<Event>(select: (link: LinkCapability) => EventHook<Event>, handler: (event: Event) => void): void;

package/dist/link.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginLink = require("@embedpdf/plugin-link");
+const LinkLayer_vue_vue_type_script_setup_true_lang = require("./LinkLayer.vue_vue_type_script_setup_true_lang-C5-eQD34.cjs");
+exports.LinkLayer = LinkLayer_vue_vue_type_script_setup_true_lang._sfc_main;
+exports.useLink = LinkLayer_vue_vue_type_script_setup_true_lang.useLink;
+exports.useLinkEvent = LinkLayer_vue_vue_type_script_setup_true_lang.useLinkEvent;
+Object.keys(pluginLink).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginLink[k]
+  });
+});
+//# sourceMappingURL=link.cjs.map

package/dist/link.cjs.map

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

package/dist/link.d.cts

@@ -0,0 +1,11 @@
+/**
+ * @embedpdf/vue/link: the Vue surface of `@embedpdf/plugin-link`.
+ *
+ * `<LinkLayer>` makes a page's links clickable while a navigation tool is
+ * active, with a `#link` slot to draw them yourself; `useLink()` follows links
+ * from code (and opens websites while a component uses it), and
+ * `useLinkEvent()` follows the plugin's events.
+ */
+export * from '@embedpdf/plugin-link';
+export { default as LinkLayer } from './link/LinkLayer.vue.cjs';
+export { useLink, useLinkEvent } from './link/composables.cjs';

package/dist/link.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @embedpdf/vue/link: the Vue surface of `@embedpdf/plugin-link`.
+ *
+ * `<LinkLayer>` makes a page's links clickable while a navigation tool is
+ * active, with a `#link` slot to draw them yourself; `useLink()` follows links
+ * from code (and opens websites while a component uses it), and
+ * `useLinkEvent()` follows the plugin's events.
+ */
+export * from '@embedpdf/plugin-link';
+export { default as LinkLayer } from './link/LinkLayer.vue.js';
+export { useLink, useLinkEvent } from './link/composables.js';

package/dist/link.js

@@ -0,0 +1,8 @@
+export * from "@embedpdf/plugin-link";
+import { _, u, a } from "./LinkLayer.vue_vue_type_script_setup_true_lang-EzLaOP3g.js";
+export {
+  _ as LinkLayer,
+  u as useLink,
+  a as useLinkEvent
+};
+//# sourceMappingURL=link.js.map

package/dist/link.js.map

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

package/dist/measurement.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginMeasurement = require("@embedpdf/plugin-measurement");
+const vue = require("vue");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+const state = require("./state-M22NDJQo.cjs");
+function useMeasurement() {
+  return capabilities.useCapability(pluginMeasurement.MeasurementToken);
+}
+function useMeasurementEvent(select, handler) {
+  capabilities.useCapabilityEvent(pluginMeasurement.MeasurementToken, select, handler);
+}
+const useMeasurementState = state.stateComposable(pluginMeasurement.measurementState);
+const useMeasurementSettings = state.settingsComposable(pluginMeasurement.MeasurementToken);
+function usePageScale(page) {
+  const scope = capabilities.useDocumentScope();
+  return capabilities.useKernelValue((kernel) => {
+    var _a;
+    const wanted = vue.toValue(page);
+    if (wanted === null) return null;
+    return ((_a = kernel.tryCapability(pluginMeasurement.MeasurementToken, scope.value ?? void 0)) == null ? void 0 : _a.getPageScale(wanted)) ?? pluginMeasurement.NO_PAGE_SCALE;
+  });
+}
+function useMeasurementReadout(ref) {
+  return capabilities.useOptionalSelector(
+    pluginMeasurement.MeasurementToken,
+    (measurement) => measurement.getReadout(vue.toValue(ref)),
+    pluginMeasurement.NO_READOUT
+  );
+}
+exports.useMeasurement = useMeasurement;
+exports.useMeasurementEvent = useMeasurementEvent;
+exports.useMeasurementReadout = useMeasurementReadout;
+exports.useMeasurementSettings = useMeasurementSettings;
+exports.useMeasurementState = useMeasurementState;
+exports.usePageScale = usePageScale;
+Object.keys(pluginMeasurement).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginMeasurement[k]
+  });
+});
+//# sourceMappingURL=measurement.cjs.map

package/dist/measurement.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"measurement.cjs","sources":["../src/measurement.ts"],"sourcesContent":["/**\n * @embedpdf/vue/measurement: the Vue view of `@embedpdf/plugin-measurement`.\n * The four composables every plugin has, plus one per page scale and one per\n * measurement, so a template updates only for its own page or measurement.\n * Every one works before a document opens.\n *\n *   const measurement = useMeasurement();\n *   const scale = usePageScale(0); // the cover's, as a ref\n *   const readout = useMeasurementReadout(() => props.annotation); // { kind, value, label }\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-measurement';\nimport { toValue } from 'vue';\nimport type { MaybeRefOrGetter, Ref } from 'vue';\nimport type { EventHook, PageRef } from '@embedpdf/core';\nimport {\n  MeasurementToken,\n  measurementState,\n  NO_PAGE_SCALE,\n  NO_READOUT,\n} from '@embedpdf/plugin-measurement';\nimport type {\n  AnnotationRef,\n  MeasurementCapability,\n  MeasurementReadout,\n  MeasurementUnavailable,\n  PageScale,\n} from '@embedpdf/plugin-measurement';\nimport { useCapability, useCapabilityEvent, useOptionalSelector } from './runtime/capabilities';\nimport { useDocumentScope, useKernelValue } from './runtime/kernel';\nimport { settingsComposable, stateComposable } from './state';\n\n/**\n * The measurement API (scales, calibration, readouts, creating measurements)\n * of the nearest `<DocumentScope>`'s document, else the active one. The object\n * never changes; outside a document every method throws `not-ready`.\n */\nexport function useMeasurement(): MeasurementCapability {\n  return useCapability(MeasurementToken);\n}\n\n/** Subscribe to one measurement event while the component lives: `useMeasurementEvent((measurement) => measurement.onScaleChanged, handler)`. */\nexport function useMeasurementEvent<Event>(\n  select: (measurement: MeasurementCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(MeasurementToken, select, handler);\n}\n\n/**\n * The measurement state as refs: whether a scale change runs, the\n * calibration request waiting for its length, and the last change's reports\n * (the page's State table, declared once in `measurementState`). With a\n * selector, one ref that updates only when the value it picks changes.\n */\nexport const useMeasurementState = stateComposable(measurementState);\n\n/** The measurement settings (`defaultScale`, `presets`), with or without a document, as refs. Takes a selector. */\nexport const useMeasurementSettings = settingsComposable(MeasurementToken);\n\n/**\n * A page's measurement scale (its ref or its index; a getter to follow a\n * prop), as a ref: for a scale bar or a \"1:100\" badge. Accepts `null` (no\n * current page) and answers `null` then, so chrome can stay mounted without\n * inventing a page.\n */\nexport function usePageScale(page: MaybeRefOrGetter<PageRef | number>): Readonly<Ref<PageScale>>;\nexport function usePageScale(\n  page: MaybeRefOrGetter<PageRef | number | null>,\n): Readonly<Ref<PageScale | null>>;\nexport function usePageScale(\n  page: MaybeRefOrGetter<PageRef | number | null>,\n): Readonly<Ref<PageScale | null>> {\n  const scope = useDocumentScope();\n  // Scales are reference-stable in the plugin, so the ref updates only when this page's changes.\n  return useKernelValue((kernel) => {\n    const wanted = toValue(page);\n    if (wanted === null) return null;\n    return (\n      kernel.tryCapability(MeasurementToken, scope.value ?? undefined)?.getPageScale(wanted) ??\n      NO_PAGE_SCALE\n    );\n  });\n}\n\n/**\n * A measurement's `{ kind, value, label }` as a ref, or `{ unavailable }`\n * with why there's none. Pass a getter to follow a prop:\n * `useMeasurementReadout(() => props.annotation)`. Readouts are\n * reference-stable in the plugin, so the ref updates only when the\n * measurement's changes.\n */\nexport function useMeasurementReadout(\n  ref: MaybeRefOrGetter<AnnotationRef>,\n): Readonly<Ref<MeasurementReadout | MeasurementUnavailable>> {\n  return useOptionalSelector(\n    MeasurementToken,\n    (measurement) => measurement.getReadout(toValue(ref)),\n    NO_READOUT as MeasurementReadout | MeasurementUnavailable,\n  );\n}\n"],"names":["useCapability","MeasurementToken","useCapabilityEvent","stateComposable","measurementState","settingsComposable","useDocumentScope","useKernelValue","toValue","NO_PAGE_SCALE","useOptionalSelector","NO_READOUT"],"mappings":";;;;;;AAsCO,SAAS,iBAAwC;AACtD,SAAOA,aAAAA,cAAcC,kBAAAA,gBAAgB;AACvC;AAGO,SAAS,oBACd,QACA,SACM;AACNC,kCAAmBD,kBAAAA,kBAAkB,QAAQ,OAAO;AACtD;AAQO,MAAM,sBAAsBE,MAAAA,gBAAgBC,kBAAAA,gBAAgB;AAG5D,MAAM,yBAAyBC,MAAAA,mBAAmBJ,kBAAAA,gBAAgB;AAYlE,SAAS,aACd,MACiC;AACjC,QAAM,QAAQK,aAAAA,iBAAA;AAEd,SAAOC,aAAAA,eAAe,CAAC,WAAW;;AAChC,UAAM,SAASC,IAAAA,QAAQ,IAAI;AAC3B,QAAI,WAAW,KAAM,QAAO;AAC5B,aACE,YAAO,cAAcP,kBAAAA,kBAAkB,MAAM,SAAS,MAAS,MAA/D,mBAAkE,aAAa,YAC/EQ,kBAAAA;AAAAA,EAEJ,CAAC;AACH;AASO,SAAS,sBACd,KAC4D;AAC5D,SAAOC,aAAAA;AAAAA,IACLT,kBAAAA;AAAAA,IACA,CAAC,gBAAgB,YAAY,WAAWO,IAAAA,QAAQ,GAAG,CAAC;AAAA,IACpDG,kBAAAA;AAAAA,EAAA;AAEJ;;;;;;;;;;;;;"}

package/dist/measurement.d.cts

@@ -0,0 +1,51 @@
+/**
+ * @embedpdf/vue/measurement: the Vue view of `@embedpdf/plugin-measurement`.
+ * The four composables every plugin has, plus one per page scale and one per
+ * measurement, so a template updates only for its own page or measurement.
+ * Every one works before a document opens.
+ *
+ *   const measurement = useMeasurement();
+ *   const scale = usePageScale(0); // the cover's, as a ref
+ *   const readout = useMeasurementReadout(() => props.annotation); // { kind, value, label }
+ */
+export * from '@embedpdf/plugin-measurement';
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { EventHook, PageRef } from '@embedpdf/core';
+import type { AnnotationRef, MeasurementCapability, MeasurementReadout, MeasurementUnavailable, PageScale } from '@embedpdf/plugin-measurement';
+/**
+ * The measurement API (scales, calibration, readouts, creating measurements)
+ * of the nearest `<DocumentScope>`'s document, else the active one. The object
+ * never changes; outside a document every method throws `not-ready`.
+ */
+export declare function useMeasurement(): MeasurementCapability;
+/** Subscribe to one measurement event while the component lives: `useMeasurementEvent((measurement) => measurement.onScaleChanged, handler)`. */
+export declare function useMeasurementEvent<Event>(select: (measurement: MeasurementCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The measurement state as refs: whether a scale change runs, the
+ * calibration request waiting for its length, and the last change's reports
+ * (the page's State table, declared once in `measurementState`). With a
+ * selector, one ref that updates only when the value it picks changes.
+ */
+export declare const useMeasurementState: import("./state.cjs").StateComposable<{
+    busy: boolean;
+    calibrationRequest: import("@embedpdf/plugin-measurement").CalibrationRequest | null;
+    lastReports: readonly import("@embedpdf/plugin-measurement").ScaleChangeReport[];
+}>;
+/** The measurement settings (`defaultScale`, `presets`), with or without a document, as refs. Takes a selector. */
+export declare const useMeasurementSettings: import("./state.cjs").SettingsComposable<import("@embedpdf/plugin-measurement").MeasurementSettings & object>;
+/**
+ * A page's measurement scale (its ref or its index; a getter to follow a
+ * prop), as a ref: for a scale bar or a "1:100" badge. Accepts `null` (no
+ * current page) and answers `null` then, so chrome can stay mounted without
+ * inventing a page.
+ */
+export declare function usePageScale(page: MaybeRefOrGetter<PageRef | number>): Readonly<Ref<PageScale>>;
+export declare function usePageScale(page: MaybeRefOrGetter<PageRef | number | null>): Readonly<Ref<PageScale | null>>;
+/**
+ * A measurement's `{ kind, value, label }` as a ref, or `{ unavailable }`
+ * with why there's none. Pass a getter to follow a prop:
+ * `useMeasurementReadout(() => props.annotation)`. Readouts are
+ * reference-stable in the plugin, so the ref updates only when the
+ * measurement's changes.
+ */
+export declare function useMeasurementReadout(ref: MaybeRefOrGetter<AnnotationRef>): Readonly<Ref<MeasurementReadout | MeasurementUnavailable>>;

package/dist/measurement.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @embedpdf/vue/measurement: the Vue view of `@embedpdf/plugin-measurement`.
+ * The four composables every plugin has, plus one per page scale and one per
+ * measurement, so a template updates only for its own page or measurement.
+ * Every one works before a document opens.
+ *
+ *   const measurement = useMeasurement();
+ *   const scale = usePageScale(0); // the cover's, as a ref
+ *   const readout = useMeasurementReadout(() => props.annotation); // { kind, value, label }
+ */
+export * from '@embedpdf/plugin-measurement';
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { EventHook, PageRef } from '@embedpdf/core';
+import type { AnnotationRef, MeasurementCapability, MeasurementReadout, MeasurementUnavailable, PageScale } from '@embedpdf/plugin-measurement';
+/**
+ * The measurement API (scales, calibration, readouts, creating measurements)
+ * of the nearest `<DocumentScope>`'s document, else the active one. The object
+ * never changes; outside a document every method throws `not-ready`.
+ */
+export declare function useMeasurement(): MeasurementCapability;
+/** Subscribe to one measurement event while the component lives: `useMeasurementEvent((measurement) => measurement.onScaleChanged, handler)`. */
+export declare function useMeasurementEvent<Event>(select: (measurement: MeasurementCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The measurement state as refs: whether a scale change runs, the
+ * calibration request waiting for its length, and the last change's reports
+ * (the page's State table, declared once in `measurementState`). With a
+ * selector, one ref that updates only when the value it picks changes.
+ */
+export declare const useMeasurementState: import("./state.js").StateComposable<{
+    busy: boolean;
+    calibrationRequest: import("@embedpdf/plugin-measurement").CalibrationRequest | null;
+    lastReports: readonly import("@embedpdf/plugin-measurement").ScaleChangeReport[];
+}>;
+/** The measurement settings (`defaultScale`, `presets`), with or without a document, as refs. Takes a selector. */
+export declare const useMeasurementSettings: import("./state.js").SettingsComposable<import("@embedpdf/plugin-measurement").MeasurementSettings & object>;
+/**
+ * A page's measurement scale (its ref or its index; a getter to follow a
+ * prop), as a ref: for a scale bar or a "1:100" badge. Accepts `null` (no
+ * current page) and answers `null` then, so chrome can stay mounted without
+ * inventing a page.
+ */
+export declare function usePageScale(page: MaybeRefOrGetter<PageRef | number>): Readonly<Ref<PageScale>>;
+export declare function usePageScale(page: MaybeRefOrGetter<PageRef | number | null>): Readonly<Ref<PageScale | null>>;
+/**
+ * A measurement's `{ kind, value, label }` as a ref, or `{ unavailable }`
+ * with why there's none. Pass a getter to follow a prop:
+ * `useMeasurementReadout(() => props.annotation)`. Readouts are
+ * reference-stable in the plugin, so the ref updates only when the
+ * measurement's changes.
+ */
+export declare function useMeasurementReadout(ref: MaybeRefOrGetter<AnnotationRef>): Readonly<Ref<MeasurementReadout | MeasurementUnavailable>>;

package/dist/measurement.js

@@ -0,0 +1,38 @@
+import { MeasurementToken, NO_PAGE_SCALE, measurementState, NO_READOUT } from "@embedpdf/plugin-measurement";
+export * from "@embedpdf/plugin-measurement";
+import { toValue } from "vue";
+import { a as useCapability, b as useCapabilityEvent, i as useOptionalSelector, e as useDocumentScope, g as useKernelValue } from "./capabilities-C7YzgPCX.js";
+import { s as settingsComposable, a as stateComposable } from "./state-DZg8q3v6.js";
+function useMeasurement() {
+  return useCapability(MeasurementToken);
+}
+function useMeasurementEvent(select, handler) {
+  useCapabilityEvent(MeasurementToken, select, handler);
+}
+const useMeasurementState = stateComposable(measurementState);
+const useMeasurementSettings = settingsComposable(MeasurementToken);
+function usePageScale(page) {
+  const scope = useDocumentScope();
+  return useKernelValue((kernel) => {
+    var _a;
+    const wanted = toValue(page);
+    if (wanted === null) return null;
+    return ((_a = kernel.tryCapability(MeasurementToken, scope.value ?? void 0)) == null ? void 0 : _a.getPageScale(wanted)) ?? NO_PAGE_SCALE;
+  });
+}
+function useMeasurementReadout(ref) {
+  return useOptionalSelector(
+    MeasurementToken,
+    (measurement) => measurement.getReadout(toValue(ref)),
+    NO_READOUT
+  );
+}
+export {
+  useMeasurement,
+  useMeasurementEvent,
+  useMeasurementReadout,
+  useMeasurementSettings,
+  useMeasurementState,
+  usePageScale
+};
+//# sourceMappingURL=measurement.js.map