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

package/dist/runtime/readers.svelte.js

@@ -0,0 +1,122 @@
+/**
+ * The generic readers every plugin binding is built from: a value derived from the kernel, a
+ * plugin's capability (as a handle, or the raw object), a value selected from it, and its events.
+ *
+ * Call them while a component is created, like every `use…()` function: they read the viewer and
+ * the document scope from context, and the event readers clean up when the component goes away.
+ */
+import { untrack } from 'svelte';
+import { standInFor } from '@embedpdf/core';
+import { documentScopeOf, useKernelBinding } from './binding.svelte.js';
+import { capabilityHandle } from './capability-handle.js';
+import { currentOf, derivedValue, valueOf, } from './values.svelte.js';
+/** Equal when the two arrays hold the same items in the same order. */
+export const shallowArray = (left, right) => left === right || (left.length === right.length && left.every((item, i) => item === right[i]));
+/**
+ * A value derived from the kernel, computed again after every kernel change and passed on only
+ * when `isEqual` says it changed.
+ */
+export function useKernelValue(select, isEqual = Object.is) {
+    const binding = useKernelBinding();
+    return currentOf(derivedValue(() => {
+        binding.track();
+        return select(binding.kernel);
+    }, isEqual));
+}
+/** The active document's id, or null with none open. */
+export function useActiveDocumentId() {
+    return useKernelValue((kernel) => kernel.documents.getActiveId());
+}
+/** The document the nearest `<DocumentScope>` names, or null when this subtree follows the active one. */
+export function useDocumentScope() {
+    return currentOf(documentScopeOf());
+}
+/** The document this subtree talks to: the nearest `<DocumentScope>`'s, else the active one. */
+export function useDocumentId() {
+    const scoped = documentScopeOf();
+    return useKernelValue((kernel) => scoped() ?? kernel.documents.getActiveId());
+}
+/**
+ * A plugin's capability, as a handle that is always the capability of the document in scope
+ * (see `./capability-handle.ts`). Outside a ready document a document plugin's calls refuse with
+ * `not-ready` (a method that returns a promise rejects), and its settings calls still work. A token no plugin provides throws now: a setup
+ * mistake. The token may be a function, for a component whose token is a prop.
+ */
+export function useCapability(token) {
+    const binding = useKernelBinding();
+    const { kernel } = binding;
+    const scoped = documentScopeOf();
+    const initial = untrack(() => valueOf(token));
+    if (kernel.scopeOf(initial) !== 'document')
+        kernel.capability(initial);
+    return capabilityHandle(() => {
+        const current = valueOf(token);
+        return kernel.tryCapability(current, scoped() ?? undefined) ?? standInFor(kernel, current);
+    }, () => binding.track());
+}
+/**
+ * The capability itself, or null while the token can't resolve (no plugin, no document, or a
+ * document that isn't ready yet). The object is the plugin's own, so it can be handed to code
+ * that keeps it, such as an effect that registers something with it.
+ */
+export function useOptionalCapability(token) {
+    const binding = useKernelBinding();
+    const scoped = documentScopeOf();
+    return currentOf(derivedValue(() => {
+        binding.track();
+        return binding.kernel.tryCapability(valueOf(token), scoped() ?? undefined);
+    }));
+}
+/**
+ * A value selected from a capability. Strict: while the token can't resolve, reading it throws
+ * the kernel's reason (no document, the document is loading), for code that knows a document
+ * exists, such as anything inside a `<DocumentGate>`. {@link useOptionalSelector} is its total twin.
+ */
+export function useSelector(token, select, isEqual = Object.is) {
+    const binding = useKernelBinding();
+    const scoped = documentScopeOf();
+    return currentOf(derivedValue(() => {
+        binding.track();
+        const current = valueOf(token);
+        const documentId = scoped() ?? undefined;
+        const capability = binding.kernel.tryCapability(current, documentId) ??
+            binding.kernel.capability(current, documentId);
+        return select(capability);
+    }, isEqual));
+}
+/**
+ * A value selected from a capability, or `fallback` while the token can't resolve: for chrome
+ * that stays mounted while no document is open (a zoom readout). A read through a capability
+ * whose document closed a moment ago gives `fallback` too.
+ */
+export function useOptionalSelector(token, select, fallback, isEqual = Object.is) {
+    const binding = useKernelBinding();
+    const scoped = documentScopeOf();
+    return currentOf(derivedValue(() => {
+        binding.track();
+        const capability = binding.kernel.tryCapability(valueOf(token), scoped() ?? undefined);
+        if (capability === null)
+            return fallback;
+        try {
+            return select(capability);
+        }
+        catch {
+            return fallback;
+        }
+    }, isEqual));
+}
+/**
+ * Subscribe to one of a capability's events while the component lives:
+ * `useCapabilityEvent(StageToken, (stage) => stage.onZoomChanged, handler)`. It subscribes again
+ * when the document in scope changes, and not at all without one. Events say what happened;
+ * the current value is a state reader's.
+ */
+export function useCapabilityEvent(token, select, handler) {
+    const capability = useOptionalCapability(token);
+    $effect(() => {
+        const current = capability.current;
+        if (!current)
+            return;
+        return untrack(() => select(current)((event) => handler(event)));
+    });
+}

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

@@ -0,0 +1,35 @@
+import type { CapabilityToken, SettingsOf, StateDeclaration } from '@embedpdf/core';
+import { type KernelBinding } from './binding.svelte.js';
+import { type CurrentValue, type MaybeGetter } from './values.svelte.js';
+/** A declared state's reader: the whole state, or the value `select` picks from it. */
+export interface StateReader<State extends object> {
+    (): Readonly<State>;
+    <Selected>(select: (state: State) => Selected): CurrentValue<Selected>;
+}
+/** A plugin's settings reader: the settings, or the value `select` picks from them. */
+export interface SettingsReader<Settings extends object> {
+    (): Readonly<Settings>;
+    <Selected>(select: (settings: Settings) => Selected): CurrentValue<Selected>;
+}
+/**
+ * The whole state, read through the capability `token` resolves for this subtree's document, or
+ * `empty` while it can't resolve. Resolved on every read: a document that closes reads as `empty`,
+ * never through its closed capability.
+ */
+export declare function declaredState<Capability, State extends object>(binding: KernelBinding, token: MaybeGetter<CapabilityToken<Capability>>, read: (capability: Capability) => State, empty: State): () => State;
+/** The reader's two forms over one getter: a reactive object with `keys`, or a selected value. */
+export declare function readRecord<Record extends object, Selected>(whole: () => Record, keys: readonly (keyof Record)[], select: ((record: Record) => Selected) | undefined): Readonly<Record> | CurrentValue<Selected>;
+/**
+ * Turn a state declaration into its reader. It reads this subtree's document (the nearest
+ * `<DocumentScope>`, else the active one) and gives the declaration's `empty` while that
+ * document is missing or not ready, so it works anywhere. State the plugin loads on demand
+ * (the declaration's `ensure`) loads once a ready document's capability is in scope.
+ */
+export declare function stateReader<Capability, State extends object>(declaration: StateDeclaration<Capability, State>): StateReader<State>;
+/**
+ * Turn a plugin's token into its settings reader. A plugin's settings belong to the plugin as
+ * the app registered it, not to a document, so the reader works before the first document opens
+ * and every document shows the same settings. `getSettings()` keeps its object until a setting
+ * changes. A token whose plugin isn't installed, or has no settings, throws: a setup mistake.
+ */
+export declare function settingsReader<Capability>(token: CapabilityToken<Capability>): SettingsReader<SettingsOf<Capability> & object>;

package/dist/runtime/state.svelte.js

@@ -0,0 +1,90 @@
+/**
+ * Declared state and settings as Svelte readers. A plugin declares its state once with
+ * `defineState` and its settings once in its definition (both in `@embedpdf/core`), and its
+ * Svelte bindings are one line each:
+ *
+ *   export const useSearchState = stateReader(searchState);
+ *   export const useSearchSettings = settingsReader(SearchToken);
+ *
+ * Called with no argument, a reader returns a reactive object (`state.hitCount`), one derived
+ * value per field. Called with a selector, it returns the value the selector picks as
+ * `{ current }`, compared field by field so a fresh object passes nothing on until a field changes.
+ */
+import { untrack } from 'svelte';
+import { shallowEqual } from '@embedpdf/core';
+import { documentScopeOf, useKernelBinding } from './binding.svelte.js';
+import { currentOf, derivedValue, reactiveRecord, valueOf, } from './values.svelte.js';
+/**
+ * The whole state, read through the capability `token` resolves for this subtree's document, or
+ * `empty` while it can't resolve. Resolved on every read: a document that closes reads as `empty`,
+ * never through its closed capability.
+ */
+export function declaredState(binding, token, read, empty) {
+    const scoped = documentScopeOf();
+    return derivedValue(() => {
+        binding.track();
+        const capability = binding.kernel.tryCapability(valueOf(token), scoped() ?? undefined);
+        return capability ? read(capability) : empty;
+    }, shallowEqual);
+}
+/** The reader's two forms over one getter: a reactive object with `keys`, or a selected value. */
+export function readRecord(whole, keys, select) {
+    if (!select)
+        return reactiveRecord(whole, keys);
+    return currentOf(derivedValue(() => select(whole()), shallowEqual));
+}
+/**
+ * Load state the plugin loads on demand (`ensure`) for each capability the reader comes to read:
+ * once a ready document's capability is in scope, and again for the next document's.
+ */
+function ensureWhileRead(binding, token, ensure) {
+    const scoped = documentScopeOf();
+    let ensured = null;
+    $effect(() => {
+        binding.track();
+        const capability = binding.kernel.tryCapability(token, scoped() ?? undefined);
+        if (!capability || capability === ensured)
+            return;
+        ensured = capability;
+        // The state says when the load fails (its status), so the rejection has nothing to add.
+        untrack(() => ensure(capability).catch(() => { }));
+    });
+}
+/**
+ * Turn a state declaration into its reader. It reads this subtree's document (the nearest
+ * `<DocumentScope>`, else the active one) and gives the declaration's `empty` while that
+ * document is missing or not ready, so it works anywhere. State the plugin loads on demand
+ * (the declaration's `ensure`) loads once a ready document's capability is in scope.
+ */
+export function stateReader(declaration) {
+    const keys = Object.keys(declaration.empty);
+    const { ensure } = declaration;
+    return function useDeclaredState(select) {
+        const binding = useKernelBinding();
+        const whole = declaredState(binding, declaration.token, declaration.read, declaration.empty);
+        if (ensure)
+            ensureWhileRead(binding, declaration.token, ensure);
+        return readRecord(whole, keys, select);
+    };
+}
+/** A plugin's settings through the kernel: the same with or without a document. */
+function settingsOf(kernel, token) {
+    return kernel.settingsOf(token).getSettings();
+}
+/**
+ * Turn a plugin's token into its settings reader. A plugin's settings belong to the plugin as
+ * the app registered it, not to a document, so the reader works before the first document opens
+ * and every document shows the same settings. `getSettings()` keeps its object until a setting
+ * changes. A token whose plugin isn't installed, or has no settings, throws: a setup mistake.
+ */
+export function settingsReader(token) {
+    return function useSettings(select) {
+        const binding = useKernelBinding();
+        const initial = settingsOf(binding.kernel, token);
+        const whole = derivedValue(() => {
+            binding.track();
+            return settingsOf(binding.kernel, token);
+        }, shallowEqual);
+        return readRecord(whole, Object.keys(initial), select);
+    };
+}

package/dist/runtime/theme.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `epdfTheme()`: a theme written with setting names, as a `style` for the element around your
+ * viewer. The variables and their lookup are framework-free (`@embedpdf/web`); this writes them
+ * as the CSS text a Svelte `style` attribute takes.
+ */
+import { type EpdfTheme } from '@embedpdf/web';
+export type { EpdfTheme } from '@embedpdf/web';
+/**
+ * The CSS variables of a theme, for a `style` attribute: `<div style={epdfTheme({ accent })}>`.
+ * Everything inside the element follows them, and a CSS variable wins over any setting.
+ */
+export declare function epdfTheme(theme: EpdfTheme): string;

package/dist/runtime/theme.js

@@ -0,0 +1,15 @@
+/**
+ * `epdfTheme()`: a theme written with setting names, as a `style` for the element around your
+ * viewer. The variables and their lookup are framework-free (`@embedpdf/web`); this writes them
+ * as the CSS text a Svelte `style` attribute takes.
+ */
+import { epdfThemeVariables } from '@embedpdf/web';
+/**
+ * The CSS variables of a theme, for a `style` attribute: `<div style={epdfTheme({ accent })}>`.
+ * Everything inside the element follows them, and a CSS variable wins over any setting.
+ */
+export function epdfTheme(theme) {
+    return Object.entries(epdfThemeVariables(theme))
+        .map(([name, value]) => `${name}: ${value};`)
+        .join(' ');
+}

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

@@ -0,0 +1,28 @@
+/**
+ * The two shapes a reader returns, and the derived value both are made of.
+ *
+ * - One value is `{ current }`, like Svelte's own `MediaQuery`: `pages.current`.
+ * - A record of named values (a plugin's state, its settings) is a reactive object whose fields
+ *   are getters: `state.zoomLevel`. Each field is its own `$derived`, so a template or an effect
+ *   that reads `zoomLevel` runs again only when `zoomLevel` changes.
+ */
+/** A value that changes: read `current` in a template, a `$derived` or an effect. */
+export interface CurrentValue<T> {
+    readonly current: T;
+}
+/** An argument that may change: the value, or a function that returns it (`() => note.ref`). */
+export type MaybeGetter<T> = T | (() => T);
+/** The value of a {@link MaybeGetter}. Only for values that are never functions themselves. */
+export declare function valueOf<T>(value: MaybeGetter<T>): T;
+/**
+ * A `$derived` that keeps its last value while `isEqual` says the new one is the same, so a value
+ * built fresh on every read (an object a selector returns) passes nothing on until a field changes.
+ */
+export declare function derivedValue<T>(compute: () => T, isEqual?: (left: T, right: T) => boolean): () => T;
+/** `{ current }` over a getter. */
+export declare function currentOf<T>(read: () => T): CurrentValue<T>;
+/**
+ * A reactive object with `keys` as getters over `whole()`, each its own derived value. The keys
+ * are fixed when it is made: a declared state's `empty`, or the settings it starts with.
+ */
+export declare function reactiveRecord<Record extends object>(whole: () => Record, keys: readonly (keyof Record)[]): Readonly<Record>;

package/dist/runtime/values.svelte.js

@@ -0,0 +1,51 @@
+/**
+ * The two shapes a reader returns, and the derived value both are made of.
+ *
+ * - One value is `{ current }`, like Svelte's own `MediaQuery`: `pages.current`.
+ * - A record of named values (a plugin's state, its settings) is a reactive object whose fields
+ *   are getters: `state.zoomLevel`. Each field is its own `$derived`, so a template or an effect
+ *   that reads `zoomLevel` runs again only when `zoomLevel` changes.
+ */
+/** The value of a {@link MaybeGetter}. Only for values that are never functions themselves. */
+export function valueOf(value) {
+    return typeof value === 'function' ? value() : value;
+}
+/**
+ * A `$derived` that keeps its last value while `isEqual` says the new one is the same, so a value
+ * built fresh on every read (an object a selector returns) passes nothing on until a field changes.
+ */
+export function derivedValue(compute, isEqual = Object.is) {
+    let last = null;
+    const value = $derived.by(() => {
+        const next = compute();
+        if (last !== null && isEqual(last.value, next))
+            return last.value;
+        last = { value: next };
+        return next;
+    });
+    return () => value;
+}
+/** `{ current }` over a getter. */
+export function currentOf(read) {
+    return {
+        get current() {
+            return read();
+        },
+    };
+}
+/** One field of a record, as its own `$derived`: it passes a change on only when the field changed. */
+function fieldOf(whole, key) {
+    const field = $derived(whole()[key]);
+    return () => field;
+}
+/**
+ * A reactive object with `keys` as getters over `whole()`, each its own derived value. The keys
+ * are fixed when it is made: a declared state's `empty`, or the settings it starts with.
+ */
+export function reactiveRecord(whole, keys) {
+    const record = {};
+    for (const key of keys) {
+        Object.defineProperty(record, key, { get: fieldOf(whole, key), enumerable: true });
+    }
+    return record;
+}

package/dist/runtime.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @embedpdf/svelte/runtime — the generic binding.
+ *
+ * `<Viewer>` owns the kernel, and `<KernelProvider>` gives a subtree a kernel someone else owns;
+ * the readers turn its one change stream into Svelte reactivity and resolve capabilities against
+ * the document in scope (the active one, or a `<DocumentScope>`'s), with a stand-in while there is
+ * none; the page context is the seam every layer draws through. Every plugin binding is built from
+ * these. How to add one: this package's README.
+ */
+export * from '@embedpdf/core';
+export { mountWebFont, saveFile } from '@embedpdf/web';
+export { default as Viewer } from './runtime/Viewer.svelte';
+export { default as KernelProvider } from './runtime/KernelProvider.svelte';
+export { default as DocumentGate } from './runtime/DocumentGate.svelte';
+export { default as DocumentScope } from './runtime/DocumentScope.svelte';
+export type { DocumentGateProps, DocumentScopeProps, KernelProviderProps, ViewerProps, } from './runtime/props.js';
+export { useKernel } from './runtime/binding.svelte.js';
+export { shallowArray, useActiveDocumentId, useCapability, useCapabilityEvent, useDocumentId, useDocumentScope, useKernelValue, useOptionalCapability, useOptionalSelector, useSelector, } from './runtime/readers.svelte.js';
+export { useDocument, useDocuments, useDocumentsEvent, useDocumentsState, usePageList, useViewerSettings, } from './runtime/documents.svelte.js';
+export { settingsReader, stateReader } from './runtime/state.svelte.js';
+export type { SettingsReader, StateReader } from './runtime/state.svelte.js';
+export type { CurrentValue, MaybeGetter } from './runtime/values.svelte.js';
+export { makePageContext, setPageContext, usePage } from './runtime/page.js';
+export type { PageContextValue } from './runtime/page.js';
+export { epdfTheme } from './runtime/theme.js';
+export type { EpdfTheme } from './runtime/theme.js';

package/dist/runtime.js

@@ -0,0 +1,25 @@
+/**
+ * @embedpdf/svelte/runtime — the generic binding.
+ *
+ * `<Viewer>` owns the kernel, and `<KernelProvider>` gives a subtree a kernel someone else owns;
+ * the readers turn its one change stream into Svelte reactivity and resolve capabilities against
+ * the document in scope (the active one, or a `<DocumentScope>`'s), with a stand-in while there is
+ * none; the page context is the seam every layer draws through. Every plugin binding is built from
+ * these. How to add one: this package's README.
+ */
+// Registration travels with the UI: the kernel's types, tokens and helpers come from here too.
+export * from '@embedpdf/core';
+// What a page with a viewer needs from the browser: handing bytes to the user as a download,
+// and a font the engine draws with, for text you draw yourself.
+export { mountWebFont, saveFile } from '@embedpdf/web';
+export { default as Viewer } from './runtime/Viewer.svelte';
+export { default as KernelProvider } from './runtime/KernelProvider.svelte';
+export { default as DocumentGate } from './runtime/DocumentGate.svelte';
+export { default as DocumentScope } from './runtime/DocumentScope.svelte';
+export { useKernel } from './runtime/binding.svelte.js';
+export { shallowArray, useActiveDocumentId, useCapability, useCapabilityEvent, useDocumentId, useDocumentScope, useKernelValue, useOptionalCapability, useOptionalSelector, useSelector, } from './runtime/readers.svelte.js';
+export { useDocument, useDocuments, useDocumentsEvent, useDocumentsState, usePageList, useViewerSettings, } from './runtime/documents.svelte.js';
+export { settingsReader, stateReader } from './runtime/state.svelte.js';
+export { makePageContext, setPageContext, usePage } from './runtime/page.js';
+// A theme written with setting names, as the style for the element around a viewer.
+export { epdfTheme } from './runtime/theme.js';

package/dist/search/SearchLayer.svelte

@@ -0,0 +1,94 @@
+<!--
+  The search matches on one page, the selection layer's twin: it reads the page's matches in page
+  space from the plugin and maps them through the page's transform, in the colors of the plugin's
+  `highlight` setting, which the `--epdf-search-*` CSS variables win over. It calls no engine:
+  searching is app chrome's, through `useSearch()`.
+-->
+<script lang="ts">
+  import type { SearchHit } from '@embedpdf/plugin-search';
+  import { createClickDetector, paint, searchHighlightsOf } from '@embedpdf/web';
+  import { usePage } from '../runtime/page.js';
+  import type { SearchLayerProps } from './props.js';
+  import { useSearchHits, useSearchSettings, useSearchState } from './readers.svelte.js';
+
+  let { onHitClick }: SearchLayerProps = $props();
+
+  const page = usePage();
+  // The plugin keeps a page's list until matches land on it, so this redraws only then.
+  const hits = useSearchHits(() => page.ref);
+  // The record form: `activeHit` passes on only when it is another match (compared by identity).
+  const search = useSearchState();
+  const highlight = useSearchSettings((settings) => settings.highlight);
+  // Tells a click on a match from a drag that starts there (and selects text).
+  const clicks = createClickDetector();
+
+  // Each color is its CSS variable first, then the setting: CSS wins.
+  const color = $derived(paint('search-highlight', highlight.current.color));
+  const activeColor = $derived(paint('search-highlight-active', highlight.current.activeColor));
+  const blendMode = $derived(paint('search-blend-mode', highlight.current.blendMode));
+  // One piece per line of each match: a rounded box when upright, its true quad when turned.
+  const pieces = $derived(
+    searchHighlightsOf(hits.current, {
+      active: search.activeHit,
+      page: page.transform,
+      color,
+      activeColor,
+    }),
+  );
+
+  // Nothing here stops the press, so it reaches the page as well: a drag that starts on a match
+  // selects text, and only a click counts.
+  const press = (event: PointerEvent) => clicks.press(event);
+  const click = (hit: SearchHit, event: MouseEvent) => {
+    if (clicks.isClick(event)) onHitClick?.(hit);
+  };
+</script>
+
+{#if hits.current.length > 0}
+  <div style="position: absolute; inset: 0; pointer-events: none">
+    <!-- Only a clickable match takes the pointer; a plain highlight stays inert. A match isn't a
+         control of its own: the keyboard moves between matches with the search's next and
+         previous. -->
+    {#each pieces as piece (piece.key)}
+      {#if piece.box}
+        <!-- An upright line is a rounded box. -->
+        <!-- svelte-ignore a11y_click_events_have_key_events, a11y_no_static_element_interactions -->
+        <div
+          style:position="absolute"
+          style:left="{piece.box.left}px"
+          style:top="{piece.box.top}px"
+          style:width="{piece.box.width}px"
+          style:height="{piece.box.height}px"
+          style:background-color={piece.fill}
+          style:mix-blend-mode={blendMode}
+          style:border-radius="2px"
+          style:pointer-events={onHitClick ? 'auto' : undefined}
+          style:cursor={onHitClick ? 'pointer' : undefined}
+          onpointerdown={onHitClick ? press : undefined}
+          onclick={onHitClick ? (event) => click(piece.hit, event) : undefined}
+        ></div>
+      {:else}
+        <!-- A turned line draws its true quad. -->
+        <svg
+          style:position="absolute"
+          style:inset="0"
+          style:width="100%"
+          style:height="100%"
+          style:overflow="visible"
+          style:mix-blend-mode={blendMode}
+        >
+          <!-- The fill is in `style`: an SVG attribute doesn't read var(). -->
+          <!-- svelte-ignore a11y_click_events_have_key_events, a11y_no_static_element_interactions -->
+          <polygon
+            points={piece.points}
+            style:fill={piece.fill}
+            style:pointer-events={onHitClick ? 'auto' : undefined}
+            style:cursor={onHitClick ? 'pointer' : undefined}
+            onpointerdown={onHitClick ? press : undefined}
+            onclick={onHitClick ? (event) => click(piece.hit, event) : undefined}
+          />
+        </svg>
+      {/if}
+    {/each}
+  </div>
+{/if}

package/dist/search/SearchLayer.svelte.d.ts

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

package/dist/search/props.d.ts

@@ -0,0 +1,11 @@
+/** The props of `<SearchLayer>`. */
+import type { SearchHit } from '@embedpdf/plugin-search';
+export interface SearchLayerProps {
+    /**
+     * Make matches clickable: called with the match someone clicks, for example to make it the
+     * active one with `search.goToHit(hit)`. The press still reaches the page, so a drag that
+     * starts on a match selects text, and only a click calls this. Without it, matches are only
+     * paint and the pointer goes straight through.
+     */
+    onHitClick?: (hit: SearchHit) => void;
+}

package/dist/search/props.js

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

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

@@ -0,0 +1,41 @@
+/**
+ * The search plugin's readers: `useSearch()` (the API), `useSearchState()`,
+ * `useSearchSettings()`, `useSearchEvent()`, and `useSearchHits()` for a results list.
+ */
+import type { EventHook, PageRef } from '@embedpdf/core';
+import type { SearchCapability, SearchHit } from '@embedpdf/plugin-search';
+import { type CurrentValue, type MaybeGetter } from '../runtime/values.svelte.js';
+/**
+ * The search API (`search()`, `clear()`, `nextHit()`, `goToHit()`, …) for app chrome. A handle,
+ * always the capability of the document in scope.
+ */
+export declare function useSearch(): SearchCapability;
+/**
+ * The search's state: the query, status, count, active match, progress and error (declared once
+ * in `searchState`), as a reactive object (`state.hitCount`). With a selector, the value it picks
+ * as `{ current }`. Empty without a document.
+ */
+export declare const useSearchState: import("../index.js").StateReader<{
+    query: import("@embedpdf/plugin-search").SearchQuery | null;
+    status: import("@embedpdf/plugin-search").SearchStatus;
+    hitCount: number;
+    activeHitIndex: number;
+    activeHit: SearchHit | null;
+    progress: import("@embedpdf/plugin-search").SearchProgress;
+    error: import("@embedpdf/core").PluginErrorInfo | null;
+}>;
+/** The search settings (`reveal`, `highlight`), with or without a document. */
+export declare const useSearchSettings: import("../index.js").SettingsReader<import("@embedpdf/plugin-search").SearchSettings & object>;
+/**
+ * Subscribe to one search event while the component lives:
+ * `useSearchEvent((search) => search.onCompleted, handler)`.
+ */
+export declare function useSearchEvent<T>(select: (search: SearchCapability) => EventHook<T>, handler: (event: T) => void): void;
+/**
+ * Every match found so far, or one page's (its ref or its index), as `{ current }`: for a results
+ * list or a count per thumbnail. A page that changes is passed as a function
+ * (`useSearchHits(() => page.ref)`). The plugin keeps each list's identity until matches land on
+ * it, so a list redraws only then. Empty without a document, and for a page that has just left
+ * the document.
+ */
+export declare function useSearchHits(page?: MaybeGetter<PageRef | number | undefined>): CurrentValue<readonly SearchHit[]>;

package/dist/search/readers.svelte.js

@@ -0,0 +1,40 @@
+import { SearchToken, searchState } from '@embedpdf/plugin-search';
+import { useCapability, useCapabilityEvent, useOptionalSelector } from '../runtime/readers.svelte.js';
+import { settingsReader, stateReader } from '../runtime/state.svelte.js';
+import { valueOf } from '../runtime/values.svelte.js';
+/**
+ * The search API (`search()`, `clear()`, `nextHit()`, `goToHit()`, …) for app chrome. A handle,
+ * always the capability of the document in scope.
+ */
+export function useSearch() {
+    return useCapability(SearchToken);
+}
+/**
+ * The search's state: the query, status, count, active match, progress and error (declared once
+ * in `searchState`), as a reactive object (`state.hitCount`). With a selector, the value it picks
+ * as `{ current }`. Empty without a document.
+ */
+export const useSearchState = stateReader(searchState);
+/** The search settings (`reveal`, `highlight`), with or without a document. */
+export const useSearchSettings = settingsReader(SearchToken);
+/**
+ * Subscribe to one search event while the component lives:
+ * `useSearchEvent((search) => search.onCompleted, handler)`.
+ */
+export function useSearchEvent(select, handler) {
+    useCapabilityEvent(SearchToken, select, handler);
+}
+const NO_HITS = Object.freeze([]);
+/**
+ * Every match found so far, or one page's (its ref or its index), as `{ current }`: for a results
+ * list or a count per thumbnail. A page that changes is passed as a function
+ * (`useSearchHits(() => page.ref)`). The plugin keeps each list's identity until matches land on
+ * it, so a list redraws only then. Empty without a document, and for a page that has just left
+ * the document.
+ */
+export function useSearchHits(page) {
+    return useOptionalSelector(SearchToken, (search) => {
+        const only = valueOf(page);
+        return search.listHits(only === undefined ? undefined : { page: only });
+    }, NO_HITS);
+}

package/dist/search.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @embedpdf/svelte/search — full-text search.
+ *
+ * `<SearchLayer>` paints the matches on each page (and makes them clickable with `onHitClick`);
+ * the readers are the plugin's four, `useSearch()`, `useSearchState()`, `useSearchSettings()` and
+ * `useSearchEvent()`, and `useSearchHits()` for a results list.
+ */
+export * from '@embedpdf/plugin-search';
+export { default as SearchLayer } from './search/SearchLayer.svelte';
+export type { SearchLayerProps } from './search/props.js';
+export { useSearch, useSearchEvent, useSearchHits, useSearchSettings, useSearchState, } from './search/readers.svelte.js';

package/dist/search.js

@@ -0,0 +1,11 @@
+/**
+ * @embedpdf/svelte/search — full-text search.
+ *
+ * `<SearchLayer>` paints the matches on each page (and makes them clickable with `onHitClick`);
+ * the readers are the plugin's four, `useSearch()`, `useSearchState()`, `useSearchSettings()` and
+ * `useSearchEvent()`, and `useSearchHits()` for a results list.
+ */
+// Registration travels with the UI.
+export * from '@embedpdf/plugin-search';
+export { default as SearchLayer } from './search/SearchLayer.svelte';
+export { useSearch, useSearchEvent, useSearchHits, useSearchSettings, useSearchState, } from './search/readers.svelte.js';