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

package/dist/actions/index.d.ts

@@ -1,24 +1,42 @@
-import { ActionUiAdapter } from '@embedpdf/plugin-actions';
+import { ActionUiAdapter, ActionsCapability, ActionsConfig } from '@embedpdf/plugin-actions';
 export * from '@embedpdf/plugin-actions';
+import * as _embedpdf_angular_runtime from '@embedpdf/angular/runtime';
+import { EmbedPdfFeature } from '@embedpdf/angular/runtime';
+import * as i0 from '@angular/core';
 
-/** Override any subset of the default adapter policy. */
+declare const EpdfActions_base: _embedpdf_angular_runtime.PluginServiceClass<ActionsCapability, Record<never, never>, "execute" | "canExecute" | "executeNamed" | "canExecuteNamed" | "getActionTree" | "isScriptingEnabled" | "dispatch" | "canDispatch" | "setUiAdapter" | "runDocumentVerb" | "prepareClose" | "setSubmitHandler" | "registerExecutor", "onExecuted" | "onDiagnosticReported" | "onScriptDiagnosticReported" | "onScriptFailed" | "onOpenSequenceCompleted">;
+/**
+ * The actions of the document in scope (`[epdfDocumentScope]`), else the active one:
+ * `executeNamed()`, `execute()`, `dispatch()`, `getActionTree()`, the checks (`canExecuteNamed()`,
+ * `isScriptingEnabled()`, …), the settings (`settings()`, `updateSettings()`, …, which work with
+ * no document) and the streams (`executed$`, `diagnosticReported$`, `scriptFailed$`, …). With
+ * no document every other call refuses with `not-ready`.
+ */
+declare class EpdfActions extends EpdfActions_base {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpdfActions, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EpdfActions>;
+}
+/** The actions plugin, for `provideEmbedPdf()`: `withActions({ javascript: { enabled: true } })`. */
+declare function withActions(config?: ActionsConfig): EmbedPdfFeature;
+/** Your own handlers for any of the adapter's effects: `openUri`, `print`, `alert`, `gotoPage`. */
 type ActionsUiHandlers = Partial<ActionUiAdapter>;
 /**
- * Angular's spelling of React's `useActionsUiAdapter` (the `use*` →
- * `inject*` law): installs the UI adapter for the active document's action
- * dispatcher. The DEFAULT policy — the origin×phase visibility matrix,
- * sanitizeExternalUri URI opens, browser print/alert fallbacks — is
- * `@embedpdf/web`'s `createDefaultActionsUiAdapter`, written ONCE for every
- * binding; this function is Angular glue only. The doc.print AUTHORITY gate
- * is upstream (the actions plugin) and not overridable.
+ * The UI adapter of the active document's actions: the browser's defaults, with `handlers` in
+ * place of any of them. `handlers` may be a function, which runs once in an injection context,
+ * so your handlers can use your services:
+ *
+ *   withActionsUi(() => {
+ *     const toasts = inject(Toasts);
+ *     return { alert: (message) => toasts.show(message) };
+ *   })
  *
- * Must run in an injection context (a constructor or field initializer —
- * the runtime `inject*` constraint). Pass a FUNCTION for late-bound
- * handlers; signal reads inside it are NOT tracked (the adapter consults it
- * per effect, the same contract as React's handlers ref). Installing an
- * adapter releases the document-open sequence latch, exactly as in React.
+ * It follows the active document, and the Stage showing it for page moves, and is installed in
+ * the same change that makes a document ready, before anything inside it can run an action.
+ * Installing it is also the first sign of a person that lets a document's opening actions run
+ * (`openSequence: 'auto'`), so a document opened in a background tab waits until it's shown.
+ * The `doc.print` permission is checked by the plugin, before any handler runs.
  */
-declare function injectActionsUiAdapter(handlers?: ActionsUiHandlers | (() => ActionsUiHandlers | undefined)): void;
+declare function withActionsUi(handlers?: ActionsUiHandlers | (() => ActionsUiHandlers)): EmbedPdfFeature;
 
-export { injectActionsUiAdapter };
+export { EpdfActions, withActions, withActionsUi };
 export type { ActionsUiHandlers };

package/dist/anchored/index.d.ts

@@ -0,0 +1,67 @@
+import * as _embedpdf_web from '@embedpdf/web';
+import { ViewProjector, AnchorTarget, AnchoredRect, AnchoredPlacement } from '@embedpdf/web';
+export { AnchorTarget, AnchoredPlacement, AnchoredSide, PageViewEnv, ViewProjector } from '@embedpdf/web';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal } from '@angular/core';
+
+/** What a page surface gives the anchored UI inside it. */
+interface EpdfProjectorBinding {
+    /** How a box on a page lands in the surface; null while there is nothing to project onto. */
+    readonly projector: Signal<ViewProjector | null>;
+    /**
+     * Changes whenever the projection may have (the Stage's camera): anchored UI reads it, so it
+     * moves in the same pass as the pages.
+     */
+    readonly revision: Signal<unknown>;
+    /** The pages on screen, by object number; null when the surface shows a single page. */
+    readonly shownPages: Signal<ReadonlySet<number> | null>;
+    /**
+     * For a surface that moves with the browser rather than with state (a page view scrolled with
+     * the document): call `callback` after such a move. A Stage has none.
+     */
+    readonly subscribe?: (callback: () => void) => () => void;
+}
+/** Provided by page surfaces (`<epdf-stage>`, a standalone page view), not by app code. */
+declare const EPDF_PROJECTOR: InjectionToken<EpdfProjectorBinding>;
+/** Where anchored UI sits: next to a box on a page, and points it keeps clear of. */
+type EpdfAnchor = Omit<AnchorTarget, 'bounds'> & {
+    bounds?: AnchoredRect | null;
+};
+/**
+ * Its content, placed next to a box on a page. Once the content's size is measured it flips to
+ * the other side when the chosen one has no room, and stays inside the view, unless `pinned`.
+ * A pointer press inside it doesn't reach the page under it, so a click in a menu is never a
+ * click outside the selection.
+ */
+declare class EpdfAnchored {
+    /**
+     * The box on a page to sit next to, in page coordinates: `{ page, bounds }`, with `avoid`
+     * points to keep clear of. Null, or no `bounds` (a search match without a box), hides it.
+     */
+    readonly anchor: _angular_core.InputSignal<EpdfAnchor | null | undefined>;
+    /** A side of the box, centred, or lined up with that side's start or end (`'top-end'`). */
+    readonly placement: _angular_core.InputSignal<AnchoredPlacement>;
+    /** Screen pixels between the box and the content, and between the content and the view's edge. */
+    readonly gap: _angular_core.InputSignal<number>;
+    /**
+     * Stay where `placement` puts it: never flip, never move to stay in view, and scroll away with
+     * the box. For badges and status; menus leave it off.
+     */
+    readonly pinned: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly binding;
+    /** The content's size and the view's, measured once it's shown and again when either resizes. */
+    private readonly fit;
+    /** Moves the browser made that no state announces (a page view scrolled with the document). */
+    private readonly moved;
+    private readonly box;
+    protected readonly space: Signal<"overlay" | "client">;
+    /** Whether its page is on screen: until it is, nothing below reads the camera. */
+    private readonly onShownPage;
+    protected readonly position: Signal<_embedpdf_web.AnchoredPosition | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EpdfAnchored, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EpdfAnchored, "epdf-anchored", never, { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "pinned": { "alias": "pinned"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { EPDF_PROJECTOR, EpdfAnchored };
+export type { EpdfAnchor, EpdfProjectorBinding };