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

package/dist/stage/Stage.svelte

@@ -0,0 +1,181 @@
+<!--
+  The Stage: lays out the document's pages by the camera, keeps only the visible ones mounted,
+  and draws its content (the `children` snippet) on each; you bring the layers. Pointer, wheel and touch input go
+  through `@embedpdf/web`'s stage surface, so every framework has one feel.
+
+  Everything inside binds to this lens: a `useStageState()` in a page's chrome or a
+  `<Scrollbar>` in the overlay needs no token. The overlay also gets the Stage's projection, so
+  anchored UI follows the camera in the same flush as the pages.
+-->
+<script lang="ts">
+  import { untrack } from 'svelte';
+  import type { CapabilityToken } from '@embedpdf/core';
+  import type { PageFrame } from '@embedpdf/core-geometry';
+  import { createScrollHandler, DEFAULT_SETTINGS, stageState } from '@embedpdf/plugin-stage';
+  import type { VisiblePage } from '@embedpdf/plugin-stage';
+  import type { StageHostCapability } from '@embedpdf/plugin-stage/contract/host';
+  import { InteractionToken as InteractionPublicToken } from '@embedpdf/plugin-interaction/contract';
+  import { InteractionToken } from '@embedpdf/plugin-interaction/contract/host';
+  import { createStageSurface, stageViewProjector } from '@embedpdf/web';
+  import { setProjectorBinding, setShownPages, type ShownPages } from '../anchored/context.js';
+  import {
+    useCapabilityEvent,
+    useDocumentId,
+    useKernelValue,
+    useOptionalCapability,
+    useOptionalSelector,
+  } from '../runtime/readers.svelte.js';
+  import { declaredState } from '../runtime/state.svelte.js';
+  import { useKernelBinding } from '../runtime/binding.svelte.js';
+  import PageSurface from './PageSurface.svelte';
+  import type { StageProps } from './props.js';
+  import { setStageToken, stageTokenOf } from './stage-scope.js';
+  import { syncTwoWay } from './two-way.svelte.js';
+
+  let {
+    children,
+    pageChrome,
+    overlay,
+    tool = $bindable(),
+    onToolChange,
+    page = $bindable(),
+    zoom = $bindable(),
+    token: explicitToken,
+    class: className,
+    style,
+  }: StageProps = $props();
+
+  const token = stageTokenOf(() => explicitToken);
+  setStageToken(token);
+  // The surface is a host of the lens: it reports the viewport size, drives gestures and reads
+  // the lens id. The host contract is the same runtime token, typed wider.
+  const hostToken = () => token() as unknown as CapabilityToken<StageHostCapability>;
+  const stage = useOptionalCapability(hostToken);
+  const interaction = useOptionalCapability(InteractionToken);
+  const documentId = useDocumentId();
+
+  const NO_PAGES: readonly VisiblePage[] = [];
+  // The visible pages already fold in the camera (each carries its snapped screen position and
+  // transform), so panning gives a new list: no separate camera subscription.
+  const pages = useOptionalSelector(hostToken, (lens) => lens.listVisiblePages(), NO_PAGES);
+  const settings = useOptionalSelector(hostToken, (lens) => lens.getSettings(), DEFAULT_SETTINGS);
+  // The reserved bands around every page, compared by side so an equal frame changes nothing.
+  const frame = useOptionalSelector(
+    hostToken,
+    (lens) => lens.getSettings().pageFrame,
+    DEFAULT_SETTINGS.pageFrame,
+    (left: PageFrame, right: PageFrame) =>
+      left.top === right.top &&
+      left.right === right.right &&
+      left.bottom === right.bottom &&
+      left.left === right.left,
+  );
+
+  // How this view takes pointer input is its own settings: routed to the interaction plugin
+  // (which also registers this view's pan-scroll handler, scoped to it, so two Stages on one
+  // document never pan each other), or the Stage's own drag-to-pan without it.
+  const routed = $derived(settings.current.interaction && interaction.current !== null);
+  const panFallback = $derived(settings.current.panFallback);
+  const zoomGestures = $derived(settings.current.zoomGestures);
+  // The cursor the interaction plugin resolves (text, grab, …), on the viewport while routed.
+  const hubCursor = useKernelValue(() => interaction.current?.getCursor() ?? 'default');
+
+  let element: HTMLDivElement | undefined;
+
+  $effect(() => {
+    const lens = stage.current;
+    const hub = routed ? interaction.current : null;
+    const gestures = zoomGestures;
+    const fallback = panFallback;
+    if (!element || !lens) return;
+    return untrack(() => {
+      const detachSurface = createStageSurface(element!, lens, {
+        hub,
+        source: lens.getLensId(),
+        zoomGestures: gestures,
+      });
+      const offScroll = hub
+        ? hub.registerHandler(createScrollHandler(lens, hub, { panFallback: fallback }), {
+            source: lens.getLensId(),
+          })
+        : null;
+      return () => {
+        offScroll?.();
+        detachSurface();
+      };
+    });
+  });
+
+  // ── two-way values ─────────────────────────────────────────────────────────
+
+  // The bound tool wins whenever it's set, again when the document changes.
+  $effect(() => {
+    const wanted = tool;
+    const hub = interaction.current;
+    if (wanted === undefined || !hub) return;
+    untrack(() => {
+      if (hub.getActiveToolId() !== wanted) hub.activateTool(wanted);
+    });
+  });
+  useCapabilityEvent(
+    InteractionPublicToken,
+    (hub) => hub.onToolChanged,
+    (event) => {
+      if (tool !== undefined) tool = event.toolId;
+      onToolChange?.(event.toolId);
+    },
+  );
+
+  const binding = useKernelBinding();
+  const view = declaredState(binding, token, stageState.read, stageState.empty);
+  syncTwoWay({
+    stage: () => view().currentPageIndex,
+    bound: () => page,
+    ready: () => stage.current !== null,
+    write: (value) => (page = value),
+    apply: (value) => stage.current?.goToPage(value),
+  });
+  syncTwoWay({
+    stage: () => view().zoomLevel,
+    bound: () => zoom,
+    ready: () => stage.current !== null,
+    write: (value) => (zoom = value),
+    apply: (value) => stage.current?.zoomTo(value),
+  });
+
+  // ── what the overlay anchors to ───────────────────────────────────────────
+
+  // Anchored UI positions through the camera: pure state, no DOM reads. The visible pages are
+  // the binding's revision, so a camera change moves the pages and every anchored element in
+  // the same flush.
+  const projector = stageViewProjector(() => stage.current);
+  const projectorBinding = $derived({ projector, revision: pages.current });
+  setProjectorBinding(() => projectorBinding);
+  // The pages on screen as one value that changes only when a page comes or goes, so anchored
+  // UI on the other pages sits out every camera frame.
+  const shownKey = $derived(pages.current.map((visible) => visible.ref.objectNumber).join(','));
+  const shownPages: ShownPages = $derived(new Set(shownKey ? shownKey.split(',').map(Number) : []));
+  setShownPages(() => shownPages);
+</script>
+
+<div
+  bind:this={element}
+  class={className}
+  style="position: relative; overflow: hidden; touch-action: none;{routed
+    ? ` cursor: ${hubCursor.current};`
+    : ''}{style ? ` ${style}` : ''}"
+>
+  {#if stage.current}
+    {#each pages.current as visible (visible.ref.objectNumber)}
+      <PageSurface
+        documentId={documentId.current ?? ''}
+        page={visible}
+        frame={frame.current}
+        stage={stage.current}
+        content={children}
+        chrome={pageChrome}
+      />
+    {/each}
+  {/if}
+  {@render overlay?.()}
+</div>

package/dist/stage/Stage.svelte.d.ts

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

package/dist/stage/StageScope.svelte

@@ -0,0 +1,14 @@
+<!--
+  Binds everything inside to a stage lens: the stage readers and stage chrome inside use `token`
+  unless they are given one themselves.
+-->
+<script lang="ts">
+  import type { Snippet } from 'svelte';
+  import { setStageToken, type StageTokenProp } from './stage-scope.js';
+
+  let { token, children }: { token: StageTokenProp; children?: Snippet } = $props();
+
+  setStageToken(() => token);
+</script>
+
+{@render children?.()}

package/dist/stage/StageScope.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Snippet } from 'svelte';
+import { type StageTokenProp } from './stage-scope.js';
+type $$ComponentProps = {
+    token: StageTokenProp;
+    children?: Snippet;
+};
+declare const StageScope: import("svelte").Component<$$ComponentProps, {}, "">;
+type StageScope = ReturnType<typeof StageScope>;
+export default StageScope;

package/dist/stage/props.d.ts

@@ -0,0 +1,71 @@
+/** The props of the Stage's components: `<Stage>` and `<Scrollbar>`. */
+import type { Snippet } from 'svelte';
+import type { PageContextValue } from '../runtime/page.js';
+import type { StageTokenProp } from './stage-scope.js';
+export interface StageProps {
+    /**
+     * Page-space content for each visible page (`<RenderLayer>`, annotations, markers): what you
+     * write between `<Stage>` and `</Stage>`, or `{#snippet children(page)}` when it needs the page.
+     * It's drawn inside the page's content frame, so it turns with the page, and positions are PDF
+     * points.
+     */
+    children: Snippet<[page: PageContextValue]>;
+    /**
+     * Box-space chrome for each visible page (a page number, a selection border, a per-page
+     * button), drawn into the outer box (content and the reserved `pageFrame`). It never turns,
+     * and the reserved bands are plain regions: `bottom: 0; height: page.frame.bottom`.
+     */
+    pageChrome?: Snippet<[page: PageContextValue]>;
+    /** Viewport-space UI (menus, controls, `<Scrollbar>`), drawn above the pages. */
+    overlay?: Snippet;
+    /**
+     * The active tool, two-way (`bind:tool`): while it's set, the interaction plugin's active tool
+     * follows it, and a tool chosen elsewhere is written back. Leave it out for the default
+     * (`useInteraction().activateTool()`).
+     */
+    tool?: string;
+    /** Called on every tool change of this stage's document. */
+    onToolChange?: (toolId: string) => void;
+    /**
+     * The current page's index, from 0, two-way (`bind:page`): the Stage writes it as the reader
+     * moves, and goes to the page when you change it.
+     */
+    page?: number;
+    /**
+     * The zoom level, two-way (`bind:zoom`): `1` is 100%. The Stage writes it as the zoom changes,
+     * and zooms to it when you change it.
+     */
+    zoom?: number;
+    /** The stage lens to drive: the nearest `<StageScope>`'s, else the main view. */
+    token?: StageTokenProp;
+    class?: string;
+    style?: string;
+}
+export type ScrollbarAxis = 'x' | 'y';
+export interface ScrollbarProps {
+    axis: ScrollbarAxis;
+    /** The stage lens to scroll: the nearest `<StageScope>` / `<Stage>`'s, else the main view. */
+    token?: StageTokenProp;
+    /**
+     * Hide `autoHide` milliseconds after the view stops moving (a drag or the pointer over it
+     * keeps it shown; a hidden bar ignores the pointer, like macOS). `false` always shows it.
+     * Published as `data-state="visible|hidden"`. Default 1200.
+     */
+    autoHide?: number | false;
+    /** The smallest thumb, in pixels, so it never vanishes on a long document. Default 24. */
+    minThumbSize?: number;
+    /**
+     * A press on the track: `'page'` steps 90% of a view toward the pointer and repeats while
+     * held, stopping at the pointer; `'jump'` centers the thumb at the pointer and drags from
+     * there. Default `'page'`.
+     */
+    trackPress?: 'page' | 'jump';
+    /**
+     * The track's class and style. The default style pins it to the right (y) or bottom (x) edge
+     * of the nearest positioned ancestor: the Stage, when it's in the overlay.
+     */
+    class?: string;
+    style?: string;
+    thumbClass?: string;
+    thumbStyle?: string;
+}

package/dist/stage/props.js

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

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

@@ -0,0 +1,39 @@
+import type { CapabilityToken, EventHook } from '@embedpdf/core';
+import { stageState } from '@embedpdf/plugin-stage';
+import type { StageCapability, StageSettings } from '@embedpdf/plugin-stage';
+import type { ScrollMetrics, StageHostCapability } from '@embedpdf/plugin-stage/contract/host';
+import { type CurrentValue, type MaybeGetter } from '../runtime/values.svelte.js';
+import { type StageTokenProp } from './stage-scope.js';
+/** What `useStageState()` gives: the Stage page's State table. */
+export type StageStateValue = (typeof stageState)['empty'];
+/** A lens argument: a token, a function that returns one, or none (the scope's, else the main view). */
+type LensArgument = MaybeGetter<StageTokenProp | undefined>;
+/** The Stage's API (zoom, navigation, reveal, settings), for app chrome. */
+export declare function useStage(token?: LensArgument): StageCapability;
+/** Subscribe to one stage event while the component lives: `useStageEvent((stage) => stage.onZoomChanged, handler)`. */
+export declare function useStageEvent<T>(select: (stage: StageCapability) => EventHook<T>, handler: (event: T) => void, token?: LensArgument): void;
+/**
+ * The view's state: the zoom, the current page, the page count, the view rotation and the
+ * responsive rules that apply (declared once in `stageState`), as a reactive object
+ * (`state.zoomLevel`). With a selector, the value it picks as `{ current }`. Without a document
+ * it is `stageState.empty`.
+ */
+export declare function useStageState(token?: StageTokenProp): Readonly<StageStateValue>;
+export declare function useStageState<Selected>(select: (state: StageStateValue) => Selected, token?: LensArgument): CurrentValue<Selected>;
+/**
+ * The view's settings, as a reactive object, or the value a selector picks as `{ current }`. They
+ * belong to the view, so without a document there is none yet and this reads the defaults.
+ * Change them with `useStage().updateSettings()`.
+ */
+export declare function useStageSettings(token?: StageTokenProp): Readonly<StageSettings>;
+export declare function useStageSettings<Selected>(select: (settings: StageSettings) => Selected, token?: LensArgument): CurrentValue<Selected>;
+export declare const asHost: (token: CapabilityToken<StageCapability>) => CapabilityToken<StageHostCapability>;
+/**
+ * The view's scroll position as a scrolling element has it: `scrollTop`, `scrollHeight`,
+ * `clientHeight` and their horizontal twins, in screen pixels, as a reactive object. The raw
+ * material for scroll UI of your own; all zero without a document.
+ */
+export declare function useScrollMetrics(token?: LensArgument): Readonly<ScrollMetrics>;
+/** {@link useScrollMetrics} for the lens `lens()` names now, for a component whose token is a prop. */
+export declare function scrollMetricsOf(lens: () => StageTokenProp): Readonly<ScrollMetrics>;
+export {};

package/dist/stage/readers.svelte.js

@@ -0,0 +1,84 @@
+/**
+ * The Stage's readers: `useStage()` (the API), `useStageState()`, `useStageSettings()`,
+ * `useStageEvent()` and `useScrollMetrics()`. Each takes an optional token; without one it binds
+ * to the nearest `<StageScope>` / `<Stage>`, else the main view. A token that changes (a prop) is
+ * passed as a function: `useStage(() => token)`, and after a selector,
+ * `useStageState((state) => state.zoomLevel, () => token)`.
+ */
+import { shallowEqual } from '@embedpdf/core';
+import { DEFAULT_SETTINGS, stageState } from '@embedpdf/plugin-stage';
+import { documentScopeOf, useKernelBinding } from '../runtime/binding.svelte.js';
+import { useCapability, useCapabilityEvent } from '../runtime/readers.svelte.js';
+import { declaredState, readRecord } from '../runtime/state.svelte.js';
+import { derivedValue, valueOf, } from '../runtime/values.svelte.js';
+import { stageTokenOf } from './stage-scope.js';
+/** The lens a reader with this argument binds to, read on every use. */
+const lensOf = (token) => stageTokenOf(() => valueOf(token));
+/** The Stage's API (zoom, navigation, reveal, settings), for app chrome. */
+export function useStage(token) {
+    return useCapability(lensOf(token));
+}
+/** Subscribe to one stage event while the component lives: `useStageEvent((stage) => stage.onZoomChanged, handler)`. */
+export function useStageEvent(select, handler, token) {
+    useCapabilityEvent(lensOf(token), select, handler);
+}
+/**
+ * A reader's arguments: a selector, then an optional lens; or just a token. A function first is
+ * always the selector, so a token that changes goes second, as a function.
+ */
+function selectorAndLens(first, second) {
+    return typeof first === 'function' ? [first, second] : [undefined, first ?? second];
+}
+export function useStageState(first, second) {
+    const [select, token] = selectorAndLens(first, second);
+    const binding = useKernelBinding();
+    const lens = lensOf(token);
+    const whole = declaredState(binding, lens, stageState.read, stageState.empty);
+    return readRecord(whole, Object.keys(stageState.empty), select);
+}
+export function useStageSettings(first, second) {
+    const [select, token] = selectorAndLens(first, second);
+    const binding = useKernelBinding();
+    const lens = lensOf(token);
+    const scoped = documentScopeOf();
+    const whole = derivedValue(() => {
+        binding.track();
+        const stage = binding.kernel.tryCapability(lens(), scoped() ?? undefined);
+        return stage?.getSettings() ?? DEFAULT_SETTINGS;
+    }, shallowEqual);
+    return readRecord(whole, Object.keys(DEFAULT_SETTINGS), select);
+}
+/** What a view with nothing to scroll measures: no document, or not placed yet. */
+const NO_SCROLL = Object.freeze({
+    scrollLeft: 0,
+    scrollTop: 0,
+    scrollWidth: 0,
+    scrollHeight: 0,
+    clientWidth: 0,
+    clientHeight: 0,
+    scrollableX: false,
+    scrollableY: false,
+});
+// Scroll metrics live on the host lens (the same runtime token, typed wider): a scrollbar is
+// chrome that drives the camera, not a document-level consumer.
+export const asHost = (token) => token;
+/**
+ * The view's scroll position as a scrolling element has it: `scrollTop`, `scrollHeight`,
+ * `clientHeight` and their horizontal twins, in screen pixels, as a reactive object. The raw
+ * material for scroll UI of your own; all zero without a document.
+ */
+export function useScrollMetrics(token) {
+    return scrollMetricsOf(lensOf(token));
+}
+/** {@link useScrollMetrics} for the lens `lens()` names now, for a component whose token is a prop. */
+export function scrollMetricsOf(lens) {
+    const binding = useKernelBinding();
+    const scoped = documentScopeOf();
+    // The capability keeps the same metrics object until a number moves.
+    const whole = derivedValue(() => {
+        binding.track();
+        const stage = binding.kernel.tryCapability(asHost(lens()), scoped() ?? undefined);
+        return stage?.getScrollMetrics() ?? NO_SCROLL;
+    });
+    return readRecord(whole, Object.keys(NO_SCROLL), undefined);
+}

package/dist/stage/stage-scope.d.ts

@@ -0,0 +1,18 @@
+import type { CapabilityToken } from '@embedpdf/core';
+import type { StageCapability } from '@embedpdf/plugin-stage/contract';
+/** Which stage lens to bind to: the main `StageToken`, or a second view's own token. */
+export type StageTokenProp = CapabilityToken<StageCapability>;
+/** For `<Stage>` and `<StageScope>`: bind everything inside to the lens `token()` names. */
+export declare function setStageToken(token: () => StageTokenProp): void;
+/**
+ * The lens a stage reader binds to, as a function read on every use: the explicit token, else
+ * the nearest `<StageScope>` / `<Stage>`, else the main lens.
+ */
+export declare function stageTokenOf(explicit?: () => StageTokenProp | undefined): () => StageTokenProp;
+/**
+ * The lens stage chrome of your own binds to, as `{ current }`: `token`, else the nearest
+ * `<StageScope>` / `<Stage>`, else the main lens.
+ */
+export declare function useStageToken(token?: StageTokenProp): {
+    readonly current: StageTokenProp;
+};

package/dist/stage/stage-scope.js

@@ -0,0 +1,35 @@
+/**
+ * The stage lens a subtree binds to, so the stage readers and the stage-bound chrome
+ * (`<Scrollbar>`, `<SelectionHandles>`) need no token. `<Stage>` provides its own lens to its
+ * pages and overlay; an app wraps a second lens (a thumbnail rail) in `<StageScope token>`. An
+ * explicit token still wins everywhere.
+ *
+ * Apart from `./Stage.svelte`, so entries that only need the scope never pull the stage surface.
+ */
+import { getContext, hasContext, setContext } from 'svelte';
+import { StageToken } from '@embedpdf/plugin-stage/contract';
+const STAGE_TOKEN = Symbol('embedpdf.stage-token');
+/** For `<Stage>` and `<StageScope>`: bind everything inside to the lens `token()` names. */
+export function setStageToken(token) {
+    setContext(STAGE_TOKEN, token);
+}
+/**
+ * The lens a stage reader binds to, as a function read on every use: the explicit token, else
+ * the nearest `<StageScope>` / `<Stage>`, else the main lens.
+ */
+export function stageTokenOf(explicit) {
+    const scoped = hasContext(STAGE_TOKEN) ? getContext(STAGE_TOKEN) : null;
+    return () => explicit?.() ?? scoped?.() ?? StageToken;
+}
+/**
+ * The lens stage chrome of your own binds to, as `{ current }`: `token`, else the nearest
+ * `<StageScope>` / `<Stage>`, else the main lens.
+ */
+export function useStageToken(token) {
+    const lens = stageTokenOf(() => token);
+    return {
+        get current() {
+            return lens();
+        },
+    };
+}

package/dist/stage/two-way.svelte.d.ts

@@ -0,0 +1,13 @@
+export interface TwoWayValue<T> {
+    /** The Stage's value now. */
+    stage: () => T;
+    /** The bound prop now; undefined while the owner gives none. */
+    bound: () => T | undefined;
+    /** Whether the Stage can take a value yet (it has a document). */
+    ready: () => boolean;
+    /** Write the Stage's value to the bound prop. */
+    write: (value: T) => void;
+    /** Move the Stage to the owner's value. */
+    apply: (value: T) => void;
+}
+export declare function syncTwoWay<T>(value: TwoWayValue<T>): void;

package/dist/stage/two-way.svelte.js

@@ -0,0 +1,26 @@
+/**
+ * A value the Stage and its owner both write, for `bind:page` and `bind:zoom`: the owner's
+ * value goes in when it differs from the Stage's, and the Stage's goes out when it changes.
+ */
+import { untrack } from 'svelte';
+export function syncTwoWay(value) {
+    // In first: on mount, the owner's value is where the Stage goes, and only then does the
+    // Stage's own value come back out.
+    $effect(() => {
+        const wanted = value.bound();
+        if (wanted === undefined || !value.ready())
+            return;
+        untrack(() => {
+            if (!Object.is(wanted, value.stage()))
+                value.apply(wanted);
+        });
+    });
+    let last = untrack(value.stage);
+    $effect(() => {
+        const current = value.stage();
+        if (Object.is(current, last))
+            return;
+        last = current;
+        untrack(() => value.write(current));
+    });
+}

package/dist/stage.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @embedpdf/svelte/stage — the Stage and its readers.
+ *
+ * `<Stage>` lays out and positions the visible pages by the camera, and hands each one to its
+ * content: you bring the layers. The readers are the plugin's four, `useStage()` (the API),
+ * `useStageState()`, `useStageSettings()` and `useStageEvent()`; `<Scrollbar>` and
+ * `useScrollMetrics()` are the Stage's too.
+ */
+export * from '@embedpdf/plugin-stage';
+export { default as Stage } from './stage/Stage.svelte';
+export { default as StageScope } from './stage/StageScope.svelte';
+export { default as Scrollbar } from './stage/Scrollbar.svelte';
+export type { ScrollbarAxis, ScrollbarProps, StageProps } from './stage/props.js';
+export { useStageToken } from './stage/stage-scope.js';
+export type { StageTokenProp } from './stage/stage-scope.js';
+export { useScrollMetrics, useStage, useStageEvent, useStageSettings, useStageState, } from './stage/readers.svelte.js';
+export type { StageStateValue } from './stage/readers.svelte.js';

package/dist/stage.js

@@ -0,0 +1,15 @@
+/**
+ * @embedpdf/svelte/stage — the Stage and its readers.
+ *
+ * `<Stage>` lays out and positions the visible pages by the camera, and hands each one to its
+ * content: you bring the layers. The readers are the plugin's four, `useStage()` (the API),
+ * `useStageState()`, `useStageSettings()` and `useStageEvent()`; `<Scrollbar>` and
+ * `useScrollMetrics()` are the Stage's too.
+ */
+// Registration travels with the UI.
+export * from '@embedpdf/plugin-stage';
+export { default as Stage } from './stage/Stage.svelte';
+export { default as StageScope } from './stage/StageScope.svelte';
+export { default as Scrollbar } from './stage/Scrollbar.svelte';
+export { useStageToken } from './stage/stage-scope.js';
+export { useScrollMetrics, useStage, useStageEvent, useStageSettings, useStageState, } from './stage/readers.svelte.js';

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

@@ -0,0 +1,50 @@
+/**
+ * The stamp plugin's readers: `useStamp()` (the API), `useStampState()`, `useStampSettings()`,
+ * `useStampEvent()`, and the three a picker is built from: `useStampLibraries()`,
+ * `useStampAssets()` and `useStampAssetPreviewUrl()`.
+ *
+ * The plugin owns the libraries, their stamps and the cached previews; the one thing made here is
+ * the DOM resource a picker shows, the object URL of a stamp's preview.
+ */
+import type { EventHook } from '@embedpdf/core';
+import type { StampAsset, StampAssetFilter, StampCapability, StampLibrary, StampLibraryFilter } from '@embedpdf/plugin-stamp';
+import { type CurrentValue, type MaybeGetter } from '../runtime/values.svelte.js';
+/**
+ * The stamp API. Libraries are shared by every document; the placing verbs (`armAsset`,
+ * `placeAsset`, …) act on the nearest `<DocumentScope>`'s document, else the active one. A handle:
+ * keep it whole and call through it, `stamp.armAsset(id)`.
+ */
+export declare function useStamp(): StampCapability;
+/** Subscribe to one stamp event while the component lives: `useStampEvent((stamp) => stamp.onLibraryChanged, handler)`. */
+export declare function useStampEvent<T>(select: (stamp: StampCapability) => EventHook<T>, handler: (event: T) => void): void;
+/**
+ * The stamps' state for this component's document: the armed stamp (the page's State table,
+ * declared once in `stampState`), as a reactive object (`stampState.armedAsset`). With a
+ * selector, the value it picks as `{ current }`.
+ */
+export declare const useStampState: import("../index.js").StateReader<{
+    armedAsset: StampAsset | null;
+}>;
+/** The stamp settings (`assetEngine`, `previewWidth`, `dynamic`), with or without a document. */
+export declare const useStampSettings: import("../index.js").SettingsReader<import("@embedpdf/plugin-stamp").StampSettings & object>;
+/**
+ * The libraries as `{ current }`, optionally of one kind or several (`{ kind: 'stamps' }`,
+ * `{ kind: ['stamps', 'legal-seals'] }`; a function to follow a prop). Every read is a new array,
+ * compared item by item, so the value changes only when a library is added, renamed or removed.
+ */
+export declare function useStampLibraries(filter?: MaybeGetter<StampLibraryFilter | undefined>): CurrentValue<readonly StampLibrary[]>;
+/**
+ * The stamps as `{ current }`: one library's (`{ libraryId }`), one kind's or category's, or every
+ * stamp, in the order a picker shows them. A filter that changes is a function:
+ * `useStampAssets(() => ({ libraryId }))`.
+ */
+export declare function useStampAssets(filter?: MaybeGetter<StampAssetFilter | undefined>): CurrentValue<readonly StampAsset[]>;
+/**
+ * An image URL for a stamp's cached preview (a gallery thumbnail) as `{ current }`, or null while
+ * there is none. An id that changes is a function: `useStampAssetPreviewUrl(() => assetId)`.
+ *
+ * The plugin holds the preview's bytes; the URL is a DOM resource, so it is made here and revoked
+ * when the preview changes or the component goes away, the rule `<AnnotationLayer>` follows for
+ * the pictures it shows.
+ */
+export declare function useStampAssetPreviewUrl(assetId: MaybeGetter<string | null>): CurrentValue<string | null>;