haze-ui 1.32.0 → 1.34.0

package/dist/types/components/Switch/index.d.ts

@@ -1,4 +1,5 @@
-export { default as Switch } from './Switch';
-export type { SwitchProps } from './Switch';
-export { default as SwitchCore } from './SwitchCore';
-export type { SwitchCoreProps } from './SwitchCore';
+export { default as Switch } from './Switch.js';
+export type { SwitchProps } from './Switch.js';
+export { default as SwitchCore } from './SwitchCore.js';
+export type { SwitchCoreProps } from './SwitchCore.js';
+export { trackSizes, thumbSizes } from './switch-styles.js';

package/dist/types/components/Switch/switch-styles.d.ts

@@ -0,0 +1,15 @@
+export declare const trackSizes: {
+    readonly sm: import("@linaria/core").LinariaClassName;
+    readonly md: import("@linaria/core").LinariaClassName;
+    readonly lg: import("@linaria/core").LinariaClassName;
+};
+export declare const thumbSizes: {
+    readonly sm: import("@linaria/core").LinariaClassName;
+    readonly md: import("@linaria/core").LinariaClassName;
+    readonly lg: import("@linaria/core").LinariaClassName;
+};
+export declare const thumbCheckedSizes: {
+    readonly sm: import("@linaria/core").LinariaClassName;
+    readonly md: import("@linaria/core").LinariaClassName;
+    readonly lg: import("@linaria/core").LinariaClassName;
+};

package/dist/types/components/TabBar/index.d.ts

@@ -1,4 +1,4 @@
-export { default as TabBar } from './TabBar';
-export type { TabBarProps } from './TabBar';
-export { TabBarItem } from './TabBar';
-export type { TabBarItemProps } from './TabBar';
+export { default as TabBar } from './TabBar.js';
+export type { TabBarProps } from './TabBar.js';
+export { TabBarItem } from './TabBar.js';
+export type { TabBarItemProps } from './TabBar.js';

package/dist/types/components/Table/Table.d.ts

@@ -1,9 +1,24 @@
-import type { ReactNode } from 'react';
+import type { ReactNode, Ref } from 'react';
+import type { TableClassNames } from './TableContext.js';
 type TableProps = {
+    /** Zebra-stripe even body rows (default off, ConfigProvider
+     * `Table.striped` under it). */
     striped?: boolean;
+    /** Full cell borders on every th/td (default off, ConfigProvider
+     * `Table.bordered` under it). */
     bordered?: boolean;
+    /**
+     * Semantic slot classes (AntD v6 `classNames` shape): declared once
+     * here and distributed to every family part through context (see
+     * {@link TableClassNames}). Slot classes are appended at the end of
+     * each part's class list; per-part `className` props still land after
+     * the slot class. Not passing it renders identical output.
+     */
+    classNames?: TableClassNames;
     className?: string;
     children: ReactNode;
+    /** Forwarded to the underlying `<table>` element. */
+    ref?: Ref<HTMLTableElement>;
 };
-export default function Table({ striped, bordered, className, children, }: TableProps): import("react").JSX.Element;
+export default function Table({ striped, bordered, classNames, className, children, ref, }: TableProps): import("react").JSX.Element;
 export type { TableProps };

package/dist/types/components/Table/TableContext.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Semantic slot classes (AntD v6 `classNames` shape) for the Table
+ * family: declared once on `<Table>` and distributed to every part
+ * through context — the sub-components stay prop-light while one
+ * record themes the whole table. Consumer classes are appended at the
+ * end of each part's class list (able to override component defaults);
+ * per-part `className` props remain for one-off tweaks and still land
+ * after the slot class. Parts rendered outside a `<Table>` (bare
+ * `<TableHead>` etc.) receive nothing.
+ */
+export type TableClassNames = {
+    /** The scrolling wrapper `<div>` (`data-slot='table-container'`) `<Table>` renders. */
+    wrapper?: string;
+    /** Every `<TableHead>` (`<thead>`, `data-slot='header'`). */
+    head?: string;
+    /** Every `<TableBody>` (`<tbody>`, `data-slot='body'`). */
+    body?: string;
+    /** Every `<TableRow>` (`<tr>`, `data-slot='row'`). */
+    row?: string;
+    /** Every `<TableCell>` (`<td>`/`<th>`, `data-slot='cell'`). */
+    cell?: string;
+};
+export declare const TableClassNamesProvider: import("react").Provider<TableClassNames | undefined>;
+/** The slot record declared on the nearest `<Table>` (or a table-shaped
+ *  host like `DataTable`); `undefined` outside one. Decorative only —
+ *  never throws, so bare sub-components keep rendering. */
+export declare function useTableClassNames(): TableClassNames | undefined;

package/dist/types/components/Table/index.d.ts

@@ -1,10 +1,11 @@
-export { default as Table } from './Table';
-export type { TableProps } from './Table';
-export { default as TableHead } from './TableHead';
-export type { TableHeadProps } from './TableHead';
-export { default as TableBody } from './TableBody';
-export type { TableBodyProps } from './TableBody';
-export { default as TableRow } from './TableRow';
-export type { TableRowProps } from './TableRow';
-export { default as TableCell } from './TableCell';
-export type { TableCellProps } from './TableCell';
+export { default as Table } from './Table.js';
+export type { TableProps } from './Table.js';
+export type { TableClassNames } from './TableContext.js';
+export { default as TableHead } from './TableHead.js';
+export type { TableHeadProps } from './TableHead.js';
+export { default as TableBody } from './TableBody.js';
+export type { TableBodyProps } from './TableBody.js';
+export { default as TableRow } from './TableRow.js';
+export type { TableRowProps } from './TableRow.js';
+export { default as TableCell } from './TableCell.js';
+export type { TableCellProps } from './TableCell.js';

package/dist/types/components/Table/table-styles.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Table's boolean skin classes — exported so tests (and consumers)
+ * can assert the ConfigProvider `Table.striped` / `Table.bordered`
+ * tiers the same way Button's size map does. Sibling styles module
+ * per the react-refresh boundary convention (Input `input-styles`
+ * precedent); split-css groups the module with the Table family's css.
+ */
+export declare const stripedStyle: import("@linaria/core").LinariaClassName;
+export declare const borderedStyle: import("@linaria/core").LinariaClassName;

package/dist/types/components/Tabs/Tab.d.ts

@@ -23,6 +23,14 @@ type TabProps = {
      * (Unsaved changes / Error / Syncing).
      */
     statusLabel?: ReactNode;
+    /**
+     * Inert tab: not clickable, excluded from the strip's roving
+     * keyboard model (the `disabled` attribute on the plain button, plus
+     * `aria-disabled` on the closable div form), and skipped by the ⋯
+     * overflow menu's radios. Purely visual on the tab itself — why a
+     * tab is disabled stays the consumer's story to tell.
+     */
+    disabled?: boolean;
     /**
      * Renders the × close affordance. Purely notifying: activating it
      * calls `onClose` and nothing else — removing the tab from the
@@ -55,5 +63,5 @@ type TabProps = {
 export declare function TabStatusDot({ status }: {
     status: TabStatus;
 }): import("react").JSX.Element;
-export default function Tab({ value, icon, status, statusLabel, closable, closeLabel, onClose, className, children, }: TabProps): import("react").JSX.Element;
+export default function Tab({ value, icon, status, statusLabel, closable, closeLabel, onClose, disabled, className, children, }: TabProps): import("react").JSX.Element;
 export type { TabProps, TabStatus };

package/dist/types/components/Tabs/TabList.d.ts

@@ -1,5 +1,5 @@
 import type { RefObject, ReactNode } from 'react';
-import type { TabMeta } from './tab-metas';
+import type { TabMeta } from './tab-metas.js';
 type TabListProps = {
     className?: string;
     /** External handle on the strip's scroll viewport. SortableTabList

package/dist/types/components/Tabs/TabPanel.d.ts

@@ -4,5 +4,5 @@ type TabPanelProps = {
     className?: string;
     children: ReactNode;
 };
-export default function TabPanel({ value, className, children, }: TabPanelProps): import("react").JSX.Element;
+export default function TabPanel({ value, className, children, }: TabPanelProps): import("react").JSX.Element | null;
 export type { TabPanelProps };

package/dist/types/components/Tabs/Tabs.d.ts

@@ -1,8 +1,71 @@
-import type { ReactNode } from 'react';
+import type { ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
-import type { TabsClassNames } from './TabsContext';
+import type { TabsClassNames, TabsVariant, TabsAddable } from './TabsContext.js';
+import type { TabStatus } from './Tab.js';
+/**
+ * One tab of the data-driven `items` API on `<Tabs>`: the same affordances
+ * a compound `<Tab>` + `<TabPanel>` pair would declare, flattened into a
+ * record. `panel` is the tab's content — the panel always renders (even
+ * without `panel`) so the tab's `aria-controls` target never dangles.
+ */
+type TabData = {
+    value: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    /** Inert tab: not clickable, not focusable, skipped by the roving
+     *  model — surfaced on the compound layer as Tab's `disabled`. */
+    disabled?: boolean;
+    /** Renders the × close affordance (purely visual on this path — the
+     *  notifying `onClose` lives on the compound `<Tab>`). */
+    closable?: boolean;
+    status?: TabStatus;
+    panel?: ReactNode;
+};
 type TabsProps = {
     value?: ControlOrValue<string>;
+    /**
+     * Visual skin of the whole strip, distributed through context:
+     * `line` (default — the classic underline strip, full-width
+     * separator), `card` (flat antd-style cards, the selected tab
+     * raising onto a bordered surface) or `pill` (the Segmented-style
+     * capsule). Omitting it keeps the line look byte-for-byte.
+     */
+    variant?: TabsVariant;
+    /**
+     * Data-driven mode: renders the `<TabList>` (one `<Tab>` per item)
+     * and every `<TabPanel>` for you — the strip keeps the full
+     * compound machinery (overflow folding, roving keyboard,
+     * ResizeObserver compression) because it is the same `<TabList>`
+     * path. Mutually exclusive with compound `children`; when both are
+     * given, `items` wins and a dev-time console.error explains the
+     * conflict.
+     */
+    items?: TabData[];
+    /**
+     * `false` (default) keeps inactive tab panels mounted and hidden
+     * (`display: none`) — panel state survives tab switches. `true`
+     * unmounts them instead: switching destroys the panel's internal
+     * state (inputs, scroll), trading keep-alive for a lighter DOM.
+     */
+    destroyInactiveTabPane?: boolean;
+    /**
+     * `false` (default) mounts every panel eagerly (hidden behind
+     * `display: none` when inactive). `true` defers each panel's first
+     * mount to its first activation — `items` and compound paths alike.
+     * After the first activation `destroyInactiveTabPane` takes over
+     * again: keep the panel alive and hidden (`false`) or unmount it on
+     * every switch away (`true`).
+     */
+    lazy?: boolean;
+    /**
+     * Renders the `+` button at the tail of the tab bar (outside the
+     * tablist, so the strip keeps owning nothing but tabs). A real
+     * button — a normal tab stop, Enter/Space activates. `onAdd` only
+     * notifies; growing the `items` array (or mounting another compound
+     * `<Tab>`) is the consumer's job. `addLabel` overrides the
+     * accessible name.
+     */
+    addable?: TabsAddable;
     /**
      * Semantic slot classes (AntD v6 `classNames` shape): declared once
      * here and distributed to every part through context — see
@@ -10,7 +73,15 @@ type TabsProps = {
      */
     classNames?: TabsClassNames;
     className?: string;
-    children: ReactNode;
+    /**
+     * Forwarded to the root wrapper `<div data-slot='tabs'>` — layout
+     * measurement and `ref.current.focus()`-style element access reach
+     * the family root (the strip and panels keep their own internal
+     * handles).
+     */
+    ref?: Ref<HTMLDivElement>;
+    /** Compound mode: `<TabList>` + `<TabPanel>`s. Omit when using `items`. */
+    children?: ReactNode;
 };
-export default function Tabs({ value: valueControl, classNames, className, children, }: TabsProps): import("react").JSX.Element;
-export type { TabsProps };
+export default function Tabs({ value: valueControl, variant, items, destroyInactiveTabPane, lazy, addable, classNames, className, ref, children, }: TabsProps): import("react").JSX.Element;
+export type { TabsProps, TabData };

package/dist/types/components/Tabs/TabsContext.d.ts

@@ -1,4 +1,24 @@
 import type { Dispatch, SetStateAction } from 'react';
+/**
+ * Visual skin of the strip, declared once on `<Tabs>` and distributed
+ * through context:
+ *
+ * - `line` — the classic underline strip (default, the long-standing look)
+ * - `card` — flat antd-style cards; the selected tab raises onto a
+ *   bordered surface, no strip separator
+ * - `pill` — the Segmented-style capsule: a muted trough with the
+ *   selected tab lifting onto the bg surface
+ */
+export type TabsVariant = 'line' | 'card' | 'pill';
+/**
+ * The strip-tail `+` affordance, declared once on `<Tabs>` — see
+ * `addable` there. `addLabel` overrides the button's accessible
+ * name (the i18n hook).
+ */
+export type TabsAddable = {
+    onAdd?: () => void;
+    addLabel?: string;
+};
 /**
  * Semantic slot classes (AntD v6 `classNames` shape) for the Tabs
  * family: declared once on the `<Tabs>` root and distributed to every
@@ -21,6 +41,21 @@ export type TabsClassNames = {
 type TabsContextValue = {
     value: string;
     setValue: Dispatch<SetStateAction<string>>;
+    /** Strip/tab visual variant — one declaration on `<Tabs>` skins
+     *  every part (the strip chrome, each tab, the overflow areas). */
+    variant: TabsVariant;
+    /** Unmount inactive tab panels instead of keeping them alive and
+     * hidden — see `destroyInactiveTabPane` on `<Tabs>`. */
+    destroyInactiveTabPane: boolean;
+    /** Defer each panel's first mount to its first activation — see
+     * `lazy` on `<Tabs>`. */
+    lazy: boolean;
+    /** Values that have been active at least once (seeded with the
+     *  initial value) — the lazy-mount ledger `TabPanel` consults
+     *  before mounting an inactive panel. */
+    activated: ReadonlySet<string>;
+    /** Renders the strip-tail `+` button when set (TabList reads it). */
+    addable: TabsAddable | undefined;
     classNames: TabsClassNames | undefined;
 };
 export declare const TabsProvider: import("react").Provider<TabsContextValue | undefined>;

package/dist/types/components/Tabs/index.d.ts

@@ -1,11 +1,12 @@
-export { default as Tabs } from './Tabs';
-export type { TabsProps } from './Tabs';
-export type { TabsClassNames } from './TabsContext';
-export { default as TabList } from './TabList';
-export type { TabListProps } from './TabList';
-export { default as Tab } from './Tab';
-export type { TabProps, TabStatus } from './Tab';
-export { default as TabPanel } from './TabPanel';
-export type { TabPanelProps } from './TabPanel';
-export { default as SortableTabList } from './SortableTabList';
-export type { SortableTabListProps } from './SortableTabList';
+export { default as Tabs } from './Tabs.js';
+export type { TabsProps } from './Tabs.js';
+export type { TabsClassNames } from './TabsContext.js';
+export { default as TabList } from './TabList.js';
+export type { TabListProps } from './TabList.js';
+export { default as Tab } from './Tab.js';
+export type { TabProps, TabStatus } from './Tab.js';
+export { default as TabPanel } from './TabPanel.js';
+export type { TabPanelProps } from './TabPanel.js';
+export { default as SortableTabList } from './SortableTabList.js';
+export type { SortableTabListProps } from './SortableTabList.js';
+export { tabVariants, listVariants } from './tabs-styles.js';

package/dist/types/components/Tabs/tab-metas.d.ts

@@ -1,11 +1,25 @@
 import type { ReactNode } from 'react';
-import type { TabStatus } from './Tab';
+import type { TabStatus } from './Tab.js';
 export type TabMeta = {
     value: string;
     label: ReactNode;
     icon?: ReactNode;
     status?: TabStatus;
+    /** Carried into the overflow menu so a disabled tab is not
+     * selectable through the ⋯ radios either. */
+    disabled?: boolean;
 };
+/**
+ * The lazy-mount ledger: tab values that have been active at least
+ * once, seeded with the initial value. `<TabPanel>` consults it when
+ * `lazy` is set on `<Tabs>` — a panel that has never been active stays
+ * unmounted until its first activation. Recording happens in an effect
+ * (the newly active panel already mounts through `isActive`, so the
+ * one-commit lag is invisible). Lives here beside the metas collector
+ * so the component files keep a components-only export surface for
+ * react-refresh.
+ */
+export declare function useActivatedTabs(activeValue: string, enabled: boolean): ReadonlySet<string>;
 /**
  * `<Tab>` children in DOM order for the overflow menu: arrays and
  * Fragments flatten. Anything else between the tabs is left alone —

package/dist/types/components/Tabs/tabs-styles.d.ts

@@ -0,0 +1,10 @@
+import type { TabsVariant } from './TabsContext.js';
+/** Per-variant skin pair — `idle` rides every tab of the variant,
+ * `active` only the selected one (after the shared active floor). */
+export declare const tabVariants: Record<TabsVariant, {
+    idle: string;
+    active: string;
+}>;
+/** Per-variant strip chrome — the tabs carry the matching skins (see
+ * `tabVariants`). `variant` rides the Tabs context. */
+export declare const listVariants: Record<TabsVariant, string>;

package/dist/types/components/Tag/Tag.d.ts

@@ -1,11 +1,39 @@
-import type { ReactNode } from 'react';
-type TagProps = {
-    variant?: 'default' | 'primary' | 'success' | 'warning' | 'danger';
+import type { ComponentPropsWithRef, ElementType, ReactNode } from 'react';
+type TagOwnProps = {
+    /** Semantic status color. */
+    color?: 'default' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
     size?: 'sm' | 'md';
     closable?: boolean;
     onClose?: () => void;
-    className?: string;
+    /**
+     * Accessible label for the remove button. Inlined default keeps Tag
+     * hook-free (RSC-safe: no useStrings); locale-aware callers pass
+     * their own string.
+     */
+    removeLabel?: string;
     children: ReactNode;
 };
-export default function Tag({ variant, size, closable, onClose, className, children, }: TagProps): import("react").JSX.Element;
-export type { TagProps };
+/**
+ * MUI-OverridableComponent-shaped polymorphism (Button's pattern): own
+ * props first, then the target element's props minus the colliding keys.
+ * The skin, `data-slot` and the remove button always land on/inside the
+ * rendered element — the same "wiring wins" precedence as Button's `as`.
+ * `ref` (and every native attribute) flows through to the rendered root.
+ */
+type TagProps<T extends ElementType = 'span'> = TagOwnProps & {
+    /**
+     * Render element. `'span'` (default) keeps the static tag; `'a'`
+     * renders a clickable tag link — `href`, `target`, `rel` and the
+     * rest of the anchor surface flow through, and the link shape resets
+     * the UA underline so the tag looks identical to the `span` form.
+     * Any component that forwards props to a DOM element works the same
+     * way (e.g. a router Link).
+     *
+     * Don't combine an interactive `as` with `closable`: the remove
+     * button would nest inside a link — invalid HTML and an SR/keyboard
+     * trap.
+     */
+    as?: T;
+} & Omit<ComponentPropsWithRef<T>, keyof TagOwnProps | 'as'>;
+export default function Tag<T extends ElementType = 'span'>({ color, size, closable, onClose, removeLabel, as, className, children, ...rest }: TagProps<T>): import("react").JSX.Element;
+export type { TagOwnProps, TagProps };

package/dist/types/components/Tag/index.d.ts

@@ -1,2 +1,3 @@
-export { default as Tag } from './Tag';
-export type { TagProps } from './Tag';
+export { default as Tag } from './Tag.js';
+export type { TagProps } from './Tag.js';
+export { colors as tagVariants, tagSizes } from './tag-styles.js';

package/dist/types/components/Tag/tag-styles.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared Tag skin — the base, color and size classes the `Tag`
+ * component wears. Living in their own module keeps the component file
+ * free of style internals (react-refresh boundary) and lets the
+ * colors/sizes maps ship as public constants (`tagVariants` /
+ * `tagSizes`, the shadcn `buttonVariants` precedent) for consumers
+ * composing custom elements with the same skin; split-css groups the
+ * emitted CSS into `haze-ui/css/tag.css` with them.
+ */
+export declare const base: import("@linaria/core").LinariaClassName;
+export declare const colors: {
+    readonly default: import("@linaria/core").LinariaClassName;
+    readonly primary: import("@linaria/core").LinariaClassName;
+    readonly success: import("@linaria/core").LinariaClassName;
+    readonly warning: import("@linaria/core").LinariaClassName;
+    readonly danger: import("@linaria/core").LinariaClassName;
+    readonly info: import("@linaria/core").LinariaClassName;
+};
+export declare const tagSizes: {
+    readonly sm: import("@linaria/core").LinariaClassName;
+    readonly md: import("@linaria/core").LinariaClassName;
+};
+/** The link shape (`as` set): anchors get a UA underline the tag skin
+ * never asked for — reset it (the color classes already own the ink;
+ * Button's `link` class does the same for its anchor shape). Applies to
+ * every explicit `as`, including router Links that render anchors. */
+export declare const linkShape: import("@linaria/core").LinariaClassName;
+export declare const closeBtn: import("@linaria/core").LinariaClassName;

package/dist/types/components/TagGroup/SortableTagGroup.d.ts

@@ -1,5 +1,5 @@
 import type { ReactNode } from 'react';
-import { type TagGroupClassNames } from './TagGroup';
+import { type TagGroupClassNames } from './TagGroup.js';
 /**
  * Drag-and-drop reorderable variant of TagGroup — built on @dnd-kit
  * (a haze-ui dependency), so this module statically imports the dnd

package/dist/types/components/TagGroup/index.d.ts

@@ -1,6 +1,6 @@
-export { default as TagGroup } from './TagGroup';
-export { default as TagGroupItem } from './TagGroupItem';
-export { default as SortableTagGroup } from './SortableTagGroup';
-export type { TagGroupClassNames, TagGroupProps } from './TagGroup';
-export type { TagGroupItemProps } from './TagGroupItem';
-export type { SortableTagGroupProps } from './SortableTagGroup';
+export { default as TagGroup } from './TagGroup.js';
+export { default as TagGroupItem } from './TagGroupItem.js';
+export { default as SortableTagGroup } from './SortableTagGroup.js';
+export type { TagGroupClassNames, TagGroupProps } from './TagGroup.js';
+export type { TagGroupItemProps } from './TagGroupItem.js';
+export type { SortableTagGroupProps } from './SortableTagGroup.js';

package/dist/types/components/TagInput/SortableTagInputCore.d.ts

@@ -1,4 +1,4 @@
-import type { TagInputCoreProps } from './TagInputCore';
+import type { TagInputCoreProps } from './TagInputCore.js';
 /**
  * Props for `SortableTagInputCore` — the full `TagInputCoreProps` field
  * set (value/onChange/placeholder/maxTags/disabled/className/id/aria/ref)

package/dist/types/components/TagInput/TagInput.d.ts

@@ -7,6 +7,15 @@ type TagInputProps = {
     maxTags?: number;
     disabled?: boolean;
     className?: string;
+    /**
+     * Form field name: renders one hidden input per tag under the same
+     * name (native repeated-field semantics) so `<form action={fn}>` /
+     * `new FormData(form).getAll(name)` receive every tag — the inner
+     * text input never carries it (partial drafts would leak). An empty
+     * list submits nothing. react-f0rm `FormItem` usage never passes it,
+     * so both worlds coexist.
+     */
+    name?: string;
     /**
      * 字段 id（FormItem 桥生成）：必须挂到内部可聚焦的 input 上而非根
      * div，<label htmlFor> 与错误 span 的 aria 链路才能接到焦点元素——
@@ -21,5 +30,5 @@ type TagInputProps = {
      * element form bridges and `ref.current.focus()` reach. */
     ref?: Ref<HTMLInputElement>;
 };
-export default function TagInput({ value: valueControl, onChange, placeholder, maxTags, disabled, className, id, 'aria-invalid': ariaInvalid, 'aria-describedby': ariaDescribedby, ref, }: TagInputProps): import("react").JSX.Element;
+export default function TagInput({ value: valueControl, onChange, placeholder, maxTags, disabled, className, name, id, 'aria-invalid': ariaInvalid, 'aria-describedby': ariaDescribedby, ref, }: TagInputProps): import("react").JSX.Element;
 export type { TagInputProps };

package/dist/types/components/TagInput/index.d.ts

@@ -1,8 +1,8 @@
-export { default as TagInput } from './TagInput';
-export type { TagInputProps } from './TagInput';
-export { default as TagInputCore } from './TagInputCore';
-export type { TagInputCoreProps } from './TagInputCore';
-export { default as SortableTagInput } from './SortableTagInput';
-export type { SortableTagInputProps } from './SortableTagInput';
-export { default as SortableTagInputCore } from './SortableTagInputCore';
-export type { SortableTagInputCoreProps } from './SortableTagInputCore';
+export { default as TagInput } from './TagInput.js';
+export type { TagInputProps } from './TagInput.js';
+export { default as TagInputCore } from './TagInputCore.js';
+export type { TagInputCoreProps } from './TagInputCore.js';
+export { default as SortableTagInput } from './SortableTagInput.js';
+export type { SortableTagInputProps } from './SortableTagInput.js';
+export { default as SortableTagInputCore } from './SortableTagInputCore.js';
+export type { SortableTagInputCoreProps } from './SortableTagInputCore.js';

package/dist/types/components/Textarea/index.d.ts

@@ -1,4 +1,4 @@
-export { default as Textarea } from './Textarea';
-export type { TextareaProps } from './Textarea';
-export { default as TextareaCore } from './TextareaCore';
-export type { TextareaCoreProps } from './TextareaCore';
+export { default as Textarea } from './Textarea.js';
+export type { TextareaProps } from './Textarea.js';
+export { default as TextareaCore } from './TextareaCore.js';
+export type { TextareaCoreProps } from './TextareaCore.js';

package/dist/types/components/Textarea/textarea-styles.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared Textarea size skin — the per-size padding/typography classes
+ * the `TextareaCore` component wears (the `Textarea` sugar delegates to
+ * it). Sibling styles module per the react-refresh boundary convention
+ * (Input `input-styles` / NumberInput `number-input-styles` precedent);
+ * split-css groups the module with the Textarea family's css.
+ */
+export declare const sizes: {
+    readonly sm: import("@linaria/core").LinariaClassName;
+    readonly md: import("@linaria/core").LinariaClassName;
+    readonly lg: import("@linaria/core").LinariaClassName;
+};

package/dist/types/components/ThinkingIndicator/index.d.ts

@@ -1,2 +1,2 @@
-export { default as ThinkingIndicator } from './ThinkingIndicator';
-export type { ThinkingIndicatorProps } from './ThinkingIndicator';
+export { default as ThinkingIndicator } from './ThinkingIndicator.js';
+export type { ThinkingIndicatorProps } from './ThinkingIndicator.js';

package/dist/types/components/TimeField/TimeField.d.ts

@@ -0,0 +1,26 @@
+import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+import type { TimePickerFormat } from '../TimePicker/time.js';
+import type { TimeLabels, TimePlaceholder } from './TimeFieldCore.js';
+type TimeFieldProps = {
+    /** `"HH:mm"` / `"HH:mm:ss"` matching `format` (TimePicker's value
+     * semantics) or `''` when empty; commits fire only when every
+     * segment holds a value. */
+    value?: ControlOrValue<string>;
+    onChange?: (value: string) => void;
+    /** Column granularity and the value's serialization shape; defaults
+     * to `'HH:mm'` (no second segment), matching TimePicker. */
+    format?: TimePickerFormat;
+    /** 12-hour presentation with an AM/PM segment; the value stays
+     * 24-hour either way (10 PM serializes as `22:00`). */
+    use12Hours?: boolean;
+    disabled?: boolean;
+    placeholder?: TimePlaceholder;
+    labels?: TimeLabels;
+    className?: string;
+    /** Forwarded to the current tab-stop segment span — the element form
+     * bridges and `ref.current.focus()` reach. */
+    ref?: Ref<HTMLSpanElement>;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'onChange'>;
+export default function TimeField({ value: valueControl, onChange, format, use12Hours, disabled, placeholder, labels, className, ref, ...rest }: TimeFieldProps): import("react").JSX.Element;
+export type { TimeFieldProps };

package/dist/types/components/TimeField/TimeFieldCore.d.ts

@@ -0,0 +1,36 @@
+import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { TimePickerFormat } from '../TimePicker/time.js';
+/** Per-segment placeholder strings for the empty state. */
+type TimePlaceholder = {
+    hour?: string;
+    minute?: string;
+    second?: string;
+    dayPeriod?: string;
+};
+/** Accessible segment names, overriding the built-in English ones. */
+type TimeLabels = {
+    hour?: string;
+    minute?: string;
+    second?: string;
+    dayPeriod?: string;
+};
+type TimeFieldCoreProps = {
+    /** `"HH:mm"` / `"HH:mm:ss"` matching `format` (TimePicker's value
+     * semantics), or `''` when empty. */
+    value: string;
+    onChange: (value: string) => void;
+    /** Column granularity and the value's serialization shape; defaults
+     * to `'HH:mm'` (no second segment), matching TimePicker. */
+    format?: TimePickerFormat;
+    /** 12-hour presentation with an AM/PM segment; the value stays
+     * 24-hour either way (10 PM serializes as `22:00`). */
+    use12Hours?: boolean;
+    disabled?: boolean;
+    placeholder?: TimePlaceholder;
+    labels?: TimeLabels;
+    className?: string;
+    /** Forwarded to the current tab-stop segment span. */
+    ref?: Ref<HTMLSpanElement>;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'onChange'>;
+export default function TimeFieldCore({ value, onChange, format, use12Hours, disabled, placeholder, labels, className, ref, ...rest }: TimeFieldCoreProps): import("react").JSX.Element;
+export type { TimeFieldCoreProps, TimePlaceholder, TimeLabels };

package/dist/types/components/TimeField/index.d.ts

@@ -0,0 +1,4 @@
+export { default as TimeField } from './TimeField.js';
+export type { TimeFieldProps } from './TimeField.js';
+export { default as TimeFieldCore } from './TimeFieldCore.js';
+export type { TimeFieldCoreProps, TimePlaceholder, TimeLabels } from './TimeFieldCore.js';