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

package/dist/actions.cjs

@@ -1,17 +1,34 @@
 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_web = require("@embedpdf/web");
+let react = require("react");
 let _embedpdf_plugin_stage_contract = require("@embedpdf/plugin-stage/contract");
 let _embedpdf_plugin_actions = require("@embedpdf/plugin-actions");
 //#region src/actions.tsx
 /**
+* The actions capability (executeNamed, execute, dispatch, the settings) of
+* the surrounding `<DocumentScope>`'s document, else the active one. Outside
+* a document, the settings calls work and every other method throws
+* `not-ready`.
+*/
+function useActions() {
+	return require_runtime.useCapability(_embedpdf_plugin_actions.ActionsToken);
+}
+/** The actions settings (`policy`, `triggers`, `openSequence`, `javascript`), with or without a document. Takes a selector. */
+const useActionsSettings = require_state.settingsHook(_embedpdf_plugin_actions.ActionsToken);
+/** Subscribe to one actions event for the mounted lifetime: `useActionsEvent((actions) => actions.onExecuted, handler)`. */
+function useActionsEvent(select, handler) {
+	require_runtime.useCapabilityEvent(_embedpdf_plugin_actions.ActionsToken, select, handler);
+}
+/**
 * Install the UI adapter for the active document's action dispatcher. The
-* DEFAULT policy — the origin×phase visibility matrix, sanitizeExternalUri
+* default policy — the origin×phase visibility matrix, sanitizeExternalUri
 * URI opens, browser print/alert fallbacks — is `@embedpdf/web`'s
-* `createDefaultActionsUiAdapter`, written ONCE for every binding; this
+* `createDefaultActionsUiAdapter`, written once for every binding; this
 * hook is React glue only (late-bound handlers, stage navigation,
-* identity-safe install/uninstall). The doc.print AUTHORITY gate is
+* identity-safe install/uninstall). The doc.print authority gate is
 * upstream (the actions plugin) and not overridable.
 */
 function useActionsUiAdapter(handlers) {
@@ -29,6 +46,9 @@ function useActionsUiAdapter(handlers) {
 	}, [actions, stage]);
 }
 //#endregion
+exports.useActions = useActions;
+exports.useActionsEvent = useActionsEvent;
+exports.useActionsSettings = useActionsSettings;
 exports.useActionsUiAdapter = useActionsUiAdapter;
 Object.keys(_embedpdf_plugin_actions).forEach(function(k) {
 	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {

package/dist/actions.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"actions.cjs","names":["useOptionalCapability","ActionsToken","StageToken"],"sources":["../src/actions.tsx"],"sourcesContent":["/**\n * The React view of @embedpdf/plugin-actions — the action engine's UI port.\n *\n * The plugin is DOM-free; opening tabs and printing are this layer's job.\n * `useActionsUiAdapter()` installs the browser-default adapter (the same\n * sanitizer + window.open the link layer uses; print = the browser dialog),\n * overridable per handler. Without it, `adapter`-routed actions (URI, Print)\n * report `no-adapter` diagnostics instead of executing.\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-actions';\nimport { useEffect, useRef } from 'react';\nimport { ActionsToken, type ActionUiAdapter } from '@embedpdf/plugin-actions';\nimport { StageToken } from '@embedpdf/plugin-stage/contract';\nimport { createDefaultActionsUiAdapter } from '@embedpdf/web';\n\nimport { useOptionalCapability } from './runtime';\n\n/** Override any subset of the default adapter policy. */\nexport type ActionsUiHandlers = Partial<ActionUiAdapter>;\n\n/**\n * Install the UI adapter for the active document's action dispatcher. The\n * DEFAULT policy — the origin×phase visibility matrix, sanitizeExternalUri\n * URI opens, browser print/alert fallbacks — is `@embedpdf/web`'s\n * `createDefaultActionsUiAdapter`, written ONCE for every binding; this\n * hook is React glue only (late-bound handlers, stage navigation,\n * identity-safe install/uninstall). The doc.print AUTHORITY gate is\n * upstream (the actions plugin) and not overridable.\n */\nexport function useActionsUiAdapter(handlers?: ActionsUiHandlers): void {\n  const actions = useOptionalCapability(ActionsToken);\n  const stage = useOptionalCapability(StageToken);\n  const handlersRef = useRef(handlers);\n  handlersRef.current = handlers;\n\n  useEffect(() => {\n    if (!actions) return;\n    const adapter: ActionUiAdapter = createDefaultActionsUiAdapter({\n      overrides: () => handlersRef.current,\n      goToPage: (page) => stage?.goToPage(page),\n    });\n    return actions.setUiAdapter(adapter);\n  }, [actions, stage]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA+BA,SAAgB,oBAAoB,UAAoC;CACtE,MAAM,UAAUA,gBAAAA,sBAAsBC,yBAAAA,YAAY;CAClD,MAAM,QAAQD,gBAAAA,sBAAsBE,gCAAAA,UAAU;CAC9C,MAAM,eAAA,GAAA,MAAA,OAAA,CAAqB,QAAQ;CACnC,YAAY,UAAU;CAEtB,CAAA,GAAA,MAAA,UAAA,OAAgB;EACd,IAAI,CAAC,SAAS;EACd,MAAM,WAAA,GAAA,cAAA,8BAAA,CAAyD;GAC7D,iBAAiB,YAAY;GAC7B,WAAW,SAAS,OAAO,SAAS,IAAI;EAC1C,CAAC;EACD,OAAO,QAAQ,aAAa,OAAO;CACrC,GAAG,CAAC,SAAS,KAAK,CAAC;AACrB"}
+{"version":3,"file":"actions.cjs","names":["useCapability","ActionsToken","settingsHook","useOptionalCapability","StageToken"],"sources":["../src/actions.tsx"],"sourcesContent":["/**\n * The React view of @embedpdf/plugin-actions — the action engine's UI port.\n *\n * The plugin is DOM-free; opening tabs and printing are this layer's job.\n * `useActionsUiAdapter()` installs the browser-default adapter (the same\n * sanitizer + window.open the link layer uses; print = the browser dialog),\n * overridable per handler. Without it, `adapter`-routed actions (URI, Print)\n * report `no-adapter` diagnostics instead of executing.\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-actions';\nimport { useEffect, useRef } from 'react';\nimport {\n  ActionsToken,\n  type ActionsCapability,\n  type ActionUiAdapter,\n} from '@embedpdf/plugin-actions';\nimport { StageToken } from '@embedpdf/plugin-stage/contract';\nimport type { EventHook } from '@embedpdf/core';\nimport { createDefaultActionsUiAdapter } from '@embedpdf/web';\n\nimport { useCapability, useCapabilityEvent, useOptionalCapability } from './runtime';\nimport { settingsHook } from './state';\n\n/**\n * The actions capability (executeNamed, execute, dispatch, the settings) of\n * the surrounding `<DocumentScope>`'s document, else the active one. Outside\n * a document, the settings calls work and every other method throws\n * `not-ready`.\n */\nexport function useActions(): ActionsCapability {\n  return useCapability(ActionsToken);\n}\n\n/** The actions settings (`policy`, `triggers`, `openSequence`, `javascript`), with or without a document. Takes a selector. */\nexport const useActionsSettings = settingsHook(ActionsToken);\n\n/** Subscribe to one actions event for the mounted lifetime: `useActionsEvent((actions) => actions.onExecuted, handler)`. */\nexport function useActionsEvent<T>(\n  select: (actions: ActionsCapability) => EventHook<T>,\n  handler: (event: T) => void,\n): void {\n  useCapabilityEvent(ActionsToken, select, handler);\n}\n\n/** Override any subset of the default adapter policy. */\nexport type ActionsUiHandlers = Partial<ActionUiAdapter>;\n\n/**\n * Install the UI adapter for the active document's action dispatcher. The\n * default policy — the origin×phase visibility matrix, sanitizeExternalUri\n * URI opens, browser print/alert fallbacks — is `@embedpdf/web`'s\n * `createDefaultActionsUiAdapter`, written once for every binding; this\n * hook is React glue only (late-bound handlers, stage navigation,\n * identity-safe install/uninstall). The doc.print authority gate is\n * upstream (the actions plugin) and not overridable.\n */\nexport function useActionsUiAdapter(handlers?: ActionsUiHandlers): void {\n  const actions = useOptionalCapability(ActionsToken);\n  const stage = useOptionalCapability(StageToken);\n  const handlersRef = useRef(handlers);\n  handlersRef.current = handlers;\n\n  useEffect(() => {\n    if (!actions) return;\n    const adapter: ActionUiAdapter = createDefaultActionsUiAdapter({\n      overrides: () => handlersRef.current,\n      goToPage: (page) => stage?.goToPage(page),\n    });\n    return actions.setUiAdapter(adapter);\n  }, [actions, stage]);\n}\n"],"mappings":";;;;;;;;;;;;;;;AA+BA,SAAgB,aAAgC;CAC9C,OAAOA,gBAAAA,cAAcC,yBAAAA,YAAY;AACnC;;AAGA,MAAa,qBAAqBC,cAAAA,aAAaD,yBAAAA,YAAY;;AAG3D,SAAgB,gBACd,QACA,SACM;CACN,gBAAA,mBAAmBA,yBAAAA,cAAc,QAAQ,OAAO;AAClD;;;;;;;;;;AAcA,SAAgB,oBAAoB,UAAoC;CACtE,MAAM,UAAUE,gBAAAA,sBAAsBF,yBAAAA,YAAY;CAClD,MAAM,QAAQE,gBAAAA,sBAAsBC,gCAAAA,UAAU;CAC9C,MAAM,eAAA,GAAA,MAAA,OAAA,CAAqB,QAAQ;CACnC,YAAY,UAAU;CAEtB,CAAA,GAAA,MAAA,UAAA,OAAgB;EACd,IAAI,CAAC,SAAS;EACd,MAAM,WAAA,GAAA,cAAA,8BAAA,CAAyD;GAC7D,iBAAiB,YAAY;GAC7B,WAAW,SAAS,OAAO,SAAS,IAAI;EAC1C,CAAC;EACD,OAAO,QAAQ,aAAa,OAAO;CACrC,GAAG,CAAC,SAAS,KAAK,CAAC;AACrB"}

package/dist/actions.d.cts

@@ -1,18 +1,31 @@
-import { ActionUiAdapter } from "@embedpdf/plugin-actions";
+import { t as SettingsHook } from "./state-0K1I5cM4.cjs";
+import { EventHook } from "@embedpdf/core";
+import { ActionUiAdapter, ActionsCapability } from "@embedpdf/plugin-actions";
 export * from "@embedpdf/plugin-actions";
 //#region src/actions.d.ts
+/**
+ * The actions capability (executeNamed, execute, dispatch, the settings) of
+ * the surrounding `<DocumentScope>`'s document, else the active one. Outside
+ * a document, the settings calls work and every other method throws
+ * `not-ready`.
+ */
+declare function useActions(): ActionsCapability;
+/** The actions settings (`policy`, `triggers`, `openSequence`, `javascript`), with or without a document. Takes a selector. */
+declare const useActionsSettings: SettingsHook<import("@embedpdf/plugin-actions").ActionsSettings>;
+/** Subscribe to one actions event for the mounted lifetime: `useActionsEvent((actions) => actions.onExecuted, handler)`. */
+declare function useActionsEvent<T>(select: (actions: ActionsCapability) => EventHook<T>, handler: (event: T) => void): void;
 /** Override any subset of the default adapter policy. */
 type ActionsUiHandlers = Partial<ActionUiAdapter>;
 /**
  * Install the UI adapter for the active document's action dispatcher. The
- * DEFAULT policy — the origin×phase visibility matrix, sanitizeExternalUri
+ * default policy — the origin×phase visibility matrix, sanitizeExternalUri
  * URI opens, browser print/alert fallbacks — is `@embedpdf/web`'s
- * `createDefaultActionsUiAdapter`, written ONCE for every binding; this
+ * `createDefaultActionsUiAdapter`, written once for every binding; this
  * hook is React glue only (late-bound handlers, stage navigation,
- * identity-safe install/uninstall). The doc.print AUTHORITY gate is
+ * identity-safe install/uninstall). The doc.print authority gate is
  * upstream (the actions plugin) and not overridable.
  */
 declare function useActionsUiAdapter(handlers?: ActionsUiHandlers): void;
 //#endregion
-export { ActionsUiHandlers, useActionsUiAdapter };
+export { ActionsUiHandlers, useActions, useActionsEvent, useActionsSettings, useActionsUiAdapter };
 //# sourceMappingURL=actions.d.cts.map

package/dist/actions.d.ts

@@ -1,18 +1,31 @@
-import { ActionUiAdapter } from "@embedpdf/plugin-actions";
+import { t as SettingsHook } from "./state-0K1I5cM4.js";
+import { EventHook } from "@embedpdf/core";
+import { ActionUiAdapter, ActionsCapability } from "@embedpdf/plugin-actions";
 export * from "@embedpdf/plugin-actions";
 //#region src/actions.d.ts
+/**
+ * The actions capability (executeNamed, execute, dispatch, the settings) of
+ * the surrounding `<DocumentScope>`'s document, else the active one. Outside
+ * a document, the settings calls work and every other method throws
+ * `not-ready`.
+ */
+declare function useActions(): ActionsCapability;
+/** The actions settings (`policy`, `triggers`, `openSequence`, `javascript`), with or without a document. Takes a selector. */
+declare const useActionsSettings: SettingsHook<import("@embedpdf/plugin-actions").ActionsSettings>;
+/** Subscribe to one actions event for the mounted lifetime: `useActionsEvent((actions) => actions.onExecuted, handler)`. */
+declare function useActionsEvent<T>(select: (actions: ActionsCapability) => EventHook<T>, handler: (event: T) => void): void;
 /** Override any subset of the default adapter policy. */
 type ActionsUiHandlers = Partial<ActionUiAdapter>;
 /**
  * Install the UI adapter for the active document's action dispatcher. The
- * DEFAULT policy — the origin×phase visibility matrix, sanitizeExternalUri
+ * default policy — the origin×phase visibility matrix, sanitizeExternalUri
  * URI opens, browser print/alert fallbacks — is `@embedpdf/web`'s
- * `createDefaultActionsUiAdapter`, written ONCE for every binding; this
+ * `createDefaultActionsUiAdapter`, written once for every binding; this
  * hook is React glue only (late-bound handlers, stage navigation,
- * identity-safe install/uninstall). The doc.print AUTHORITY gate is
+ * identity-safe install/uninstall). The doc.print authority gate is
  * upstream (the actions plugin) and not overridable.
  */
 declare function useActionsUiAdapter(handlers?: ActionsUiHandlers): void;
 //#endregion
-export { ActionsUiHandlers, useActionsUiAdapter };
+export { ActionsUiHandlers, useActions, useActionsEvent, useActionsSettings, useActionsUiAdapter };
 //# sourceMappingURL=actions.d.ts.map

package/dist/actions.js

@@ -1,17 +1,33 @@
-import { useOptionalCapability } from "./runtime.js";
-import { useEffect, useRef } from "react";
+import { S as useOptionalCapability, f as useCapability, p as useCapabilityEvent } from "./runtime-B6xcPsEb.js";
+import { t as settingsHook } from "./state-CbgxhwLA.js";
 import { createDefaultActionsUiAdapter } from "@embedpdf/web";
+import { useEffect, useRef } from "react";
 import { StageToken } from "@embedpdf/plugin-stage/contract";
 import { ActionsToken } from "@embedpdf/plugin-actions";
 export * from "@embedpdf/plugin-actions";
 //#region src/actions.tsx
 /**
+* The actions capability (executeNamed, execute, dispatch, the settings) of
+* the surrounding `<DocumentScope>`'s document, else the active one. Outside
+* a document, the settings calls work and every other method throws
+* `not-ready`.
+*/
+function useActions() {
+	return useCapability(ActionsToken);
+}
+/** The actions settings (`policy`, `triggers`, `openSequence`, `javascript`), with or without a document. Takes a selector. */
+const useActionsSettings = settingsHook(ActionsToken);
+/** Subscribe to one actions event for the mounted lifetime: `useActionsEvent((actions) => actions.onExecuted, handler)`. */
+function useActionsEvent(select, handler) {
+	useCapabilityEvent(ActionsToken, select, handler);
+}
+/**
 * Install the UI adapter for the active document's action dispatcher. The
-* DEFAULT policy — the origin×phase visibility matrix, sanitizeExternalUri
+* default policy — the origin×phase visibility matrix, sanitizeExternalUri
 * URI opens, browser print/alert fallbacks — is `@embedpdf/web`'s
-* `createDefaultActionsUiAdapter`, written ONCE for every binding; this
+* `createDefaultActionsUiAdapter`, written once for every binding; this
 * hook is React glue only (late-bound handlers, stage navigation,
-* identity-safe install/uninstall). The doc.print AUTHORITY gate is
+* identity-safe install/uninstall). The doc.print authority gate is
 * upstream (the actions plugin) and not overridable.
 */
 function useActionsUiAdapter(handlers) {
@@ -29,6 +45,6 @@ function useActionsUiAdapter(handlers) {
 	}, [actions, stage]);
 }
 //#endregion
-export { useActionsUiAdapter };
+export { useActions, useActionsEvent, useActionsSettings, useActionsUiAdapter };
 
 //# sourceMappingURL=actions.js.map

package/dist/actions.js.map

@@ -1 +1 @@
-{"version":3,"file":"actions.js","names":[],"sources":["../src/actions.tsx"],"sourcesContent":["/**\n * The React view of @embedpdf/plugin-actions — the action engine's UI port.\n *\n * The plugin is DOM-free; opening tabs and printing are this layer's job.\n * `useActionsUiAdapter()` installs the browser-default adapter (the same\n * sanitizer + window.open the link layer uses; print = the browser dialog),\n * overridable per handler. Without it, `adapter`-routed actions (URI, Print)\n * report `no-adapter` diagnostics instead of executing.\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-actions';\nimport { useEffect, useRef } from 'react';\nimport { ActionsToken, type ActionUiAdapter } from '@embedpdf/plugin-actions';\nimport { StageToken } from '@embedpdf/plugin-stage/contract';\nimport { createDefaultActionsUiAdapter } from '@embedpdf/web';\n\nimport { useOptionalCapability } from './runtime';\n\n/** Override any subset of the default adapter policy. */\nexport type ActionsUiHandlers = Partial<ActionUiAdapter>;\n\n/**\n * Install the UI adapter for the active document's action dispatcher. The\n * DEFAULT policy — the origin×phase visibility matrix, sanitizeExternalUri\n * URI opens, browser print/alert fallbacks — is `@embedpdf/web`'s\n * `createDefaultActionsUiAdapter`, written ONCE for every binding; this\n * hook is React glue only (late-bound handlers, stage navigation,\n * identity-safe install/uninstall). The doc.print AUTHORITY gate is\n * upstream (the actions plugin) and not overridable.\n */\nexport function useActionsUiAdapter(handlers?: ActionsUiHandlers): void {\n  const actions = useOptionalCapability(ActionsToken);\n  const stage = useOptionalCapability(StageToken);\n  const handlersRef = useRef(handlers);\n  handlersRef.current = handlers;\n\n  useEffect(() => {\n    if (!actions) return;\n    const adapter: ActionUiAdapter = createDefaultActionsUiAdapter({\n      overrides: () => handlersRef.current,\n      goToPage: (page) => stage?.goToPage(page),\n    });\n    return actions.setUiAdapter(adapter);\n  }, [actions, stage]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA+BA,SAAgB,oBAAoB,UAAoC;CACtE,MAAM,UAAU,sBAAsB,YAAY;CAClD,MAAM,QAAQ,sBAAsB,UAAU;CAC9C,MAAM,cAAc,OAAO,QAAQ;CACnC,YAAY,UAAU;CAEtB,gBAAgB;EACd,IAAI,CAAC,SAAS;EACd,MAAM,UAA2B,8BAA8B;GAC7D,iBAAiB,YAAY;GAC7B,WAAW,SAAS,OAAO,SAAS,IAAI;EAC1C,CAAC;EACD,OAAO,QAAQ,aAAa,OAAO;CACrC,GAAG,CAAC,SAAS,KAAK,CAAC;AACrB"}
+{"version":3,"file":"actions.js","names":[],"sources":["../src/actions.tsx"],"sourcesContent":["/**\n * The React view of @embedpdf/plugin-actions — the action engine's UI port.\n *\n * The plugin is DOM-free; opening tabs and printing are this layer's job.\n * `useActionsUiAdapter()` installs the browser-default adapter (the same\n * sanitizer + window.open the link layer uses; print = the browser dialog),\n * overridable per handler. Without it, `adapter`-routed actions (URI, Print)\n * report `no-adapter` diagnostics instead of executing.\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-actions';\nimport { useEffect, useRef } from 'react';\nimport {\n  ActionsToken,\n  type ActionsCapability,\n  type ActionUiAdapter,\n} from '@embedpdf/plugin-actions';\nimport { StageToken } from '@embedpdf/plugin-stage/contract';\nimport type { EventHook } from '@embedpdf/core';\nimport { createDefaultActionsUiAdapter } from '@embedpdf/web';\n\nimport { useCapability, useCapabilityEvent, useOptionalCapability } from './runtime';\nimport { settingsHook } from './state';\n\n/**\n * The actions capability (executeNamed, execute, dispatch, the settings) of\n * the surrounding `<DocumentScope>`'s document, else the active one. Outside\n * a document, the settings calls work and every other method throws\n * `not-ready`.\n */\nexport function useActions(): ActionsCapability {\n  return useCapability(ActionsToken);\n}\n\n/** The actions settings (`policy`, `triggers`, `openSequence`, `javascript`), with or without a document. Takes a selector. */\nexport const useActionsSettings = settingsHook(ActionsToken);\n\n/** Subscribe to one actions event for the mounted lifetime: `useActionsEvent((actions) => actions.onExecuted, handler)`. */\nexport function useActionsEvent<T>(\n  select: (actions: ActionsCapability) => EventHook<T>,\n  handler: (event: T) => void,\n): void {\n  useCapabilityEvent(ActionsToken, select, handler);\n}\n\n/** Override any subset of the default adapter policy. */\nexport type ActionsUiHandlers = Partial<ActionUiAdapter>;\n\n/**\n * Install the UI adapter for the active document's action dispatcher. The\n * default policy — the origin×phase visibility matrix, sanitizeExternalUri\n * URI opens, browser print/alert fallbacks — is `@embedpdf/web`'s\n * `createDefaultActionsUiAdapter`, written once for every binding; this\n * hook is React glue only (late-bound handlers, stage navigation,\n * identity-safe install/uninstall). The doc.print authority gate is\n * upstream (the actions plugin) and not overridable.\n */\nexport function useActionsUiAdapter(handlers?: ActionsUiHandlers): void {\n  const actions = useOptionalCapability(ActionsToken);\n  const stage = useOptionalCapability(StageToken);\n  const handlersRef = useRef(handlers);\n  handlersRef.current = handlers;\n\n  useEffect(() => {\n    if (!actions) return;\n    const adapter: ActionUiAdapter = createDefaultActionsUiAdapter({\n      overrides: () => handlersRef.current,\n      goToPage: (page) => stage?.goToPage(page),\n    });\n    return actions.setUiAdapter(adapter);\n  }, [actions, stage]);\n}\n"],"mappings":";;;;;;;;;;;;;;AA+BA,SAAgB,aAAgC;CAC9C,OAAO,cAAc,YAAY;AACnC;;AAGA,MAAa,qBAAqB,aAAa,YAAY;;AAG3D,SAAgB,gBACd,QACA,SACM;CACN,mBAAmB,cAAc,QAAQ,OAAO;AAClD;;;;;;;;;;AAcA,SAAgB,oBAAoB,UAAoC;CACtE,MAAM,UAAU,sBAAsB,YAAY;CAClD,MAAM,QAAQ,sBAAsB,UAAU;CAC9C,MAAM,cAAc,OAAO,QAAQ;CACnC,YAAY,UAAU;CAEtB,gBAAgB;EACd,IAAI,CAAC,SAAS;EACd,MAAM,UAA2B,8BAA8B;GAC7D,iBAAiB,YAAY;GAC7B,WAAW,SAAS,OAAO,SAAS,IAAI;EAC1C,CAAC;EACD,OAAO,QAAQ,aAAa,OAAO;CACrC,GAAG,CAAC,SAAS,KAAK,CAAC;AACrB"}

package/dist/anchored-DeX95xSd.d.ts

@@ -0,0 +1,85 @@
+import { AnchorTarget, AnchorTarget as AnchorTarget$1, AnchoredPlacement, AnchoredPlacement as AnchoredPlacement$1, AnchoredRect, AnchoredSide, PageViewEnv, ViewProjector, ViewProjector as ViewProjector$1 } from "@embedpdf/web";
+import * as React$1 from "react";
+//#region src/anchored.d.ts
+/**
+ * What a page surface provides via context: the pure projection snapshot,
+ * bound to React's reactivity.
+ */
+interface ProjectorBinding {
+  projector: ViewProjector;
+  /**
+   * Changes identity exactly when projection may have changed for
+   * state-driven reasons — the Stage uses its `visiblePages()` value (a
+   * stable reference that already folds camera, viewport, scene and DPR).
+   * Consumers re-render because the binding's identity changes with it;
+   * nothing reads this field, but it is what makes the memoized binding
+   * change, so do not "optimize" it away.
+   */
+  revision: unknown;
+  /** Browser-driven invalidation only (PageView scroll/resize — see
+   *  `observeClientGeometry`). The Stage deliberately provides none. */
+  subscribe?: (callback: () => void) => () => void;
+}
+/** Installed by page surfaces (<Stage>, <PageView>) — not by app code. */
+declare const ProjectorProvider: React$1.Provider<ProjectorBinding | null>;
+/**
+ * The pages a surface shows right now, by object number. It is a value of its
+ * own, next to the projection, because it changes only when a page comes on
+ * screen or leaves it: anchored UI on other pages reads only this, so it
+ * isn't rendered again on every camera frame.
+ */
+type ShownPages = ReadonlySet<number>;
+/** Installed by page surfaces (<Stage>, <PageView>) — not by app code. */
+declare const ShownPagesProvider: React$1.Provider<ShownPages | null>;
+/** The surface's projector binding, or null outside any page surface — for
+ *  chrome that degrades (and warns) instead of throwing. */
+declare function useOptionalProjectorBinding(): ProjectorBinding | null;
+/** The surface's projector binding. Reading it subscribes the caller to
+ *  projection changes (the binding's identity is the revision). */
+declare function useProjectorBinding(): ProjectorBinding;
+interface AnchoredProps {
+  /**
+   * The box on a page to sit next to, in page coordinates: `{ page, bounds }`,
+   * with `avoid` points to keep clear of. `null`, or a target without
+   * `bounds` (a search match with no geometry), hides it.
+   */
+  anchor: (Omit<AnchorTarget, 'bounds'> & {
+    bounds?: AnchoredRect;
+  }) | null;
+  /**
+   * Where to sit: a side of the box, centred, or lined up with the side's
+   * start or end (`'top-end'`). Default 'top'.
+   */
+  placement?: AnchoredPlacement;
+  /**
+   * Gap in screen px between the box and the content, and between the content
+   * and the view's edge. Negative overlaps the box. Default 8.
+   */
+  gap?: number;
+  /**
+   * Stay where `placement` puts it: never flip to the other side, never move
+   * to stay in view, and scroll away with the box. For badges and status;
+   * menus leave it off. Default false.
+   */
+  pinned?: boolean;
+  children: React$1.ReactNode;
+}
+/**
+ * Position `children` around a page-space anchor, on whichever page surface
+ * is in scope. Projection runs during render from the shared pure helper.
+ * Once the content's size is measured, it flips to the opposite side when
+ * the chosen one has no room, and stays inside the view, unless `pinned`.
+ * Its wrapper's `data-placement` is where it sits now: `placement`, or the
+ * opposite side after a flip, so what opens from the content can open away
+ * from the box.
+ * Pointer isolation keeps a click inside anchored UI from reaching the
+ * surface's own listener (which would read it as a click outside).
+ *
+ * Anchored UI on a page that isn't shown renders nothing and reads only the
+ * pages on screen, so a document with hundreds of badges costs only the ones
+ * in view while people scroll and zoom.
+ */
+declare function Anchored(props: AnchoredProps): import("react/jsx-runtime").JSX.Element | null;
+//#endregion
+export { AnchoredSide as a, ProjectorProvider as c, ViewProjector$1 as d, useOptionalProjectorBinding as f, AnchoredProps as i, ShownPages as l, Anchored as n, PageViewEnv as o, useProjectorBinding as p, AnchoredPlacement$1 as r, ProjectorBinding as s, AnchorTarget$1 as t, ShownPagesProvider as u };
+//# sourceMappingURL=anchored-DeX95xSd.d.ts.map

package/dist/anchored-DzN3JywS.d.cts

@@ -0,0 +1,85 @@
+import * as React from "react";
+import { AnchorTarget, AnchorTarget as AnchorTarget$1, AnchoredPlacement, AnchoredPlacement as AnchoredPlacement$1, AnchoredRect, AnchoredSide, PageViewEnv, ViewProjector, ViewProjector as ViewProjector$1 } from "@embedpdf/web";
+//#region src/anchored.d.ts
+/**
+ * What a page surface provides via context: the pure projection snapshot,
+ * bound to React's reactivity.
+ */
+interface ProjectorBinding {
+  projector: ViewProjector;
+  /**
+   * Changes identity exactly when projection may have changed for
+   * state-driven reasons — the Stage uses its `visiblePages()` value (a
+   * stable reference that already folds camera, viewport, scene and DPR).
+   * Consumers re-render because the binding's identity changes with it;
+   * nothing reads this field, but it is what makes the memoized binding
+   * change, so do not "optimize" it away.
+   */
+  revision: unknown;
+  /** Browser-driven invalidation only (PageView scroll/resize — see
+   *  `observeClientGeometry`). The Stage deliberately provides none. */
+  subscribe?: (callback: () => void) => () => void;
+}
+/** Installed by page surfaces (<Stage>, <PageView>) — not by app code. */
+declare const ProjectorProvider: React.Provider<ProjectorBinding | null>;
+/**
+ * The pages a surface shows right now, by object number. It is a value of its
+ * own, next to the projection, because it changes only when a page comes on
+ * screen or leaves it: anchored UI on other pages reads only this, so it
+ * isn't rendered again on every camera frame.
+ */
+type ShownPages = ReadonlySet<number>;
+/** Installed by page surfaces (<Stage>, <PageView>) — not by app code. */
+declare const ShownPagesProvider: React.Provider<ShownPages | null>;
+/** The surface's projector binding, or null outside any page surface — for
+ *  chrome that degrades (and warns) instead of throwing. */
+declare function useOptionalProjectorBinding(): ProjectorBinding | null;
+/** The surface's projector binding. Reading it subscribes the caller to
+ *  projection changes (the binding's identity is the revision). */
+declare function useProjectorBinding(): ProjectorBinding;
+interface AnchoredProps {
+  /**
+   * The box on a page to sit next to, in page coordinates: `{ page, bounds }`,
+   * with `avoid` points to keep clear of. `null`, or a target without
+   * `bounds` (a search match with no geometry), hides it.
+   */
+  anchor: (Omit<AnchorTarget, 'bounds'> & {
+    bounds?: AnchoredRect;
+  }) | null;
+  /**
+   * Where to sit: a side of the box, centred, or lined up with the side's
+   * start or end (`'top-end'`). Default 'top'.
+   */
+  placement?: AnchoredPlacement;
+  /**
+   * Gap in screen px between the box and the content, and between the content
+   * and the view's edge. Negative overlaps the box. Default 8.
+   */
+  gap?: number;
+  /**
+   * Stay where `placement` puts it: never flip to the other side, never move
+   * to stay in view, and scroll away with the box. For badges and status;
+   * menus leave it off. Default false.
+   */
+  pinned?: boolean;
+  children: React.ReactNode;
+}
+/**
+ * Position `children` around a page-space anchor, on whichever page surface
+ * is in scope. Projection runs during render from the shared pure helper.
+ * Once the content's size is measured, it flips to the opposite side when
+ * the chosen one has no room, and stays inside the view, unless `pinned`.
+ * Its wrapper's `data-placement` is where it sits now: `placement`, or the
+ * opposite side after a flip, so what opens from the content can open away
+ * from the box.
+ * Pointer isolation keeps a click inside anchored UI from reaching the
+ * surface's own listener (which would read it as a click outside).
+ *
+ * Anchored UI on a page that isn't shown renders nothing and reads only the
+ * pages on screen, so a document with hundreds of badges costs only the ones
+ * in view while people scroll and zoom.
+ */
+declare function Anchored(props: AnchoredProps): import("react/jsx-runtime").JSX.Element | null;
+//#endregion
+export { AnchoredSide as a, ProjectorProvider as c, ViewProjector$1 as d, useOptionalProjectorBinding as f, AnchoredProps as i, ShownPages as l, Anchored as n, PageViewEnv as o, useProjectorBinding as p, AnchoredPlacement$1 as r, ProjectorBinding as s, AnchorTarget$1 as t, ShownPagesProvider as u };
+//# sourceMappingURL=anchored-DzN3JywS.d.cts.map

package/dist/anchored.cjs

@@ -1,75 +1,116 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("./rolldown-runtime-DDXJien1.cjs");
 let react_jsx_runtime = require("react/jsx-runtime");
+let _embedpdf_web = require("@embedpdf/web");
 let react = require("react");
 react = require_rolldown_runtime.__toESM(react, 1);
 let react_dom = require("react-dom");
-let _embedpdf_web = require("@embedpdf/web");
 //#region src/anchored.tsx
 /**
-* Anchored overlays — ONE primitive for every piece of UI that floats over
+* Anchored overlays — one primitive for every piece of UI that floats over
 * page content (selection menus, draft menus, future popovers).
 *
 * The factoring:
-*   - PLUGINS produce anchors (a content-space rect on a page, plus points
+*   - plugins produce anchors (a page-space rect on a page, plus points
 *     to dodge) as capability reads.
-*   - The projection SNAPSHOT contract and the placement math are shared,
+*   - The projection snapshot contract and the placement math are shared,
 *     framework-neutral, in `@embedpdf/web` ({@link ViewProjector},
 *     `projectAnchoredTarget`).
-*   - SURFACES (<Stage>, <PageView>) provide a {@link ProjectorBinding}:
-*     the snapshot plus REACT's way of knowing when it changed.
-*   - <Anchored> renders at the projected position, isolates pointer
-*     events, and portals when the space demands it.
+*   - surfaces (<Stage>, <PageView>) provide a {@link ProjectorBinding}:
+*     the snapshot plus react's way of knowing when it changed.
+*   - <Anchored> renders at the projected position, flips to the other
+*     side and stays inside the view once it knows its size (unless
+*     pinned), says where it sits in `data-placement`, isolates pointer
+*     events, and portals when the space demands it. On a page that isn't
+*     shown it renders nothing and doesn't follow the camera at all (see
+*     {@link ShownPages}).
 *
-* THE SCHEDULING LAW (this is what keeps menus glued to the content): a
+* The scheduling law (this is what keeps menus glued to the content): a
 * state-driven projection change (the Stage camera) reaches consumers as a
-* NEW BINDING IDENTITY through context — surface and overlay re-render in
-* the SAME React commit, so they can never paint a frame apart. No
+* new binding identity through context — surface and overlay re-render in
+* the same React commit, so they can never paint a frame apart. No
 * listener sets, no post-commit notifications, no second menu-only render.
-* `subscribe` exists ONLY for genuinely browser-driven invalidation (a
+* `subscribe` exists only for genuinely browser-driven invalidation (a
 * PageView moving because the document scrolled), where no state change
 * announces the move.
 */
 const ProjectorContext = (0, react.createContext)(null);
 /** Installed by page surfaces (<Stage>, <PageView>) — not by app code. */
 const ProjectorProvider = ProjectorContext.Provider;
+const ShownPagesContext = (0, react.createContext)(null);
+/** Installed by page surfaces (<Stage>, <PageView>) — not by app code. */
+const ShownPagesProvider = ShownPagesContext.Provider;
+/** The surface's projector binding, or null outside any page surface — for
+*  chrome that degrades (and warns) instead of throwing. */
+function useOptionalProjectorBinding() {
+	return (0, react.useContext)(ProjectorContext);
+}
 /** The surface's projector binding. Reading it subscribes the caller to
-*  projection changes (the binding's identity IS the revision). */
+*  projection changes (the binding's identity is the revision). */
 function useProjectorBinding() {
 	const binding = (0, react.useContext)(ProjectorContext);
 	if (!binding) throw new Error("No ViewProjector in scope: mount anchored UI under <Stage> (overlay slot) or <PageView>.");
 	return binding;
 }
 /**
-* Position `children` around a content-space anchor, on whichever page
-* surface is in scope. Projection runs during render from the shared pure
-* helper; pointer isolation keeps a click inside anchored UI from reaching
-* the surface's own listener (which would read it as click-outside).
+* Position `children` around a page-space anchor, on whichever page surface
+* is in scope. Projection runs during render from the shared pure helper.
+* Once the content's size is measured, it flips to the opposite side when
+* the chosen one has no room, and stays inside the view, unless `pinned`.
+* Its wrapper's `data-placement` is where it sits now: `placement`, or the
+* opposite side after a flip, so what opens from the content can open away
+* from the box.
+* Pointer isolation keeps a click inside anchored UI from reaching the
+* surface's own listener (which would read it as a click outside).
+*
+* Anchored UI on a page that isn't shown renders nothing and reads only the
+* pages on screen, so a document with hundreds of badges costs only the ones
+* in view while people scroll and zoom.
 */
-function Anchored({ anchor, placement = "top", gap = 8, children }) {
+function Anchored(props) {
+	const shown = (0, react.useContext)(ShownPagesContext);
+	if (!props.anchor?.bounds) return null;
+	if (shown && !shown.has(props.anchor.page.objectNumber)) return null;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(PlacedAnchored, { ...props });
+}
+/** Anchored UI on a page that is shown: it follows the camera. */
+function PlacedAnchored({ anchor, placement = "top", gap = 8, pinned = false, children }) {
 	const { projector, subscribe } = useProjectorBinding();
+	const [element, setElement] = (0, react.useState)(null);
+	const [fit, setFit] = (0, react.useState)(null);
 	const [, force] = (0, react.useReducer)((x) => x + 1, 0);
 	(0, react.useLayoutEffect)(() => subscribe ? subscribe(force) : void 0, [subscribe]);
 	(0, react.useLayoutEffect)(() => {
 		if (projector.space === "client") force();
 	}, [projector, anchor]);
-	const ref = (0, react.useRef)(null);
+	(0, react.useLayoutEffect)(() => {
+		if (!element) return;
+		return (0, _embedpdf_web.observeAnchoredFit)(element, projector.space, (next) => setFit((current) => (0, _embedpdf_web.sameAnchoredFit)(current, next) ? current : next));
+	}, [element, projector.space]);
 	(0, react.useEffect)(() => {
-		const el = ref.current;
-		if (!el) return;
-		const stop = (e) => e.stopPropagation();
-		el.addEventListener("pointerdown", stop);
-		return () => el.removeEventListener("pointerdown", stop);
-	});
-	if (!anchor) return null;
-	const pos = (0, _embedpdf_web.projectAnchoredTarget)(projector, anchor, placement, gap);
+		if (!element) return;
+		const stop = (event) => event.stopPropagation();
+		element.addEventListener("pointerdown", stop);
+		return () => element.removeEventListener("pointerdown", stop);
+	}, [element]);
+	if (!anchor?.bounds) return null;
+	const pos = (0, _embedpdf_web.projectAnchoredTarget)(projector, {
+		...anchor,
+		bounds: anchor.bounds
+	}, {
+		placement,
+		gap,
+		pinned
+	}, fit);
 	if (!pos) return null;
 	const node = /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-		ref,
+		ref: setElement,
+		"data-placement": pos.placement,
 		style: {
 			position: projector.space === "client" ? "fixed" : "absolute",
 			left: pos.left,
 			top: pos.top,
+			width: "max-content",
 			transform: pos.transform,
 			pointerEvents: "auto"
 		},
@@ -84,6 +125,8 @@ function Anchored({ anchor, placement = "top", gap = 8, children }) {
 //#endregion
 exports.Anchored = Anchored;
 exports.ProjectorProvider = ProjectorProvider;
+exports.ShownPagesProvider = ShownPagesProvider;
+exports.useOptionalProjectorBinding = useOptionalProjectorBinding;
 exports.useProjectorBinding = useProjectorBinding;
 
 //# sourceMappingURL=anchored.cjs.map

package/dist/anchored.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"anchored.cjs","names":[],"sources":["../src/anchored.tsx"],"sourcesContent":["/**\n * Anchored overlays — ONE primitive for every piece of UI that floats over\n * page content (selection menus, draft menus, future popovers).\n *\n * The factoring:\n *   - PLUGINS produce anchors (a content-space rect on a page, plus points\n *     to dodge) as capability reads.\n *   - The projection SNAPSHOT contract and the placement math are shared,\n *     framework-neutral, in `@embedpdf/web` ({@link ViewProjector},\n *     `projectAnchoredTarget`).\n *   - SURFACES (<Stage>, <PageView>) provide a {@link ProjectorBinding}:\n *     the snapshot plus REACT's way of knowing when it changed.\n *   - <Anchored> renders at the projected position, isolates pointer\n *     events, and portals when the space demands it.\n *\n * THE SCHEDULING LAW (this is what keeps menus glued to the content): a\n * state-driven projection change (the Stage camera) reaches consumers as a\n * NEW BINDING IDENTITY through context — surface and overlay re-render in\n * the SAME React commit, so they can never paint a frame apart. No\n * listener sets, no post-commit notifications, no second menu-only render.\n * `subscribe` exists ONLY for genuinely browser-driven invalidation (a\n * PageView moving because the document scrolled), where no state change\n * announces the move.\n */\nimport * as React from 'react';\nimport { createContext, useContext, useEffect, useLayoutEffect, useReducer, useRef } from 'react';\nimport { createPortal } from 'react-dom';\nimport {\n  projectAnchoredTarget,\n  type AnchoredPlacement,\n  type AnchorTarget,\n  type ViewProjector,\n} from '@embedpdf/web';\n\nexport type { AnchoredPlacement, AnchorTarget, ViewProjector } from '@embedpdf/web';\n\n/**\n * What a page surface provides via context: the pure projection snapshot,\n * bound to React's reactivity.\n */\nexport interface ProjectorBinding {\n  projector: ViewProjector;\n  /**\n   * Changes identity exactly when projection may have changed for\n   * STATE-driven reasons — the Stage uses its `visiblePages()` value (a\n   * stable reference that already folds camera, viewport, scene and DPR).\n   * Consumers re-render because the binding's identity changes with it;\n   * nothing reads this field, but it is what makes the memoized binding\n   * change, so do not \"optimize\" it away.\n   */\n  revision: unknown;\n  /** Browser-driven invalidation ONLY (PageView scroll/resize — see\n   *  `observeClientGeometry`). The Stage deliberately provides none. */\n  subscribe?: (callback: () => void) => () => void;\n}\n\nconst ProjectorContext = createContext<ProjectorBinding | null>(null);\n\n/** Installed by page surfaces (<Stage>, <PageView>) — not by app code. */\nexport const ProjectorProvider = ProjectorContext.Provider;\n\n/** The surface's projector binding. Reading it subscribes the caller to\n *  projection changes (the binding's identity IS the revision). */\nexport function useProjectorBinding(): ProjectorBinding {\n  const binding = useContext(ProjectorContext);\n  if (!binding) {\n    throw new Error(\n      'No ViewProjector in scope: mount anchored UI under <Stage> (overlay slot) or <PageView>.',\n    );\n  }\n  return binding;\n}\n\nexport interface AnchoredProps {\n  anchor: AnchorTarget | null;\n  /** Which side of the anchor to sit on. Default 'top'. */\n  placement?: AnchoredPlacement;\n  /** Gap in screen px between the anchor box and the content. Default 8. */\n  gap?: number;\n  children: React.ReactNode;\n}\n\n/**\n * Position `children` around a content-space anchor, on whichever page\n * surface is in scope. Projection runs during render from the shared pure\n * helper; pointer isolation keeps a click inside anchored UI from reaching\n * the surface's own listener (which would read it as click-outside).\n */\nexport function Anchored({ anchor, placement = 'top', gap = 8, children }: AnchoredProps) {\n  const { projector, subscribe } = useProjectorBinding();\n\n  // Browser-driven invalidation only (PageView). State-driven changes come\n  // through the binding identity — no local bump involved.\n  const [, force] = useReducer((x: number) => x + 1, 0);\n  useLayoutEffect(() => (subscribe ? subscribe(force) : undefined), [subscribe]);\n  // Client-space surfaces measure the DOM, which does not exist during the\n  // surface's first render — force one post-commit pass so the position\n  // appears as soon as it is measurable. (Solves measurability, not\n  // reactivity.)\n  useLayoutEffect(() => {\n    if (projector.space === 'client') force();\n  }, [projector, anchor]);\n\n  const ref = useRef<HTMLDivElement>(null);\n  useEffect(() => {\n    const el = ref.current;\n    if (!el) return;\n    const stop = (e: Event) => e.stopPropagation();\n    el.addEventListener('pointerdown', stop);\n    return () => el.removeEventListener('pointerdown', stop);\n  });\n\n  if (!anchor) return null;\n  const pos = projectAnchoredTarget(projector, anchor, placement, gap);\n  if (!pos) return null;\n\n  const node = (\n    <div\n      ref={ref}\n      style={{\n        position: projector.space === 'client' ? 'fixed' : 'absolute',\n        left: pos.left,\n        top: pos.top,\n        transform: pos.transform,\n        pointerEvents: 'auto',\n      }}\n    >\n      {children}\n    </div>\n  );\n  if (projector.space === 'client') {\n    if (typeof document === 'undefined') return null;\n    return createPortal(node, document.body);\n  }\n  return node;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDA,MAAM,oBAAA,GAAA,MAAA,cAAA,CAA0D,IAAI;;AAGpE,MAAa,oBAAoB,iBAAiB;;;AAIlD,SAAgB,sBAAwC;CACtD,MAAM,WAAA,GAAA,MAAA,WAAA,CAAqB,gBAAgB;CAC3C,IAAI,CAAC,SACH,MAAM,IAAI,MACR,0FACF;CAEF,OAAO;AACT;;;;;;;AAiBA,SAAgB,SAAS,EAAE,QAAQ,YAAY,OAAO,MAAM,GAAG,YAA2B;CACxF,MAAM,EAAE,WAAW,cAAc,oBAAoB;CAIrD,MAAM,GAAG,UAAA,GAAA,MAAA,WAAA,EAAqB,MAAc,IAAI,GAAG,CAAC;CACpD,CAAA,GAAA,MAAA,gBAAA,OAAuB,YAAY,UAAU,KAAK,IAAI,KAAA,GAAY,CAAC,SAAS,CAAC;CAK7E,CAAA,GAAA,MAAA,gBAAA,OAAsB;EACpB,IAAI,UAAU,UAAU,UAAU,MAAM;CAC1C,GAAG,CAAC,WAAW,MAAM,CAAC;CAEtB,MAAM,OAAA,GAAA,MAAA,OAAA,CAA6B,IAAI;CACvC,CAAA,GAAA,MAAA,UAAA,OAAgB;EACd,MAAM,KAAK,IAAI;EACf,IAAI,CAAC,IAAI;EACT,MAAM,QAAQ,MAAa,EAAE,gBAAgB;EAC7C,GAAG,iBAAiB,eAAe,IAAI;EACvC,aAAa,GAAG,oBAAoB,eAAe,IAAI;CACzD,CAAC;CAED,IAAI,CAAC,QAAQ,OAAO;CACpB,MAAM,OAAA,GAAA,cAAA,sBAAA,CAA4B,WAAW,QAAQ,WAAW,GAAG;CACnE,IAAI,CAAC,KAAK,OAAO;CAEjB,MAAM,OACJ,iBAAA,GAAA,kBAAA,IAAA,CAAC,OAAD;EACO;EACL,OAAO;GACL,UAAU,UAAU,UAAU,WAAW,UAAU;GACnD,MAAM,IAAI;GACV,KAAK,IAAI;GACT,WAAW,IAAI;GACf,eAAe;EACjB;EAEC;CACE,CAAA;CAEP,IAAI,UAAU,UAAU,UAAU;EAChC,IAAI,OAAO,aAAa,aAAa,OAAO;EAC5C,QAAA,GAAA,UAAA,aAAA,CAAoB,MAAM,SAAS,IAAI;CACzC;CACA,OAAO;AACT"}
+{"version":3,"file":"anchored.cjs","names":[],"sources":["../src/anchored.tsx"],"sourcesContent":["/**\n * Anchored overlays — one primitive for every piece of UI that floats over\n * page content (selection menus, draft menus, future popovers).\n *\n * The factoring:\n *   - plugins produce anchors (a page-space rect on a page, plus points\n *     to dodge) as capability reads.\n *   - The projection snapshot contract and the placement math are shared,\n *     framework-neutral, in `@embedpdf/web` ({@link ViewProjector},\n *     `projectAnchoredTarget`).\n *   - surfaces (<Stage>, <PageView>) provide a {@link ProjectorBinding}:\n *     the snapshot plus react's way of knowing when it changed.\n *   - <Anchored> renders at the projected position, flips to the other\n *     side and stays inside the view once it knows its size (unless\n *     pinned), says where it sits in `data-placement`, isolates pointer\n *     events, and portals when the space demands it. On a page that isn't\n *     shown it renders nothing and doesn't follow the camera at all (see\n *     {@link ShownPages}).\n *\n * The scheduling law (this is what keeps menus glued to the content): a\n * state-driven projection change (the Stage camera) reaches consumers as a\n * new binding identity through context — surface and overlay re-render in\n * the same React commit, so they can never paint a frame apart. No\n * listener sets, no post-commit notifications, no second menu-only render.\n * `subscribe` exists only for genuinely browser-driven invalidation (a\n * PageView moving because the document scrolled), where no state change\n * announces the move.\n */\nimport * as React from 'react';\nimport { createContext, useContext, useEffect, useLayoutEffect, useReducer, useState } from 'react';\nimport { createPortal } from 'react-dom';\nimport {\n  observeAnchoredFit,\n  projectAnchoredTarget,\n  sameAnchoredFit,\n  type AnchoredFit,\n  type AnchoredPlacement,\n  type AnchoredRect,\n  type AnchorTarget,\n  type ViewProjector,\n} from '@embedpdf/web';\n\nexport type {\n  AnchoredPlacement,\n  AnchoredSide,\n  AnchorTarget,\n  PageViewEnv,\n  ViewProjector,\n} from '@embedpdf/web';\n\n/**\n * What a page surface provides via context: the pure projection snapshot,\n * bound to React's reactivity.\n */\nexport interface ProjectorBinding {\n  projector: ViewProjector;\n  /**\n   * Changes identity exactly when projection may have changed for\n   * state-driven reasons — the Stage uses its `visiblePages()` value (a\n   * stable reference that already folds camera, viewport, scene and DPR).\n   * Consumers re-render because the binding's identity changes with it;\n   * nothing reads this field, but it is what makes the memoized binding\n   * change, so do not \"optimize\" it away.\n   */\n  revision: unknown;\n  /** Browser-driven invalidation only (PageView scroll/resize — see\n   *  `observeClientGeometry`). The Stage deliberately provides none. */\n  subscribe?: (callback: () => void) => () => void;\n}\n\nconst ProjectorContext = createContext<ProjectorBinding | null>(null);\n\n/** Installed by page surfaces (<Stage>, <PageView>) — not by app code. */\nexport const ProjectorProvider = ProjectorContext.Provider;\n\n/**\n * The pages a surface shows right now, by object number. It is a value of its\n * own, next to the projection, because it changes only when a page comes on\n * screen or leaves it: anchored UI on other pages reads only this, so it\n * isn't rendered again on every camera frame.\n */\nexport type ShownPages = ReadonlySet<number>;\n\nconst ShownPagesContext = createContext<ShownPages | null>(null);\n\n/** Installed by page surfaces (<Stage>, <PageView>) — not by app code. */\nexport const ShownPagesProvider = ShownPagesContext.Provider;\n\n/** The surface's projector binding, or null outside any page surface — for\n *  chrome that degrades (and warns) instead of throwing. */\nexport function useOptionalProjectorBinding(): ProjectorBinding | null {\n  return useContext(ProjectorContext);\n}\n\n/** The surface's projector binding. Reading it subscribes the caller to\n *  projection changes (the binding's identity is the revision). */\nexport function useProjectorBinding(): ProjectorBinding {\n  const binding = useContext(ProjectorContext);\n  if (!binding) {\n    throw new Error(\n      'No ViewProjector in scope: mount anchored UI under <Stage> (overlay slot) or <PageView>.',\n    );\n  }\n  return binding;\n}\n\nexport interface AnchoredProps {\n  /**\n   * The box on a page to sit next to, in page coordinates: `{ page, bounds }`,\n   * with `avoid` points to keep clear of. `null`, or a target without\n   * `bounds` (a search match with no geometry), hides it.\n   */\n  anchor: (Omit<AnchorTarget, 'bounds'> & { bounds?: AnchoredRect }) | null;\n  /**\n   * Where to sit: a side of the box, centred, or lined up with the side's\n   * start or end (`'top-end'`). Default 'top'.\n   */\n  placement?: AnchoredPlacement;\n  /**\n   * Gap in screen px between the box and the content, and between the content\n   * and the view's edge. Negative overlaps the box. Default 8.\n   */\n  gap?: number;\n  /**\n   * Stay where `placement` puts it: never flip to the other side, never move\n   * to stay in view, and scroll away with the box. For badges and status;\n   * menus leave it off. Default false.\n   */\n  pinned?: boolean;\n  children: React.ReactNode;\n}\n\n/**\n * Position `children` around a page-space anchor, on whichever page surface\n * is in scope. Projection runs during render from the shared pure helper.\n * Once the content's size is measured, it flips to the opposite side when\n * the chosen one has no room, and stays inside the view, unless `pinned`.\n * Its wrapper's `data-placement` is where it sits now: `placement`, or the\n * opposite side after a flip, so what opens from the content can open away\n * from the box.\n * Pointer isolation keeps a click inside anchored UI from reaching the\n * surface's own listener (which would read it as a click outside).\n *\n * Anchored UI on a page that isn't shown renders nothing and reads only the\n * pages on screen, so a document with hundreds of badges costs only the ones\n * in view while people scroll and zoom.\n */\nexport function Anchored(props: AnchoredProps) {\n  const shown = useContext(ShownPagesContext);\n  if (!props.anchor?.bounds) return null;\n  if (shown && !shown.has(props.anchor.page.objectNumber)) return null;\n  return <PlacedAnchored {...props} />;\n}\n\n/** Anchored UI on a page that is shown: it follows the camera. */\nfunction PlacedAnchored({\n  anchor,\n  placement = 'top',\n  gap = 8,\n  pinned = false,\n  children,\n}: AnchoredProps) {\n  const { projector, subscribe } = useProjectorBinding();\n  const [element, setElement] = useState<HTMLDivElement | null>(null);\n  // The content's size and the view's: measured after the first commit, and\n  // again whenever either resizes. A camera move changes neither.\n  const [fit, setFit] = useState<AnchoredFit | null>(null);\n\n  // Browser-driven invalidation only (PageView). State-driven changes come\n  // through the binding identity — no local bump involved.\n  const [, force] = useReducer((x: number) => x + 1, 0);\n  useLayoutEffect(() => (subscribe ? subscribe(force) : undefined), [subscribe]);\n  // Client-space surfaces measure the DOM, which does not exist during the\n  // surface's first render — force one post-commit pass so the position\n  // appears as soon as it is measurable. (Solves measurability, not\n  // reactivity.)\n  useLayoutEffect(() => {\n    if (projector.space === 'client') force();\n  }, [projector, anchor]);\n\n  useLayoutEffect(() => {\n    if (!element) return;\n    return observeAnchoredFit(element, projector.space, (next) =>\n      setFit((current) => (sameAnchoredFit(current, next) ? current : next)),\n    );\n  }, [element, projector.space]);\n\n  useEffect(() => {\n    if (!element) return;\n    const stop = (event: Event) => event.stopPropagation();\n    element.addEventListener('pointerdown', stop);\n    return () => element.removeEventListener('pointerdown', stop);\n  }, [element]);\n\n  if (!anchor?.bounds) return null;\n  const pos = projectAnchoredTarget(\n    projector,\n    { ...anchor, bounds: anchor.bounds },\n    { placement, gap, pinned },\n    fit,\n  );\n  if (!pos) return null;\n\n  const node = (\n    <div\n      ref={setElement}\n      data-placement={pos.placement}\n      style={{\n        position: projector.space === 'client' ? 'fixed' : 'absolute',\n        left: pos.left,\n        top: pos.top,\n        // Its own width, wherever it sits: the size the placement measured.\n        width: 'max-content',\n        transform: pos.transform,\n        pointerEvents: 'auto',\n      }}\n    >\n      {children}\n    </div>\n  );\n  if (projector.space === 'client') {\n    if (typeof document === 'undefined') return null;\n    return createPortal(node, document.body);\n  }\n  return node;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEA,MAAM,oBAAA,GAAA,MAAA,cAAA,CAA0D,IAAI;;AAGpE,MAAa,oBAAoB,iBAAiB;AAUlD,MAAM,qBAAA,GAAA,MAAA,cAAA,CAAqD,IAAI;;AAG/D,MAAa,qBAAqB,kBAAkB;;;AAIpD,SAAgB,8BAAuD;CACrE,QAAA,GAAA,MAAA,WAAA,CAAkB,gBAAgB;AACpC;;;AAIA,SAAgB,sBAAwC;CACtD,MAAM,WAAA,GAAA,MAAA,WAAA,CAAqB,gBAAgB;CAC3C,IAAI,CAAC,SACH,MAAM,IAAI,MACR,0FACF;CAEF,OAAO;AACT;;;;;;;;;;;;;;;;AA2CA,SAAgB,SAAS,OAAsB;CAC7C,MAAM,SAAA,GAAA,MAAA,WAAA,CAAmB,iBAAiB;CAC1C,IAAI,CAAC,MAAM,QAAQ,QAAQ,OAAO;CAClC,IAAI,SAAS,CAAC,MAAM,IAAI,MAAM,OAAO,KAAK,YAAY,GAAG,OAAO;CAChE,OAAO,iBAAA,GAAA,kBAAA,IAAA,CAAC,gBAAD,EAAgB,GAAI,MAAQ,CAAA;AACrC;;AAGA,SAAS,eAAe,EACtB,QACA,YAAY,OACZ,MAAM,GACN,SAAS,OACT,YACgB;CAChB,MAAM,EAAE,WAAW,cAAc,oBAAoB;CACrD,MAAM,CAAC,SAAS,eAAA,GAAA,MAAA,SAAA,CAA8C,IAAI;CAGlE,MAAM,CAAC,KAAK,WAAA,GAAA,MAAA,SAAA,CAAuC,IAAI;CAIvD,MAAM,GAAG,UAAA,GAAA,MAAA,WAAA,EAAqB,MAAc,IAAI,GAAG,CAAC;CACpD,CAAA,GAAA,MAAA,gBAAA,OAAuB,YAAY,UAAU,KAAK,IAAI,KAAA,GAAY,CAAC,SAAS,CAAC;CAK7E,CAAA,GAAA,MAAA,gBAAA,OAAsB;EACpB,IAAI,UAAU,UAAU,UAAU,MAAM;CAC1C,GAAG,CAAC,WAAW,MAAM,CAAC;CAEtB,CAAA,GAAA,MAAA,gBAAA,OAAsB;EACpB,IAAI,CAAC,SAAS;EACd,QAAA,GAAA,cAAA,mBAAA,CAA0B,SAAS,UAAU,QAAQ,SACnD,QAAQ,aAAA,GAAA,cAAA,gBAAA,CAA6B,SAAS,IAAI,IAAI,UAAU,IAAK,CACvE;CACF,GAAG,CAAC,SAAS,UAAU,KAAK,CAAC;CAE7B,CAAA,GAAA,MAAA,UAAA,OAAgB;EACd,IAAI,CAAC,SAAS;EACd,MAAM,QAAQ,UAAiB,MAAM,gBAAgB;EACrD,QAAQ,iBAAiB,eAAe,IAAI;EAC5C,aAAa,QAAQ,oBAAoB,eAAe,IAAI;CAC9D,GAAG,CAAC,OAAO,CAAC;CAEZ,IAAI,CAAC,QAAQ,QAAQ,OAAO;CAC5B,MAAM,OAAA,GAAA,cAAA,sBAAA,CACJ,WACA;EAAE,GAAG;EAAQ,QAAQ,OAAO;CAAO,GACnC;EAAE;EAAW;EAAK;CAAO,GACzB,GACF;CACA,IAAI,CAAC,KAAK,OAAO;CAEjB,MAAM,OACJ,iBAAA,GAAA,kBAAA,IAAA,CAAC,OAAD;EACE,KAAK;EACL,kBAAgB,IAAI;EACpB,OAAO;GACL,UAAU,UAAU,UAAU,WAAW,UAAU;GACnD,MAAM,IAAI;GACV,KAAK,IAAI;GAET,OAAO;GACP,WAAW,IAAI;GACf,eAAe;EACjB;EAEC;CACE,CAAA;CAEP,IAAI,UAAU,UAAU,UAAU;EAChC,IAAI,OAAO,aAAa,aAAa,OAAO;EAC5C,QAAA,GAAA,UAAA,aAAA,CAAoB,MAAM,SAAS,IAAI;CACzC;CACA,OAAO;AACT"}

package/dist/anchored.d.cts

@@ -1,45 +1,2 @@
-import * as React from "react";
-import { AnchorTarget, AnchorTarget as AnchorTarget$1, AnchoredPlacement, AnchoredPlacement as AnchoredPlacement$1, ViewProjector, ViewProjector as ViewProjector$1 } from "@embedpdf/web";
-//#region src/anchored.d.ts
-/**
- * What a page surface provides via context: the pure projection snapshot,
- * bound to React's reactivity.
- */
-interface ProjectorBinding {
-  projector: ViewProjector$1;
-  /**
-   * Changes identity exactly when projection may have changed for
-   * STATE-driven reasons — the Stage uses its `visiblePages()` value (a
-   * stable reference that already folds camera, viewport, scene and DPR).
-   * Consumers re-render because the binding's identity changes with it;
-   * nothing reads this field, but it is what makes the memoized binding
-   * change, so do not "optimize" it away.
-   */
-  revision: unknown;
-  /** Browser-driven invalidation ONLY (PageView scroll/resize — see
-   *  `observeClientGeometry`). The Stage deliberately provides none. */
-  subscribe?: (callback: () => void) => () => void;
-}
-/** Installed by page surfaces (<Stage>, <PageView>) — not by app code. */
-declare const ProjectorProvider: React.Provider<ProjectorBinding | null>;
-/** The surface's projector binding. Reading it subscribes the caller to
- *  projection changes (the binding's identity IS the revision). */
-declare function useProjectorBinding(): ProjectorBinding;
-interface AnchoredProps {
-  anchor: AnchorTarget$1 | null;
-  /** Which side of the anchor to sit on. Default 'top'. */
-  placement?: AnchoredPlacement$1;
-  /** Gap in screen px between the anchor box and the content. Default 8. */
-  gap?: number;
-  children: React.ReactNode;
-}
-/**
- * Position `children` around a content-space anchor, on whichever page
- * surface is in scope. Projection runs during render from the shared pure
- * helper; pointer isolation keeps a click inside anchored UI from reaching
- * the surface's own listener (which would read it as click-outside).
- */
-declare function Anchored({ anchor, placement, gap, children }: AnchoredProps): import("react/jsx-runtime").JSX.Element | null;
-//#endregion
-export { type AnchorTarget, Anchored, type AnchoredPlacement, AnchoredProps, ProjectorBinding, ProjectorProvider, type ViewProjector, useProjectorBinding };
-//# sourceMappingURL=anchored.d.cts.map
+import { a as AnchoredSide, c as ProjectorProvider, d as ViewProjector, f as useOptionalProjectorBinding, i as AnchoredProps, l as ShownPages, n as Anchored, o as PageViewEnv, p as useProjectorBinding, r as AnchoredPlacement, s as ProjectorBinding, t as AnchorTarget, u as ShownPagesProvider } from "./anchored-DzN3JywS.cjs";
+export { type AnchorTarget, Anchored, type AnchoredPlacement, AnchoredProps, type AnchoredSide, type PageViewEnv, ProjectorBinding, ProjectorProvider, ShownPages, ShownPagesProvider, type ViewProjector, useOptionalProjectorBinding, useProjectorBinding };