@nibapp/ui 0.0.0-stage → 0.1.0

package/dist/lib/direction.js

@@ -0,0 +1,25 @@
+"use client";
+import { useDirection } from "@base-ui/react/direction-provider";
+/**
+ * +1 left to right, -1 right to left: multiply a horizontal motion offset by it so things slide in
+ * from the side they would in the person's language (a step forward comes from the end edge). The
+ * direction is the one `UiI18nProvider` gives Base UI.
+ */
+export function useInlineSign() {
+    return useDirection() === "rtl" ? -1 : 1;
+}
+/**
+ * A horizontal arrow key as a left-to-right reader means it, given `useInlineSign()`'s sign: right to
+ * left, ArrowRight points toward the start of the line and ArrowLeft toward its end (WAI-ARIA APG), so
+ * they swap. A handler written for left to right (ArrowRight opens a tree node, moves to the next
+ * column) then follows the reading direction. Other keys pass through.
+ */
+export function logicalArrow(key, sign) {
+    if (sign === 1)
+        return key;
+    if (key === "ArrowLeft")
+        return "ArrowRight";
+    if (key === "ArrowRight")
+        return "ArrowLeft";
+    return key;
+}

package/dist/lib/image-size.d.ts

@@ -0,0 +1,12 @@
+/** An image's own size in pixels, as its file header gives it. */
+export interface ImageSize {
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * The size a PNG, JPEG, GIF or WebP declares in its header, from its first bytes (a JPEG's frame
+ * header can come after its metadata: give it the first 64 KB); undefined for anything else.
+ */
+export declare function imageSize(bytes: Uint8Array): ImageSize | undefined;
+/** The size an inline (base64) image declares, decoding only its first 64 KB. */
+export declare function base64ImageSize(base64: string): ImageSize | undefined;

package/dist/lib/image-size.js

@@ -0,0 +1,66 @@
+const ascii = (bytes, at, length) => String.fromCharCode(...bytes.subarray(at, at + length));
+const u16be = (bytes, at) => ((bytes[at] ?? 0) << 8) | (bytes[at + 1] ?? 0);
+const u16le = (bytes, at) => (bytes[at] ?? 0) | ((bytes[at + 1] ?? 0) << 8);
+const u24le = (bytes, at) => u16le(bytes, at) | ((bytes[at + 2] ?? 0) << 16);
+const u32be = (bytes, at) => u16be(bytes, at) * 0x1_00_00 + u16be(bytes, at + 2);
+const sized = (width, height) => width > 0 && height > 0 ? { width, height } : undefined;
+/** A JPEG's size from its first start-of-frame marker (SOF0–SOF15, not DHT, JPG or DAC). */
+function jpegSize(bytes) {
+    let at = 2;
+    while (at + 9 < bytes.length) {
+        if (bytes[at] !== 0xff)
+            return undefined;
+        const marker = bytes[at + 1] ?? 0;
+        if (marker === 0xff) {
+            at += 1;
+            continue;
+        }
+        const frame = marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc;
+        if (frame)
+            return sized(u16be(bytes, at + 7), u16be(bytes, at + 5));
+        at += 2 + u16be(bytes, at + 2);
+    }
+    return undefined;
+}
+function webpSize(bytes) {
+    const chunk = ascii(bytes, 12, 4);
+    if (chunk === "VP8X")
+        return sized(u24le(bytes, 24) + 1, u24le(bytes, 27) + 1);
+    if (chunk === "VP8L") {
+        const b = (i) => bytes[21 + i] ?? 0;
+        return sized(1 + (((b(1) & 0x3f) << 8) | b(0)), 1 + (((b(3) & 0x0f) << 10) | (b(2) << 2) | ((b(1) & 0xc0) >> 6)));
+    }
+    if (chunk === "VP8 ")
+        return sized(u16le(bytes, 26) & 0x3fff, u16le(bytes, 28) & 0x3fff);
+    return undefined;
+}
+/**
+ * The size a PNG, JPEG, GIF or WebP declares in its header, from its first bytes (a JPEG's frame
+ * header can come after its metadata: give it the first 64 KB); undefined for anything else.
+ */
+export function imageSize(bytes) {
+    if (bytes[0] === 0x89 && ascii(bytes, 1, 3) === "PNG")
+        return sized(u32be(bytes, 16), u32be(bytes, 20));
+    if (ascii(bytes, 0, 4) === "GIF8")
+        return sized(u16le(bytes, 6), u16le(bytes, 8));
+    if (ascii(bytes, 0, 4) === "RIFF" && ascii(bytes, 8, 4) === "WEBP")
+        return webpSize(bytes);
+    if (bytes[0] === 0xff && bytes[1] === 0xd8)
+        return jpegSize(bytes);
+    return undefined;
+}
+/** How much of a base64 image to read for its size: 64 KB of bytes. */
+const HEADER_CHARS = 87_384;
+/** The size an inline (base64) image declares, decoding only its first 64 KB. */
+export function base64ImageSize(base64) {
+    try {
+        const binary = atob(base64.slice(0, HEADER_CHARS));
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i += 1)
+            bytes[i] = binary.charCodeAt(i);
+        return imageSize(bytes);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/lib/keycaps.d.ts

@@ -0,0 +1,21 @@
+import { type UiStrings } from "../i18n/strings/index.js";
+/**
+ * Keys as text, with no React and no DOM, for the kit's keycaps and for hosts that print text (an
+ * approval card in the CLI): a logical key's glyph, a chord as plain text, and the keycaps of a
+ * desktop accelerator. The caller says whether keys read as on a Mac (`isMacPlatform()` in a page,
+ * the host's own platform elsewhere).
+ */
+type KbdStrings = UiStrings["kbd"];
+/**
+ * Maps logical key names to platform glyphs: `mod` → ⌘ on Apple, Ctrl elsewhere. Key words come
+ * from `strings` (`useUiStrings().kbd`; English by default).
+ */
+export declare function keyGlyph(key: string, mac: boolean, strings?: KbdStrings): string;
+/** A chord as plain text, for placeholders and sentences: "⌘↵" on Apple, "Ctrl+Enter" elsewhere. */
+export declare function shortcutText(keys: readonly string[], mac: boolean, strings?: KbdStrings): string;
+/**
+ * The keycaps a desktop accelerator shows, as logical keys: the summon shortcut as the desktop shell
+ * takes it, a Tauri accelerator such as "CommandOrControl+Shift+Space" → `["mod", "shift", "space"]`.
+ */
+export declare function acceleratorKeys(accelerator: string): string[];
+export {};

package/dist/lib/keycaps.js

@@ -0,0 +1,62 @@
+import { EN_UI_STRINGS } from "../i18n/strings/index.js";
+/**
+ * Maps logical key names to platform glyphs: `mod` → ⌘ on Apple, Ctrl elsewhere. Key words come
+ * from `strings` (`useUiStrings().kbd`; English by default).
+ */
+export function keyGlyph(key, mac, strings = EN_UI_STRINGS.kbd) {
+    const k = key.toLowerCase();
+    const { keys } = strings;
+    const map = mac
+        ? { mod: "⌘", cmd: "⌘", ctrl: "⌃", alt: "⌥", option: "⌥", shift: "⇧", enter: "↵", return: "↵" }
+        : {
+            mod: keys.ctrl,
+            cmd: keys.ctrl,
+            ctrl: keys.ctrl,
+            alt: keys.alt,
+            option: keys.alt,
+            shift: keys.shift,
+            enter: keys.enter,
+            return: keys.enter,
+        };
+    const shared = {
+        up: "↑",
+        down: "↓",
+        left: "←",
+        right: "→",
+        esc: keys.esc,
+        escape: keys.esc,
+        tab: keys.tab,
+        space: keys.space,
+        backspace: "⌫",
+        delete: "⌦",
+    };
+    return map[k] ?? shared[k] ?? (key.length === 1 ? key.toUpperCase() : key);
+}
+/** A chord as plain text, for placeholders and sentences: "⌘↵" on Apple, "Ctrl+Enter" elsewhere. */
+export function shortcutText(keys, mac, strings = EN_UI_STRINGS.kbd) {
+    return keys.map((key) => keyGlyph(key, mac, strings)).join(mac ? "" : "+");
+}
+/**
+ * An accelerator's modifier and key names as logical keys, and the keys its name doesn't show
+ * ("Backquote" is the key marked `); the rest are the key as written ("K", "F5", "Up").
+ */
+const KEYCAP = {
+    CommandOrControl: "mod",
+    CmdOrCtrl: "mod",
+    Command: "cmd",
+    Control: "ctrl",
+    Ctrl: "ctrl",
+    Alt: "alt",
+    Option: "alt",
+    Shift: "shift",
+    Space: "space",
+    Enter: "enter",
+    Backquote: "`",
+};
+/**
+ * The keycaps a desktop accelerator shows, as logical keys: the summon shortcut as the desktop shell
+ * takes it, a Tauri accelerator such as "CommandOrControl+Shift+Space" → `["mod", "shift", "space"]`.
+ */
+export function acceleratorKeys(accelerator) {
+    return accelerator.split("+").map((part) => KEYCAP[part] ?? part);
+}

package/dist/lib/keyed.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Stable React keys for a list of values: each value's own key, with `#n` telling repeats apart. For
+ * pieces with no id (a message's images, a path's segments), so a list never leans on the map index.
+ * `@nibapp/ui/keyed`, a preview API: it may change in a minor version before 1.0.
+ */
+export declare function keyed<T>(items: readonly T[], keyOf: (item: T) => string): {
+    readonly item: T;
+    readonly key: string;
+}[];

package/dist/lib/keyed.js

@@ -0,0 +1,14 @@
+/**
+ * Stable React keys for a list of values: each value's own key, with `#n` telling repeats apart. For
+ * pieces with no id (a message's images, a path's segments), so a list never leans on the map index.
+ * `@nibapp/ui/keyed`, a preview API: it may change in a minor version before 1.0.
+ */
+export function keyed(items, keyOf) {
+    const seen = new Map();
+    return items.map((item) => {
+        const base = keyOf(item);
+        const count = seen.get(base) ?? 0;
+        seen.set(base, count + 1);
+        return { item, key: `${base}#${count}` };
+    });
+}

package/dist/lib/keys.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Keys, the kit's way: chords as logical keys (`["mod", "k"]`: `mod` is ⌘ on Apple platforms, Ctrl
+ * elsewhere, see `keyGlyph` in keycaps.ts), how a key event matches one on any keyboard layout, the
+ * `aria-keyshortcuts` a control announces, and the input-method guard every Enter handler uses. No
+ * table of bindings: a host's keymap reaches the kit's tooltips and menus through `ShortcutProvider`.
+ */
+/** Whether a key event lands where text goes (a field, a select, editable content): single-key shortcuts stand down there. */
+export declare function isTypingTarget(target: EventTarget | null): boolean;
+type ComposingKey = Pick<KeyboardEvent, "isComposing" | "keyCode">;
+/**
+ * A key pressed while an input method composes text: Chinese, Japanese, Korean and other input
+ * confirm a candidate with Enter, so a handler that acts on Enter skips it. WebKit, the desktop app's
+ * engine, sends the confirming Enter after `compositionend` with `isComposing` false and `keyCode`
+ * 229, so both count. Takes a DOM or a React keyboard event.
+ */
+export declare function isComposing(event: ComposingKey | {
+    readonly nativeEvent: ComposingKey;
+}): boolean;
+/** macOS, iPhone or iPad: `mod` is ⌘. */
+export declare function isMacPlatform(): boolean;
+/** Windows. */
+export declare function isWindowsPlatform(): boolean;
+/**
+ * The keys a key event stands for in a shortcut, lower-cased: a letter, or an unshifted digit, by its
+ * position (`code`), so a shortcut works on any layout (the key marked Y types "н" on a Russian one);
+ * punctuation and named keys as typed ("?", "@", "enter") and by position ("[" for ⌘⇧[, which types
+ * "{", or where a Russian layout types "х"). Every matcher, the kit's and its host's, reads these.
+ */
+export declare function shortcutKeys(event: Pick<KeyboardEvent, "key" | "shiftKey"> & {
+    readonly code?: string | undefined;
+}): string[];
+/**
+ * Whether a keyboard event matches a chord's keys (exact modifiers; `mod` resolves per platform).
+ * Single-key chords like `j` / `k` only match without modifiers.
+ */
+export declare function matchesShortcut(event: Pick<KeyboardEvent, "key" | "metaKey" | "ctrlKey" | "shiftKey" | "altKey"> & {
+    readonly code?: string | undefined;
+}, keys: readonly string[], mac?: boolean): boolean;
+/**
+ * The `aria-keyshortcuts` value for a chord (`["mod", "n"]` → "Meta+N" on Apple, "Control+N"
+ * elsewhere). Put it on the control the shortcut triggers; the visible `<Shortcut>` inside it is
+ * `aria-hidden`, so the control's name stays "New document" instead of "New document⌘N".
+ */
+export declare function ariaKeyShortcuts(keys: readonly string[], mac?: boolean): string;
+/** Spread onto a control: `{ "aria-keyshortcuts": "Meta+N" }`, or nothing when there is no chord. */
+export declare function keyShortcutsProps(keys: readonly string[] | undefined, mac?: boolean): {
+    "aria-keyshortcuts"?: string;
+};
+export {};

package/dist/lib/keys.js

@@ -0,0 +1,159 @@
+/**
+ * Keys, the kit's way: chords as logical keys (`["mod", "k"]`: `mod` is ⌘ on Apple platforms, Ctrl
+ * elsewhere, see `keyGlyph` in keycaps.ts), how a key event matches one on any keyboard layout, the
+ * `aria-keyshortcuts` a control announces, and the input-method guard every Enter handler uses. No
+ * table of bindings: a host's keymap reaches the kit's tooltips and menus through `ShortcutProvider`.
+ */
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+/** Whether a key event lands where text goes (a field, a select, editable content): single-key shortcuts stand down there. */
+export function isTypingTarget(target) {
+    return (target instanceof HTMLElement &&
+        (target.isContentEditable || target.closest("input, textarea, select") !== null));
+}
+/**
+ * A key pressed while an input method composes text: Chinese, Japanese, Korean and other input
+ * confirm a candidate with Enter, so a handler that acts on Enter skips it. WebKit, the desktop app's
+ * engine, sends the confirming Enter after `compositionend` with `isComposing` false and `keyCode`
+ * 229, so both count. Takes a DOM or a React keyboard event.
+ */
+export function isComposing(event) {
+    const key = "nativeEvent" in event ? event.nativeEvent : event;
+    return key.isComposing || key.keyCode === 229;
+}
+/**
+ * The page's platform name: the User-Agent client hint where the browser has one (TypeScript's DOM
+ * types don't know it yet), else `navigator.platform`; empty where there is no browser.
+ */
+function platformName() {
+    if (typeof navigator === "undefined")
+        return "";
+    const hints = "userAgentData" in navigator ? navigator.userAgentData : undefined;
+    const hinted = isRecord(hints) ? hints["platform"] : undefined;
+    return typeof hinted === "string" ? hinted : (navigator.platform ?? "");
+}
+/** macOS, iPhone or iPad: `mod` is ⌘. */
+export function isMacPlatform() {
+    return /mac|iphone|ipad/iu.test(platformName());
+}
+/** Windows. */
+export function isWindowsPlatform() {
+    return /^win/iu.test(platformName());
+}
+const KEY_ALIASES = {
+    esc: "escape",
+    return: "enter",
+    up: "arrowup",
+    down: "arrowdown",
+    left: "arrowleft",
+    right: "arrowright",
+    space: " ",
+};
+/** Punctuation keys by position, as a US layout types them. */
+const PUNCTUATION_CODES = {
+    Backquote: "`",
+    Backslash: "\\",
+    BracketLeft: "[",
+    BracketRight: "]",
+    Comma: ",",
+    Period: ".",
+    Slash: "/",
+    Semicolon: ";",
+    Quote: "'",
+    Minus: "-",
+    Equal: "=",
+};
+/**
+ * The keys a key event stands for in a shortcut, lower-cased: a letter, or an unshifted digit, by its
+ * position (`code`), so a shortcut works on any layout (the key marked Y types "н" on a Russian one);
+ * punctuation and named keys as typed ("?", "@", "enter") and by position ("[" for ⌘⇧[, which types
+ * "{", or where a Russian layout types "х"). Every matcher, the kit's and its host's, reads these.
+ */
+export function shortcutKeys(event) {
+    const code = event.code ?? "";
+    const letter = /^Key([A-Z])$/u.exec(code)?.[1];
+    if (letter !== undefined)
+        return [letter.toLowerCase()];
+    const digit = /^Digit(\d)$/u.exec(code)?.[1];
+    if (digit !== undefined && !event.shiftKey)
+        return [digit];
+    const typed = event.key.toLowerCase();
+    const placed = PUNCTUATION_CODES[code];
+    return placed === undefined || placed === typed ? [typed] : [typed, placed];
+}
+/**
+ * Whether a keyboard event matches a chord's keys (exact modifiers; `mod` resolves per platform).
+ * Single-key chords like `j` / `k` only match without modifiers.
+ */
+export function matchesShortcut(event, keys, mac = isMacPlatform()) {
+    const want = { meta: false, ctrl: false, shift: false, alt: false };
+    let main;
+    for (const raw of keys) {
+        const k = raw.toLowerCase();
+        if (k === "mod")
+            want[mac ? "meta" : "ctrl"] = true;
+        else if (k === "cmd" || k === "meta")
+            want.meta = true;
+        else if (k === "ctrl")
+            want.ctrl = true;
+        else if (k === "shift")
+            want.shift = true;
+        else if (k === "alt" || k === "option")
+            want.alt = true;
+        else
+            main = KEY_ALIASES[k] ?? k;
+    }
+    if (main === undefined)
+        return false;
+    // Shifted punctuation ("@") arrives already shifted; don't require the flag for it.
+    const shiftOk = want.shift === event.shiftKey || (main.length === 1 && !/[a-z0-9]/.test(main));
+    return (shortcutKeys(event).includes(main) &&
+        event.metaKey === want.meta &&
+        event.ctrlKey === want.ctrl &&
+        event.altKey === want.alt &&
+        shiftOk);
+}
+const ARIA_KEYS = {
+    cmd: "Meta",
+    meta: "Meta",
+    ctrl: "Control",
+    // i18n-ignore: an aria-keyshortcuts key name (UI Events `key` value), the same in every locale
+    alt: "Alt",
+    option: "Alt",
+    shift: "Shift",
+    enter: "Enter",
+    return: "Enter",
+    esc: "Escape",
+    escape: "Escape",
+    tab: "Tab",
+    space: "Space",
+    backspace: "Backspace",
+    delete: "Delete",
+    up: "ArrowUp",
+    down: "ArrowDown",
+    left: "ArrowLeft",
+    right: "ArrowRight",
+    "+": "Plus",
+};
+/**
+ * The `aria-keyshortcuts` value for a chord (`["mod", "n"]` → "Meta+N" on Apple, "Control+N"
+ * elsewhere). Put it on the control the shortcut triggers; the visible `<Shortcut>` inside it is
+ * `aria-hidden`, so the control's name stays "New document" instead of "New document⌘N".
+ */
+export function ariaKeyShortcuts(keys, mac = isMacPlatform()) {
+    return keys
+        .map((raw) => {
+        const k = raw.toLowerCase();
+        if (k === "mod")
+            return mac ? "Meta" : "Control";
+        return ARIA_KEYS[k] ?? (raw.length === 1 ? raw.toUpperCase() : raw);
+    })
+        .join("+");
+}
+/** Spread onto a control: `{ "aria-keyshortcuts": "Meta+N" }`, or nothing when there is no chord. */
+export function keyShortcutsProps(keys, mac = isMacPlatform()) {
+    if (keys === undefined || keys.length === 0)
+        return {};
+    return { "aria-keyshortcuts": ariaKeyShortcuts(keys, mac) };
+}

package/dist/lib/kit-motion.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from "react";
+/**
+ * Where a kit component's `motion/react-m` elements get their animations. The features load the first time one
+ * renders, so a page that never animates doesn't carry them, and every animated component wraps itself, so it animates
+ * with no provider from the app. An element's first animation waits for them (a few milliseconds, once).
+ */
+export declare function KitMotion({ children }: {
+    readonly children: ReactNode;
+}): import("react").JSX.Element;

package/dist/lib/kit-motion.js

@@ -0,0 +1,12 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { LazyMotion } from "motion/react";
+const features = () => import("./motion-features.js").then((module) => module.domAnimation);
+/**
+ * Where a kit component's `motion/react-m` elements get their animations. The features load the first time one
+ * renders, so a page that never animates doesn't carry them, and every animated component wraps itself, so it animates
+ * with no provider from the app. An element's first animation waits for them (a few milliseconds, once).
+ */
+export function KitMotion({ children }) {
+    return _jsx(LazyMotion, { features: features, children: children });
+}

package/dist/lib/link-check-dialog.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from "react";
+/**
+ * `ExternalLinkCheck`'s dialog (components/link-policy.tsx), loaded only where a check renders: the whole address,
+ * then Open (as the link would have, in a new tab with no opener), Copy or Cancel. `asked` opens it at once, for a
+ * click on the link while this was still loading.
+ */
+export declare function LinkCheckDialog({ href, trigger, asked, }: {
+    readonly href: string;
+    readonly trigger: (open: () => void) => ReactNode;
+    readonly asked: boolean;
+}): import("react").JSX.Element;

package/dist/lib/link-check-dialog.js

@@ -0,0 +1,18 @@
+"use client";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Button } from "../components/button.js";
+import { Dialog, DialogClose } from "../components/dialog.js";
+import { useUiStrings } from "../i18n/provider.js";
+import { useCopyToClipboard } from "./use-copy-to-clipboard.js";
+/**
+ * `ExternalLinkCheck`'s dialog (components/link-policy.tsx), loaded only where a check renders: the whole address,
+ * then Open (as the link would have, in a new tab with no opener), Copy or Cancel. `asked` opens it at once, for a
+ * click on the link while this was still loading.
+ */
+export function LinkCheckDialog({ href, trigger, asked, }) {
+    const t = useUiStrings().markdown.linkCheck;
+    const [open, setOpen] = useState(asked);
+    const [copied, copy] = useCopyToClipboard();
+    return (_jsxs(_Fragment, { children: [trigger(() => setOpen(true)), _jsx(Dialog, { open: open, onOpenChange: setOpen, title: t.title, description: t.description, footer: _jsxs(_Fragment, { children: [_jsx(DialogClose, { render: _jsx(Button, { variant: "ghost" }), children: t.cancel }), _jsx(Button, { variant: "secondary", onClick: () => copy(href), children: copied ? t.copied : t.copy }), _jsx(Button, { nativeButton: false, render: _jsx("a", { href: href, target: "_blank", rel: "noopener noreferrer" }), onClick: () => setOpen(false), children: t.open })] }), children: _jsx("p", { "data-slot": "link-check-address", className: "break-all font-mono text-sm text-fg", children: href }) })] }));
+}

package/dist/lib/motion-features.d.ts

@@ -0,0 +1 @@
+export { domAnimation } from "motion/react";

package/dist/lib/motion-features.js

@@ -0,0 +1,4 @@
+// The animation features the kit's `motion/react-m` elements use (animate, exit, variants, the gestures): loaded by
+// `KitMotion` once a kit animation first renders, apart from the page's first bundle. No kit module uses layout
+// animation or drag, which `domMax` would add.
+export { domAnimation } from "motion/react";

package/dist/lib/motion-provider.d.ts

@@ -0,0 +1,5 @@
+import type { ReactNode } from "react";
+/** App-wide motion defaults: a 180 ms tween, and honor the OS reduced-motion setting. */
+export declare function MotionProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/lib/motion-provider.js

@@ -0,0 +1,8 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { MotionConfig } from "motion/react";
+import { tween } from "./motion.js";
+/** App-wide motion defaults: a 180 ms tween, and honor the OS reduced-motion setting. */
+export function MotionProvider({ children }) {
+    return (_jsx(MotionConfig, { reducedMotion: "user", transition: tween.base, children: children }));
+}

package/dist/lib/motion.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Motion presets for `motion/react`. Keep motion purposeful: functional UI settles within 200 ms,
+ * no blur and no gratuitous bounce outside micro-moments. Every preset degrades gracefully under
+ * `prefers-reduced-motion` when the tree is wrapped in <MotionProvider> (reducedMotion="user").
+ */
+import { EASINGS, type SpringName } from "../_bundled/tokens/index.js";
+import type { BezierDefinition, Transition, Variants } from "motion/react";
+export declare const spring: Record<SpringName, Transition>;
+/** Durations in seconds (Motion's unit). */
+export declare const duration: {
+    readonly instant: number;
+    readonly fast: number;
+    readonly base: number;
+    readonly moderate: number;
+    readonly slow: number;
+    readonly slower: number;
+    readonly glacial: number;
+};
+export declare const ease: Record<keyof typeof EASINGS, BezierDefinition>;
+/** Tween helpers for opacity-only or color transitions where springs add nothing. */
+export declare const tween: {
+    fast: {
+        duration: number;
+        ease: BezierDefinition;
+    };
+    base: {
+        duration: number;
+        ease: BezierDefinition;
+    };
+    exit: {
+        duration: number;
+        ease: BezierDefinition;
+    };
+};
+export declare const fade: Variants;
+export declare const rise: Variants;
+export declare const pop: Variants;
+/** Staggered list entrance: put on the parent, use `rise` on children. */
+export declare const stagger: (each?: number, delayChildren?: number) => Variants;

package/dist/lib/motion.js

@@ -0,0 +1,49 @@
+/**
+ * Motion presets for `motion/react`. Keep motion purposeful: functional UI settles within 200 ms,
+ * no blur and no gratuitous bounce outside micro-moments. Every preset degrades gracefully under
+ * `prefers-reduced-motion` when the tree is wrapped in <MotionProvider> (reducedMotion="user").
+ */
+import { DURATIONS, EASINGS, SPRINGS } from "../_bundled/tokens/index.js";
+export const spring = {
+    snappy: { type: "spring", ...SPRINGS.snappy },
+    smooth: { type: "spring", ...SPRINGS.smooth },
+    gentle: { type: "spring", ...SPRINGS.gentle },
+    bouncy: { type: "spring", ...SPRINGS.bouncy },
+    signature: { type: "spring", ...SPRINGS.signature },
+};
+/** Durations in seconds (Motion's unit). */
+export const duration = {
+    instant: DURATIONS.instant / 1000,
+    fast: DURATIONS.fast / 1000,
+    base: DURATIONS.base / 1000,
+    moderate: DURATIONS.moderate / 1000,
+    slow: DURATIONS.slow / 1000,
+    slower: DURATIONS.slower / 1000,
+    glacial: DURATIONS.glacial / 1000,
+};
+export const ease = EASINGS;
+/** Tween helpers for opacity-only or color transitions where springs add nothing. */
+export const tween = {
+    fast: { duration: duration.fast, ease: ease.standard },
+    base: { duration: duration.base, ease: ease.standard },
+    exit: { duration: duration.fast, ease: ease.out },
+};
+export const fade = {
+    initial: { opacity: 0 },
+    animate: { opacity: 1, transition: tween.base },
+    exit: { opacity: 0, transition: tween.exit },
+};
+export const rise = {
+    initial: { opacity: 0, y: 6 },
+    animate: { opacity: 1, y: 0, transition: spring.snappy },
+    exit: { opacity: 0, y: -4, transition: tween.exit },
+};
+export const pop = {
+    initial: { opacity: 0, scale: 0.94 },
+    animate: { opacity: 1, scale: 1, transition: spring.snappy },
+    exit: { opacity: 0, scale: 0.97, transition: tween.exit },
+};
+/** Staggered list entrance: put on the parent, use `rise` on children. */
+export const stagger = (each = 0.03, delayChildren = 0) => ({
+    animate: { transition: { staggerChildren: each, delayChildren } },
+});