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

package/dist/stage/index.d.ts

@@ -1,180 +1,281 @@
 import * as _embedpdf_plugin_stage from '@embedpdf/plugin-stage';
-import { VisiblePage, PageFrame, StageCapability } from '@embedpdf/plugin-stage';
+import { StagePluginOptions, StageCapability, StageSettings, VisiblePage } from '@embedpdf/plugin-stage';
 export * from '@embedpdf/plugin-stage';
+import { EmbedPdfFeature, EpdfPageContext, EpdfKernelHost, CapabilityBinding, EpdfDocumentScopeRef } from '@embedpdf/angular/runtime';
 import * as _angular_core from '@angular/core';
 import { TemplateRef, Signal } from '@angular/core';
-import { EpdfPageContext, CapabilityToken } from '@embedpdf/angular/runtime';
-import * as _embedpdf_core_geometry from '@embedpdf/core-geometry';
-import * as _embedpdf_angular_stage from '@embedpdf/angular/stage';
 import * as _embedpdf_core from '@embedpdf/core';
+import { CapabilityToken, PageRef, OpenSource } from '@embedpdf/core';
+import * as rxjs from 'rxjs';
+import * as _embedpdf_core_geometry from '@embedpdf/core-geometry';
+import { PageFrame } from '@embedpdf/core-geometry';
 import * as _embedpdf_core_stage from '@embedpdf/core-stage';
+import { StageHostCapability, ScrollMetrics } from '@embedpdf/plugin-stage/contract/host';
+import { EpdfProjectorBinding } from '@embedpdf/angular/anchored';
+import * as _embedpdf_web from '@embedpdf/web';
+
+/**
+ * `withStage(options)`: the Stage plugin, as a feature of `provideEmbedPdf()`. Give it twice
+ * for a second view, with its own `id` and `token`:
+ *
+ *   provideEmbedPdf({ engine }, withStage(), withStage({ id: 'stage-thumbs', token: ThumbsToken }))
+ *
+ * `inject(EpdfStageRef)` is the Stage's API: inside `<epdf-stage>` that Stage, anywhere else the
+ * main view of the document in scope.
+ */
+
+declare function withStage(options?: StagePluginOptions): EmbedPdfFeature;
 
 /**
- * The render-prop translation: React's `children: (page) => ReactNode` becomes
- * marker directives on `<ng-template>`, typed so `let-page` infers
- * `EpdfPageContext` in the template.
+ * The templates a Stage draws each page with. React's page function becomes a marker directive
+ * on an `<ng-template>`, typed so `let-page` is the page context:
  *
  *   <epdf-stage>
- *     <ng-template epdfPage>            page-space content (rotates)
- *     <ng-template epdfPageChrome>      box-space chrome (never rotates)
+ *     <ng-template epdfPage>              on the page: turns with it (layers)
+ *     <ng-template epdfPageChrome>        around the page: never turns (labels, buttons)
  *
- * The `$implicit` context is the SAME stable object the per-page injector
- * provides as `EPDF_PAGE` — `let-page` is sugar for inline chrome; components
- * inside the template just call `injectPage()`.
+ * `let-page` is the same context a component inside the template gets from `injectPage()`.
  */
 
 interface EpdfPageTemplateContext {
     $implicit: EpdfPageContext;
 }
-/** PAGE-SPACE content for each visible page (RenderLayer, annotations,
- *  markers). Rendered inside the page's content frame, so it ROTATES with the
- *  page's display rotation — coordinates are plain PDF points. */
+/**
+ * What each visible page draws: the render layer, text selection, annotations, your markers.
+ * It sits in the page's content box and turns with the page, so positions in it are page
+ * coordinates.
+ */
 declare class EpdfPageTemplate {
     readonly template: TemplateRef<EpdfPageTemplateContext>;
-    static ngTemplateContextGuard(_dir: EpdfPageTemplate, ctx: unknown): ctx is EpdfPageTemplateContext;
+    static ngTemplateContextGuard(_directive: EpdfPageTemplate, context: unknown): context is EpdfPageTemplateContext;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<EpdfPageTemplate, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EpdfPageTemplate, "ng-template[epdfPage]", never, {}, {}, never, never, true, never>;
 }
-/** BOX-SPACE chrome for each visible page (page-number label, selection
- *  border, per-page buttons). Rendered into the OUTER box (content + reserved
- *  `pageFrame`), so it does NOT rotate and the reserved bands are plain
- *  regions (`bottom: 0; height: page.frame().bottom`). */
+/**
+ * What goes around each visible page: a page number, a border, a row of buttons. It fills the
+ * page's box with the bands `pageFrame` reserves, and never turns, so a label in the bottom
+ * band is `bottom: 0` with `[style.height.px]="page.frame().bottom"`.
+ */
 declare class EpdfPageChrome {
     readonly template: TemplateRef<EpdfPageTemplateContext>;
-    static ngTemplateContextGuard(_dir: EpdfPageChrome, ctx: unknown): ctx is EpdfPageTemplateContext;
+    static ngTemplateContextGuard(_directive: EpdfPageChrome, context: unknown): context is EpdfPageTemplateContext;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<EpdfPageChrome, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EpdfPageChrome, "ng-template[epdfPageChrome]", never, {}, {}, never, never, true, never>;
 }
 
-declare class EpdfPageSurface {
-    readonly vp: _angular_core.InputSignal<VisiblePage>;
-    readonly frame: _angular_core.InputSignal<PageFrame>;
-    readonly documentId: _angular_core.InputSignal<string>;
-    readonly pageTpl: _angular_core.InputSignal<TemplateRef<EpdfPageTemplateContext>>;
-    readonly chromeTpl: _angular_core.InputSignal<TemplateRef<EpdfPageTemplateContext> | null>;
-    protected readonly t: _angular_core.Signal<_embedpdf_core_geometry.PageTransform>;
-    protected readonly left: _angular_core.Signal<number>;
-    protected readonly top: _angular_core.Signal<number>;
-    protected readonly outerWidth: _angular_core.Signal<number>;
-    protected readonly outerHeight: _angular_core.Signal<number>;
-    protected readonly contentLeft: _angular_core.Signal<number>;
-    protected readonly contentTop: _angular_core.Signal<number>;
-    protected readonly rotate: _angular_core.Signal<string | null>;
-    private readonly contentEl;
-    /** ONE stable context per surface — volatile parts are signals inside it. */
-    readonly page: EpdfPageContext;
-    /** ONE stable injector per surface (see the invariant above), parented to
-     *  this surface's node injector so layers also reach the kernel host. */
-    protected readonly pageInjector: _angular_core.DestroyableInjector;
-    protected readonly templateContext: EpdfPageTemplateContext;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EpdfPageSurface, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EpdfPageSurface, "epdf-page-surface", never, { "vp": { "alias": "vp"; "required": true; "isSignal": true; }; "frame": { "alias": "frame"; "required": true; "isSignal": true; }; "documentId": { "alias": "documentId"; "required": true; "isSignal": true; }; "pageTpl": { "alias": "pageTpl"; "required": true; "isSignal": true; }; "chromeTpl": { "alias": "chromeTpl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+/** The view a Stage drives: the main one (`StageToken`), or one registered with its own token. */
+type StageTokenProp = CapabilityToken<StageCapability>;
+declare class EpdfStageRef {
+    /** The viewer the view is in. */
+    protected readonly host: EpdfKernelHost;
+    /** The view, for the document in scope: inside `<epdf-stage>`, the Stage's own. */
+    protected readonly binding: CapabilityBinding<StageHostCapability>;
+    /** The view it drives: the main one. `<epdf-stage>` drives the one its `[token]` names. */
+    protected view(): StageTokenProp;
+    /** What an error says was used without a viewer. */
+    protected usedAs(): string;
+    private readonly state;
+    /** The zoom as a number: `1` is 100%. */
+    readonly zoomLevel: Signal<number>;
+    /** The fit mode, such as `'fit-width'`, or `'custom'` after a pinch or an exact level. */
+    readonly zoomMode: Signal<_embedpdf_core_stage.ZoomModeValue | "custom">;
+    /** The current page's place in the document, from 0. */
+    readonly currentPageIndex: Signal<number>;
+    /** The current page's ref, or null before the document has pages. */
+    readonly currentPage: Signal<PageRef | null>;
+    /** How many pages the document has. */
+    readonly pageCount: Signal<number>;
+    /** How the view is turned: `0`, `90`, `180` or `270`. */
+    readonly viewRotation: Signal<_embedpdf_core_geometry.PageRotation>;
+    /** The names of the responsive rules that apply now, in order. */
+    readonly activeRules: Signal<readonly string[]>;
+    /** The view's settings; the defaults without a document. Change them with `updateSettings()`. */
+    readonly settings: Signal<StageSettings>;
+    /** The scroll position as a scrolling element has it, in screen pixels; all zero without a document. */
+    readonly scrollMetrics: Signal<ScrollMetrics>;
+    /** Another page became the current one: `page`, `pageIndex`, `previousPageIndex`. */
+    readonly pageChanged$: rxjs.Observable<_embedpdf_plugin_stage.StagePageChangedEvent>;
+    /** The zoom level changed: `level`, `previousLevel`, `mode`. */
+    readonly zoomChanged$: rxjs.Observable<_embedpdf_plugin_stage.StageZoomChangedEvent>;
+    /** The view moved, on every frame of a scroll or zoom: `camera`. */
+    readonly cameraChanged$: rxjs.Observable<_embedpdf_plugin_stage.StageCameraChangedEvent>;
+    /** Scrolling, a fling or an animated move came to rest: `camera`. */
+    readonly motionEnded$: rxjs.Observable<_embedpdf_plugin_stage.StageMotionEndedEvent>;
+    /** The Stage itself changed size: `size`. */
+    readonly viewportChanged$: rxjs.Observable<_embedpdf_plugin_stage.StageViewportChangedEvent>;
+    /** A setting changed, by a call or a responsive rule: `settings`, `changed`. */
+    readonly settingsChanged$: rxjs.Observable<_embedpdf_plugin_stage.StageSettingsChangedEvent>;
+    readonly getCamera: () => _embedpdf_core_stage.Camera;
+    readonly setCamera: (camera: _embedpdf_core_stage.Camera) => void;
+    readonly getViewportSize: () => _embedpdf_core_geometry.Size;
+    readonly getZoomLevel: () => number;
+    readonly getZoomMode: () => _embedpdf_core_stage.ZoomModeValue | "custom";
+    readonly getViewRotation: () => _embedpdf_core_geometry.PageRotation;
+    readonly getCurrentPage: () => PageRef | null;
+    readonly getCurrentPageIndex: () => number;
+    readonly getPageCount: () => number;
+    readonly listCurrentItemPages: () => readonly _embedpdf_core.PageInfo[];
+    readonly listVisiblePages: () => readonly _embedpdf_plugin_stage.VisiblePage[];
+    readonly isPageVisible: (page: PageRef | number) => boolean;
+    readonly getViewpoint: () => _embedpdf_plugin_stage.Viewpoint;
+    readonly getViewState: () => _embedpdf_plugin_stage.StageViewState;
+    readonly applyViewState: (view: _embedpdf_plugin_stage.StageViewState) => void;
+    readonly isMoving: () => boolean;
+    readonly stopMotion: () => void;
+    readonly zoomTo: (zoom: number | _embedpdf_core_stage.ZoomSpec, options?: _embedpdf_plugin_stage.ZoomToOptions) => void;
+    readonly zoomBy: (factor: number, options?: _embedpdf_plugin_stage.ZoomToOptions) => void;
+    readonly zoomIn: () => void;
+    readonly zoomOut: () => void;
+    readonly fitWidth: () => void;
+    readonly fitPage: () => void;
+    readonly fitAll: () => void;
+    readonly fitAutomatic: () => void;
+    readonly goToPage: (page: PageRef | number, options?: _embedpdf_plugin_stage.GoToOptions) => void;
+    readonly goToDestination: (destination: _embedpdf_core.PageDestination, options?: _embedpdf_plugin_stage.GoToDestinationOptions) => void;
+    readonly goToFirstPage: (options?: _embedpdf_plugin_stage.GoToOptions) => void;
+    readonly goToLastPage: (options?: _embedpdf_plugin_stage.GoToOptions) => void;
+    readonly nextPage: (options?: _embedpdf_plugin_stage.GoToOptions) => void;
+    readonly previousPage: (options?: _embedpdf_plugin_stage.GoToOptions) => void;
+    readonly canGoNext: () => boolean;
+    readonly canGoPrevious: () => boolean;
+    readonly reveal: (page: PageRef | number, options?: _embedpdf_plugin_stage.RevealOptions) => void;
+    readonly scrollTo: (options: _embedpdf_plugin_stage.StageScrollToOptions) => void;
+    readonly scrollBy: (options: _embedpdf_plugin_stage.StageScrollToOptions) => void;
+    readonly panBy: (dxViewport: number, dyViewport: number) => void;
+    readonly resetView: () => void;
+    readonly setViewRotation: (rotation: _embedpdf_core_geometry.PageRotation) => void;
+    readonly rotateViewBy: (delta: 90 | -90) => void;
+    readonly getSettings: () => StageSettings;
+    readonly updateSettings: (changes: _embedpdf_plugin_stage.StageSettingsPatch) => void;
+    readonly resetSettings: () => void;
+    readonly setResponsiveRules: (rules: readonly _embedpdf_plugin_stage.ResponsiveRule[]) => void;
+    readonly listActiveRules: () => readonly string[];
+    readonly matchesRule: (name: string) => boolean;
+    readonly getPageAt: (point: _embedpdf_plugin_stage.ViewportPoint) => {
+        ref: PageRef;
+        point: _embedpdf_core_geometry.Point;
+        scale: number;
+        rotation: _embedpdf_core_geometry.PageRotation;
+        zoom: number;
+    } | null;
+    readonly viewportToPage: (page: PageRef | number, point: _embedpdf_plugin_stage.ViewportPoint) => _embedpdf_core_geometry.Point | null;
+    readonly pageToViewport: (page: PageRef | number, point: _embedpdf_core_geometry.Point) => _embedpdf_plugin_stage.ViewportPoint | null;
+    readonly pageRectToViewport: (page: PageRef | number, rect: _embedpdf_core_geometry.Rect) => _embedpdf_plugin_stage.ViewportRect | null;
+    readonly getPageFrame: (page: PageRef | number) => _embedpdf_plugin_stage.VisiblePage | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EpdfStageRef, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EpdfStageRef>;
 }
 
-/** Which stage lens to bind to. Defaults to the main StageToken — pass a custom
- *  token to drive an additional lens (e.g. a wrapped thumbnail sidebar). */
-type StageTokenProp = CapabilityToken<StageCapability>;
-declare class EpdfStage {
+declare class EpdfStage extends EpdfStageRef {
+    /** The view to drive: a token registered with `withStage({ token })`; the main view without one. */
+    readonly token: _angular_core.InputSignal<StageTokenProp | undefined>;
+    /** A document to open for this Stage. A new value opens it and closes the one before. */
+    readonly document: _angular_core.InputSignal<OpenSource | null | undefined>;
+    /** The current page's index, from 0: `[(page)]`. Setting it goes to that page. */
+    readonly page: _angular_core.InputSignal<number | undefined>;
+    /** Another page became the current one: its index. The output half of `[(page)]`. */
+    readonly pageChange: _angular_core.OutputEmitterRef<number>;
+    /** The zoom level, `1` for 100%: `[(zoom)]`. Setting it zooms there. */
+    readonly zoom: _angular_core.InputSignal<number | undefined>;
+    /** The zoom level changed. The output half of `[(zoom)]`. */
+    readonly zoomChange: _angular_core.OutputEmitterRef<number>;
+    private readonly ownDocument;
+    /** The document this Stage shows, for what's inside it: its own `[document]`, else its scope's. */
+    readonly documentScope: EpdfDocumentScopeRef;
+    /** The view's capability, or null without a document. */
+    protected readonly hostCapability: Signal<StageHostCapability | null>;
+    protected view(): StageTokenProp;
+    protected usedAs(): string;
+    /** The pages on screen, each with its place and transform: a new list every camera frame. */
+    protected readonly pages: Signal<readonly VisiblePage[]>;
+    protected readonly frame: Signal<PageFrame>;
+    protected readonly documentId: Signal<string | null>;
+    /** The viewer's `page` settings: each page's background and shadow. */
+    protected readonly look: Signal<_embedpdf_core.ViewerPageSettings>;
+    private readonly pageTemplateDirective;
+    private readonly chromeTemplateDirective;
+    protected readonly pageTemplate: Signal<TemplateRef<EpdfPageTemplateContext> | null>;
+    protected readonly chromeTemplate: Signal<TemplateRef<EpdfPageTemplateContext> | null>;
+    private readonly interaction;
+    private readonly panFallback;
+    private readonly zoomGestures;
+    /** The interaction hub of this Stage's document: the active tool takes the pointer. */
+    private readonly hub;
+    private readonly usesHub;
+    private readonly hubCursor;
+    /** The hub's cursor (text, grab, a tool's own), while the hub takes this Stage's pointer. */
+    protected readonly cursor: Signal<string | null>;
     /**
-     * Route this Stage's pointer events to the interaction hub (page-resolved via
-     * `pageAt`) — AND register this lens's tool-gated pan-scroll handler with it
-     * (lens-scoped, so multiple stages on one document never pan each other).
-     * Pan is then the `pan` tool's job and dragging in `pointer` mode selects
-     * text (incl. across pages).
-     *
-     * Default TRUE: registering `interactionPlugin()` is the one opt-in — tools
-     * just work; without the hub this is inert and the stage falls back to
-     * built-in drag-to-pan, so a hub-less setup costs nothing. Set `false` on
-     * SECONDARY lenses (a thumbnail rail) that should stay click-to-navigate
-     * instead of feeding the document's tools.
+     * How anchored UI (`<epdf-anchored>`) inside the Stage follows the camera: a projection
+     * through the view, and the visible pages as its revision, so the pages and the UI on them
+     * update in the same change detection pass and never a frame apart.
      */
-    readonly interaction: _angular_core.InputSignal<boolean>;
+    readonly projection: EpdfProjectorBinding;
+    constructor();
+    /** `[document]`: open it for this Stage once the viewer runs; close it when the value changes. */
+    private followDocumentInput;
     /**
-     * With `interaction`: let drags over page GAPS pan regardless of the active
-     * tool (and show a grab cursor there) — the gutter always pans; there is
-     * nothing to draw/select outside a page. Default true.
+     * `[(page)]` and `[(zoom)]`. A value from the parent moves the view there; a move of the view
+     * (scroll, pinch, a button) goes out as `pageChange` and `zoomChange`. When the Stage changes
+     * documents (another tab), the new document keeps its own place and reports it.
      */
-    readonly panFallback: _angular_core.InputSignal<boolean>;
+    private followPageAndZoom;
     /**
-     * Ambient ZOOM gestures on this stage: ctrl/cmd+wheel and trackpad pinch
-     * (Safari gesture events included). Default true. Turn OFF for follower
-     * lenses with a fixed magnification (a thumbnail rail should scroll under
-     * cmd+wheel, not zoom); pinches are still swallowed either way.
+     * The browser side: the viewport size and pixel ratio, wheel and touch gestures, and the
+     * pointer going to the interaction hub. All of it is `@embedpdf/web`'s, shared by every
+     * framework, so the Stage feels the same everywhere; this binds it again when the view, the
+     * hub or the input settings change.
      */
-    readonly zoomGestures: _angular_core.InputSignal<boolean>;
-    /** The stage lens to drive (default: the main StageToken). */
-    readonly token: _angular_core.InputSignal<StageTokenProp>;
-    private readonly host;
-    private readonly stage;
-    private readonly ix;
-    private readonly useHub;
-    private readonly hubCursor;
-    protected readonly cursor: _angular_core.Signal<string | null>;
-    protected readonly documentId: _angular_core.Signal<string | null>;
-    protected readonly pages: _angular_core.Signal<VisiblePage[]>;
-    protected readonly frame: _angular_core.Signal<PageFrame>;
-    private readonly pageTemplateDir;
-    private readonly chromeTemplateDir;
-    protected readonly pageTemplate: _angular_core.Signal<_angular_core.TemplateRef<_embedpdf_angular_stage.EpdfPageTemplateContext> | null>;
-    protected readonly chromeTemplate: _angular_core.Signal<_angular_core.TemplateRef<_embedpdf_angular_stage.EpdfPageTemplateContext> | null>;
-    constructor();
+    private bindSurface;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<EpdfStage, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EpdfStage, "epdf-stage", never, { "interaction": { "alias": "interaction"; "required": false; "isSignal": true; }; "panFallback": { "alias": "panFallback"; "required": false; "isSignal": true; }; "zoomGestures": { "alias": "zoomGestures"; "required": false; "isSignal": true; }; "token": { "alias": "token"; "required": false; "isSignal": true; }; }, {}, ["pageTemplateDir", "chromeTemplateDir"], ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EpdfStage, "epdf-stage", ["epdfStage"], { "token": { "alias": "token"; "required": false; "isSignal": true; }; "document": { "alias": "document"; "required": false; "isSignal": true; }; "page": { "alias": "page"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; "zoomChange": "zoomChange"; }, ["pageTemplateDirective", "chromeTemplateDirective"], ["*"], true, never>;
 }
 
-declare function injectStage(token?: StageTokenProp): Signal<StageCapability>;
-declare function injectZoom(token?: StageTokenProp): {
-    zoom: Signal<number>;
-    /** Active zoom intent: 'automatic' | 'fit-page' | 'fit-width' | 'fit-all' | 'custom'. */
-    mode: Signal<_embedpdf_core_stage.ZoomModeValue | "custom">;
-    zoomIn: () => void;
-    zoomOut: () => void;
-    fitWidth: () => void;
-    fitPage: () => void;
-    fitAll: () => void;
-    automatic: () => void;
-    zoomTo: (spec: _embedpdf_core_stage.ZoomSpec) => void;
-};
-declare function injectPages(token?: StageTokenProp): {
-    currentPage: Signal<number>;
-    pageCount: Signal<number>;
-    goToPage: (pageIndex: number, opts?: _embedpdf_plugin_stage.GoToOptions) => void;
-    next: (opts?: _embedpdf_plugin_stage.GoToOptions) => void;
-    prev: (opts?: _embedpdf_plugin_stage.GoToOptions) => void;
-    reveal: (pageIndex: number, opts?: _embedpdf_plugin_stage.RevealOptions) => void;
-};
-declare function injectLayout(token?: StageTokenProp): {
-    flow: Signal<_embedpdf_plugin_stage.FlowMode>;
-    layout: Signal<_embedpdf_plugin_stage.LayoutKind>;
-    spread: Signal<_embedpdf_core_stage.SpreadMode>;
-    sizing: Signal<_embedpdf_core_stage.SizingMode>;
-    bounded: Signal<boolean>;
-    setFlow: (flow: _embedpdf_plugin_stage.FlowMode) => void;
-    setLayout: (layout: _embedpdf_plugin_stage.LayoutKind) => void;
-    setSpread: (spread: _embedpdf_core_stage.SpreadMode) => void;
-    setSizing: (sizing: _embedpdf_core_stage.SizingMode) => void;
-    setBounded: (bounded: boolean) => void;
-};
-/** The document's page list (with PDF labels) + the current item's pages — the
- *  data for page thumbnails / worksheet-style page tabs. */
-declare function injectPageList(token?: StageTokenProp): {
-    pages: Signal<{
-        index: number;
-        pon: _embedpdf_core.PageObjectNumber;
-        label: string | null;
-    }[]>;
-    currentItemPages: Signal<number[]>;
-};
-/**
- * All Stage settings + the batch `update`. The seam for "presets are a customer
- * concern": keep your own `Partial<StageSettings>` objects and apply them with
- * `update(preset)` (one anchor-preserving change).
- */
-declare function injectStageSettings(token?: StageTokenProp): {
-    settings: Signal<_embedpdf_plugin_stage.StageSettings>;
-    update: (patch: Partial<_embedpdf_plugin_stage.StageSettings>) => void;
-    reset: () => void;
-};
+type ScrollbarAxis = 'x' | 'y';
+declare class EpdfScrollbar {
+    /** `'y'` for a vertical bar, `'x'` for a horizontal one. */
+    readonly axis: _angular_core.InputSignal<ScrollbarAxis>;
+    /**
+     * Hide this many milliseconds after the view stops moving (hover and dragging keep it shown;
+     * a hidden bar ignores the pointer, like macOS), or `false` to always show it.
+     */
+    readonly autoHide: _angular_core.InputSignalWithTransform<number | false, string | number | false>;
+    /** The shortest thumb, in pixels, so it never vanishes on a long document. */
+    readonly minThumbSize: _angular_core.InputSignal<number>;
+    /**
+     * Pressing the track: `'page'` steps 90% of a view toward the pointer and repeats while held;
+     * `'jump'` puts the thumb under the pointer and goes on as a drag.
+     */
+    readonly trackPress: _angular_core.InputSignal<"page" | "jump">;
+    /** The thumb's class. */
+    readonly thumbClass: _angular_core.InputSignal<string | null>;
+    private readonly stage;
+    private readonly element;
+    private readonly trackPx;
+    protected readonly dragging: _angular_core.WritableSignal<boolean>;
+    protected readonly hovered: _angular_core.WritableSignal<boolean>;
+    /** The view moved a moment ago. */
+    private readonly active;
+    protected readonly vertical: _angular_core.Signal<boolean>;
+    protected readonly scrollable: _angular_core.Signal<boolean>;
+    /** The thumb along the track: one formula for drawing, dragging and paging, in every framework. */
+    protected readonly layout: _angular_core.Signal<_embedpdf_web.ScrollbarLayout>;
+    protected readonly shown: _angular_core.Signal<boolean>;
+    protected readonly thumbColor: string;
+    protected readonly round: (x: number) => number;
+    /** Thumb drags, track paging and jumps: `@embedpdf/web`'s, shared by every framework. */
+    private readonly presses;
+    constructor();
+    /** The bar as it is now, for `@embedpdf/web`'s press handling. */
+    private track;
+    protected onThumbDown(event: PointerEvent): void;
+    protected onTrackDown(event: PointerEvent): void;
+    /** Pointer capture sends the moves here, for thumb drags, jump drags and paging alike. */
+    protected onMove(event: PointerEvent): void;
+    protected endDrag(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EpdfScrollbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EpdfScrollbar, "epdf-scrollbar", never, { "axis": { "alias": "axis"; "required": true; "isSignal": true; }; "autoHide": { "alias": "autoHide"; "required": false; "isSignal": true; }; "minThumbSize": { "alias": "minThumbSize"; "required": false; "isSignal": true; }; "trackPress": { "alias": "trackPress"; "required": false; "isSignal": true; }; "thumbClass": { "alias": "thumbClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
 
-export { EpdfPageChrome, EpdfPageSurface, EpdfPageTemplate, EpdfStage, injectLayout, injectPageList, injectPages, injectStage, injectStageSettings, injectZoom };
-export type { EpdfPageTemplateContext, StageTokenProp };
+export { EpdfPageChrome, EpdfPageTemplate, EpdfScrollbar, EpdfStage, EpdfStageRef, withStage };
+export type { EpdfPageTemplateContext, ScrollbarAxis, StageTokenProp };

package/dist/stamp/index.d.ts

@@ -0,0 +1,58 @@
+import * as _embedpdf_plugin_stamp from '@embedpdf/plugin-stamp';
+import { StampAsset, StampLibrary, StampAssetFilter, persistStampLibraries as persistStampLibraries$1, StampLibraryStore, StampConfig } from '@embedpdf/plugin-stamp';
+export * from '@embedpdf/plugin-stamp';
+export { ByteStore, indexedDbByteStore } from '@embedpdf/web';
+import * as _embedpdf_angular_runtime from '@embedpdf/angular/runtime';
+import { EmbedPdfFeature } from '@embedpdf/angular/runtime';
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+
+declare const EpdfStamp_base: _embedpdf_angular_runtime.PluginServiceClass<_embedpdf_plugin_stamp.StampCapability, {
+    armedAsset: StampAsset | null;
+}, "disarm" | "importLibrary" | "listLibraries" | "getLibrary" | "listAssets" | "getAsset" | "getAssetPreview" | "renderAssetPreview" | "readAssetBytes" | "createLibrary" | "updateLibrary" | "deleteLibrary" | "exportLibrary" | "createAsset" | "createAssetFromAnnotations" | "updateAsset" | "deleteAsset" | "moveAsset" | "duplicateAsset" | "armAsset" | "getArmedAsset" | "placeAsset" | "placeAssetOnPages" | "canPlace" | "canCreateFromAnnotations" | "canImport", "onLibraryCreated" | "onLibraryUpdated" | "onLibraryDeleted" | "onAssetCreated" | "onAssetUpdated" | "onAssetDeleted" | "onArmChanged" | "onLibraryChanged">;
+/**
+ * Stamps: the libraries and their stamps, shared by every document, and arming and placing
+ * them on the document in scope (`[epdfDocumentScope]`), else the active one. The Stamps page's
+ * methods, `armedAsset()` as a signal, the events as streams (`libraryChanged$`, `armChanged$`,
+ * …), and the settings. The libraries work without a document; a placing call refuses with
+ * `not-ready` until one is open.
+ */
+declare class EpdfStamp extends EpdfStamp_base {
+    /**
+     * Every library, in the order they were added. It changes when a library is added, renamed
+     * or removed; filter it for the kinds a picker shows (`library.kind`).
+     */
+    readonly libraries: Signal<readonly StampLibrary[]>;
+    /**
+     * The stamps in the order a picker shows them: one library's (`{ libraryId }`), one kind's or
+     * category's, or every stamp. Pass a function (`() => ({ libraryId: this.libraryId() })`) and
+     * it follows the signals it reads. It changes when a stamp is added, renamed or removed.
+     */
+    assetsOf(filter?: StampAssetFilter | (() => StampAssetFilter | undefined)): Signal<readonly StampAsset[]>;
+    /**
+     * An image URL for a stamp's picture (a picker's thumbnail), or null while it has none. Pass
+     * a function (`() => this.asset().id`) and it follows the stamp you show, and a picture that
+     * arrives after the stamp does.
+     *
+     * The URL is a browser resource that holds the picture's bytes, so it is released when the
+     * stamp changes and when the caller goes: call it in an injection context (a constructor or a
+     * field initializer).
+     */
+    previewUrlOf(assetId: string | null | (() => string | null)): Signal<string | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfStamp, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EpdfStamp>;
+}
+/** Stamps, with their settings: `withStamp({ assetEngine: localEngine() })` on a cloud viewer. */
+declare function withStamp(options?: StampConfig): EmbedPdfFeature;
+/** What {@link persistStampLibraries} takes besides the stamps and the store. */
+type PersistStampLibrariesOptions = NonNullable<Parameters<typeof persistStampLibraries$1>[2]>;
+/**
+ * Keep every library in `store` from now on: a change writes the library's PDF (a burst of
+ * edits saves once), a removed library is deleted. `except` names the libraries never to store,
+ * such as the standard set you import on every visit. Returns the stop, for when the caller
+ * goes: `inject(DestroyRef).onDestroy(persistStampLibraries(stamp, store))`.
+ */
+declare function persistStampLibraries(stamp: Pick<EpdfStamp, 'exportLibrary' | 'libraryChanged$'>, store: StampLibraryStore, options?: PersistStampLibrariesOptions): () => void;
+
+export { EpdfStamp, persistStampLibraries, withStamp };
+export type { PersistStampLibrariesOptions };

package/dist/testing/index.d.ts

@@ -0,0 +1,53 @@
+import { ComponentHarness, BaseHarnessFilters, HarnessPredicate, ContentContainerComponentHarness } from '@angular/cdk/testing';
+
+/**
+ * Test harnesses for the viewer's components, built on `@angular/cdk/testing`: a test talks to
+ * the Stage and the search highlights the way a user does, through the page, instead of
+ * reaching into their internals.
+ *
+ *   const loader = TestbedHarnessEnvironment.loader(fixture);
+ *   const stage = await loader.getHarness(EpdfStageHarness);
+ *   expect(await stage.getShownPageCount()).toBe(2);
+ *   const [layer] = await stage.getAllHarnesses(EpdfSearchLayerHarness);
+ *   await layer.clickHighlight(0); // (hitClick) emits the first match
+ *
+ * They read only what the components draw, so they keep working when the inside changes.
+ */
+
+/**
+ * `<epdf-stage>`. It holds harnesses for what's drawn in it: `stage.getAllHarnesses(
+ * EpdfSearchLayerHarness)` gives the search layers of the pages on screen.
+ */
+declare class EpdfStageHarness extends ContentContainerComponentHarness {
+    static hostSelector: string;
+    /** A Stage that matches `options`: `EpdfStageHarness.with({ selector: '.thumbnails' })`. */
+    static with(options?: BaseHarnessFilters): HarnessPredicate<EpdfStageHarness>;
+    private readonly pages;
+    /** How many pages are drawn now: the Stage draws only the ones on screen. */
+    getShownPageCount(): Promise<number>;
+    /** The cursor over the Stage: the one the active tool asks for, such as `text` over text. */
+    getCursor(): Promise<string>;
+    /** Turn the mouse wheel over the Stage: it scrolls, as a user's wheel does. */
+    scrollBy(deltaY: number, deltaX?: number): Promise<void>;
+}
+/**
+ * `<epdf-search-layer>`: the search's highlights on one page. A match over two lines is two
+ * highlights.
+ */
+declare class EpdfSearchLayerHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** A search layer that matches `options`. */
+    static with(options?: BaseHarnessFilters): HarnessPredicate<EpdfSearchLayerHarness>;
+    private readonly highlights;
+    private readonly activeHighlights;
+    /** How many highlights the page shows: one per line of each match on it. */
+    getHighlightCount(): Promise<number>;
+    /** How many of them belong to the active match: none when it's on another page. */
+    getActiveHighlightCount(): Promise<number>;
+    /** Whether the highlights take clicks: only while something listens to `(hitClick)`. */
+    isClickable(): Promise<boolean>;
+    /** Click the highlight at `index`, in the order the page draws them. */
+    clickHighlight(index: number): Promise<void>;
+}
+
+export { EpdfSearchLayerHarness, EpdfStageHarness };