@forte-ui/react 1.0.0-alpha.1

package/dist/components/textarea/Textarea.d.ts

@@ -0,0 +1,119 @@
+import { Field as BaseField } from '@base-ui/react/field';
+import * as React from "react";
+export type TextareaSize = "sm" | "md" | "lg";
+export type TextareaVariant = "outline" | "soft" | "ghost";
+export type TextareaResize = "vertical" | "none" | "both";
+type BaseControlProps = React.ComponentPropsWithoutRef<typeof BaseField.Control>;
+type TextareaElementProps = Omit<React.ComponentPropsWithoutRef<"textarea">, "className">;
+export interface TextareaProps extends TextareaElementProps {
+    /**
+     * Size of the control. Inline padding, block padding and font size move
+     * together, and the numbers come from the same `--forte-control-*` tokens
+     * `Input` and `Select.Trigger` read — so a textarea stacked under an input
+     * shares its optical inset at every `data-forte-density` setting.
+     *
+     * A `<textarea>` has no native `size` attribute, so unlike `Input` this
+     * shadows nothing.
+     * @default "md"
+     */
+    size?: TextareaSize;
+    /**
+     * How much visual weight the control carries. `outline` reads as a form
+     * control, `soft` as a filled field, `ghost` as an inline affordance — the
+     * same three `Input` has.
+     * @default "outline"
+     */
+    variant?: TextareaVariant;
+    /**
+     * The number of rows the box is at its shortest. Sets the native `rows`
+     * attribute and the floor the control can never shrink below — including
+     * under `autoResize`, and including a drag on the resize handle.
+     * @default 3
+     */
+    rows?: number;
+    /**
+     * The number of rows the box may grow to before it starts scrolling
+     * instead. Only a ceiling: a textarea shorter than this is unaffected.
+     * Unset means no ceiling.
+     */
+    maxRows?: number;
+    /**
+     * Grow with the content as the user types, between `rows` and `maxRows`.
+     *
+     * Implemented with the CSS `field-sizing` property where the browser has it,
+     * so there is no measurement, no reflow per keystroke and no inline height
+     * on the element. Older engines fall back to a resize observer and a
+     * `scrollHeight` read, which behaves identically and costs a layout per
+     * change.
+     *
+     * Forces `resize` to `"none"`: a handle whose value the next keystroke
+     * overwrites is not a control.
+     * @default false
+     */
+    autoResize?: boolean;
+    /**
+     * Which axes the user may drag the control along. `vertical` is the default
+     * because `both` lets the box escape the column it sits in — legitimate for
+     * a full-width composer, wrong for a field in a form.
+     * @default "vertical"
+     */
+    resize?: TextareaResize;
+    /**
+     * Stretch the control to fill the width of its container. Only needed
+     * outside a `Field.Root` — a field is a flex column, so a textarea inside
+     * one already stretches.
+     * @default false
+     */
+    fullWidth?: boolean;
+    /**
+     * Additional class name(s). Applied after the internal styles so consumer
+     * utilities (e.g. Tailwind) win without needing `!important`.
+     */
+    className?: string;
+    /** Replace the rendered element. Defaults to a `<textarea>`. */
+    render?: BaseControlProps["render"];
+    /** Callback fired when the value changes. Use when controlled. */
+    onValueChange?: BaseControlProps["onValueChange"];
+}
+/**
+ * The `autoResize` fallback for engines without `field-sizing` — Chrome landed
+ * it in 123, Firefox in 152 and Safari in 26.2, which still leaves a real
+ * share of users on a textarea that would silently not grow.
+ *
+ * Deliberately a no-op where the property IS supported: one CSS declaration
+ * does the whole job during layout, and an inline `block-size` written on top
+ * of it would fight the stylesheet's own min/max clamps.
+ *
+ * Exported for `InputGroup.Textarea`, which is the same control rendered bare
+ * inside a group shell and must grow by exactly the same rules — but NOT
+ * re-exported from the package: it is shared implementation, not API.
+ */
+export declare function useAutoSize(enabled: boolean): React.RefObject<HTMLTextAreaElement | null>;
+/**
+ * A multi-line text control.
+ *
+ * Base UI has no textarea primitive, so this is built on `Field.Control` — the
+ * same component `Input` is — rendered as a `<textarea>`. That is what makes it
+ * participate in a `Field` with no wiring: drop one inside a `Field.Root` and
+ * it picks up the label, the description, the error message, the `name` used on
+ * submit, and the validity attributes.
+ *
+ * ```tsx
+ * <Field.Root name="bio">
+ *   <Field.Label>Bio</Field.Label>
+ *   <Textarea rows={4} placeholder="Tell us about yourself" />
+ *   <Field.Error />
+ * </Field.Root>
+ * ```
+ *
+ * Height is expressed in rows rather than pixels — `rows` is the floor,
+ * `maxRows` the ceiling, and `autoResize` moves between them as the user types.
+ *
+ * State is exposed on `data-*` (`data-disabled`, `data-invalid`, `data-valid`,
+ * `data-dirty`, `data-touched`, `data-filled`, `data-focused`) and every visual
+ * decision is a `--forte-textarea-*` custom property, so it can be re-skinned
+ * from plain CSS or targeted with Tailwind arbitrary variants
+ * (`data-[invalid]:...`) without wrapping.
+ */
+export declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export {};

package/dist/components/textarea/Textarea.js

@@ -0,0 +1,3 @@
+"use client";
+import { n as e, t } from "../../Textarea-CqZJL41e.js";
+export { t as Textarea, e as useAutoSize };

package/dist/components/textarea/index.d.ts

@@ -0,0 +1,2 @@
+export { Textarea } from './Textarea';
+export type { TextareaProps, TextareaSize, TextareaVariant, TextareaResize, } from './Textarea';

package/dist/components/textarea/index.js

@@ -0,0 +1,2 @@
+import { t as e } from "../../Textarea-CqZJL41e.js";
+export { e as Textarea };

package/dist/components/toast/Toast.d.ts

@@ -0,0 +1,517 @@
+import { ToastObject as BaseToastObject, ToastManager as BaseToastManager, ToastPortalProps as BaseToastPortalProps, ToastRootProps as BaseToastRootProps, ToastTitleProps as BaseToastTitleProps, ToastDescriptionProps as BaseToastDescriptionProps, ToastActionProps as BaseToastActionProps, ToastCloseProps as BaseToastCloseProps } from '@base-ui/react/toast';
+import * as React from "react";
+/**
+ * The five types the library styles. `type` is a plain string in Base UI, so
+ * any other value passes through unharmed — it lands on `data-type` and gets
+ * the neutral treatment, which is what you want for an app-specific type
+ * styled from your own CSS.
+ */
+export type ToastType = "success" | "error" | "warning" | "info" | "loading";
+/**
+ * Where the stack sits. `start` / `end` are the *inline* edges, so a
+ * `bottom-end` viewport is bottom-right in LTR and bottom-left in RTL without
+ * anything being configured.
+ */
+export type ToastPosition = "top-start" | "top" | "top-end" | "bottom-start" | "bottom" | "bottom-end";
+/** A direction a toast can be flicked in to dismiss it. */
+export type ToastSwipeDirection = "up" | "down" | "left" | "right";
+/**
+ * Custom data carried on a toast.
+ *
+ * `icon` and `dismissible` are read by `Toast.Item`; everything else is yours
+ * and reaches a custom renderer untouched through `toast.data`. They live here
+ * rather than as top-level fields because `data` is the one field Base UI
+ * hands through verbatim — inventing a sibling of `title` would mean patching
+ * Base UI's own object type, and that breaks the moment it gains a field of
+ * the same name.
+ */
+export interface ToastData {
+    /**
+     * Replaces the type's default glyph. `false` removes it — and removes the
+     * icon column with it, so the text starts at the padding edge.
+     */
+    icon?: React.ReactNode | false;
+    /**
+     * Whether the close button renders. Turn it off for a toast that must be
+     * answered through its action button.
+     * @default true
+     */
+    dismissible?: boolean;
+    [key: string]: unknown;
+}
+/** A toast as it exists in the store — what a custom renderer receives. */
+export type ToastObject = BaseToastObject<ToastData>;
+/** The action button, if the toast has one. */
+export interface ToastActionOptions extends Omit<React.ComponentPropsWithoutRef<"button">, "children"> {
+    /** The button's text. */
+    label: React.ReactNode;
+}
+/**
+ * Everything you can say about a toast.
+ *
+ * Every field is optional, including `title` — a toast with only a
+ * `description` is a valid one-line message, and `Toast.Title` renders nothing
+ * rather than an empty heading.
+ */
+export interface ToastOptions {
+    /** The headline. Becomes the toast's accessible name. */
+    title?: React.ReactNode;
+    /** A second line under the title. Becomes the accessible description. */
+    description?: React.ReactNode;
+    /**
+     * Which glyph and accent colour to use, and what lands on `data-type`.
+     * The named methods on `useToast()` set this for you.
+     */
+    type?: ToastType | (string & {});
+    /**
+     * How long before the toast dismisses itself, in milliseconds. `0` keeps it
+     * on screen until it is closed. Falls back to the provider's `timeout`.
+     *
+     * Ignored for `type="loading"`, which never auto-dismisses — resolve it with
+     * `update()` or close it through the handle.
+     */
+    timeout?: number;
+    /**
+     * `"high"` announces the toast assertively, interrupting whatever the screen
+     * reader is saying, and renders it as an `alertdialog` rather than a
+     * `dialog`. Reserve it for something the user has to hear *now*; routine
+     * confirmations are `"low"`.
+     * @default "low"
+     */
+    priority?: "low" | "high";
+    /**
+     * A stable identifier. Showing a toast with an id that is already on screen
+     * updates that toast in place and restarts its timer, instead of stacking a
+     * second copy — which is how you keep a save-status or connection toast to
+     * one card however often the event fires.
+     */
+    id?: string;
+    /** A single button inside the toast: `{ label: "Undo", onClick: undo }`. */
+    action?: ToastActionOptions;
+    /** Called when the toast closes, however it was closed. */
+    onClose?: () => void;
+    /** Called once the toast has finished animating out and left the DOM. */
+    onRemove?: () => void;
+    /** Custom data. `icon` and `dismissible` are read by `Toast.Item`. */
+    data?: ToastData;
+    /**
+     * Replaces the type's default glyph. `false` removes it. Shorthand for
+     * `data.icon`.
+     */
+    icon?: React.ReactNode | false;
+    /**
+     * Whether the close button renders. Shorthand for `data.dismissible`.
+     * @default true
+     */
+    dismissible?: boolean;
+}
+/**
+ * What the shorthand methods accept: a message, or the full options object.
+ *
+ * `toast.success("Saved")` and `toast.success({ title: "Saved" })` are the
+ * same call — a bare message becomes the `title`, because that is the field
+ * that gets announced and the one that carries the meaning.
+ */
+export type ToastMessage = React.ReactNode | ToastOptions;
+/**
+ * The value `show()` and the named methods return.
+ *
+ * An object rather than a bare `hide` function, because dismissing is only one
+ * of the three things you want to do with a toast you have just raised: the id
+ * is what identifies it across a reload or in a map, and `update` is what
+ * turns "Uploading…" into "Uploaded" without a second card appearing.
+ */
+export interface ToastHandle {
+    /** The toast's id, generated unless `options.id` was given. */
+    readonly id: string;
+    /** Closes this toast. Safe to call after it has already gone. */
+    close: () => void;
+    /**
+     * Rewrites this toast in place. Only the fields you pass change, and the
+     * toast keeps its position in the stack — so "Uploading…" becomes "Uploaded"
+     * without a second card appearing.
+     *
+     * Each field you pass REPLACES the old one; nothing is merged, `data`
+     * included. Restate `icon` or `dismissible` if the updated toast should keep
+     * them.
+     *
+     * The running timer is left alone unless the update changes `timeout`, or
+     * resolves a `loading` toast into a type that auto-dismisses.
+     */
+    update: (message: ToastMessage, options?: ToastOptions) => void;
+}
+/** How `promise()` describes each of the three states. */
+export interface ToastPromiseOptions<Value> {
+    /** Shown immediately, and never auto-dismissed. */
+    loading: ToastMessage;
+    /** Replaces it when the promise resolves. */
+    success: ToastMessage | ((value: Value) => ToastMessage);
+    /** Replaces it when the promise rejects. */
+    error: ToastMessage | ((error: unknown) => ToastMessage);
+}
+/**
+ * The toast API — what `useToast()` returns, and what `Toast.createManager()`
+ * gives you outside React.
+ */
+export interface ToastApi {
+    /** Shows a toast of any type. `type` decides the glyph and the accent. */
+    show: (message: ToastMessage, options?: ToastOptions) => ToastHandle;
+    /** Shows a `success` toast. */
+    success: (message: ToastMessage, options?: ToastOptions) => ToastHandle;
+    /** Shows an `error` toast. */
+    error: (message: ToastMessage, options?: ToastOptions) => ToastHandle;
+    /** Shows a `warning` toast. */
+    warning: (message: ToastMessage, options?: ToastOptions) => ToastHandle;
+    /** Shows an `info` toast. */
+    info: (message: ToastMessage, options?: ToastOptions) => ToastHandle;
+    /** Shows a `loading` toast. It never auto-dismisses. */
+    loading: (message: ToastMessage, options?: ToastOptions) => ToastHandle;
+    /**
+     * Raises a loading toast and swaps it for a success or error one when the
+     * promise settles. Returns the promise, with the rejection intact — so this
+     * is a pass-through you can `await` and still `catch`.
+     */
+    promise: <Value>(promise: Promise<Value>, options: ToastPromiseOptions<Value>) => Promise<Value>;
+    /** Rewrites a toast in place by id. */
+    update: (id: string, message: ToastMessage, options?: ToastOptions) => void;
+    /** Closes one toast, or every toast when called with no argument. */
+    close: (id?: string) => void;
+}
+/** A manager created with `Toast.createManager()`. */
+export interface ToastManager extends ToastApi {
+    /**
+     * The Base UI manager underneath. Pass it to `Toast.Provider`'s
+     * `toastManager` prop — that is what connects the two.
+     */
+    readonly base: BaseToastManager<ToastData>;
+}
+/** What `useToast()` returns: the API, plus the live list of toasts. */
+export interface UseToastReturn extends ToastApi {
+    /**
+     * Every toast currently in the store, newest first, including the ones
+     * animating out. Read it to render your own stack, or to show a count.
+     */
+    toasts: ToastObject[];
+}
+/**
+ * Raises toasts from inside a component.
+ *
+ * ```tsx
+ * const toast = useToast();
+ *
+ * toast.success("Profile saved");
+ * toast.error("Could not save", { description: "Check your connection." });
+ *
+ * const { close } = toast.info("Uploading…", { timeout: 0 });
+ * ```
+ *
+ * Must be called under a `Toast.Provider`.
+ *
+ * Every method on it keeps the same identity for the life of the provider, so
+ * one pulled out by destructuring is safe in a dependency array. The object
+ * itself is rebuilt whenever `toasts` changes, since that is the only way a
+ * live list can be live — destructure what you need rather than depending on
+ * the whole thing.
+ */
+export declare function useToast(): UseToastReturn;
+/**
+ * Creates a toast manager that works outside React.
+ *
+ * ```ts
+ * // toaster.ts
+ * export const toaster = Toast.createManager();
+ *
+ * // anywhere — an API client, a store, an event handler
+ * toaster.error("Request failed");
+ *
+ * // app root
+ * <Toast.Provider toastManager={toaster.base}>…</Toast.Provider>
+ * ```
+ *
+ * Same methods as `useToast()`, minus `toasts` — a plain object has nothing to
+ * re-render when the list changes, so reading it there would hand back a
+ * snapshot that is already stale. Use the hook when you need the list.
+ *
+ * A manager delivers to a MOUNTED provider and nowhere else: the provider
+ * subscribes in an effect, and a call made before that runs — at module load,
+ * during the first server render — is dropped rather than queued. Raise toasts
+ * from events, which is where they belong anyway.
+ */
+export declare function createToastManager(): ToastManager;
+export interface ToastViewportProps extends Omit<React.ComponentPropsWithoutRef<"div">, "className" | "children"> {
+    /**
+     * Which corner or edge the stack sits at. `start` and `end` are the inline
+     * edges, so `bottom-end` is bottom-right in LTR and bottom-left in RTL.
+     * @default "bottom-end"
+     */
+    position?: ToastPosition;
+    /**
+     * An element to render the stack into instead of `<body>`.
+     *
+     * Setting it also switches the viewport from `position: fixed` to
+     * `position: absolute`, so the stack pins to the container rather than to
+     * the screen — give that container `position: relative`. There is no
+     * separate prop for that, because a contained viewport that stayed fixed
+     * would be a silent bug: the toasts would sit in the screen corner while
+     * the container they were scoped to sat somewhere else entirely.
+     *
+     * The usual reason to reach for it is a preview or an embedded surface that
+     * has its own theme scope — a portal to `<body>` escapes the scope, and the
+     * toasts come out in the page's colours.
+     */
+    container?: BaseToastPortalProps["container"];
+    /**
+     * Which way a toast may be flicked away. Defaults to the direction away from
+     * the viewport's own edge plus both inline directions; pass `[]` to turn
+     * swipe-to-dismiss off.
+     */
+    swipeDirection?: ToastSwipeDirection | ToastSwipeDirection[];
+    /**
+     * Renders one toast. Return a `Toast.Item` — it is what carries the stacking
+     * geometry and the swipe gesture.
+     *
+     * ```tsx
+     * renderToast={(toast) => (
+     *   <Toast.Item toast={toast}>
+     *     <Toast.Icon />
+     *     <Toast.Title />
+     *     <Toast.Close />
+     *   </Toast.Item>
+     * )}
+     * ```
+     *
+     * Defaults to `<Toast.Item toast={toast} />`, which supplies the standard
+     * layout from the toast's own fields.
+     */
+    renderToast?: (toast: ToastObject) => React.ReactNode;
+    /**
+     * Additional class name(s). Applied after the internal styles so consumer
+     * utilities (e.g. Tailwind) win without needing `!important`.
+     */
+    className?: string;
+}
+/**
+ * The stack itself: Base UI's `Portal` → `Viewport`, plus the loop over the
+ * toasts. Collapsing the three keeps the common case to one element, the way
+ * `Dialog.Popup` collapses its four.
+ *
+ * `Toast.Provider` renders one of these for you. Render it yourself only when
+ * it has to go somewhere specific — inside a `container`, or after some other
+ * portalled chrome — and pass `viewport={false}` to the provider so there is
+ * not a second one.
+ */
+export declare const ToastViewport: React.ForwardRefExoticComponent<ToastViewportProps & React.RefAttributes<HTMLDivElement>>;
+export interface ToastProviderProps extends ToastViewportProps {
+    /** The app. */
+    children?: React.ReactNode;
+    /**
+     * How long a toast stays on screen by default, in milliseconds. `0` keeps
+     * every toast until it is closed. A toast can override it with its own
+     * `timeout`.
+     * @default 5000
+     */
+    timeout?: number;
+    /**
+     * How many toasts are visible at once. The rest stay in the store and take
+     * their turn as the front ones are dismissed, so nothing is lost — they are
+     * marked `data-limited` and hidden rather than dropped.
+     * @default 3
+     */
+    limit?: number;
+    /**
+     * A manager from `Toast.createManager()`, for raising toasts outside React.
+     * Pass the manager's `base`.
+     */
+    toastManager?: BaseToastManager;
+    /**
+     * Whether to render the stack. Turn it off when you are placing
+     * `Toast.Viewport` yourself.
+     * @default true
+     */
+    viewport?: boolean;
+}
+/**
+ * Owns every toast below it, and renders the stack.
+ *
+ * Mount it once, near the root of the app:
+ *
+ * ```tsx
+ * <Toast.Provider position="bottom-end" timeout={5000}>
+ *   <App />
+ * </Toast.Provider>
+ * ```
+ *
+ * The viewport comes with it deliberately. Base UI keeps the two apart, which
+ * is the right primitive but the wrong default here: a provider without a
+ * viewport swallows every toast silently — the calls succeed, the store fills
+ * up, and nothing is ever drawn. Rendering it here means the failure cannot
+ * happen, and `viewport={false}` is one prop away when you need to place it
+ * yourself.
+ *
+ * Renders no DOM element of its own; the stack is portalled.
+ */
+export declare function ToastProvider({ children, timeout, limit, toastManager, viewport, ...viewportProps }: ToastProviderProps): React.JSX.Element;
+export interface ToastItemProps extends Omit<BaseToastRootProps, "className" | "toast"> {
+    /** The toast to render — the object a `renderToast` callback receives. */
+    toast: ToastObject;
+    /**
+     * Which way this toast may be flicked away. Inherited from the viewport;
+     * set it here to override one toast, or pass `[]` to pin it in place.
+     */
+    swipeDirection?: ToastSwipeDirection | ToastSwipeDirection[];
+    /**
+     * The toast's contents. Omit it for the standard layout — icon, title,
+     * description, action, close — assembled from the toast's own fields.
+     *
+     * Passing children replaces that layout entirely. Compose it from the parts
+     * (`Toast.Icon`, `Toast.Title`, `Toast.Description`, `Toast.Action`,
+     * `Toast.Close`), each of which defaults its content from the toast, so a
+     * custom arrangement does not mean restating the text.
+     */
+    children?: React.ReactNode;
+    /**
+     * Additional class name(s). Applied after the internal styles so consumer
+     * utilities (e.g. Tailwind) win without needing `!important`.
+     */
+    className?: string;
+}
+/**
+ * One toast: Base UI's `Root` wrapping its `Content`.
+ *
+ * `Root` carries the stacking geometry, the swipe gesture and the focus
+ * handling; `Content` is what fades when the toast is behind another one, and
+ * is why the two are separate elements rather than one.
+ */
+export declare const ToastItem: React.ForwardRefExoticComponent<Omit<ToastItemProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export interface ToastIconProps extends Omit<React.ComponentPropsWithoutRef<"span">, "className" | "children"> {
+    /**
+     * The glyph to draw. Defaults to `data.icon` if the toast carries one, and
+     * otherwise to the standard glyph for its `type`.
+     */
+    children?: React.ReactNode;
+    /**
+     * Additional class name(s). Applied after the internal styles so consumer
+     * utilities (e.g. Tailwind) win without needing `!important`.
+     */
+    className?: string;
+}
+/**
+ * The status glyph, coloured by the toast's type.
+ *
+ * A `loading` toast gets a `Spinner` instead of a static glyph. The spinner is
+ * a child of the toast root rather than the root itself, which is load-bearing
+ * — Base UI waits on `root.getAnimations()` before removing a dismissed toast,
+ * and an infinite animation's promise never settles, so a spinning root would
+ * stay in the DOM for the lifetime of the page. `getAnimations()` is not
+ * called with `subtree: true`, so a descendant is safe.
+ *
+ * Renders nothing when there is no glyph to draw, so the icon column collapses
+ * on a typeless toast rather than leaving a gap where an icon would be.
+ */
+export declare const ToastIcon: React.ForwardRefExoticComponent<ToastIconProps & React.RefAttributes<HTMLSpanElement>>;
+export interface ToastTitleProps extends Omit<BaseToastTitleProps, "className"> {
+    /**
+     * Additional class name(s). Applied after the internal styles so consumer
+     * utilities (e.g. Tailwind) win without needing `!important`.
+     */
+    className?: string;
+}
+/**
+ * The toast's headline, and its accessible name.
+ *
+ * Renders an `<h2>` whose text defaults to the toast's `title`. Renders
+ * nothing at all when there is no title, so a description-only toast does not
+ * carry an empty heading.
+ */
+export declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastTitleProps, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+export interface ToastDescriptionProps extends Omit<BaseToastDescriptionProps, "className"> {
+    /**
+     * Additional class name(s). Applied after the internal styles so consumer
+     * utilities (e.g. Tailwind) win without needing `!important`.
+     */
+    className?: string;
+}
+/**
+ * The second line, and the toast's accessible description.
+ *
+ * Renders a `<p>` whose text defaults to the toast's `description`, and
+ * renders nothing when there is none.
+ */
+export declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastDescriptionProps, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export interface ToastActionProps extends Omit<BaseToastActionProps, "className"> {
+    /**
+     * Additional class name(s). Applied after the internal styles so consumer
+     * utilities (e.g. Tailwind) win without needing `!important`.
+     */
+    className?: string;
+}
+/**
+ * The toast's action button.
+ *
+ * Renders a `<button>` whose label and `onClick` default to the toast's
+ * `action`, and renders nothing when the toast has none — so the default
+ * layout can include it unconditionally.
+ *
+ * Clicking it does not close the toast. That is deliberate: an action that
+ * fails should be able to say so, and closing is one `handle.close()` away
+ * inside the handler.
+ */
+export declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastActionProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export interface ToastCloseProps extends Omit<BaseToastCloseProps, "className"> {
+    /**
+     * Additional class name(s). Applied after the internal styles so consumer
+     * utilities (e.g. Tailwind) win without needing `!important`.
+     */
+    className?: string;
+}
+/**
+ * The button that dismisses the toast.
+ *
+ * Renders a `<button>` with a "×" and an `aria-label` of "Close", both
+ * overridable through `children` and `aria-label`. Base UI hides it from
+ * assistive technology while the stack is collapsed and reveals it once the
+ * viewport is hovered or focused, so it is announced exactly when it is
+ * reachable.
+ */
+export declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastCloseProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Transient messages, built on Base UI's `Toast`.
+ *
+ * ```tsx
+ * // once, at the root
+ * <Toast.Provider position="bottom-end">
+ *   <App />
+ * </Toast.Provider>
+ *
+ * // anywhere below it
+ * const toast = useToast();
+ * toast.success("Profile saved");
+ * ```
+ *
+ * Two things are worth knowing before reaching for one.
+ *
+ * **A toast is not a place for anything the user must not miss.** It is
+ * announced once and then it is gone; it cannot be scrolled back to, and on a
+ * phone it may be covered by the keyboard. An error the user has to act on
+ * belongs next to the thing that failed.
+ *
+ * **Timers pause while the stack is hovered, focused, or the window is in the
+ * background,** so a toast raised while the user was in another tab is still
+ * there when they come back.
+ *
+ * Styling is driven by `data-*` attributes and `--forte-toast-*` custom
+ * properties, so it can be re-skinned from plain CSS or targeted with Tailwind
+ * arbitrary variants (`data-[type=error]:...`) without wrapping anything.
+ */
+export declare const Toast: {
+    Provider: typeof ToastProvider;
+    Viewport: React.ForwardRefExoticComponent<ToastViewportProps & React.RefAttributes<HTMLDivElement>>;
+    Item: React.ForwardRefExoticComponent<Omit<ToastItemProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Icon: React.ForwardRefExoticComponent<ToastIconProps & React.RefAttributes<HTMLSpanElement>>;
+    Title: React.ForwardRefExoticComponent<Omit<ToastTitleProps, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+    Description: React.ForwardRefExoticComponent<Omit<ToastDescriptionProps, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+    Action: React.ForwardRefExoticComponent<Omit<ToastActionProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    Close: React.ForwardRefExoticComponent<Omit<ToastCloseProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    /** Creates a manager for raising toasts outside React. */
+    createManager: typeof createToastManager;
+};

package/dist/components/toast/Toast.js

@@ -0,0 +1,3 @@
+"use client";
+import { a as e, c as t, d as n, i as r, l as i, n as a, o, r as s, s as c, t as l, u } from "../../Toast-BWayxAcd.js";
+export { l as Toast, a as ToastAction, s as ToastClose, r as ToastDescription, e as ToastIcon, o as ToastItem, c as ToastProvider, t as ToastTitle, i as ToastViewport, u as createToastManager, n as useToast };

package/dist/components/toast/index.d.ts

@@ -0,0 +1,2 @@
+export { Toast, useToast } from './Toast';
+export type { ToastType, ToastPosition, ToastSwipeDirection, ToastData, ToastObject, ToastActionOptions, ToastOptions, ToastMessage, ToastHandle, ToastPromiseOptions, ToastApi, ToastManager, UseToastReturn, ToastProviderProps, ToastViewportProps, ToastItemProps, ToastIconProps, ToastTitleProps, ToastDescriptionProps, ToastActionProps, ToastCloseProps, } from './Toast';

package/dist/components/toast/index.js

@@ -0,0 +1,2 @@
+import { d as e, t } from "../../Toast-BWayxAcd.js";
+export { t as Toast, e as useToast };