@inkbar/svelte 0.0.0-stage → 0.1.1

package/dist/components/annotation-element.svelte.js

@@ -0,0 +1,25 @@
+import { observeAnnotationElement } from '@inkbar/core/dom';
+/**
+ * The overlay element core draws for an annotation, for anchoring a popover to it. Core
+ * creates and removes these elements outside Svelte, so this follows the root's subtree while
+ * an id is wanted.
+ */
+export function useAnnotationElement(root, id) {
+    let element = $state.raw(null);
+    $effect(() => {
+        const r = root();
+        const i = id();
+        if (!r || !i) {
+            element = null;
+            return;
+        }
+        return observeAnnotationElement(r, i, (el) => {
+            element = el;
+        });
+    });
+    return {
+        get current() {
+            return element;
+        },
+    };
+}

package/dist/components/child-snippet.d.ts

@@ -0,0 +1,22 @@
+import type { Snippet } from 'svelte';
+/** A `child` prop: render your own element, spread `props` on it. */
+export type ChildSnippet = Snippet<[{
+    props: Record<string, unknown>;
+}]>;
+/** `T` as Bits UI types its props: no `null` and no explicit `undefined` in a value type. */
+export type BitsProps<T> = {
+    [K in keyof T]: Exclude<T[K], null | undefined>;
+};
+/**
+ * Svelte's attribute types allow `null` and `undefined` (`id?: string | null | undefined`)
+ * where Bits UI's do not (`id?: string`, under exactOptionalPropertyTypes), so the host's rest
+ * props do not type-check against a Bits UI component as they are. This takes both out of the
+ * value types and nothing else, so the keys and the remaining value types are still checked.
+ *
+ * It is a cast at the type level only: nothing is dropped at runtime, and a key the host set
+ * to `null` or `undefined` is passed on as that. For an attribute Bits UI hands through to the
+ * element, Svelte leaves it off. A prop Bits UI reads itself (`id`, `disabled`, `orientation`,
+ * `loop`) receives the explicit `null` or `undefined`. This is the one place the cast lives.
+ */
+export declare function asBitsProps<T extends object>(rest: T): BitsProps<T>;
+//# sourceMappingURL=child-snippet.d.ts.map

package/dist/components/child-snippet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-snippet.d.ts","sourceRoot":"","sources":["../../src/lib/components/child-snippet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAErC,qEAAqE;AACrE,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,CAAC,CAAA;AAExE,6FAA6F;AAC7F,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC;CAAE,CAAA;AAE9E;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAEnE"}

package/dist/components/child-snippet.js

@@ -0,0 +1,14 @@
+/**
+ * Svelte's attribute types allow `null` and `undefined` (`id?: string | null | undefined`)
+ * where Bits UI's do not (`id?: string`, under exactOptionalPropertyTypes), so the host's rest
+ * props do not type-check against a Bits UI component as they are. This takes both out of the
+ * value types and nothing else, so the keys and the remaining value types are still checked.
+ *
+ * It is a cast at the type level only: nothing is dropped at runtime, and a key the host set
+ * to `null` or `undefined` is passed on as that. For an attribute Bits UI hands through to the
+ * element, Svelte leaves it off. A prop Bits UI reads itself (`id`, `disabled`, `orientation`,
+ * `loop`) receives the explicit `null` or `undefined`. This is the one place the cast lives.
+ */
+export function asBitsProps(rest) {
+    return rest;
+}

package/dist/components/popover-focus.d.ts

@@ -0,0 +1,33 @@
+import { type FocusReturn } from '@inkbar/core/dom';
+import type { InkContext } from '../context.js';
+/** Core's focus planner, as the two handlers Bits UI's popover content takes. */
+export interface PopoverFocusReturn {
+    beforeRemove: FocusReturn['beforeRemove'];
+    /** Bits UI's `onOpenAutoFocus` handler. Leaves the default alone: focus moves into the popover. */
+    onOpenAutoFocus: (event: Event) => void;
+    /** Bits UI's `onCloseAutoFocus` handler. Prevents the default; the planner places focus. */
+    onCloseAutoFocus: (event: Event, anchor: HTMLElement | null) => void;
+}
+/** Bits UI's `onInteractOutside` handler: a press that will activate an annotation keeps the popover open. */
+export declare function keepOpenOnAnnotation(event: PointerEvent): void;
+/**
+ * Bits UI reports the close from an effect teardown, where a reactive read returns the value
+ * from before the change that closed the popover. The planner needs the activation as it is
+ * now, so it reads the untracked copy.
+ *
+ * Bits UI also reports a close while a popover opens: its focus scope mounts a second time,
+ * and the remount reports a close and then, in the same call, an open. That close is not one,
+ * and answering it would focus the anchor a frame before focus moves into the popover. So a
+ * close reaches the planner one microtask late, and only when no open was reported after it.
+ *
+ * This relies on Bits UI reporting a remount as a close and then an open within one synchronous
+ * call (observed in bits-ui 2.19.5, `FocusScope.mount`). If that changes, the browser case 'a
+ * card opened by selection alone takes focus without passing it through the annotation' fails.
+ *
+ * A close that is superseded this way moves no focus, but it still uses up whatever
+ * `beforeRemove` planned for it, so the plan cannot leak into a later close. A close that is
+ * only reported again in the same stretch is dropped, and the last report answers with the
+ * plan intact.
+ */
+export declare function useFocusReturn(ctx: InkContext): PopoverFocusReturn;
+//# sourceMappingURL=popover-focus.d.ts.map

package/dist/components/popover-focus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"popover-focus.d.ts","sourceRoot":"","sources":["../../src/lib/components/popover-focus.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAE/C,iFAAiF;AACjF,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,WAAW,CAAC,cAAc,CAAC,CAAA;IACzC,mGAAmG;IACnG,eAAe,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IACvC,4FAA4F;IAC5F,gBAAgB,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAA;CACrE;AAED,8GAA8G;AAC9G,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAE9D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,UAAU,GAAG,kBAAkB,CAkClE"}

package/dist/components/popover-focus.js

@@ -0,0 +1,63 @@
+import { createFocusReturn, shouldKeepOpenOnAnnotation, } from '@inkbar/core/dom';
+import { peekActivated } from '../context.js';
+/** Bits UI's `onInteractOutside` handler: a press that will activate an annotation keeps the popover open. */
+export function keepOpenOnAnnotation(event) {
+    if (shouldKeepOpenOnAnnotation(event.target))
+        event.preventDefault();
+}
+/**
+ * Bits UI reports the close from an effect teardown, where a reactive read returns the value
+ * from before the change that closed the popover. The planner needs the activation as it is
+ * now, so it reads the untracked copy.
+ *
+ * Bits UI also reports a close while a popover opens: its focus scope mounts a second time,
+ * and the remount reports a close and then, in the same call, an open. That close is not one,
+ * and answering it would focus the anchor a frame before focus moves into the popover. So a
+ * close reaches the planner one microtask late, and only when no open was reported after it.
+ *
+ * This relies on Bits UI reporting a remount as a close and then an open within one synchronous
+ * call (observed in bits-ui 2.19.5, `FocusScope.mount`). If that changes, the browser case 'a
+ * card opened by selection alone takes focus without passing it through the annotation' fails.
+ *
+ * A close that is superseded this way moves no focus, but it still uses up whatever
+ * `beforeRemove` planned for it, so the plan cannot leak into a later close. A close that is
+ * only reported again in the same stretch is dropped, and the last report answers with the
+ * plan intact.
+ */
+export function useFocusReturn(ctx) {
+    /** True while a superseded close is handed to the planner only to clear its plan. */
+    let discarding = false;
+    const planner = createFocusReturn({
+        // Without a root the planner clears its plan and returns before it looks for focus.
+        root: () => (discarding ? null : ctx.rootEl),
+        activated: () => peekActivated(ctx),
+    });
+    /** Open and close reports so far, so a deferred close can tell what followed it. */
+    let opens = 0;
+    let closes = 0;
+    return {
+        beforeRemove: (anchor, prefer) => planner.beforeRemove(anchor, prefer),
+        onOpenAutoFocus() {
+            opens += 1;
+        },
+        onCloseAutoFocus(event, anchor) {
+            // Never the library's own focus return: there is no trigger for it to return to.
+            event.preventDefault();
+            const close = ++closes;
+            const opensBefore = opens;
+            queueMicrotask(() => {
+                // Reported again since: the last close of the stretch answers, with the plan intact.
+                if (close !== closes)
+                    return;
+                // An open followed: the popover is open, so only the plan is cleared.
+                discarding = opens !== opensBefore;
+                try {
+                    planner.onCloseAutoFocus(event, anchor);
+                }
+                finally {
+                    discarding = false;
+                }
+            });
+        },
+    };
+}

package/dist/components/portal.d.ts

@@ -0,0 +1,26 @@
+import type { Attachment } from 'svelte/attachments';
+/**
+ * Teleport for an element's content. On attach it moves every child node of the element into
+ * `target`, Svelte's anchor comments included; on cleanup it moves them back so Svelte's own
+ * teardown removes them. Svelte inserts later nodes relative to those anchors, so `{#if}` and
+ * `{#each}` blocks inside the moved content keep updating in the target. The target ends up with
+ * the content's own nodes and no wrapper, the same DOM the Vue and React packages produce.
+ *
+ * A new `target` is a new attachment: Svelte runs the cleanup and the attach again. The same
+ * target always gets the same attachment, so `{@attach portal(el)}` re-evaluated with an
+ * unchanged `el` leaves the content where it is.
+ *
+ * The cleanup relies on one invariant: the first and last nodes it moved are still children of
+ * the target, in that order, and every node between them belongs to the wrapper (the nodes
+ * moved on attach, plus whatever Svelte inserted between them since). Svelte keeps to it, because
+ * it only ever inserts relative to the anchors that were moved. Then the whole run from the
+ * first node to the last comes back, late nodes included. Nothing else may put nodes of its
+ * own between the two: they would be taken for the wrapper's and moved into it.
+ *
+ * When the invariant does not hold (the first or last node has left the target, or the walk
+ * from the first never reaches the last), the cleanup falls back to the nodes it moved on
+ * attach, wherever they are now, and moves only those back. Nodes Svelte added later are not
+ * moved.
+ */
+export declare function portal(target: Element): Attachment<HTMLElement>;
+//# sourceMappingURL=portal.d.ts.map

package/dist/components/portal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portal.d.ts","sourceRoot":"","sources":["../../src/lib/components/portal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAIpD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,UAAU,CAAC,WAAW,CAAC,CA2B/D"}

package/dist/components/portal.js

@@ -0,0 +1,55 @@
+const attachments = new WeakMap();
+/**
+ * Teleport for an element's content. On attach it moves every child node of the element into
+ * `target`, Svelte's anchor comments included; on cleanup it moves them back so Svelte's own
+ * teardown removes them. Svelte inserts later nodes relative to those anchors, so `{#if}` and
+ * `{#each}` blocks inside the moved content keep updating in the target. The target ends up with
+ * the content's own nodes and no wrapper, the same DOM the Vue and React packages produce.
+ *
+ * A new `target` is a new attachment: Svelte runs the cleanup and the attach again. The same
+ * target always gets the same attachment, so `{@attach portal(el)}` re-evaluated with an
+ * unchanged `el` leaves the content where it is.
+ *
+ * The cleanup relies on one invariant: the first and last nodes it moved are still children of
+ * the target, in that order, and every node between them belongs to the wrapper (the nodes
+ * moved on attach, plus whatever Svelte inserted between them since). Svelte keeps to it, because
+ * it only ever inserts relative to the anchors that were moved. Then the whole run from the
+ * first node to the last comes back, late nodes included. Nothing else may put nodes of its
+ * own between the two: they would be taken for the wrapper's and moved into it.
+ *
+ * When the invariant does not hold (the first or last node has left the target, or the walk
+ * from the first never reaches the last), the cleanup falls back to the nodes it moved on
+ * attach, wherever they are now, and moves only those back. Nodes Svelte added later are not
+ * moved.
+ */
+export function portal(target) {
+    let attachment = attachments.get(target);
+    if (!attachment) {
+        attachment = (wrapper) => {
+            const moved = [...wrapper.childNodes];
+            for (const node of moved)
+                target.appendChild(node);
+            return () => {
+                const first = moved[0];
+                const last = moved.at(-1);
+                // Everything between the first and last moved node comes back, which takes in the
+                // nodes Svelte inserted since. The target may already be detached (core removed the
+                // annotation); the nodes move back all the same, so Svelte finds them where it left
+                // them.
+                const back = [];
+                if (first && last && first.parentNode === target && last.parentNode === target) {
+                    for (let node = first; node; node = node.nextSibling) {
+                        back.push(node);
+                        if (node === last)
+                            break;
+                    }
+                }
+                for (const node of back.at(-1) === last ? back : moved)
+                    if (node.parentNode !== wrapper)
+                        wrapper.appendChild(node);
+            };
+        };
+        attachments.set(target, attachment);
+    }
+    return attachment;
+}

package/dist/components/zoom-button.d.ts

@@ -0,0 +1,10 @@
+import type { ChildSnippet } from './child-snippet.js';
+import type { Snippet } from 'svelte';
+import type { HTMLButtonAttributes } from 'svelte/elements';
+/** Props of `InkZoomIn` and `InkZoomOut`: a toolbar button that may render through `child`. */
+export interface InkZoomButtonProps extends Omit<HTMLButtonAttributes, 'children'> {
+    children?: Snippet | undefined;
+    /** Render your own button: spread `props` on it. */
+    child?: ChildSnippet | undefined;
+}
+//# sourceMappingURL=zoom-button.d.ts.map

package/dist/components/zoom-button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zoom-button.d.ts","sourceRoot":"","sources":["../../src/lib/components/zoom-button.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AACrC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAE3D,+FAA+F;AAC/F,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,oBAAoB,EAAE,UAAU,CAAC;IAChF,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC9B,oDAAoD;IACpD,KAAK,CAAC,EAAE,YAAY,GAAG,SAAS,CAAA;CACjC"}

package/dist/components/zoom-button.js

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

package/dist/compositions/DefaultToolbar.svelte

@@ -0,0 +1,90 @@
+<script module lang="ts">
+  import type { Snippet } from 'svelte'
+
+  export interface DefaultToolbarProps {
+    label?: string | undefined
+    class?: string | undefined
+    children?: Snippet | undefined
+  }
+</script>
+
+<script lang="ts">
+  /*
+   * The standard toolbar: tools, zoom and page controls with icons. It adds no styles of its
+   * own; the theme styles the `data-ink-*` hooks. Extra controls go in `children`.
+   */
+  // One module per icon: the package's index evaluates every icon it ships, which costs a
+  // server (or a test) that imports this file well over a second. A new icon also goes in the
+  // browser tests' `optimizeDeps.include` in vitest.config.ts.
+  import Hand from '@lucide/svelte/icons/hand'
+  import Highlighter from '@lucide/svelte/icons/highlighter'
+  import MessageSquare from '@lucide/svelte/icons/message-square'
+  import MousePointer2 from '@lucide/svelte/icons/mouse-pointer-2'
+  import Square from '@lucide/svelte/icons/square'
+  import ZoomIn from '@lucide/svelte/icons/zoom-in'
+  import ZoomOut from '@lucide/svelte/icons/zoom-out'
+
+  import { cx } from '../class-names.js'
+  import InkPageCount from '../components/InkPageCount.svelte'
+  import InkPageInput from '../components/InkPageInput.svelte'
+  import InkToolbar from '../components/InkToolbar.svelte'
+  import InkToolButton from '../components/InkToolButton.svelte'
+  import InkZoomIn from '../components/InkZoomIn.svelte'
+  import InkZoomOut from '../components/InkZoomOut.svelte'
+  import InkZoomSelect from '../components/InkZoomSelect.svelte'
+
+  let {
+    label = 'Document tools',
+    class: className,
+    children,
+  }: DefaultToolbarProps = $props()
+
+  const ICON = 18
+</script>
+
+<InkToolbar
+  {label}
+  class={cx('ink-default-toolbar', className)}
+  data-ink-default-toolbar=""
+>
+  <div
+    class="ink-toolbar-group"
+    data-ink-toolbar-group="tools"
+    role="group"
+    aria-label="Tools"
+  >
+    <InkToolButton tool="view"><Hand size={ICON} aria-hidden="true" /></InkToolButton>
+    <InkToolButton tool="select"
+      ><MousePointer2 size={ICON} aria-hidden="true" /></InkToolButton
+    >
+    <InkToolButton tool="highlight"
+      ><Highlighter size={ICON} aria-hidden="true" /></InkToolButton
+    >
+    <InkToolButton tool="redact-area"
+      ><Square size={ICON} aria-hidden="true" /></InkToolButton
+    >
+    <InkToolButton tool="note"
+      ><MessageSquare size={ICON} aria-hidden="true" /></InkToolButton
+    >
+  </div>
+  <div
+    class="ink-toolbar-group"
+    data-ink-toolbar-group="zoom"
+    role="group"
+    aria-label="Zoom"
+  >
+    <InkZoomOut><ZoomOut size={ICON} aria-hidden="true" /></InkZoomOut>
+    <InkZoomSelect />
+    <InkZoomIn><ZoomIn size={ICON} aria-hidden="true" /></InkZoomIn>
+  </div>
+  <div
+    class="ink-toolbar-group"
+    data-ink-toolbar-group="page"
+    role="group"
+    aria-label="Page"
+  >
+    <InkPageInput />
+    <InkPageCount />
+  </div>
+  {@render children?.()}
+</InkToolbar>

package/dist/compositions/DefaultToolbar.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Snippet } from 'svelte';
+export interface DefaultToolbarProps {
+    label?: string | undefined;
+    class?: string | undefined;
+    children?: Snippet | undefined;
+}
+declare const DefaultToolbar: import("svelte").Component<DefaultToolbarProps, {}, "">;
+type DefaultToolbar = ReturnType<typeof DefaultToolbar>;
+export default DefaultToolbar;
+//# sourceMappingURL=DefaultToolbar.svelte.d.ts.map

package/dist/compositions/DefaultToolbar.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultToolbar.svelte.d.ts","sourceRoot":"","sources":["../../src/lib/compositions/DefaultToolbar.svelte.ts"],"names":[],"mappings":"AAGE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAErC,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAC/B;AAkFH,QAAA,MAAM,cAAc,yDAAwC,CAAC;AAC7D,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AACxD,eAAe,cAAc,CAAC"}

package/dist/context.d.ts

@@ -0,0 +1,57 @@
+import type { Annotation, InkDocument, InkStatus, PdfAssets } from '@inkbar/core';
+import type { ToolController, ToolId, Viewport, ZoomValue } from '@inkbar/core/dom';
+export type { InkStatus };
+/** Undo and redo for the current document, whichever mode its annotations are in. */
+export interface InkHistory {
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    undo(): void;
+    redo(): void;
+    clear(): void;
+    /**
+     * Runs `fn` and records what it changes as one undo step. The host still receives one change
+     * per add. Controlled, the history groups the resulting list changes into one step, and
+     * `canUndo` updates once the current task ends. Any other change the host applies in that
+     * same window joins the step.
+     */
+    batch(fn: () => void): void;
+}
+/**
+ * What InkRoot shares with everything inside it. Every `readonly` member is a getter over
+ * InkRoot's state, so a template or effect that reads one re-runs when it changes.
+ */
+export interface InkContext {
+    readonly assets: PdfAssets;
+    readonly document: InkDocument | null;
+    /** `loading` from the moment a document starts opening, then the document's own status. */
+    readonly status: InkStatus;
+    readonly annotations: readonly Annotation[];
+    readonly selection: readonly string[];
+    /** Set by InkViewport once it has built its viewport and tool controller. */
+    readonly viewport: Viewport | null;
+    readonly tools: ToolController | null;
+    /** Desired tool; InkViewport applies it to the controller. */
+    readonly tool: ToolId;
+    setTool(id: ToolId): void;
+    /** Desired zoom and page from the host's props; InkViewport applies and reports back. */
+    readonly zoomModel: ZoomValue | undefined;
+    readonly pageModel: number | undefined;
+    reportZoom(z: ZoomValue): void;
+    reportPage(p: number): void;
+    /** Last activated annotation (Enter, click with the note tool, etc.). Popovers key off this. */
+    readonly activated: string | null;
+    setActivated(id: string | null): void;
+    readonly history: InkHistory;
+    readonly rootEl: HTMLElement | null;
+    setViewport(viewport: Viewport | null, tools: ToolController | null): void;
+}
+/** Called once by InkRoot during its initialisation. */
+export declare function setInkContext(ctx: InkContext, peekActivated: () => string | null): void;
+/** The untracked `activated` of a context made by InkRoot. Not part of the public entry. */
+export declare function peekActivated(ctx: InkContext): string | null;
+/**
+ * The context for hooks and components: throws a readable error when called outside a component
+ * rendered inside `InkRoot`, including when called outside any component at all.
+ */
+export declare function useInkContext(consumer: string): InkContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/lib/context.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEnF,YAAY,EAAE,SAAS,EAAE,CAAA;AAEzB,qFAAqF;AACrF,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,IAAI,IAAI,IAAI,CAAA;IACZ,IAAI,IAAI,IAAI,CAAA;IACZ,KAAK,IAAI,IAAI,CAAA;IACb;;;;;OAKG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;CAC5B;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAA;IAC1B,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAA;IACrC,2FAA2F;IAC3F,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAA;IAC1B,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAA;IAC3C,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;IACrC,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAA;IAClC,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAA;IACrC,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,yFAAyF;IACzF,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,CAAA;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,UAAU,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,CAAA;IAC9B,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,gGAAgG;IAChG,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAA;IACrC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAA;IAC5B,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAA;IACnC,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,EAAE,KAAK,EAAE,cAAc,GAAG,IAAI,GAAG,IAAI,CAAA;CAC3E;AAWD,wDAAwD;AACxD,wBAAgB,aAAa,CAAC,GAAG,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,IAAI,CAGvF;AAED,4FAA4F;AAC5F,wBAAgB,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAG5D;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAY1D"}

package/dist/context.js

@@ -0,0 +1,34 @@
+import { getContext, setContext } from 'svelte';
+const KEY = Symbol('inkbar');
+/**
+ * `activated` as last set, not tracked, per context. Internal to the package. For code that
+ * runs while an effect is torn down (a popover's close handler): there Svelte serves a
+ * reactive read the value from before the change that caused the teardown.
+ */
+const activatedPeeks = new WeakMap();
+/** Called once by InkRoot during its initialisation. */
+export function setInkContext(ctx, peekActivated) {
+    activatedPeeks.set(ctx, peekActivated);
+    setContext(KEY, ctx);
+}
+/** The untracked `activated` of a context made by InkRoot. Not part of the public entry. */
+export function peekActivated(ctx) {
+    const peek = activatedPeeks.get(ctx);
+    return peek ? peek() : ctx.activated;
+}
+/**
+ * The context for hooks and components: throws a readable error when called outside a component
+ * rendered inside `InkRoot`, including when called outside any component at all.
+ */
+export function useInkContext(consumer) {
+    let ctx;
+    try {
+        ctx = getContext(KEY);
+    }
+    catch {
+        ctx = undefined;
+    }
+    if (!ctx)
+        throw new Error(`[inkbar] ${consumer} must be called in a component inside <InkRoot>.`);
+    return ctx;
+}