solid-baseui 0.1.0-alpha.0

package/dist/lib/types/popover/store/PopoverStore.d.ts

@@ -0,0 +1,65 @@
+import { DetachedPopupStore, PopupStore, type InteractionType, type PopupStoreOptions } from '../../internals/overlay/index.js';
+import type { PopoverRootChangeEventDetails, PopoverRootChangeEventReason } from '../root/PopoverRoot.js';
+export type PopoverInstantType = 'dismiss' | 'click' | 'focus' | 'trigger-change' | undefined;
+export interface PopoverTriggerData<Payload> {
+    payload: Payload | undefined;
+    disabled: boolean;
+    openOnHover: boolean;
+    closeDelay: number;
+}
+export declare class PopoverStore<Payload = unknown> extends PopupStore<Payload, PopoverRootChangeEventDetails> {
+    private readonly triggerData;
+    private readonly openMethodAccessor;
+    private readonly setOpenMethodSignal;
+    private readonly openReasonAccessor;
+    private readonly setOpenReason;
+    private readonly instantTypeAccessor;
+    private readonly setInstantTypeSignal;
+    private readonly stickIfOpenAccessor;
+    private readonly setStickIfOpenSignal;
+    private readonly focusManagerModalAccessor;
+    private readonly setFocusManagerModalSignal;
+    private readonly disabledAccessor;
+    private readonly setDisabledSignal;
+    private readonly openOnHoverAccessor;
+    private readonly setOpenOnHoverSignal;
+    private patientClickTimer;
+    constructor(options?: PopupStoreOptions<PopoverRootChangeEventDetails>);
+    openMethod(): InteractionType | null;
+    setOpenMethod(value: InteractionType | null): void;
+    openChangeReason(): PopoverRootChangeEventReason | null;
+    instantType(): PopoverInstantType;
+    setInstantType(value: PopoverInstantType): void;
+    stickIfOpen(): boolean;
+    focusManagerModal(): boolean;
+    setFocusManagerModal(value: boolean): void;
+    disabled(): boolean;
+    openOnHover(): boolean;
+    closeDelay(): number;
+    floatingElement(): HTMLElement | null;
+    setTriggerData(id: string, data: PopoverTriggerData<Payload>): void;
+    removeTriggerData(id: string): void;
+    syncTriggerData(activeId?: string | null, open?: boolean): void;
+    resetAfterUnmount(): void;
+    dispose(): void;
+    reconcileTriggers(): void;
+    setOpen(open: boolean, details: PopoverRootChangeEventDetails): boolean;
+}
+export declare class DetachedPopoverStore<Payload = unknown> extends DetachedPopupStore<Payload> {
+    openMethod(): InteractionType | null;
+    setOpenMethod(_value: InteractionType | null): void;
+    openChangeReason(): PopoverRootChangeEventReason | null;
+    instantType(): PopoverInstantType;
+    setInstantType(_value: PopoverInstantType): void;
+    stickIfOpen(): boolean;
+    focusManagerModal(): boolean;
+    setFocusManagerModal(_value: boolean): void;
+    disabled(): boolean;
+    openOnHover(): boolean;
+    closeDelay(): number;
+    floatingElement(): HTMLElement | null;
+    isMountedByTrigger(_id: string | undefined): boolean;
+    setTriggerData(_id: string, _data: PopoverTriggerData<Payload>): void;
+    removeTriggerData(_id: string): void;
+    syncTriggerData(_activeId?: string | null, _open?: boolean): void;
+}

package/dist/lib/types/popover/title/PopoverTitle.d.ts

@@ -0,0 +1,11 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface PopoverTitleState {
+}
+export type PopoverTitleProps<Component extends ValidComponent = 'h2'> = BaseUIComponentProps<Component, PopoverTitleState>;
+/** A heading that labels the popover. */
+export declare function PopoverTitle<Component extends ValidComponent = 'h2'>(props: PopoverTitle.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace PopoverTitle {
+    type State = PopoverTitleState;
+    type Props<Component extends ValidComponent = 'h2'> = PopoverTitleProps<Component>;
+}

package/dist/lib/types/popover/trigger/PopoverTrigger.d.ts

@@ -0,0 +1,33 @@
+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 { PopoverHandle } from '../store/PopoverHandle.js';
+export interface PopoverTriggerState {
+    disabled: boolean;
+    open: boolean;
+}
+type TriggerEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onClick?: JSX.EventHandlerUnion<infer Target, MouseEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface PopoverTriggerOwnProps<Payload, Component extends ValidComponent> {
+    handle?: PopoverHandle<Payload> | undefined;
+    payload?: Payload | undefined;
+    disabled?: boolean | undefined;
+    nativeButton?: boolean | undefined;
+    openOnHover?: boolean | undefined;
+    delay?: number | undefined;
+    closeDelay?: number | undefined;
+    onClick?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, MouseEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, KeyboardEvent> | undefined;
+    onMouseDown?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, PointerEvent> | undefined;
+}
+export type PopoverTriggerProps<Payload = unknown, Component extends ValidComponent = 'button'> = BaseUIComponentProps<Component, PopoverTriggerState, PopoverTriggerOwnProps<Payload, Component>>;
+/** A button that opens the popover. */
+export declare function PopoverTrigger<Payload = unknown, Component extends ValidComponent = 'button'>(props: PopoverTrigger.Props<Payload, Component>): JSX.Element;
+export declare namespace PopoverTrigger {
+    type State = PopoverTriggerState;
+    type Props<Payload = unknown, Component extends ValidComponent = 'button'> = PopoverTriggerProps<Payload, Component>;
+}
+export {};

package/dist/lib/types/popover/utils/ClosePartContext.d.ts

@@ -0,0 +1,10 @@
+import { type Accessor } from 'solid-js';
+export interface ClosePartContextValue {
+    hasClosePart: Accessor<boolean>;
+    register(): () => void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ClosePartContext: import("solid-js").Context<ClosePartContextValue | typeof MISSING_CONTEXT>;
+export declare function createClosePartContext(): ClosePartContextValue;
+export declare function useClosePartRegistration(): void;
+export {};

package/dist/lib/types/popover/utils/mergePopoverStyles.d.ts

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

package/dist/lib/types/popover/utils/stateAttributesMapping.d.ts

@@ -0,0 +1,26 @@
+export declare const popoverPositionerStateMapping: {
+    open: (value: boolean) => {
+        'data-open': string;
+    } | {
+        'data-closed': string;
+    };
+    anchorHidden: (value: boolean) => {
+        'data-anchor-hidden': string;
+    } | null;
+};
+export declare const popoverPopupTransitionStateMapping: {
+    transitionStatus(value: import("../../internals/stateAttributesMapping.js").TransitionStatus): Record<string, string> | null;
+    open: (value: boolean) => {
+        'data-open': string;
+    } | {
+        'data-closed': string;
+    };
+    anchorHidden: (value: boolean) => {
+        'data-anchor-hidden': string;
+    } | null;
+};
+export declare const popoverViewportStateMapping: {
+    activationDirection: (value: string | undefined) => {
+        'data-activation-direction': string;
+    } | null;
+};

package/dist/lib/types/popover/viewport/PopoverViewport.d.ts

@@ -0,0 +1,15 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { PopoverInstantType } from '../store/PopoverStore.js';
+export interface PopoverViewportState {
+    activationDirection: string | undefined;
+    transitioning: boolean;
+    instant: PopoverInstantType;
+}
+export type PopoverViewportProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, PopoverViewportState>;
+/** Displays content transitions when the active trigger changes. */
+export declare function PopoverViewport<Component extends ValidComponent = 'div'>(props: PopoverViewport.Props<Component>): JSX.Element;
+export declare namespace PopoverViewport {
+    type State = PopoverViewportState;
+    type Props<Component extends ValidComponent = 'div'> = PopoverViewportProps<Component>;
+}

package/dist/lib/types/preview-card/arrow/PreviewCardArrow.d.ts

@@ -0,0 +1,16 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { AnchorAlign, AnchorSide } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface PreviewCardArrowState {
+    open: boolean;
+    side: AnchorSide;
+    align: AnchorAlign;
+    uncentered: boolean;
+}
+export type PreviewCardArrowProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, PreviewCardArrowState>;
+/** Displays an element positioned against the preview card anchor. */
+export declare function PreviewCardArrow<Component extends ValidComponent = 'div'>(props: PreviewCardArrow.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace PreviewCardArrow {
+    type State = PreviewCardArrowState;
+    type Props<Component extends ValidComponent = 'div'> = PreviewCardArrowProps<Component>;
+}

package/dist/lib/types/preview-card/backdrop/PreviewCardBackdrop.d.ts

@@ -0,0 +1,14 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface PreviewCardBackdropState {
+    open: boolean;
+    transitionStatus: TransitionStatus;
+}
+export type PreviewCardBackdropProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, PreviewCardBackdropState>;
+/** A presentational overlay displayed beneath the popup. */
+export declare function PreviewCardBackdrop<Component extends ValidComponent = 'div'>(props: PreviewCardBackdrop.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace PreviewCardBackdrop {
+    type State = PreviewCardBackdropState;
+    type Props<Component extends ValidComponent = 'div'> = PreviewCardBackdropProps<Component>;
+}

package/dist/lib/types/preview-card/index.d.ts

@@ -0,0 +1,9 @@
+export * as PreviewCard from './index.parts.js';
+export type * from './root/PreviewCardRoot.js';
+export type * from './trigger/PreviewCardTrigger.js';
+export type * from './portal/PreviewCardPortal.js';
+export type * from './positioner/PreviewCardPositioner.js';
+export type * from './popup/PreviewCardPopup.js';
+export type * from './arrow/PreviewCardArrow.js';
+export type * from './backdrop/PreviewCardBackdrop.js';
+export type * from './viewport/PreviewCardViewport.js';

package/dist/lib/types/preview-card/index.parts.d.ts

@@ -0,0 +1,9 @@
+export { PreviewCardRoot as Root } from './root/PreviewCardRoot.js';
+export { PreviewCardTrigger as Trigger } from './trigger/PreviewCardTrigger.js';
+export { PreviewCardPortal as Portal } from './portal/PreviewCardPortal.js';
+export { PreviewCardPositioner as Positioner } from './positioner/PreviewCardPositioner.js';
+export { PreviewCardPopup as Popup } from './popup/PreviewCardPopup.js';
+export { PreviewCardArrow as Arrow } from './arrow/PreviewCardArrow.js';
+export { PreviewCardBackdrop as Backdrop } from './backdrop/PreviewCardBackdrop.js';
+export { PreviewCardViewport as Viewport } from './viewport/PreviewCardViewport.js';
+export { PreviewCardHandle as Handle, createPreviewCardHandle as createHandle, } from './store/PreviewCardHandle.js';

package/dist/lib/types/preview-card/popup/PreviewCardPopup.d.ts

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

package/dist/lib/types/preview-card/portal/PreviewCardPortal.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 PreviewCardPortalState {
+}
+interface PreviewCardPortalOwnProps {
+    keepMounted?: boolean | undefined;
+    container?: PopupPortalContainer | undefined;
+}
+export type PreviewCardPortalProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, PreviewCardPortalState, PreviewCardPortalOwnProps>;
+/** Moves the preview card layer into a portal appended to the document body by default. */
+export declare function PreviewCardPortal<Component extends ValidComponent = 'div'>(props: PreviewCardPortal.Props<Component>): JSX.Element;
+export declare namespace PreviewCardPortal {
+    type State = PreviewCardPortalState;
+    type Props<Component extends ValidComponent = 'div'> = PreviewCardPortalProps<Component>;
+}
+export {};

package/dist/lib/types/preview-card/portal/PreviewCardPortalContext.d.ts

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

package/dist/lib/types/preview-card/positioner/PreviewCardPositioner.d.ts

@@ -0,0 +1,38 @@
+import { type Accessor } from 'solid-js';
+import { type ValidComponent } from '@solidjs/web';
+import type { ReferenceElement } 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';
+type AnchorRef = {
+    current: Element | null;
+};
+export type PreviewCardAnchor = ReferenceElement | AnchorRef | Accessor<ReferenceElement | null> | null;
+export interface PreviewCardPositionerState {
+    open: boolean;
+    side: AnchorSide;
+    align: AnchorAlign;
+    anchorHidden: boolean;
+    instant: 'dismiss' | 'focus' | 'initial' | undefined;
+}
+interface PreviewCardPositionerOwnProps {
+    anchor?: PreviewCardAnchor | undefined;
+    positionMethod?: 'absolute' | 'fixed' | undefined;
+    side?: AnchorSide | undefined;
+    align?: AnchorAlign | undefined;
+    sideOffset?: number | OffsetFunction | 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 PreviewCardPositionerProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, PreviewCardPositionerState, PreviewCardPositionerOwnProps>;
+/** Positions the popup against the active trigger or a custom anchor. */
+export declare function PreviewCardPositioner<Component extends ValidComponent = 'div'>(props: PreviewCardPositioner.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace PreviewCardPositioner {
+    type State = PreviewCardPositionerState;
+    type Props<Component extends ValidComponent = 'div'> = PreviewCardPositionerProps<Component>;
+}
+export {};

package/dist/lib/types/preview-card/positioner/PreviewCardPositionerContext.d.ts

@@ -0,0 +1,5 @@
+import type { AnchorPositioning } from '../../internals/overlay/index.js';
+declare const MISSING_CONTEXT: unique symbol;
+export declare const PreviewCardPositionerContext: import("solid-js").Context<AnchorPositioning | typeof MISSING_CONTEXT>;
+export declare function usePreviewCardPositionerContext(): AnchorPositioning;
+export {};

package/dist/lib/types/preview-card/root/PreviewCardRoot.d.ts

@@ -0,0 +1,37 @@
+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 { PreviewCardHandle } from '../store/PreviewCardHandle.js';
+export interface PreviewCardRootState {
+}
+export interface PreviewCardRootActions {
+    unmount(): void;
+    close(): void;
+}
+export type PreviewCardRootChangeEventReason = typeof REASONS.triggerHover | typeof REASONS.triggerFocus | typeof REASONS.triggerPress | typeof REASONS.outsidePress | typeof REASONS.escapeKey | typeof REASONS.imperativeAction | typeof REASONS.none;
+export type PreviewCardRootChangeEventDetails = BaseUIChangeEventDetails<PreviewCardRootChangeEventReason> & {
+    preventUnmountOnClose(): void;
+};
+export interface PreviewCardRootProps<Payload = unknown> {
+    defaultOpen?: boolean | undefined;
+    open?: boolean | undefined;
+    onOpenChange?: ((open: boolean, details: PreviewCardRootChangeEventDetails) => void) | undefined;
+    onOpenChangeComplete?: ((open: boolean) => void) | undefined;
+    actionsRef?: ((actions: PreviewCardRootActions) => void) | undefined;
+    handle?: PreviewCardHandle<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 preview card without rendering an element. */
+export declare function PreviewCardRoot<Payload = unknown>(props: PreviewCardRoot.Props<Payload>): JSX.Element;
+export declare namespace PreviewCardRoot {
+    type State = PreviewCardRootState;
+    type Props<Payload = unknown> = PreviewCardRootProps<Payload>;
+    type Actions = PreviewCardRootActions;
+    type ChangeEventReason = PreviewCardRootChangeEventReason;
+    type ChangeEventDetails = PreviewCardRootChangeEventDetails;
+}

package/dist/lib/types/preview-card/root/PreviewCardRootContext.d.ts

@@ -0,0 +1,12 @@
+import type { FloatingTreeStore, PopupPresence } from '../../internals/overlay/index.js';
+import type { PreviewCardStore } from '../store/PreviewCardStore.js';
+export interface PreviewCardRootContextValue<Payload = unknown> {
+    store: PreviewCardStore<Payload>;
+    tree: FloatingTreeStore;
+    presence: PopupPresence;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const PreviewCardRootContext: import("solid-js").Context<typeof MISSING_CONTEXT | PreviewCardRootContextValue<unknown>>;
+export declare function usePreviewCardRootContext<Payload = unknown>(optional?: false): PreviewCardRootContextValue<Payload>;
+export declare function usePreviewCardRootContext<Payload = unknown>(optional: true): PreviewCardRootContextValue<Payload> | undefined;
+export {};

package/dist/lib/types/preview-card/store/PreviewCardHandle.d.ts

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

package/dist/lib/types/preview-card/store/PreviewCardStore.d.ts

@@ -0,0 +1,34 @@
+import type { Accessor } from 'solid-js';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import { DetachedPopupStore, FloatingRootStore, FloatingTreeStore, PopupStore, type InlineRectState, type PopupStoreOptions, type PopupHandleStore, type PopupTriggerStore } from '../../internals/overlay/index.js';
+import type { PreviewCardRootChangeEventDetails } from '../root/PreviewCardRoot.js';
+export interface PreviewCardTriggerStore<Payload = unknown> extends PopupTriggerStore<Payload>, PopupHandleStore {
+    readonly context: PopupTriggerStore<Payload>['context'] & {
+        floatingRoot: FloatingRootStore;
+    };
+    readonly inlineRect: InlineRectState;
+    readonly tree: FloatingTreeStore;
+    floatingElement(): HTMLElement | null;
+    transitionStatus(): TransitionStatus;
+}
+export declare class PreviewCardStore<Payload = unknown> extends PopupStore<Payload, PreviewCardRootChangeEventDetails> implements PreviewCardTriggerStore<Payload> {
+    readonly inlineRect: InlineRectState;
+    constructor(options: PopupStoreOptions<PreviewCardRootChangeEventDetails> & {
+        tree: FloatingTreeStore;
+    });
+    readonly tree: FloatingTreeStore;
+    floatingElement(): HTMLElement | null;
+    transitionStatus(): TransitionStatus;
+    setOpen(open: boolean, details: PreviewCardRootChangeEventDetails): boolean;
+}
+export declare class DetachedPreviewCardStore<Payload = unknown> extends DetachedPopupStore<Payload> implements PreviewCardTriggerStore<Payload> {
+    readonly inlineRect: InlineRectState;
+    readonly tree: FloatingTreeStore;
+    readonly context: DetachedPopupStore<Payload>['context'] & {
+        floatingRoot: FloatingRootStore;
+    };
+    constructor();
+    floatingElement(): HTMLElement | null;
+    transitionStatus(): TransitionStatus;
+}
+export type PreviewCardStoreAccessor<Payload> = Accessor<PreviewCardTriggerStore<Payload> | undefined>;

package/dist/lib/types/preview-card/trigger/PreviewCardTrigger.d.ts

@@ -0,0 +1,20 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { PreviewCardHandle } from '../store/PreviewCardHandle.js';
+export interface PreviewCardTriggerState {
+    open: boolean;
+}
+interface PreviewCardTriggerOwnProps<Payload> {
+    handle?: PreviewCardHandle<Payload> | undefined;
+    payload?: Payload | undefined;
+    delay?: number | undefined;
+    closeDelay?: number | undefined;
+}
+export type PreviewCardTriggerProps<Payload = unknown, Component extends ValidComponent = 'a'> = BaseUIComponentProps<Component, PreviewCardTriggerState, PreviewCardTriggerOwnProps<Payload>>;
+/** A link that opens the preview card after a hover or focus delay. */
+export declare function PreviewCardTrigger<Payload = unknown, Component extends ValidComponent = 'a'>(props: PreviewCardTrigger.Props<Payload, Component>): JSX.Element;
+export declare namespace PreviewCardTrigger {
+    type State = PreviewCardTriggerState;
+    type Props<Payload = unknown, Component extends ValidComponent = 'a'> = PreviewCardTriggerProps<Payload, Component>;
+}
+export {};

package/dist/lib/types/preview-card/utils/mergePreviewCardStyles.d.ts

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

package/dist/lib/types/preview-card/utils/stateAttributesMapping.d.ts

@@ -0,0 +1,32 @@
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+export declare const previewCardPopupStateMapping: {
+    open: (value: boolean) => {
+        'data-open': string;
+    } | {
+        'data-closed': string;
+    };
+    anchorHidden: (value: boolean) => {
+        'data-anchor-hidden': string;
+    } | null;
+};
+export declare const previewCardPopupTransitionStateMapping: {
+    transitionStatus(value: TransitionStatus): Record<string, string> | null;
+    open: (value: boolean) => {
+        'data-open': string;
+    } | {
+        'data-closed': string;
+    };
+    anchorHidden: (value: boolean) => {
+        'data-anchor-hidden': string;
+    } | null;
+};
+export declare const previewCardViewportStateMapping: {
+    activationDirection: (value: string | undefined) => {
+        'data-activation-direction': string;
+    } | null;
+};
+export type PreviewCardTransitionState = {
+    open: boolean;
+    anchorHidden: boolean;
+    transitionStatus: TransitionStatus;
+};

package/dist/lib/types/preview-card/viewport/PreviewCardViewport.d.ts

@@ -0,0 +1,14 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface PreviewCardViewportState {
+    activationDirection: string | undefined;
+    transitioning: boolean;
+    instant: 'dismiss' | 'focus' | undefined;
+}
+export type PreviewCardViewportProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, PreviewCardViewportState>;
+/** Displays content transitions when the active trigger changes. */
+export declare function PreviewCardViewport<Component extends ValidComponent = 'div'>(props: PreviewCardViewport.Props<Component>): JSX.Element;
+export declare namespace PreviewCardViewport {
+    type State = PreviewCardViewportState;
+    type Props<Component extends ValidComponent = 'div'> = PreviewCardViewportProps<Component>;
+}

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

@@ -0,0 +1,6 @@
+export * as Progress from './index.parts.js';
+export type { ProgressRootProps, ProgressRootState, ProgressStatus, } from './root/ProgressRoot.js';
+export type { ProgressTrackProps, ProgressTrackState } from './track/ProgressTrack.js';
+export type { ProgressIndicatorProps, ProgressIndicatorState, } from './indicator/ProgressIndicator.js';
+export type { ProgressValueProps, ProgressValueState } from './value/ProgressValue.js';
+export type { ProgressLabelProps, ProgressLabelState } from './label/ProgressLabel.js';

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

@@ -0,0 +1,6 @@
+export { ProgressRoot as Root } from './root/ProgressRoot.js';
+export { ProgressTrack as Track } from './track/ProgressTrack.js';
+export { ProgressIndicator as Indicator } from './indicator/ProgressIndicator.js';
+export { ProgressValue as Value } from './value/ProgressValue.js';
+export { ProgressLabel as Label } from './label/ProgressLabel.js';
+export type { ProgressStatus as Status } from './root/ProgressRoot.js';

package/dist/lib/types/progress/indicator/ProgressIndicator.d.ts

@@ -0,0 +1,12 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { ProgressRootState } from '../root/ProgressRoot.js';
+export interface ProgressIndicatorState extends ProgressRootState {
+}
+export type ProgressIndicatorProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ProgressIndicatorState>;
+/** Visualizes the task's completion status. */
+export declare function ProgressIndicator<Component extends ValidComponent = 'div'>(props: ProgressIndicator.Props<Component>): JSX.Element;
+export declare namespace ProgressIndicator {
+    type State = ProgressIndicatorState;
+    type Props<Component extends ValidComponent = 'div'> = ProgressIndicatorProps<Component>;
+}

package/dist/lib/types/progress/label/ProgressLabel.d.ts

@@ -0,0 +1,17 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { ProgressRootState } from '../root/ProgressRoot.js';
+export interface ProgressLabelState extends ProgressRootState {
+}
+interface ProgressLabelOwnProps {
+    /** The id used to label the progress bar. */
+    id?: string | undefined;
+}
+export type ProgressLabelProps<Component extends ValidComponent = 'span'> = BaseUIComponentProps<Component, ProgressLabelState, ProgressLabelOwnProps>;
+/** An accessible label that is automatically associated with the progress bar. */
+export declare function ProgressLabel<Component extends ValidComponent = 'span'>(props: ProgressLabel.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ProgressLabel {
+    type State = ProgressLabelState;
+    type Props<Component extends ValidComponent = 'span'> = ProgressLabelProps<Component>;
+}
+export {};

package/dist/lib/types/progress/root/ProgressRoot.d.ts

@@ -0,0 +1,31 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export type ProgressStatus = 'indeterminate' | 'progressing' | 'complete';
+export interface ProgressRootState {
+    /** The current task completion status. */
+    status: ProgressStatus;
+}
+interface ProgressRootOwnProps {
+    /** A human-readable text alternative for the current value. */
+    'aria-valuetext'?: string | undefined;
+    /** Options used to format the clamped value. */
+    format?: Intl.NumberFormatOptions | undefined;
+    /** Returns the human-readable text alternative for the current value. */
+    getAriaValueText?: ((formattedValue: string, value: number | null) => string) | undefined;
+    /** The locale used by `Intl.NumberFormat`. */
+    locale?: Intl.LocalesArgument | undefined;
+    /** The maximum value. @default 100 */
+    max?: number | undefined;
+    /** The minimum value. @default 0 */
+    min?: number | undefined;
+    /** The current value. The progress is indeterminate when this is `null`. */
+    value: number | null;
+}
+export type ProgressRootProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ProgressRootState, ProgressRootOwnProps>;
+/** Groups all progress parts and exposes task completion to assistive technology. */
+export declare function ProgressRoot<Component extends ValidComponent = 'div'>(props: ProgressRoot.Props<Component>): JSX.Element;
+export declare namespace ProgressRoot {
+    type State = ProgressRootState;
+    type Props<Component extends ValidComponent = 'div'> = ProgressRootProps<Component>;
+}
+export {};

package/dist/lib/types/progress/root/ProgressRootContext.d.ts

@@ -0,0 +1,13 @@
+import { type Accessor, type Setter } from 'solid-js';
+import type { ProgressRootState } from './ProgressRoot.js';
+export interface ProgressRootContextValue {
+    formattedValue: Accessor<string>;
+    percentageValue: Accessor<number | null>;
+    setLabelId: Setter<string | undefined>;
+    state: Accessor<ProgressRootState>;
+    value: Accessor<number | null>;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ProgressRootContext: import("solid-js").Context<ProgressRootContextValue | typeof MISSING_CONTEXT>;
+export declare function useProgressRootContext(): ProgressRootContextValue;
+export {};

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

@@ -0,0 +1,3 @@
+import type { StateAttributesMapping } from '../../internals/getStateAttributesProps.js';
+import type { ProgressRootState } from './ProgressRoot.js';
+export declare const progressStateAttributesMapping: StateAttributesMapping<ProgressRootState>;

package/dist/lib/types/progress/track/ProgressTrack.d.ts

@@ -0,0 +1,12 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { ProgressRootState } from '../root/ProgressRoot.js';
+export interface ProgressTrackState extends ProgressRootState {
+}
+export type ProgressTrackProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ProgressTrackState>;
+/** Contains the progress indicator. */
+export declare function ProgressTrack<Component extends ValidComponent = 'div'>(props: ProgressTrack.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ProgressTrack {
+    type State = ProgressTrackState;
+    type Props<Component extends ValidComponent = 'div'> = ProgressTrackProps<Component>;
+}