@embedpdf/react 3.0.0-next.14 → 3.0.0-next.16

package/dist/metadata.cjs

@@ -1,18 +1,31 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./rolldown-runtime-DDXJien1.cjs");
-const require_runtime = require("./runtime.cjs");
+const require_runtime = require("./runtime-BfnpyfY0.cjs");
+const require_state = require("./state-Dtf8HAue.cjs");
 let _embedpdf_plugin_metadata = require("@embedpdf/plugin-metadata");
 //#region src/metadata.ts
+/**
+* The metadata capability (update, custom.update, refresh, canUpdate) of the
+* surrounding `<DocumentScope>`'s document, else the active one. Outside a
+* document, every method throws `not-ready`.
+*/
 function useMetadata() {
-	const cap = require_runtime.useCapability(_embedpdf_plugin_metadata.MetadataToken);
-	return {
-		metadata: require_runtime.useSelector(_embedpdf_plugin_metadata.MetadataToken, (c) => c.current()),
-		update: cap.update,
-		canEdit: cap.canEdit
-	};
+	return require_runtime.useCapability(_embedpdf_plugin_metadata.MetadataToken);
+}
+/**
+* The metadata's state: the standard fields, your own fields and the load
+* state (the page's State table, declared once in `metadataState`). Takes a
+* selector, and re-renders only when what it returns changes.
+*/
+const useMetadataState = require_state.stateHook(_embedpdf_plugin_metadata.metadataState);
+/** Subscribe to one metadata event for the mounted lifetime: `useMetadataEvent((metadata) => metadata.onUpdated, handler)`. */
+function useMetadataEvent(select, handler) {
+	require_runtime.useCapabilityEvent(_embedpdf_plugin_metadata.MetadataToken, select, handler);
 }
 //#endregion
 exports.useMetadata = useMetadata;
+exports.useMetadataEvent = useMetadataEvent;
+exports.useMetadataState = useMetadataState;
 Object.keys(_embedpdf_plugin_metadata).forEach(function(k) {
 	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
 		enumerable: true,

package/dist/metadata.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"metadata.cjs","names":["useCapability","MetadataToken","useSelector"],"sources":["../src/metadata.ts"],"sourcesContent":["import { MetadataToken } from '@embedpdf/plugin-metadata';\nimport type { DocumentMetadata, MetadataPatch } from '@embedpdf/core';\nimport { useCapability, useSelector } from './runtime';\n\n/**\n * The document's metadata, bound to the surrounding `DocumentScope`. Reactive:\n * `metadata` updates from your own edits AND from remote (SSE) edits — the\n * plugin keeps it live off the document event stream.\n *\n *   const { metadata, update } = useMetadata();\n *   await update({ title: 'New title' }); // three-state patch; writes to the layer\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-metadata';\nexport function useMetadata(): {\n  metadata: DocumentMetadata | null;\n  update: (patch: MetadataPatch) => Promise<void>;\n  canEdit: () => boolean;\n} {\n  const cap = useCapability(MetadataToken);\n  const metadata = useSelector(MetadataToken, (c) => c.current());\n  return { metadata, update: cap.update, canEdit: cap.canEdit };\n}\n"],"mappings":";;;;;AAeA,SAAgB,cAId;CACA,MAAM,MAAMA,gBAAAA,cAAcC,0BAAAA,aAAa;CAEvC,OAAO;EAAE,UADQC,gBAAAA,YAAYD,0BAAAA,gBAAgB,MAAM,EAAE,QAAQ,CAC7C;EAAG,QAAQ,IAAI;EAAQ,SAAS,IAAI;CAAQ;AAC9D"}
+{"version":3,"file":"metadata.cjs","names":["useCapability","MetadataToken","stateHook","metadataState"],"sources":["../src/metadata.ts"],"sourcesContent":["/**\n * The React surface for @embedpdf/plugin-metadata: the capability, the state\n * declared once in `metadataState`, and its events. The plugin keeps the\n * metadata live off the document event stream, so the state updates after\n * your own edits and after other sessions'.\n *\n *   const metadata = useMetadata();\n *   const { metadata: fields, custom, status } = useMetadataState();\n *   await metadata.update({ title: 'New title' }); // resolves once the state shows it\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-metadata';\nimport { MetadataToken, metadataState, type MetadataCapability } from '@embedpdf/plugin-metadata';\nimport type { EventHook } from '@embedpdf/core';\nimport { useCapability, useCapabilityEvent } from './runtime';\nimport { stateHook } from './state';\n\n/**\n * The metadata capability (update, custom.update, refresh, canUpdate) of the\n * surrounding `<DocumentScope>`'s document, else the active one. Outside a\n * document, every method throws `not-ready`.\n */\nexport function useMetadata(): MetadataCapability {\n  return useCapability(MetadataToken);\n}\n\n/**\n * The metadata's state: the standard fields, your own fields and the load\n * state (the page's State table, declared once in `metadataState`). Takes a\n * selector, and re-renders only when what it returns changes.\n */\nexport const useMetadataState = stateHook(metadataState);\n\n/** Subscribe to one metadata event for the mounted lifetime: `useMetadataEvent((metadata) => metadata.onUpdated, handler)`. */\nexport function useMetadataEvent<T>(\n  select: (metadata: MetadataCapability) => EventHook<T>,\n  handler: (event: T) => void,\n): void {\n  useCapabilityEvent(MetadataToken, select, handler);\n}\n"],"mappings":";;;;;;;;;;;AAuBA,SAAgB,cAAkC;CAChD,OAAOA,gBAAAA,cAAcC,0BAAAA,aAAa;AACpC;;;;;;AAOA,MAAa,mBAAmBC,cAAAA,UAAUC,0BAAAA,aAAa;;AAGvD,SAAgB,iBACd,QACA,SACM;CACN,gBAAA,mBAAmBF,0BAAAA,eAAe,QAAQ,OAAO;AACnD"}

package/dist/metadata.d.cts

@@ -1,11 +1,26 @@
-import { DocumentMetadata, MetadataPatch } from "@embedpdf/core";
+import { n as StateHook } from "./state-0K1I5cM4.cjs";
+import { EventHook } from "@embedpdf/core";
+import { MetadataCapability } from "@embedpdf/plugin-metadata";
 export * from "@embedpdf/plugin-metadata";
 //#region src/metadata.d.ts
-declare function useMetadata(): {
-  metadata: DocumentMetadata | null;
-  update: (patch: MetadataPatch) => Promise<void>;
-  canEdit: () => boolean;
-};
+/**
+ * The metadata capability (update, custom.update, refresh, canUpdate) of the
+ * surrounding `<DocumentScope>`'s document, else the active one. Outside a
+ * document, every method throws `not-ready`.
+ */
+declare function useMetadata(): MetadataCapability;
+/**
+ * The metadata's state: the standard fields, your own fields and the load
+ * state (the page's State table, declared once in `metadataState`). Takes a
+ * selector, and re-renders only when what it returns changes.
+ */
+declare const useMetadataState: StateHook<{
+  metadata: import("@embedpdf/core").DocumentMetadata | null;
+  custom: import("@embedpdf/core").CustomMetadata | null;
+  status: import("@embedpdf/core").ResourceStatus;
+}>;
+/** Subscribe to one metadata event for the mounted lifetime: `useMetadataEvent((metadata) => metadata.onUpdated, handler)`. */
+declare function useMetadataEvent<T>(select: (metadata: MetadataCapability) => EventHook<T>, handler: (event: T) => void): void;
 //#endregion
-export { useMetadata };
+export { useMetadata, useMetadataEvent, useMetadataState };
 //# sourceMappingURL=metadata.d.cts.map

package/dist/metadata.d.ts

@@ -1,11 +1,26 @@
-import { DocumentMetadata, MetadataPatch } from "@embedpdf/core";
+import { n as StateHook } from "./state-0K1I5cM4.js";
+import { EventHook } from "@embedpdf/core";
+import { MetadataCapability } from "@embedpdf/plugin-metadata";
 export * from "@embedpdf/plugin-metadata";
 //#region src/metadata.d.ts
-declare function useMetadata(): {
-  metadata: DocumentMetadata | null;
-  update: (patch: MetadataPatch) => Promise<void>;
-  canEdit: () => boolean;
-};
+/**
+ * The metadata capability (update, custom.update, refresh, canUpdate) of the
+ * surrounding `<DocumentScope>`'s document, else the active one. Outside a
+ * document, every method throws `not-ready`.
+ */
+declare function useMetadata(): MetadataCapability;
+/**
+ * The metadata's state: the standard fields, your own fields and the load
+ * state (the page's State table, declared once in `metadataState`). Takes a
+ * selector, and re-renders only when what it returns changes.
+ */
+declare const useMetadataState: StateHook<{
+  metadata: import("@embedpdf/core").DocumentMetadata | null;
+  custom: import("@embedpdf/core").CustomMetadata | null;
+  status: import("@embedpdf/core").ResourceStatus;
+}>;
+/** Subscribe to one metadata event for the mounted lifetime: `useMetadataEvent((metadata) => metadata.onUpdated, handler)`. */
+declare function useMetadataEvent<T>(select: (metadata: MetadataCapability) => EventHook<T>, handler: (event: T) => void): void;
 //#endregion
-export { useMetadata };
+export { useMetadata, useMetadataEvent, useMetadataState };
 //# sourceMappingURL=metadata.d.ts.map

package/dist/metadata.js

@@ -1,17 +1,27 @@
-import "./rolldown-runtime-BBjsoOtd.js";
-import { useCapability, useSelector } from "./runtime.js";
-import { MetadataToken } from "@embedpdf/plugin-metadata";
+import { f as useCapability, p as useCapabilityEvent } from "./runtime-tD5iJU83.js";
+import { n as stateHook } from "./state-CzI2KlZb.js";
+import { MetadataToken, metadataState } from "@embedpdf/plugin-metadata";
 export * from "@embedpdf/plugin-metadata";
 //#region src/metadata.ts
+/**
+* The metadata capability (update, custom.update, refresh, canUpdate) of the
+* surrounding `<DocumentScope>`'s document, else the active one. Outside a
+* document, every method throws `not-ready`.
+*/
 function useMetadata() {
-	const cap = useCapability(MetadataToken);
-	return {
-		metadata: useSelector(MetadataToken, (c) => c.current()),
-		update: cap.update,
-		canEdit: cap.canEdit
-	};
+	return useCapability(MetadataToken);
+}
+/**
+* The metadata's state: the standard fields, your own fields and the load
+* state (the page's State table, declared once in `metadataState`). Takes a
+* selector, and re-renders only when what it returns changes.
+*/
+const useMetadataState = stateHook(metadataState);
+/** Subscribe to one metadata event for the mounted lifetime: `useMetadataEvent((metadata) => metadata.onUpdated, handler)`. */
+function useMetadataEvent(select, handler) {
+	useCapabilityEvent(MetadataToken, select, handler);
 }
 //#endregion
-export { useMetadata };
+export { useMetadata, useMetadataEvent, useMetadataState };
 
 //# sourceMappingURL=metadata.js.map

package/dist/metadata.js.map

@@ -1 +1 @@
-{"version":3,"file":"metadata.js","names":[],"sources":["../src/metadata.ts"],"sourcesContent":["import { MetadataToken } from '@embedpdf/plugin-metadata';\nimport type { DocumentMetadata, MetadataPatch } from '@embedpdf/core';\nimport { useCapability, useSelector } from './runtime';\n\n/**\n * The document's metadata, bound to the surrounding `DocumentScope`. Reactive:\n * `metadata` updates from your own edits AND from remote (SSE) edits — the\n * plugin keeps it live off the document event stream.\n *\n *   const { metadata, update } = useMetadata();\n *   await update({ title: 'New title' }); // three-state patch; writes to the layer\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-metadata';\nexport function useMetadata(): {\n  metadata: DocumentMetadata | null;\n  update: (patch: MetadataPatch) => Promise<void>;\n  canEdit: () => boolean;\n} {\n  const cap = useCapability(MetadataToken);\n  const metadata = useSelector(MetadataToken, (c) => c.current());\n  return { metadata, update: cap.update, canEdit: cap.canEdit };\n}\n"],"mappings":";;;;;AAeA,SAAgB,cAId;CACA,MAAM,MAAM,cAAc,aAAa;CAEvC,OAAO;EAAE,UADQ,YAAY,gBAAgB,MAAM,EAAE,QAAQ,CAC7C;EAAG,QAAQ,IAAI;EAAQ,SAAS,IAAI;CAAQ;AAC9D"}
+{"version":3,"file":"metadata.js","names":[],"sources":["../src/metadata.ts"],"sourcesContent":["/**\n * The React surface for @embedpdf/plugin-metadata: the capability, the state\n * declared once in `metadataState`, and its events. The plugin keeps the\n * metadata live off the document event stream, so the state updates after\n * your own edits and after other sessions'.\n *\n *   const metadata = useMetadata();\n *   const { metadata: fields, custom, status } = useMetadataState();\n *   await metadata.update({ title: 'New title' }); // resolves once the state shows it\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-metadata';\nimport { MetadataToken, metadataState, type MetadataCapability } from '@embedpdf/plugin-metadata';\nimport type { EventHook } from '@embedpdf/core';\nimport { useCapability, useCapabilityEvent } from './runtime';\nimport { stateHook } from './state';\n\n/**\n * The metadata capability (update, custom.update, refresh, canUpdate) of the\n * surrounding `<DocumentScope>`'s document, else the active one. Outside a\n * document, every method throws `not-ready`.\n */\nexport function useMetadata(): MetadataCapability {\n  return useCapability(MetadataToken);\n}\n\n/**\n * The metadata's state: the standard fields, your own fields and the load\n * state (the page's State table, declared once in `metadataState`). Takes a\n * selector, and re-renders only when what it returns changes.\n */\nexport const useMetadataState = stateHook(metadataState);\n\n/** Subscribe to one metadata event for the mounted lifetime: `useMetadataEvent((metadata) => metadata.onUpdated, handler)`. */\nexport function useMetadataEvent<T>(\n  select: (metadata: MetadataCapability) => EventHook<T>,\n  handler: (event: T) => void,\n): void {\n  useCapabilityEvent(MetadataToken, select, handler);\n}\n"],"mappings":";;;;;;;;;;AAuBA,SAAgB,cAAkC;CAChD,OAAO,cAAc,aAAa;AACpC;;;;;;AAOA,MAAa,mBAAmB,UAAU,aAAa;;AAGvD,SAAgB,iBACd,QACA,SACM;CACN,mBAAmB,eAAe,QAAQ,OAAO;AACnD"}

package/dist/outline.cjs

@@ -0,0 +1,39 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./rolldown-runtime-DDXJien1.cjs");
+const require_runtime = require("./runtime-BfnpyfY0.cjs");
+const require_state = require("./state-Dtf8HAue.cjs");
+let _embedpdf_plugin_outline = require("@embedpdf/plugin-outline");
+//#region src/outline.ts
+/**
+* The outline capability (expand, select, activate, create, update, move,
+* delete) of the surrounding `<DocumentScope>`'s document, else the active
+* one. Outside a document, every method throws `not-ready`.
+*/
+function useOutline() {
+	return require_runtime.useCapability(_embedpdf_plugin_outline.OutlineToken);
+}
+/**
+* The outline's state: its items, the rows a tree view shows, the item for
+* where the view is reading, the selection, the load state and whether you may
+* edit it (the page's State table, declared once in `outlineState`). Takes a
+* selector, and re-renders only when what it returns changes.
+*/
+const useOutlineState = require_state.stateHook(_embedpdf_plugin_outline.outlineState);
+/** Subscribe to one outline event for the mounted lifetime: `useOutlineEvent((outline) => outline.onChanged, handler)`. */
+function useOutlineEvent(select, handler) {
+	require_runtime.useCapabilityEvent(_embedpdf_plugin_outline.OutlineToken, select, handler);
+}
+//#endregion
+exports.useOutline = useOutline;
+exports.useOutlineEvent = useOutlineEvent;
+exports.useOutlineState = useOutlineState;
+Object.keys(_embedpdf_plugin_outline).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return _embedpdf_plugin_outline[k];
+		}
+	});
+});
+
+//# sourceMappingURL=outline.cjs.map

package/dist/outline.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"outline.cjs","names":["useCapability","OutlineToken","stateHook","outlineState"],"sources":["../src/outline.ts"],"sourcesContent":["/**\n * The React surface for @embedpdf/plugin-outline: the capability, the state\n * declared once in `outlineState`, and its events. Reading the state reads\n * the outline; the plugin keeps it live off the document event stream, and\n * shows your own edits at once.\n *\n *   const outline = useOutline();\n *   const { rows, current, canEdit } = useOutlineState();\n *   outline.activate(row.item.ref); // goes where the item goes, as a click does\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-outline';\nimport { OutlineToken, outlineState, type OutlineCapability } from '@embedpdf/plugin-outline';\nimport type { EventHook } from '@embedpdf/core';\nimport { useCapability, useCapabilityEvent } from './runtime';\nimport { stateHook } from './state';\n\n/**\n * The outline capability (expand, select, activate, create, update, move,\n * delete) of the surrounding `<DocumentScope>`'s document, else the active\n * one. Outside a document, every method throws `not-ready`.\n */\nexport function useOutline(): OutlineCapability {\n  return useCapability(OutlineToken);\n}\n\n/**\n * The outline's state: its items, the rows a tree view shows, the item for\n * where the view is reading, the selection, the load state and whether you may\n * edit it (the page's State table, declared once in `outlineState`). Takes a\n * selector, and re-renders only when what it returns changes.\n */\nexport const useOutlineState = stateHook(outlineState);\n\n/** Subscribe to one outline event for the mounted lifetime: `useOutlineEvent((outline) => outline.onChanged, handler)`. */\nexport function useOutlineEvent<T>(\n  select: (outline: OutlineCapability) => EventHook<T>,\n  handler: (event: T) => void,\n): void {\n  useCapabilityEvent(OutlineToken, select, handler);\n}\n"],"mappings":";;;;;;;;;;;AAuBA,SAAgB,aAAgC;CAC9C,OAAOA,gBAAAA,cAAcC,yBAAAA,YAAY;AACnC;;;;;;;AAQA,MAAa,kBAAkBC,cAAAA,UAAUC,yBAAAA,YAAY;;AAGrD,SAAgB,gBACd,QACA,SACM;CACN,gBAAA,mBAAmBF,yBAAAA,cAAc,QAAQ,OAAO;AAClD"}

package/dist/outline.d.cts

@@ -0,0 +1,31 @@
+import { n as StateHook } from "./state-0K1I5cM4.cjs";
+import { EventHook } from "@embedpdf/core";
+import { OutlineCapability } from "@embedpdf/plugin-outline";
+export * from "@embedpdf/plugin-outline";
+//#region src/outline.d.ts
+/**
+ * The outline capability (expand, select, activate, create, update, move,
+ * delete) of the surrounding `<DocumentScope>`'s document, else the active
+ * one. Outside a document, every method throws `not-ready`.
+ */
+declare function useOutline(): OutlineCapability;
+/**
+ * The outline's state: its items, the rows a tree view shows, the item for
+ * where the view is reading, the selection, the load state and whether you may
+ * edit it (the page's State table, declared once in `outlineState`). Takes a
+ * selector, and re-renders only when what it returns changes.
+ */
+declare const useOutlineState: StateHook<{
+  items: readonly import("@embedpdf/plugin-outline").OutlineItem<import("@embedpdf/core").PageDestination>[];
+  rows: readonly import("@embedpdf/plugin-outline").OutlineRow[];
+  current: import("@embedpdf/plugin-outline").OutlineItemRef | null;
+  selected: readonly import("@embedpdf/plugin-outline").OutlineItemRef[];
+  status: import("@embedpdf/core").ResourceStatus;
+  incomplete: boolean;
+  canEdit: boolean;
+}>;
+/** Subscribe to one outline event for the mounted lifetime: `useOutlineEvent((outline) => outline.onChanged, handler)`. */
+declare function useOutlineEvent<T>(select: (outline: OutlineCapability) => EventHook<T>, handler: (event: T) => void): void;
+//#endregion
+export { useOutline, useOutlineEvent, useOutlineState };
+//# sourceMappingURL=outline.d.cts.map

package/dist/outline.d.ts

@@ -0,0 +1,31 @@
+import { n as StateHook } from "./state-0K1I5cM4.js";
+import { EventHook } from "@embedpdf/core";
+import { OutlineCapability } from "@embedpdf/plugin-outline";
+export * from "@embedpdf/plugin-outline";
+//#region src/outline.d.ts
+/**
+ * The outline capability (expand, select, activate, create, update, move,
+ * delete) of the surrounding `<DocumentScope>`'s document, else the active
+ * one. Outside a document, every method throws `not-ready`.
+ */
+declare function useOutline(): OutlineCapability;
+/**
+ * The outline's state: its items, the rows a tree view shows, the item for
+ * where the view is reading, the selection, the load state and whether you may
+ * edit it (the page's State table, declared once in `outlineState`). Takes a
+ * selector, and re-renders only when what it returns changes.
+ */
+declare const useOutlineState: StateHook<{
+  items: readonly import("@embedpdf/plugin-outline").OutlineItem<import("@embedpdf/core").PageDestination>[];
+  rows: readonly import("@embedpdf/plugin-outline").OutlineRow[];
+  current: import("@embedpdf/plugin-outline").OutlineItemRef | null;
+  selected: readonly import("@embedpdf/plugin-outline").OutlineItemRef[];
+  status: import("@embedpdf/core").ResourceStatus;
+  incomplete: boolean;
+  canEdit: boolean;
+}>;
+/** Subscribe to one outline event for the mounted lifetime: `useOutlineEvent((outline) => outline.onChanged, handler)`. */
+declare function useOutlineEvent<T>(select: (outline: OutlineCapability) => EventHook<T>, handler: (event: T) => void): void;
+//#endregion
+export { useOutline, useOutlineEvent, useOutlineState };
+//# sourceMappingURL=outline.d.ts.map

package/dist/outline.js

@@ -0,0 +1,28 @@
+import { f as useCapability, p as useCapabilityEvent } from "./runtime-tD5iJU83.js";
+import { n as stateHook } from "./state-CzI2KlZb.js";
+import { OutlineToken, outlineState } from "@embedpdf/plugin-outline";
+export * from "@embedpdf/plugin-outline";
+//#region src/outline.ts
+/**
+* The outline capability (expand, select, activate, create, update, move,
+* delete) of the surrounding `<DocumentScope>`'s document, else the active
+* one. Outside a document, every method throws `not-ready`.
+*/
+function useOutline() {
+	return useCapability(OutlineToken);
+}
+/**
+* The outline's state: its items, the rows a tree view shows, the item for
+* where the view is reading, the selection, the load state and whether you may
+* edit it (the page's State table, declared once in `outlineState`). Takes a
+* selector, and re-renders only when what it returns changes.
+*/
+const useOutlineState = stateHook(outlineState);
+/** Subscribe to one outline event for the mounted lifetime: `useOutlineEvent((outline) => outline.onChanged, handler)`. */
+function useOutlineEvent(select, handler) {
+	useCapabilityEvent(OutlineToken, select, handler);
+}
+//#endregion
+export { useOutline, useOutlineEvent, useOutlineState };
+
+//# sourceMappingURL=outline.js.map

package/dist/outline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outline.js","names":[],"sources":["../src/outline.ts"],"sourcesContent":["/**\n * The React surface for @embedpdf/plugin-outline: the capability, the state\n * declared once in `outlineState`, and its events. Reading the state reads\n * the outline; the plugin keeps it live off the document event stream, and\n * shows your own edits at once.\n *\n *   const outline = useOutline();\n *   const { rows, current, canEdit } = useOutlineState();\n *   outline.activate(row.item.ref); // goes where the item goes, as a click does\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-outline';\nimport { OutlineToken, outlineState, type OutlineCapability } from '@embedpdf/plugin-outline';\nimport type { EventHook } from '@embedpdf/core';\nimport { useCapability, useCapabilityEvent } from './runtime';\nimport { stateHook } from './state';\n\n/**\n * The outline capability (expand, select, activate, create, update, move,\n * delete) of the surrounding `<DocumentScope>`'s document, else the active\n * one. Outside a document, every method throws `not-ready`.\n */\nexport function useOutline(): OutlineCapability {\n  return useCapability(OutlineToken);\n}\n\n/**\n * The outline's state: its items, the rows a tree view shows, the item for\n * where the view is reading, the selection, the load state and whether you may\n * edit it (the page's State table, declared once in `outlineState`). Takes a\n * selector, and re-renders only when what it returns changes.\n */\nexport const useOutlineState = stateHook(outlineState);\n\n/** Subscribe to one outline event for the mounted lifetime: `useOutlineEvent((outline) => outline.onChanged, handler)`. */\nexport function useOutlineEvent<T>(\n  select: (outline: OutlineCapability) => EventHook<T>,\n  handler: (event: T) => void,\n): void {\n  useCapabilityEvent(OutlineToken, select, handler);\n}\n"],"mappings":";;;;;;;;;;AAuBA,SAAgB,aAAgC;CAC9C,OAAO,cAAc,YAAY;AACnC;;;;;;;AAQA,MAAa,kBAAkB,UAAU,YAAY;;AAGrD,SAAgB,gBACd,QACA,SACM;CACN,mBAAmB,cAAc,QAAQ,OAAO;AAClD"}

package/dist/page-edit.cjs

@@ -1,13 +1,25 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./rolldown-runtime-DDXJien1.cjs");
-const require_runtime = require("./runtime.cjs");
+const require_runtime = require("./runtime-BfnpyfY0.cjs");
+const require_state = require("./state-Dtf8HAue.cjs");
 let _embedpdf_plugin_page_edit = require("@embedpdf/plugin-page-edit");
 //#region src/page-edit.ts
-function usePageEditor() {
+/**
+* The page edits of the surrounding `<DocumentScope>`'s document, else the
+* active one. Outside a document, every method throws `not-ready`.
+*/
+function usePageEdit() {
 	return require_runtime.useCapability(_embedpdf_plugin_page_edit.PageEditToken);
 }
+/**
+* The page edits' state: the selected pages and whether you may edit and copy
+* pages (the page's State table, declared once in `pageEditState`). Takes a
+* selector, and re-renders only when what it returns changes.
+*/
+const usePageEditState = require_state.stateHook(_embedpdf_plugin_page_edit.pageEditState);
 //#endregion
-exports.usePageEditor = usePageEditor;
+exports.usePageEdit = usePageEdit;
+exports.usePageEditState = usePageEditState;
 Object.keys(_embedpdf_plugin_page_edit).forEach(function(k) {
 	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
 		enumerable: true,

package/dist/page-edit.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"page-edit.cjs","names":["useCapability","PageEditToken"],"sources":["../src/page-edit.ts"],"sourcesContent":["import { PageEditToken, type PageEditCapability } from '@embedpdf/plugin-page-edit';\nimport { useCapability } from './runtime';\n\n/**\n * The page-edit capability, bound to the surrounding `DocumentScope`.\n *\n * Thin idiomatic wrapper over `PageEditToken` — the relative→absolute rotation\n * and PON addressing live in the plugin, so this hook (and its Vue/Svelte/\n * Angular siblings) is pure binding sugar with no logic to drift.\n *\n *   const editor = usePageEditor();\n *   editor.rotateBy(page.pon, 90);\n *   if (editor.canEdit()) { … }\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-page-edit';\nexport function usePageEditor(): PageEditCapability {\n  return useCapability(PageEditToken);\n}\n"],"mappings":";;;;;AAiBA,SAAgB,gBAAoC;CAClD,OAAOA,gBAAAA,cAAcC,2BAAAA,aAAa;AACpC"}
+{"version":3,"file":"page-edit.cjs","names":["useCapability","PageEditToken","stateHook","pageEditState"],"sources":["../src/page-edit.ts"],"sourcesContent":["/**\n * The React surface for @embedpdf/plugin-page-edit: the capability and the\n * state declared once in `pageEditState`. The plugin turns a page relative to\n * its rotation and resolves positions, so this file is binding only:\n *\n *   const pageEdit = usePageEdit();\n *   const { selected, canEdit } = usePageEditState();\n *   await pageEdit.rotateBy(selected, 90);\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-page-edit';\nimport { PageEditToken, pageEditState, type PageEditCapability } from '@embedpdf/plugin-page-edit';\nimport { useCapability } from './runtime';\nimport { stateHook } from './state';\n\n/**\n * The page edits of the surrounding `<DocumentScope>`'s document, else the\n * active one. Outside a document, every method throws `not-ready`.\n */\nexport function usePageEdit(): PageEditCapability {\n  return useCapability(PageEditToken);\n}\n\n/**\n * The page edits' state: the selected pages and whether you may edit and copy\n * pages (the page's State table, declared once in `pageEditState`). Takes a\n * selector, and re-renders only when what it returns changes.\n */\nexport const usePageEditState = stateHook(pageEditState);\n"],"mappings":";;;;;;;;;;AAoBA,SAAgB,cAAkC;CAChD,OAAOA,gBAAAA,cAAcC,2BAAAA,aAAa;AACpC;;;;;;AAOA,MAAa,mBAAmBC,cAAAA,UAAUC,2BAAAA,aAAa"}

package/dist/page-edit.d.cts

@@ -1,7 +1,22 @@
+import { n as StateHook } from "./state-0K1I5cM4.cjs";
 import { PageEditCapability } from "@embedpdf/plugin-page-edit";
 export * from "@embedpdf/plugin-page-edit";
 //#region src/page-edit.d.ts
-declare function usePageEditor(): PageEditCapability;
+/**
+ * The page edits of the surrounding `<DocumentScope>`'s document, else the
+ * active one. Outside a document, every method throws `not-ready`.
+ */
+declare function usePageEdit(): PageEditCapability;
+/**
+ * The page edits' state: the selected pages and whether you may edit and copy
+ * pages (the page's State table, declared once in `pageEditState`). Takes a
+ * selector, and re-renders only when what it returns changes.
+ */
+declare const usePageEditState: StateHook<{
+  selected: readonly import("@embedpdf/core").PageRef[];
+  canEdit: boolean;
+  canExtract: boolean;
+}>;
 //#endregion
-export { usePageEditor };
+export { usePageEdit, usePageEditState };
 //# sourceMappingURL=page-edit.d.cts.map

package/dist/page-edit.d.ts

@@ -1,7 +1,22 @@
+import { n as StateHook } from "./state-0K1I5cM4.js";
 import { PageEditCapability } from "@embedpdf/plugin-page-edit";
 export * from "@embedpdf/plugin-page-edit";
 //#region src/page-edit.d.ts
-declare function usePageEditor(): PageEditCapability;
+/**
+ * The page edits of the surrounding `<DocumentScope>`'s document, else the
+ * active one. Outside a document, every method throws `not-ready`.
+ */
+declare function usePageEdit(): PageEditCapability;
+/**
+ * The page edits' state: the selected pages and whether you may edit and copy
+ * pages (the page's State table, declared once in `pageEditState`). Takes a
+ * selector, and re-renders only when what it returns changes.
+ */
+declare const usePageEditState: StateHook<{
+  selected: readonly import("@embedpdf/core").PageRef[];
+  canEdit: boolean;
+  canExtract: boolean;
+}>;
 //#endregion
-export { usePageEditor };
+export { usePageEdit, usePageEditState };
 //# sourceMappingURL=page-edit.d.ts.map

package/dist/page-edit.js

@@ -1,12 +1,22 @@
-import "./rolldown-runtime-BBjsoOtd.js";
-import { useCapability } from "./runtime.js";
-import { PageEditToken } from "@embedpdf/plugin-page-edit";
+import { f as useCapability } from "./runtime-tD5iJU83.js";
+import { n as stateHook } from "./state-CzI2KlZb.js";
+import { PageEditToken, pageEditState } from "@embedpdf/plugin-page-edit";
 export * from "@embedpdf/plugin-page-edit";
 //#region src/page-edit.ts
-function usePageEditor() {
+/**
+* The page edits of the surrounding `<DocumentScope>`'s document, else the
+* active one. Outside a document, every method throws `not-ready`.
+*/
+function usePageEdit() {
 	return useCapability(PageEditToken);
 }
+/**
+* The page edits' state: the selected pages and whether you may edit and copy
+* pages (the page's State table, declared once in `pageEditState`). Takes a
+* selector, and re-renders only when what it returns changes.
+*/
+const usePageEditState = stateHook(pageEditState);
 //#endregion
-export { usePageEditor };
+export { usePageEdit, usePageEditState };
 
 //# sourceMappingURL=page-edit.js.map

package/dist/page-edit.js.map

@@ -1 +1 @@
-{"version":3,"file":"page-edit.js","names":[],"sources":["../src/page-edit.ts"],"sourcesContent":["import { PageEditToken, type PageEditCapability } from '@embedpdf/plugin-page-edit';\nimport { useCapability } from './runtime';\n\n/**\n * The page-edit capability, bound to the surrounding `DocumentScope`.\n *\n * Thin idiomatic wrapper over `PageEditToken` — the relative→absolute rotation\n * and PON addressing live in the plugin, so this hook (and its Vue/Svelte/\n * Angular siblings) is pure binding sugar with no logic to drift.\n *\n *   const editor = usePageEditor();\n *   editor.rotateBy(page.pon, 90);\n *   if (editor.canEdit()) { … }\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-page-edit';\nexport function usePageEditor(): PageEditCapability {\n  return useCapability(PageEditToken);\n}\n"],"mappings":";;;;;AAiBA,SAAgB,gBAAoC;CAClD,OAAO,cAAc,aAAa;AACpC"}
+{"version":3,"file":"page-edit.js","names":[],"sources":["../src/page-edit.ts"],"sourcesContent":["/**\n * The React surface for @embedpdf/plugin-page-edit: the capability and the\n * state declared once in `pageEditState`. The plugin turns a page relative to\n * its rotation and resolves positions, so this file is binding only:\n *\n *   const pageEdit = usePageEdit();\n *   const { selected, canEdit } = usePageEditState();\n *   await pageEdit.rotateBy(selected, 90);\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-page-edit';\nimport { PageEditToken, pageEditState, type PageEditCapability } from '@embedpdf/plugin-page-edit';\nimport { useCapability } from './runtime';\nimport { stateHook } from './state';\n\n/**\n * The page edits of the surrounding `<DocumentScope>`'s document, else the\n * active one. Outside a document, every method throws `not-ready`.\n */\nexport function usePageEdit(): PageEditCapability {\n  return useCapability(PageEditToken);\n}\n\n/**\n * The page edits' state: the selected pages and whether you may edit and copy\n * pages (the page's State table, declared once in `pageEditState`). Takes a\n * selector, and re-renders only when what it returns changes.\n */\nexport const usePageEditState = stateHook(pageEditState);\n"],"mappings":";;;;;;;;;AAoBA,SAAgB,cAAkC;CAChD,OAAO,cAAc,aAAa;AACpC;;;;;;AAOA,MAAa,mBAAmB,UAAU,aAAa"}

package/dist/page-layers-Bkaaz8Zf.js

@@ -0,0 +1,26 @@
+import { pageLayersOf } from "@embedpdf/web";
+import { useInsertionEffect, useSyncExternalStore } from "react";
+//#region src/page-layers.ts
+/**
+* The React side of `@embedpdf/web`'s page layers: a layer says, while it's
+* mounted, which part of its page it paints, and the render layer reads which
+* parts are painted, to leave them out of the page's picture.
+*/
+/**
+* Say, while mounted, that this layer paints `part` of its page (`pageRef`,
+* the page context's `ref`). Said in an insertion effect, which runs before
+* any layout effect of the same commit, so a render layer mounted alongside
+* already plans its tiles without it.
+*/
+function usePaintsPagePart(pageRef, part) {
+	useInsertionEffect(() => pageLayersOf(pageRef).paint(part), [pageRef, part]);
+}
+/** Which parts of the page (`pageRef`, the page context's `ref`) the layers on it paint. */
+function usePaintedParts(pageRef) {
+	const layers = pageLayersOf(pageRef);
+	return useSyncExternalStore(layers.subscribe, layers.painted, layers.painted);
+}
+//#endregion
+export { usePaintsPagePart as n, usePaintedParts as t };
+
+//# sourceMappingURL=page-layers-Bkaaz8Zf.js.map

package/dist/page-layers-Bkaaz8Zf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-layers-Bkaaz8Zf.js","names":[],"sources":["../src/page-layers.ts"],"sourcesContent":["/**\n * The React side of `@embedpdf/web`'s page layers: a layer says, while it's\n * mounted, which part of its page it paints, and the render layer reads which\n * parts are painted, to leave them out of the page's picture.\n */\nimport { pageLayersOf, type PagePart, type PaintedParts } from '@embedpdf/web';\nimport { useInsertionEffect, useSyncExternalStore } from 'react';\n\n/**\n * Say, while mounted, that this layer paints `part` of its page (`pageRef`,\n * the page context's `ref`). Said in an insertion effect, which runs before\n * any layout effect of the same commit, so a render layer mounted alongside\n * already plans its tiles without it.\n */\nexport function usePaintsPagePart(pageRef: object, part: PagePart): void {\n  useInsertionEffect(() => pageLayersOf(pageRef).paint(part), [pageRef, part]);\n}\n\n/** Which parts of the page (`pageRef`, the page context's `ref`) the layers on it paint. */\nexport function usePaintedParts(pageRef: object): PaintedParts {\n  const layers = pageLayersOf(pageRef);\n  return useSyncExternalStore(layers.subscribe, layers.painted, layers.painted);\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,SAAgB,kBAAkB,SAAiB,MAAsB;CACvE,yBAAyB,aAAa,OAAO,CAAC,CAAC,MAAM,IAAI,GAAG,CAAC,SAAS,IAAI,CAAC;AAC7E;;AAGA,SAAgB,gBAAgB,SAA+B;CAC7D,MAAM,SAAS,aAAa,OAAO;CACnC,OAAO,qBAAqB,OAAO,WAAW,OAAO,SAAS,OAAO,OAAO;AAC9E"}

package/dist/page-layers-BloZDoOV.cjs

@@ -0,0 +1,37 @@
+let _embedpdf_web = require("@embedpdf/web");
+let react = require("react");
+//#region src/page-layers.ts
+/**
+* The React side of `@embedpdf/web`'s page layers: a layer says, while it's
+* mounted, which part of its page it paints, and the render layer reads which
+* parts are painted, to leave them out of the page's picture.
+*/
+/**
+* Say, while mounted, that this layer paints `part` of its page (`pageRef`,
+* the page context's `ref`). Said in an insertion effect, which runs before
+* any layout effect of the same commit, so a render layer mounted alongside
+* already plans its tiles without it.
+*/
+function usePaintsPagePart(pageRef, part) {
+	(0, react.useInsertionEffect)(() => (0, _embedpdf_web.pageLayersOf)(pageRef).paint(part), [pageRef, part]);
+}
+/** Which parts of the page (`pageRef`, the page context's `ref`) the layers on it paint. */
+function usePaintedParts(pageRef) {
+	const layers = (0, _embedpdf_web.pageLayersOf)(pageRef);
+	return (0, react.useSyncExternalStore)(layers.subscribe, layers.painted, layers.painted);
+}
+//#endregion
+Object.defineProperty(exports, "usePaintedParts", {
+	enumerable: true,
+	get: function() {
+		return usePaintedParts;
+	}
+});
+Object.defineProperty(exports, "usePaintsPagePart", {
+	enumerable: true,
+	get: function() {
+		return usePaintsPagePart;
+	}
+});
+
+//# sourceMappingURL=page-layers-BloZDoOV.cjs.map

package/dist/page-layers-BloZDoOV.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-layers-BloZDoOV.cjs","names":[],"sources":["../src/page-layers.ts"],"sourcesContent":["/**\n * The React side of `@embedpdf/web`'s page layers: a layer says, while it's\n * mounted, which part of its page it paints, and the render layer reads which\n * parts are painted, to leave them out of the page's picture.\n */\nimport { pageLayersOf, type PagePart, type PaintedParts } from '@embedpdf/web';\nimport { useInsertionEffect, useSyncExternalStore } from 'react';\n\n/**\n * Say, while mounted, that this layer paints `part` of its page (`pageRef`,\n * the page context's `ref`). Said in an insertion effect, which runs before\n * any layout effect of the same commit, so a render layer mounted alongside\n * already plans its tiles without it.\n */\nexport function usePaintsPagePart(pageRef: object, part: PagePart): void {\n  useInsertionEffect(() => pageLayersOf(pageRef).paint(part), [pageRef, part]);\n}\n\n/** Which parts of the page (`pageRef`, the page context's `ref`) the layers on it paint. */\nexport function usePaintedParts(pageRef: object): PaintedParts {\n  const layers = pageLayersOf(pageRef);\n  return useSyncExternalStore(layers.subscribe, layers.painted, layers.painted);\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,SAAgB,kBAAkB,SAAiB,MAAsB;CACvE,CAAA,GAAA,MAAA,mBAAA,QAAA,GAAA,cAAA,aAAA,CAAsC,OAAO,CAAC,CAAC,MAAM,IAAI,GAAG,CAAC,SAAS,IAAI,CAAC;AAC7E;;AAGA,SAAgB,gBAAgB,SAA+B;CAC7D,MAAM,UAAA,GAAA,cAAA,aAAA,CAAsB,OAAO;CACnC,QAAA,GAAA,MAAA,qBAAA,CAA4B,OAAO,WAAW,OAAO,SAAS,OAAO,OAAO;AAC9E"}