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

package/dist/form/TextControl.vue.d.cts

@@ -0,0 +1,11 @@
+import type { FormWidgetItem } from '@embedpdf/plugin-form';
+import type { FormColors } from '@embedpdf/web';
+type __VLS_Props = {
+    item: Extract<FormWidgetItem, {
+        control: 'text';
+    }>;
+    colors: FormColors;
+};
+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/form/TextControl.vue.d.ts

@@ -0,0 +1,11 @@
+import type { FormWidgetItem } from '@embedpdf/plugin-form';
+import type { FormColors } from '@embedpdf/web';
+type __VLS_Props = {
+    item: Extract<FormWidgetItem, {
+        control: 'text';
+    }>;
+    colors: FormColors;
+};
+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/form/ToggleControl.vue.d.cts

@@ -0,0 +1,11 @@
+import type { FormWidgetItem } from '@embedpdf/plugin-form';
+import type { FormColors } from '@embedpdf/web';
+type __VLS_Props = {
+    item: Extract<FormWidgetItem, {
+        control: 'toggle';
+    }>;
+    colors: FormColors;
+};
+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/form/ToggleControl.vue.d.ts

@@ -0,0 +1,11 @@
+import type { FormWidgetItem } from '@embedpdf/plugin-form';
+import type { FormColors } from '@embedpdf/web';
+type __VLS_Props = {
+    item: Extract<FormWidgetItem, {
+        control: 'toggle';
+    }>;
+    colors: FormColors;
+};
+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/form/composables.d.cts

@@ -0,0 +1,52 @@
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { EventHook } from '@embedpdf/core';
+import type { AnnotationRef } from '@embedpdf/plugin-annotation/contract';
+import type { FormCapability, FormFieldRef, FormFieldValue } from '@embedpdf/plugin-form';
+import type { FormColors } from '@embedpdf/web';
+/**
+ * The form API for the document in scope: reading, filling, form data and
+ * building. The object never changes, so it's safe to keep in a closure; keep
+ * it whole (`form.setValue(…)`), since a member taken out of it once stays the
+ * one of that moment.
+ */
+export declare function useForm(): FormCapability;
+/** Subscribe to one form event while the component lives: `useFormEvent((form) => form.onValueChanged, handler)`. */
+export declare function useFormEvent<Event>(select: (form: FormCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The form's state as refs: every field (`fields`), whether it's read
+ * (`status`), what kind of form the document has (`formKind`), and the field
+ * of the selected widget in design mode (`selectedField`), declared once in
+ * `formState`. With a selector, one ref that updates only when the value it
+ * picks changes. Empty without a document.
+ */
+export declare const useFormState: import("../index.cjs").StateComposable<{
+    fields: readonly import("@embedpdf/plugin-form").FormFieldDTO[];
+    status: import("@embedpdf/core").ResourceStatus;
+    formKind: import("@embedpdf/plugin-form").FormKind;
+    selectedField: import("@embedpdf/plugin-form").FormFieldDTO | null;
+}>;
+/**
+ * The form settings (`validation`, `focus`, `fields`) as refs, or one ref for
+ * the value `select` picks. They belong to the plugin, so they read without a
+ * document; change them with `useForm().updateSettings()`.
+ */
+export declare const useFormSettings: import("../index.cjs").SettingsComposable<import("@embedpdf/plugin-form").FormSettings & object>;
+/**
+ * One field's value, in the shape `setValue()` takes, or `null`: a ref that
+ * updates only when that field's value changes (the plugin keeps one value
+ * object per field while it stays the same). `field` may be a ref or a
+ * getter, and the ref follows it. `null` without a document.
+ */
+export declare function useFormValue(field: MaybeRefOrGetter<FormFieldRef>): Readonly<Ref<FormFieldValue | null>>;
+/**
+ * The colors the viewer draws fields with: the form settings over the
+ * viewer's accent, each behind its `--epdf-form-*` CSS variable.
+ */
+export declare function useFormColors(): Readonly<Ref<FormColors>>;
+/**
+ * A click on a widget runs its `/A` action. ISO 32000 puts the activate
+ * action on the widget, whatever its field, and many forms ship "buttons" as
+ * read-only text fields with an `/A` that Acrobat runs; a widget without one
+ * is inert. `widget` is read at the click, so it is the item's current one.
+ */
+export declare function useWidgetActivation(widget: () => AnnotationRef | null): () => void;

package/dist/form/composables.d.ts

@@ -0,0 +1,52 @@
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { EventHook } from '@embedpdf/core';
+import type { AnnotationRef } from '@embedpdf/plugin-annotation/contract';
+import type { FormCapability, FormFieldRef, FormFieldValue } from '@embedpdf/plugin-form';
+import type { FormColors } from '@embedpdf/web';
+/**
+ * The form API for the document in scope: reading, filling, form data and
+ * building. The object never changes, so it's safe to keep in a closure; keep
+ * it whole (`form.setValue(…)`), since a member taken out of it once stays the
+ * one of that moment.
+ */
+export declare function useForm(): FormCapability;
+/** Subscribe to one form event while the component lives: `useFormEvent((form) => form.onValueChanged, handler)`. */
+export declare function useFormEvent<Event>(select: (form: FormCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The form's state as refs: every field (`fields`), whether it's read
+ * (`status`), what kind of form the document has (`formKind`), and the field
+ * of the selected widget in design mode (`selectedField`), declared once in
+ * `formState`. With a selector, one ref that updates only when the value it
+ * picks changes. Empty without a document.
+ */
+export declare const useFormState: import("../index.js").StateComposable<{
+    fields: readonly import("@embedpdf/plugin-form").FormFieldDTO[];
+    status: import("@embedpdf/core").ResourceStatus;
+    formKind: import("@embedpdf/plugin-form").FormKind;
+    selectedField: import("@embedpdf/plugin-form").FormFieldDTO | null;
+}>;
+/**
+ * The form settings (`validation`, `focus`, `fields`) as refs, or one ref for
+ * the value `select` picks. They belong to the plugin, so they read without a
+ * document; change them with `useForm().updateSettings()`.
+ */
+export declare const useFormSettings: import("../index.js").SettingsComposable<import("@embedpdf/plugin-form").FormSettings & object>;
+/**
+ * One field's value, in the shape `setValue()` takes, or `null`: a ref that
+ * updates only when that field's value changes (the plugin keeps one value
+ * object per field while it stays the same). `field` may be a ref or a
+ * getter, and the ref follows it. `null` without a document.
+ */
+export declare function useFormValue(field: MaybeRefOrGetter<FormFieldRef>): Readonly<Ref<FormFieldValue | null>>;
+/**
+ * The colors the viewer draws fields with: the form settings over the
+ * viewer's accent, each behind its `--epdf-form-*` CSS variable.
+ */
+export declare function useFormColors(): Readonly<Ref<FormColors>>;
+/**
+ * A click on a widget runs its `/A` action. ISO 32000 puts the activate
+ * action on the widget, whatever its field, and many forms ship "buttons" as
+ * read-only text fields with an `/A` that Acrobat runs; a widget without one
+ * is inert. `widget` is read at the click, so it is the item's current one.
+ */
+export declare function useWidgetActivation(widget: () => AnnotationRef | null): () => void;

package/dist/form/widget-box.d.cts

@@ -0,0 +1,34 @@
+import type { CSSProperties, Ref } from 'vue';
+import type { FormWidgetItem } from '@embedpdf/plugin-form';
+import type { FormColors, PixelRect } from '@embedpdf/web';
+/** A control's box: bind `element` with `ref`, and `style` on the same element. */
+export interface WidgetBox {
+    /** The box element, for the template's `ref`. */
+    readonly element: Ref<HTMLDivElement | null>;
+    /** Where the widget is on the page, in view px. */
+    readonly frame: Readonly<Ref<PixelRect>>;
+    /** The box's place, and its edge when the field has no border of its own. */
+    readonly style: Readonly<Ref<CSSProperties>>;
+}
+/**
+ * The box of one widget. `edge: false` leaves out the edge for controls that
+ * draw their own (a list box) or never have one (a button).
+ *
+ * The box keeps every press that starts in it from the page below: the Stage
+ * listens natively on an ancestor, and a press reaching it would start the
+ * active tool's gesture or end an edit as a click outside. Vue's listeners are
+ * native too, but the box stops it with `isolatePointerDown`, the same call
+ * every framework's form layer makes. The widget's pointer and focus events
+ * (its `/AA` actions: enter, exit, down, up, focus, blur) go to the form
+ * plugin from native listeners on the box (`bindWidgetEvents`), never the
+ * control inside: "may edit this field" and "may receive PDF action events"
+ * are different rights, and a session that may not fill still sees hover
+ * tooltips. Its own `pointerdown` listener sits on the same element as the
+ * isolation, so the stopped press still reaches the field's "mouse down"
+ * action. Focus is `focusin`/`focusout`, so a control's own blur (where a
+ * text field starts its commit) runs before the box sends "blur", and a blur
+ * script sees the committed value.
+ */
+export declare function useWidgetBox(item: () => FormWidgetItem, colors: () => FormColors, options?: {
+    edge?: boolean;
+}): WidgetBox;

package/dist/form/widget-box.d.ts

@@ -0,0 +1,34 @@
+import type { CSSProperties, Ref } from 'vue';
+import type { FormWidgetItem } from '@embedpdf/plugin-form';
+import type { FormColors, PixelRect } from '@embedpdf/web';
+/** A control's box: bind `element` with `ref`, and `style` on the same element. */
+export interface WidgetBox {
+    /** The box element, for the template's `ref`. */
+    readonly element: Ref<HTMLDivElement | null>;
+    /** Where the widget is on the page, in view px. */
+    readonly frame: Readonly<Ref<PixelRect>>;
+    /** The box's place, and its edge when the field has no border of its own. */
+    readonly style: Readonly<Ref<CSSProperties>>;
+}
+/**
+ * The box of one widget. `edge: false` leaves out the edge for controls that
+ * draw their own (a list box) or never have one (a button).
+ *
+ * The box keeps every press that starts in it from the page below: the Stage
+ * listens natively on an ancestor, and a press reaching it would start the
+ * active tool's gesture or end an edit as a click outside. Vue's listeners are
+ * native too, but the box stops it with `isolatePointerDown`, the same call
+ * every framework's form layer makes. The widget's pointer and focus events
+ * (its `/AA` actions: enter, exit, down, up, focus, blur) go to the form
+ * plugin from native listeners on the box (`bindWidgetEvents`), never the
+ * control inside: "may edit this field" and "may receive PDF action events"
+ * are different rights, and a session that may not fill still sees hover
+ * tooltips. Its own `pointerdown` listener sits on the same element as the
+ * isolation, so the stopped press still reaches the field's "mouse down"
+ * action. Focus is `focusin`/`focusout`, so a control's own blur (where a
+ * text field starts its commit) runs before the box sends "blur", and a blur
+ * script sees the committed value.
+ */
+export declare function useWidgetBox(item: () => FormWidgetItem, colors: () => FormColors, options?: {
+    edge?: boolean;
+}): WidgetBox;

package/dist/form.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginForm = require("@embedpdf/plugin-form");
+const FormLayer_vue_vue_type_script_setup_true_lang = require("./FormLayer.vue_vue_type_script_setup_true_lang-BA0_VwFc.cjs");
+exports.FormLayer = FormLayer_vue_vue_type_script_setup_true_lang._sfc_main;
+exports.useForm = FormLayer_vue_vue_type_script_setup_true_lang.useForm;
+exports.useFormEvent = FormLayer_vue_vue_type_script_setup_true_lang.useFormEvent;
+exports.useFormSettings = FormLayer_vue_vue_type_script_setup_true_lang.useFormSettings;
+exports.useFormState = FormLayer_vue_vue_type_script_setup_true_lang.useFormState;
+exports.useFormValue = FormLayer_vue_vue_type_script_setup_true_lang.useFormValue;
+Object.keys(pluginForm).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginForm[k]
+  });
+});
+//# sourceMappingURL=form.cjs.map

package/dist/form.cjs.map

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

package/dist/form.d.cts

@@ -0,0 +1,12 @@
+/**
+ * @embedpdf/vue/form: the Vue surface of `@embedpdf/plugin-form`.
+ *
+ * `<FormLayer>` puts a real HTML control over each field of its page, for
+ * people to fill in; `useForm()` reads, fills and builds the form from code;
+ * `useFormState()` and `useFormValue()` follow the fields and one field's
+ * value as refs, `useFormSettings()` the settings, and `useFormEvent()` the
+ * plugin's events.
+ */
+export * from '@embedpdf/plugin-form';
+export { default as FormLayer } from './form/FormLayer.vue.cjs';
+export { useForm, useFormEvent, useFormSettings, useFormState, useFormValue, } from './form/composables.cjs';

package/dist/form.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @embedpdf/vue/form: the Vue surface of `@embedpdf/plugin-form`.
+ *
+ * `<FormLayer>` puts a real HTML control over each field of its page, for
+ * people to fill in; `useForm()` reads, fills and builds the form from code;
+ * `useFormState()` and `useFormValue()` follow the fields and one field's
+ * value as refs, `useFormSettings()` the settings, and `useFormEvent()` the
+ * plugin's events.
+ */
+export * from '@embedpdf/plugin-form';
+export { default as FormLayer } from './form/FormLayer.vue.js';
+export { useForm, useFormEvent, useFormSettings, useFormState, useFormValue, } from './form/composables.js';

package/dist/form.js

@@ -0,0 +1,11 @@
+export * from "@embedpdf/plugin-form";
+import { _, u, a, b, c, d } from "./FormLayer.vue_vue_type_script_setup_true_lang-DUqft-xs.js";
+export {
+  _ as FormLayer,
+  u as useForm,
+  a as useFormEvent,
+  b as useFormSettings,
+  c as useFormState,
+  d as useFormValue
+};
+//# sourceMappingURL=form.js.map

package/dist/form.js.map

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

package/dist/history.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginHistory = require("@embedpdf/plugin-history");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+const state = require("./state-M22NDJQo.cjs");
+function useHistory() {
+  return capabilities.useCapability(pluginHistory.HistoryToken);
+}
+const useHistoryState = state.stateComposable(pluginHistory.historyState);
+function useHistoryEvent(select, handler) {
+  capabilities.useCapabilityEvent(pluginHistory.HistoryToken, select, handler);
+}
+exports.useHistory = useHistory;
+exports.useHistoryEvent = useHistoryEvent;
+exports.useHistoryState = useHistoryState;
+Object.keys(pluginHistory).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginHistory[k]
+  });
+});
+//# sourceMappingURL=history.cjs.map

package/dist/history.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.cjs","sources":["../src/history.ts"],"sourcesContent":["/**\n * @embedpdf/vue/history: the Vue view of `@embedpdf/plugin-history`, undo and\n * redo of what you change through the viewer, one history per open document.\n * An action shows undone at once, even while it is still on its way.\n *\n *   const history = useHistory();\n *   const { canUndo, undoLabel } = useHistoryState();\n *   <button :disabled=\"!canUndo\" @click=\"history.undo()\">Undo</button>\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-history';\nimport { HistoryToken, historyState } from '@embedpdf/plugin-history';\nimport type { HistoryCapability } from '@embedpdf/plugin-history';\nimport type { EventHook } from '@embedpdf/core';\nimport { useCapability, useCapabilityEvent } from './runtime/capabilities';\nimport { stateComposable } from './state';\n\n/**\n * The history API (`undo`, `redo`, `canUndo`, `canRedo`, the labels, `clear`) of the nearest\n * `<DocumentScope>`'s document, else the active one. The object never changes; outside a\n * document every method throws `not-ready`.\n */\nexport function useHistory(): HistoryCapability {\n  return useCapability(HistoryToken);\n}\n\n/**\n * Whether undo and redo can run, and what they would undo and redo, as refs (the page's State\n * table, declared once in `historyState`). With a selector, one ref for the value it picks,\n * which updates only when that value changes.\n */\nexport const useHistoryState = stateComposable(historyState);\n\n/** Subscribe to one history event while the component lives: `useHistoryEvent((history) => history.onUndone, handler)`. */\nexport function useHistoryEvent<Event>(\n  select: (history: HistoryCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(HistoryToken, select, handler);\n}\n"],"names":["useCapability","HistoryToken","stateComposable","historyState","useCapabilityEvent"],"mappings":";;;;;AAuBO,SAAS,aAAgC;AAC9C,SAAOA,aAAAA,cAAcC,cAAAA,YAAY;AACnC;AAOO,MAAM,kBAAkBC,MAAAA,gBAAgBC,cAAAA,YAAY;AAGpD,SAAS,gBACd,QACA,SACM;AACNC,kCAAmBH,cAAAA,cAAc,QAAQ,OAAO;AAClD;;;;;;;;;;"}

package/dist/history.d.cts

@@ -0,0 +1,31 @@
+/**
+ * @embedpdf/vue/history: the Vue view of `@embedpdf/plugin-history`, undo and
+ * redo of what you change through the viewer, one history per open document.
+ * An action shows undone at once, even while it is still on its way.
+ *
+ *   const history = useHistory();
+ *   const { canUndo, undoLabel } = useHistoryState();
+ *   <button :disabled="!canUndo" @click="history.undo()">Undo</button>
+ */
+export * from '@embedpdf/plugin-history';
+import type { HistoryCapability } from '@embedpdf/plugin-history';
+import type { EventHook } from '@embedpdf/core';
+/**
+ * The history API (`undo`, `redo`, `canUndo`, `canRedo`, the labels, `clear`) 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 useHistory(): HistoryCapability;
+/**
+ * Whether undo and redo can run, and what they would undo and redo, as refs (the page's State
+ * table, declared once in `historyState`). With a selector, one ref for the value it picks,
+ * which updates only when that value changes.
+ */
+export declare const useHistoryState: import("./state.cjs").StateComposable<{
+    canUndo: boolean;
+    canRedo: boolean;
+    undoLabel: import("@embedpdf/core").ChangeLabel | null;
+    redoLabel: import("@embedpdf/core").ChangeLabel | null;
+}>;
+/** Subscribe to one history event while the component lives: `useHistoryEvent((history) => history.onUndone, handler)`. */
+export declare function useHistoryEvent<Event>(select: (history: HistoryCapability) => EventHook<Event>, handler: (event: Event) => void): void;

package/dist/history.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @embedpdf/vue/history: the Vue view of `@embedpdf/plugin-history`, undo and
+ * redo of what you change through the viewer, one history per open document.
+ * An action shows undone at once, even while it is still on its way.
+ *
+ *   const history = useHistory();
+ *   const { canUndo, undoLabel } = useHistoryState();
+ *   <button :disabled="!canUndo" @click="history.undo()">Undo</button>
+ */
+export * from '@embedpdf/plugin-history';
+import type { HistoryCapability } from '@embedpdf/plugin-history';
+import type { EventHook } from '@embedpdf/core';
+/**
+ * The history API (`undo`, `redo`, `canUndo`, `canRedo`, the labels, `clear`) 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 useHistory(): HistoryCapability;
+/**
+ * Whether undo and redo can run, and what they would undo and redo, as refs (the page's State
+ * table, declared once in `historyState`). With a selector, one ref for the value it picks,
+ * which updates only when that value changes.
+ */
+export declare const useHistoryState: import("./state.js").StateComposable<{
+    canUndo: boolean;
+    canRedo: boolean;
+    undoLabel: import("@embedpdf/core").ChangeLabel | null;
+    redoLabel: import("@embedpdf/core").ChangeLabel | null;
+}>;
+/** Subscribe to one history event while the component lives: `useHistoryEvent((history) => history.onUndone, handler)`. */
+export declare function useHistoryEvent<Event>(select: (history: HistoryCapability) => EventHook<Event>, handler: (event: Event) => void): void;

package/dist/history.js

@@ -0,0 +1,17 @@
+import { HistoryToken, historyState } from "@embedpdf/plugin-history";
+export * from "@embedpdf/plugin-history";
+import { a as useCapability, b as useCapabilityEvent } from "./capabilities-C7YzgPCX.js";
+import { a as stateComposable } from "./state-DZg8q3v6.js";
+function useHistory() {
+  return useCapability(HistoryToken);
+}
+const useHistoryState = stateComposable(historyState);
+function useHistoryEvent(select, handler) {
+  useCapabilityEvent(HistoryToken, select, handler);
+}
+export {
+  useHistory,
+  useHistoryEvent,
+  useHistoryState
+};
+//# sourceMappingURL=history.js.map

package/dist/history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.js","sources":["../src/history.ts"],"sourcesContent":["/**\n * @embedpdf/vue/history: the Vue view of `@embedpdf/plugin-history`, undo and\n * redo of what you change through the viewer, one history per open document.\n * An action shows undone at once, even while it is still on its way.\n *\n *   const history = useHistory();\n *   const { canUndo, undoLabel } = useHistoryState();\n *   <button :disabled=\"!canUndo\" @click=\"history.undo()\">Undo</button>\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-history';\nimport { HistoryToken, historyState } from '@embedpdf/plugin-history';\nimport type { HistoryCapability } from '@embedpdf/plugin-history';\nimport type { EventHook } from '@embedpdf/core';\nimport { useCapability, useCapabilityEvent } from './runtime/capabilities';\nimport { stateComposable } from './state';\n\n/**\n * The history API (`undo`, `redo`, `canUndo`, `canRedo`, the labels, `clear`) of the nearest\n * `<DocumentScope>`'s document, else the active one. The object never changes; outside a\n * document every method throws `not-ready`.\n */\nexport function useHistory(): HistoryCapability {\n  return useCapability(HistoryToken);\n}\n\n/**\n * Whether undo and redo can run, and what they would undo and redo, as refs (the page's State\n * table, declared once in `historyState`). With a selector, one ref for the value it picks,\n * which updates only when that value changes.\n */\nexport const useHistoryState = stateComposable(historyState);\n\n/** Subscribe to one history event while the component lives: `useHistoryEvent((history) => history.onUndone, handler)`. */\nexport function useHistoryEvent<Event>(\n  select: (history: HistoryCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(HistoryToken, select, handler);\n}\n"],"names":[],"mappings":";;;;AAuBO,SAAS,aAAgC;AAC9C,SAAO,cAAc,YAAY;AACnC;AAOO,MAAM,kBAAkB,gBAAgB,YAAY;AAGpD,SAAS,gBACd,QACA,SACM;AACN,qBAAmB,cAAc,QAAQ,OAAO;AAClD;"}

package/dist/i18n.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginI18n = require("@embedpdf/plugin-i18n");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+const state = require("./state-M22NDJQo.cjs");
+function useI18n() {
+  return capabilities.useCapability(pluginI18n.I18nToken);
+}
+function useI18nEvent(select, handler) {
+  capabilities.useCapabilityEvent(pluginI18n.I18nToken, select, handler);
+}
+const useI18nState = state.stateComposable(pluginI18n.i18nState);
+const useI18nSettings = state.settingsComposable(pluginI18n.I18nToken);
+function useT() {
+  const translator = capabilities.useSelector(pluginI18n.I18nToken, (i18n) => i18n.getTranslator());
+  return (key, options) => translator.value(key, options);
+}
+exports.useI18n = useI18n;
+exports.useI18nEvent = useI18nEvent;
+exports.useI18nSettings = useI18nSettings;
+exports.useI18nState = useI18nState;
+exports.useT = useT;
+Object.keys(pluginI18n).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginI18n[k]
+  });
+});
+//# sourceMappingURL=i18n.cjs.map

package/dist/i18n.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.cjs","sources":["../src/i18n.ts"],"sourcesContent":["/**\n * @embedpdf/vue/i18n: the Vue surface of `@embedpdf/plugin-i18n`. The plugin\n * belongs to the workspace and needs no engine, so these composables work from\n * the first frame, before a document opens: a loading screen and a password\n * prompt translate too.\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-i18n';\nimport { I18nToken, i18nState } from '@embedpdf/plugin-i18n';\nimport type { I18nCapability, TranslateOptions } from '@embedpdf/plugin-i18n';\nimport type { EventHook } from '@embedpdf/core';\nimport { useCapability, useCapabilityEvent, useSelector } from './runtime/capabilities';\nimport { settingsComposable, stateComposable } from './state';\n\n/** The i18n API: `t`, `setLocale`, `addTranslations`, `registerLocale`, the settings calls. The object never changes. */\nexport function useI18n(): I18nCapability {\n  return useCapability(I18nToken);\n}\n\n/** Subscribe to one i18n event while the component lives: `useI18nEvent((i18n) => i18n.onLocaleChanged, handler)`. */\nexport function useI18nEvent<Event>(\n  select: (i18n: I18nCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(I18nToken, select, handler);\n}\n\n/**\n * The current language, how it reads, every language you can switch to, and\n * the one loading, as refs (the translations page's State table, declared once\n * in `i18nState`). With a selector, one ref, which updates only when what it\n * picks changes.\n */\nexport const useI18nState = stateComposable(i18nState);\n\n/** The i18n settings (`locale`, `fallbackLocale`, `locales`, `loaders`) as refs. Takes a selector. */\nexport const useI18nSettings = settingsComposable(I18nToken);\n\n/**\n * A translate function that reads the language reactively: a template, a\n * computed or a `watch` that calls it updates when the language or the strings\n * change. The function itself never changes, so it can be kept anywhere.\n *\n *   const t = useT();\n *   <span>{{ t('search.results', { params: { count } }) }}</span>\n */\nexport function useT(): (key: string, options?: TranslateOptions) => string {\n  // The plugin hands out a new translator when the language or the strings change;\n  // reading the ref inside the call is what makes the caller depend on it.\n  const translator = useSelector(I18nToken, (i18n) => i18n.getTranslator());\n  return (key, options) => translator.value(key, options);\n}\n"],"names":["useCapability","I18nToken","useCapabilityEvent","stateComposable","i18nState","settingsComposable","useSelector"],"mappings":";;;;;AAgBO,SAAS,UAA0B;AACxC,SAAOA,aAAAA,cAAcC,WAAAA,SAAS;AAChC;AAGO,SAAS,aACd,QACA,SACM;AACNC,kCAAmBD,WAAAA,WAAW,QAAQ,OAAO;AAC/C;AAQO,MAAM,eAAeE,MAAAA,gBAAgBC,WAAAA,SAAS;AAG9C,MAAM,kBAAkBC,MAAAA,mBAAmBJ,WAAAA,SAAS;AAUpD,SAAS,OAA4D;AAG1E,QAAM,aAAaK,aAAAA,YAAYL,WAAAA,WAAW,CAAC,SAAS,KAAK,eAAe;AACxE,SAAO,CAAC,KAAK,YAAY,WAAW,MAAM,KAAK,OAAO;AACxD;;;;;;;;;;;;"}

package/dist/i18n.d.cts

@@ -0,0 +1,36 @@
+/**
+ * @embedpdf/vue/i18n: the Vue surface of `@embedpdf/plugin-i18n`. The plugin
+ * belongs to the workspace and needs no engine, so these composables work from
+ * the first frame, before a document opens: a loading screen and a password
+ * prompt translate too.
+ */
+export * from '@embedpdf/plugin-i18n';
+import type { I18nCapability, TranslateOptions } from '@embedpdf/plugin-i18n';
+import type { EventHook } from '@embedpdf/core';
+/** The i18n API: `t`, `setLocale`, `addTranslations`, `registerLocale`, the settings calls. The object never changes. */
+export declare function useI18n(): I18nCapability;
+/** Subscribe to one i18n event while the component lives: `useI18nEvent((i18n) => i18n.onLocaleChanged, handler)`. */
+export declare function useI18nEvent<Event>(select: (i18n: I18nCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The current language, how it reads, every language you can switch to, and
+ * the one loading, as refs (the translations page's State table, declared once
+ * in `i18nState`). With a selector, one ref, which updates only when what it
+ * picks changes.
+ */
+export declare const useI18nState: import("./state.cjs").StateComposable<{
+    locale: string;
+    direction: import("@embedpdf/plugin-i18n").TextDirection;
+    locales: readonly import("@embedpdf/plugin-i18n").LocaleInfo[];
+    loading: string | null;
+}>;
+/** The i18n settings (`locale`, `fallbackLocale`, `locales`, `loaders`) as refs. Takes a selector. */
+export declare const useI18nSettings: import("./state.cjs").SettingsComposable<import("@embedpdf/plugin-i18n").I18nSettings & object>;
+/**
+ * A translate function that reads the language reactively: a template, a
+ * computed or a `watch` that calls it updates when the language or the strings
+ * change. The function itself never changes, so it can be kept anywhere.
+ *
+ *   const t = useT();
+ *   <span>{{ t('search.results', { params: { count } }) }}</span>
+ */
+export declare function useT(): (key: string, options?: TranslateOptions) => string;

package/dist/i18n.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @embedpdf/vue/i18n: the Vue surface of `@embedpdf/plugin-i18n`. The plugin
+ * belongs to the workspace and needs no engine, so these composables work from
+ * the first frame, before a document opens: a loading screen and a password
+ * prompt translate too.
+ */
+export * from '@embedpdf/plugin-i18n';
+import type { I18nCapability, TranslateOptions } from '@embedpdf/plugin-i18n';
+import type { EventHook } from '@embedpdf/core';
+/** The i18n API: `t`, `setLocale`, `addTranslations`, `registerLocale`, the settings calls. The object never changes. */
+export declare function useI18n(): I18nCapability;
+/** Subscribe to one i18n event while the component lives: `useI18nEvent((i18n) => i18n.onLocaleChanged, handler)`. */
+export declare function useI18nEvent<Event>(select: (i18n: I18nCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The current language, how it reads, every language you can switch to, and
+ * the one loading, as refs (the translations page's State table, declared once
+ * in `i18nState`). With a selector, one ref, which updates only when what it
+ * picks changes.
+ */
+export declare const useI18nState: import("./state.js").StateComposable<{
+    locale: string;
+    direction: import("@embedpdf/plugin-i18n").TextDirection;
+    locales: readonly import("@embedpdf/plugin-i18n").LocaleInfo[];
+    loading: string | null;
+}>;
+/** The i18n settings (`locale`, `fallbackLocale`, `locales`, `loaders`) as refs. Takes a selector. */
+export declare const useI18nSettings: import("./state.js").SettingsComposable<import("@embedpdf/plugin-i18n").I18nSettings & object>;
+/**
+ * A translate function that reads the language reactively: a template, a
+ * computed or a `watch` that calls it updates when the language or the strings
+ * change. The function itself never changes, so it can be kept anywhere.
+ *
+ *   const t = useT();
+ *   <span>{{ t('search.results', { params: { count } }) }}</span>
+ */
+export declare function useT(): (key: string, options?: TranslateOptions) => string;

package/dist/i18n.js

@@ -0,0 +1,24 @@
+import { I18nToken, i18nState } from "@embedpdf/plugin-i18n";
+export * from "@embedpdf/plugin-i18n";
+import { a as useCapability, b as useCapabilityEvent, j as useSelector } from "./capabilities-C7YzgPCX.js";
+import { s as settingsComposable, a as stateComposable } from "./state-DZg8q3v6.js";
+function useI18n() {
+  return useCapability(I18nToken);
+}
+function useI18nEvent(select, handler) {
+  useCapabilityEvent(I18nToken, select, handler);
+}
+const useI18nState = stateComposable(i18nState);
+const useI18nSettings = settingsComposable(I18nToken);
+function useT() {
+  const translator = useSelector(I18nToken, (i18n) => i18n.getTranslator());
+  return (key, options) => translator.value(key, options);
+}
+export {
+  useI18n,
+  useI18nEvent,
+  useI18nSettings,
+  useI18nState,
+  useT
+};
+//# sourceMappingURL=i18n.js.map

package/dist/i18n.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.js","sources":["../src/i18n.ts"],"sourcesContent":["/**\n * @embedpdf/vue/i18n: the Vue surface of `@embedpdf/plugin-i18n`. The plugin\n * belongs to the workspace and needs no engine, so these composables work from\n * the first frame, before a document opens: a loading screen and a password\n * prompt translate too.\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-i18n';\nimport { I18nToken, i18nState } from '@embedpdf/plugin-i18n';\nimport type { I18nCapability, TranslateOptions } from '@embedpdf/plugin-i18n';\nimport type { EventHook } from '@embedpdf/core';\nimport { useCapability, useCapabilityEvent, useSelector } from './runtime/capabilities';\nimport { settingsComposable, stateComposable } from './state';\n\n/** The i18n API: `t`, `setLocale`, `addTranslations`, `registerLocale`, the settings calls. The object never changes. */\nexport function useI18n(): I18nCapability {\n  return useCapability(I18nToken);\n}\n\n/** Subscribe to one i18n event while the component lives: `useI18nEvent((i18n) => i18n.onLocaleChanged, handler)`. */\nexport function useI18nEvent<Event>(\n  select: (i18n: I18nCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(I18nToken, select, handler);\n}\n\n/**\n * The current language, how it reads, every language you can switch to, and\n * the one loading, as refs (the translations page's State table, declared once\n * in `i18nState`). With a selector, one ref, which updates only when what it\n * picks changes.\n */\nexport const useI18nState = stateComposable(i18nState);\n\n/** The i18n settings (`locale`, `fallbackLocale`, `locales`, `loaders`) as refs. Takes a selector. */\nexport const useI18nSettings = settingsComposable(I18nToken);\n\n/**\n * A translate function that reads the language reactively: a template, a\n * computed or a `watch` that calls it updates when the language or the strings\n * change. The function itself never changes, so it can be kept anywhere.\n *\n *   const t = useT();\n *   <span>{{ t('search.results', { params: { count } }) }}</span>\n */\nexport function useT(): (key: string, options?: TranslateOptions) => string {\n  // The plugin hands out a new translator when the language or the strings change;\n  // reading the ref inside the call is what makes the caller depend on it.\n  const translator = useSelector(I18nToken, (i18n) => i18n.getTranslator());\n  return (key, options) => translator.value(key, options);\n}\n"],"names":[],"mappings":";;;;AAgBO,SAAS,UAA0B;AACxC,SAAO,cAAc,SAAS;AAChC;AAGO,SAAS,aACd,QACA,SACM;AACN,qBAAmB,WAAW,QAAQ,OAAO;AAC/C;AAQO,MAAM,eAAe,gBAAgB,SAAS;AAG9C,MAAM,kBAAkB,mBAAmB,SAAS;AAUpD,SAAS,OAA4D;AAG1E,QAAM,aAAa,YAAY,WAAW,CAAC,SAAS,KAAK,eAAe;AACxE,SAAO,CAAC,KAAK,YAAY,WAAW,MAAM,KAAK,OAAO;AACxD;"}