@enigmax/primitives 0.17.0 → 0.18.0

package/dist/input-BwXjFenq.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Input affordances: the buttons that live inside a field, with no styling of their own.
+ *
+ * A password field gets its reveal toggle automatically, because a field the visitor
+ * cannot read back is the single most common cause of a failed sign-in. Everything about
+ * it is replaceable - the icon, the label, the position, the container, whether it exists
+ * at all - and the same mechanism takes any other action you want in there.
+ *
+ * The details below are the ones the hand-rolled version gets wrong; each is commented
+ * with the failure it prevents.
+ */
+/** What an action renders. A string is parsed as HTML, so an inline SVG works. */
+type InputIcon = string | Node;
+interface InputActionState {
+    /** The field the action belongs to. */
+    input: HTMLInputElement;
+    /** True while the password is readable. Always false for a non-password field. */
+    revealed: boolean;
+    /** The field cannot be acted on: disabled or read-only. */
+    locked: boolean;
+}
+interface InputAction {
+    /** Stable id. Used for `data-action` and to replace a built-in (e.g. "reveal"). */
+    name: string;
+    /** Accessible name. Becomes both `aria-label` and `title`. */
+    label: string | ((state: InputActionState) => string);
+    icon: InputIcon | ((state: InputActionState) => InputIcon);
+    /** Runs on click and on Enter/Space, because it is a real button. */
+    onSelect: (state: InputActionState) => void;
+    /** Renders `aria-pressed`. Omit for actions that are not a toggle. */
+    pressed?: (state: InputActionState) => boolean;
+    /** Hide the action without removing it, e.g. a clear button on an empty field. */
+    visible?: (state: InputActionState) => boolean;
+}
+interface InputOptions {
+    /**
+     * The password reveal. `false` removes it. An object overrides parts of it - the
+     * icons, the labels - without giving up the caret and focus handling.
+     */
+    reveal?: boolean | {
+        /** Shown while the password is hidden; selecting it reveals. */
+        showIcon?: InputIcon;
+        /** Shown while the password is readable. */
+        hideIcon?: InputIcon;
+        showLabel?: string;
+        hideLabel?: string;
+    };
+    /** Extra actions, or a replacement for a built-in when `name` matches. */
+    actions?: InputAction[];
+    /** Which side the actions mount on. Position them yourself with CSS. */
+    position?: "start" | "end";
+    /**
+     * Mount the actions here instead of in a container created next to the input.
+     * Use it when your markup already has a slot for them.
+     */
+    container?: HTMLElement;
+    /** Called whenever the password's visibility changes. */
+    onRevealChange?: (revealed: boolean) => void;
+}
+interface InputInstance {
+    readonly revealed: boolean;
+    /** Show or hide the password. Toggles when the argument is omitted. */
+    reveal(next?: boolean): void;
+    /** Re-read the field and re-render the actions. Call after changing it yourself. */
+    refresh(): void;
+    update(options: Partial<InputOptions>): void;
+    destroy(): void;
+}
+
+/**
+ * Wire a field's in-field actions.
+ *
+ * @param input The field itself. A `type="password"` field gets the reveal for free.
+ */
+declare function createInput(input: HTMLInputElement, options?: InputOptions): InputInstance;
+
+export { type InputAction as I, type InputActionState as a, type InputIcon as b, type InputInstance as c, type InputOptions as d, createInput as e };

package/dist/marquee-CJ3Uwy3E.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Draggable infinite marquee: the behaviour engine, with no styling of its own.
+ *
+ * The contract is a SPEED in pixels per second, never a duration. A lap of a
+ * looping row is as long as its content, so a duration makes the row run faster
+ * every time an item is added to it. See the package README.
+ *
+ * Every rule encoded here was measured in a browser, not reasoned about. The
+ * comments marked "non-negotiable" name the bug that the obvious implementation
+ * shipped with.
+ */
+/**
+ * What a MOUSE resting on the row does to its speed. One option covers every case, so
+ * there is no pile of booleans to reconcile:
+ *
+ * - `"off"`   ignore hover entirely (the default)
+ * - `"pause"` stop while the pointer is on it
+ * - a number  multiply the cruise speed: `0.15` crawls, `1` changes nothing, `2` doubles
+ * - `{ speed }` an ABSOLUTE speed in px/s, whatever the cruise is; direction still
+ *   follows `reverse`, so you give a magnitude and not a sign
+ *
+ * Touch never triggers any of it - see the pointerType note on the hover handler.
+ */
+type MarqueeHover = number | "off" | "pause" | {
+    speed: number;
+};
+interface MarqueeOptions {
+    /**
+     * Pixels per second. NOT a duration: a duration ties the speed to the item
+     * count and the row silently accelerates as content grows.
+     */
+    speed?: number;
+    /** Scroll towards the start instead of the end. */
+    reverse?: boolean;
+    /** Scroll on the Y axis instead of the X axis. */
+    vertical?: boolean;
+    /** Allow grabbing and throwing the row. */
+    draggable?: boolean;
+    /** What a mouse resting on the row does to its speed. See {@link MarqueeHover}. */
+    hover?: MarqueeHover;
+    /** Fraction of the remaining velocity gap left after one second. */
+    decay?: number;
+    /**
+     * Apply the styles the behaviour needs (overflow, touch-action, user-select,
+     * will-change, transform). Never theme styles. Turn off to own them yourself.
+     */
+    manageStyles?: boolean;
+    /**
+     * How the repeated copies get into the DOM.
+     * - "clone": the engine clones the first child of the track (vanilla, Astro).
+     * - "external": the consumer renders them and is told the count (React, Vue).
+     */
+    copies?: "clone" | "external";
+    /** Called when the required copy count changes. Required for "external". */
+    onCopyCountChange?: (count: number) => void;
+    /** Called on a click that was not the end of a drag. */
+    onItemClick?: (event: MouseEvent) => void;
+    /** Called whenever the measured lap period changes. */
+    onMeasure?: (period: number, copyCount: number) => void;
+}
+interface MarqueeInstance {
+    /** Current offset in px, normalized to [0, period). */
+    readonly offset: number;
+    /** Measured distance between two copies of the content, in px. */
+    readonly period: number;
+    /** Copies currently required to cover the lane plus one whole period. */
+    readonly copyCount: number;
+    /** True between pointerdown and pointerup while the row is being grabbed. */
+    readonly dragging: boolean;
+    /** True while the OS asks for reduced motion. Autoplay stops, drag does not. */
+    readonly reducedMotion: boolean;
+    update(options: Partial<MarqueeOptions>): void;
+    /** Re-read the lap from the DOM. Called for you on resize and on font load. */
+    measure(): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+}
+declare function createMarquee(lane: HTMLElement, track: HTMLElement, options?: MarqueeOptions): MarqueeInstance;
+
+export { type MarqueeHover as M, type MarqueeInstance as a, type MarqueeOptions as b, createMarquee as c };

package/dist/network-D2LsBG_k.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Connection state: online/offline plus whatever the Network Information API will say.
+ *
+ * The part worth not rewriting is the TRANSITION. "You are back online" needs to know the
+ * connection had dropped, and every implementation of that ends up as a stray `wasOffline`
+ * boolean next to the effect, re-derived per screen and wrong the first time the page
+ * loads offline. It is tracked here instead.
+ */
+interface NetworkState {
+    online: boolean;
+    /** Estimated downlink in Mbps. Null where the browser does not report it. */
+    downlink: number | null;
+    downlinkMax: number | null;
+    /** "slow-2g" | "2g" | "3g" | "4g", or null. */
+    effectiveType: string | null;
+    /** Estimated round-trip time in ms. */
+    rtt: number | null;
+    /** The visitor asked for reduced data use. */
+    saveData: boolean | null;
+    /** "wifi" | "cellular" | "ethernet" | ..., or null. */
+    type: string | null;
+    /**
+     * The connection dropped earlier and is back. False on a first load, so a page that
+     * opens online never announces a recovery that did not happen.
+     */
+    recovered: boolean;
+    /** On a connection worth degrading for: 2g or slower, or data saver on. */
+    slow: boolean;
+}
+interface NetworkMonitor {
+    readonly state: NetworkState;
+    subscribe(listener: (state: NetworkState) => void): () => void;
+    destroy(): void;
+}
+/** What a server render sees. Assuming offline would flash a warning on every page. */
+declare const SERVER_NETWORK_STATE: NetworkState;
+declare function createNetworkMonitor(): NetworkMonitor;
+
+export { type NetworkMonitor as N, SERVER_NETWORK_STATE as S, type NetworkState as a, createNetworkMonitor as c };

package/dist/next/index.d.ts

@@ -1,8 +1,25 @@
 import * as react from 'react';
-import { ButtonProps } from '../react/index.js';
-export { BreachChecker, BreachState, BreachStatus, FieldAction, Flag, FlagProps, Input, InputProps, PasswordStrength, PasswordStrengthProps, RelativeTime, RelativeTimeProps, ToastControls, ToastPosition, Toaster, ToasterProps, UseButtonResult, UseInputResult, UseMarqueeResult, UseNotificationsResult, UseSearchResult, createNotificationQueue, defaultQueue, getLinkComponent, setLinkComponent, useButton, useInput, useMarquee, useNetworkState, useNotifications, useSearch } from '../react/index.js';
-export { ButtonOptions, ButtonState, EstimateOptions, FlagFormat, FlagOptions, FlagShape, FlagSource, GeneratePasswordOptions, InputAction, InputIcon, InputOptions, MarqueeHover, MarqueeInstance, MarqueeOptions, NetworkState, PasswordScore, PasswordStrengthReport, configureFlags, estimatePasswordStrength, flagAttributes, flagSrc, flagView, generatePassword, normalizeFlagCode } from '../index.js';
+import { ButtonProps } from '../react/button.js';
+export { UseMarqueeResult, useMarquee } from '../react/marquee.js';
+export { M as MarqueeHover, a as MarqueeInstance, b as MarqueeOptions } from '../marquee-CJ3Uwy3E.js';
+export { PasswordStrength, PasswordStrengthProps, UseButtonResult, UseInputResult, getLinkComponent, setLinkComponent, useButton, useInput } from '../react/index.js';
+export { UseSearchResult, useSearch } from '../react/search.js';
+export { I as InputAction, b as InputIcon, d as InputOptions } from '../input-BwXjFenq.js';
 export { F as FuseConstructor, b as SearchMatch, c as SearchOptions } from '../search-CsO3L1Lw.js';
+export { c as ButtonOptions, d as ButtonState } from '../button-CaXaqG_K.js';
+export { B as BreachChecker, a as BreachState, b as BreachStatus, F as FieldAction, I as Input, c as InputBaseProps, d as InputProps, e as InputType, P as PasswordOnlyProps, g as PlainOnlyProps, S as SearchOnlyProps } from '../index-DNXPtY9X.js';
+export { Slot, SlotProps, mergeSlotProps } from '../react/slot.js';
+export { E as EstimateOptions, G as GeneratePasswordOptions, a as PasswordScore, b as PasswordStrengthReport, e as estimatePasswordStrength, g as generatePassword } from '../password-C8lG4Zm9.js';
+export { UseNotificationsResult, createNotificationQueue, defaultQueue, useNotifications } from '../react/notifications.js';
+export { ToastControls, ToastPosition, Toaster, ToasterProps } from '../react/toast.js';
+export { useNetworkState } from '../react/network.js';
+export { a as NetworkState } from '../network-D2LsBG_k.js';
+export { RelativeTime, RelativeTimeProps } from '../react/relative-time.js';
+export { Flag, FlagProps } from '../react/flag.js';
+export { c as FlagFormat, d as FlagOptions, e as FlagShape, f as FlagSource, h as configureFlags, i as flagAttributes, k as flagName, l as flagSrc, m as flagView, n as normalizeFlagCode } from '../flags-BBJc9unY.js';
+export { P as PaletteContent, a as PaletteContextValue, b as PaletteField, c as PaletteFooter, d as PaletteItem, e as PaletteList, f as PaletteListProps, g as PaletteRoot, h as PaletteRootProps, i as PaletteRow, j as PaletteSection, k as PaletteTrigger, R as RecentEntry, l as RecentStore, S as SearchPalette, m as SearchPaletteProps, n as createRecentStore, o as groupRows, p as isPaletteShortcut, q as moveActive, r as recentKey, s as shortcutLabel, u as usePaletteContext } from '../index-D-ARvWpQ.js';
+import '../notifications-BpVV6sel.js';
+import '../relative-time-YpRTG7YH.js';
 
 /**
  * The Next.js entry. Same components, wired to `next/link`.

package/dist/next/index.js

@@ -1,8 +1,28 @@
 "use client";
-import { Button } from '../chunk-JFNND6P4.js';
-export { Flag, Input, PasswordStrength, RelativeTime, Toaster, createNotificationQueue, defaultQueue, getLinkComponent, setLinkComponent, useButton, useInput, useMarquee, useNetworkState, useNotifications, useSearch } from '../chunk-JFNND6P4.js';
-export { configureFlags, estimatePasswordStrength, flagAttributes, flagSrc, flagView, generatePassword, normalizeFlagCode } from '../chunk-4GLYRF4B.js';
+export { useInput } from '../chunk-U3V4EHOB.js';
+export { PasswordStrength } from '../chunk-XQHCZAPJ.js';
+export { Flag } from '../chunk-XNNQRA35.js';
+export { Toaster } from '../chunk-ZCUFYBPB.js';
+export { useMarquee } from '../chunk-ZWR2EXHQ.js';
+export { useSearch } from '../chunk-WSB655JB.js';
+export { useNetworkState } from '../chunk-S653GLSF.js';
+export { createNotificationQueue, defaultQueue, useNotifications } from '../chunk-QYMUIW5I.js';
+export { RelativeTime } from '../chunk-OCMI7R6H.js';
+import '../chunk-KJINGUQN.js';
+export { estimatePasswordStrength, generatePassword } from '../chunk-HC2ME5PU.js';
+export { configureFlags, flagAttributes, flagName, flagSrc, flagView, normalizeFlagCode } from '../chunk-AU3H5WIY.js';
+import '../chunk-UOSSNUSC.js';
+import '../chunk-2QFTRNAZ.js';
+import '../chunk-SNYUBXWQ.js';
+import '../chunk-IXVMRVD4.js';
+export { Input } from '../chunk-IIT6U7LM.js';
+import '../chunk-F25CGNQC.js';
+export { PaletteContent, PaletteField, PaletteFooter, PaletteItem, PaletteList, PaletteRoot, PaletteTrigger, SearchPalette, createRecentStore, groupRows, isPaletteShortcut, moveActive, recentKey, shortcutLabel, usePaletteContext } from '../chunk-LKA2UG4P.js';
 import '../chunk-UZFEEFMF.js';
+import { Button } from '../chunk-6BGBYUSZ.js';
+export { getLinkComponent, setLinkComponent, useButton } from '../chunk-6BGBYUSZ.js';
+import '../chunk-MMQPZGSU.js';
+export { Slot, mergeSlotProps } from '../chunk-HS3X3XCW.js';
 import Link from 'next/link';
 import { forwardRef, createElement } from 'react';
 

package/dist/notifications-BpVV6sel.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Notification queue: ordering, timers, dedupe and pause. No rendering, no styles.
+ *
+ * The timer is the part that is always wrong when hand-rolled. A dismiss timer
+ * that keeps counting while the tab is hidden fires the moment the visitor comes
+ * back and they never see the message, so the remaining time is held, not run.
+ */
+type NotificationTone = "info" | "success" | "warning" | "error" | "loading";
+/** One button on a notification. Anything more belongs on the page, not in a toast. */
+interface NotificationAction {
+    label: string;
+    onSelect: () => void;
+    /** Dismiss once it has been pressed. On by default. */
+    dismiss?: boolean;
+}
+interface NotificationInput {
+    /** Reuses the slot of a live notification with the same key instead of stacking. */
+    key?: string;
+    title: string;
+    body?: string;
+    tone?: NotificationTone;
+    /** ms before it dismisses itself. 0 or Infinity keeps it until dismissed. */
+    duration?: number;
+    action?: NotificationAction;
+    /** Arbitrary payload for the renderer: an href, an icon name. */
+    data?: unknown;
+}
+interface Notification extends Required<Omit<NotificationInput, "body" | "data" | "key" | "action">> {
+    id: string;
+    key?: string;
+    body?: string;
+    action?: NotificationAction;
+    data?: unknown;
+    createdAt: number;
+}
+/** What `promise()` shows at each stage. A function receives the resolved value or the error. */
+interface PromiseMessages<T> {
+    loading: string | NotificationInput;
+    success: string | ((value: T) => string | NotificationInput);
+    error: string | ((error: unknown) => string | NotificationInput);
+}
+interface NotificationsOptions {
+    /** Live notifications kept at once. The oldest dismissable one makes room. */
+    max?: number;
+    /** Default ms before self-dismissal. */
+    duration?: number;
+    /** Errors default to staying until dismissed. */
+    stickyTones?: NotificationTone[];
+}
+interface Notifications {
+    readonly items: readonly Notification[];
+    notify(input: NotificationInput): string;
+    /** Change a live notification in place, keeping its slot and restarting its timer. */
+    update(id: string, patch: Partial<NotificationInput>): void;
+    /**
+     * One notification that follows an async operation from loading to its outcome, in the
+     * same slot. The alternative is three toasts stacking up for one action.
+     */
+    promise<T>(work: Promise<T>, messages: PromiseMessages<T>): Promise<T>;
+    dismiss(id: string): void;
+    dismissAll(): void;
+    /** Hold every timer, e.g. while a pointer rests on the stack. */
+    pause(): void;
+    resume(): void;
+    subscribe(listener: (items: readonly Notification[]) => void): () => void;
+    destroy(): void;
+}
+declare function createNotifications(options?: NotificationsOptions): Notifications;
+
+export { type Notification as N, type PromiseMessages as P, type NotificationAction as a, type NotificationInput as b, type NotificationTone as c, type Notifications as d, type NotificationsOptions as e, createNotifications as f };

package/dist/password-3DRQYAYQ.js

@@ -0,0 +1,2 @@
+export { PasswordExtras, PasswordStrength } from './chunk-XQHCZAPJ.js';
+import './chunk-HC2ME5PU.js';

package/dist/password-C8lG4Zm9.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Making a password, and judging one.
+ *
+ * Both are opt-in. A sign-in form wants neither: offering to generate a password where one
+ * already exists is noise, and scoring one the visitor cannot change is worse. They belong
+ * on a registration form and a change-password form, which is where an agent should switch
+ * them on.
+ */
+/** Character classes a generated password can draw from. */
+interface PasswordAlphabet {
+    lowercase?: boolean;
+    uppercase?: boolean;
+    digits?: boolean;
+    symbols?: boolean;
+}
+interface GeneratePasswordOptions extends PasswordAlphabet {
+    /** Default 20. Long beats clever: length is the only term that scales. */
+    length?: number;
+    /**
+     * Drop the characters that are read wrong off a screen or off paper - I l 1 O 0.
+     * Worth it when the password will be typed by hand, not worth the entropy otherwise.
+     */
+    excludeAmbiguous?: boolean;
+    /** Characters to remove from every class, e.g. ones your backend rejects. */
+    exclude?: string;
+    /**
+     * Guarantee at least one character from every class asked for. Most password policies
+     * demand it; it costs a little entropy, because it removes every password that happens
+     * to lack one.
+     */
+    requireEachClass?: boolean;
+}
+/**
+ * A random password from the classes asked for.
+ *
+ * @throws when the runtime has no CSPRNG, or when the options ask for something impossible
+ *         (every class excluded, or a length too short to hold one of each).
+ */
+declare function generatePassword(options?: GeneratePasswordOptions): string;
+type PasswordScore = 0 | 1 | 2 | 3 | 4;
+interface PasswordStrengthReport {
+    /** 0 worst, 4 best. What the bars under the field render. */
+    score: PasswordScore;
+    /** Estimated bits of entropy after the penalties below. */
+    bits: number;
+    /**
+     * Why it scored what it scored, worst first. Show the first one; showing all of them
+     * turns a hint into a lecture.
+     */
+    warnings: string[];
+    /** Empty field. Render nothing rather than a zero score, which reads as a failure. */
+    empty: boolean;
+}
+interface EstimateOptions {
+    /**
+     * Values the visitor has already typed elsewhere - email, name, company. A password
+     * containing one of them is guessable by anyone who has the sign-up form in front of
+     * them, and no character-class rule catches it.
+     */
+    userInputs?: string[];
+}
+/**
+ * Score a password.
+ *
+ * The bits are an estimate and the bands are a convention, not a measurement - they exist
+ * to move a bar, not to certify anything. Swap this out for zxcvbn where the number has to
+ * mean something, and check the breach corpus for the cases no estimator can see.
+ */
+declare function estimatePasswordStrength(password: string, options?: EstimateOptions): PasswordStrengthReport;
+
+export { type EstimateOptions as E, type GeneratePasswordOptions as G, type PasswordAlphabet as P, type PasswordScore as a, type PasswordStrengthReport as b, estimatePasswordStrength as e, generatePassword as g };

package/dist/password-FB2CUEKJ.js

@@ -0,0 +1 @@
+export { estimatePasswordStrength, generatePassword } from './chunk-HC2ME5PU.js';

package/dist/react/button.d.ts

@@ -0,0 +1,75 @@
+import * as react from 'react';
+import { ComponentPropsWithoutRef, ElementType, ReactNode } from 'react';
+import { c as ButtonOptions, d as ButtonState } from '../button-CaXaqG_K.js';
+
+/**
+ * `<Button>` - the component, for the ninety percent.
+ *
+ * ```tsx
+ * <Button onPress={save}>Save</Button>
+ * ```
+ *
+ * That is the whole thing: disabled while the work runs, `aria-busy`, `data-loading`, and a
+ * cooldown afterwards if you asked for one. `useButton` is still there for a button whose
+ * markup is nothing like a button - a card, a table row - but reaching for it to render an
+ * ordinary one means writing the same six lines at every call site, which is how they drift.
+ */
+interface ButtonProps extends ButtonOptions, Omit<ComponentPropsWithoutRef<"button">, "onClick" | "onChange" | "children" | "type"> {
+    /**
+     * What to run when it is pressed. The same thing as `onPress`, under the name React
+     * already uses - write whichever reads better.
+     *
+     * It is an ALIAS, not a second handler: the component owns the element's real onClick,
+     * because that is where a press is refused while the button is loading, disabled or
+     * cooling down. Passing one through would replace that and silently take the behaviour
+     * with it. Returning a promise drives `loading` for its duration, same as `onPress`.
+     */
+    onClick?: ButtonOptions["onPress"];
+    /**
+     * Override what to render. You rarely need it: an href already renders whatever
+     * `setLinkComponent` registered - your router's Link - and a button otherwise.
+     */
+    as?: ElementType;
+    /**
+     * The label, or a function of the state for one that changes with it.
+     *
+     * ```tsx
+     * <Button onPress={send} cooldown={30_000}>
+     *     {({ loading, cooldown }) => loading ? "Sending" : cooldown ? `Wait ${Math.ceil(cooldown / 1000)}s` : "Resend"}
+     * </Button>
+     * ```
+     */
+    children?: ReactNode | ((state: ButtonState) => ReactNode);
+    /** Replaces the label while async work runs - a spinner, or just different words. */
+    pending?: ReactNode;
+    /** `type` on a real button. Ignored on a link, which has none. */
+    type?: "button" | "submit" | "reset";
+    /**
+     * Show the shortcut as a key badge after the label, the way Stripe writes
+     * "Create invoice n".
+     *
+     * `"auto"` (the default) shows it when there is a shortcut AND the label renders text:
+     * beside a lone glyph on an icon-only button the badge is noise, and it would double the
+     * width of the smallest control on the screen. `true` and `false` decide it outright.
+     */
+    shortcutHint?: boolean | "auto";
+    /** Render the badge yourself. Return null to drop it for one button. */
+    renderShortcut?: (key: string) => ReactNode;
+    /**
+     * Put the behaviour on YOUR element instead of ours - a `motion.button`, your design
+     * system's button, a router Link, anything.
+     *
+     * ```tsx
+     * <Button asChild cooldown={30_000} onPress={resend}>
+     *     <motion.button whileTap={{ scale: 0.98 }}>Resend</motion.button>
+     * </Button>
+     * ```
+     *
+     * The child owns its own markup, so the shortcut badge is not injected - the child is
+     * rendered exactly as written. Read `state.shortcut` from `useButton` to place your own.
+     */
+    asChild?: boolean;
+}
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLElement>>;
+
+export { Button, type ButtonProps };

package/dist/react/button.js

@@ -0,0 +1,4 @@
+"use client";
+export { Button } from '../chunk-6BGBYUSZ.js';
+import '../chunk-MMQPZGSU.js';
+import '../chunk-HS3X3XCW.js';

package/dist/react/flag.d.ts

@@ -0,0 +1,37 @@
+import { ImgHTMLAttributes, ReactNode } from 'react';
+import { e as FlagShape, c as FlagFormat, f as FlagSource } from '../flags-BBJc9unY.js';
+
+interface FlagProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, "src" | "alt" | "width" | "height"> {
+    /** `es`, `ES`, `en-GB`, `gb-eng`, or the emoji flag you are replacing. */
+    code: string | null | undefined;
+    /**
+     * Your own accessible name. Left out, the country's own name is used, in the reader's
+     * language - so a flag standing on its own is never a silent image.
+     */
+    label?: string;
+    /**
+     * Beside a country name that is already on screen the flag is decoration, and repeating
+     * the name only makes a screen reader say it twice.
+     */
+    decorative?: boolean;
+    /** Language the automatic name is written in. Follows the document's `lang` otherwise. */
+    locale?: string;
+    shape?: FlagShape;
+    format?: FlagFormat;
+    source?: FlagSource;
+    basePath?: string;
+    /** Rendered height in px. The width follows the shape. Default 16. */
+    size?: number;
+    /** Rendered when the code resolves to nothing. Nothing, by default. */
+    fallback?: ReactNode;
+}
+/**
+ * `<Flag code="es" />` - a country flag as an image, at the size you asked for, from the
+ * source the app configured once.
+ *
+ * The defaults come from `configureFlags`, so moving the whole application from the CDN to
+ * a downloaded set is one line at startup and no change at any call site.
+ */
+declare function Flag({ code, label, decorative, locale, shape, format, source, basePath, size, fallback, ...rest }: FlagProps): ReactNode;
+
+export { Flag, type FlagProps };

package/dist/react/flag.js

@@ -0,0 +1,3 @@
+"use client";
+export { Flag } from '../chunk-XNNQRA35.js';
+import '../chunk-AU3H5WIY.js';