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

package/dist/runtime-BfnpyfY0.cjs

@@ -0,0 +1,556 @@
+const require_rolldown_runtime = require("./rolldown-runtime-DDXJien1.cjs");
+let react_jsx_runtime = require("react/jsx-runtime");
+let _embedpdf_core = require("@embedpdf/core");
+let _embedpdf_web = require("@embedpdf/web");
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react, 1);
+//#region src/theme.ts
+/**
+* The CSS variables of a theme, for a `style` prop: `<div style={epdfTheme({ accent })}>`.
+* Everything inside the element follows them, and a CSS variable wins over any setting.
+*/
+function epdfTheme(theme) {
+	return (0, _embedpdf_web.epdfThemeVariables)(theme);
+}
+//#endregion
+//#region src/dev.ts
+/**
+* Development-time guardrails. Every warning fires once per process (keyed),
+* says what is wrong and what to do instead, and compiles out of production
+* builds ({@link isDev}).
+*/
+const warned = /* @__PURE__ */ new Set();
+/**
+* Whether this is a development build, as the app's bundler says: every bundler replaces
+* `process.env.NODE_ENV`, with `"production"` in a production build, so there this is `false`
+* and the warnings behind it compile out. A page with no bundler has no `process` at all, and
+* counts as development: the warnings help most while you try the package out.
+*/
+function isDev() {
+	try {
+		return process.env.NODE_ENV !== "production";
+	} catch {
+		return true;
+	}
+}
+/** Warn once per key. No-op in production. */
+function devWarn(key, message) {
+	if (!isDev() || warned.has(key)) return;
+	warned.add(key);
+	console.warn(`[embedpdf] ${message}`);
+}
+//#endregion
+//#region src/runtime.tsx
+const KernelCtx = (0, react.createContext)(null);
+/** The document a subtree is bound to. null => use the active document. */
+const DocumentScopeCtx = (0, react.createContext)(null);
+function useKernel() {
+	const kernel = (0, react.useContext)(KernelCtx);
+	if (!kernel) throw new Error("useKernel must be used within <Viewer>/<EmbedPDF>");
+	return kernel;
+}
+/**
+* Give a subtree a kernel someone else created and owns, so every hook in it
+* works against that kernel. The full viewer's wrapper puts the children it
+* slots into the viewer inside one. The provider never starts or destroys the
+* kernel; `<Viewer>` is the component that owns one.
+*/
+function KernelProvider({ kernel, children }) {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(KernelCtx.Provider, {
+		value: kernel,
+		children
+	});
+}
+const shallowArray = (left, right) => left === right || left.length === right.length && left.every((item, i) => item === right[i]);
+/** Read a value derived from the kernel, cached by equality (no tearing loop). */
+function useKernelValue(select, isEqual = Object.is) {
+	const kernel = useKernel();
+	const last = (0, react.useRef)(null);
+	const get = () => {
+		const next = select(kernel);
+		if (last.current && isEqual(last.current.v, next)) return last.current.v;
+		last.current = { v: next };
+		return next;
+	};
+	return (0, react.useSyncExternalStore)(kernel.subscribe, get, get);
+}
+function useActiveDocumentId() {
+	return useKernelValue((kernel) => kernel.documents.getActiveId());
+}
+/** The document id for this subtree: the nearest <DocumentScope>, else the active doc. */
+function useDocumentId() {
+	const scoped = useDocumentScope();
+	const active = useActiveDocumentId();
+	return scoped ?? active;
+}
+/**
+* The document the nearest <DocumentScope> binds this subtree to, or null when
+* it follows the active document. For resolvers that pass it to
+* `kernel.tryCapability`, which reads the active document at call time; UI
+* that needs the id itself uses {@link useDocumentId}.
+*/
+function useDocumentScope() {
+	return (0, react.useContext)(DocumentScopeCtx);
+}
+/** Bind a subtree to a specific document (panes, comparison). */
+function DocumentScope({ id, children }) {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(DocumentScopeCtx.Provider, {
+		value: id,
+		children
+	});
+}
+/**
+* Render children only while this subtree has a ready document — the
+* structural way to say "this UI is defined over a document". An empty
+* workspace is a legitimate, designable state (the Viewer no longer blocks on
+* documents so chrome can render at t≈0): workspace-scoped UI (toolbars,
+* commands, i18n) lives outside the gate; document-scoped UI (Stage, panels,
+* page chrome) lives inside it. A document that waits for its password, or
+* failed, renders `locked` or `error` with it, or else `fallback`. Sibling of
+* <DocumentScope>, which picks which document; this one handles whether.
+*/
+function DocumentGate({ fallback = null, locked, error, children }) {
+	const document = useDocument();
+	if (document.status === "ready") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children });
+	if (document.status === "locked" && locked) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: locked(document) });
+	if (document.status === "error" && error) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: error(document) });
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: fallback });
+}
+/**
+* Resolve a capability by token, binding document-scoped ones to this
+* subtree's document. Resolution is a reactive read (`tryCapability` through
+* the kernel's one change stream), not a memoized call — under the
+* request-time lifecycle a document can become resolvable while its id stays
+* the same, so any id-keyed cache goes stale; subscribing makes staleness
+* structurally impossible.
+*
+* Outside a document (none open, not ready yet, or none in scope), a document
+* plugin resolves to its stand-in (`standInFor` from `@embedpdf/core`):
+* rendering never fails, and a method called too early refuses with
+* `not-ready` (a method that returns a promise rejects). A token no plugin
+* provides still throws the kernel's reason, because that is a setup mistake.
+*/
+function useCapability(token) {
+	const kernel = useKernel();
+	const capability = useOptionalCapability(token);
+	if (capability) return capability;
+	if (kernel.scopeOf(token) === "document") return (0, _embedpdf_core.standInFor)(kernel, token);
+	return kernel.capability(token);
+}
+/** Like `useCapability`, but null while the token can't resolve (no plugin,
+*  no document, or a document that isn't ready yet). */
+function useOptionalCapability(token) {
+	const scoped = useDocumentScope();
+	return useKernelValue((kernel) => kernel.tryCapability(token, scoped ?? void 0));
+}
+/**
+* Subscribe to a selector over a (document-resolved) capability. Strict:
+* while the token can't resolve, it throws the kernel's reason (`no
+* document`, `document is loading`), for code that knows a document exists,
+* such as anything inside a <DocumentGate>. `useOptionalSelector` is its
+* total twin.
+*/
+function useSelector(token, select, isEqual = Object.is) {
+	const kernel = useKernel();
+	const scoped = useDocumentScope();
+	const capability = useOptionalCapability(token) ?? kernel.capability(token, scoped ?? void 0);
+	const last = (0, react.useRef)(null);
+	const get = () => {
+		const next = select(capability);
+		if (last.current && isEqual(last.current.v, next)) return last.current.v;
+		last.current = { v: next };
+		return next;
+	};
+	return (0, react.useSyncExternalStore)(kernel.subscribe, get, get);
+}
+/**
+* Null-safe `useSelector`: `fallback` whenever the token can't resolve — no
+* provider, or a document-scoped token with no document. For chrome that stays
+* mounted across the empty-workspace state (a zoom readout, a mode band).
+*
+* The `select` guard also swallows reads through a capability whose document
+* closed between the store notification and this render — that teardown race
+* resolves to `fallback` for one frame, then re-renders against the new state.
+*/
+function useOptionalSelector(token, select, fallback, isEqual = Object.is) {
+	const kernel = useKernel();
+	const capability = useOptionalCapability(token);
+	const last = (0, react.useRef)(null);
+	const get = () => {
+		let next;
+		if (capability === null) next = fallback;
+		else try {
+			next = select(capability);
+		} catch {
+			next = fallback;
+		}
+		if (last.current && isEqual(last.current.v, next)) return last.current.v;
+		last.current = { v: next };
+		return next;
+	};
+	return (0, react.useSyncExternalStore)(kernel.subscribe, get, get);
+}
+/**
+* Subscribe to a capability's {@link EventHook} for the mounted lifetime —
+* `useCapabilityEvent(ActionsToken, (actions) => actions.onExecuted, handler)`. Events
+* carry occurrences, never state (a late subscriber that needs the current
+* value uses `useSelector`). The handler rides a ref, so a fresh closure per
+* render never resubscribes. Null-safe: no plugin/document → no subscription.
+*/
+function useCapabilityEvent(token, select, handler) {
+	const capability = useOptionalCapability(token);
+	const handlerRef = (0, react.useRef)(handler);
+	handlerRef.current = handler;
+	const selectRef = (0, react.useRef)(select);
+	selectRef.current = select;
+	(0, react.useEffect)(() => {
+		if (!capability) return;
+		return selectRef.current(capability)((event) => handlerRef.current(event));
+	}, [capability]);
+}
+/**
+* The documents API: open, close, unlock, download, and the tabs. Inside a
+* <DocumentScope>, the calls that leave out the document use that one, so
+* `download()` without an id downloads the document in scope. The object
+* never changes, so it's safe in effects and callbacks. What to show comes
+* from `useDocument()` and `useDocumentsState()`.
+*/
+function useDocuments() {
+	return useCapability(_embedpdf_core.DocumentsToken);
+}
+/** Read a state declaration's value through the kernel, or the value `select` picks from it. */
+function useDeclared(token, read, empty, select) {
+	const scoped = useDocumentScope();
+	return useKernelValue((kernel) => {
+		const capability = kernel.tryCapability(token, scoped ?? void 0);
+		const state = capability ? read(capability) : empty;
+		return select ? select(state) : state;
+	}, _embedpdf_core.shallowEqual);
+}
+/**
+* The document this component talks to: the one its <DocumentScope> names, or
+* else the active one. Its `id`, `name`, `status`, `pageCount`,
+* `hasUnsavedChanges`, and why it's locked or failed. With no document, an
+* empty one that reads as still opening. Takes a selector, and re-renders only
+* when what it returns changes.
+*/
+function useDocument(select) {
+	return useDeclared(_embedpdf_core.DocumentsToken, _embedpdf_core.documentState.read, _embedpdf_core.documentState.empty, select);
+}
+/**
+* Every open document, in tab order (loading, locked and failed ones too),
+* and the active one's id. Takes a selector, and re-renders only when what it
+* returns changes.
+*/
+function useDocumentsState(select) {
+	return useDeclared(_embedpdf_core.DocumentsToken, _embedpdf_core.documentsState.read, _embedpdf_core.documentsState.empty, select);
+}
+/** Subscribe to one documents event for the mounted lifetime: `useDocumentsEvent((documents) => documents.onOpened, handler)`. */
+function useDocumentsEvent(select, handler) {
+	useCapabilityEvent(_embedpdf_core.DocumentsToken, select, handler);
+}
+const NO_PAGES = Object.freeze([]);
+/**
+* The pages of the document this component talks to, in order: each with its
+* `ref`, `index`, `label`, size and rotation. Needs no Stage, so a thumbnail
+* list or a page picker works anywhere. The same array until a page is added,
+* removed, moved or rotated; empty with no document.
+*/
+function usePageList() {
+	const documentId = useDocumentId();
+	return useKernelValue((kernel) => documentId ? kernel.documents.listPages(documentId) : NO_PAGES);
+}
+/**
+* The viewer's own settings (`<Viewer identity scope accent page>`), or the
+* value `select` picks from them: the accent every part without a color of its
+* own follows, and how pages look. What paints a page or an accent reads it
+* here, through `paint()` from `@embedpdf/web`, so a CSS variable still wins.
+*/
+function useViewerSettings(select) {
+	return useKernelValue((kernel) => {
+		const settings = kernel.getSettings();
+		return select ? select(settings) : settings;
+	}, _embedpdf_core.shallowEqual);
+}
+/**
+* Owns the kernel as an effect-scoped resource: each effect setup creates and
+* starts exactly one kernel; each cleanup destroys exactly that one. That is
+* the contract StrictMode exercises (two kernels in dev, the first fully
+* destroyed) — the kernel itself is never restarted after destroy.
+*
+* The kernel is published to context the moment it exists — before `start()`
+* resolves — so the `fallback` can use workspace capabilities (i18n copy on a
+* loading screen). The one exception is the very first render, which happens
+* before the effect: it renders nothing. Children mount once `start()` resolves
+* — which never touches the engine, so the shell is alive while WASM compiles
+* or the transport connects. `initialDocuments` open in the background and
+* stream into the registry (`useDocuments()` is reactive); per-document
+* loading UI is the Stage's job, not a root gate.
+*
+* Engine ownership. When `engine` is a thunk, the Viewer owns it: each effect
+* setup constructs one engine (construction is synchronous and inert — boot
+* happens lazily inside the engine) and each cleanup destroys exactly that one
+* — after the kernel, so handles close first. When `engine` is an instance it
+* is borrowed and never destroyed here; the Viewer only warms up a local
+* engine so the WASM boot overlaps plugin initialization. StrictMode's
+* double-mount therefore constructs two independent thunk engines and tears
+* the first fully down, matching the kernel's own effect-scoped lifecycle.
+* That means dev-only double resource use (two worker spawns, two font
+* fetches, briefly overlapping) — deliberate, because it is exactly the
+* leak-detection contract StrictMode exists to exercise; production mounts
+* once and boots once.
+*/
+const Viewer = (0, react.forwardRef)(function Viewer({ engine, plugins, initialDocuments, fallback, renderError, onReady, identity, scope, accent, page, children }, ref) {
+	const initial = (0, react.useRef)({
+		engine,
+		plugins,
+		initialDocuments
+	});
+	const settings = (0, _embedpdf_core.viewerSettingsOf)({
+		identity,
+		scope,
+		accent,
+		page
+	});
+	const latestSettings = (0, react.useRef)(settings);
+	latestSettings.current = settings;
+	const warned = (0, react.useRef)(false);
+	if (isDev() && !warned.current) {
+		if (initial.current.engine !== engine || initial.current.plugins !== plugins) {
+			warned.current = true;
+			console.warn("[embedpdf] <Viewer> engine/plugins are init-only. A changed identity is ignored — pass stable references (module scope, useState, or useMemo). An inline `plugins={[...]}` array recreates its identity every render.");
+		}
+	}
+	const [boot, setBoot] = (0, react.useState)({
+		phase: "booting",
+		kernel: null
+	});
+	const onReadyRef = (0, react.useRef)(onReady);
+	onReadyRef.current = onReady;
+	(0, react.useImperativeHandle)(ref, () => boot.phase === "ready" ? boot.kernel : null, [boot]);
+	(0, react.useEffect)(() => {
+		const captured = initial.current;
+		const ownsEngine = typeof captured.engine === "function";
+		const engine = ownsEngine ? captured.engine() : captured.engine;
+		if ((0, _embedpdf_core.isLocalEngine)(engine)) engine.warmup();
+		let kernel;
+		try {
+			kernel = (0, _embedpdf_core.createKernel)({
+				engine,
+				plugins: captured.plugins,
+				settings: latestSettings.current,
+				clock: (0, _embedpdf_web.browserClock)(),
+				printer: (0, _embedpdf_web.browserPrinter)()
+			});
+		} catch (error) {
+			setBoot({
+				phase: "error",
+				error
+			});
+			if (ownsEngine) engine.destroy();
+			return;
+		}
+		let alive = true;
+		setBoot({
+			phase: "booting",
+			kernel
+		});
+		kernel.start().then(() => {
+			if (!alive) return;
+			onReadyRef.current?.(kernel);
+			setBoot({
+				phase: "ready",
+				kernel
+			});
+			kernel.documents.openAll(captured.initialDocuments ?? []);
+		}, (error) => {
+			if (alive) setBoot({
+				phase: "error",
+				error
+			});
+		});
+		return () => {
+			alive = false;
+			kernel.destroy().then(() => {
+				if (ownsEngine) engine.destroy();
+			});
+		};
+	}, []);
+	const liveKernel = boot.phase === "error" ? null : boot.kernel;
+	(0, react.useEffect)(() => {
+		liveKernel?.updateSettings(latestSettings.current);
+	});
+	if (boot.phase === "error") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: renderError ? renderError(boot.error) : null });
+	if (!boot.kernel) return null;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(KernelCtx.Provider, {
+		value: boot.kernel,
+		children: boot.phase === "ready" ? children : fallback ?? null
+	});
+});
+const EmbedPDF = Viewer;
+const PageCtx = (0, react.createContext)(null);
+const PageProvider = PageCtx.Provider;
+function usePage() {
+	const context = (0, react.useContext)(PageCtx);
+	if (!context) throw new Error("usePage must be used inside <PageView> or a <Stage> page");
+	return context;
+}
+//#endregion
+Object.defineProperty(exports, "DocumentGate", {
+	enumerable: true,
+	get: function() {
+		return DocumentGate;
+	}
+});
+Object.defineProperty(exports, "DocumentScope", {
+	enumerable: true,
+	get: function() {
+		return DocumentScope;
+	}
+});
+Object.defineProperty(exports, "EmbedPDF", {
+	enumerable: true,
+	get: function() {
+		return EmbedPDF;
+	}
+});
+Object.defineProperty(exports, "KernelProvider", {
+	enumerable: true,
+	get: function() {
+		return KernelProvider;
+	}
+});
+Object.defineProperty(exports, "PageProvider", {
+	enumerable: true,
+	get: function() {
+		return PageProvider;
+	}
+});
+Object.defineProperty(exports, "Viewer", {
+	enumerable: true,
+	get: function() {
+		return Viewer;
+	}
+});
+Object.defineProperty(exports, "devWarn", {
+	enumerable: true,
+	get: function() {
+		return devWarn;
+	}
+});
+Object.defineProperty(exports, "epdfTheme", {
+	enumerable: true,
+	get: function() {
+		return epdfTheme;
+	}
+});
+Object.defineProperty(exports, "shallowArray", {
+	enumerable: true,
+	get: function() {
+		return shallowArray;
+	}
+});
+Object.defineProperty(exports, "useActiveDocumentId", {
+	enumerable: true,
+	get: function() {
+		return useActiveDocumentId;
+	}
+});
+Object.defineProperty(exports, "useCapability", {
+	enumerable: true,
+	get: function() {
+		return useCapability;
+	}
+});
+Object.defineProperty(exports, "useCapabilityEvent", {
+	enumerable: true,
+	get: function() {
+		return useCapabilityEvent;
+	}
+});
+Object.defineProperty(exports, "useDocument", {
+	enumerable: true,
+	get: function() {
+		return useDocument;
+	}
+});
+Object.defineProperty(exports, "useDocumentId", {
+	enumerable: true,
+	get: function() {
+		return useDocumentId;
+	}
+});
+Object.defineProperty(exports, "useDocumentScope", {
+	enumerable: true,
+	get: function() {
+		return useDocumentScope;
+	}
+});
+Object.defineProperty(exports, "useDocuments", {
+	enumerable: true,
+	get: function() {
+		return useDocuments;
+	}
+});
+Object.defineProperty(exports, "useDocumentsEvent", {
+	enumerable: true,
+	get: function() {
+		return useDocumentsEvent;
+	}
+});
+Object.defineProperty(exports, "useDocumentsState", {
+	enumerable: true,
+	get: function() {
+		return useDocumentsState;
+	}
+});
+Object.defineProperty(exports, "useKernel", {
+	enumerable: true,
+	get: function() {
+		return useKernel;
+	}
+});
+Object.defineProperty(exports, "useKernelValue", {
+	enumerable: true,
+	get: function() {
+		return useKernelValue;
+	}
+});
+Object.defineProperty(exports, "useOptionalCapability", {
+	enumerable: true,
+	get: function() {
+		return useOptionalCapability;
+	}
+});
+Object.defineProperty(exports, "useOptionalSelector", {
+	enumerable: true,
+	get: function() {
+		return useOptionalSelector;
+	}
+});
+Object.defineProperty(exports, "usePage", {
+	enumerable: true,
+	get: function() {
+		return usePage;
+	}
+});
+Object.defineProperty(exports, "usePageList", {
+	enumerable: true,
+	get: function() {
+		return usePageList;
+	}
+});
+Object.defineProperty(exports, "useSelector", {
+	enumerable: true,
+	get: function() {
+		return useSelector;
+	}
+});
+Object.defineProperty(exports, "useViewerSettings", {
+	enumerable: true,
+	get: function() {
+		return useViewerSettings;
+	}
+});
+
+//# sourceMappingURL=runtime-BfnpyfY0.cjs.map

package/dist/runtime-BfnpyfY0.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-BfnpyfY0.cjs","names":["DocumentsToken","shallowEqual","documentState","documentsState"],"sources":["../src/theme.ts","../src/dev.ts","../src/runtime.tsx"],"sourcesContent":["/**\n * `epdfTheme()`: a theme written with setting names, as a style for the\n * element around your viewer. The variables and their lookup are framework-free\n * (`@embedpdf/web`); this only types the result as React's style.\n */\nimport type * as React from 'react';\nimport { epdfThemeVariables, type EpdfTheme } from '@embedpdf/web';\n\nexport type { EpdfTheme } from '@embedpdf/web';\n\n/**\n * The CSS variables of a theme, for a `style` prop: `<div style={epdfTheme({ accent })}>`.\n * Everything inside the element follows them, and a CSS variable wins over any setting.\n */\nexport function epdfTheme(theme: EpdfTheme): React.CSSProperties {\n  return epdfThemeVariables(theme) as React.CSSProperties;\n}\n","/**\n * Development-time guardrails. Every warning fires once per process (keyed),\n * says what is wrong and what to do instead, and compiles out of production\n * builds ({@link isDev}).\n */\nconst warned = new Set<string>();\n\n/**\n * Whether this is a development build, as the app's bundler says: every bundler replaces\n * `process.env.NODE_ENV`, with `\"production\"` in a production build, so there this is `false`\n * and the warnings behind it compile out. A page with no bundler has no `process` at all, and\n * counts as development: the warnings help most while you try the package out.\n */\nexport function isDev(): boolean {\n  try {\n    return process.env.NODE_ENV !== 'production';\n  } catch {\n    return true;\n  }\n}\n\n/** Warn once per key. No-op in production. */\nexport function devWarn(key: string, message: string): void {\n  if (!isDev() || warned.has(key)) return;\n  warned.add(key);\n  console.warn(`[embedpdf] ${message}`);\n}\n\n/** Test seam: forget every warning so a suite can assert one fires again. */\nexport function resetDevWarnings(): void {\n  warned.clear();\n}\n","/**\n * @embedpdf/react — the generic binding.\n *\n * Binds the kernel's one change stream to React (useSyncExternalStore), resolves\n * capabilities (document-scoped ones against the active or `<DocumentScope>`-given\n * document, with a stand-in while there is none), and provides the page\n * coordinate context. Every plugin and layer rides on this — there is no\n * per-plugin framework code.\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/core';\n// What a page with a viewer needs from the browser: handing bytes to the user as a download,\n// and a font the engine draws with, for text you draw yourself.\nexport { mountWebFont, saveFile } from '@embedpdf/web';\n// The page context every layer draws through; its conversions are shared with every framework.\nexport { makePageContext } from '@embedpdf/web';\n// A theme written with setting names, as the style for the element around a viewer.\nexport { epdfTheme } from './theme';\nexport type { EpdfTheme } from './theme';\nimport * as React from 'react';\nimport {\n  createContext,\n  forwardRef,\n  useContext,\n  useEffect,\n  useImperativeHandle,\n  useRef,\n  useState,\n  useSyncExternalStore,\n} from 'react';\nimport {\n  DocumentsToken,\n  createKernel,\n  documentState,\n  documentsState,\n  isLocalEngine,\n  shallowEqual,\n  standInFor,\n  viewerSettingsOf,\n} from '@embedpdf/core';\nimport type {\n  AnyPlugin,\n  CapabilityToken,\n  DocumentInfo,\n  DocumentsCapability,\n  DocumentsState,\n  Engine,\n  EngineFactory,\n  EventHook,\n  FailedDocumentInfo,\n  Identity,\n  InitialDocument,\n  Kernel,\n  LockedDocumentInfo,\n  PageInfo,\n  ViewerPageSettings,\n  ViewerSettings,\n} from '@embedpdf/core';\n// Pure coordinate math from the geometry base — not from stage-core. The\n// PageContext seam stays stage-agnostic (it must also serve standalone PageView).\nimport type { PageTransform } from '@embedpdf/core-geometry';\nimport type { PageViewDemand } from '@embedpdf/plugin-render/contract';\nimport { browserClock, browserPrinter } from '@embedpdf/web';\nimport type { PageContext } from '@embedpdf/web';\n\nimport { isDev } from './dev';\n\nconst KernelCtx = createContext<Kernel | null>(null);\n/** The document a subtree is bound to. null => use the active document. */\nconst DocumentScopeCtx = createContext<string | null>(null);\n\nexport function useKernel(): Kernel {\n  const kernel = useContext(KernelCtx);\n  if (!kernel) throw new Error('useKernel must be used within <Viewer>/<EmbedPDF>');\n  return kernel;\n}\n\nexport interface KernelProviderProps {\n  kernel: Kernel;\n  children?: React.ReactNode;\n}\n/**\n * Give a subtree a kernel someone else created and owns, so every hook in it\n * works against that kernel. The full viewer's wrapper puts the children it\n * slots into the viewer inside one. The provider never starts or destroys the\n * kernel; `<Viewer>` is the component that owns one.\n */\nexport function KernelProvider({ kernel, children }: KernelProviderProps) {\n  return <KernelCtx.Provider value={kernel}>{children}</KernelCtx.Provider>;\n}\n\nexport const shallowArray = <T,>(left: readonly T[], right: readonly T[]): boolean =>\n  left === right || (left.length === right.length && left.every((item, i) => item === right[i]));\n\n/** Read a value derived from the kernel, cached by equality (no tearing loop). */\nexport function useKernelValue<R>(\n  select: (kernel: Kernel) => R,\n  isEqual: (left: R, right: R) => boolean = Object.is,\n): R {\n  const kernel = useKernel();\n  const last = useRef<{ v: R } | null>(null);\n  const get = () => {\n    const next = select(kernel);\n    if (last.current && isEqual(last.current.v, next)) return last.current.v;\n    last.current = { v: next };\n    return next;\n  };\n  return useSyncExternalStore(kernel.subscribe, get, get);\n}\n\nexport function useActiveDocumentId(): string | null {\n  return useKernelValue((kernel) => kernel.documents.getActiveId());\n}\n\n/** The document id for this subtree: the nearest <DocumentScope>, else the active doc. */\nexport function useDocumentId(): string | null {\n  const scoped = useDocumentScope();\n  const active = useActiveDocumentId();\n  return scoped ?? active;\n}\n\n/**\n * The document the nearest <DocumentScope> binds this subtree to, or null when\n * it follows the active document. For resolvers that pass it to\n * `kernel.tryCapability`, which reads the active document at call time; UI\n * that needs the id itself uses {@link useDocumentId}.\n */\nexport function useDocumentScope(): string | null {\n  return useContext(DocumentScopeCtx);\n}\n\nexport interface DocumentScopeProps {\n  id: string;\n  children: React.ReactNode;\n}\n/** Bind a subtree to a specific document (panes, comparison). */\nexport function DocumentScope({ id, children }: DocumentScopeProps) {\n  return <DocumentScopeCtx.Provider value={id}>{children}</DocumentScopeCtx.Provider>;\n}\n\nexport interface DocumentGateProps {\n  /** Shown while this subtree has no document: none is open, or it's still opening. */\n  fallback?: React.ReactNode;\n  /** Shown while the document waits for its password; `fallback` without it. */\n  locked?: (document: LockedDocumentInfo) => React.ReactNode;\n  /** Shown when the document couldn't be opened, with why; `fallback` without it. */\n  error?: (document: FailedDocumentInfo) => React.ReactNode;\n  children?: React.ReactNode;\n}\n/**\n * Render children only while this subtree has a ready document — the\n * structural way to say \"this UI is defined over a document\". An empty\n * workspace is a legitimate, designable state (the Viewer no longer blocks on\n * documents so chrome can render at t≈0): workspace-scoped UI (toolbars,\n * commands, i18n) lives outside the gate; document-scoped UI (Stage, panels,\n * page chrome) lives inside it. A document that waits for its password, or\n * failed, renders `locked` or `error` with it, or else `fallback`. Sibling of\n * <DocumentScope>, which picks which document; this one handles whether.\n */\nexport function DocumentGate({ fallback = null, locked, error, children }: DocumentGateProps) {\n  const document = useDocument();\n  if (document.status === 'ready') return <>{children}</>;\n  if (document.status === 'locked' && locked) {\n    return <>{locked(document as LockedDocumentInfo)}</>;\n  }\n  if (document.status === 'error' && error) return <>{error(document as FailedDocumentInfo)}</>;\n  return <>{fallback}</>;\n}\n\n/**\n * Resolve a capability by token, binding document-scoped ones to this\n * subtree's document. Resolution is a reactive read (`tryCapability` through\n * the kernel's one change stream), not a memoized call — under the\n * request-time lifecycle a document can become resolvable while its id stays\n * the same, so any id-keyed cache goes stale; subscribing makes staleness\n * structurally impossible.\n *\n * Outside a document (none open, not ready yet, or none in scope), a document\n * plugin resolves to its stand-in (`standInFor` from `@embedpdf/core`):\n * rendering never fails, and a method called too early refuses with\n * `not-ready` (a method that returns a promise rejects). A token no plugin\n * provides still throws the kernel's reason, because that is a setup mistake.\n */\nexport function useCapability<T>(token: CapabilityToken<T>): T {\n  const kernel = useKernel();\n  const capability = useOptionalCapability(token);\n  if (capability) return capability;\n  if (kernel.scopeOf(token) === 'document') return standInFor(kernel, token);\n  return kernel.capability(token);\n}\n\n/** Like `useCapability`, but null while the token can't resolve (no plugin,\n *  no document, or a document that isn't ready yet). */\nexport function useOptionalCapability<T>(token: CapabilityToken<T>): T | null {\n  const scoped = useDocumentScope();\n  return useKernelValue((kernel) => kernel.tryCapability(token, scoped ?? undefined));\n}\n\n/**\n * Subscribe to a selector over a (document-resolved) capability. Strict:\n * while the token can't resolve, it throws the kernel's reason (`no\n * document`, `document is loading`), for code that knows a document exists,\n * such as anything inside a <DocumentGate>. `useOptionalSelector` is its\n * total twin.\n */\nexport function useSelector<C, R>(\n  token: CapabilityToken<C>,\n  select: (capability: C) => R,\n  isEqual: (left: R, right: R) => boolean = Object.is,\n): R {\n  const kernel = useKernel();\n  const scoped = useDocumentScope();\n  const capability = useOptionalCapability(token) ?? kernel.capability(token, scoped ?? undefined);\n  const last = useRef<{ v: R } | null>(null);\n  const get = () => {\n    const next = select(capability);\n    if (last.current && isEqual(last.current.v, next)) return last.current.v;\n    last.current = { v: next };\n    return next;\n  };\n  return useSyncExternalStore(kernel.subscribe, get, get);\n}\n\n/**\n * Null-safe `useSelector`: `fallback` whenever the token can't resolve — no\n * provider, or a document-scoped token with no document. For chrome that stays\n * mounted across the empty-workspace state (a zoom readout, a mode band).\n *\n * The `select` guard also swallows reads through a capability whose document\n * closed between the store notification and this render — that teardown race\n * resolves to `fallback` for one frame, then re-renders against the new state.\n */\nexport function useOptionalSelector<C, R>(\n  token: CapabilityToken<C>,\n  select: (capability: C) => R,\n  fallback: R,\n  isEqual: (left: R, right: R) => boolean = Object.is,\n): R {\n  const kernel = useKernel();\n  const capability = useOptionalCapability(token);\n  const last = useRef<{ v: R } | null>(null);\n  const get = () => {\n    let next: R;\n    if (capability === null) {\n      next = fallback;\n    } else {\n      try {\n        next = select(capability);\n      } catch {\n        next = fallback;\n      }\n    }\n    if (last.current && isEqual(last.current.v, next)) return last.current.v;\n    last.current = { v: next };\n    return next;\n  };\n  return useSyncExternalStore(kernel.subscribe, get, get);\n}\n\n/**\n * Subscribe to a capability's {@link EventHook} for the mounted lifetime —\n * `useCapabilityEvent(ActionsToken, (actions) => actions.onExecuted, handler)`. Events\n * carry occurrences, never state (a late subscriber that needs the current\n * value uses `useSelector`). The handler rides a ref, so a fresh closure per\n * render never resubscribes. Null-safe: no plugin/document → no subscription.\n */\nexport function useCapabilityEvent<C, T>(\n  token: CapabilityToken<C>,\n  select: (capability: C) => EventHook<T>,\n  handler: (event: T) => void,\n): void {\n  const capability = useOptionalCapability(token);\n  const handlerRef = useRef(handler);\n  handlerRef.current = handler;\n  const selectRef = useRef(select);\n  selectRef.current = select;\n  useEffect(() => {\n    if (!capability) return;\n    return selectRef.current(capability)((event) => handlerRef.current(event));\n  }, [capability]);\n}\n\n/**\n * The documents API: open, close, unlock, download, and the tabs. Inside a\n * <DocumentScope>, the calls that leave out the document use that one, so\n * `download()` without an id downloads the document in scope. The object\n * never changes, so it's safe in effects and callbacks. What to show comes\n * from `useDocument()` and `useDocumentsState()`.\n */\nexport function useDocuments(): DocumentsCapability {\n  return useCapability(DocumentsToken);\n}\n\n/** Read a state declaration's value through the kernel, or the value `select` picks from it. */\nfunction useDeclared<Capability, State extends object, Selected>(\n  token: CapabilityToken<Capability>,\n  read: (capability: Capability) => State,\n  empty: State,\n  select: ((state: State) => Selected) | undefined,\n): Selected {\n  const scoped = useDocumentScope();\n  return useKernelValue((kernel) => {\n    const capability = kernel.tryCapability(token, scoped ?? undefined);\n    const state = capability ? read(capability) : empty;\n    return select ? select(state) : (state as unknown as Selected);\n  }, shallowEqual);\n}\n\n/**\n * The document this component talks to: the one its <DocumentScope> names, or\n * else the active one. Its `id`, `name`, `status`, `pageCount`,\n * `hasUnsavedChanges`, and why it's locked or failed. With no document, an\n * empty one that reads as still opening. Takes a selector, and re-renders only\n * when what it returns changes.\n */\nexport function useDocument<Selected = DocumentInfo>(\n  select?: (document: DocumentInfo) => Selected,\n): Selected {\n  return useDeclared(DocumentsToken, documentState.read, documentState.empty, select);\n}\n\n/**\n * Every open document, in tab order (loading, locked and failed ones too),\n * and the active one's id. Takes a selector, and re-renders only when what it\n * returns changes.\n */\nexport function useDocumentsState<Selected = DocumentsState>(\n  select?: (state: DocumentsState) => Selected,\n): Selected {\n  return useDeclared(DocumentsToken, documentsState.read, documentsState.empty, select);\n}\n\n/** Subscribe to one documents event for the mounted lifetime: `useDocumentsEvent((documents) => documents.onOpened, handler)`. */\nexport function useDocumentsEvent<T>(\n  select: (documents: DocumentsCapability) => EventHook<T>,\n  handler: (event: T) => void,\n): void {\n  useCapabilityEvent(DocumentsToken, select, handler);\n}\n\nconst NO_PAGES: readonly PageInfo[] = Object.freeze([]);\n\n/**\n * The pages of the document this component talks to, in order: each with its\n * `ref`, `index`, `label`, size and rotation. Needs no Stage, so a thumbnail\n * list or a page picker works anywhere. The same array until a page is added,\n * removed, moved or rotated; empty with no document.\n */\nexport function usePageList(): readonly PageInfo[] {\n  const documentId = useDocumentId();\n  return useKernelValue((kernel) =>\n    documentId ? kernel.documents.listPages(documentId) : NO_PAGES,\n  );\n}\n\n/**\n * The viewer's own settings (`<Viewer identity scope accent page>`), or the\n * value `select` picks from them: the accent every part without a color of its\n * own follows, and how pages look. What paints a page or an accent reads it\n * here, through `paint()` from `@embedpdf/web`, so a CSS variable still wins.\n */\nexport function useViewerSettings<Selected = ViewerSettings>(\n  select?: (settings: ViewerSettings) => Selected,\n): Selected {\n  return useKernelValue((kernel) => {\n    const settings = kernel.getSettings();\n    return select ? select(settings) : (settings as unknown as Selected);\n  }, shallowEqual);\n}\n\n// `InitialDocument` is the kernel's type (re-exported via `export * from\n// '@embedpdf/core'` above) — one shared shape for every adapter.\n\nexport interface ViewerProps {\n  /**\n   * The engine, as an instance or a thunk. Engines construct synchronously and\n   * boot lazily (`localEngine()` allocates nothing until first use), so\n   * ownership follows the shape of what you pass:\n   *\n   *   - An **instance** (`engine={engine}`) is borrowed: the Viewer uses it and\n   *     never destroys it, because you acquired it and therefore own it. The\n   *     common path — a module-scope `const engine = localEngine()` shared\n   *     across viewers and route changes. The Viewer warms up a local engine\n   *     on mount so the boot overlaps app initialization.\n   *   - A **thunk** (`engine={() => localEngine()}`) is viewer-owned: the\n   *     Viewer calls it on mount and `destroy()`s the result on unmount. Use it\n   *     for per-mount isolation (StrictMode/HMR-clean teardown, independent\n   *     multi-viewer engines).\n   *\n   * Init-only: captured on first render; later identity changes are ignored (dev warns).\n   */\n  engine: Engine | EngineFactory;\n  /** Init-only: captured on first render; later identity changes are ignored (dev warns). */\n  plugins: AnyPlugin[];\n  /** Documents to open on startup (with optional tab names). Init-only. */\n  initialDocuments?: InitialDocument[];\n  fallback?: React.ReactNode;\n  /** Rendered when kernel construction or `start()` fails. Without it a boot\n   *  failure renders nothing — but never a silent forever-fallback. */\n  renderError?: (error: unknown) => React.ReactNode;\n  /** Called once the kernel has started — before `children` mount and before\n   *  `initialDocuments` open. The imperative door for code outside React\n   *  (register commands, subscribe events). The `ref` carries the same kernel. */\n  onReady?: (kernel: Kernel) => void;\n  /**\n   * Who the user is, for every document opened without an `identity` of its\n   * own (which replaces this one). Documents opened after a change use the new\n   * value; open ones keep theirs. The local engine only: the cloud engine reads\n   * it from the document's token.\n   */\n  identity?: Identity;\n  /**\n   * What the user may do, as permissions, in every document opened without a\n   * `scope` of its own (which replaces this one). Left out, they may do\n   * everything. Changes reach the documents opened after them, as `identity`.\n   */\n  scope?: readonly string[];\n  /** The color every part without a color of its own follows. CSS `--epdf-accent` wins over it. */\n  accent?: string;\n  /** How pages look: `background` before the picture arrives, and the `shadow` under each page. */\n  page?: Partial<ViewerPageSettings>;\n  children?: React.ReactNode;\n}\n\ntype BootState =\n  | { phase: 'booting'; kernel: Kernel | null }\n  | { phase: 'ready'; kernel: Kernel }\n  | { phase: 'error'; error: unknown };\n\n/**\n * Owns the kernel as an effect-scoped resource: each effect setup creates and\n * starts exactly one kernel; each cleanup destroys exactly that one. That is\n * the contract StrictMode exercises (two kernels in dev, the first fully\n * destroyed) — the kernel itself is never restarted after destroy.\n *\n * The kernel is published to context the moment it exists — before `start()`\n * resolves — so the `fallback` can use workspace capabilities (i18n copy on a\n * loading screen). The one exception is the very first render, which happens\n * before the effect: it renders nothing. Children mount once `start()` resolves\n * — which never touches the engine, so the shell is alive while WASM compiles\n * or the transport connects. `initialDocuments` open in the background and\n * stream into the registry (`useDocuments()` is reactive); per-document\n * loading UI is the Stage's job, not a root gate.\n *\n * Engine ownership. When `engine` is a thunk, the Viewer owns it: each effect\n * setup constructs one engine (construction is synchronous and inert — boot\n * happens lazily inside the engine) and each cleanup destroys exactly that one\n * — after the kernel, so handles close first. When `engine` is an instance it\n * is borrowed and never destroyed here; the Viewer only warms up a local\n * engine so the WASM boot overlaps plugin initialization. StrictMode's\n * double-mount therefore constructs two independent thunk engines and tears\n * the first fully down, matching the kernel's own effect-scoped lifecycle.\n * That means dev-only double resource use (two worker spawns, two font\n * fetches, briefly overlapping) — deliberate, because it is exactly the\n * leak-detection contract StrictMode exists to exercise; production mounts\n * once and boots once.\n */\nexport const Viewer = forwardRef<Kernel | null, ViewerProps>(function Viewer(\n  {\n    engine,\n    plugins,\n    initialDocuments,\n    fallback,\n    renderError,\n    onReady,\n    identity,\n    scope,\n    accent,\n    page,\n    children,\n  }: ViewerProps,\n  ref,\n) {\n  // Init-only inputs: the kernel's lifetime is the component's lifetime, so a\n  // changed engine/plugins identity cannot mean \"rebuild the workspace\" —\n  // that would silently drop every open document. Capture once, warn in dev.\n  const initial = useRef({ engine, plugins, initialDocuments });\n  // The viewer's settings follow the props. The first ones go to the kernel when it's\n  // created, so the initial documents open with them; later ones as they change.\n  const settings = viewerSettingsOf({ identity, scope, accent, page });\n  const latestSettings = useRef(settings);\n  latestSettings.current = settings;\n  const warned = useRef(false);\n  if (isDev() && !warned.current) {\n    if (initial.current.engine !== engine || initial.current.plugins !== plugins) {\n      warned.current = true;\n      console.warn(\n        '[embedpdf] <Viewer> engine/plugins are init-only. A changed identity is ignored — ' +\n          'pass stable references (module scope, useState, or useMemo). ' +\n          'An inline `plugins={[...]}` array recreates its identity every render.',\n      );\n    }\n  }\n\n  const [boot, setBoot] = useState<BootState>({ phase: 'booting', kernel: null });\n  const onReadyRef = useRef(onReady);\n  onReadyRef.current = onReady;\n  // The ref is the started kernel (null before boot and after an error).\n  useImperativeHandle<Kernel | null, Kernel | null>(\n    ref,\n    () => (boot.phase === 'ready' ? boot.kernel : null),\n    [boot],\n  );\n  useEffect(() => {\n    const captured = initial.current;\n    // A thunk is viewer-owned: call it now, destroy on unmount. An instance is\n    // borrowed: use as-is, never destroy. Construction is synchronous and inert\n    // either way — the engine boots lazily on first use — so a local engine's\n    // `warmup()` overlaps the WASM boot with plugin initialization.\n    const ownsEngine = typeof captured.engine === 'function';\n    const engine: Engine = ownsEngine\n      ? (captured.engine as EngineFactory)()\n      : (captured.engine as Engine);\n    if (isLocalEngine(engine)) engine.warmup();\n    let kernel: Kernel;\n    try {\n      kernel = createKernel({\n        engine,\n        plugins: captured.plugins,\n        settings: latestSettings.current,\n        clock: browserClock(),\n        printer: browserPrinter(),\n      });\n    } catch (error) {\n      setBoot({ phase: 'error', error }); // plan/graph errors surface, not throw mid-render\n      if (ownsEngine) void engine.destroy();\n      return;\n    }\n    let alive = true;\n    setBoot({ phase: 'booting', kernel }); // context carries the kernel from this frame on\n    kernel.start().then(\n      () => {\n        if (!alive) return; // unmounted mid-boot — don't open anything\n        onReadyRef.current?.(kernel);\n        setBoot({ phase: 'ready', kernel });\n        // Kernel-owned boot policy: all tabs appear immediately in array\n        // order; the `active` entry (else the first) is selected; failures\n        // surface as tab status. See DocumentsCapability.openAll.\n        kernel.documents.openAll(captured.initialDocuments ?? []);\n      },\n      (error) => {\n        if (alive) setBoot({ phase: 'error', error });\n      },\n    );\n    return () => {\n      alive = false;\n      // Kernel first (closes every document handle), then the engine we own —\n      // ownership follows acquisition. `engine.destroy()` joins an in-flight\n      // boot (or no-ops if it never started), so an unmount mid-boot is safe.\n      void kernel.destroy().then(() => {\n        if (ownsEngine) void engine.destroy();\n      });\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  // After every render: props compare by value (an inline `page={{ shadow: 'none' }}` is a new\n  // object each time), and settings that didn't change change nothing.\n  const liveKernel = boot.phase === 'error' ? null : boot.kernel;\n  useEffect(() => {\n    liveKernel?.updateSettings(latestSettings.current);\n  });\n\n  if (boot.phase === 'error') {\n    return <>{renderError ? renderError(boot.error) : null}</>;\n  }\n  if (!boot.kernel) return null; // pre-effect first render only\n  return (\n    <KernelCtx.Provider value={boot.kernel}>\n      {boot.phase === 'ready' ? children : (fallback ?? null)}\n    </KernelCtx.Provider>\n  );\n});\nexport const EmbedPDF = Viewer;\n\n/**\n * PageContext — the seam. A layer depends only on this, never on the Stage. So the\n * same layer works inside a virtualized Stage and in a standalone <PageView>.\n * Its members are documented on `PageContext` in `@embedpdf/web`.\n */\nexport type PageContextValue = PageContext<PageTransform, PageViewDemand>;\n\nconst PageCtx = createContext<PageContextValue | null>(null);\nexport const PageProvider = PageCtx.Provider;\n\nexport function usePage(): PageContextValue {\n  const context = useContext(PageCtx);\n  if (!context) throw new Error('usePage must be used inside <PageView> or a <Stage> page');\n  return context;\n}\n"],"mappings":"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"}