fancy-ui-react 0.2.0

package/dist/internals/float.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Floating element positioning — geometry only.
+ *
+ * A pure geometry helper that pins a floating box (menu, popover, completion
+ * list) to an anchor. The anchor can be a real element's rect or a virtual
+ * rect, which is how a caret-following menu is placed.
+ *
+ * `attachFloat` / `useFloat` (the DOM-observing half) are a separate,
+ * hook-carrying unit and are not ported here.
+ */
+export type FloatPlacement = "top" | "bottom" | "top-start" | "bottom-start" | "top-end" | "bottom-end";
+export interface FloatRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface FloatSize {
+    width: number;
+    height: number;
+}
+export interface FloatOptions {
+    /** Real element, a fixed rect, or a getter returning the current rect (caret anchoring). */
+    anchor: HTMLElement | FloatRect | (() => FloatRect | null);
+    placement?: FloatPlacement;
+    offset?: number;
+    padding?: number;
+    /** Force the float to the anchor's width before measuring. */
+    matchWidth?: boolean;
+    enabled?: boolean;
+}
+/**
+ * Resolve the viewport-space position of a floating box against its anchor.
+ *
+ * Flips to the opposite side only when the requested side cannot hold the float
+ * *and* the opposite side has strictly more room. If neither side fits, the
+ * larger one is kept — overflowing where the least content is hidden.
+ */
+export declare function computeFloatPosition(anchor: FloatRect, float: FloatSize, viewport: FloatSize, opts: {
+    placement: FloatPlacement;
+    offset: number;
+    padding: number;
+}): {
+    top: number;
+    left: number;
+    placement: FloatPlacement;
+};

package/dist/internals/float.js

@@ -0,0 +1,31 @@
+"use client";
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(value, max));
+}
+function splitPlacement(placement) {
+  const [side, align] = placement.split("-");
+  return { side, align: align ?? "center" };
+}
+function joinPlacement(side, align) {
+  return align === "center" ? side : `${side}-${align}`;
+}
+function computeFloatPosition(anchor, float, viewport, opts) {
+  const { offset, padding } = opts;
+  const { side, align } = splitPlacement(opts.placement);
+  const roomBelow = viewport.height - (anchor.y + anchor.height) - offset - padding;
+  const roomAbove = anchor.y - offset - padding;
+  const wanted = side === "bottom" ? roomBelow : roomAbove;
+  const opposite = side === "bottom" ? roomAbove : roomBelow;
+  const flipped = float.height > wanted && opposite > wanted;
+  const finalSide = flipped ? side === "bottom" ? "top" : "bottom" : side;
+  const top = finalSide === "bottom" ? anchor.y + anchor.height + offset : anchor.y - float.height - offset;
+  const left = align === "start" ? anchor.x : align === "end" ? anchor.x + anchor.width - float.width : anchor.x + anchor.width / 2 - float.width / 2;
+  return {
+    top: clamp(top, padding, viewport.height - float.height - padding),
+    left: clamp(left, padding, viewport.width - float.width - padding),
+    placement: joinPlacement(finalSide, align)
+  };
+}
+export {
+  computeFloatPosition
+};

package/dist/internals/focus-trap.d.ts

@@ -0,0 +1,82 @@
+import type { ElementRef } from "./dom/types.js";
+export interface FocusTrapOptions {
+    /**
+     * Element to focus when the trap activates. Defaults to the first focusable
+     * descendant of node. A ref is resolved at every use rather than at attach
+     * time, so a target that appears later still wins.
+     */
+    initialFocus?: ElementRef<HTMLElement> | HTMLElement | null;
+    /**
+     * Whether to restore focus to the previously active element on destroy.
+     * Defaults to true. It does NOT govern `returnFocusNow()`: a caller that
+     * passes `returnFocus: false` and then calls the handle is contradicting
+     * itself, and the handle wins — asking for the eager return IS asking for
+     * the return. `returnFocus: false` governs the *unmount* path only.
+     */
+    returnFocus?: boolean;
+    /**
+     * Called on destroy, but only when the element that had focus before the
+     * trap activated is no longer in the document — removed by a re-render,
+     * a list row disappearing, a trigger inside a reordering list. Should
+     * return a still-connected element to focus instead, typically the
+     * overlay's own trigger, or `null`/`undefined` to fall through to the last
+     * resort. Never called while the original element is still connected —
+     * that element always wins first, unconditionally.
+     */
+    fallbackFocus?: () => HTMLElement | null | undefined;
+}
+/**
+ * The two functions the Svelte side hands out through `onActivate`. Here they
+ * are simply RETURNED: a hook can return a value, an action cannot.
+ *
+ * 1. `returnFocusNow` exists because an animated exit delays the unmount by the
+ *    length of the fade. Without it a keyboard user pressing Escape waits
+ *    200 ms for focus to come back — and worse, the panel is marked `inert` the
+ *    instant the exit starts, which drops focus to `<body>` for that whole
+ *    window. It is called at the dismiss instant, from `usePresence`'s
+ *    `onExitStart`, which fires on every close path (Escape, outside click,
+ *    close button, a caller's own `open` write) and fires before the node goes.
+ *
+ * 2. `rearm` exists because a surface reopened DURING its exit is not a new
+ *    mount: `usePresence` keeps it mounted through the whole exit, so the
+ *    effect never re-ran, the initial focus move never re-ran, and the
+ *    `returned` latch is still set. Without it the reopened `aria-modal` panel
+ *    would be interactive again with focus sitting on the trigger *behind* it
+ *    — untrapped, because the Tab handler is bound to the panel — and its next
+ *    dismiss would return focus nowhere at all, the handle and the unmount path
+ *    both being permanently disarmed for the life of the instance.
+ */
+export interface FocusTrapHandle {
+    /**
+     * Runs the three-step return chain IMMEDIATELY and disarms the unmount
+     * return. Idempotent: calling it twice, or letting the unmount follow it,
+     * returns focus exactly once.
+     */
+    returnFocusNow(): void;
+    /**
+     * Undoes that latch and pulls focus back inside, recapturing the element it
+     * displaced. Called at `onEnterStart` when a surface is reopened mid-exit.
+     */
+    rearm(): void;
+}
+export interface FocusTrapCoreHandle extends FocusTrapHandle {
+    update(options?: FocusTrapOptions): void;
+    destroy(): void;
+}
+/**
+ * The framework-free core. Activates the trap on `node` synchronously and
+ * returns the handle plus `update`/`destroy`.
+ *
+ * SSR-safe: does nothing when `document` is unavailable.
+ */
+export declare function attachFocusTrap(node: HTMLElement, opts?: FocusTrapOptions): FocusTrapCoreHandle;
+/**
+ * React binding. Pass the node (convention C-1), get back an identity-stable
+ * handle that is safe in a dependency array.
+ *
+ * The trap attaches in a layout effect keyed on `[node]` so focus lands before
+ * paint; option changes flow through the core's `update()` instead of
+ * re-attaching, so retargeting `initialFocus` between form steps never
+ * re-runs the initial focus move.
+ */
+export declare function useFocusTrap(node: HTMLElement | null, options?: FocusTrapOptions): FocusTrapHandle;

package/dist/internals/focus-trap.js

@@ -0,0 +1,145 @@
+"use client";
+import { useRef } from "react";
+import { useConstant, useIsomorphicLayoutEffect } from "./dom/ssr.js";
+import { useEventCallback } from "./dom/use-event-callback.js";
+import { useLiveRef } from "./dom/use-live-ref.js";
+const FOCUSABLE_SELECTOR = [
+  "button:not([disabled])",
+  "[href]:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  '[tabindex]:not([tabindex="-1"]):not([disabled])'
+].join(", ");
+function isVisible(el) {
+  if (el.hidden || el.closest("[hidden]") !== null) return false;
+  if (getComputedStyle(el).visibility === "hidden") return false;
+  for (let node = el; node; node = node.parentElement) {
+    if (getComputedStyle(node).display === "none") return false;
+  }
+  return true;
+}
+function getFocusableElements(node) {
+  return Array.from(node.querySelectorAll(FOCUSABLE_SELECTOR)).filter(isVisible);
+}
+function resolveElement(target) {
+  if (!target) return null;
+  return "current" in target ? target.current : target;
+}
+function attachFocusTrap(node, opts = {}) {
+  if (typeof document === "undefined") {
+    return { returnFocusNow() {
+    }, rearm() {
+    }, update() {
+    }, destroy() {
+    } };
+  }
+  let returnFocus = opts.returnFocus ?? true;
+  let fallbackFocus = opts.fallbackFocus;
+  let initialFocus = opts.initialFocus;
+  let previouslyFocused = document.activeElement;
+  function focusContainerFallback() {
+    if (!node.hasAttribute("tabindex")) node.setAttribute("tabindex", "-1");
+    node.focus();
+  }
+  function focusInitial(initialFocus2) {
+    const target = resolveElement(initialFocus2) ?? getFocusableElements(node)[0] ?? null;
+    if (target) target.focus();
+    else focusContainerFallback();
+  }
+  let returned = false;
+  function returnFocus_() {
+    if (returned) return;
+    returned = true;
+    if (previouslyFocused?.isConnected) {
+      previouslyFocused.focus();
+      return;
+    }
+    const fallback = fallbackFocus?.();
+    if (fallback?.isConnected) {
+      fallback.focus();
+      return;
+    }
+    if (!document.body.hasAttribute("tabindex")) {
+      document.body.setAttribute("tabindex", "-1");
+    }
+    document.body.focus();
+  }
+  function rearm() {
+    returned = false;
+    const active = document.activeElement;
+    if (node.contains(active)) return;
+    if (active && active !== document.body && active.isConnected) {
+      previouslyFocused = active;
+    }
+    focusInitial(initialFocus);
+  }
+  function handleKeydown(event) {
+    if (event.key !== "Tab") return;
+    const focusable = getFocusableElements(node);
+    if (focusable.length === 0) {
+      event.preventDefault();
+      focusContainerFallback();
+      return;
+    }
+    const first = focusable[0];
+    const last = focusable[focusable.length - 1];
+    const active = document.activeElement;
+    if (event.shiftKey) {
+      if (active === first || !node.contains(active)) {
+        event.preventDefault();
+        last.focus();
+      }
+    } else if (active === last || !node.contains(active)) {
+      event.preventDefault();
+      first.focus();
+    }
+  }
+  focusInitial(initialFocus);
+  node.addEventListener("keydown", handleKeydown);
+  return {
+    returnFocusNow: returnFocus_,
+    rearm,
+    update(newOpts = {}) {
+      returnFocus = newOpts.returnFocus ?? true;
+      fallbackFocus = newOpts.fallbackFocus;
+      initialFocus = newOpts.initialFocus;
+    },
+    destroy() {
+      node.removeEventListener("keydown", handleKeydown);
+      if (!returnFocus || returned) return;
+      returnFocus_();
+    }
+  };
+}
+function useFocusTrap(node, options = {}) {
+  const { initialFocus = null, returnFocus = true } = options;
+  const fallbackFocus = useEventCallback(options.fallbackFocus);
+  const coreRef = useRef(null);
+  const latest = useLiveRef({ initialFocus, returnFocus, fallbackFocus });
+  const handle = useConstant(() => ({
+    returnFocusNow() {
+      coreRef.current?.returnFocusNow();
+    },
+    rearm() {
+      coreRef.current?.rearm();
+    }
+  }));
+  useIsomorphicLayoutEffect(() => {
+    if (!node) return;
+    const core = attachFocusTrap(node, latest.current);
+    coreRef.current = core;
+    return () => {
+      coreRef.current = null;
+      core.destroy();
+    };
+  }, [node, latest]);
+  useIsomorphicLayoutEffect(() => {
+    coreRef.current?.update({ initialFocus, returnFocus, fallbackFocus });
+  }, [initialFocus, returnFocus, fallbackFocus]);
+  return handle;
+}
+export {
+  attachFocusTrap,
+  useFocusTrap
+};

package/dist/internals/host.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The two scraps of text that identify a cited document on screen: the host it
+ * came from, and the single character that stands in for a favicon.
+ *
+ * Loading a real favicon would mean a request to the cited site from every
+ * reader's browser, which is a tracking beacon nobody asked for and a broken
+ * image the moment the site is gone. A letter drawn from the host says the same
+ * thing, costs nothing, and cannot fail.
+ *
+ * Every citation surface — source cards, the collapsed sources pill, search
+ * result rows — reads hosts through here, so a `www.` is stripped and a
+ * scheme-less fixture is parsed the same way everywhere. Internal: not exported
+ * from the package.
+ */
+/**
+ * The host of a URL with any `www.` prefix removed, or an empty string when
+ * there is no host to show.
+ *
+ * `new URL` is the parser of record; the regex behind it only exists for the
+ * protocol-relative and scheme-less strings it rejects (`//docs.example.dev/x`,
+ * `docs.example.dev/x`), which turn up constantly in hand-written fixtures and
+ * in model output.
+ *
+ * `undefined` is accepted rather than merely typed away: the data reaching these
+ * components comes off the wire, where an optional field is a real possibility
+ * whatever the interface says.
+ */
+export declare function hostOf(url: string | undefined): string;
+/**
+ * The character in a monogram circle: the first letter or digit of the text,
+ * upper-cased, falling back to a question mark so the circle is never empty.
+ *
+ * First letter or digit rather than first character, because a title that opens
+ * with a quote or a bullet would otherwise put punctuation in the circle. The
+ * `u` flag is what keeps a character outside the BMP whole instead of matching
+ * half a surrogate pair.
+ */
+export declare function monogram(text: string | undefined): string;

package/dist/internals/host.js

@@ -0,0 +1,24 @@
+"use client";
+function hostOf(url) {
+  if (typeof url !== "string" || url === "") return "";
+  try {
+    return stripWww(new URL(url).hostname);
+  } catch {
+    const match = /^(?:[a-z][a-z0-9+.-]*:)?(?:\/\/)?([^/?#\s]+)/i.exec(url);
+    if (!match) return "";
+    const host = match[1].split("@").pop();
+    return host.includes(".") ? stripWww(host) : "";
+  }
+}
+function monogram(text) {
+  const match = /[\p{L}\p{N}]/u.exec(text ?? "");
+  const upper = (match?.[0] ?? "?").toUpperCase();
+  return [...upper].length > 1 ? match?.[0] ?? "?" : upper;
+}
+function stripWww(host) {
+  return host.replace(/^www\./i, "");
+}
+export {
+  hostOf,
+  monogram
+};

package/dist/internals/listbox.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Listbox keyboard-navigation core: which option is "active" (highlighted,
+ * `aria-activedescendant`-pointed-at) as arrow keys, Home/End and typeahead
+ * move through a flat list of options, some of which may be disabled.
+ *
+ * This is the frozen surface `Select`, `Combobox`, `Autocomplete` and
+ * `TimePicker` all consume, so every one of them gets the same two behaviours
+ * right once instead of four times:
+ *
+ * - A run of consecutive disabled options is skipped as a block, not one
+ *   step into a dead end — `move`/`moveToEdge` keep stepping past them. If
+ *   *every* option is disabled, stepping terminates after at most `count()`
+ *   attempts rather than looping forever hunting for an enabled option that
+ *   does not exist.
+ * - Typeahead accumulates characters typed within a short window and resets
+ *   after it, so "ne" lands on "Netherlands" rather than re-matching "e"
+ *   against everything. Repeating the same character cycles through the
+ *   matches for that character, one per press, the way a native `<select>`
+ *   does.
+ *
+ * Pure state + behaviour, no DOM: a caller wires `count`/`enabled` off
+ * whatever it renders (a data array for `Select`, live DOM children for a
+ * `Combobox` built on real elements) and reacts to `onActiveChange` to keep
+ * the active row in view.
+ *
+ * `createListbox` is framework-free and stays the tested surface. `useListbox`
+ * is the thin React binding on top: one store per mount, `destroy()` on
+ * unmount, and `activeIndex` read through `useSyncExternalStore` because this
+ * is the one index in the internals that genuinely has to drive rendering
+ * (`aria-activedescendant` on the listbox, `isActive(index)` on every row).
+ */
+export interface ListboxOptions {
+    /** Number of options currently rendered. */
+    count: () => number;
+    /** Whether the option at this index can be activated. */
+    enabled?: (index: number) => boolean;
+    /** Called when the active option changes, so the caller can scroll it into view. */
+    onActiveChange?: (index: number) => void;
+    /** Whether arrow navigation wraps at the ends. Defaults to true. */
+    loop?: boolean;
+}
+export interface ListboxState {
+    /** Index of the active option, or -1 when nothing is active. */
+    readonly activeIndex: number;
+    /** Moves by delta, skipping disabled options, wrapping when `loop`. `delta === 0` is a no-op. */
+    move(delta: number): void;
+    /** Jumps to the first or last enabled option. */
+    moveToEdge(edge: "first" | "last"): void;
+    /** Sets the active option directly; -1 clears it. A disabled index is left alone (no-op), never activated. */
+    setActive(index: number): void;
+    /** Advances typeahead with a printable character and activates the match. */
+    typeahead(char: string, labelAt: (index: number) => string): void;
+    /** Clears the typeahead buffer and any pending timer. Call from teardown. */
+    destroy(): void;
+    /**
+     * Added for React, standing in for the Svelte `$state` rune: notifies on
+     * every `activeIndex` change. Returns the unsubscribe.
+     */
+    subscribe(listener: () => void): () => void;
+}
+export declare function createListbox(options: ListboxOptions): ListboxState;
+export interface UseListboxOptions {
+    /**
+     * A plain number. The hook wraps it in a live ref and hands the factory the
+     * getter it expects, so a virtualised list that changes `count` between
+     * renders is honoured at call time exactly as in Svelte.
+     */
+    count: number;
+    /** Whether the option at this index can be activated. Read on every call, so an inline literal is fine. */
+    enabled?: (index: number) => boolean;
+    /** Called when the active option changes, so the caller can scroll it into view. */
+    onActiveChange?: (index: number) => void;
+    /** Whether arrow navigation wraps at the ends. Defaults to true. */
+    loop?: boolean;
+}
+export interface ListboxHandle {
+    /** The active option for THIS render, or -1. */
+    readonly activeIndex: number;
+    /** Moves by delta, skipping disabled options, wrapping when `loop`. `delta === 0` is a no-op. */
+    move(delta: number): void;
+    /** Jumps to the first or last enabled option. */
+    moveToEdge(edge: "first" | "last"): void;
+    /** Sets the active option directly; -1 clears it. A disabled index is left alone (no-op), never activated. */
+    setActive(index: number): void;
+    /** Advances typeahead with a printable character and activates the match. */
+    typeahead(char: string, labelAt: (index: number) => string): void;
+}
+/**
+ * One store per mount, `destroy()` on unmount — the consumer cannot forget the
+ * teardown the way a component wiring the factory by hand could.
+ *
+ * `count`, `enabled`, `onActiveChange` and `loop` are all read at call time
+ * from live refs, so passing them as plain values (or as inline literals that
+ * change identity every render) behaves exactly like the Svelte call sites'
+ * getter objects. The store is never rebuilt, so the buffered typeahead and
+ * the active index survive every re-render.
+ *
+ * Only the returned object's identity changes, and only when `activeIndex`
+ * does; the four methods are stable for the life of the component.
+ */
+export declare function useListbox(options: UseListboxOptions): ListboxHandle;

package/dist/internals/listbox.js

@@ -0,0 +1,171 @@
+"use client";
+import { useEffect, useCallback, useSyncExternalStore, useMemo } from "react";
+import { useConstant } from "./dom/ssr.js";
+import { useEventCallback } from "./dom/use-event-callback.js";
+import { useLiveRef } from "./dom/use-live-ref.js";
+const NONE = null;
+const TYPEAHEAD_TIMEOUT_MS = 500;
+function findNext(from, direction, count, loop, isEnabled) {
+  let idx = from;
+  for (let attempts = 0; attempts < count; attempts++) {
+    idx += direction;
+    if (loop) {
+      idx = (idx % count + count) % count;
+    } else if (idx < 0 || idx >= count) {
+      return NONE;
+    }
+    if (isEnabled(idx)) return idx;
+  }
+  return NONE;
+}
+function createListbox(options) {
+  let activeIndex = -1;
+  let buffer = "";
+  let timer = null;
+  const listeners = /* @__PURE__ */ new Set();
+  function notify() {
+    for (const listener of listeners) listener();
+  }
+  function subscribe(listener) {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+  function isEnabled(index) {
+    return options.enabled?.(index) ?? true;
+  }
+  function commitActive(index) {
+    if (index === activeIndex) return;
+    activeIndex = index;
+    notify();
+    options.onActiveChange?.(index);
+  }
+  function setActive(index) {
+    if (index !== -1) {
+      const count = options.count();
+      if (index < 0 || index >= count) return;
+      if (!isEnabled(index)) return;
+    }
+    commitActive(index);
+  }
+  function move(delta) {
+    if (delta === 0) return;
+    const count = options.count();
+    if (count <= 0) return;
+    const loop = options.loop ?? true;
+    const direction = delta >= 0 ? 1 : -1;
+    const steps = Math.abs(delta);
+    let from = activeIndex === -1 ? direction === 1 ? -1 : count : activeIndex;
+    let found = NONE;
+    for (let i = 0; i < steps; i++) {
+      const next = findNext(found ?? from, direction, count, loop, isEnabled);
+      if (next === NONE) break;
+      found = next;
+    }
+    if (found !== NONE) commitActive(found);
+  }
+  function moveToEdge(edge) {
+    const count = options.count();
+    if (count <= 0) return;
+    if (edge === "first") {
+      for (let i = 0; i < count; i++) {
+        if (isEnabled(i)) {
+          commitActive(i);
+          return;
+        }
+      }
+      return;
+    }
+    for (let i = count - 1; i >= 0; i--) {
+      if (isEnabled(i)) {
+        commitActive(i);
+        return;
+      }
+    }
+  }
+  function clearBuffer() {
+    buffer = "";
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  function typeahead(char, labelAt) {
+    const count = options.count();
+    if (count <= 0) return;
+    const lower = char.toLowerCase();
+    const isRepeatChar = buffer.length > 0 && [...buffer].every((c) => c === lower);
+    if (timer !== null) clearTimeout(timer);
+    timer = setTimeout(clearBuffer, TYPEAHEAD_TIMEOUT_MS);
+    if (isRepeatChar) {
+      buffer = lower;
+      for (let i = 1; i <= count; i++) {
+        const candidate = (activeIndex + i + count) % count;
+        if (!isEnabled(candidate)) continue;
+        if (labelAt(candidate).toLowerCase().startsWith(lower)) {
+          commitActive(candidate);
+          return;
+        }
+      }
+      return;
+    }
+    buffer += lower;
+    const query = buffer;
+    for (let i = 0; i < count; i++) {
+      if (!isEnabled(i)) continue;
+      if (labelAt(i).toLowerCase().startsWith(query)) {
+        commitActive(i);
+        return;
+      }
+    }
+  }
+  function destroy() {
+    clearBuffer();
+  }
+  return {
+    get activeIndex() {
+      return activeIndex;
+    },
+    move,
+    moveToEdge,
+    setActive,
+    typeahead,
+    destroy,
+    subscribe
+  };
+}
+const getServerSnapshot = () => -1;
+function useListbox(options) {
+  const countRef = useLiveRef(options.count);
+  const enabledRef = useLiveRef(options.enabled);
+  const loopRef = useLiveRef(options.loop);
+  const onActiveChange = useEventCallback(options.onActiveChange);
+  const store = useConstant(
+    () => createListbox({
+      count: () => countRef.current,
+      enabled: (index) => enabledRef.current?.(index) ?? true,
+      onActiveChange,
+      get loop() {
+        return loopRef.current;
+      }
+    })
+  );
+  useEffect(() => () => store.destroy(), [store]);
+  const getSnapshot = useCallback(() => store.activeIndex, [store]);
+  const activeIndex = useSyncExternalStore(store.subscribe, getSnapshot, getServerSnapshot);
+  return useMemo(
+    () => ({
+      activeIndex,
+      move: store.move,
+      moveToEdge: store.moveToEdge,
+      setActive: store.setActive,
+      typeahead: store.typeahead
+    }),
+    [activeIndex, store]
+  );
+}
+export {
+  createListbox,
+  useListbox
+};

package/dist/internals/markdown/Markdown.d.ts

@@ -0,0 +1,22 @@
+import { type ReactNode } from "react";
+import { type BlockToken } from "../markdown.js";
+export interface MarkdownProps {
+    /** Markdown source. Safe to update on every streamed chunk. */
+    text?: string;
+    className?: string;
+    /**
+     * Already-parsed blocks, used when the component renders itself for a
+     * blockquote. Consumers pass `text`.
+     */
+    blocks?: BlockToken[];
+    /**
+     * Rendered inline at the very end of the document — a streaming caret, say.
+     * Every block here is block-level, so a caret placed after the component
+     * would sit on its own line instead of trailing the last character; this
+     * puts it inside the last paragraph, heading or list item instead. A
+     * document ending in code, a table, a rule, or nothing at all has no inline
+     * tail to hold it, and drops it.
+     */
+    trailingCursor?: ReactNode;
+}
+export declare function Markdown({ text, className, blocks, trailingCursor }: MarkdownProps): import("react").JSX.Element;