solid-baseui 0.1.0-alpha.0

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

@@ -0,0 +1,6 @@
+/**
+ * Whether the element is focus-visible. Environments that cannot evaluate
+ * `:focus-visible` (JSDOM) report `true` so keyboard-driven behavior stays
+ * testable, matching Base UI.
+ */
+export declare function isFocusVisible(element: Element | null): boolean;

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

@@ -0,0 +1,5 @@
+/**
+ * Generates an id for a toast created outside of a component, where Solid's
+ * `createUniqueId` has no owner to scope to.
+ */
+export declare function generateToastId(prefix?: string): string;

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

@@ -0,0 +1,6 @@
+/**
+ * Mirrors Base UI's renderable-node check for resolved Solid children: `null`,
+ * `undefined`, booleans, and the empty string render nothing, and an array is
+ * renderable when any entry is.
+ */
+export declare function isRenderableNode(node: unknown): boolean;

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

@@ -0,0 +1,2 @@
+import type { JSX } from '@solidjs/web';
+export declare function mergeToastStyles(internal: JSX.CSSProperties, external: JSX.CSSProperties | string | false | undefined): JSX.CSSProperties | string;

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

@@ -0,0 +1,2 @@
+import type { ToastManagerUpdateOptions } from '../types.js';
+export declare function resolvePromiseOptions<Value, Data extends object>(options: string | ToastManagerUpdateOptions<Data> | ((result: Value) => string | ToastManagerUpdateOptions<Data>), result?: Value): ToastManagerUpdateOptions<Data>;

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

@@ -0,0 +1,13 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ToastViewportState {
+    /** Whether toasts are expanded in the viewport. */
+    expanded: boolean;
+}
+export type ToastViewportProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ToastViewportState>;
+/** A container viewport for toasts. */
+export declare function ToastViewport<Component extends ValidComponent = 'div'>(props: ToastViewport.Props<Component>): JSX.Element;
+export declare namespace ToastViewport {
+    type State = ToastViewportState;
+    type Props<Component extends ValidComponent = 'div'> = ToastViewportProps<Component>;
+}

package/dist/lib/types/toggle/Toggle.d.ts

@@ -0,0 +1,40 @@
+import { type ComponentProps, type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../internals/composeEventHandlers.js';
+import { createChangeEventDetails } from '../internals/createBaseUIEventDetails.js';
+import { REASONS } from '../internals/reasons.js';
+import type { BaseUIComponentProps } from '../types/index.js';
+export interface ToggleState {
+    /** Whether the toggle is currently pressed. */
+    pressed: boolean;
+    /** Whether the toggle should ignore user interaction. */
+    disabled: boolean;
+}
+type ToggleEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onClick?: JSX.EventHandlerUnion<infer Target, MouseEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface ToggleOwnProps<Value extends string, Component extends ValidComponent> {
+    defaultPressed?: boolean | undefined;
+    disabled?: boolean | undefined;
+    nativeButton?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<ToggleEventTarget<Component>, MouseEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<ToggleEventTarget<Component>, FocusEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<ToggleEventTarget<Component>, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<ToggleEventTarget<Component>, KeyboardEvent> | undefined;
+    onMouseDown?: BaseUIEventHandlerUnion<ToggleEventTarget<Component>, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<ToggleEventTarget<Component>, PointerEvent> | undefined;
+    onPressedChange?: ((pressed: boolean, eventDetails: ToggleChangeEventDetails) => void) | undefined;
+    pressed?: boolean | undefined;
+    value?: Value | undefined;
+}
+export type ToggleProps<Value extends string = string, Component extends ValidComponent = 'button'> = BaseUIComponentProps<Component, ToggleState, ToggleOwnProps<Value, Component>>;
+/** A two-state button that can be on or off. */
+export declare function Toggle<Value extends string = string, Component extends ValidComponent = 'button'>(props: Toggle.Props<Value, Component>): JSX.Element;
+export type ToggleChangeEventReason = typeof REASONS.none;
+export type ToggleChangeEventDetails = ReturnType<typeof createChangeEventDetails<ToggleChangeEventReason>>;
+export declare namespace Toggle {
+    type State = ToggleState;
+    type Props<Value extends string = string, Component extends ValidComponent = 'button'> = ToggleProps<Value, Component>;
+    type ChangeEventReason = ToggleChangeEventReason;
+    type ChangeEventDetails = ToggleChangeEventDetails;
+}
+export {};

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

@@ -0,0 +1,2 @@
+export { Toggle } from './Toggle.js';
+export type { ToggleChangeEventDetails, ToggleChangeEventReason, ToggleProps, ToggleState, } from './Toggle.js';

package/dist/lib/types/toggle-group/ToggleGroup.d.ts

@@ -0,0 +1,37 @@
+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 { Orientation } from '../internals/types.js';
+export interface ToggleGroupState {
+    /** Whether the component should ignore user interaction. */
+    disabled: boolean;
+    /** Whether multiple toggles may be pressed at once. */
+    multiple: boolean;
+    /** The direction in which the toggles are arranged. */
+    orientation: Orientation;
+}
+type ToggleGroupEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onKeyDown?: JSX.EventHandlerUnion<infer Target, KeyboardEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface ToggleGroupOwnProps<Value extends string, Component extends ValidComponent> {
+    defaultValue?: readonly Value[] | undefined;
+    disabled?: boolean | undefined;
+    loopFocus?: boolean | undefined;
+    multiple?: boolean | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<ToggleGroupEventTarget<Component>, KeyboardEvent> | undefined;
+    onValueChange?: ((value: Value[], eventDetails: ToggleGroupChangeEventDetails) => void) | undefined;
+    orientation?: Orientation | undefined;
+    value?: readonly Value[] | undefined;
+}
+export type ToggleGroupProps<Value extends string = string, Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ToggleGroupState, ToggleGroupOwnProps<Value, Component>>;
+/** Provides shared state and roving focus to a series of toggle buttons. */
+export declare function ToggleGroup<Value extends string = string, Component extends ValidComponent = 'div'>(props: ToggleGroup.Props<Value, Component>): JSX.Element;
+export type ToggleGroupChangeEventReason = 'none';
+export type ToggleGroupChangeEventDetails = import('../types/index.js').BaseUIChangeEventDetails<ToggleGroupChangeEventReason>;
+export declare namespace ToggleGroup {
+    type State = ToggleGroupState;
+    type Props<Value extends string = string, Component extends ValidComponent = 'div'> = ToggleGroupProps<Value, Component>;
+    type ChangeEventReason = ToggleGroupChangeEventReason;
+    type ChangeEventDetails = ToggleGroupChangeEventDetails;
+}
+export {};

package/dist/lib/types/toggle-group/ToggleGroupContext.d.ts

@@ -0,0 +1,25 @@
+import { type Accessor } from 'solid-js';
+import type { BaseUIChangeEventDetails } from '../types/index.js';
+import type { ToolbarRootContextValue } from '../toolbar/root/ToolbarRootContext.js';
+export interface RegisteredToggle {
+    token: symbol;
+    order: number;
+    disabled: Accessor<boolean>;
+    element: Accessor<HTMLElement | undefined>;
+    focusableWhenDisabled: Accessor<boolean>;
+}
+export interface ToggleGroupContextValue<Value extends string = string> {
+    disabled: Accessor<boolean>;
+    isPressed: (value: Value) => boolean;
+    isTabStop: (item: RegisteredToggle) => boolean;
+    isValueInitialized: Accessor<boolean>;
+    registerItem: (item: RegisteredToggle) => () => void;
+    setActiveItem: (item: RegisteredToggle) => void;
+    setGroupValue: (value: Value, nextPressed: boolean, eventDetails: BaseUIChangeEventDetails<'none'>) => void;
+    toolbar: ToolbarRootContextValue | undefined;
+    value: Accessor<readonly Value[]>;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ToggleGroupContext: import("solid-js").Context<typeof MISSING_CONTEXT | ToggleGroupContextValue<any>>;
+export declare function useToggleGroupContext<Value extends string = string>(): ToggleGroupContextValue<Value> | undefined;
+export {};

package/dist/lib/types/toggle-group/index.d.ts

@@ -0,0 +1,2 @@
+export { ToggleGroup } from './ToggleGroup.js';
+export type { ToggleGroupChangeEventDetails, ToggleGroupChangeEventReason, ToggleGroupProps, ToggleGroupState, } from './ToggleGroup.js';

package/dist/lib/types/toolbar/ToolbarItemOwnerContext.d.ts

@@ -0,0 +1,10 @@
+import { type Accessor } from 'solid-js';
+export interface ToolbarItemOwnerContextValue {
+    disabled: Accessor<boolean>;
+    focusableWhenDisabled: Accessor<boolean>;
+    setChildDisabled: (disabled: boolean) => void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ToolbarItemOwnerContext: import("solid-js").Context<ToolbarItemOwnerContextValue | typeof MISSING_CONTEXT>;
+export declare function useToolbarItemOwnerContext(): ToolbarItemOwnerContextValue | undefined;
+export {};

package/dist/lib/types/toolbar/button/ToolbarButton.d.ts

@@ -0,0 +1,32 @@
+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 { ToolbarRootState } from '../root/ToolbarRoot.js';
+export interface ToolbarButtonState extends ToolbarRootState {
+    /** Whether the button ignores user interaction. */
+    disabled: boolean;
+    /** Whether the button is configured to remain focusable when disabled. */
+    focusable: boolean;
+}
+type ToolbarButtonEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onClick?: JSX.EventHandlerUnion<infer Target, MouseEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface ToolbarButtonOwnProps<Component extends ValidComponent> {
+    disabled?: boolean | undefined;
+    focusableWhenDisabled?: boolean | undefined;
+    nativeButton?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<ToolbarButtonEventTarget<Component>, MouseEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<ToolbarButtonEventTarget<Component>, FocusEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<ToolbarButtonEventTarget<Component>, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<ToolbarButtonEventTarget<Component>, KeyboardEvent> | undefined;
+    onMouseDown?: BaseUIEventHandlerUnion<ToolbarButtonEventTarget<Component>, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<ToolbarButtonEventTarget<Component>, PointerEvent> | undefined;
+}
+export type ToolbarButtonProps<Component extends ValidComponent = 'button'> = BaseUIComponentProps<Component, ToolbarButtonState, ToolbarButtonOwnProps<Component>>;
+/** A toolbar item with native or accessible non-native button semantics. */
+export declare function ToolbarButton<Component extends ValidComponent = 'button'>(props: ToolbarButton.Props<Component>): JSX.Element;
+export declare namespace ToolbarButton {
+    type State = ToolbarButtonState;
+    type Props<Component extends ValidComponent = 'button'> = ToolbarButtonProps<Component>;
+}
+export {};

package/dist/lib/types/toolbar/createToolbarItem.d.ts

@@ -0,0 +1,13 @@
+import { type Accessor } from 'solid-js';
+import { type ToolbarItemRegistration } from './root/ToolbarRootContext.js';
+export interface ToolbarItemMetadata {
+    disabled: Accessor<boolean>;
+    focusableWhenDisabled: Accessor<boolean>;
+}
+export declare function createToolbarItem(metadata: ToolbarItemMetadata): {
+    element: import("solid-js").SourceAccessor<HTMLElement | undefined>;
+    registration: ToolbarItemRegistration;
+    root: import("./root/ToolbarRootContext.js").ToolbarRootContextValue;
+    setElement: import("solid-js").Setter<HTMLElement | undefined>;
+    tabIndex: () => 0 | -1;
+};

package/dist/lib/types/toolbar/group/ToolbarGroup.d.ts

@@ -0,0 +1,16 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { ToolbarRootState } from '../root/ToolbarRoot.js';
+export interface ToolbarGroupState extends ToolbarRootState {
+}
+interface ToolbarGroupOwnProps {
+    disabled?: boolean | undefined;
+}
+export type ToolbarGroupProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ToolbarGroupState, ToolbarGroupOwnProps>;
+/** Groups related controls without creating a nested keyboard navigation scope. */
+export declare function ToolbarGroup<Component extends ValidComponent = 'div'>(props: ToolbarGroup.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ToolbarGroup {
+    type State = ToolbarGroupState;
+    type Props<Component extends ValidComponent = 'div'> = ToolbarGroupProps<Component>;
+}
+export {};

package/dist/lib/types/toolbar/group/ToolbarGroupContext.d.ts

@@ -0,0 +1,8 @@
+import { type Accessor } from 'solid-js';
+export interface ToolbarGroupContextValue {
+    disabled: Accessor<boolean>;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ToolbarGroupContext: import("solid-js").Context<ToolbarGroupContextValue | typeof MISSING_CONTEXT>;
+export declare function useToolbarGroupContext(): ToolbarGroupContextValue | undefined;
+export {};

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

@@ -0,0 +1,8 @@
+export * as Toolbar from './index.parts.js';
+export type { Orientation } from './index.parts.js';
+export type * from './root/ToolbarRoot.js';
+export type * from './group/ToolbarGroup.js';
+export type * from './button/ToolbarButton.js';
+export type * from './link/ToolbarLink.js';
+export type * from './input/ToolbarInput.js';
+export type * from './separator/ToolbarSeparator.js';

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

@@ -0,0 +1,7 @@
+export { ToolbarRoot as Root } from './root/ToolbarRoot.js';
+export { ToolbarGroup as Group } from './group/ToolbarGroup.js';
+export { ToolbarButton as Button } from './button/ToolbarButton.js';
+export { ToolbarLink as Link } from './link/ToolbarLink.js';
+export { ToolbarInput as Input } from './input/ToolbarInput.js';
+export { ToolbarSeparator as Separator } from './separator/ToolbarSeparator.js';
+export type { Orientation } from '../internals/types.js';

package/dist/lib/types/toolbar/input/ToolbarInput.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';
+import type { ToolbarRootState } from '../root/ToolbarRoot.js';
+export interface ToolbarInputState extends ToolbarRootState {
+    /** Whether the input ignores user interaction. */
+    disabled: boolean;
+    /** Whether the input is configured to remain focusable when disabled. */
+    focusable: boolean;
+}
+type ToolbarInputEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onKeyDown?: JSX.EventHandlerUnion<infer Target, KeyboardEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface ToolbarInputOwnProps<Component extends ValidComponent> {
+    disabled?: boolean | undefined;
+    focusableWhenDisabled?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<ToolbarInputEventTarget<Component>, MouseEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<ToolbarInputEventTarget<Component>, FocusEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<ToolbarInputEventTarget<Component>, KeyboardEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<ToolbarInputEventTarget<Component>, PointerEvent> | undefined;
+}
+export type ToolbarInputProps<Component extends ValidComponent = 'input'> = BaseUIComponentProps<Component, ToolbarInputState, ToolbarInputOwnProps<Component>>;
+/** A native input that participates in toolbar roving focus. */
+export declare function ToolbarInput<Component extends ValidComponent = 'input'>(props: ToolbarInput.Props<Component>): JSX.Element;
+export declare namespace ToolbarInput {
+    type State = ToolbarInputState;
+    type Props<Component extends ValidComponent = 'input'> = ToolbarInputProps<Component>;
+}
+export {};

package/dist/lib/types/toolbar/link/ToolbarLink.d.ts

@@ -0,0 +1,14 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { ToolbarRootOrientation } from '../root/ToolbarRoot.js';
+export interface ToolbarLinkState {
+    /** The direction in which toolbar items are arranged. */
+    orientation: ToolbarRootOrientation;
+}
+export type ToolbarLinkProps<Component extends ValidComponent = 'a'> = BaseUIComponentProps<Component, ToolbarLinkState>;
+/** A native link that occupies one toolbar roving-focus slot. */
+export declare function ToolbarLink<Component extends ValidComponent = 'a'>(props: ToolbarLink.Props<Component>): JSX.Element;
+export declare namespace ToolbarLink {
+    type State = ToolbarLinkState;
+    type Props<Component extends ValidComponent = 'a'> = ToolbarLinkProps<Component>;
+}

package/dist/lib/types/toolbar/root/ToolbarRoot.d.ts

@@ -0,0 +1,29 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { Orientation } from '../../internals/types.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ToolbarRootItemMetadata {
+    disabled: boolean;
+    focusableWhenDisabled: boolean;
+}
+export type ToolbarRootOrientation = Orientation;
+export interface ToolbarRootState {
+    /** Whether the toolbar and its disableable items are disabled. */
+    disabled: boolean;
+    /** The direction in which toolbar items are arranged. */
+    orientation: ToolbarRootOrientation;
+}
+interface ToolbarRootOwnProps {
+    disabled?: boolean | undefined;
+    loopFocus?: boolean | undefined;
+    orientation?: ToolbarRootOrientation | undefined;
+}
+export type ToolbarRootProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ToolbarRootState, ToolbarRootOwnProps>;
+/** A container for grouping a set of controls into one keyboard navigation scope. */
+export declare function ToolbarRoot<Component extends ValidComponent = 'div'>(props: ToolbarRoot.Props<Component>): JSX.Element;
+export declare namespace ToolbarRoot {
+    type ItemMetadata = ToolbarRootItemMetadata;
+    type Orientation = ToolbarRootOrientation;
+    type State = ToolbarRootState;
+    type Props<Component extends ValidComponent = 'div'> = ToolbarRootProps<Component>;
+}
+export {};

package/dist/lib/types/toolbar/root/ToolbarRootContext.d.ts

@@ -0,0 +1,23 @@
+import { type Accessor } from 'solid-js';
+import type { Orientation } from '../../internals/types.js';
+export interface ToolbarItemRegistration {
+    token: symbol;
+    order: number;
+    element: Accessor<HTMLElement | undefined>;
+    disabled: Accessor<boolean>;
+    focusableWhenDisabled: Accessor<boolean>;
+}
+export interface ToolbarRootContextValue {
+    disabled: Accessor<boolean>;
+    orientation: Accessor<Orientation>;
+    isTabStop: (item: ToolbarItemRegistration) => boolean;
+    notifyItemChange: () => void;
+    registerItem: (item: ToolbarItemRegistration) => () => void;
+    setActiveItem: (item: ToolbarItemRegistration) => void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ToolbarRootContext: import("solid-js").Context<ToolbarRootContextValue | typeof MISSING_CONTEXT>;
+export declare function useToolbarRootContext(): ToolbarRootContextValue;
+export declare function useToolbarRootContext(optional: false): ToolbarRootContextValue;
+export declare function useToolbarRootContext(optional: true): ToolbarRootContextValue | undefined;
+export {};

package/dist/lib/types/toolbar/separator/ToolbarSeparator.d.ts

@@ -0,0 +1,16 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { Orientation } from '../../internals/types.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ToolbarSeparatorState {
+    /** The orientation of the separator. */
+    orientation: Orientation;
+}
+export type ToolbarSeparatorProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ToolbarSeparatorState, {
+    orientation?: Orientation | undefined;
+}>;
+/** A separator that defaults to the opposite orientation of its toolbar. */
+export declare function ToolbarSeparator<Component extends ValidComponent = 'div'>(props: ToolbarSeparator.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ToolbarSeparator {
+    type State = ToolbarSeparatorState;
+    type Props<Component extends ValidComponent = 'div'> = ToolbarSeparatorProps<Component>;
+}

package/dist/lib/types/tooltip/arrow/TooltipArrow.d.ts

@@ -0,0 +1,17 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { AnchorAlign, AnchorSide } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface TooltipArrowState {
+    open: boolean;
+    side: AnchorSide;
+    align: AnchorAlign;
+    uncentered: boolean;
+    instant: 'delay' | 'dismiss' | 'focus' | undefined;
+}
+export type TooltipArrowProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, TooltipArrowState>;
+/** Displays an arrow positioned against the tooltip anchor. */
+export declare function TooltipArrow<Component extends ValidComponent = 'div'>(props: TooltipArrow.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace TooltipArrow {
+    type State = TooltipArrowState;
+    type Props<Component extends ValidComponent = 'div'> = TooltipArrowProps<Component>;
+}

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

@@ -0,0 +1,9 @@
+export * as Tooltip from './index.parts.js';
+export type * from './provider/TooltipProvider.js';
+export type * from './root/TooltipRoot.js';
+export type * from './trigger/TooltipTrigger.js';
+export type * from './portal/TooltipPortal.js';
+export type * from './positioner/TooltipPositioner.js';
+export type * from './popup/TooltipPopup.js';
+export type * from './viewport/TooltipViewport.js';
+export type * from './arrow/TooltipArrow.js';

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

@@ -0,0 +1,9 @@
+export { TooltipProvider as Provider } from './provider/TooltipProvider.js';
+export { TooltipRoot as Root } from './root/TooltipRoot.js';
+export { TooltipTrigger as Trigger } from './trigger/TooltipTrigger.js';
+export { TooltipPortal as Portal } from './portal/TooltipPortal.js';
+export { TooltipPositioner as Positioner } from './positioner/TooltipPositioner.js';
+export { TooltipPopup as Popup } from './popup/TooltipPopup.js';
+export { TooltipViewport as Viewport } from './viewport/TooltipViewport.js';
+export { TooltipArrow as Arrow } from './arrow/TooltipArrow.js';
+export { TooltipHandle as Handle, createTooltipHandle as createHandle } from './store/TooltipHandle.js';

package/dist/lib/types/tooltip/popup/TooltipPopup.d.ts

@@ -0,0 +1,23 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { AnchorAlign, AnchorSide } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface TooltipPopupState {
+    open: boolean;
+    side: AnchorSide;
+    align: AnchorAlign;
+    instant: 'delay' | 'focus' | 'dismiss' | undefined;
+    transitionStatus: TransitionStatus;
+}
+interface TooltipPopupOwnProps {
+    onKeyDown?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+}
+export type TooltipPopupProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, TooltipPopupState, TooltipPopupOwnProps>;
+/** A container for the tooltip contents. */
+export declare function TooltipPopup<Component extends ValidComponent = 'div'>(props: TooltipPopup.Props<Component>): JSX.Element;
+export declare namespace TooltipPopup {
+    type State = TooltipPopupState;
+    type Props<Component extends ValidComponent = 'div'> = TooltipPopupProps<Component>;
+}
+export {};

package/dist/lib/types/tooltip/portal/TooltipPortal.d.ts

@@ -0,0 +1,17 @@
+import type { JSX, ValidComponent } from '@solidjs/web';
+import { type PopupPortalContainer } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface TooltipPortalState {
+}
+interface TooltipPortalOwnProps {
+    keepMounted?: boolean | undefined;
+    container?: PopupPortalContainer | undefined;
+}
+export type TooltipPortalProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, TooltipPortalState, TooltipPortalOwnProps>;
+/** Moves the tooltip layer into a portal appended to the document body by default. */
+export declare function TooltipPortal<Component extends ValidComponent = 'div'>(props: TooltipPortal.Props<Component>): JSX.Element;
+export declare namespace TooltipPortal {
+    type State = TooltipPortalState;
+    type Props<Component extends ValidComponent = 'div'> = TooltipPortalProps<Component>;
+}
+export {};

package/dist/lib/types/tooltip/portal/TooltipPortalContext.d.ts

@@ -0,0 +1,8 @@
+import { type Accessor } from 'solid-js';
+export interface TooltipPortalContextValue {
+    keepMounted: Accessor<boolean>;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const TooltipPortalContext: import("solid-js").Context<TooltipPortalContextValue | typeof MISSING_CONTEXT>;
+export declare function useTooltipPortalContext(): TooltipPortalContextValue;
+export {};

package/dist/lib/types/tooltip/positioner/TooltipPositioner.d.ts

@@ -0,0 +1,37 @@
+import { type Accessor } from 'solid-js';
+import { type ValidComponent } from '@solidjs/web';
+import type { ReferenceElement, 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';
+export type TooltipAnchor = ReferenceElement | Accessor<ReferenceElement | null> | {
+    current: ReferenceElement | null;
+} | null;
+export interface TooltipPositionerState {
+    open: boolean;
+    side: AnchorSide;
+    align: AnchorAlign;
+    anchorHidden: boolean;
+    instant: string | undefined;
+}
+interface TooltipPositionerOwnProps {
+    anchor?: TooltipAnchor | undefined;
+    positionMethod?: Strategy | undefined;
+    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;
+}
+export type TooltipPositionerProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, TooltipPositionerState, TooltipPositionerOwnProps>;
+/** Positions the tooltip against its active trigger. */
+export declare function TooltipPositioner<Component extends ValidComponent = 'div'>(props: TooltipPositioner.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace TooltipPositioner {
+    type State = TooltipPositionerState;
+    type Props<Component extends ValidComponent = 'div'> = TooltipPositionerProps<Component>;
+}
+export {};

package/dist/lib/types/tooltip/positioner/TooltipPositionerContext.d.ts

@@ -0,0 +1,14 @@
+import { type Accessor } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+import type { AnchorAlign, AnchorSide } from '../../internals/overlay/index.js';
+export interface TooltipPositionerContextValue {
+    side: Accessor<AnchorSide>;
+    align: Accessor<AnchorAlign>;
+    arrowStyles: Accessor<JSX.CSSProperties>;
+    arrowUncentered: Accessor<boolean>;
+    setArrowElement(element: Element | null): void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const TooltipPositionerContext: import("solid-js").Context<TooltipPositionerContextValue | typeof MISSING_CONTEXT>;
+export declare function useTooltipPositionerContext(): TooltipPositionerContextValue;
+export {};

package/dist/lib/types/tooltip/provider/TooltipProvider.d.ts

@@ -0,0 +1,15 @@
+import type { JSX } from '@solidjs/web';
+export interface TooltipProviderState {
+}
+export interface TooltipProviderProps {
+    children?: JSX.Element;
+    delay?: number | undefined;
+    closeDelay?: number | undefined;
+    timeout?: number | undefined;
+}
+/** Shares hover delays so adjacent tooltips can open without waiting again. */
+export declare function TooltipProvider(props: TooltipProvider.Props): JSX.Element;
+export declare namespace TooltipProvider {
+    type State = TooltipProviderState;
+    type Props = TooltipProviderProps;
+}

package/dist/lib/types/tooltip/provider/TooltipProviderContext.d.ts

@@ -0,0 +1,10 @@
+import { type Accessor } from 'solid-js';
+import type { DelayGroup } from '../../internals/overlay/index.js';
+export interface TooltipProviderContextValue {
+    delay: Accessor<number | undefined>;
+    group: DelayGroup;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const TooltipProviderContext: import("solid-js").Context<TooltipProviderContextValue | typeof MISSING_CONTEXT>;
+export declare function useTooltipProviderContext(): TooltipProviderContextValue | undefined;
+export {};

package/dist/lib/types/tooltip/root/TooltipRoot.d.ts

@@ -0,0 +1,40 @@
+import { type Accessor } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+import type { BaseUIChangeEventDetails } from '../../internals/createBaseUIEventDetails.js';
+import { REASONS } from '../../internals/reasons.js';
+import type { TooltipHandle } from '../store/TooltipHandle.js';
+export interface TooltipRootState {
+}
+export interface TooltipRootActions {
+    unmount(): void;
+    close(): void;
+}
+export type TooltipRootChangeEventReason = typeof REASONS.triggerHover | typeof REASONS.triggerFocus | typeof REASONS.triggerPress | typeof REASONS.outsidePress | typeof REASONS.escapeKey | typeof REASONS.disabled | typeof REASONS.imperativeAction | typeof REASONS.none;
+export type TooltipRootChangeEventDetails = BaseUIChangeEventDetails<TooltipRootChangeEventReason> & {
+    preventUnmountOnClose(): void;
+};
+export interface TooltipRootProps<Payload = unknown> {
+    defaultOpen?: boolean | undefined;
+    open?: boolean | undefined;
+    onOpenChange?: ((open: boolean, details: TooltipRootChangeEventDetails) => void) | undefined;
+    onOpenChangeComplete?: ((open: boolean) => void) | undefined;
+    disableHoverablePopup?: boolean | undefined;
+    trackCursorAxis?: 'none' | 'x' | 'y' | 'both' | undefined;
+    actionsRef?: ((actions: TooltipRootActions) => void) | undefined;
+    disabled?: boolean | undefined;
+    handle?: TooltipHandle<Payload> | undefined;
+    children?: JSX.Element | ((state: {
+        payload: Accessor<Payload | undefined>;
+    }) => JSX.Element);
+    triggerId?: string | null | undefined;
+    defaultTriggerId?: string | null | undefined;
+}
+/** Groups all parts of the tooltip without rendering an element. */
+export declare function TooltipRoot<Payload = unknown>(props: TooltipRoot.Props<Payload>): JSX.Element;
+export declare namespace TooltipRoot {
+    type State = TooltipRootState;
+    type Props<Payload = unknown> = TooltipRootProps<Payload>;
+    type Actions = TooltipRootActions;
+    type ChangeEventReason = TooltipRootChangeEventReason;
+    type ChangeEventDetails = TooltipRootChangeEventDetails;
+}

package/dist/lib/types/tooltip/root/TooltipRootContext.d.ts

@@ -0,0 +1,11 @@
+import type { FloatingTreeStore, PopupPresence } from '../../internals/overlay/index.js';
+import type { TooltipStore } from '../store/TooltipStore.js';
+export interface TooltipRootContextValue<Payload = unknown> {
+    store: TooltipStore<Payload>;
+    tree: FloatingTreeStore;
+    presence: PopupPresence;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const TooltipRootContext: import("solid-js").Context<typeof MISSING_CONTEXT | TooltipRootContextValue<unknown>>;
+export declare function useTooltipRootContext<Payload = unknown>(optional?: boolean): TooltipRootContextValue<Payload> | undefined;
+export {};

package/dist/lib/types/tooltip/store/TooltipHandle.d.ts

@@ -0,0 +1,10 @@
+import { BasePopupHandle } from '../../internals/overlay/index.js';
+import { TooltipStore } from './TooltipStore.js';
+/** Imperatively controls a Tooltip and connects detached triggers to its Root. */
+export declare class TooltipHandle<Payload = unknown> extends BasePopupHandle<TooltipStore<Payload>> {
+    constructor();
+    open(triggerId: string): void;
+    close(): void;
+    get isOpen(): boolean;
+}
+export declare function createTooltipHandle<Payload = unknown>(): TooltipHandle<Payload>;