solid-baseui 0.1.0-alpha.0

package/dist/lib/types/tabs/root/TabsRootContext.d.ts

@@ -0,0 +1,43 @@
+import { type Accessor } from 'solid-js';
+import type { TabsRootChangeEventDetails, TabsRootState } from './TabsRoot.js';
+import type { TabsTabValue } from '../tab/TabsTab.js';
+export interface TabsTabRegistration {
+    token: symbol;
+    order: number;
+    element: Accessor<HTMLElement | undefined>;
+    id: Accessor<string>;
+    value: Accessor<TabsTabValue>;
+    disabled: Accessor<boolean>;
+}
+export interface TabsPanelRegistration {
+    token: symbol;
+    order: number;
+    element: Accessor<HTMLElement | undefined>;
+    id: Accessor<string>;
+    value: Accessor<TabsTabValue>;
+    rendered: Accessor<boolean>;
+}
+export interface TabsRootContextValue {
+    value: Accessor<TabsTabValue>;
+    orientation: Accessor<'horizontal' | 'vertical'>;
+    tabActivationDirection: Accessor<'left' | 'right' | 'up' | 'down' | 'none'>;
+    state: Accessor<TabsRootState>;
+    tabsVersion: Accessor<number>;
+    panelsVersion: Accessor<number>;
+    getOrderedTabs: () => TabsTabRegistration[];
+    getTabIndex: (registration: TabsTabRegistration) => number;
+    getPanelIndex: (registration: TabsPanelRegistration) => number;
+    getTabElementBySelectedValue: (value: TabsTabValue) => HTMLElement | undefined;
+    getTabIdByPanelValue: (value: TabsTabValue) => string | undefined;
+    getTabPanelIdByValue: (value: TabsTabValue) => string | undefined;
+    claimPanel: (registration: TabsPanelRegistration) => void;
+    notifyTabChange: () => void;
+    notifyPanelChange: () => void;
+    onValueChange: (value: TabsTabValue, details: TabsRootChangeEventDetails) => boolean;
+    registerTab: (registration: TabsTabRegistration) => () => void;
+    registerPanel: (registration: TabsPanelRegistration) => () => void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const TabsRootContext: import("solid-js").Context<TabsRootContextValue | typeof MISSING_CONTEXT>;
+export declare function useTabsRootContext(): TabsRootContextValue;
+export {};

package/dist/lib/types/tabs/root/TabsRootDataAttributes.d.ts

@@ -0,0 +1,4 @@
+export declare enum TabsRootDataAttributes {
+    orientation = "data-orientation",
+    activationDirection = "data-activation-direction"
+}

package/dist/lib/types/tabs/root/stateAttributesMapping.d.ts

@@ -0,0 +1,8 @@
+export declare const tabsStateAttributesMapping: {
+    orientation: (value: import("../../index.js").Orientation) => {
+        "data-orientation": import("../../index.js").Orientation;
+    };
+    tabActivationDirection: (value: import("../index.js").TabsTabActivationDirection) => {
+        "data-activation-direction": import("../index.js").TabsTabActivationDirection;
+    };
+};

package/dist/lib/types/tabs/tab/TabsTab.d.ts

@@ -0,0 +1,59 @@
+import { type ComponentProps, type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { TabsRootOrientation } from '../root/TabsRoot.js';
+export type TabsTabValue = any | null;
+export type TabsTabActivationDirection = 'left' | 'right' | 'up' | 'down' | 'none';
+export interface TabsTabPosition {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+export interface TabsTabSize {
+    width: number;
+    height: number;
+}
+export interface TabsTabMetadata {
+    disabled: boolean;
+    id: string | undefined;
+    value: TabsTabValue | undefined;
+}
+export interface TabsTabState {
+    /** Whether the tab ignores activation. */
+    disabled: boolean;
+    /** Whether the tab is currently selected. */
+    active: boolean;
+    /** The component orientation. */
+    orientation: TabsRootOrientation;
+    /** The physical direction of the latest committed activation. */
+    tabActivationDirection: TabsTabActivationDirection;
+}
+type TabsTabEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onClick?: JSX.EventHandlerUnion<infer Target, MouseEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface TabsTabOwnProps<Component extends ValidComponent> {
+    /** The value represented by this tab. */
+    value: TabsTabValue;
+    /** Whether the tab ignores activation while remaining focusable. */
+    disabled?: boolean | undefined;
+    /** Whether the rendered root has native button semantics. @default true */
+    nativeButton?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<TabsTabEventTarget<Component>, MouseEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<TabsTabEventTarget<Component>, FocusEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<TabsTabEventTarget<Component>, KeyboardEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<TabsTabEventTarget<Component>, PointerEvent> | undefined;
+}
+export type TabsTabProps<Component extends ValidComponent = 'button'> = BaseUIComponentProps<Component, TabsTabState, TabsTabOwnProps<Component>>;
+/** An interactive tab that selects its matching panel. */
+export declare function TabsTab<Component extends ValidComponent = 'button'>(props: TabsTab.Props<Component>): JSX.Element;
+export declare namespace TabsTab {
+    type Value = TabsTabValue;
+    type ActivationDirection = TabsTabActivationDirection;
+    type Position = TabsTabPosition;
+    type Size = TabsTabSize;
+    type Metadata = TabsTabMetadata;
+    type State = TabsTabState;
+    type Props<Component extends ValidComponent = 'button'> = TabsTabProps<Component>;
+}
+export {};

package/dist/lib/types/tabs/tab/TabsTabDataAttributes.d.ts

@@ -0,0 +1,6 @@
+export declare enum TabsTabDataAttributes {
+    orientation = "data-orientation",
+    activationDirection = "data-activation-direction",
+    active = "data-active",
+    disabled = "data-disabled"
+}

package/dist/lib/types/toast/action/ToastAction.d.ts

@@ -0,0 +1,30 @@
+import { type ComponentProps, type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ToastActionState {
+    /** The type of the toast. */
+    type: string | undefined;
+}
+type ActionEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onClick?: JSX.EventHandlerUnion<infer Target, MouseEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface ToastActionOwnProps<Component extends ValidComponent> {
+    disabled?: boolean | undefined;
+    nativeButton?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<ActionEventTarget<Component>, MouseEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<ActionEventTarget<Component>, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<ActionEventTarget<Component>, KeyboardEvent> | undefined;
+    onMouseDown?: BaseUIEventHandlerUnion<ActionEventTarget<Component>, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<ActionEventTarget<Component>, PointerEvent> | undefined;
+}
+export type ToastActionProps<Component extends ValidComponent = 'button'> = BaseUIComponentProps<Component, ToastActionState, ToastActionOwnProps<Component>>;
+/**
+ * Performs an action when clicked. Renders nothing when neither the toast nor the part supplies
+ * action content.
+ */
+export declare function ToastAction<Component extends ValidComponent = 'button'>(props: ToastAction.Props<Component>): JSX.Element;
+export declare namespace ToastAction {
+    type State = ToastActionState;
+    type Props<Component extends ValidComponent = 'button'> = ToastActionProps<Component>;
+}
+export {};

package/dist/lib/types/toast/arrow/ToastArrow.d.ts

@@ -0,0 +1,18 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { AnchorAlign, AnchorSide } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ToastArrowState {
+    /** The side of the anchor the component is placed on. */
+    side: AnchorSide;
+    /** The alignment of the component relative to the anchor. */
+    align: AnchorAlign;
+    /** Whether the arrow cannot be centered on the anchor. */
+    uncentered: boolean;
+}
+export type ToastArrowProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ToastArrowState>;
+/** Displays an element positioned against the toast anchor. */
+export declare function ToastArrow<Component extends ValidComponent = 'div'>(props: ToastArrow.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ToastArrow {
+    type State = ToastArrowState;
+    type Props<Component extends ValidComponent = 'div'> = ToastArrowProps<Component>;
+}

package/dist/lib/types/toast/close/ToastClose.d.ts

@@ -0,0 +1,29 @@
+import { type ComponentProps, type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ToastCloseState {
+    /** The type of the toast. */
+    type: string | undefined;
+}
+type CloseEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onClick?: JSX.EventHandlerUnion<infer Target, MouseEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface ToastCloseOwnProps<Component extends ValidComponent> {
+    disabled?: boolean | undefined;
+    nativeButton?: boolean | undefined;
+    onBlur?: BaseUIEventHandlerUnion<CloseEventTarget<Component>, FocusEvent> | undefined;
+    onClick?: BaseUIEventHandlerUnion<CloseEventTarget<Component>, MouseEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<CloseEventTarget<Component>, FocusEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<CloseEventTarget<Component>, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<CloseEventTarget<Component>, KeyboardEvent> | undefined;
+    onMouseDown?: BaseUIEventHandlerUnion<CloseEventTarget<Component>, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<CloseEventTarget<Component>, PointerEvent> | undefined;
+}
+export type ToastCloseProps<Component extends ValidComponent = 'button'> = BaseUIComponentProps<Component, ToastCloseState, ToastCloseOwnProps<Component>>;
+/** Closes the toast when clicked. */
+export declare function ToastClose<Component extends ValidComponent = 'button'>(props: ToastClose.Props<Component>): JSX.Element;
+export declare namespace ToastClose {
+    type State = ToastCloseState;
+    type Props<Component extends ValidComponent = 'button'> = ToastCloseProps<Component>;
+}
+export {};

package/dist/lib/types/toast/content/ToastContent.d.ts

@@ -0,0 +1,15 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ToastContentState {
+    /** Whether the toast viewport is expanded. */
+    expanded: boolean;
+    /** Whether the toast is behind the frontmost toast in the stack. */
+    behind: boolean;
+}
+export type ToastContentProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ToastContentState>;
+/** A container for the contents of a toast. Its size drives the measured toast height. */
+export declare function ToastContent<Component extends ValidComponent = 'div'>(props: ToastContent.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ToastContent {
+    type State = ToastContentState;
+    type Props<Component extends ValidComponent = 'div'> = ToastContentProps<Component>;
+}

package/dist/lib/types/toast/createToastManager.d.ts

@@ -0,0 +1,15 @@
+import type { ToastManagerAddOptions, ToastManagerPromiseOptions, ToastManagerUpdateOptions } from './types.js';
+export interface ToastManagerEvent {
+    action: 'add' | 'close' | 'update' | 'promise';
+    options: any;
+}
+export interface ToastManager<Data extends object = any> {
+    /** Private; only `Toast.Provider` subscribes to a manager. */
+    ' subscribe': (listener: (data: ToastManagerEvent) => void) => () => void;
+    add: <T extends Data = Data>(options: ToastManagerAddOptions<T>) => string;
+    close: (id?: string) => void;
+    update: <T extends Data = Data>(id: string, updates: ToastManagerUpdateOptions<T>) => void;
+    promise: <Value, T extends Data = Data>(promiseValue: Promise<Value>, options: ToastManagerPromiseOptions<Value, T>) => Promise<Value>;
+}
+/** Creates a toast manager usable outside of a component. */
+export declare function createToastManager<Data extends object = any>(): ToastManager<Data>;

package/dist/lib/types/toast/description/ToastDescription.d.ts

@@ -0,0 +1,16 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ToastDescriptionState {
+    /** The type of the toast. */
+    type: string | undefined;
+}
+export type ToastDescriptionProps<Component extends ValidComponent = 'p'> = BaseUIComponentProps<Component, ToastDescriptionState>;
+/**
+ * A description that describes the toast. Can be used as the default message for the toast when
+ * no title is provided. Renders nothing when it has no content.
+ */
+export declare function ToastDescription<Component extends ValidComponent = 'p'>(props: ToastDescription.Props<Component>): JSX.Element;
+export declare namespace ToastDescription {
+    type State = ToastDescriptionState;
+    type Props<Component extends ValidComponent = 'p'> = ToastDescriptionProps<Component>;
+}

package/dist/lib/types/toast/index.d.ts

@@ -0,0 +1,17 @@
+export * as Toast from './index.parts.js';
+export type * from './types.js';
+export type * from './root/ToastRoot.js';
+export type * from './provider/ToastProvider.js';
+export type * from './viewport/ToastViewport.js';
+export type * from './content/ToastContent.js';
+export type * from './description/ToastDescription.js';
+export type * from './title/ToastTitle.js';
+export type * from './close/ToastClose.js';
+export type * from './action/ToastAction.js';
+export type * from './portal/ToastPortal.js';
+export type * from './positioner/ToastPositioner.js';
+export type * from './arrow/ToastArrow.js';
+export type * from './useToastManager.js';
+export type * from './createToastManager.js';
+export { useToastManager } from './useToastManager.js';
+export { createToastManager } from './createToastManager.js';

package/dist/lib/types/toast/index.parts.d.ts

@@ -0,0 +1,11 @@
+export { ToastProvider as Provider } from './provider/ToastProvider.js';
+export { ToastViewport as Viewport } from './viewport/ToastViewport.js';
+export { ToastRoot as Root } from './root/ToastRoot.js';
+export { ToastContent as Content } from './content/ToastContent.js';
+export { ToastDescription as Description } from './description/ToastDescription.js';
+export { ToastTitle as Title } from './title/ToastTitle.js';
+export { ToastClose as Close } from './close/ToastClose.js';
+export { ToastAction as Action } from './action/ToastAction.js';
+export { ToastPortal as Portal } from './portal/ToastPortal.js';
+export { ToastPositioner as Positioner } from './positioner/ToastPositioner.js';
+export { ToastArrow as Arrow } from './arrow/ToastArrow.js';

package/dist/lib/types/toast/portal/ToastPortal.d.ts

@@ -0,0 +1,20 @@
+import type { JSX, ValidComponent } from '@solidjs/web';
+import { type PopupPortalContainer } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ToastPortalState {
+}
+interface ToastPortalOwnProps {
+    /** A parent element to render the portal element into. */
+    container?: PopupPortalContainer | undefined;
+}
+export type ToastPortalProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ToastPortalState, ToastPortalOwnProps>;
+/**
+ * A portal element that moves the viewport to a different part of the DOM. By default, the
+ * portal element is appended to `<body>`.
+ */
+export declare function ToastPortal<Component extends ValidComponent = 'div'>(props: ToastPortal.Props<Component>): JSX.Element;
+export declare namespace ToastPortal {
+    type State = ToastPortalState;
+    type Props<Component extends ValidComponent = 'div'> = ToastPortalProps<Component>;
+}
+export {};

package/dist/lib/types/toast/positioner/ToastPositioner.d.ts

@@ -0,0 +1,42 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { Strategy } from '@floating-ui/dom';
+import { type AnchorAlign, type AnchorBoundary, type AnchorSide, type CollisionAvoidance, type OffsetFunction } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { ToastObject } from '../types.js';
+export interface ToastPositionerState {
+    /** The side of the anchor the component is placed on. */
+    side: AnchorSide;
+    /** The alignment of the component relative to the anchor. */
+    align: AnchorAlign;
+    /** Whether the anchor element is hidden. */
+    anchorHidden: boolean;
+}
+export interface ToastPositionerOwnProps {
+    /** An element to position the toast against. */
+    anchor?: Element | null | undefined;
+    positionMethod?: Strategy | undefined;
+    /**
+     * Which side of the anchor element to align the toast against.
+     * May automatically change to avoid collisions.
+     * @default 'top'
+     */
+    side?: AnchorSide | undefined;
+    sideOffset?: number | OffsetFunction | undefined;
+    align?: AnchorAlign | undefined;
+    alignOffset?: number | OffsetFunction | undefined;
+    collisionBoundary?: AnchorBoundary | undefined;
+    collisionPadding?: number | Partial<Record<'top' | 'right' | 'bottom' | 'left', number>> | undefined;
+    arrowPadding?: number | undefined;
+    sticky?: boolean | undefined;
+    disableAnchorTracking?: boolean | undefined;
+    collisionAvoidance?: CollisionAvoidance | undefined;
+    /** The toast object associated with the positioner. */
+    toast: ToastObject<any>;
+}
+export type ToastPositionerProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ToastPositionerState, ToastPositionerOwnProps>;
+/** Positions the toast against the anchor. */
+export declare function ToastPositioner<Component extends ValidComponent = 'div'>(props: ToastPositioner.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ToastPositioner {
+    type State = ToastPositionerState;
+    type Props<Component extends ValidComponent = 'div'> = ToastPositionerProps<Component>;
+}

package/dist/lib/types/toast/positioner/ToastPositionerContext.d.ts

@@ -0,0 +1,6 @@
+import type { AnchorPositioning } from '../../internals/overlay/createAnchorPositioning.js';
+export type ToastPositionerContextValue = Pick<AnchorPositioning, 'renderedSide' | 'renderedAlign' | 'arrowUncentered' | 'arrowStyles' | 'setArrowElement'>;
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ToastPositionerContext: import("solid-js").Context<ToastPositionerContextValue | typeof MISSING_CONTEXT>;
+export declare function useToastPositionerContext(): ToastPositionerContextValue;
+export {};

package/dist/lib/types/toast/provider/ToastProvider.d.ts

@@ -0,0 +1,28 @@
+import type { JSX } from '@solidjs/web';
+import type { ToastManager } from '../createToastManager.js';
+export interface ToastProviderState {
+}
+export interface ToastProviderProps {
+    children?: JSX.Element;
+    /**
+     * The default amount of time (in ms) before a toast is auto dismissed.
+     * A value of `0` will prevent the toast from being dismissed automatically.
+     * @default 5000
+     */
+    timeout?: number | undefined;
+    /**
+     * The maximum number of toasts that can be displayed at once.
+     * When the limit is exceeded, the oldest toasts are marked as `limited` (via the
+     * `data-limited` attribute) rather than removed, so they can be hidden or animated out.
+     * @default 3
+     */
+    limit?: number | undefined;
+    /** A global manager for toasts to use outside of a Solid component. */
+    toastManager?: ToastManager | undefined;
+}
+/** Provides a context for creating and managing toasts. */
+export declare function ToastProvider(props: ToastProvider.Props): JSX.Element;
+export declare namespace ToastProvider {
+    type State = ToastProviderState;
+    type Props = ToastProviderProps;
+}

package/dist/lib/types/toast/provider/ToastProviderContext.d.ts

@@ -0,0 +1,5 @@
+import type { ToastStore } from '../store/ToastStore.js';
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ToastProviderContext: import("solid-js").Context<typeof MISSING_CONTEXT | ToastStore>;
+export declare function useToastProviderContext(): ToastStore;
+export {};

package/dist/lib/types/toast/root/ToastRoot.d.ts

@@ -0,0 +1,39 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type StateAttributesMapping } from '../../internals/getStateAttributesProps.js';
+import { type SwipeDirection } from '../../internals/overlay/createSwipeDismiss.js';
+import { type TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { ToastObject } from '../types.js';
+export declare const toastRootStateAttributesMapping: StateAttributesMapping<ToastRootState>;
+export interface ToastRootState {
+    /** The transition status of the component. */
+    transitionStatus: TransitionStatus;
+    /** Whether the toasts in the viewport are expanded. */
+    expanded: boolean;
+    /** Whether the toast was limited because the toast limit was exceeded. */
+    limited: boolean;
+    /** The type of the toast. */
+    type: string | undefined;
+    /** Whether the toast is being swiped. */
+    swiping: boolean;
+    /** The direction the toast is being swiped. */
+    swipeDirection: SwipeDirection | undefined;
+}
+interface ToastRootOwnProps {
+    /** The toast to render. */
+    toast: ToastObject<any>;
+    /**
+     * Direction(s) in which the toast can be swiped to dismiss.
+     * @default ['down', 'right']
+     */
+    swipeDirection?: SwipeDirection | SwipeDirection[] | undefined;
+}
+export type ToastRootProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ToastRootState, ToastRootOwnProps>;
+/** Groups all parts of an individual toast. */
+export declare function ToastRoot<Component extends ValidComponent = 'div'>(props: ToastRoot.Props<Component>): JSX.Element;
+export declare namespace ToastRoot {
+    type State = ToastRootState;
+    type Props<Component extends ValidComponent = 'div'> = ToastRootProps<Component>;
+    type ToastObject<Data extends object = any> = import('../types.js').ToastObject<Data>;
+}
+export {};

package/dist/lib/types/toast/root/ToastRootContext.d.ts

@@ -0,0 +1,14 @@
+import { type Accessor, type Setter } from 'solid-js';
+import type { ToastObject } from '../types.js';
+export interface ToastRootContextValue {
+    toast: Accessor<ToastObject<any>>;
+    setTitleId: Setter<string | undefined>;
+    setDescriptionId: Setter<string | undefined>;
+    visibleIndex: Accessor<number>;
+    expanded: Accessor<boolean>;
+    recalculateHeight(flushSync?: boolean): void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ToastRootContext: import("solid-js").Context<ToastRootContextValue | typeof MISSING_CONTEXT>;
+export declare function useToastRootContext(): ToastRootContextValue;
+export {};

package/dist/lib/types/toast/store/ToastStore.d.ts

@@ -0,0 +1,60 @@
+import { ReactiveStore } from '../../internals/overlay/ReactiveStore.js';
+import type { StoredToast, ToastManagerAddOptions, ToastManagerPromiseOptions, ToastManagerUpdateOptions, ToastObject } from '../types.js';
+type ToastInternalUpdateOptions<Data extends object> = Partial<Omit<ToastObject<Data>, 'id' | 'updateKey'>>;
+export interface ToastMetadata {
+    value: StoredToast;
+    domIndex: number;
+    visibleIndex: number;
+    offsetY: number;
+}
+export interface ToastState {
+    toasts: StoredToast[];
+    toastMetadata: Map<string, ToastMetadata>;
+    hovering: boolean;
+    focused: boolean;
+    timeout: number;
+    limit: number;
+    isWindowFocused: boolean;
+    viewport: HTMLElement | null;
+    prevFocusElement: HTMLElement | null;
+}
+export type ToastInitialState = Omit<ToastState, 'toastMetadata'>;
+export declare const selectors: {
+    toasts: (state: ToastState) => StoredToast[];
+    isEmpty: (state: ToastState) => boolean;
+    toast: (state: ToastState, id: string) => StoredToast | undefined;
+    toastIndex: (state: ToastState, id: string) => number;
+    toastOffsetY: (state: ToastState, id: string) => number;
+    toastVisibleIndex: (state: ToastState, id: string) => number;
+    focused: (state: ToastState) => boolean;
+    expanded: (state: ToastState) => boolean;
+    expandedOrOutOfFocus: (state: ToastState) => boolean;
+    prevFocusElement: (state: ToastState) => HTMLElement | null;
+};
+export declare class ToastStore extends ReactiveStore<ToastState> {
+    private timers;
+    private areTimersPaused;
+    constructor(initialState: ToastInitialState);
+    setViewport: (viewport: HTMLElement | null) => void;
+    syncProviderProps(timeout: number, limit: number): void;
+    dispose: () => void;
+    removeToast(toastId: string, skipOnRemove?: boolean): void;
+    addToast: <Data extends object>(toast: ToastManagerAddOptions<Data>) => string;
+    updateToast: <Data extends object>(id: string, updates: ToastManagerUpdateOptions<Data>) => void;
+    updateToastInternal: <Data extends object>(id: string, updates: ToastInternalUpdateOptions<Data>, resetTimer?: boolean, markUpdated?: boolean) => void;
+    closeToast: (toastId?: string) => void;
+    promiseToast: <Value, Data extends object>(promiseValue: Promise<Value>, options: ToastManagerPromiseOptions<Value, Data>) => Promise<Value>;
+    pauseTimers(): void;
+    resumeTimers(): void;
+    restoreFocusToPrevElement(): void;
+    handleDocumentPointerDown: (event: PointerEvent) => void;
+    private scheduleTimer;
+    private stopTimer;
+    private clearTimers;
+    private clearTimer;
+    private handleTimerFired;
+    private resetPausedStateIfNoTimersRemain;
+    private setToasts;
+    private handleFocusManagement;
+}
+export {};

package/dist/lib/types/toast/title/ToastTitle.d.ts

@@ -0,0 +1,13 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ToastTitleState {
+    /** The type of the toast. */
+    type: string | undefined;
+}
+export type ToastTitleProps<Component extends ValidComponent = 'h2'> = BaseUIComponentProps<Component, ToastTitleState>;
+/** A title that labels the toast. Renders nothing when it has no content. */
+export declare function ToastTitle<Component extends ValidComponent = 'h2'>(props: ToastTitle.Props<Component>): JSX.Element;
+export declare namespace ToastTitle {
+    type State = ToastTitleState;
+    type Props<Component extends ValidComponent = 'h2'> = ToastTitleProps<Component>;
+}

package/dist/lib/types/toast/types.d.ts

@@ -0,0 +1,77 @@
+import type { JSX } from '@solidjs/web';
+import type { ToastPositionerOwnProps } from './positioner/ToastPositioner.js';
+/**
+ * A toast as it lives in the manager. Base UI's React `ref` object is replaced
+ * by the resolved DOM element, which is how Solid exposes refs.
+ */
+export interface ToastObject<Data extends object = any> {
+    /** The unique identifier for the toast. */
+    id: string;
+    /** The rendered `Toast.Root` element, registered by the root part. */
+    element?: HTMLElement | null | undefined;
+    /** The title of the toast. */
+    title?: JSX.Element;
+    /**
+     * The type of the toast. Used to conditionally style the toast, including
+     * conditionally rendering elements based on the type.
+     */
+    type?: string | undefined;
+    /** The description of the toast. */
+    description?: JSX.Element;
+    /**
+     * The amount of time (in ms) before the toast is auto dismissed.
+     * A value of `0` will prevent the toast from being dismissed automatically.
+     * @default 5000
+     */
+    timeout?: number | undefined;
+    /**
+     * The priority of the toast.
+     * - `low` - The toast will be announced politely.
+     * - `high` - The toast will be announced urgently.
+     * @default 'low'
+     */
+    priority?: 'low' | 'high' | undefined;
+    /** The transition status of the toast. */
+    transitionStatus?: 'starting' | 'ending' | undefined;
+    /** A counter that increments whenever the toast is updated or upserted. */
+    updateKey?: number | undefined;
+    /** Determines if the toast was limited because the toast limit was exceeded. */
+    limited?: boolean | undefined;
+    /** The height of the toast. */
+    height?: number | undefined;
+    /** Callback function to be called when the toast is closed. */
+    onClose?: (() => void) | undefined;
+    /**
+     * Callback function to be called when the toast is removed from the list after
+     * any animations are complete when closed.
+     */
+    onRemove?: (() => void) | undefined;
+    /** The props for the action button. */
+    actionProps?: JSX.ButtonHTMLAttributes<HTMLButtonElement> | undefined;
+    /** The props forwarded to the toast positioner element when rendering anchored toasts. */
+    positionerProps?: ToastManagerPositionerProps | undefined;
+    /** Custom data for the toast. */
+    data?: Data | undefined;
+}
+export interface ToastManagerPositionerProps extends Omit<ToastPositionerOwnProps, 'anchor' | 'toast'> {
+    /** An element to position the toast against. */
+    anchor?: Element | null | undefined;
+}
+export interface ToastManagerAddOptions<Data extends object = any> extends Omit<ToastObject<Data>, 'id' | 'element' | 'height' | 'limited' | 'updateKey'> {
+    /**
+     * The unique identifier for the toast. Adding a toast with an existing ID
+     * updates it in place and refreshes its auto-dismiss timer.
+     */
+    id?: string | undefined;
+}
+export interface ToastManagerUpdateOptions<Data extends object = any> extends Partial<Omit<ToastObject<Data>, 'id' | 'element' | 'height' | 'transitionStatus' | 'limited' | 'updateKey'>> {
+}
+export interface ToastManagerPromiseOptions<Value, Data extends object = any> {
+    loading: string | ToastManagerUpdateOptions<Data>;
+    success: string | ToastManagerUpdateOptions<Data> | ((result: Value) => string | ToastManagerUpdateOptions<Data>);
+    error: string | ToastManagerUpdateOptions<Data> | ((error: any) => string | ToastManagerUpdateOptions<Data>);
+}
+/** A toast once it lives in the store; `addToast` always stamps `updateKey`. */
+export type StoredToast<Data extends object = any> = ToastObject<Data> & {
+    updateKey: number;
+};

package/dist/lib/types/toast/useToastManager.d.ts

@@ -0,0 +1,11 @@
+import type { Accessor } from 'solid-js';
+import type { ToastManagerAddOptions, ToastManagerPromiseOptions, ToastManagerUpdateOptions, ToastObject } from './types.js';
+export interface UseToastManagerReturnValue<Data extends object = any> {
+    toasts: Accessor<ToastObject<Data>[]>;
+    add: <T extends Data = Data>(options: ToastManagerAddOptions<T>) => string;
+    close: (toastId?: string) => void;
+    update: <T extends Data = Data>(toastId: string, options: ToastManagerUpdateOptions<T>) => void;
+    promise: <Value, T extends Data = Data>(promiseValue: Promise<Value>, options: ToastManagerPromiseOptions<Value, T>) => Promise<Value>;
+}
+/** Returns an accessor for the toasts along with methods to manage them. */
+export declare function useToastManager<Data extends object = any>(): UseToastManagerReturnValue<Data>;

package/dist/lib/types/toast/utils/createToastLabelPart.d.ts

@@ -0,0 +1,17 @@
+import { type Accessor } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+export interface ToastLabelPart {
+    id: Accessor<string>;
+    content: Accessor<JSX.Element>;
+    shouldRender: Accessor<boolean>;
+    type: Accessor<string | undefined>;
+}
+/**
+ * Shared logic for `Toast.Title` and `Toast.Description`, which differ only by the rendered tag,
+ * the fallback content, and which id setter they register with. The part mounts only while it
+ * carries renderable content, and registers its id with the root for that time.
+ */
+export declare function createToastLabelPart(props: {
+    id?: string | undefined;
+    children?: JSX.Element;
+}, part: 'title' | 'description'): ToastLabelPart;