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

package/dist/search/index.d.ts

@@ -0,0 +1,71 @@
+import * as _embedpdf_plugin_search from '@embedpdf/plugin-search';
+import { SearchHit, SearchConfig } from '@embedpdf/plugin-search';
+export * from '@embedpdf/plugin-search';
+import * as _embedpdf_angular_runtime from '@embedpdf/angular/runtime';
+import { EmbedPdfFeature } from '@embedpdf/angular/runtime';
+import * as _embedpdf_core from '@embedpdf/core';
+import { PageRef } from '@embedpdf/core';
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+import { SearchHighlightPiece } from '@embedpdf/web';
+
+declare const EpdfSearch_base: _embedpdf_angular_runtime.PluginServiceClass<_embedpdf_plugin_search.SearchCapability, {
+    query: _embedpdf_plugin_search.SearchQuery | null;
+    status: _embedpdf_plugin_search.SearchStatus;
+    hitCount: number;
+    activeHitIndex: number;
+    activeHit: SearchHit | null;
+    progress: _embedpdf_plugin_search.SearchProgress;
+    error: _embedpdf_core.PluginErrorInfo | null;
+}, "search" | "canSearch" | "refresh" | "cancel" | "clear" | "nextHit" | "previousHit" | "goToHit" | "revealActiveHit" | "getQuery" | "getStatus" | "listHits" | "getHitCount" | "listPagesWithHits" | "getActiveHitIndex" | "getActiveHit" | "getProgress" | "getError" | "findAll", "onStarted" | "onProgressChanged" | "onCompleted" | "onCancelled" | "onFailed" | "onActiveHitChanged" | "onCleared">;
+/**
+ * Search: `search({ text })`, `nextHit()`, `goToHit(hit)` and the rest of the Search page's
+ * methods, every value of its State table as a signal (`search.hitCount()`), its events as
+ * streams (`search.completed$`), and its settings (`search.updateSettings({ highlight })`).
+ * Without a document the signals read empty and the methods refuse with `not-ready`.
+ */
+declare class EpdfSearch extends EpdfSearch_base {
+    /**
+     * Every match found so far, for a list of results. The plugin hands out the same array until
+     * matches are added, so a list redraws only when there are new ones. Empty without a document.
+     */
+    readonly hits: Signal<readonly SearchHit[]>;
+    /**
+     * The matches on one page (its ref or its index), for a count on a thumbnail. Pass a function
+     * (`() => this.page().ref`) and it follows the page you show. Empty for a page that isn't in
+     * the document, and without one.
+     */
+    hitsOn(page: PageRef | number | (() => PageRef | number)): Signal<readonly SearchHit[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfSearch, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EpdfSearch>;
+}
+/** The search plugin, with its settings: `withSearch({ highlight: { color: '#fde047' } })`. */
+declare function withSearch(options?: SearchConfig): EmbedPdfFeature;
+
+declare class EpdfSearchLayer {
+    private readonly clicks$;
+    /** A match was clicked (not dragged across): makes matches clickable while it's listened to. */
+    readonly hitClick: i0.OutputRef<SearchHit>;
+    private readonly page;
+    /** The search plugin of the page's own document. */
+    private readonly search;
+    /** This page's matches: the plugin's own array, the same until matches land on this page. */
+    private readonly hits;
+    private readonly active;
+    private readonly highlight;
+    private readonly color;
+    private readonly activeColor;
+    protected readonly blendMode: i0.Signal<string>;
+    /** One painted piece per line of each match: a box when upright, a polygon when turned. */
+    protected readonly pieces: i0.Signal<readonly SearchHighlightPiece<SearchHit>[]>;
+    /** Tells a click on a match from a drag that starts there (and selects text). */
+    private readonly clickDetector;
+    /** Whether `(hitClick)` is listened to: only then do matches take the pointer. */
+    protected get clickable(): boolean;
+    protected press(event: PointerEvent): void;
+    protected click(event: MouseEvent, hit: SearchHit): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfSearchLayer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EpdfSearchLayer, "epdf-search-layer", never, {}, { "hitClick": "hitClick"; }, never, never, true, never>;
+}
+
+export { EpdfSearch, EpdfSearchLayer, withSearch };

package/dist/selection/index.d.ts

@@ -0,0 +1,141 @@
+import * as _embedpdf_plugin_selection from '@embedpdf/plugin-selection';
+import { SelectionConfig } from '@embedpdf/plugin-selection';
+export * from '@embedpdf/plugin-selection';
+import { SelectionHandleSession } from '@embedpdf/web';
+export { copySelection } from '@embedpdf/web';
+import * as _embedpdf_angular_runtime from '@embedpdf/angular/runtime';
+import { EmbedPdfFeature } from '@embedpdf/angular/runtime';
+import * as _embedpdf_core from '@embedpdf/core';
+import { CapabilityToken } from '@embedpdf/core';
+import * as _angular_core from '@angular/core';
+import { AnchoredPlacement } from '@embedpdf/angular/anchored';
+import { StageCapability } from '@embedpdf/plugin-stage/contract';
+
+declare const EpdfSelection_base: _embedpdf_angular_runtime.PluginServiceClass<_embedpdf_plugin_selection.SelectionCapability, {
+    hasSelection: boolean;
+    isSelecting: boolean;
+    range: _embedpdf_plugin_selection.TextRange | null;
+    pages: readonly _embedpdf_core.PageRef[];
+}, "canSelect" | "canCopy" | "select" | "selectAll" | "selectPage" | "selectWordAt" | "selectLineAt" | "extendTo" | "clear" | "getSnapshot" | "getRange" | "listSelectedPages" | "listSegments" | "listRects" | "getAnchor" | "readText" | "readTextInRange", "onChanged" | "onCommitted" | "onCleared">;
+/**
+ * Text selection: `select()` and the other methods of the Selecting page, every value of its
+ * State table as a signal (`selection.hasSelection()`), its events as streams
+ * (`selection.committed$`), and its settings (`selection.settings()`,
+ * `selection.updateSettings({ color })`). Without a document the signals read empty and the
+ * methods refuse with `not-ready`.
+ */
+declare class EpdfSelection extends EpdfSelection_base {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EpdfSelection, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EpdfSelection>;
+}
+/**
+ * The selection plugin: selecting text with the pointer, a finger and from code. It works with
+ * the interaction plugin, so give `withInteraction()` too:
+ * `provideEmbedPdf({ engine }, withStage(), withInteraction(), withSelection())`.
+ */
+declare function withSelection(options?: SelectionConfig): EmbedPdfFeature;
+
+declare class EpdfSelectionLayer {
+    private readonly page;
+    private readonly host;
+    /** The selection plugin of the page's own document, with what layers need of it. */
+    private readonly selection;
+    /** This page's selected lines: the same array until the selection on this page changes. */
+    private readonly segments;
+    /** False while something else draws the selection itself (a highlighter's preview). */
+    protected readonly visible: _angular_core.Signal<boolean>;
+    private readonly color;
+    /** Each line's corners in the page's pixels, which turn with the page. */
+    protected readonly polygons: _angular_core.Signal<string[]>;
+    /** The CSS variable, then the setting, then the accent (with its own variable) at 35%. */
+    protected readonly fill: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EpdfSelectionLayer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EpdfSelectionLayer, "epdf-selection-layer", never, {}, {}, never, never, true, never>;
+}
+
+declare class EpdfSelectionMenu {
+    /** Which side of the selection: `'top'`, `'bottom'`, `'left'` or `'right'`, or a corner. */
+    readonly placement: _angular_core.InputSignal<AnchoredPlacement>;
+    /** Screen pixels between the selection and the menu. */
+    readonly gap: _angular_core.InputSignal<number>;
+    /** The selection of the document this part of the template talks to. */
+    private readonly selection;
+    private readonly selecting;
+    private readonly settled;
+    /** Where the menu goes; nothing while a drag is still selecting. */
+    protected readonly anchor: _angular_core.Signal<_embedpdf_plugin_selection.SelectionAnchor | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EpdfSelectionMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EpdfSelectionMenu, "epdf-selection-menu", never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type Role = 'start' | 'end';
+/** One handle, laid out in the Stage's own box. */
+interface HandleLayout {
+    readonly role: Role;
+    readonly left: number;
+    readonly top: number;
+    readonly height: number;
+    readonly barTop: number;
+    readonly barHeight: number;
+    readonly headTop: number;
+    /** Null for upright text: an upright handle carries no transform. */
+    readonly transform: string | null;
+    readonly transformOrigin: string | null;
+}
+/** What a press on a handle starts: the point it grabbed (the bar's middle), and the drag. */
+type SelectionGripDrag = {
+    readonly base: {
+        readonly x: number;
+        readonly y: number;
+    };
+    readonly session: SelectionHandleSession;
+} | null;
+declare class EpdfSelectionHandles {
+    /** The view the handles are drawn over: the Stage they're in, unless you name another. */
+    readonly token: _angular_core.InputSignal<CapabilityToken<StageCapability> | undefined>;
+    protected readonly pad = 14;
+    protected readonly bar = 2;
+    protected readonly head = 12;
+    protected readonly gripWidth: number;
+    private readonly host;
+    private readonly enclosingStage;
+    /** How the surface it's in places things: the Stage's camera, or nothing to project through. */
+    private readonly projection;
+    private readonly documentId;
+    private readonly selection;
+    private readonly stage;
+    private readonly selecting;
+    private readonly visible;
+    private readonly settings;
+    /** Both ends of the selection, compared corner by corner: the same until one moves. */
+    private readonly endpoints;
+    /** The handle being dragged: it keeps both handles shown while it selects. */
+    private readonly dragging;
+    /** Each color is its CSS variable first, then the setting; an unset color is the accent. */
+    protected readonly color: _angular_core.Signal<string>;
+    protected readonly shadow: _angular_core.Signal<string>;
+    /** Whether this sits over a Stage, the only surface with a camera to place handles through. */
+    private readonly overStage;
+    protected readonly handles: _angular_core.Signal<readonly HandleLayout[]>;
+    protected readonly armStart: () => SelectionGripDrag;
+    protected readonly armEnd: () => SelectionGripDrag;
+    constructor();
+    /** A press on a handle: start a drag from the other end, with the selection as it is now. */
+    private arm;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EpdfSelectionHandles, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EpdfSelectionHandles, "epdf-selection-handles", never, { "token": { "alias": "token"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class EpdfSelectionClipboard {
+    /** Read the selected text when the selection settles (default true). */
+    readonly prefetch: _angular_core.InputSignal<boolean | undefined>;
+    /** Ctrl+C or the Copy menu met a selection the user may not copy: say so. */
+    readonly refused: _angular_core.OutputEmitterRef<void>;
+    private readonly selection;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EpdfSelectionClipboard, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EpdfSelectionClipboard, "epdf-selection-clipboard, [epdfSelectionClipboard]", never, { "prefetch": { "alias": "prefetch"; "required": false; "isSignal": true; }; }, { "refused": "refused"; }, never, never, true, never>;
+}
+
+export { EpdfSelection, EpdfSelectionClipboard, EpdfSelectionHandles, EpdfSelectionLayer, EpdfSelectionMenu, withSelection };

package/dist/shell/index.d.ts

@@ -0,0 +1,88 @@
+import * as _embedpdf_plugin_shell from '@embedpdf/plugin-shell';
+import { SurfaceProps, OpenSurfaceOptions } from '@embedpdf/plugin-shell';
+export * from '@embedpdf/plugin-shell';
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+import * as _embedpdf_angular_runtime from '@embedpdf/angular/runtime';
+import { EmbedPdfFeature } from '@embedpdf/angular/runtime';
+
+/** One named panel, dialog or overlay of the service's document. */
+interface EpdfSurface {
+    /** Whether it's open; false without a document. */
+    readonly isOpen: Signal<boolean>;
+    /** The props it was opened with, or updated to; empty when it has none. */
+    readonly props: Signal<SurfaceProps>;
+    /** Open it: `exclusive` closes the others of that group, `props` travel with it. */
+    open(options?: OpenSurfaceOptions): void;
+    close(): void;
+    /** Open it when it's closed, close it when it's open. */
+    toggle(options?: OpenSurfaceOptions): void;
+}
+declare const EpdfShell_base: _embedpdf_angular_runtime.PluginServiceClass<_embedpdf_plugin_shell.ShellCapability, {
+    openSurfaces: readonly _embedpdf_plugin_shell.SurfaceState[];
+    openMenus: readonly string[];
+}, "open" | "close" | "toggle" | "isOpen" | "getSurface" | "listOpenSurfaces" | "updateSurfaceProps" | "closeAll" | "isMenuOpen" | "listOpenMenus" | "openMenu" | "closeMenu" | "toggleMenu" | "closeAllMenus" | "getSnapshot" | "applySnapshot", "onSurfaceOpened" | "onSurfaceClosed" | "onMenuOpened" | "onMenuClosed">;
+/**
+ * The panels, dialogs and menus of this part of the template's document: `openSurfaces()` and
+ * `openMenus()` as signals, the shell's methods, `surfaceOpened$` and the other events, and
+ * `surface(id)` for one panel.
+ */
+declare class EpdfShell extends EpdfShell_base {
+    /**
+     * One panel, dialog or overlay: `isOpen()` and `props()` as signals, and `open()`, `close()`
+     * and `toggle()`. Pass a function for an id that changes (a component's input). Without a
+     * document it reads as closed and its verbs do nothing.
+     *
+     *   protected readonly panel = inject(EpdfShell).surface('comments');
+     */
+    surface(id: string | (() => string)): EpdfSurface;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfShell, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EpdfShell>;
+}
+/** The shell plugin: which panels, dialogs and menus are open, per document. */
+declare function withShell(): EmbedPdfFeature;
+/**
+ * A button of yours that opens and closes a panel, and says whether it's open
+ * (`aria-expanded`). `epdfPanelToggleExclusive` gives the panel its group, so opening it
+ * closes the group's other panel:
+ *
+ *   <button epdfPanelToggle="comments" epdfPanelToggleExclusive="right">Comments</button>
+ *
+ * The template reference has `isOpen()`: `#comments="epdfPanelToggle"`.
+ */
+declare class EpdfPanelToggle {
+    /** The panel's name. */
+    readonly id: i0.InputSignal<string>;
+    /** Its group: opening it closes the other open panel of the same group. */
+    readonly exclusive: i0.InputSignal<string | undefined>;
+    private readonly panel;
+    /** Whether the panel is open. */
+    readonly isOpen: Signal<boolean>;
+    /** Open the panel when it's closed, close it when it's open. */
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfPanelToggle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EpdfPanelToggle, "[epdfPanelToggle]", ["epdfPanelToggle"], { "id": { "alias": "epdfPanelToggle"; "required": true; "isSignal": true; }; "exclusive": { "alias": "epdfPanelToggleExclusive"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * An element of yours that takes the cursor when the panel `epdfSurfaceFocus` names asks for it:
+ * on every `open(id, { focus: true })`, a command whose panel says `focus` among them, and when
+ * the element appears while the request is up (the panel opened, or its code loaded, because of
+ * it). A plain open never moves it. `epdfSurfaceFocusSelect` selects an input's text, so typing
+ * replaces it:
+ *
+ *   <input epdfSurfaceFocus="search" epdfSurfaceFocusSelect [(ngModel)]="query" />
+ *
+ * It reads the panel of this part of the template's document.
+ */
+declare class EpdfSurfaceFocus {
+    /** The panel's name. */
+    readonly id: i0.InputSignal<string>;
+    /** Select the text of an input or a text area as it takes focus. */
+    readonly select: i0.InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfSurfaceFocus, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EpdfSurfaceFocus, "[epdfSurfaceFocus]", never, { "id": { "alias": "epdfSurfaceFocus"; "required": true; "isSignal": true; }; "select": { "alias": "epdfSurfaceFocusSelect"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { EpdfPanelToggle, EpdfShell, EpdfSurfaceFocus, withShell };
+export type { EpdfSurface };

package/dist/signature/index.d.ts

@@ -0,0 +1,45 @@
+import * as _embedpdf_plugin_signature from '@embedpdf/plugin-signature';
+import { SignerRow, SignatureConfig } from '@embedpdf/plugin-signature';
+export * from '@embedpdf/plugin-signature';
+import * as _embedpdf_angular_runtime from '@embedpdf/angular/runtime';
+import { EmbedPdfFeature } from '@embedpdf/angular/runtime';
+import * as _embedpdf_core from '@embedpdf/core';
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+
+declare const EpdfSignature_base: _embedpdf_angular_runtime.PluginServiceClass<_embedpdf_plugin_signature.SignatureCapability, {
+    signatures: readonly _embedpdf_plugin_signature.SignatureInfo[];
+    protection: _embedpdf_plugin_signature.DocumentProtection | null;
+    target: _embedpdf_plugin_signature.FormFieldRef | null;
+    busy: boolean;
+    pending: _embedpdf_plugin_signature.SignaturePending | null;
+    status: _embedpdf_core.ResourceStatus;
+}, "sign" | "getStatus" | "refresh" | "validate" | "getSnapshot" | "canFill" | "listSignatures" | "listUnsignedFields" | "getSignature" | "listVerdicts" | "getVerdict" | "getProtection" | "getPending" | "isBusy" | "getMode" | "getTarget" | "prepareSignature" | "completeSignature" | "cancelPending" | "fillField" | "clearField" | "placeMark" | "setTarget" | "requestInspection" | "validateField" | "analyzeChanges" | "readRevision" | "canSign" | "canCertify" | "canReadRevision", "onSigned" | "onFilled" | "onCleared" | "onValidated" | "onProtectionChanged" | "onInvalidationPredicted" | "onTargetChanged" | "onSignRequested" | "onInspectionRequested">;
+/**
+ * Signatures: `signatures()`, `protection()`, `target()`, `busy()`, `pending()` and `status()`
+ * as signals; signing, filling and checking as methods (`sign()`, `placeMark()`,
+ * `fillField()`, `validate()`, …, the Signatures page's Methods table); the events as streams
+ * (`signed$`, `invalidationPredicted$`, `targetChanged$`, …); and the settings. Without a
+ * document, `signatures()` is empty and a method refuses with `not-ready`.
+ */
+declare class EpdfSignature extends EpdfSignature_base {
+    /** The stamp plugin, where a person's marks are kept; absent without `withStamp()`. */
+    private readonly stamp;
+    private readonly libraries;
+    private readonly assets;
+    /**
+     * The people whose marks this browser holds, one row per stamp library of kind
+     * `signatures`, each with its signatures and its initials, for a picker. Empty without the
+     * stamp plugin. Rename, delete and export a person with the stamp plugin's library methods.
+     */
+    readonly signerRows: Signal<readonly SignerRow[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfSignature, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EpdfSignature>;
+}
+/**
+ * The signature plugin, with its settings: the `key` to sign with (a signer, or a function that
+ * gives one when someone signs), the `mode`, the certificates you `trust`, and `allowCertify`.
+ */
+declare function withSignature(config?: SignatureConfig): EmbedPdfFeature;
+
+export { EpdfSignature, withSignature };