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

package/dist/link/LinkLayer.svelte

@@ -0,0 +1,164 @@
+<!--
+  The links on one page: one absolutely placed `<a>` per clickable area. Real anchors on purpose:
+  a website gets an `href`, so a middle click, "copy link", the status-bar preview and keyboard
+  focus work as in any page. A click or a key follows the link through the plugin's `activate()`,
+  so every way of following one fires `onActivated`; the plugin opens websites through the opener
+  this binding registers.
+
+  The layer stands down while the active tool doesn't enable `link-nav`: the annotation layer
+  owns links then (select, move, resize). While a tool can edit annotations, a link attached to
+  another annotation is that annotation's, and its anchor stands down too.
+-->
+<script lang="ts">
+  import { ActionsToken, createHoverPump } from '@embedpdf/plugin-actions/contract';
+  import { InteractionToken } from '@embedpdf/plugin-interaction/contract/host';
+  import { LinkToken, type Link } from '@embedpdf/plugin-link';
+  import { LinkToken as LinkHostToken } from '@embedpdf/plugin-link/contract/host';
+  import {
+    hoverLink,
+    isModifiedClick,
+    isolatePointerDown,
+    linkActivateContextOf,
+    linkAnchorOf,
+    navigableLinksOf,
+    sendLinkEvent,
+    type LinkAnchorEvent,
+  } from '@embedpdf/web';
+  import { usePage } from '../runtime/page.js';
+  import {
+    shallowArray,
+    useCapability,
+    useOptionalCapability,
+    useOptionalSelector,
+  } from '../runtime/readers.svelte.js';
+  import { stageTokenOf } from '../stage/stage-scope.js';
+  import type { LinkLayerProps } from './props.js';
+  import { useUriOpener } from './readers.svelte.js';
+
+  const NO_LINKS: readonly Link[] = Object.freeze([]);
+
+  let { link: drawLink }: LinkLayerProps = $props();
+
+  const page = usePage();
+  // The API for following a link (a handle: always this document's), and the plugin's own object
+  // for the reads here, which then wake nothing but a new document.
+  const links = useCapability(LinkToken);
+  const capability = useOptionalCapability(LinkToken);
+  useUriOpener();
+  // A page destination moves the view this page is shown in.
+  const stage = useOptionalCapability(stageTokenOf());
+  // The links' own /AA events (enter, exit, down, up, focus, blur) can only fire from here: while
+  // a link navigates, its pixels are these anchors. One hover pump per layer; crossing layers
+  // still orders Exit before Enter, since both sides submit in DOM event order.
+  const actions = useOptionalCapability(ActionsToken);
+  const pump = $derived(actions.current ? createHoverPump(actions.current.dispatch) : null);
+
+  const items = useOptionalSelector(
+    LinkToken,
+    (lens) => lens.listLinks(page.ref),
+    NO_LINKS,
+    shallowArray,
+  );
+  const engaged = useOptionalSelector(LinkHostToken, (lens) => lens.isNavigationEngaged(), false);
+  // One owner per pixel: while the active tool can edit annotations, a link attached to another
+  // annotation belongs to it, and its anchor stands down. Standalone links navigate under any
+  // tool that enables `link-nav`.
+  const editEnabled = useOptionalSelector(
+    InteractionToken,
+    (interaction) => interaction.activeToolEnables('annotation-edit'),
+    false,
+  );
+  const visible = $derived(
+    engaged.current && items.current.length > 0
+      ? navigableLinksOf(items.current, editEnabled.current)
+      : NO_LINKS,
+  );
+
+  $effect(() => {
+    const lens = capability.current;
+    const ref = page.ref;
+    if (!lens) return;
+    void lens.ensureLoaded(ref);
+  });
+
+  /** Follow `item` through the plugin, which moves the view or opens a website. */
+  function follow(item: Link) {
+    links.activate(item, linkActivateContextOf(item, page.ref, stage.current));
+  }
+
+  /** The link's own /AA event for a press, a release or focus, with the actions plugin. */
+  function notify(item: Link, event: LinkAnchorEvent) {
+    sendLinkEvent(actions.current, item, page.ref, event);
+  }
+
+  function onClick(href: string | null, item: Link, event: MouseEvent) {
+    // A modified click on a real `href` keeps the browser's own behavior (a background tab, a
+    // new window). Every other click follows the link through the plugin.
+    if (href && isModifiedClick(event)) return;
+    event.preventDefault();
+    follow(item);
+  }
+
+  function onKeyDown(item: Link, event: KeyboardEvent) {
+    if (event.key !== 'Enter' && event.key !== ' ') return;
+    event.preventDefault();
+    follow(item);
+  }
+
+  /**
+   * A press inside a link must not reach the Stage (it would start the active tool's gesture, or
+   * end an edit as a click outside). Svelte hands `onpointerdown` to the root, after the Stage
+   * saw the press, so the press stops on a native listener on the anchor, which also sends the
+   * link's "mouse down" action.
+   */
+  const isolate = (item: () => Link) => (element: HTMLElement) =>
+    isolatePointerDown(element, () => notify(item(), 'mouseDown'));
+</script>
+
+{#if visible.length > 0}
+  <div style="position: absolute; inset: 0; pointer-events: none">
+    {#each visible as item (item.id)}
+      {@const { box, href, label } = linkAnchorOf(
+        item,
+        page.transform,
+        (link) => capability.current?.getLabel(link) ?? '',
+      )}
+      <!-- Its box, its label, and a native `href` only for a website with nothing chained after
+           it. -->
+      <!-- The layer's own anchor; a `link` snippet draws around it. -->
+      {#snippet native()}
+        <!-- `role` stays: an anchor without `href` (a page destination) has no role of its own. -->
+        <!-- svelte-ignore a11y_no_redundant_roles -->
+        <a
+          {@attach isolate(() => item)}
+          href={href ?? undefined}
+          target="_blank"
+          rel="noopener noreferrer"
+          role="link"
+          tabindex="0"
+          title={label}
+          aria-label={label}
+          onclick={(event) => onClick(href, item, event)}
+          onkeydown={(event) => onKeyDown(item, event)}
+          onpointerenter={() => hoverLink(pump, item, page.ref)}
+          onpointerleave={() => pump?.hover(null)}
+          onpointerup={() => notify(item, 'mouseUp')}
+          onfocus={() => notify(item, 'focus')}
+          onblur={() => notify(item, 'blur')}
+          style:position="absolute"
+          style:left="{box.left}px"
+          style:top="{box.top}px"
+          style:width="{box.width}px"
+          style:height="{box.height}px"
+          style:cursor="pointer"
+          style:pointer-events="auto"
+        ></a>
+      {/snippet}
+      {#if drawLink}
+        {@render drawLink({ link: item, native })}
+      {:else}
+        {@render native()}
+      {/if}
+    {/each}
+  </div>
+{/if}

package/dist/link/LinkLayer.svelte.d.ts

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

package/dist/link/props.d.ts

@@ -0,0 +1,17 @@
+/** The props of `<LinkLayer>`. */
+import type { Snippet } from 'svelte';
+import type { Link } from '@embedpdf/plugin-link';
+/** What the `link` snippet receives for each link. */
+export interface LinkRenderProps {
+    /** The link: its `id`, its `bounds` on the page and its `target`. */
+    link: Link;
+    /** The layer's own clickable area, `{@render native()}`: wrap it to keep what a click does. */
+    native: Snippet;
+}
+export interface LinkLayerProps {
+    /**
+     * Draw each link yourself, usually around `{@render native()}`. To leave a link as it is,
+     * render only `native` for it.
+     */
+    link?: Snippet<[props: LinkRenderProps]>;
+}

package/dist/link/props.js

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

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

@@ -0,0 +1,18 @@
+import type { EventHook } from '@embedpdf/core';
+import type { LinkCapability } from '@embedpdf/plugin-link';
+/**
+ * Hand the link plugin this binding's website opener (`openExternalUri`) while the component
+ * lives: an allowed address opens in a new tab, anything else is refused and the plugin reports
+ * it. Registered again for each document.
+ */
+export declare function useUriOpener(): void;
+/**
+ * The link API (`listLinks()`, `activate()`, …) for app code. While a component uses it,
+ * `activate()` opens a website in a new tab.
+ */
+export declare function useLink(): LinkCapability;
+/**
+ * Subscribe to one link event while the component lives:
+ * `useLinkEvent((link) => link.onActivated, handler)`.
+ */
+export declare function useLinkEvent<T>(select: (link: LinkCapability) => EventHook<T>, handler: (event: T) => void): void;

package/dist/link/readers.svelte.js

@@ -0,0 +1,38 @@
+/**
+ * The link plugin's readers: `useLink()` (the API) and `useLinkEvent()`, and the website opener
+ * this binding hands the plugin while a link component is mounted.
+ */
+import { untrack } from 'svelte';
+import { LinkToken } from '@embedpdf/plugin-link';
+import { LinkToken as LinkHostToken } from '@embedpdf/plugin-link/contract/host';
+import { openExternalUri } from '@embedpdf/web';
+import { useCapability, useCapabilityEvent, useOptionalCapability, } from '../runtime/readers.svelte.js';
+/**
+ * Hand the link plugin this binding's website opener (`openExternalUri`) while the component
+ * lives: an allowed address opens in a new tab, anything else is refused and the plugin reports
+ * it. Registered again for each document.
+ */
+export function useUriOpener() {
+    const host = useOptionalCapability(LinkHostToken);
+    $effect(() => {
+        const current = host.current;
+        if (!current)
+            return;
+        return untrack(() => current.registerUriOpener(openExternalUri));
+    });
+}
+/**
+ * The link API (`listLinks()`, `activate()`, …) for app code. While a component uses it,
+ * `activate()` opens a website in a new tab.
+ */
+export function useLink() {
+    useUriOpener();
+    return useCapability(LinkToken);
+}
+/**
+ * Subscribe to one link event while the component lives:
+ * `useLinkEvent((link) => link.onActivated, handler)`.
+ */
+export function useLinkEvent(select, handler) {
+    useCapabilityEvent(LinkToken, select, handler);
+}

package/dist/link.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @embedpdf/svelte/link — following links.
+ *
+ * `<LinkLayer>` puts a real anchor over each link on a page (draw around it with its `link`
+ * snippet); `useLink()` is the plugin's API and opens websites while it's in use, and
+ * `useLinkEvent()` its events.
+ */
+export * from '@embedpdf/plugin-link';
+export { default as LinkLayer } from './link/LinkLayer.svelte';
+export type { LinkLayerProps, LinkRenderProps } from './link/props.js';
+export { useLink, useLinkEvent } from './link/readers.svelte.js';

package/dist/link.js

@@ -0,0 +1,11 @@
+/**
+ * @embedpdf/svelte/link — following links.
+ *
+ * `<LinkLayer>` puts a real anchor over each link on a page (draw around it with its `link`
+ * snippet); `useLink()` is the plugin's API and opens websites while it's in use, and
+ * `useLinkEvent()` its events.
+ */
+// Registration travels with the UI.
+export * from '@embedpdf/plugin-link';
+export { default as LinkLayer } from './link/LinkLayer.svelte';
+export { useLink, useLinkEvent } from './link/readers.svelte.js';

package/dist/measurement/readers.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The measurement plugin's readers: `useMeasurement()` (the API), `useMeasurementState()`,
+ * `useMeasurementSettings()`, `useMeasurementEvent()`, and one per page scale and one per
+ * measurement, so a template updates only for its own page or measurement. Every one works before
+ * a document opens.
+ */
+import type { EventHook, PageRef } from '@embedpdf/core';
+import type { AnnotationRef, MeasurementCapability, MeasurementReadout, MeasurementUnavailable, PageScale } from '@embedpdf/plugin-measurement';
+import { type CurrentValue, type MaybeGetter } from '../runtime/values.svelte.js';
+/**
+ * The measurement API (scales, calibration, readouts, creating measurements) of the nearest
+ * `<DocumentScope>`'s document, else the active one. Outside a ready document every method throws
+ * `not-ready`.
+ */
+export declare function useMeasurement(): MeasurementCapability;
+/** Subscribe to one measurement event while the component lives: `useMeasurementEvent((measurement) => measurement.onScaleChanged, handler)`. */
+export declare function useMeasurementEvent<T>(select: (measurement: MeasurementCapability) => EventHook<T>, handler: (event: T) => void): void;
+/**
+ * The measurement state: whether a scale change runs, the calibration request waiting for its
+ * length, and the last change's reports (the page's State table, declared once in
+ * `measurementState`), as a reactive object (`state.calibrationRequest`). With a selector, the
+ * value it picks as `{ current }`. Empty without a document.
+ */
+export declare const useMeasurementState: import("../index.js").StateReader<{
+    busy: boolean;
+    calibrationRequest: import("@embedpdf/plugin-measurement").CalibrationRequest | null;
+    lastReports: readonly import("@embedpdf/plugin-measurement").ScaleChangeReport[];
+}>;
+/** The measurement settings (`defaultScale`, `presets`), with or without a document. */
+export declare const useMeasurementSettings: import("../index.js").SettingsReader<import("@embedpdf/plugin-measurement").MeasurementSettings & object>;
+/**
+ * A page's measurement scale (its ref or its index; a function to follow a prop) as
+ * `{ current }`: for a scale bar or a "1:100" badge. Accepts `null` (no current page) and answers
+ * `null` then, so chrome can stay mounted without inventing a page.
+ */
+export declare function usePageScale(page: MaybeGetter<PageRef | number>): CurrentValue<PageScale>;
+export declare function usePageScale(page: MaybeGetter<PageRef | number | null>): CurrentValue<PageScale | null>;
+/**
+ * A measurement's `{ kind, value, label }` as `{ current }`, or `{ unavailable }` with why there's
+ * none. A measurement that changes is a function: `useMeasurementReadout(() => annotation)`.
+ * Readouts are reference-stable in the plugin, so the value changes only when the measurement's
+ * does.
+ */
+export declare function useMeasurementReadout(ref: MaybeGetter<AnnotationRef>): CurrentValue<MeasurementReadout | MeasurementUnavailable>;

package/dist/measurement/readers.js

@@ -0,0 +1,46 @@
+import { MeasurementToken, measurementState, NO_PAGE_SCALE, NO_READOUT, } from '@embedpdf/plugin-measurement';
+import { documentScopeOf } from '../runtime/binding.svelte.js';
+import { useCapability, useCapabilityEvent, useKernelValue, useOptionalSelector, } from '../runtime/readers.svelte.js';
+import { settingsReader, stateReader } from '../runtime/state.svelte.js';
+import { valueOf } from '../runtime/values.svelte.js';
+/**
+ * The measurement API (scales, calibration, readouts, creating measurements) of the nearest
+ * `<DocumentScope>`'s document, else the active one. Outside a ready document every method throws
+ * `not-ready`.
+ */
+export function useMeasurement() {
+    return useCapability(MeasurementToken);
+}
+/** Subscribe to one measurement event while the component lives: `useMeasurementEvent((measurement) => measurement.onScaleChanged, handler)`. */
+export function useMeasurementEvent(select, handler) {
+    useCapabilityEvent(MeasurementToken, select, handler);
+}
+/**
+ * The measurement state: whether a scale change runs, the calibration request waiting for its
+ * length, and the last change's reports (the page's State table, declared once in
+ * `measurementState`), as a reactive object (`state.calibrationRequest`). With a selector, the
+ * value it picks as `{ current }`. Empty without a document.
+ */
+export const useMeasurementState = stateReader(measurementState);
+/** The measurement settings (`defaultScale`, `presets`), with or without a document. */
+export const useMeasurementSettings = settingsReader(MeasurementToken);
+export function usePageScale(page) {
+    const scoped = documentScopeOf();
+    // Scales are reference-stable in the plugin, so the value changes only when this page's does.
+    return useKernelValue((kernel) => {
+        const wanted = valueOf(page);
+        if (wanted === null)
+            return null;
+        return (kernel.tryCapability(MeasurementToken, scoped() ?? undefined)?.getPageScale(wanted) ??
+            NO_PAGE_SCALE);
+    });
+}
+/**
+ * A measurement's `{ kind, value, label }` as `{ current }`, or `{ unavailable }` with why there's
+ * none. A measurement that changes is a function: `useMeasurementReadout(() => annotation)`.
+ * Readouts are reference-stable in the plugin, so the value changes only when the measurement's
+ * does.
+ */
+export function useMeasurementReadout(ref) {
+    return useOptionalSelector(MeasurementToken, (measurement) => measurement.getReadout(valueOf(ref)), NO_READOUT);
+}

package/dist/measurement.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @embedpdf/svelte/measurement — distances, perimeters and areas in the page's scale.
+ *
+ * Measuring rides the annotation plugin (the `distance`, `perimeter` and `area` tools draw on its
+ * `<AnnotationLayer>`); these readers surface the scale, the calibration and the readouts:
+ *
+ *   const measurement = useMeasurement();
+ *   const scale = usePageScale(0); // scale.current: the cover's
+ *   const readout = useMeasurementReadout(() => annotation); // readout.current.label
+ */
+export * from '@embedpdf/plugin-measurement';
+export { useMeasurement, useMeasurementEvent, useMeasurementReadout, useMeasurementSettings, useMeasurementState, usePageScale, } from './measurement/readers.js';

package/dist/measurement.js

@@ -0,0 +1,13 @@
+/**
+ * @embedpdf/svelte/measurement — distances, perimeters and areas in the page's scale.
+ *
+ * Measuring rides the annotation plugin (the `distance`, `perimeter` and `area` tools draw on its
+ * `<AnnotationLayer>`); these readers surface the scale, the calibration and the readouts:
+ *
+ *   const measurement = useMeasurement();
+ *   const scale = usePageScale(0); // scale.current: the cover's
+ *   const readout = useMeasurementReadout(() => annotation); // readout.current.label
+ */
+// Registration travels with the UI.
+export * from '@embedpdf/plugin-measurement';
+export { useMeasurement, useMeasurementEvent, useMeasurementReadout, useMeasurementSettings, useMeasurementState, usePageScale, } from './measurement/readers.js';

package/dist/metadata/readers.d.ts

@@ -0,0 +1,22 @@
+/** The metadata's readers: the API, the state declared once in `metadataState`, and its events. */
+import type { EventHook } from '@embedpdf/core';
+import type { MetadataCapability } from '@embedpdf/plugin-metadata';
+/**
+ * The metadata API (`update`, `custom.update`, `refresh`, `canUpdate`) of the nearest
+ * `<DocumentScope>`'s document, else the active one. Outside a ready document, every method
+ * throws `not-ready`. `canUpdate()` is a read, so `disabled={!metadata.canUpdate()}` updates by
+ * itself.
+ */
+export declare function useMetadata(): MetadataCapability;
+/**
+ * The standard fields, your own fields and their load state (the page's State table, declared
+ * once in `metadataState`), as a reactive object: `state.metadata?.title`. With a selector, the
+ * value it picks as `{ current }`, which changes only when that value does.
+ */
+export declare const useMetadataState: import("../index.js").StateReader<{
+    metadata: import("@embedpdf/core").DocumentMetadata | null;
+    custom: import("@embedpdf/core").CustomMetadata | null;
+    status: import("@embedpdf/core").ResourceStatus;
+}>;
+/** Subscribe to one metadata event while the component lives: `useMetadataEvent((metadata) => metadata.onUpdated, handler)`. */
+export declare function useMetadataEvent<T>(select: (metadata: MetadataCapability) => EventHook<T>, handler: (event: T) => void): void;

package/dist/metadata/readers.js

@@ -0,0 +1,22 @@
+import { MetadataToken, metadataState } from '@embedpdf/plugin-metadata';
+import { useCapability, useCapabilityEvent } from '../runtime/readers.svelte.js';
+import { stateReader } from '../runtime/state.svelte.js';
+/**
+ * The metadata API (`update`, `custom.update`, `refresh`, `canUpdate`) of the nearest
+ * `<DocumentScope>`'s document, else the active one. Outside a ready document, every method
+ * throws `not-ready`. `canUpdate()` is a read, so `disabled={!metadata.canUpdate()}` updates by
+ * itself.
+ */
+export function useMetadata() {
+    return useCapability(MetadataToken);
+}
+/**
+ * The standard fields, your own fields and their load state (the page's State table, declared
+ * once in `metadataState`), as a reactive object: `state.metadata?.title`. With a selector, the
+ * value it picks as `{ current }`, which changes only when that value does.
+ */
+export const useMetadataState = stateReader(metadataState);
+/** Subscribe to one metadata event while the component lives: `useMetadataEvent((metadata) => metadata.onUpdated, handler)`. */
+export function useMetadataEvent(select, handler) {
+    useCapabilityEvent(MetadataToken, select, handler);
+}

package/dist/metadata.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @embedpdf/svelte/metadata — the document's properties and your own fields.
+ *
+ * The plugin keeps the metadata live off the document's event stream, so the state follows your
+ * own edits and other sessions':
+ *
+ *   const metadata = useMetadata();
+ *   const state = useMetadataState(); // state.metadata, state.custom, state.status
+ *   await metadata.update({ title: 'New title' }); // resolves once the state shows it
+ */
+export * from '@embedpdf/plugin-metadata';
+export { useMetadata, useMetadataEvent, useMetadataState } from './metadata/readers.js';

package/dist/metadata.js

@@ -0,0 +1,13 @@
+/**
+ * @embedpdf/svelte/metadata — the document's properties and your own fields.
+ *
+ * The plugin keeps the metadata live off the document's event stream, so the state follows your
+ * own edits and other sessions':
+ *
+ *   const metadata = useMetadata();
+ *   const state = useMetadataState(); // state.metadata, state.custom, state.status
+ *   await metadata.update({ title: 'New title' }); // resolves once the state shows it
+ */
+// Registration travels with the UI.
+export * from '@embedpdf/plugin-metadata';
+export { useMetadata, useMetadataEvent, useMetadataState } from './metadata/readers.js';

package/dist/outline/readers.d.ts

@@ -0,0 +1,26 @@
+/** The outline's readers: the API, the state declared once in `outlineState`, and its events. */
+import type { EventHook } from '@embedpdf/core';
+import type { OutlineCapability } from '@embedpdf/plugin-outline';
+/**
+ * The outline API (expand, select, activate, create, update, move, delete) of the nearest
+ * `<DocumentScope>`'s document, else the active one. Outside a ready document, every method
+ * throws `not-ready`. `canEdit()` is a read, so `disabled={!outline.canEdit()}` updates by itself.
+ */
+export declare function useOutline(): OutlineCapability;
+/**
+ * The outline's items, the rows a tree view shows, the item for where the view is reading, the
+ * selection, the load state and whether you may edit it (the page's State table, declared once in
+ * `outlineState`), as a reactive object: `state.rows`. With a selector, the value it picks as
+ * `{ current }`, which changes only when that value does.
+ */
+export declare const useOutlineState: import("../index.js").StateReader<{
+    items: readonly import("@embedpdf/plugin-outline").OutlineItem<import("@embedpdf/core").PageDestination>[];
+    rows: readonly import("@embedpdf/plugin-outline").OutlineRow[];
+    current: import("@embedpdf/plugin-outline").OutlineItemRef | null;
+    selected: readonly import("@embedpdf/plugin-outline").OutlineItemRef[];
+    status: import("@embedpdf/core").ResourceStatus;
+    incomplete: boolean;
+    canEdit: boolean;
+}>;
+/** Subscribe to one outline event while the component lives: `useOutlineEvent((outline) => outline.onChanged, handler)`. */
+export declare function useOutlineEvent<T>(select: (outline: OutlineCapability) => EventHook<T>, handler: (event: T) => void): void;

package/dist/outline/readers.js

@@ -0,0 +1,22 @@
+import { OutlineToken, outlineState } from '@embedpdf/plugin-outline';
+import { useCapability, useCapabilityEvent } from '../runtime/readers.svelte.js';
+import { stateReader } from '../runtime/state.svelte.js';
+/**
+ * The outline API (expand, select, activate, create, update, move, delete) of the nearest
+ * `<DocumentScope>`'s document, else the active one. Outside a ready document, every method
+ * throws `not-ready`. `canEdit()` is a read, so `disabled={!outline.canEdit()}` updates by itself.
+ */
+export function useOutline() {
+    return useCapability(OutlineToken);
+}
+/**
+ * The outline's items, the rows a tree view shows, the item for where the view is reading, the
+ * selection, the load state and whether you may edit it (the page's State table, declared once in
+ * `outlineState`), as a reactive object: `state.rows`. With a selector, the value it picks as
+ * `{ current }`, which changes only when that value does.
+ */
+export const useOutlineState = stateReader(outlineState);
+/** Subscribe to one outline event while the component lives: `useOutlineEvent((outline) => outline.onChanged, handler)`. */
+export function useOutlineEvent(select, handler) {
+    useCapabilityEvent(OutlineToken, select, handler);
+}

package/dist/outline.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @embedpdf/svelte/outline — the document's outline (its bookmarks).
+ *
+ * Reading the state reads the outline; the plugin keeps it live off the document's event stream,
+ * and shows your own edits at once:
+ *
+ *   const outline = useOutline();
+ *   const state = useOutlineState(); // state.rows, state.current, state.canEdit
+ *   outline.activate(row.item.ref); // goes where the item goes, as a click does
+ */
+export * from '@embedpdf/plugin-outline';
+export { useOutline, useOutlineEvent, useOutlineState } from './outline/readers.js';

package/dist/outline.js

@@ -0,0 +1,13 @@
+/**
+ * @embedpdf/svelte/outline — the document's outline (its bookmarks).
+ *
+ * Reading the state reads the outline; the plugin keeps it live off the document's event stream,
+ * and shows your own edits at once:
+ *
+ *   const outline = useOutline();
+ *   const state = useOutlineState(); // state.rows, state.current, state.canEdit
+ *   outline.activate(row.item.ref); // goes where the item goes, as a click does
+ */
+// Registration travels with the UI.
+export * from '@embedpdf/plugin-outline';
+export { useOutline, useOutlineEvent, useOutlineState } from './outline/readers.js';

package/dist/page-edit/readers.d.ts

@@ -0,0 +1,17 @@
+import type { PageEditCapability } from '@embedpdf/plugin-page-edit';
+/**
+ * The page edits of the nearest `<DocumentScope>`'s document, else the active one. Outside a
+ * ready document, every method throws `not-ready`. `canEdit()` and `canExtract()` are reads, so
+ * `disabled={!pageEdit.canEdit()}` updates by itself.
+ */
+export declare function usePageEdit(): PageEditCapability;
+/**
+ * The selected pages and whether you may edit and copy pages (the page's State table, declared
+ * once in `pageEditState`), as a reactive object: `state.selected`. With a selector, the value it
+ * picks as `{ current }`, which changes only when that value does.
+ */
+export declare const usePageEditState: import("../index.js").StateReader<{
+    selected: readonly import("@embedpdf/core").PageRef[];
+    canEdit: boolean;
+    canExtract: boolean;
+}>;

package/dist/page-edit/readers.js

@@ -0,0 +1,18 @@
+/** The page edits' readers: the API, and the state declared once in `pageEditState`. The pages are the document's. */
+import { PageEditToken, pageEditState } from '@embedpdf/plugin-page-edit';
+import { useCapability } from '../runtime/readers.svelte.js';
+import { stateReader } from '../runtime/state.svelte.js';
+/**
+ * The page edits of the nearest `<DocumentScope>`'s document, else the active one. Outside a
+ * ready document, every method throws `not-ready`. `canEdit()` and `canExtract()` are reads, so
+ * `disabled={!pageEdit.canEdit()}` updates by itself.
+ */
+export function usePageEdit() {
+    return useCapability(PageEditToken);
+}
+/**
+ * The selected pages and whether you may edit and copy pages (the page's State table, declared
+ * once in `pageEditState`), as a reactive object: `state.selected`. With a selector, the value it
+ * picks as `{ current }`, which changes only when that value does.
+ */
+export const usePageEditState = stateReader(pageEditState);

package/dist/page-edit.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @embedpdf/svelte/page-edit — rotate, move, insert, delete and extract pages.
+ *
+ * The plugin turns a page relative to its rotation and resolves positions, so this is binding
+ * only. The pages themselves come from `usePageList()` (`@embedpdf/svelte/runtime`), which
+ * follows every edit:
+ *
+ *   const pageEdit = usePageEdit();
+ *   await pageEdit.rotateBy([page.ref], 90);
+ */
+export * from '@embedpdf/plugin-page-edit';
+export { usePageEdit, usePageEditState } from './page-edit/readers.js';

package/dist/page-edit.js

@@ -0,0 +1,13 @@
+/**
+ * @embedpdf/svelte/page-edit — rotate, move, insert, delete and extract pages.
+ *
+ * The plugin turns a page relative to its rotation and resolves positions, so this is binding
+ * only. The pages themselves come from `usePageList()` (`@embedpdf/svelte/runtime`), which
+ * follows every edit:
+ *
+ *   const pageEdit = usePageEdit();
+ *   await pageEdit.rotateBy([page.ref], 90);
+ */
+// Registration travels with the UI.
+export * from '@embedpdf/plugin-page-edit';
+export { usePageEdit, usePageEditState } from './page-edit/readers.js';