@nim.zone/ui 0.6.0

package/dist/components/sheet.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+export interface SheetProps {
+    children: ReactNode;
+    className?: string;
+    /** Label for the close control; also names the dialog when no title is set. */
+    closeLabel?: string;
+    footer?: ReactNode;
+    onClose: () => void;
+    open: boolean;
+    title?: ReactNode;
+}
+/**
+ * The bottom sheet is nim's modal surface. It owns the three things that are
+ * always forgotten in hand-rolled sheets: the page behind it must not scroll,
+ * Escape must close it, and focus must move into it on open and be restorable
+ * on close.
+ */
+export declare function Sheet({ children, className, closeLabel, footer, onClose, open, title }: SheetProps): import('react').ReactPortal | null;

package/dist/components/sign-in-flow.d.ts

@@ -0,0 +1,60 @@
+import { ReactNode } from 'react';
+export type SignInMethod = 'code' | 'password';
+export interface SignInCopy {
+    back: string;
+    codeLabel: string;
+    codeSubtitle: (destination: string) => ReactNode;
+    codeTitle: string;
+    identifierLabel: string;
+    passwordLabel: string;
+    passwordSubtitle: ReactNode;
+    passwordTitle: string;
+    phoneLabel: string;
+    phoneSubtitle: ReactNode;
+    phoneTitle: string;
+    resend: string;
+    resendIn: (seconds: number) => string;
+    sendCode: string;
+    signIn: string;
+    usePassword: string;
+    usePhone: string;
+    verify: string;
+}
+export interface SignInFlowProps {
+    brand?: ReactNode;
+    className?: string;
+    codeLength?: number;
+    copy?: Partial<SignInCopy>;
+    /** ISO 3166-1 alpha-2 the phone step opens on. */
+    defaultCountry?: string;
+    /** Which door the flow opens on. With both methods enabled the viewer can
+        switch; with one, the other is never offered. */
+    defaultMethod?: SignInMethod;
+    /** Terms line, support link — under the action on every step. */
+    footer?: ReactNode;
+    methods?: SignInMethod[];
+    /** Ask the backend for a code. Rejecting shows the message on the step. */
+    onRequestCode?: (e164: string) => Promise<void> | void;
+    /** Verify it. Resolving is success — routing afterwards is the caller's. */
+    onVerifyCode?: (e164: string, code: string) => Promise<void> | void;
+    onPasswordSignIn?: (identifier: string, password: string) => Promise<void> | void;
+    /** Countries floated to the top of the picker. */
+    priority?: string[];
+    /** Seconds before "send it again" is offered. */
+    resendSeconds?: number;
+}
+/**
+ * The whole sign-in, ready to mount: phone → code, or email → password, with
+ * the resend countdown, the loading and error states, and the step machine
+ * already wired.
+ *
+ * The caller supplies three async functions and gets a working screen. Nothing
+ * here knows about a router or an API client — `onVerifyCode` resolving *is*
+ * success, and where the viewer goes next is the app's decision, made in one
+ * place instead of at each of the flow's five exits.
+ *
+ * Compose `AuthScreen`, `PhoneField`, `OtpInput` and `PasswordField` by hand
+ * instead when the product's flow differs — an invite code step, a captcha, a
+ * tenant picker. This is the common shape, not the only one.
+ */
+export declare function SignInFlow({ brand, className, codeLength, copy, defaultCountry, defaultMethod, footer, methods, onPasswordSignIn, onRequestCode, onVerifyCode, priority, resendSeconds, }: SignInFlowProps): import("react").JSX.Element;

package/dist/components/slider.d.ts

@@ -0,0 +1,10 @@
+import { InputHTMLAttributes } from 'react';
+export interface SliderProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type'> {
+    label?: string;
+    max?: number;
+    min?: number;
+    /** Rendered beneath the track, evenly spaced — e.g. ['1M', '8M', '15M']. */
+    scale?: string[];
+    value: number;
+}
+export declare function Slider({ className, label, max, min, scale, step, value, ...props }: SliderProps): import("react").JSX.Element;

package/dist/components/stat.d.ts

@@ -0,0 +1,10 @@
+import { HTMLAttributes, ReactNode } from 'react';
+export interface StatProps extends HTMLAttributes<HTMLDivElement> {
+    /** Signed change, e.g. `+12%`. Direction colours it and picks the arrow. */
+    delta?: string;
+    deltaDirection?: 'down' | 'up';
+    label: ReactNode;
+    unit?: ReactNode;
+    value: ReactNode;
+}
+export declare function Stat({ className, delta, deltaDirection, label, unit, value, ...props }: StatProps): import("react").JSX.Element;

package/dist/components/stepper.d.ts

@@ -0,0 +1,17 @@
+export interface StepperProps {
+    className?: string;
+    decrementLabel?: string;
+    incrementLabel?: string;
+    label: string;
+    max?: number;
+    min?: number;
+    onChange: (value: number) => void;
+    step?: number;
+    value: number;
+}
+/**
+ * A number with two full-size targets. Both buttons are control-height
+ * squares, so the pair clears the touch minimum rather than shrinking into the
+ * cramped ± chevrons this control usually becomes.
+ */
+export declare function Stepper({ className, decrementLabel, incrementLabel, label, max, min, onChange, step, value, }: StepperProps): import("react").JSX.Element;

package/dist/components/tab-bar.d.ts

@@ -0,0 +1,40 @@
+import { ReactNode } from 'react';
+import { IconName } from './icon';
+export interface TabBarItem {
+    /** Lifted and filled: the one action the product is for. At most one item
+        should carry it — two centres is no centre. */
+    center?: boolean;
+    href?: string;
+    icon: IconName;
+    /** Full name for assistive tech when `label` is shortened to fit. */
+    fullLabel?: string;
+    key: string;
+    label: string;
+    onSelect?: () => void;
+}
+export interface TabBarProps {
+    /** Accessible name for the bar itself. */
+    label: string;
+    className?: string;
+    items: TabBarItem[];
+    /** `key` of the active item. */
+    value: string;
+    /** Wrap items in the app's own router link. Given the item and the rendered
+        content, returns the element to use — nim never imports a router. */
+    renderItem?: (item: TabBarItem, content: ReactNode, props: Record<string, unknown>) => ReactNode;
+}
+/**
+ * The floating bottom navigation of a mobile app: three to five destinations,
+ * one of them optionally lifted into a primary action.
+ *
+ * It renders real links or buttons and marks the active one with
+ * `aria-current="page"`, so the bar is navigable by keyboard and readable by
+ * assistive tech. Routing stays outside: `renderItem` hands the caller the
+ * content and the props to spread onto their own `<Link>`, which is why the
+ * kit ships no router dependency.
+ *
+ * It sits above the safe-area inset rather than under the home indicator, and
+ * the page below owes it `padding-block-end` — a bar that covers the last row
+ * of a list is the most common way this pattern goes wrong.
+ */
+export declare function TabBar({ className, items, label, renderItem, value }: TabBarProps): import("react").JSX.Element;

package/dist/components/table.d.ts

@@ -0,0 +1,33 @@
+import { ReactNode } from 'react';
+export type SortDirection = 'ascending' | 'descending';
+export interface TableColumn<Row> {
+    /** Aligns to the trailing edge in tabular figures. Use it for money, counts,
+        and dates — anything a reader compares down a column. */
+    numeric?: boolean;
+    header: ReactNode;
+    key: string;
+    render: (row: Row) => ReactNode;
+    sortable?: boolean;
+    width?: string;
+}
+export interface TableProps<Row> {
+    caption?: string;
+    className?: string;
+    columns: TableColumn<Row>[];
+    onSort?: (key: string) => void;
+    rowKey: (row: Row) => string;
+    rows: Row[];
+    sort?: {
+        direction: SortDirection;
+        key: string;
+    };
+}
+/**
+ * A table, not a grid of divs: the caller supplies columns and rows and gets
+ * real `<table>` semantics, which is what lets a screen reader announce "row 3
+ * of 84, Amount 4,200".
+ *
+ * Row height follows `--nim-density`, the same multiplier that drives control
+ * heights — the reason density is a token rather than a prop here.
+ */
+export declare function Table<Row>({ caption, className, columns, onSort, rowKey, rows, sort }: TableProps<Row>): import("react").JSX.Element;

package/dist/components/tabs.d.ts

@@ -0,0 +1,23 @@
+import { HTMLAttributes } from 'react';
+export interface TabOption<T extends string> {
+    /** A trailing figure — a count, never a decoration. */
+    count?: number | string;
+    disabled?: boolean;
+    label: string;
+    value: T;
+}
+export interface TabsProps<T extends string> extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    label: string;
+    onChange: (value: T) => void;
+    options: TabOption<T>[];
+    value: T;
+}
+/**
+ * Tabs switch a region of the page. A Segmented control sets a value. They
+ * look similar and mean different things, and 0.1 had the segmented control
+ * carrying both jobs.
+ *
+ * Arrow keys move between tabs and select as they go — the pattern a tablist
+ * is expected to follow when its panels are cheap to render.
+ */
+export declare function Tabs<T extends string>({ className, label, onChange, options, value, ...props }: TabsProps<T>): import("react").JSX.Element;

package/dist/components/task-progress.d.ts

@@ -0,0 +1,38 @@
+import { ReactNode } from 'react';
+export type TaskStepStatus = 'active' | 'done' | 'failed' | 'pending' | 'skipped';
+export interface TaskStep {
+    /** What went wrong, or what is happening. Shown under the label — a status
+        word alone leaves a stuck viewer with nothing to act on. */
+    detail?: ReactNode;
+    id: string;
+    label: ReactNode;
+    status: TaskStepStatus;
+}
+export interface TaskProgressProps {
+    /** Rendered under the steps: a cancel control, a support line. */
+    action?: ReactNode;
+    className?: string;
+    /** The headline under the ring — what the job is doing right now. */
+    caption?: ReactNode;
+    labels?: {
+        of: (done: number, total: number) => string;
+        status: Record<TaskStepStatus, string>;
+    };
+    steps: TaskStep[];
+    title?: ReactNode;
+    /** 0–100. Omit to derive it from the steps, which is what a job with equal
+        stages wants; pass it when the server knows better. */
+    value?: number;
+}
+/**
+ * A long-running job the viewer is waiting on: a scan, an import, a render.
+ *
+ * The steps are the point. A bare percentage tells someone how long to wait;
+ * a named stage tells them what is happening and, when it fails, which part
+ * failed — which is the difference between "try again" and "try again with a
+ * better photo". Failure is a state of a step, not a replacement for the list.
+ *
+ * The region is `aria-live="polite"`, so a stage completing is announced
+ * without the viewer having to keep looking at it.
+ */
+export declare function TaskProgress({ action, caption, className, labels, steps, title, value, }: TaskProgressProps): import("react").JSX.Element;

package/dist/components/theme.d.ts

@@ -0,0 +1,49 @@
+import { ReactNode } from 'react';
+/**
+ * nim has two independent appearance axes.
+ *
+ * A STYLE owns how the interface is shaped: radii, elevation geometry, type
+ * voice, press behaviour. A COLOURWAY owns how it is coloured: surfaces, ink,
+ * lines, accent, status. They compose freely — `ledger` + `teal` is a legal
+ * pairing, not a mistake — which is why they are two attributes rather than
+ * one `theme` name multiplying out into a file per combination.
+ */
+export type NimStyle = 'ledger' | 'vlora';
+export type NimColorway = 'coral' | 'oxblood' | 'teal' | 'vermilion';
+/** `system` follows the OS and is resolved by CSS, not by JavaScript. */
+export type NimScheme = 'dark' | 'light' | 'system';
+export type NimDirection = 'ltr' | 'rtl';
+interface NimContextValue {
+    colorway: NimColorway;
+    direction: NimDirection;
+    /** BCP 47 tag. Components that format dates or numbers use it; the script
+        corrections in `persian.css` key off the `lang` attribute it writes. */
+    locale: string | undefined;
+    scheme: NimScheme;
+    setColorway: (colorway: NimColorway) => void;
+    setScheme: (scheme: NimScheme) => void;
+    setStyle: (style: NimStyle) => void;
+    style: NimStyle;
+}
+export interface NimProviderProps {
+    children: ReactNode;
+    className?: string;
+    defaultColorway?: NimColorway;
+    defaultScheme?: NimScheme;
+    defaultStyle?: NimStyle;
+    direction?: NimDirection;
+    /** BCP 47 tag, e.g. `fa-IR`. Written to `lang`, which is what turns on the
+        Persian script corrections and gives Calendar its month and weekday
+        names and its digits. Direction is separate: `dir` says which way the
+        line runs, `lang` says which script is being set. */
+    locale?: string;
+    /** Writes the appearance attributes onto <html> as well, so portalled
+        surfaces (sheets, dialogs, menus, toasts) inherit them from outside the
+        React tree. */
+    syncDocument?: boolean;
+}
+export declare function NimProvider({ children, className, defaultColorway, defaultScheme, defaultStyle, direction, locale, syncDocument, }: NimProviderProps): import("react").JSX.Element;
+export declare function useNim(): NimContextValue;
+/** Convenience for a header toggle: flips light ⇄ dark, leaving `system`. */
+export declare function useSchemeToggle(): () => void;
+export {};

package/dist/components/toast.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+export type ToastTone = 'accent' | 'danger' | 'neutral' | 'success';
+export interface ToastOptions {
+    action?: {
+        label: string;
+        onPress: () => void;
+    };
+    /** Milliseconds on screen. Pass 0 to require a manual dismissal. */
+    duration?: number;
+    message: string;
+    tone?: ToastTone;
+}
+export declare function ToastProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Throws when used outside the provider — a silent no-op would hide the bug. */
+export declare function useToast(): (options: ToastOptions) => void;

package/dist/components/tooltip.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+export interface TooltipProps {
+    children: ReactNode;
+    className?: string;
+    /** The text shown on hover. Never the only place the name lives. */
+    label: string;
+}
+/**
+ * A name for a control that shows only an icon.
+ *
+ * The bubble is `aria-hidden`: the trigger inside must already carry its own
+ * accessible name (IconButton does), so a screen reader is never read the same
+ * label twice, and a viewer who cannot hover never depends on this.
+ *
+ * Hover waits 200ms; keyboard focus does not, because a viewer who tabbed here
+ * has already asked.
+ */
+export declare function Tooltip({ children, className, label }: TooltipProps): import("react").JSX.Element;

package/dist/components/typography.d.ts

@@ -0,0 +1,18 @@
+import { ElementType, HTMLAttributes, ReactNode } from 'react';
+interface TextProps extends HTMLAttributes<HTMLElement> {
+    as?: ElementType;
+    children: ReactNode;
+}
+/** The largest role: page-opening statements only, one per screen. */
+export declare function Display({ as: Component, children, className, ...props }: TextProps): import("react").JSX.Element;
+export declare function Title({ as: Component, children, className, size, ...props }: TextProps & {
+    size?: 'lg' | 'md';
+}): import("react").JSX.Element;
+export declare function Body({ as: Component, children, className, size, ...props }: TextProps & {
+    size?: 'md' | 'sm';
+}): import("react").JSX.Element;
+/** Mono/uppercase in Ledger, sentence case in Vlora — the theme decides. */
+export declare function Label({ as: Component, children, className, ...props }: TextProps): import("react").JSX.Element;
+export declare function Caption({ as: Component, children, className, ...props }: TextProps): import("react").JSX.Element;
+export declare function Rule({ className, ...props }: HTMLAttributes<HTMLHRElement>): import("react").JSX.Element;
+export {};

package/dist/components/wizard.d.ts

@@ -0,0 +1,70 @@
+import { ReactNode } from 'react';
+export interface WizardStep {
+    /** The step itself. A function receives nothing — the caller already holds
+        the answers, because they are the app's, not the wizard's. */
+    content: ReactNode;
+    /** Blocks the CTA until the step is answered. */
+    canContinue?: boolean;
+    /** Overrides the CTA label on this step alone. */
+    continueLabel?: string;
+    id: string;
+    /** The one thing being asked. Kept short: a wizard step is a question. */
+    question?: ReactNode;
+    subtitle?: ReactNode;
+}
+export interface WizardProps {
+    className?: string;
+    continueLabel: string;
+    /** Label on the last step. */
+    finishLabel: string;
+    labels?: {
+        back: string;
+        close: string;
+        step: (index: number, total: number) => string;
+    };
+    onClose?: () => void;
+    /** Fired from the last step's CTA. */
+    onDone: () => void;
+    /** Every step change, including backwards — for analytics and autosave. */
+    onStep?: (index: number) => void;
+    steps: WizardStep[];
+}
+/**
+ * A short, one-question-per-screen flow: mood → cause → note, or any other
+ * sequence a viewer walks once and abandons easily.
+ *
+ * The step index is the wizard's; the answers are not. A wizard that owned the
+ * answers would have to know their shape, and every product's are different —
+ * so each step is given its content and reports back through `canContinue`,
+ * which is the only thing the shell needs to know.
+ *
+ * Progress is dots rather than a bar: a bar implies a percentage of work done,
+ * and three questions are three questions. The close control is always present
+ * — a flow the viewer cannot leave is a trap, and leaving is the most common
+ * thing anyone does with one of these.
+ */
+export declare function Wizard({ className, continueLabel, finishLabel, labels, onClose, onDone, onStep, steps, }: WizardProps): import("react").JSX.Element;
+export interface ChoiceGridOption {
+    disabled?: boolean;
+    icon?: ReactNode;
+    id: string;
+    label: ReactNode;
+}
+export interface ChoiceGridProps {
+    className?: string;
+    /** Cap a multi-select. Options past the cap disable rather than disappear,
+        so the grid does not reflow under the viewer's finger. */
+    max?: number;
+    multiple?: boolean;
+    onChange: (selected: string[]) => void;
+    options: ChoiceGridOption[];
+    selected: string[];
+}
+/**
+ * The grid of icon tiles a wizard step is usually made of.
+ *
+ * Single-select renders radios and multi-select renders checkboxes — stated in
+ * ARIA rather than implied by how many are lit, because "pick one" and "pick
+ * any" are different promises and only one of them is visible in a grid.
+ */
+export declare function ChoiceGrid({ className, max, multiple, onChange, options, selected, }: ChoiceGridProps): import("react").JSX.Element;

package/dist/index.d.ts

@@ -0,0 +1,104 @@
+export { ActivityFeed, AdminShell, DetailHeader, FilterChips } from './components/admin-shell';
+export type { ActivityEvent, ActivityFeedProps, AdminNavGroup, AdminNavItem, AdminShellProps, DetailHeaderProps, FilterChip, FilterChipsProps, } from './components/admin-shell';
+export { AppShell } from './components/app-shell';
+export type { AppShellProps } from './components/app-shell';
+export { AuthScreen } from './components/auth-screen';
+export type { AuthScreenProps } from './components/auth-screen';
+export { Avatar } from './components/avatar';
+export type { AvatarProps, AvatarSize } from './components/avatar';
+export { AvatarRing, ProfileHeader } from './components/profile-header';
+export type { AvatarRingProps, ProfileHeaderProps } from './components/profile-header';
+export { Badge } from './components/badge';
+export type { BadgeProps, BadgeSize, BadgeTone, BadgeVariant } from './components/badge';
+export { Banner } from './components/banner';
+export type { BannerProps, BannerTone } from './components/banner';
+export { Breadcrumb } from './components/breadcrumb';
+export type { BreadcrumbProps, Crumb } from './components/breadcrumb';
+export { Button } from './components/button';
+export type { ButtonProps, ButtonSize, ButtonVariant } from './components/button';
+export { Card } from './components/card';
+export type { CardPadding, CardProps, CardVariant } from './components/card';
+export { ActionBar, OptionCard, OrderSummary } from './components/checkout';
+export type { ActionBarProps, OptionCardProps, OrderSummaryProps, SummaryLine, } from './components/checkout';
+export { Chat } from './components/chat';
+export type { ChatAttachment, ChatMediaKind, ChatMessage, ChatProps } from './components/chat';
+export { ChatComposer } from './components/chat-composer';
+export type { ChatComposerProps, ChatDraft } from './components/chat-composer';
+export { Checkbox, Switch } from './components/choice';
+export type { CheckboxProps, SwitchProps } from './components/choice';
+export { Combobox } from './components/combobox';
+export type { ComboboxOption, ComboboxProps } from './components/combobox';
+export { Calendar, DateField, DatePicker } from './components/date-field';
+export type { CalendarProps, CalendarSystem, DateFieldProps, DatePickerProps, IsoDate, } from './components/date-field';
+export { addDays, addMonths, formatNumeric, monthLength, parseNumeric, partsOf, fromParts, startOfMonth, todayIso, } from './lib/calendars';
+export type { CalendarParts } from './lib/calendars';
+export { Dialog } from './components/dialog';
+export type { DialogProps } from './components/dialog';
+export { EmptyState } from './components/empty-state';
+export type { EmptyStateProps } from './components/empty-state';
+export { Progress, Skeleton, Spinner } from './components/feedback';
+export type { ProgressProps, SkeletonProps, SpinnerProps } from './components/feedback';
+export { ResourceMeter } from './components/resource-meter';
+export type { ResourceMeterProps, ResourceMeterTone } from './components/resource-meter';
+export { Input, Select, Textarea } from './components/field';
+export type { InputProps, SelectOption, SelectProps, TextareaProps } from './components/field';
+export { Icon, iconNames } from './components/icon';
+export type { IconName, IconProps, IconSize, IconTone } from './components/icon';
+export { IconButton } from './components/icon-button';
+export type { IconButtonProps, IconButtonSize, IconButtonVariant } from './components/icon-button';
+export { AppFrame, Inline, Stack } from './components/layout';
+export { List, ListRow } from './components/list';
+export type { ListProps, ListRowProps } from './components/list';
+export { Menu, Popover } from './components/menu';
+export type { MenuAction, MenuHeading, MenuItem, MenuProps, MenuSeparator, PopoverProps } from './components/menu';
+export { Onboarding } from './components/onboarding';
+export type { OnboardingProps, OnboardingSlide } from './components/onboarding';
+export { OtpInput } from './components/otp-input';
+export type { OtpInputProps } from './components/otp-input';
+export { Pagination } from './components/pagination';
+export type { PaginationProps } from './components/pagination';
+export { PasswordField, scorePassword } from './components/password-field';
+export type { PasswordFieldProps, PasswordStrength } from './components/password-field';
+export { PhoneField, toE164 } from './components/phone-field';
+export type { PhoneFieldProps } from './components/phone-field';
+export { PlanCard } from './components/plan-card';
+export type { PlanCardProps, PlanFeature } from './components/plan-card';
+export { PlanPicker } from './components/plan-picker';
+export type { BillingCycle, PlanOffer, PlanPickerProps } from './components/plan-picker';
+export { ProfileScreen } from './components/profile-screen';
+export type { ProfileRow, ProfileScreenProps, ProfileSection } from './components/profile-screen';
+export { SectionHeader } from './components/section-header';
+export type { SectionHeaderProps } from './components/section-header';
+export { Segmented } from './components/segmented';
+export type { SegmentedOption, SegmentedProps } from './components/segmented';
+export { SignInFlow } from './components/sign-in-flow';
+export type { SignInCopy, SignInFlowProps, SignInMethod } from './components/sign-in-flow';
+export { Sheet } from './components/sheet';
+export type { SheetProps } from './components/sheet';
+export { Slider } from './components/slider';
+export type { SliderProps } from './components/slider';
+export { Stat } from './components/stat';
+export type { StatProps } from './components/stat';
+export { Stepper } from './components/stepper';
+export type { StepperProps } from './components/stepper';
+export { TaskProgress } from './components/task-progress';
+export type { TaskProgressProps, TaskStep, TaskStepStatus } from './components/task-progress';
+export { Table } from './components/table';
+export type { SortDirection, TableColumn, TableProps } from './components/table';
+export { TabBar } from './components/tab-bar';
+export type { TabBarItem, TabBarProps } from './components/tab-bar';
+export { Tabs } from './components/tabs';
+export type { TabOption, TabsProps } from './components/tabs';
+export { NimProvider, useNim, useSchemeToggle } from './components/theme';
+export type { NimColorway, NimDirection, NimProviderProps, NimScheme, NimStyle, } from './components/theme';
+export { ToastProvider, useToast } from './components/toast';
+export type { ToastOptions, ToastTone } from './components/toast';
+export { Tooltip } from './components/tooltip';
+export type { TooltipProps } from './components/tooltip';
+export { ChoiceGrid, Wizard } from './components/wizard';
+export type { ChoiceGridOption, ChoiceGridProps, WizardProps, WizardStep, } from './components/wizard';
+export { Body, Caption, Display, Label, Rule, Title } from './components/typography';
+export { COUNTRIES, countryByDial, countryByIso2, countryNamer, toAsciiDigits, } from './lib/countries';
+export type { Country } from './lib/countries';
+export { cn } from './lib/cn';
+export type { ClassValue } from './lib/cn';

package/dist/lib/calendars.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Calendar arithmetic for the two systems the kit draws: Gregorian and
+ * Jalali (Solar Hijri).
+ *
+ * There is no conversion table and no leap-year rule in this file, because the
+ * platform already ships one: `Intl.DateTimeFormat` with `-u-ca-persian` is
+ * ICU's Persian calendar, and it is the same implementation a browser uses to
+ * label a date anywhere else. So the direction that is hard — Gregorian to
+ * Jalali — is asked of `Intl`, and the direction that is easy — Jalali back to
+ * Gregorian — is a close estimate corrected against that same answer until it
+ * round-trips. Every value this module returns has therefore been checked
+ * against the platform's own calendar rather than against a table that has to
+ * be maintained here and goes wrong in 1403 or 2049.
+ *
+ * The kit's value type never changes: an `IsoDate` is always the Gregorian
+ * `YYYY-MM-DD`, in every calendar system. What the viewer reads and what the
+ * API receives are different questions, and only the first one has a calendar.
+ */
+/** ISO `YYYY-MM-DD`, Gregorian, always. The kit never invents a date type. */
+export type IsoDate = string;
+/** The calendar a grid is drawn in — never what a value is stored in. */
+export type CalendarSystem = 'gregory' | 'persian';
+export interface CalendarParts {
+    day: number;
+    month: number;
+    year: number;
+}
+export declare const isoOf: (date: Date) => IsoDate;
+export declare const dateOf: (value: IsoDate) => Date;
+export declare const todayIso: () => IsoDate;
+/** The calendar fields a viewer of `system` would read off this instant. */
+export declare function partsOf(value: IsoDate, system: CalendarSystem): CalendarParts;
+/**
+ * The Gregorian date on which `parts` falls in `system`.
+ *
+ * For Jalali this starts from the mean-year estimate and walks to the answer,
+ * comparing against `partsOf` — which is ICU. The estimate is never more than
+ * a few days out, and the loop is bounded, so a bad input fails by returning
+ * its best effort rather than by spinning.
+ */
+export declare function fromParts(parts: CalendarParts, system: CalendarSystem): IsoDate;
+/** The first day of the month `value` falls in, in `system`. */
+export declare function startOfMonth(value: IsoDate, system: CalendarSystem): IsoDate;
+/** `delta` months on from `value`, clamped into the target month's length. */
+export declare function addMonths(value: IsoDate, delta: number, system: CalendarSystem): IsoDate;
+/**
+ * How many days that month holds — measured, not tabulated. The distance to
+ * the first of the next month is the length, whatever the leap rule says, so
+ * an Esfand of 30 days needs no special case here.
+ */
+export declare function monthLength(year: number, month: number, system: CalendarSystem): number;
+export declare const addDays: (value: IsoDate, days: number) => IsoDate;
+/** 0 = Sunday. The week's shape is the same fact in every calendar. */
+export declare const weekdayOf: (value: IsoDate) => number;
+/**
+ * The locale tag that puts `Intl` into `system`. A `-u-ca-` extension already
+ * on the tag wins, so an app asking for `fa-IR-u-ca-gregory` keeps it.
+ */
+export declare function localeFor(locale: string | undefined, system: CalendarSystem): string;
+/**
+ * The calendar an `fa` reader expects. Persian interfaces run on the Jalali
+ * calendar; everything else this kit ships in runs on the Gregorian one.
+ */
+export declare const defaultSystem: (locale: string | undefined) => CalendarSystem;
+/** Persian weeks begin on Saturday; the Gregorian ones here on Monday. */
+export declare const defaultWeekStart: (system: CalendarSystem) => number;
+/**
+ * `۱۴۰۴/۰۶/۰۱` — year first, zero-padded, in the locale's digits.
+ *
+ * Deliberately not `Intl`'s numeric pattern, which would give `۰۱/۰۶/۱۴۰۴ ه.ش`
+ * under an English locale on the Jalali calendar: field order and an era
+ * suffix that no Iranian writes and this module's parser cannot read back. A
+ * Jalali date is written biggest-unit-first everywhere it is written at all,
+ * so `formatNumeric` and `parseNumeric` agree by construction.
+ */
+export declare function formatNumeric(value: IsoDate, locale: string | undefined, system: CalendarSystem): string;
+/**
+ * Reads `1404/06/01`, `۱۴۰۴-۰۶-۰۱`, or anything else with three numbers in
+ * year, month, day order. Returns null rather than guessing at two.
+ */
+export declare function parseNumeric(input: string, system: CalendarSystem): IsoDate | null;

package/dist/lib/cn.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The kit's only class-name helper. nim components compose a small, fixed set
+ * of semantic class names, so a full `clsx`-style dependency would buy nothing
+ * that this does not already do.
+ */
+export type ClassValue = string | false | null | undefined;
+export declare const cn: (...values: ClassValue[]) => string;