@embedpdf/react 3.0.0-next.13 → 3.0.0-next.15

package/dist/form.d.cts

@@ -1,35 +1,42 @@
-import { o as AnnotationRenderer } from "./annotation-BCED_p9H.cjs";
-import { t as FormSnapshot } from "./AnnotationListSnapshot-D3mFut1e-C_GMpK25.cjs";
-import { FormFieldDTO } from "@embedpdf/plugin-form";
+import { n as StateHook, t as SettingsHook } from "./state-0K1I5cM4.cjs";
+import { i as FormKind, n as FormFieldDTO } from "./AnnotationList-CkijRHet-HEFNUIZe.cjs";
+import { EventHook } from "@embedpdf/core";
+import { FormCapability, FormFieldRef, FormFieldValue } from "@embedpdf/plugin-form";
 export * from "@embedpdf/plugin-form";
 //#region src/form.d.ts
 /**
- * The form plugin's renderer entry, ready for
- * `<AnnotationLayer renderers={[formWidgetRenderer]} />`. It answers for the
- * PLUGIN-registered 'form-widgets' Behavior — the form plugin decides when
- * widgets are fill controls vs. editable annotations, never the app.
+ * The form's fields on one page: their pictures, and the controls people fill
+ * them in with. Put it above the page's picture (`<RenderLayer>`, and
+ * `<AnnotationLayer>` when the annotation plugin is registered); while it's
+ * there, the render layer leaves the fields out of the page's picture. The
+ * controls show while the active tool fills forms (the `pointer` and `pan`
+ * tools do), and stand down in design mode, where fields are boxes you
+ * select and move.
  */
-declare const formWidgetRenderer: AnnotationRenderer;
+declare function FormLayer(): import("react/jsx-runtime").JSX.Element;
+/** The form API for the surrounding document: reading, filling, form data and building. */
+declare function useForm(): FormCapability;
+/** Subscribe to one form event while mounted: `useFormEvent((form) => form.onValueChanged, handler)`. */
+declare function useFormEvent<T>(select: (form: FormCapability) => EventHook<T>, handler: (event: T) => void): void;
 /**
- * Fill-mode form controls for one page, positioned from the form model's own
- * widget geometry — the ANNOTATION-LESS path (a fill-only viewer whose page
- * pixels come from an annotated RenderLayer raster). Active whenever the
- * active tool carries the 'form-fill' tag (the built-in pointer/pan tools
- * do); any other tool stands the controls down. Do not mount next to an
- * AnnotationLayer wired with `formWidgetBehaviors`.
+ * The form's state: every field, whether it's read, what kind of form the
+ * document has, and the field of the selected widget (the page's State
+ * table, declared once in `formState`). Takes a selector, and re-renders only
+ * when what it returns changes.
  */
-declare function FormLayer(): import("react/jsx-runtime").JSX.Element | null;
-/** The form capability — values, interchange, design-mode verbs. */
-declare function useForm(): import("@embedpdf/plugin-form").FormCapability;
-/** The reconciled form snapshot (null until the first load lands),
- *  re-rendering on every form model change. */
-declare function useFormSnapshot(): FormSnapshot | null;
+declare const useFormState: StateHook<{
+  fields: readonly FormFieldDTO[];
+  status: import("@embedpdf/core").ResourceStatus;
+  formKind: FormKind;
+  selectedField: FormFieldDTO | null;
+}>;
+/** The form settings (`validation`, `focus`, `fields`), with or without a document. Takes a selector. */
+declare const useFormSettings: SettingsHook<import("@embedpdf/plugin-form").FormSettings>;
 /**
- * The FIELD behind the currently selected widget annotation (single
- * selection), or null. The design-mode join: widget selection lives in the
- * annotation plane, field properties live here.
+ * One field's value, in the shape `setValue()` takes, or `null`: re-renders
+ * only when that field's value changes. Empty without a document.
  */
-declare function useFormField(): FormFieldDTO | null;
+declare function useFormValue(ref: FormFieldRef): FormFieldValue | null;
 //#endregion
-export { FormLayer, formWidgetRenderer, useForm, useFormField, useFormSnapshot };
+export { FormLayer, useForm, useFormEvent, useFormSettings, useFormState, useFormValue };
 //# sourceMappingURL=form.d.cts.map

package/dist/form.d.ts

@@ -1,35 +1,42 @@
-import { o as AnnotationRenderer } from "./annotation-k38KDlIZ.js";
-import { t as FormSnapshot } from "./AnnotationListSnapshot-D3mFut1e-C_GMpK25.js";
-import { FormFieldDTO } from "@embedpdf/plugin-form";
+import { n as StateHook, t as SettingsHook } from "./state-0K1I5cM4.js";
+import { i as FormKind, n as FormFieldDTO } from "./AnnotationList-CkijRHet-HEFNUIZe.js";
+import { EventHook } from "@embedpdf/core";
+import { FormCapability, FormFieldRef, FormFieldValue } from "@embedpdf/plugin-form";
 export * from "@embedpdf/plugin-form";
 //#region src/form.d.ts
 /**
- * The form plugin's renderer entry, ready for
- * `<AnnotationLayer renderers={[formWidgetRenderer]} />`. It answers for the
- * PLUGIN-registered 'form-widgets' Behavior — the form plugin decides when
- * widgets are fill controls vs. editable annotations, never the app.
+ * The form's fields on one page: their pictures, and the controls people fill
+ * them in with. Put it above the page's picture (`<RenderLayer>`, and
+ * `<AnnotationLayer>` when the annotation plugin is registered); while it's
+ * there, the render layer leaves the fields out of the page's picture. The
+ * controls show while the active tool fills forms (the `pointer` and `pan`
+ * tools do), and stand down in design mode, where fields are boxes you
+ * select and move.
  */
-declare const formWidgetRenderer: AnnotationRenderer;
+declare function FormLayer(): import("react/jsx-runtime").JSX.Element;
+/** The form API for the surrounding document: reading, filling, form data and building. */
+declare function useForm(): FormCapability;
+/** Subscribe to one form event while mounted: `useFormEvent((form) => form.onValueChanged, handler)`. */
+declare function useFormEvent<T>(select: (form: FormCapability) => EventHook<T>, handler: (event: T) => void): void;
 /**
- * Fill-mode form controls for one page, positioned from the form model's own
- * widget geometry — the ANNOTATION-LESS path (a fill-only viewer whose page
- * pixels come from an annotated RenderLayer raster). Active whenever the
- * active tool carries the 'form-fill' tag (the built-in pointer/pan tools
- * do); any other tool stands the controls down. Do not mount next to an
- * AnnotationLayer wired with `formWidgetBehaviors`.
+ * The form's state: every field, whether it's read, what kind of form the
+ * document has, and the field of the selected widget (the page's State
+ * table, declared once in `formState`). Takes a selector, and re-renders only
+ * when what it returns changes.
  */
-declare function FormLayer(): import("react/jsx-runtime").JSX.Element | null;
-/** The form capability — values, interchange, design-mode verbs. */
-declare function useForm(): import("@embedpdf/plugin-form").FormCapability;
-/** The reconciled form snapshot (null until the first load lands),
- *  re-rendering on every form model change. */
-declare function useFormSnapshot(): FormSnapshot | null;
+declare const useFormState: StateHook<{
+  fields: readonly FormFieldDTO[];
+  status: import("@embedpdf/core").ResourceStatus;
+  formKind: FormKind;
+  selectedField: FormFieldDTO | null;
+}>;
+/** The form settings (`validation`, `focus`, `fields`), with or without a document. Takes a selector. */
+declare const useFormSettings: SettingsHook<import("@embedpdf/plugin-form").FormSettings>;
 /**
- * The FIELD behind the currently selected widget annotation (single
- * selection), or null. The design-mode join: widget selection lives in the
- * annotation plane, field properties live here.
+ * One field's value, in the shape `setValue()` takes, or `null`: re-renders
+ * only when that field's value changes. Empty without a document.
  */
-declare function useFormField(): FormFieldDTO | null;
+declare function useFormValue(ref: FormFieldRef): FormFieldValue | null;
 //#endregion
-export { FormLayer, formWidgetRenderer, useForm, useFormField, useFormSnapshot };
+export { FormLayer, useForm, useFormEvent, useFormSettings, useFormState, useFormValue };
 //# sourceMappingURL=form.d.ts.map

package/dist/form.js

@@ -1,4 +1,3 @@
-import "./runtime.js";
-import { a as useFormSnapshot, i as useFormField, n as formWidgetRenderer, r as useForm, t as FormLayer } from "./form-CK3mp99m.js";
+import { a as useFormState, i as useFormSettings, n as useForm, o as useFormValue, r as useFormEvent, t as FormLayer } from "./form-55izw0jS.js";
 export * from "@embedpdf/plugin-form";
-export { FormLayer, formWidgetRenderer, useForm, useFormField, useFormSnapshot };
+export { FormLayer, useForm, useFormEvent, useFormSettings, useFormState, useFormValue };

package/dist/history.cjs

@@ -0,0 +1,38 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./rolldown-runtime-DDXJien1.cjs");
+const require_runtime = require("./runtime-fzpGv78v.cjs");
+const require_state = require("./state-CsfZy_Eq.cjs");
+let _embedpdf_plugin_history = require("@embedpdf/plugin-history");
+//#region src/history.ts
+/**
+* The history (undo, redo, canUndo, canRedo, the labels, clear) of the
+* surrounding `<DocumentScope>`'s document, else the active one. Outside a
+* document, every method throws `not-ready`.
+*/
+function useHistory() {
+	return require_runtime.useCapability(_embedpdf_plugin_history.HistoryToken);
+}
+/**
+* Whether undo and redo can run, and what they would undo and redo (the
+* page's State table, declared once in `historyState`). Takes a selector, and
+* re-renders only when what it returns changes.
+*/
+const useHistoryState = require_state.stateHook(_embedpdf_plugin_history.historyState);
+/** Subscribe to one history event for the mounted lifetime: `useHistoryEvent((history) => history.onUndone, handler)`. */
+function useHistoryEvent(select, handler) {
+	require_runtime.useCapabilityEvent(_embedpdf_plugin_history.HistoryToken, select, handler);
+}
+//#endregion
+exports.useHistory = useHistory;
+exports.useHistoryEvent = useHistoryEvent;
+exports.useHistoryState = useHistoryState;
+Object.keys(_embedpdf_plugin_history).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return _embedpdf_plugin_history[k];
+		}
+	});
+});
+
+//# sourceMappingURL=history.cjs.map

package/dist/history.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.cjs","names":["useCapability","HistoryToken","stateHook","historyState"],"sources":["../src/history.ts"],"sourcesContent":["/**\n * The React surface for @embedpdf/plugin-history: undo and redo of what you\n * change through the viewer, one history per open document. An action shows\n * undone at once, even while it is still on its way to the engine.\n *\n *   const history = useHistory();\n *   const { canUndo, undoLabel } = useHistoryState();\n *   <button disabled={!canUndo} onClick={() => history.undo()}>Undo</button>\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-history';\nimport type { EventHook } from '@embedpdf/core';\nimport { HistoryToken, historyState, type HistoryCapability } from '@embedpdf/plugin-history';\n\nimport { useCapability, useCapabilityEvent } from './runtime';\nimport { stateHook } from './state';\n\n/**\n * The history (undo, redo, canUndo, canRedo, the labels, clear) of the\n * surrounding `<DocumentScope>`'s document, else the active one. 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 (the\n * page's State table, declared once in `historyState`). Takes a selector, and\n * re-renders only when what it returns changes.\n */\nexport const useHistoryState = stateHook(historyState);\n\n/** Subscribe to one history event for the mounted lifetime: `useHistoryEvent((history) => history.onUndone, handler)`. */\nexport function useHistoryEvent<T>(\n  select: (history: HistoryCapability) => EventHook<T>,\n  handler: (event: T) => void,\n): void {\n  useCapabilityEvent(HistoryToken, select, handler);\n}\n"],"mappings":";;;;;;;;;;;AAuBA,SAAgB,aAAgC;CAC9C,OAAOA,gBAAAA,cAAcC,yBAAAA,YAAY;AACnC;;;;;;AAOA,MAAa,kBAAkBC,cAAAA,UAAUC,yBAAAA,YAAY;;AAGrD,SAAgB,gBACd,QACA,SACM;CACN,gBAAA,mBAAmBF,yBAAAA,cAAc,QAAQ,OAAO;AAClD"}

package/dist/history.d.cts

@@ -0,0 +1,27 @@
+import { n as StateHook } from "./state-0K1I5cM4.cjs";
+import { EventHook } from "@embedpdf/core";
+import { HistoryCapability } from "@embedpdf/plugin-history";
+export * from "@embedpdf/plugin-history";
+//#region src/history.d.ts
+/**
+ * The history (undo, redo, canUndo, canRedo, the labels, clear) of the
+ * surrounding `<DocumentScope>`'s document, else the active one. Outside a
+ * document, every method throws `not-ready`.
+ */
+declare function useHistory(): HistoryCapability;
+/**
+ * Whether undo and redo can run, and what they would undo and redo (the
+ * page's State table, declared once in `historyState`). Takes a selector, and
+ * re-renders only when what it returns changes.
+ */
+declare const useHistoryState: StateHook<{
+  canUndo: boolean;
+  canRedo: boolean;
+  undoLabel: import("@embedpdf/core").ChangeLabel | null;
+  redoLabel: import("@embedpdf/core").ChangeLabel | null;
+}>;
+/** Subscribe to one history event for the mounted lifetime: `useHistoryEvent((history) => history.onUndone, handler)`. */
+declare function useHistoryEvent<T>(select: (history: HistoryCapability) => EventHook<T>, handler: (event: T) => void): void;
+//#endregion
+export { useHistory, useHistoryEvent, useHistoryState };
+//# sourceMappingURL=history.d.cts.map

package/dist/history.d.ts

@@ -0,0 +1,27 @@
+import { n as StateHook } from "./state-0K1I5cM4.js";
+import { EventHook } from "@embedpdf/core";
+import { HistoryCapability } from "@embedpdf/plugin-history";
+export * from "@embedpdf/plugin-history";
+//#region src/history.d.ts
+/**
+ * The history (undo, redo, canUndo, canRedo, the labels, clear) of the
+ * surrounding `<DocumentScope>`'s document, else the active one. Outside a
+ * document, every method throws `not-ready`.
+ */
+declare function useHistory(): HistoryCapability;
+/**
+ * Whether undo and redo can run, and what they would undo and redo (the
+ * page's State table, declared once in `historyState`). Takes a selector, and
+ * re-renders only when what it returns changes.
+ */
+declare const useHistoryState: StateHook<{
+  canUndo: boolean;
+  canRedo: boolean;
+  undoLabel: import("@embedpdf/core").ChangeLabel | null;
+  redoLabel: import("@embedpdf/core").ChangeLabel | null;
+}>;
+/** Subscribe to one history event for the mounted lifetime: `useHistoryEvent((history) => history.onUndone, handler)`. */
+declare function useHistoryEvent<T>(select: (history: HistoryCapability) => EventHook<T>, handler: (event: T) => void): void;
+//#endregion
+export { useHistory, useHistoryEvent, useHistoryState };
+//# sourceMappingURL=history.d.ts.map

package/dist/history.js

@@ -0,0 +1,27 @@
+import { f as useCapability, p as useCapabilityEvent } from "./runtime-B6xcPsEb.js";
+import { n as stateHook } from "./state-CbgxhwLA.js";
+import { HistoryToken, historyState } from "@embedpdf/plugin-history";
+export * from "@embedpdf/plugin-history";
+//#region src/history.ts
+/**
+* The history (undo, redo, canUndo, canRedo, the labels, clear) of the
+* surrounding `<DocumentScope>`'s document, else the active one. Outside a
+* document, every method throws `not-ready`.
+*/
+function useHistory() {
+	return useCapability(HistoryToken);
+}
+/**
+* Whether undo and redo can run, and what they would undo and redo (the
+* page's State table, declared once in `historyState`). Takes a selector, and
+* re-renders only when what it returns changes.
+*/
+const useHistoryState = stateHook(historyState);
+/** Subscribe to one history event for the mounted lifetime: `useHistoryEvent((history) => history.onUndone, handler)`. */
+function useHistoryEvent(select, handler) {
+	useCapabilityEvent(HistoryToken, select, handler);
+}
+//#endregion
+export { useHistory, useHistoryEvent, useHistoryState };
+
+//# sourceMappingURL=history.js.map

package/dist/history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.js","names":[],"sources":["../src/history.ts"],"sourcesContent":["/**\n * The React surface for @embedpdf/plugin-history: undo and redo of what you\n * change through the viewer, one history per open document. An action shows\n * undone at once, even while it is still on its way to the engine.\n *\n *   const history = useHistory();\n *   const { canUndo, undoLabel } = useHistoryState();\n *   <button disabled={!canUndo} onClick={() => history.undo()}>Undo</button>\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-history';\nimport type { EventHook } from '@embedpdf/core';\nimport { HistoryToken, historyState, type HistoryCapability } from '@embedpdf/plugin-history';\n\nimport { useCapability, useCapabilityEvent } from './runtime';\nimport { stateHook } from './state';\n\n/**\n * The history (undo, redo, canUndo, canRedo, the labels, clear) of the\n * surrounding `<DocumentScope>`'s document, else the active one. 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 (the\n * page's State table, declared once in `historyState`). Takes a selector, and\n * re-renders only when what it returns changes.\n */\nexport const useHistoryState = stateHook(historyState);\n\n/** Subscribe to one history event for the mounted lifetime: `useHistoryEvent((history) => history.onUndone, handler)`. */\nexport function useHistoryEvent<T>(\n  select: (history: HistoryCapability) => EventHook<T>,\n  handler: (event: T) => void,\n): void {\n  useCapabilityEvent(HistoryToken, select, handler);\n}\n"],"mappings":";;;;;;;;;;AAuBA,SAAgB,aAAgC;CAC9C,OAAO,cAAc,YAAY;AACnC;;;;;;AAOA,MAAa,kBAAkB,UAAU,YAAY;;AAGrD,SAAgB,gBACd,QACA,SACM;CACN,mBAAmB,cAAc,QAAQ,OAAO;AAClD"}

package/dist/i18n.cjs

@@ -1,44 +1,40 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_runtime = require("./runtime.cjs");
-let react = require("react");
+require("./rolldown-runtime-DDXJien1.cjs");
+const require_runtime = require("./runtime-fzpGv78v.cjs");
+const require_state = require("./state-CsfZy_Eq.cjs");
 let _embedpdf_plugin_i18n = require("@embedpdf/plugin-i18n");
 //#region src/i18n.ts
-/** The raw i18n capability (t / setLocale / locales / dir / …). */
-const useI18n = () => require_runtime.useCapability(_embedpdf_plugin_i18n.I18nToken);
+/** The i18n capability: `t`, `setLocale`, `addTranslations`, `registerLocale`, the settings calls. */
+function useI18n() {
+	return require_runtime.useCapability(_embedpdf_plugin_i18n.I18nToken);
+}
+/** Subscribe to one i18n event for the mounted lifetime: `useI18nEvent((i18n) => i18n.onLocaleChanged, handler)`. */
+function useI18nEvent(select, handler) {
+	require_runtime.useCapabilityEvent(_embedpdf_plugin_i18n.I18nToken, select, handler);
+}
 /**
-* A reactive translate function. New identity whenever i18n state changes
-* (locale switch, pack registered), so memoized children re-render too.
-*
-*   const t = useT();
-*   <button title={t('commands.zoom.in')}>+</button>
-*   <span>{t('pages', { params: { count } })}</span>
+* The current language, how it reads, every language you can switch to, and the one loading (the
+* translations page's State table, declared once in `i18nState`). Takes a selector, and
+* re-renders only when what it returns changes.
 */
-function useT() {
-	const i18n = require_runtime.useCapability(_embedpdf_plugin_i18n.I18nToken);
-	return (0, react.useMemo)(() => (key, options) => i18n.t(key, options), [i18n, require_runtime.useKernelValue((k) => k.getState().plugins["i18n"])]);
-}
-const localeListEqual = (a, b) => a.length === b.length && a.every((x, i) => x.code === b[i].code && x.name === b[i].name && x.loaded === b[i].loaded);
+const useI18nState = require_state.stateHook(_embedpdf_plugin_i18n.i18nState);
+/** The i18n settings (`locale`, `fallbackLocale`, `locales`, `loaders`). Takes a selector. */
+const useI18nSettings = require_state.settingsHook(_embedpdf_plugin_i18n.I18nToken);
 /**
-* Everything a locale switcher needs, reactive.
+* A translate function that re-renders the component when the language or the strings change,
+* and keeps its identity otherwise, so memoized children holding it re-render too.
 *
-*   const { locale, locales, loading, setLocale } = useLocale();
+*   const t = useT();
+*   <span>{t('search.results', { params: { count } })}</span>
 */
-function useLocale() {
-	const i18n = require_runtime.useCapability(_embedpdf_plugin_i18n.I18nToken);
-	const locale = require_runtime.useSelector(_embedpdf_plugin_i18n.I18nToken, (c) => c.locale());
-	const dir = require_runtime.useSelector(_embedpdf_plugin_i18n.I18nToken, (c) => c.dir());
-	const loading = require_runtime.useSelector(_embedpdf_plugin_i18n.I18nToken, (c) => c.loading());
-	return {
-		locale,
-		dir,
-		locales: require_runtime.useSelector(_embedpdf_plugin_i18n.I18nToken, (c) => c.locales(), localeListEqual),
-		loading,
-		setLocale: i18n.setLocale
-	};
+function useT() {
+	return require_runtime.useSelector(_embedpdf_plugin_i18n.I18nToken, (i18n) => i18n.getTranslator());
 }
 //#endregion
 exports.useI18n = useI18n;
-exports.useLocale = useLocale;
+exports.useI18nEvent = useI18nEvent;
+exports.useI18nSettings = useI18nSettings;
+exports.useI18nState = useI18nState;
 exports.useT = useT;
 Object.keys(_embedpdf_plugin_i18n).forEach(function(k) {
 	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {

package/dist/i18n.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"i18n.cjs","names":["useCapability","I18nToken","useKernelValue","useSelector"],"sources":["../src/i18n.ts"],"sourcesContent":["/**\n * The React surface for @embedpdf/plugin-i18n — sugar over the generic\n * binding, nothing more. The plugin keeps locale packs in the store, so\n * reactivity is the kernel's one change stream; there are no emitters to\n * subscribe and no per-plugin plumbing.\n *\n * Because the capability is workspace-scoped and engine-free, these hooks\n * work from the FIRST frame — including inside `<Viewer fallback>` — while\n * the engine is still booting.\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-i18n';\nimport { useMemo } from 'react';\nimport { I18nToken } from '@embedpdf/plugin-i18n';\nimport type { LocaleInfo, TranslateOptions } from '@embedpdf/plugin-i18n';\nimport { useCapability, useKernelValue, useSelector } from './runtime';\n\n/** The raw i18n capability (t / setLocale / locales / dir / …). */\nexport const useI18n = () => useCapability(I18nToken);\n\n/**\n * A reactive translate function. New identity whenever i18n state changes\n * (locale switch, pack registered), so memoized children re-render too.\n *\n *   const t = useT();\n *   <button title={t('commands.zoom.in')}>+</button>\n *   <span>{t('pages', { params: { count } })}</span>\n */\nexport function useT(): (key: string, options?: TranslateOptions) => string {\n  const i18n = useCapability(I18nToken);\n  const slice = useKernelValue((k) => k.getState().plugins['i18n']);\n  return useMemo(() => (key, options) => i18n.t(key, options), [i18n, slice]);\n}\n\nconst localeListEqual = (a: LocaleInfo[], b: LocaleInfo[]): boolean =>\n  a.length === b.length &&\n  a.every((x, i) => x.code === b[i].code && x.name === b[i].name && x.loaded === b[i].loaded);\n\n/**\n * Everything a locale switcher needs, reactive.\n *\n *   const { locale, locales, loading, setLocale } = useLocale();\n */\nexport function useLocale(): {\n  locale: string;\n  dir: 'ltr' | 'rtl';\n  locales: LocaleInfo[];\n  /** Code of a lazy pack being fetched, if any — show a spinner on it. */\n  loading: string | null;\n  setLocale: (code: string) => void;\n} {\n  const i18n = useCapability(I18nToken);\n  const locale = useSelector(I18nToken, (c) => c.locale());\n  const dir = useSelector(I18nToken, (c) => c.dir());\n  const loading = useSelector(I18nToken, (c) => c.loading());\n  const locales = useSelector(I18nToken, (c) => c.locales(), localeListEqual);\n  return { locale, dir, locales, loading, setLocale: i18n.setLocale };\n}\n"],"mappings":";;;;;;AAmBA,MAAa,gBAAgBA,gBAAAA,cAAcC,sBAAAA,SAAS;;;;;;;;;AAUpD,SAAgB,OAA4D;CAC1E,MAAM,OAAOD,gBAAAA,cAAcC,sBAAAA,SAAS;CAEpC,QAAA,GAAA,MAAA,QAAA,QAAsB,KAAK,YAAY,KAAK,EAAE,KAAK,OAAO,GAAG,CAAC,MADhDC,gBAAAA,gBAAgB,MAAM,EAAE,SAAS,CAAC,CAAC,QAAQ,OACe,CAAC,CAAC;AAC5E;AAEA,MAAM,mBAAmB,GAAiB,MACxC,EAAE,WAAW,EAAE,UACf,EAAE,OAAO,GAAG,MAAM,EAAE,SAAS,EAAE,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,EAAE,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,CAAC,MAAM;;;;;;AAO5F,SAAgB,YAOd;CACA,MAAM,OAAOF,gBAAAA,cAAcC,sBAAAA,SAAS;CACpC,MAAM,SAASE,gBAAAA,YAAYF,sBAAAA,YAAY,MAAM,EAAE,OAAO,CAAC;CACvD,MAAM,MAAME,gBAAAA,YAAYF,sBAAAA,YAAY,MAAM,EAAE,IAAI,CAAC;CACjD,MAAM,UAAUE,gBAAAA,YAAYF,sBAAAA,YAAY,MAAM,EAAE,QAAQ,CAAC;CAEzD,OAAO;EAAE;EAAQ;EAAK,SADNE,gBAAAA,YAAYF,sBAAAA,YAAY,MAAM,EAAE,QAAQ,GAAG,eAC/B;EAAG;EAAS,WAAW,KAAK;CAAU;AACpE"}
+{"version":3,"file":"i18n.cjs","names":["useCapability","I18nToken","stateHook","i18nState","settingsHook","useSelector"],"sources":["../src/i18n.ts"],"sourcesContent":["/**\n * The React surface for @embedpdf/plugin-i18n. The plugin is workspace-scoped\n * and needs no engine, so these hooks work from the first frame, before a\n * document opens: a loading screen and a password 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';\nimport { settingsHook, stateHook } from './state';\n\n/** The i18n capability: `t`, `setLocale`, `addTranslations`, `registerLocale`, the settings calls. */\nexport function useI18n(): I18nCapability {\n  return useCapability(I18nToken);\n}\n\n/** Subscribe to one i18n event for the mounted lifetime: `useI18nEvent((i18n) => i18n.onLocaleChanged, handler)`. */\nexport function useI18nEvent<T>(\n  select: (i18n: I18nCapability) => EventHook<T>,\n  handler: (event: T) => 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 the one loading (the\n * translations page's State table, declared once in `i18nState`). Takes a selector, and\n * re-renders only when what it returns changes.\n */\nexport const useI18nState = stateHook(i18nState);\n\n/** The i18n settings (`locale`, `fallbackLocale`, `locales`, `loaders`). Takes a selector. */\nexport const useI18nSettings = settingsHook(I18nToken);\n\n/**\n * A translate function that re-renders the component when the language or the strings change,\n * and keeps its identity otherwise, so memoized children holding it re-render too.\n *\n *   const t = useT();\n *   <span>{t('search.results', { params: { count } })}</span>\n */\nexport function useT(): (key: string, options?: TranslateOptions) => string {\n  return useSelector(I18nToken, (i18n) => i18n.getTranslator());\n}\n"],"mappings":";;;;;;;AAeA,SAAgB,UAA0B;CACxC,OAAOA,gBAAAA,cAAcC,sBAAAA,SAAS;AAChC;;AAGA,SAAgB,aACd,QACA,SACM;CACN,gBAAA,mBAAmBA,sBAAAA,WAAW,QAAQ,OAAO;AAC/C;;;;;;AAOA,MAAa,eAAeC,cAAAA,UAAUC,sBAAAA,SAAS;;AAG/C,MAAa,kBAAkBC,cAAAA,aAAaH,sBAAAA,SAAS;;;;;;;;AASrD,SAAgB,OAA4D;CAC1E,OAAOI,gBAAAA,YAAYJ,sBAAAA,YAAY,SAAS,KAAK,cAAc,CAAC;AAC9D"}

package/dist/i18n.d.cts

@@ -1,30 +1,33 @@
-import { LocaleInfo, TranslateOptions } from "@embedpdf/plugin-i18n";
+import { n as StateHook, t as SettingsHook } from "./state-0K1I5cM4.cjs";
+import { EventHook } from "@embedpdf/core";
+import { I18nCapability, TranslateOptions } from "@embedpdf/plugin-i18n";
 export * from "@embedpdf/plugin-i18n";
 //#region src/i18n.d.ts
-/** The raw i18n capability (t / setLocale / locales / dir / …). */
-declare const useI18n: () => import("@embedpdf/plugin-i18n").I18nCapability;
+/** The i18n capability: `t`, `setLocale`, `addTranslations`, `registerLocale`, the settings calls. */
+declare function useI18n(): I18nCapability;
+/** Subscribe to one i18n event for the mounted lifetime: `useI18nEvent((i18n) => i18n.onLocaleChanged, handler)`. */
+declare function useI18nEvent<T>(select: (i18n: I18nCapability) => EventHook<T>, handler: (event: T) => void): void;
 /**
- * A reactive translate function. New identity whenever i18n state changes
- * (locale switch, pack registered), so memoized children re-render too.
- *
- *   const t = useT();
- *   <button title={t('commands.zoom.in')}>+</button>
- *   <span>{t('pages', { params: { count } })}</span>
+ * The current language, how it reads, every language you can switch to, and the one loading (the
+ * translations page's State table, declared once in `i18nState`). Takes a selector, and
+ * re-renders only when what it returns changes.
  */
-declare function useT(): (key: string, options?: TranslateOptions) => string;
+declare const useI18nState: StateHook<{
+  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`). Takes a selector. */
+declare const useI18nSettings: SettingsHook<import("@embedpdf/plugin-i18n").I18nSettings>;
 /**
- * Everything a locale switcher needs, reactive.
+ * A translate function that re-renders the component when the language or the strings change,
+ * and keeps its identity otherwise, so memoized children holding it re-render too.
  *
- *   const { locale, locales, loading, setLocale } = useLocale();
+ *   const t = useT();
+ *   <span>{t('search.results', { params: { count } })}</span>
  */
-declare function useLocale(): {
-  locale: string;
-  dir: 'ltr' | 'rtl';
-  locales: LocaleInfo[];
-  /** Code of a lazy pack being fetched, if any — show a spinner on it. */
-  loading: string | null;
-  setLocale: (code: string) => void;
-};
+declare function useT(): (key: string, options?: TranslateOptions) => string;
 //#endregion
-export { useI18n, useLocale, useT };
+export { useI18n, useI18nEvent, useI18nSettings, useI18nState, useT };
 //# sourceMappingURL=i18n.d.cts.map

package/dist/i18n.d.ts

@@ -1,30 +1,33 @@
-import { LocaleInfo, TranslateOptions } from "@embedpdf/plugin-i18n";
+import { n as StateHook, t as SettingsHook } from "./state-0K1I5cM4.js";
+import { EventHook } from "@embedpdf/core";
+import { I18nCapability, TranslateOptions } from "@embedpdf/plugin-i18n";
 export * from "@embedpdf/plugin-i18n";
 //#region src/i18n.d.ts
-/** The raw i18n capability (t / setLocale / locales / dir / …). */
-declare const useI18n: () => import("@embedpdf/plugin-i18n").I18nCapability;
+/** The i18n capability: `t`, `setLocale`, `addTranslations`, `registerLocale`, the settings calls. */
+declare function useI18n(): I18nCapability;
+/** Subscribe to one i18n event for the mounted lifetime: `useI18nEvent((i18n) => i18n.onLocaleChanged, handler)`. */
+declare function useI18nEvent<T>(select: (i18n: I18nCapability) => EventHook<T>, handler: (event: T) => void): void;
 /**
- * A reactive translate function. New identity whenever i18n state changes
- * (locale switch, pack registered), so memoized children re-render too.
- *
- *   const t = useT();
- *   <button title={t('commands.zoom.in')}>+</button>
- *   <span>{t('pages', { params: { count } })}</span>
+ * The current language, how it reads, every language you can switch to, and the one loading (the
+ * translations page's State table, declared once in `i18nState`). Takes a selector, and
+ * re-renders only when what it returns changes.
  */
-declare function useT(): (key: string, options?: TranslateOptions) => string;
+declare const useI18nState: StateHook<{
+  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`). Takes a selector. */
+declare const useI18nSettings: SettingsHook<import("@embedpdf/plugin-i18n").I18nSettings>;
 /**
- * Everything a locale switcher needs, reactive.
+ * A translate function that re-renders the component when the language or the strings change,
+ * and keeps its identity otherwise, so memoized children holding it re-render too.
  *
- *   const { locale, locales, loading, setLocale } = useLocale();
+ *   const t = useT();
+ *   <span>{t('search.results', { params: { count } })}</span>
  */
-declare function useLocale(): {
-  locale: string;
-  dir: 'ltr' | 'rtl';
-  locales: LocaleInfo[];
-  /** Code of a lazy pack being fetched, if any — show a spinner on it. */
-  loading: string | null;
-  setLocale: (code: string) => void;
-};
+declare function useT(): (key: string, options?: TranslateOptions) => string;
 //#endregion
-export { useI18n, useLocale, useT };
+export { useI18n, useI18nEvent, useI18nSettings, useI18nState, useT };
 //# sourceMappingURL=i18n.d.ts.map

package/dist/i18n.js

@@ -1,42 +1,35 @@
-import { useCapability, useKernelValue, useSelector } from "./runtime.js";
-import { useMemo } from "react";
-import { I18nToken } from "@embedpdf/plugin-i18n";
+import { E as useSelector, f as useCapability, p as useCapabilityEvent } from "./runtime-B6xcPsEb.js";
+import { n as stateHook, t as settingsHook } from "./state-CbgxhwLA.js";
+import { I18nToken, i18nState } from "@embedpdf/plugin-i18n";
 export * from "@embedpdf/plugin-i18n";
 //#region src/i18n.ts
-/** The raw i18n capability (t / setLocale / locales / dir / …). */
-const useI18n = () => useCapability(I18nToken);
+/** The i18n capability: `t`, `setLocale`, `addTranslations`, `registerLocale`, the settings calls. */
+function useI18n() {
+	return useCapability(I18nToken);
+}
+/** Subscribe to one i18n event for the mounted lifetime: `useI18nEvent((i18n) => i18n.onLocaleChanged, handler)`. */
+function useI18nEvent(select, handler) {
+	useCapabilityEvent(I18nToken, select, handler);
+}
 /**
-* A reactive translate function. New identity whenever i18n state changes
-* (locale switch, pack registered), so memoized children re-render too.
-*
-*   const t = useT();
-*   <button title={t('commands.zoom.in')}>+</button>
-*   <span>{t('pages', { params: { count } })}</span>
+* The current language, how it reads, every language you can switch to, and the one loading (the
+* translations page's State table, declared once in `i18nState`). Takes a selector, and
+* re-renders only when what it returns changes.
 */
-function useT() {
-	const i18n = useCapability(I18nToken);
-	return useMemo(() => (key, options) => i18n.t(key, options), [i18n, useKernelValue((k) => k.getState().plugins["i18n"])]);
-}
-const localeListEqual = (a, b) => a.length === b.length && a.every((x, i) => x.code === b[i].code && x.name === b[i].name && x.loaded === b[i].loaded);
+const useI18nState = stateHook(i18nState);
+/** The i18n settings (`locale`, `fallbackLocale`, `locales`, `loaders`). Takes a selector. */
+const useI18nSettings = settingsHook(I18nToken);
 /**
-* Everything a locale switcher needs, reactive.
+* A translate function that re-renders the component when the language or the strings change,
+* and keeps its identity otherwise, so memoized children holding it re-render too.
 *
-*   const { locale, locales, loading, setLocale } = useLocale();
+*   const t = useT();
+*   <span>{t('search.results', { params: { count } })}</span>
 */
-function useLocale() {
-	const i18n = useCapability(I18nToken);
-	const locale = useSelector(I18nToken, (c) => c.locale());
-	const dir = useSelector(I18nToken, (c) => c.dir());
-	const loading = useSelector(I18nToken, (c) => c.loading());
-	return {
-		locale,
-		dir,
-		locales: useSelector(I18nToken, (c) => c.locales(), localeListEqual),
-		loading,
-		setLocale: i18n.setLocale
-	};
+function useT() {
+	return useSelector(I18nToken, (i18n) => i18n.getTranslator());
 }
 //#endregion
-export { useI18n, useLocale, useT };
+export { useI18n, useI18nEvent, useI18nSettings, useI18nState, useT };
 
 //# sourceMappingURL=i18n.js.map

package/dist/i18n.js.map

@@ -1 +1 @@
-{"version":3,"file":"i18n.js","names":[],"sources":["../src/i18n.ts"],"sourcesContent":["/**\n * The React surface for @embedpdf/plugin-i18n — sugar over the generic\n * binding, nothing more. The plugin keeps locale packs in the store, so\n * reactivity is the kernel's one change stream; there are no emitters to\n * subscribe and no per-plugin plumbing.\n *\n * Because the capability is workspace-scoped and engine-free, these hooks\n * work from the FIRST frame — including inside `<Viewer fallback>` — while\n * the engine is still booting.\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-i18n';\nimport { useMemo } from 'react';\nimport { I18nToken } from '@embedpdf/plugin-i18n';\nimport type { LocaleInfo, TranslateOptions } from '@embedpdf/plugin-i18n';\nimport { useCapability, useKernelValue, useSelector } from './runtime';\n\n/** The raw i18n capability (t / setLocale / locales / dir / …). */\nexport const useI18n = () => useCapability(I18nToken);\n\n/**\n * A reactive translate function. New identity whenever i18n state changes\n * (locale switch, pack registered), so memoized children re-render too.\n *\n *   const t = useT();\n *   <button title={t('commands.zoom.in')}>+</button>\n *   <span>{t('pages', { params: { count } })}</span>\n */\nexport function useT(): (key: string, options?: TranslateOptions) => string {\n  const i18n = useCapability(I18nToken);\n  const slice = useKernelValue((k) => k.getState().plugins['i18n']);\n  return useMemo(() => (key, options) => i18n.t(key, options), [i18n, slice]);\n}\n\nconst localeListEqual = (a: LocaleInfo[], b: LocaleInfo[]): boolean =>\n  a.length === b.length &&\n  a.every((x, i) => x.code === b[i].code && x.name === b[i].name && x.loaded === b[i].loaded);\n\n/**\n * Everything a locale switcher needs, reactive.\n *\n *   const { locale, locales, loading, setLocale } = useLocale();\n */\nexport function useLocale(): {\n  locale: string;\n  dir: 'ltr' | 'rtl';\n  locales: LocaleInfo[];\n  /** Code of a lazy pack being fetched, if any — show a spinner on it. */\n  loading: string | null;\n  setLocale: (code: string) => void;\n} {\n  const i18n = useCapability(I18nToken);\n  const locale = useSelector(I18nToken, (c) => c.locale());\n  const dir = useSelector(I18nToken, (c) => c.dir());\n  const loading = useSelector(I18nToken, (c) => c.loading());\n  const locales = useSelector(I18nToken, (c) => c.locales(), localeListEqual);\n  return { locale, dir, locales, loading, setLocale: i18n.setLocale };\n}\n"],"mappings":";;;;;;AAmBA,MAAa,gBAAgB,cAAc,SAAS;;;;;;;;;AAUpD,SAAgB,OAA4D;CAC1E,MAAM,OAAO,cAAc,SAAS;CAEpC,OAAO,eAAe,KAAK,YAAY,KAAK,EAAE,KAAK,OAAO,GAAG,CAAC,MADhD,gBAAgB,MAAM,EAAE,SAAS,CAAC,CAAC,QAAQ,OACe,CAAC,CAAC;AAC5E;AAEA,MAAM,mBAAmB,GAAiB,MACxC,EAAE,WAAW,EAAE,UACf,EAAE,OAAO,GAAG,MAAM,EAAE,SAAS,EAAE,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,EAAE,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,CAAC,MAAM;;;;;;AAO5F,SAAgB,YAOd;CACA,MAAM,OAAO,cAAc,SAAS;CACpC,MAAM,SAAS,YAAY,YAAY,MAAM,EAAE,OAAO,CAAC;CACvD,MAAM,MAAM,YAAY,YAAY,MAAM,EAAE,IAAI,CAAC;CACjD,MAAM,UAAU,YAAY,YAAY,MAAM,EAAE,QAAQ,CAAC;CAEzD,OAAO;EAAE;EAAQ;EAAK,SADN,YAAY,YAAY,MAAM,EAAE,QAAQ,GAAG,eAC/B;EAAG;EAAS,WAAW,KAAK;CAAU;AACpE"}
+{"version":3,"file":"i18n.js","names":[],"sources":["../src/i18n.ts"],"sourcesContent":["/**\n * The React surface for @embedpdf/plugin-i18n. The plugin is workspace-scoped\n * and needs no engine, so these hooks work from the first frame, before a\n * document opens: a loading screen and a password 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';\nimport { settingsHook, stateHook } from './state';\n\n/** The i18n capability: `t`, `setLocale`, `addTranslations`, `registerLocale`, the settings calls. */\nexport function useI18n(): I18nCapability {\n  return useCapability(I18nToken);\n}\n\n/** Subscribe to one i18n event for the mounted lifetime: `useI18nEvent((i18n) => i18n.onLocaleChanged, handler)`. */\nexport function useI18nEvent<T>(\n  select: (i18n: I18nCapability) => EventHook<T>,\n  handler: (event: T) => 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 the one loading (the\n * translations page's State table, declared once in `i18nState`). Takes a selector, and\n * re-renders only when what it returns changes.\n */\nexport const useI18nState = stateHook(i18nState);\n\n/** The i18n settings (`locale`, `fallbackLocale`, `locales`, `loaders`). Takes a selector. */\nexport const useI18nSettings = settingsHook(I18nToken);\n\n/**\n * A translate function that re-renders the component when the language or the strings change,\n * and keeps its identity otherwise, so memoized children holding it re-render too.\n *\n *   const t = useT();\n *   <span>{t('search.results', { params: { count } })}</span>\n */\nexport function useT(): (key: string, options?: TranslateOptions) => string {\n  return useSelector(I18nToken, (i18n) => i18n.getTranslator());\n}\n"],"mappings":";;;;;;AAeA,SAAgB,UAA0B;CACxC,OAAO,cAAc,SAAS;AAChC;;AAGA,SAAgB,aACd,QACA,SACM;CACN,mBAAmB,WAAW,QAAQ,OAAO;AAC/C;;;;;;AAOA,MAAa,eAAe,UAAU,SAAS;;AAG/C,MAAa,kBAAkB,aAAa,SAAS;;;;;;;;AASrD,SAAgB,OAA4D;CAC1E,OAAO,YAAY,YAAY,SAAS,KAAK,cAAc,CAAC;AAC9D"}