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

package/dist/render/props.d.ts

@@ -0,0 +1,16 @@
+/** The props of `<RenderLayer>`. */
+export interface RenderLayerProps {
+    /**
+     * Draw the annotations into the page's picture (`true`) or leave them out (`false`). Left
+     * unset, the picture leaves them to an `<AnnotationLayer>` on the page, and otherwise draws them
+     * when the user may read them.
+     */
+    annotations?: boolean;
+    /** The same for the form fields, which a `<FormLayer>` paints. */
+    formFields?: boolean;
+    /**
+     * Mount the tile plane (default true). Whether it spends anything is the render plugin's
+     * arithmetic: leave it on, and pass false only for a view that must never tile.
+     */
+    tiles?: boolean;
+}

package/dist/render/props.js

@@ -0,0 +1 @@
+export {};

package/dist/render/readers.svelte.d.ts

@@ -0,0 +1,9 @@
+/** The render plugin's readers: its API, its settings and its events. */
+import type { EventHook } from '@embedpdf/core';
+import type { RenderCapability } from '@embedpdf/plugin-render';
+/** The render API (`renderPage`, `renderThumbnail`, invalidation, settings), for app code. */
+export declare function useRender(): RenderCapability;
+/** The render settings (`fullPage`, `tiles`, `format`, …), with or without a document. */
+export declare const useRenderSettings: import("../index.js").SettingsReader<import("@embedpdf/plugin-render").RenderSettings & object>;
+/** Subscribe to one render event while the component lives: `useRenderEvent((render) => render.onInvalidated, handler)`. */
+export declare function useRenderEvent<T>(select: (render: RenderCapability) => EventHook<T>, handler: (event: T) => void): void;

package/dist/render/readers.svelte.js

@@ -0,0 +1,13 @@
+import { RenderToken } from '@embedpdf/plugin-render';
+import { useCapability, useCapabilityEvent } from '../runtime/readers.svelte.js';
+import { settingsReader } from '../runtime/state.svelte.js';
+/** The render API (`renderPage`, `renderThumbnail`, invalidation, settings), for app code. */
+export function useRender() {
+    return useCapability(RenderToken);
+}
+/** The render settings (`fullPage`, `tiles`, `format`, …), with or without a document. */
+export const useRenderSettings = settingsReader(RenderToken);
+/** Subscribe to one render event while the component lives: `useRenderEvent((render) => render.onInvalidated, handler)`. */
+export function useRenderEvent(select, handler) {
+    useCapabilityEvent(RenderToken, select, handler);
+}

package/dist/render.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @embedpdf/svelte/render — the page raster.
+ *
+ * `<RenderLayer>` draws a page's picture inside a `<Stage>` page or a `<PageView>`; the readers
+ * are the render plugin's API, settings and events, for thumbnails and previews of your own.
+ */
+export * from '@embedpdf/plugin-render';
+export { default as RenderLayer } from './render/RenderLayer.svelte';
+export type { RenderLayerProps } from './render/props.js';
+export { useRender, useRenderEvent, useRenderSettings } from './render/readers.svelte.js';

package/dist/render.js

@@ -0,0 +1,10 @@
+/**
+ * @embedpdf/svelte/render — the page raster.
+ *
+ * `<RenderLayer>` draws a page's picture inside a `<Stage>` page or a `<PageView>`; the readers
+ * are the render plugin's API, settings and events, for thumbnails and previews of your own.
+ */
+// Registration travels with the UI.
+export * from '@embedpdf/plugin-render';
+export { default as RenderLayer } from './render/RenderLayer.svelte';
+export { useRender, useRenderEvent, useRenderSettings } from './render/readers.svelte.js';

package/dist/runtime/DocumentGate.svelte

@@ -0,0 +1,26 @@
+<!--
+  Renders its content only while this subtree has a ready document: the structural way to say
+  "this UI is defined over a document". Workspace UI (toolbars, commands, translations) lives
+  outside the gate; document UI (the Stage, panels, page chrome) inside it. A document that waits
+  for its password, or failed, shows `locked` or `error` with it, or else `fallback`.
+  `<DocumentScope>` picks which document; this decides whether there is one.
+-->
+<script lang="ts">
+  import type { FailedDocumentInfo, LockedDocumentInfo } from '@embedpdf/core';
+  import { useDocument } from './documents.svelte.js';
+  import type { DocumentGateProps } from './props.js';
+
+  let { fallback, locked, error, children }: DocumentGateProps = $props();
+
+  const document = useDocument((info) => info);
+</script>
+
+{#if document.current.status === 'ready'}
+  {@render children?.()}
+{:else if document.current.status === 'locked' && locked}
+  {@render locked(document.current as LockedDocumentInfo)}
+{:else if document.current.status === 'error' && error}
+  {@render error(document.current as FailedDocumentInfo)}
+{:else}
+  {@render fallback?.()}
+{/if}

package/dist/runtime/DocumentGate.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { DocumentGateProps } from './props.js';
+declare const DocumentGate: import("svelte").Component<DocumentGateProps, {}, "">;
+type DocumentGate = ReturnType<typeof DocumentGate>;
+export default DocumentGate;

package/dist/runtime/DocumentScope.svelte

@@ -0,0 +1,14 @@
+<!--
+  Binds everything inside to one document, for panes and side-by-side comparison: the readers and
+  `use<Plugin>()` handles inside talk to `id`, not the active document.
+-->
+<script lang="ts">
+  import { setDocumentScope } from './binding.svelte.js';
+  import type { DocumentScopeProps } from './props.js';
+
+  let { id, children }: DocumentScopeProps = $props();
+
+  setDocumentScope(() => id);
+</script>
+
+{@render children?.()}

package/dist/runtime/DocumentScope.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { DocumentScopeProps } from './props.js';
+declare const DocumentScope: import("svelte").Component<DocumentScopeProps, {}, "">;
+type DocumentScope = ReturnType<typeof DocumentScope>;
+export default DocumentScope;

package/dist/runtime/KernelProvider.svelte

@@ -0,0 +1,33 @@
+<!--
+  Gives everything inside a kernel someone else created and owns, so every reader in it works
+  against that kernel: the full viewer's wrapper puts the components it shows in the viewer inside
+  one. It never starts or destroys the kernel; `<Viewer>` is the component that owns one.
+
+  The kernel is read once, like `<Viewer>`'s engine: to give a subtree another kernel, mount a new
+  provider (`{#key kernel}`).
+-->
+<script lang="ts">
+  import { onDestroy, untrack } from 'svelte';
+  import { KernelBinding, setKernelHolder } from './binding.svelte.js';
+  import { devWarn } from './dev.js';
+  import type { KernelProviderProps } from './props.js';
+
+  let { kernel, children }: KernelProviderProps = $props();
+
+  const binding = new KernelBinding(untrack(() => kernel));
+  setKernelHolder({ binding });
+  // The provider stops following the kernel; the kernel keeps running for its owner.
+  onDestroy(() => binding.dispose());
+
+  $effect(() => {
+    if (kernel !== binding.kernel) {
+      devWarn(
+        'kernel-provider-kernel',
+        '<KernelProvider> reads kernel once; a new value is ignored. To give the subtree another ' +
+          'kernel, mount a new <KernelProvider>, for example inside a {#key kernel} block.',
+      );
+    }
+  });
+</script>
+
+{@render children?.()}

package/dist/runtime/KernelProvider.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { KernelProviderProps } from './props.js';
+declare const KernelProvider: import("svelte").Component<KernelProviderProps, {}, "">;
+type KernelProvider = ReturnType<typeof KernelProvider>;
+export default KernelProvider;

package/dist/runtime/SvgShapes.svelte

@@ -0,0 +1,30 @@
+<!--
+  Scene shapes as SVG elements: `@embedpdf/web`'s element descriptions (`svgShapesOf`), one
+  element each, a clipping `svg` with its children, and the faces their text draws in mounted
+  while they show. The annotation and form layers draw their scenes through it, inside an `<svg>`.
+-->
+<svelte:options namespace="svg" />
+
+<script lang="ts">
+  import { createFontMounts, type SvgShape } from '@embedpdf/web';
+  import SvgShapes from './SvgShapes.svelte';
+
+  let { shapes }: { shapes: readonly SvgShape[] } = $props();
+
+  // The faces of this level's text: a clipping `svg` mounts its own children's.
+  const mounts = createFontMounts();
+  $effect(() => () => mounts.release());
+  $effect(() => {
+    mounts.mount(shapes.flatMap((shape) => (shape.program ? [shape.program] : [])));
+  });
+</script>
+
+{#each shapes as shape, index (index)}
+  <svelte:element this={shape.tag} {...shape.attributes} style:mix-blend-mode={shape.blend}>
+    {#if shape.children}
+      <SvgShapes shapes={shape.children} />
+    {:else if shape.text !== undefined}
+      {shape.text}
+    {/if}
+  </svelte:element>
+{/each}

package/dist/runtime/SvgShapes.svelte.d.ts

@@ -0,0 +1,8 @@
+import { type SvgShape } from '@embedpdf/web';
+import SvgShapes from './SvgShapes.svelte';
+type $$ComponentProps = {
+    shapes: readonly SvgShape[];
+};
+declare const SvgShapes: import("svelte").Component<$$ComponentProps, {}, "">;
+type SvgShapes = ReturnType<typeof SvgShapes>;
+export default SvgShapes;

package/dist/runtime/Viewer.svelte

@@ -0,0 +1,130 @@
+<!--
+  The viewer: owns the kernel for as long as it is mounted, and gives it to everything inside.
+
+  The kernel is made in the browser only, when the viewer mounts (an effect, so server rendering
+  makes nothing). Its fallback shows from then on, with the kernel already in context, so a
+  loading screen can use workspace plugins. The content mounts once `start()` resolves, which
+  never touches the engine: the shell is alive while WASM compiles or the transport connects.
+  `initialDocuments` then open in the background; per-document loading is `<DocumentGate>`'s job.
+
+  Engine ownership follows the shape of `engine`: a function is the viewer's own (made on mount,
+  destroyed after the kernel on unmount), an instance is borrowed (warmed up, never destroyed).
+-->
+<script lang="ts">
+  import { untrack } from 'svelte';
+  import { createKernel, isLocalEngine, viewerSettingsOf } from '@embedpdf/core';
+  import type { Engine, EngineFactory, Kernel, ViewerSettings } from '@embedpdf/core';
+  import { browserClock, browserPrinter } from '@embedpdf/web';
+  import { KernelBinding, setKernelHolder } from './binding.svelte.js';
+  import { isDev } from './dev.js';
+  import type { ViewerProps } from './props.js';
+
+  let {
+    engine,
+    plugins,
+    initialDocuments,
+    onReady,
+    identity,
+    scope,
+    accent,
+    page,
+    fallback,
+    error: renderError,
+    children,
+  }: ViewerProps = $props();
+
+  type Boot =
+    | { phase: 'booting'; binding: KernelBinding | null }
+    | { phase: 'ready'; binding: KernelBinding }
+    | { phase: 'error'; error: unknown };
+
+  let boot = $state.raw<Boot>({ phase: 'booting', binding: null });
+  setKernelHolder({
+    get binding() {
+      return boot.phase === 'error' ? null : boot.binding;
+    },
+  });
+
+  // The viewer's settings as the props give them: a prop left out is its default.
+  const settings = $derived<ViewerSettings>(viewerSettingsOf({ identity, scope, accent, page }));
+
+  // One kernel per mount. Everything is read untracked, so nothing a prop does later runs this
+  // again: `engine`, `plugins` and `initialDocuments` are read once.
+  $effect(() =>
+    untrack(() => {
+      const ownsEngine = typeof engine === 'function';
+      const created: Engine = ownsEngine ? (engine as EngineFactory)() : (engine as Engine);
+      if (isLocalEngine(created)) created.warmup();
+      let kernel: Kernel;
+      try {
+        kernel = createKernel({
+          engine: created,
+          plugins,
+          settings,
+          clock: browserClock(),
+          printer: browserPrinter(),
+        });
+      } catch (error) {
+        // A plugin graph that can't be built shows `error`, not an exception mid-render.
+        boot = { phase: 'error', error };
+        if (ownsEngine) void created.destroy();
+        return;
+      }
+      const binding = new KernelBinding(kernel);
+      const documents = initialDocuments ?? [];
+      let alive = true;
+      boot = { phase: 'booting', binding };
+      kernel.start().then(
+        () => {
+          if (!alive) return; // unmounted while starting: open nothing
+          onReady?.(kernel);
+          boot = { phase: 'ready', binding };
+          // Every tab appears at once in order; the `active` entry (else the first) is selected,
+          // and a failure shows as that tab's status.
+          kernel.documents.openAll(documents);
+        },
+        (error: unknown) => {
+          if (alive) boot = { phase: 'error', error };
+        },
+      );
+      return () => {
+        alive = false;
+        binding.dispose();
+        // The kernel first (it closes every document handle), then the engine we own.
+        void kernel.destroy().then(() => {
+          if (ownsEngine) void created.destroy();
+        });
+      };
+    }),
+  );
+
+  // Later settings reach the kernel as they change; settings that didn't change change nothing.
+  $effect(() => {
+    const next = settings;
+    if (boot.phase !== 'error') boot.binding?.kernel.updateSettings(next);
+  });
+
+  // `engine` and `plugins` are read once: say so when they change after the viewer mounted.
+  const mounted = untrack(() => ({ engine, plugins }));
+  let warned = false;
+  $effect(() => {
+    if (warned || !isDev()) return;
+    if (engine !== mounted.engine || plugins !== mounted.plugins) {
+      warned = true;
+      console.warn(
+        '[embedpdf] <Viewer> reads engine and plugins once, when it mounts; a new value is ignored. ' +
+          'To use other ones, mount a new <Viewer>, for example inside a {#key} block.',
+      );
+    }
+  });
+</script>
+
+{#if boot.phase === 'error'}
+  {@render renderError?.(boot.error)}
+{:else if boot.binding}
+  {#if boot.phase === 'ready'}
+    {@render children?.()}
+  {:else}
+    {@render fallback?.()}
+  {/if}
+{/if}

package/dist/runtime/Viewer.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ViewerProps } from './props.js';
+declare const Viewer: import("svelte").Component<ViewerProps, {}, "">;
+type Viewer = ReturnType<typeof Viewer>;
+export default Viewer;

package/dist/runtime/binding.svelte.d.ts

@@ -0,0 +1,33 @@
+import type { Kernel } from '@embedpdf/core';
+export declare class KernelBinding {
+    #private;
+    readonly kernel: Kernel;
+    constructor(kernel: Kernel);
+    /** Read inside a `$derived` or an effect to run it again after every kernel change. */
+    track(): void;
+    /** Stop following the kernel; the viewer calls it when it unmounts. */
+    dispose(): void;
+}
+/** What `<Viewer>` and `<KernelProvider>` provide: the binding, once the kernel exists. */
+export interface KernelHolder {
+    readonly binding: KernelBinding | null;
+}
+/** For `<Viewer>` and `<KernelProvider>`: provide the kernel to everything inside it. */
+export declare function setKernelHolder(holder: KernelHolder): void;
+/**
+ * The binding of the nearest `<Viewer>` or `<KernelProvider>`. Everything inside one is created
+ * after its kernel, so the binding is there whenever a component inside asks.
+ */
+export declare function useKernelBinding(): KernelBinding;
+/**
+ * The kernel of the nearest `<Viewer>` or `<KernelProvider>`: for code that needs it whole
+ * (`onReady` gives it too).
+ */
+export declare function useKernel(): Kernel;
+/** For `<DocumentScope>`: bind a subtree to the document `id()` names. */
+export declare function setDocumentScope(id: () => string): void;
+/**
+ * The document the nearest `<DocumentScope>` names, as a function readers call each time (so a
+ * changed `id` reaches them), or one that answers null: follow the active document.
+ */
+export declare function documentScopeOf(): () => string | null;

package/dist/runtime/binding.svelte.js

@@ -0,0 +1,71 @@
+/**
+ * The kernel as Svelte sees it, and the two contexts every reader starts from.
+ *
+ * The kernel has one change stream (`kernel.subscribe`). {@link KernelBinding} turns it into one
+ * signal: a version that moves on every change. A reader reads that version inside a `$derived`,
+ * so it computes again after any change and passes a value on only when it differs. The binding
+ * subscribes for the kernel's whole life, so a reader works the same inside a template, an effect
+ * or an event handler.
+ *
+ * `<Viewer>` puts the binding in context (`<KernelProvider>` too, for a kernel it doesn't own);
+ * `<DocumentScope>` puts the document a subtree talks to.
+ */
+import { getContext, hasContext, setContext, untrack } from 'svelte';
+export class KernelBinding {
+    kernel;
+    #version = $state(0);
+    #unsubscribe;
+    constructor(kernel) {
+        this.kernel = kernel;
+        // `untrack`: a change can be announced while a reaction runs (a verb called from an effect),
+        // and the version is a counter nobody reads to decide what to write.
+        this.#unsubscribe = kernel.subscribe(() => untrack(() => this.#version++));
+    }
+    /** Read inside a `$derived` or an effect to run it again after every kernel change. */
+    track() {
+        void this.#version;
+    }
+    /** Stop following the kernel; the viewer calls it when it unmounts. */
+    dispose() {
+        this.#unsubscribe();
+    }
+}
+const KERNEL = Symbol('embedpdf.kernel');
+const DOCUMENT_SCOPE = Symbol('embedpdf.document-scope');
+/** For `<Viewer>` and `<KernelProvider>`: provide the kernel to everything inside it. */
+export function setKernelHolder(holder) {
+    setContext(KERNEL, holder);
+}
+/**
+ * The binding of the nearest `<Viewer>` or `<KernelProvider>`. Everything inside one is created
+ * after its kernel, so the binding is there whenever a component inside asks.
+ */
+export function useKernelBinding() {
+    // Untracked: the binding never changes for a component's lifetime, so nothing re-runs on it.
+    const binding = hasContext(KERNEL)
+        ? untrack(() => getContext(KERNEL).binding)
+        : null;
+    if (!binding) {
+        throw new Error('[embedpdf] This must be used inside <Viewer> or <KernelProvider>.');
+    }
+    return binding;
+}
+/**
+ * The kernel of the nearest `<Viewer>` or `<KernelProvider>`: for code that needs it whole
+ * (`onReady` gives it too).
+ */
+export function useKernel() {
+    return useKernelBinding().kernel;
+}
+/** For `<DocumentScope>`: bind a subtree to the document `id()` names. */
+export function setDocumentScope(id) {
+    setContext(DOCUMENT_SCOPE, id);
+}
+const ACTIVE = () => null;
+/**
+ * The document the nearest `<DocumentScope>` names, as a function readers call each time (so a
+ * changed `id` reaches them), or one that answers null: follow the active document.
+ */
+export function documentScopeOf() {
+    return hasContext(DOCUMENT_SCOPE) ? getContext(DOCUMENT_SCOPE) : ACTIVE;
+}

package/dist/runtime/capability-handle.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A handle over `resolve()`. Members are cached by name, so `stage.zoomIn` is the same function
+ * every time, and a namespace (`annotation.comments`) is itself a handle. A member that is a
+ * plain value is read as it is now.
+ */
+export declare function capabilityHandle<T>(resolve: () => unknown, track: () => void): T;

package/dist/runtime/capability-handle.js

@@ -0,0 +1,71 @@
+/**
+ * What `useStage()`, `useDocuments()` and every other `use<Plugin>()` return: a handle that is
+ * always the capability of the document in scope.
+ *
+ * A component calls `use<Plugin>()` once, when it is created, but the document it talks to can
+ * change (another tab becomes active, a `<DocumentScope id>` changes) and can be missing (none is
+ * open yet). So the handle resolves the capability again on every call. Without a ready document
+ * it reaches the plugin's stand-in (`standInFor` from `@embedpdf/core`), whose calls refuse with
+ * `not-ready`: a method that returns a promise rejects, the others throw.
+ *
+ * Reads follow the capability vocabulary (docs/conventions/naming.md): a member named `get*`,
+ * `list*`, `is*`, `has*` or `can*` reads state, so calling it in a template or a `$derived`
+ * subscribes to the kernel: `{#if annotation.canCreate()}` updates when the answer changes. Every
+ * other member is a verb or an event and subscribes to nothing: an effect that calls
+ * `stage.reveal(index)` runs again only when `index` changes.
+ */
+import { untrack } from 'svelte';
+import { isReadMember } from '@embedpdf/core';
+/**
+ * A handle over `resolve()`. Members are cached by name, so `stage.zoomIn` is the same function
+ * every time, and a namespace (`annotation.comments`) is itself a handle. A member that is a
+ * plain value is read as it is now.
+ */
+export function capabilityHandle(resolve, track) {
+    return memberHandle(resolve, track, null);
+}
+function memberHandle(resolve, track, call) {
+    const members = new Map();
+    // A function target, so a member can be called and can have members of its own.
+    const target = call ? function member() { } : {};
+    return new Proxy(target, {
+        apply: (_target, _this, args) => call(args),
+        has(_target, key) {
+            const value = untrack(resolve);
+            return (typeof value === 'object' || typeof value === 'function') && value !== null
+                ? key in value
+                : false;
+        },
+        get(_target, key) {
+            // Not a thenable, and inspecting it never resolves anything.
+            if (typeof key === 'symbol' || key === 'then')
+                return undefined;
+            const value = untrack(() => resolve()?.[key]);
+            if (typeof value !== 'function' && (typeof value !== 'object' || value === null)) {
+                return value;
+            }
+            let member = members.get(key);
+            if (!member) {
+                const resolveMember = () => resolve()[key];
+                member = memberHandle(resolveMember, track, (args) => invoke(resolve, key, args, track));
+                members.set(key, member);
+            }
+            return member;
+        },
+    });
+}
+/**
+ * Call `key` on what `resolve()` gives now, with it as `this`. `Reflect.apply`, not `.apply`: a
+ * stand-in's member answers every property, `apply` too.
+ */
+function invoke(resolve, key, args, track) {
+    if (isReadMember(key)) {
+        track();
+        const owner = resolve();
+        return Reflect.apply(owner[key], owner, args);
+    }
+    return untrack(() => {
+        const owner = resolve();
+        return Reflect.apply(owner[key], owner, args);
+    });
+}

package/dist/runtime/dev.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Whether this is a development build: `DEV` from `esm-env`, as Svelte and SvelteKit read it.
+ * The app's bundler picks it by its `development` or `production` condition, so in a production
+ * build this is `false` and the warnings behind it compile out.
+ */
+export declare const isDev: () => boolean;
+/** Warn once per key. No-op in production. */
+export declare function devWarn(key: string, message: string): void;
+/** Forget every warning, so a test can assert one fires again. */
+export declare function resetDevWarnings(): void;

package/dist/runtime/dev.js

@@ -0,0 +1,23 @@
+/**
+ * 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}).
+ */
+import { DEV } from 'esm-env';
+const warned = new Set();
+/**
+ * Whether this is a development build: `DEV` from `esm-env`, as Svelte and SvelteKit read it.
+ * The app's bundler picks it by its `development` or `production` condition, so in a production
+ * build this is `false` and the warnings behind it compile out.
+ */
+export const isDev = () => DEV;
+/** Warn once per key. No-op in production. */
+export function devWarn(key, message) {
+    if (!isDev() || warned.has(key))
+        return;
+    warned.add(key);
+    console.warn(`[embedpdf] ${message}`);
+}
+/** Forget every warning, so a test can assert one fires again. */
+export function resetDevWarnings() {
+    warned.clear();
+}

package/dist/runtime/documents.svelte.d.ts

@@ -0,0 +1,34 @@
+import type { DocumentInfo, DocumentsCapability, DocumentsState, EventHook, PageInfo, ViewerSettings } from '@embedpdf/core';
+import { type CurrentValue } from './values.svelte.js';
+/**
+ * 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. What to show comes from `useDocument()` and `useDocumentsState()`.
+ */
+export declare function useDocuments(): DocumentsCapability;
+/**
+ * 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.
+ */
+export declare function useDocument(): Readonly<DocumentInfo>;
+export declare function useDocument<Selected>(select: (document: DocumentInfo) => Selected): CurrentValue<Selected>;
+/** Every open document, in tab order (loading, locked and failed ones too), and the active one's id. */
+export declare function useDocumentsState(): Readonly<DocumentsState>;
+export declare function useDocumentsState<Selected>(select: (state: DocumentsState) => Selected): CurrentValue<Selected>;
+/** Subscribe to one documents event while the component lives: `useDocumentsEvent((documents) => documents.onOpened, handler)`. */
+export declare function useDocumentsEvent<T>(select: (documents: DocumentsCapability) => EventHook<T>, handler: (event: T) => void): void;
+/**
+ * The pages of the document this component talks to, in order: each with its `ref`, `index`,
+ * `label`, size and rotation. Needs no Stage. The same array until a page is added, removed,
+ * moved or rotated; empty with no document.
+ */
+export declare function usePageList(): CurrentValue<readonly PageInfo[]>;
+/**
+ * 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.
+ */
+export declare function useViewerSettings(): Readonly<ViewerSettings>;
+export declare function useViewerSettings<Selected>(select: (settings: ViewerSettings) => Selected): CurrentValue<Selected>;

package/dist/runtime/documents.svelte.js

@@ -0,0 +1,49 @@
+/**
+ * The documents and the viewer's own settings, for components: the documents API, the document
+ * in scope, every open document, its pages, and the settings `<Viewer>` takes as props.
+ */
+import { DocumentsToken, documentState, documentsState, shallowEqual } from '@embedpdf/core';
+import { useKernelBinding } from './binding.svelte.js';
+import { useCapability, useCapabilityEvent, useDocumentId, useKernelValue } from './readers.svelte.js';
+import { declaredState, readRecord } from './state.svelte.js';
+import { derivedValue } from './values.svelte.js';
+/**
+ * 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. What to show comes from `useDocument()` and `useDocumentsState()`.
+ */
+export function useDocuments() {
+    return useCapability(DocumentsToken);
+}
+export function useDocument(select) {
+    const binding = useKernelBinding();
+    const whole = declaredState(binding, DocumentsToken, documentState.read, documentState.empty);
+    return readRecord(whole, Object.keys(documentState.empty), select);
+}
+export function useDocumentsState(select) {
+    const binding = useKernelBinding();
+    const whole = declaredState(binding, DocumentsToken, documentsState.read, documentsState.empty);
+    return readRecord(whole, Object.keys(documentsState.empty), select);
+}
+/** Subscribe to one documents event while the component lives: `useDocumentsEvent((documents) => documents.onOpened, handler)`. */
+export function useDocumentsEvent(select, handler) {
+    useCapabilityEvent(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. The same array until a page is added, removed,
+ * moved or rotated; empty with no document.
+ */
+export function usePageList() {
+    const documentId = useDocumentId();
+    return useKernelValue((kernel) => documentId.current ? kernel.documents.listPages(documentId.current) : NO_PAGES);
+}
+export function useViewerSettings(select) {
+    const binding = useKernelBinding();
+    const whole = derivedValue(() => {
+        binding.track();
+        return binding.kernel.getSettings();
+    }, shallowEqual);
+    return readRecord(whole, ['identity', 'scope', 'accent', 'page'], select);
+}