@skdx/react 0.26.0

package/dist/speed-dial/SpeedDialItemLabel.d.ts

@@ -0,0 +1,43 @@
+import * as React from 'react';
+import type { SpeedDialItemLabelProps } from './types.js';
+/**
+ * The visible text naming its `SpeedDialItem` — the little caption that sits
+ * beside an icon-only action. It registers its `id` with the item, which
+ * points `aria-labelledby` at it, so the action is named by the very element
+ * the sighted user reads.
+ *
+ * This exists as a real element on purpose. The obvious shortcut — a `title`
+ * attribute on the item — produces a tooltip that never appears for keyboard
+ * focus, cannot be styled or animated, is announced inconsistently across
+ * screen readers, and is invisible on touch entirely. A label you can see is
+ * a label you can also position, fade in on hover, and hand to
+ * `aria-labelledby`.
+ *
+ * Reveal it however you like; the item's own `:hover`/`:focus-within` is the
+ * usual hook, and nothing here hides it, so a dial that shows every label
+ * permanently needs no override:
+ *
+ * ```css
+ * .my-speed-dial-label {
+ *   opacity: 0;
+ *   transition: opacity 120ms;
+ * }
+ * .my-speed-dial-item:hover .my-speed-dial-label,
+ * .my-speed-dial-item:focus-within .my-speed-dial-label {
+ *   opacity: 1;
+ * }
+ * ```
+ *
+ * Keep it visible to assistive technology even while it is visually hidden —
+ * `opacity: 0` and `visibility: hidden` differ here, and `display: none`
+ * would drop the accessible name along with the text.
+ *
+ * @example
+ * ```tsx
+ * <SpeedDialItem onSelect={share}>
+ *   <ShareIcon aria-hidden />
+ *   <SpeedDialItemLabel>Share</SpeedDialItemLabel>
+ * </SpeedDialItem>
+ * ```
+ */
+export declare const SpeedDialItemLabel: React.ForwardRefExoticComponent<Omit<SpeedDialItemLabelProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;

package/dist/speed-dial/SpeedDialPortal.d.cts

@@ -0,0 +1,24 @@
+import type { SpeedDialPortalProps } from './types.cjs';
+/**
+ * Teleports `SpeedDialContent` to `document.body` (or a custom `container`),
+ * so the fan escapes any clipping/`overflow` ancestors — which a dial pinned
+ * to a corner of a scrolling pane will otherwise hit immediately.
+ *
+ * Unmounts once the content's exit animation has finished, not the moment the
+ * dial closes, so `forceMount` is only needed to keep the actions in the DOM
+ * permanently.
+ *
+ * @example
+ * ```tsx
+ * <SpeedDial>
+ *   <SpeedDialTrigger aria-label="Actions">+</SpeedDialTrigger>
+ *   <SpeedDialPortal>
+ *     <SpeedDialContent>…</SpeedDialContent>
+ *   </SpeedDialPortal>
+ * </SpeedDial>
+ * ```
+ */
+export declare const SpeedDialPortal: {
+    ({ forceMount, children, ...props }: SpeedDialPortalProps): import("react").JSX.Element | null;
+    displayName: string;
+};

package/dist/speed-dial/SpeedDialPortal.d.ts

@@ -0,0 +1,24 @@
+import type { SpeedDialPortalProps } from './types.js';
+/**
+ * Teleports `SpeedDialContent` to `document.body` (or a custom `container`),
+ * so the fan escapes any clipping/`overflow` ancestors — which a dial pinned
+ * to a corner of a scrolling pane will otherwise hit immediately.
+ *
+ * Unmounts once the content's exit animation has finished, not the moment the
+ * dial closes, so `forceMount` is only needed to keep the actions in the DOM
+ * permanently.
+ *
+ * @example
+ * ```tsx
+ * <SpeedDial>
+ *   <SpeedDialTrigger aria-label="Actions">+</SpeedDialTrigger>
+ *   <SpeedDialPortal>
+ *     <SpeedDialContent>…</SpeedDialContent>
+ *   </SpeedDialPortal>
+ * </SpeedDial>
+ * ```
+ */
+export declare const SpeedDialPortal: {
+    ({ forceMount, children, ...props }: SpeedDialPortalProps): import("react").JSX.Element | null;
+    displayName: string;
+};

package/dist/speed-dial/SpeedDialTrigger.d.cts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import type { SpeedDialTriggerProps } from './types.cjs';
+/**
+ * The floating action button: toggles the fan on click, opens it with the
+ * arrow keys along the fan's axis, and doubles as the positioning anchor for
+ * `SpeedDialContent`. Sets `aria-haspopup="menu"`, `aria-expanded`,
+ * `aria-controls`, `data-state` (`open`/`closed`) and `data-direction`, the
+ * last so the icon can rotate from CSS alone.
+ *
+ * With `openOnHover` on the root it also opens on pointer-enter (never for
+ * touch pointers, which have no hover) and starts the close countdown on
+ * pointer-leave.
+ *
+ * Give it an accessible name. A speed dial trigger is usually a bare `+`
+ * glyph, which tells a screen-reader user nothing about what it opens.
+ *
+ * @example
+ * ```tsx
+ * <SpeedDialTrigger aria-label="Quick actions">
+ *   <PlusIcon aria-hidden />
+ * </SpeedDialTrigger>
+ * ```
+ */
+export declare const SpeedDialTrigger: React.ForwardRefExoticComponent<Omit<SpeedDialTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;

package/dist/speed-dial/SpeedDialTrigger.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import type { SpeedDialTriggerProps } from './types.js';
+/**
+ * The floating action button: toggles the fan on click, opens it with the
+ * arrow keys along the fan's axis, and doubles as the positioning anchor for
+ * `SpeedDialContent`. Sets `aria-haspopup="menu"`, `aria-expanded`,
+ * `aria-controls`, `data-state` (`open`/`closed`) and `data-direction`, the
+ * last so the icon can rotate from CSS alone.
+ *
+ * With `openOnHover` on the root it also opens on pointer-enter (never for
+ * touch pointers, which have no hover) and starts the close countdown on
+ * pointer-leave.
+ *
+ * Give it an accessible name. A speed dial trigger is usually a bare `+`
+ * glyph, which tells a screen-reader user nothing about what it opens.
+ *
+ * @example
+ * ```tsx
+ * <SpeedDialTrigger aria-label="Quick actions">
+ *   <PlusIcon aria-hidden />
+ * </SpeedDialTrigger>
+ * ```
+ */
+export declare const SpeedDialTrigger: React.ForwardRefExoticComponent<Omit<SpeedDialTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;

package/dist/speed-dial/index.d.cts

@@ -0,0 +1,7 @@
+export { SpeedDial } from './SpeedDial.cjs';
+export { SpeedDialTrigger } from './SpeedDialTrigger.cjs';
+export { SpeedDialPortal } from './SpeedDialPortal.cjs';
+export { SpeedDialContent } from './SpeedDialContent.cjs';
+export { SpeedDialItem } from './SpeedDialItem.cjs';
+export { SpeedDialItemLabel } from './SpeedDialItemLabel.cjs';
+export type { SpeedDialProps, SpeedDialTriggerProps, SpeedDialPortalProps, SpeedDialContentProps, SpeedDialItemProps, SpeedDialItemLabelProps, SpeedDialDirection, } from './types.cjs';

package/dist/speed-dial/index.d.ts

@@ -0,0 +1,7 @@
+export { SpeedDial } from './SpeedDial.js';
+export { SpeedDialTrigger } from './SpeedDialTrigger.js';
+export { SpeedDialPortal } from './SpeedDialPortal.js';
+export { SpeedDialContent } from './SpeedDialContent.js';
+export { SpeedDialItem } from './SpeedDialItem.js';
+export { SpeedDialItemLabel } from './SpeedDialItemLabel.js';
+export type { SpeedDialProps, SpeedDialTriggerProps, SpeedDialPortalProps, SpeedDialContentProps, SpeedDialItemProps, SpeedDialItemLabelProps, SpeedDialDirection, } from './types.js';

package/dist/speed-dial/types.d.cts

@@ -0,0 +1,168 @@
+import type * as React from 'react';
+import type { PopperContentProps } from '../utils/popper.cjs';
+import type { PortalProps } from '../utils/portal.cjs';
+import type { PrimitivePropsWithRef } from '../utils/primitive.cjs';
+import type { FocusOutsideEvent, InteractOutsideEvent } from '../utils/useDismiss.cjs';
+/**
+ * Which way the actions fan out from the trigger. Physical, not logical: a
+ * speed dial is anchored to a corner of the viewport, and the corner does not
+ * move under `dir="rtl"` — only the arrow keys that walk the fan do, which
+ * `SpeedDialContent` resolves for itself.
+ */
+export type SpeedDialDirection = 'up' | 'down' | 'left' | 'right';
+/** @internal Shared state distributed from {@link SpeedDial} to its parts via context. Not part of the public API. */
+export interface SpeedDialContextValue {
+    triggerRef: React.RefObject<HTMLButtonElement | null>;
+    contentRef: React.RefObject<HTMLDivElement | null>;
+    contentId: string;
+    open: boolean;
+    /** Whether the content should be in the DOM — stays true through an exit animation after `open` goes false. */
+    mounted: boolean;
+    direction: SpeedDialDirection;
+    disabled: boolean;
+    openOnHover: boolean;
+    /** Guarded setter: a disabled speed dial never opens, whichever path asked. */
+    onOpenChange: (open: boolean) => void;
+    /** Pointer entered the trigger or the content — cancels any pending hover close. */
+    onPointerEnter: () => void;
+    /** Pointer left the trigger or the content — schedules the hover close. */
+    onPointerLeave: () => void;
+}
+/** @internal Wires a {@link SpeedDialItemLabel} to the `aria-labelledby` of its {@link SpeedDialItem}. Not part of the public API. */
+export interface SpeedDialItemContextValue {
+    labelId: string | undefined;
+    setLabelId: (id: string | undefined) => void;
+}
+/** Props for the {@link SpeedDial} root. */
+export interface SpeedDialProps {
+    /**
+     * The trigger and portal — the fan's own DOM (content, items) is rendered
+     * by {@link SpeedDialPortal} elsewhere.
+     * @default undefined — renders nothing if omitted.
+     */
+    children?: React.ReactNode;
+    /**
+     * Whether the actions are revealed, for controlled usage. Pair with `onOpenChange`.
+     * @default undefined — uncontrolled, tracks its own open state internally.
+     */
+    open?: boolean;
+    /**
+     * Whether the actions are revealed initially, for uncontrolled usage.
+     * @default false — the dial starts collapsed to just its trigger.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Fires with the new open state whenever the dial opens or closes, controlled or not.
+     * @default undefined — no-op if omitted.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Fires with the new open state once the change has finished on screen —
+     * after `SpeedDialContent`'s enter or exit animation ends, or as soon as it
+     * has settled when the content declares no animation. Use it for work that
+     * must not race the transition; use `onOpenChange` for work that must not
+     * wait for it.
+     * @default undefined — no-op if omitted.
+     */
+    onOpenChangeComplete?: (open: boolean) => void;
+    /**
+     * Which way the actions fan out from the trigger. Decides the side the
+     * content is positioned on, the axis the arrow keys walk, and the
+     * `data-direction` attribute the stagger CSS reads.
+     * @default 'up' — the usual bottom-right floating action button, whose actions can only go upward.
+     */
+    direction?: SpeedDialDirection;
+    /**
+     * Also open on pointer-enter of the trigger, not only on click. The dial
+     * still opens on click and keyboard either way; this only adds the hover
+     * path, which touch pointers never take.
+     * @default false — hover reveals nothing, so a pointer merely crossing the button cannot fire actions by accident.
+     */
+    openOnHover?: boolean;
+    /**
+     * Milliseconds the dial stays open after the pointer leaves the trigger or
+     * the content. The gap between the trigger and the first action is dead
+     * space the pointer has to cross, so closing on the first `pointerleave`
+     * would snap the menu shut mid-travel; re-entering either element within
+     * this window cancels the pending close. Only consulted when `openOnHover`
+     * is set.
+     * @default 300 — long enough to cross a normal trigger-to-item gap, short enough not to feel stuck open.
+     */
+    hoverCloseDelay?: number;
+    /**
+     * Blocks the dial from opening by any route — click, hover, or keyboard —
+     * and marks the trigger natively disabled.
+     * @default false
+     */
+    disabled?: boolean;
+}
+/** Props for {@link SpeedDialTrigger}, the floating action button that reveals the actions and anchors their position. */
+export interface SpeedDialTriggerProps extends PrimitivePropsWithRef<'button'> {
+}
+/** Props for {@link SpeedDialPortal}, which teleports the actions to `document.body`. */
+export interface SpeedDialPortalProps extends PortalProps {
+    /**
+     * Render the portal even while the dial is closed, instead of unmounting
+     * it. Only needed to keep the content in the DOM permanently — an exit
+     * animation is already waited out without this.
+     * @default false
+     */
+    forceMount?: boolean;
+}
+/**
+ * Props for {@link SpeedDialContent}, the fanned-out action list. Extends the
+ * shared popper positioning props (`align`, `sideOffset`, `alignOffset`,
+ * `avoidCollisions`, `collisionPadding`, `collisionBoundary`) — but not
+ * `side`, which the root's `direction` owns.
+ */
+export interface SpeedDialContentProps extends Omit<PopperContentProps, 'side'> {
+    /**
+     * Keep the actions mounted even while the dial is closed. Only needed to
+     * keep them in the DOM permanently — an exit animation is already waited
+     * out without this.
+     * @default false
+     */
+    forceMount?: boolean;
+    /**
+     * Whether arrow-key navigation wraps from the last action back to the first (and vice versa).
+     * @default true
+     */
+    loop?: boolean;
+    /**
+     * Fires when Escape is pressed while the dial is open. Call `event.preventDefault()` to stop it from closing.
+     * @default undefined — no-op if omitted.
+     */
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    /**
+     * Fires on pointer-down outside the content. Call `event.preventDefault()` to stop the dial from closing.
+     * @default undefined — no-op if omitted.
+     */
+    onPointerDownOutside?: (event: PointerEvent) => void;
+    /**
+     * Fires when focus moves to an element outside the content. Call `event.preventDefault()` to stop the dial from closing. Receives a cancelable stand-in carrying the original `focusin` as its `detail`, since `focusin` itself cannot be canceled.
+     * @default undefined — no-op if omitted.
+     */
+    onFocusOutside?: (event: FocusOutsideEvent) => void;
+    /**
+     * Fires for either kind of outside interaction — pointer-down or focus — immediately before the specific handler above and with the same event, so one `event.preventDefault()` here vetoes the dismissal whichever way it was triggered.
+     * @default undefined — no-op if omitted.
+     */
+    onInteractOutside?: (event: InteractOutsideEvent) => void;
+}
+/** Props for a single {@link SpeedDialItem}, one action in the fan. */
+export interface SpeedDialItemProps extends Omit<PrimitivePropsWithRef<'div'>, 'onSelect'> {
+    /**
+     * Excludes the action from arrow-key navigation and blocks selection. It
+     * keeps its slot in the fan, so the actions around it do not shuffle.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Called when the action is activated by click, Enter, or Space. `event.preventDefault()` keeps the dial open.
+     * @default undefined — no-op if omitted.
+     */
+    onSelect?: (event: Event) => void;
+}
+/** Props for {@link SpeedDialItemLabel}, the visible text naming its {@link SpeedDialItem}. */
+export interface SpeedDialItemLabelProps extends PrimitivePropsWithRef<'span'> {
+}

package/dist/speed-dial/types.d.ts

@@ -0,0 +1,168 @@
+import type * as React from 'react';
+import type { PopperContentProps } from '../utils/popper.js';
+import type { PortalProps } from '../utils/portal.js';
+import type { PrimitivePropsWithRef } from '../utils/primitive.js';
+import type { FocusOutsideEvent, InteractOutsideEvent } from '../utils/useDismiss.js';
+/**
+ * Which way the actions fan out from the trigger. Physical, not logical: a
+ * speed dial is anchored to a corner of the viewport, and the corner does not
+ * move under `dir="rtl"` — only the arrow keys that walk the fan do, which
+ * `SpeedDialContent` resolves for itself.
+ */
+export type SpeedDialDirection = 'up' | 'down' | 'left' | 'right';
+/** @internal Shared state distributed from {@link SpeedDial} to its parts via context. Not part of the public API. */
+export interface SpeedDialContextValue {
+    triggerRef: React.RefObject<HTMLButtonElement | null>;
+    contentRef: React.RefObject<HTMLDivElement | null>;
+    contentId: string;
+    open: boolean;
+    /** Whether the content should be in the DOM — stays true through an exit animation after `open` goes false. */
+    mounted: boolean;
+    direction: SpeedDialDirection;
+    disabled: boolean;
+    openOnHover: boolean;
+    /** Guarded setter: a disabled speed dial never opens, whichever path asked. */
+    onOpenChange: (open: boolean) => void;
+    /** Pointer entered the trigger or the content — cancels any pending hover close. */
+    onPointerEnter: () => void;
+    /** Pointer left the trigger or the content — schedules the hover close. */
+    onPointerLeave: () => void;
+}
+/** @internal Wires a {@link SpeedDialItemLabel} to the `aria-labelledby` of its {@link SpeedDialItem}. Not part of the public API. */
+export interface SpeedDialItemContextValue {
+    labelId: string | undefined;
+    setLabelId: (id: string | undefined) => void;
+}
+/** Props for the {@link SpeedDial} root. */
+export interface SpeedDialProps {
+    /**
+     * The trigger and portal — the fan's own DOM (content, items) is rendered
+     * by {@link SpeedDialPortal} elsewhere.
+     * @default undefined — renders nothing if omitted.
+     */
+    children?: React.ReactNode;
+    /**
+     * Whether the actions are revealed, for controlled usage. Pair with `onOpenChange`.
+     * @default undefined — uncontrolled, tracks its own open state internally.
+     */
+    open?: boolean;
+    /**
+     * Whether the actions are revealed initially, for uncontrolled usage.
+     * @default false — the dial starts collapsed to just its trigger.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Fires with the new open state whenever the dial opens or closes, controlled or not.
+     * @default undefined — no-op if omitted.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Fires with the new open state once the change has finished on screen —
+     * after `SpeedDialContent`'s enter or exit animation ends, or as soon as it
+     * has settled when the content declares no animation. Use it for work that
+     * must not race the transition; use `onOpenChange` for work that must not
+     * wait for it.
+     * @default undefined — no-op if omitted.
+     */
+    onOpenChangeComplete?: (open: boolean) => void;
+    /**
+     * Which way the actions fan out from the trigger. Decides the side the
+     * content is positioned on, the axis the arrow keys walk, and the
+     * `data-direction` attribute the stagger CSS reads.
+     * @default 'up' — the usual bottom-right floating action button, whose actions can only go upward.
+     */
+    direction?: SpeedDialDirection;
+    /**
+     * Also open on pointer-enter of the trigger, not only on click. The dial
+     * still opens on click and keyboard either way; this only adds the hover
+     * path, which touch pointers never take.
+     * @default false — hover reveals nothing, so a pointer merely crossing the button cannot fire actions by accident.
+     */
+    openOnHover?: boolean;
+    /**
+     * Milliseconds the dial stays open after the pointer leaves the trigger or
+     * the content. The gap between the trigger and the first action is dead
+     * space the pointer has to cross, so closing on the first `pointerleave`
+     * would snap the menu shut mid-travel; re-entering either element within
+     * this window cancels the pending close. Only consulted when `openOnHover`
+     * is set.
+     * @default 300 — long enough to cross a normal trigger-to-item gap, short enough not to feel stuck open.
+     */
+    hoverCloseDelay?: number;
+    /**
+     * Blocks the dial from opening by any route — click, hover, or keyboard —
+     * and marks the trigger natively disabled.
+     * @default false
+     */
+    disabled?: boolean;
+}
+/** Props for {@link SpeedDialTrigger}, the floating action button that reveals the actions and anchors their position. */
+export interface SpeedDialTriggerProps extends PrimitivePropsWithRef<'button'> {
+}
+/** Props for {@link SpeedDialPortal}, which teleports the actions to `document.body`. */
+export interface SpeedDialPortalProps extends PortalProps {
+    /**
+     * Render the portal even while the dial is closed, instead of unmounting
+     * it. Only needed to keep the content in the DOM permanently — an exit
+     * animation is already waited out without this.
+     * @default false
+     */
+    forceMount?: boolean;
+}
+/**
+ * Props for {@link SpeedDialContent}, the fanned-out action list. Extends the
+ * shared popper positioning props (`align`, `sideOffset`, `alignOffset`,
+ * `avoidCollisions`, `collisionPadding`, `collisionBoundary`) — but not
+ * `side`, which the root's `direction` owns.
+ */
+export interface SpeedDialContentProps extends Omit<PopperContentProps, 'side'> {
+    /**
+     * Keep the actions mounted even while the dial is closed. Only needed to
+     * keep them in the DOM permanently — an exit animation is already waited
+     * out without this.
+     * @default false
+     */
+    forceMount?: boolean;
+    /**
+     * Whether arrow-key navigation wraps from the last action back to the first (and vice versa).
+     * @default true
+     */
+    loop?: boolean;
+    /**
+     * Fires when Escape is pressed while the dial is open. Call `event.preventDefault()` to stop it from closing.
+     * @default undefined — no-op if omitted.
+     */
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    /**
+     * Fires on pointer-down outside the content. Call `event.preventDefault()` to stop the dial from closing.
+     * @default undefined — no-op if omitted.
+     */
+    onPointerDownOutside?: (event: PointerEvent) => void;
+    /**
+     * Fires when focus moves to an element outside the content. Call `event.preventDefault()` to stop the dial from closing. Receives a cancelable stand-in carrying the original `focusin` as its `detail`, since `focusin` itself cannot be canceled.
+     * @default undefined — no-op if omitted.
+     */
+    onFocusOutside?: (event: FocusOutsideEvent) => void;
+    /**
+     * Fires for either kind of outside interaction — pointer-down or focus — immediately before the specific handler above and with the same event, so one `event.preventDefault()` here vetoes the dismissal whichever way it was triggered.
+     * @default undefined — no-op if omitted.
+     */
+    onInteractOutside?: (event: InteractOutsideEvent) => void;
+}
+/** Props for a single {@link SpeedDialItem}, one action in the fan. */
+export interface SpeedDialItemProps extends Omit<PrimitivePropsWithRef<'div'>, 'onSelect'> {
+    /**
+     * Excludes the action from arrow-key navigation and blocks selection. It
+     * keeps its slot in the fan, so the actions around it do not shuffle.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Called when the action is activated by click, Enter, or Space. `event.preventDefault()` keeps the dial open.
+     * @default undefined — no-op if omitted.
+     */
+    onSelect?: (event: Event) => void;
+}
+/** Props for {@link SpeedDialItemLabel}, the visible text naming its {@link SpeedDialItem}. */
+export interface SpeedDialItemLabelProps extends PrimitivePropsWithRef<'span'> {
+}

package/dist/spinner/Spinner.cjs

@@ -0,0 +1 @@
+"use strict";var d=Object.create;var t=Object.defineProperty;var v=Object.getOwnPropertyDescriptor;var P=Object.getOwnPropertyNames;var y=Object.getPrototypeOf,S=Object.prototype.hasOwnProperty;var c=(r,e)=>{for(var i in e)t(r,i,{get:e[i],enumerable:!0})},a=(r,e,i,p)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of P(e))!S.call(r,o)&&o!==i&&t(r,o,{get:()=>e[o],enumerable:!(p=v(e,o))||p.enumerable});return r};var x=(r,e,i)=>(i=r!=null?d(y(r)):{},a(e||!r||!r.__esModule?t(i,"default",{value:r,enumerable:!0}):i,r)),R=r=>a(t({},"__esModule",{value:!0}),r);var L={};c(L,{Spinner:()=>f});module.exports=R(L);var m=x(require("react"),1),n=require("../utils/part.cjs"),s=require("../utils/primitive.cjs"),l=require("react/jsx-runtime"),f=m.forwardRef(({label:r="Loading",children:e,...i},p)=>(0,l.jsx)(s.Primitive.div,{role:"status","aria-live":"polite","aria-label":r,...i,...(0,n.skdxPart)("spinner","root",i.className),ref:p,children:e}));f.displayName="Spinner";0&&(module.exports={Spinner});

package/dist/spinner/Spinner.d.cts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import type { SpinnerProps } from './types.cjs';
+/**
+ * Headless loading indicator. Renders `role="status"` with
+ * `aria-live="polite"` and `aria-label` set to `label`. Renders its own
+ * `children` if given (a custom spinner graphic); otherwise renders nothing
+ * extra and relies on the brand layer to draw the spinner via CSS (e.g. an
+ * `::before` animation).
+ *
+ * @example
+ * ```tsx
+ * <Spinner label="Loading results" />
+ * ```
+ */
+export declare const Spinner: React.ForwardRefExoticComponent<Omit<SpinnerProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/spinner/Spinner.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import type { SpinnerProps } from './types.js';
+/**
+ * Headless loading indicator. Renders `role="status"` with
+ * `aria-live="polite"` and `aria-label` set to `label`. Renders its own
+ * `children` if given (a custom spinner graphic); otherwise renders nothing
+ * extra and relies on the brand layer to draw the spinner via CSS (e.g. an
+ * `::before` animation).
+ *
+ * @example
+ * ```tsx
+ * <Spinner label="Loading results" />
+ * ```
+ */
+export declare const Spinner: React.ForwardRefExoticComponent<Omit<SpinnerProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/spinner/Spinner.js

@@ -0,0 +1 @@
+import*as e from"react";import{skdxPart as t}from"../utils/part.js";import{Primitive as a}from"../utils/primitive.js";import{jsx as n}from"react/jsx-runtime";var m=e.forwardRef(({label:i="Loading",children:o,...r},p)=>n(a.div,{role:"status","aria-live":"polite","aria-label":i,...r,...t("spinner","root",r.className),ref:p,children:o}));m.displayName="Spinner";export{m as Spinner};

package/dist/spinner/index.d.cts

@@ -0,0 +1,2 @@
+export * from './Spinner.cjs';
+export type { SpinnerProps } from './types.cjs';

package/dist/spinner/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Spinner.js';
+export type { SpinnerProps } from './types.js';

package/dist/spinner/types.d.cts

@@ -0,0 +1,9 @@
+import type { PrimitivePropsWithRef } from '../utils/primitive.cjs';
+/** Props for the {@link Spinner} root. */
+export interface SpinnerProps extends PrimitivePropsWithRef<'div'> {
+    /**
+     * Accessible label announced to screen readers while the spinner is visible.
+     * @default 'Loading'
+     */
+    label?: string;
+}

package/dist/spinner/types.d.ts

@@ -0,0 +1,9 @@
+import type { PrimitivePropsWithRef } from '../utils/primitive.js';
+/** Props for the {@link Spinner} root. */
+export interface SpinnerProps extends PrimitivePropsWithRef<'div'> {
+    /**
+     * Accessible label announced to screen readers while the spinner is visible.
+     * @default 'Loading'
+     */
+    label?: string;
+}

package/dist/split-button/SplitButton.cjs

@@ -0,0 +1 @@
+"use strict";var x=Object.create;var i=Object.defineProperty;var A=Object.getOwnPropertyDescriptor;var N=Object.getOwnPropertyNames;var v=Object.getPrototypeOf,k=Object.prototype.hasOwnProperty;var w=(t,o)=>{for(var r in o)i(t,r,{get:o[r],enumerable:!0})},s=(t,o,r,l)=>{if(o&&typeof o=="object"||typeof o=="function")for(let p of N(o))!k.call(t,p)&&p!==r&&i(t,p,{get:()=>o[p],enumerable:!(l=A(o,p))||l.enumerable});return t};var e=(t,o,r)=>(r=t!=null?x(v(t)):{},s(o||!t||!t.__esModule?i(r,"default",{value:t,enumerable:!0}):r,t)),E=t=>s(i({},"__esModule",{value:!0}),t);var H={};w(H,{SplitButton:()=>B,SplitButtonAction:()=>m,SplitButtonTrigger:()=>n});module.exports=E(H);var a=e(require("react"),1),u=require("../utils/part.cjs"),f=require("../utils/primitive.cjs"),S=require("react/jsx-runtime"),B=a.forwardRef((t,o)=>(0,S.jsx)(f.Primitive.div,{role:"group",...t,...(0,u.skdxPart)("split-button","root",t.className),ref:o}));B.displayName="SplitButton";var c=e(require("react"),1),g=require("../utils/part.cjs"),P=require("../utils/primitive.cjs"),y=require("react/jsx-runtime"),m=c.forwardRef((t,o)=>(0,y.jsx)(P.Primitive.button,{type:"button",...t,...(0,g.skdxPart)("split-button","action",t.className),ref:o}));m.displayName="SplitButtonAction";var d=e(require("react"),1),R=require("../utils/part.cjs"),T=require("../utils/primitive.cjs"),b=require("react/jsx-runtime"),n=d.forwardRef((t,o)=>(0,b.jsx)(T.Primitive.button,{type:"button","aria-haspopup":"menu",...t,...(0,R.skdxPart)("split-button","trigger",t.className),ref:o}));n.displayName="SplitButtonTrigger";0&&(module.exports={SplitButton,SplitButtonAction,SplitButtonTrigger});

package/dist/split-button/SplitButton.d.cts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import type { SplitButtonProps } from './types.cjs';
+/**
+ * Groups a primary action button with a small trigger that opens a menu of
+ * related actions: renders a `<div role="group">`. Deliberately
+ * state-less — it owns no open/menu state of its own; `SplitButtonTrigger`
+ * is wrapped with `asChild` by a `DropdownMenuTrigger` (or any other menu's
+ * trigger), and the menu owns its own open/close behavior.
+ *
+ * @example
+ * ```tsx
+ * <SplitButton>
+ *   <SplitButtonAction onClick={deploy}>Deploy</SplitButtonAction>
+ *   <DropdownMenu>
+ *     <DropdownMenuTrigger asChild>
+ *       <SplitButtonTrigger aria-label="More deploy options" />
+ *     </DropdownMenuTrigger>
+ *     <DropdownMenuPortal>
+ *       <DropdownMenuContent>
+ *         <DropdownMenuItem onSelect={rollback}>Roll back</DropdownMenuItem>
+ *       </DropdownMenuContent>
+ *     </DropdownMenuPortal>
+ *   </DropdownMenu>
+ * </SplitButton>
+ * ```
+ */
+export declare const SplitButton: React.ForwardRefExoticComponent<Omit<SplitButtonProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/split-button/SplitButton.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import type { SplitButtonProps } from './types.js';
+/**
+ * Groups a primary action button with a small trigger that opens a menu of
+ * related actions: renders a `<div role="group">`. Deliberately
+ * state-less — it owns no open/menu state of its own; `SplitButtonTrigger`
+ * is wrapped with `asChild` by a `DropdownMenuTrigger` (or any other menu's
+ * trigger), and the menu owns its own open/close behavior.
+ *
+ * @example
+ * ```tsx
+ * <SplitButton>
+ *   <SplitButtonAction onClick={deploy}>Deploy</SplitButtonAction>
+ *   <DropdownMenu>
+ *     <DropdownMenuTrigger asChild>
+ *       <SplitButtonTrigger aria-label="More deploy options" />
+ *     </DropdownMenuTrigger>
+ *     <DropdownMenuPortal>
+ *       <DropdownMenuContent>
+ *         <DropdownMenuItem onSelect={rollback}>Roll back</DropdownMenuItem>
+ *       </DropdownMenuContent>
+ *     </DropdownMenuPortal>
+ *   </DropdownMenu>
+ * </SplitButton>
+ * ```
+ */
+export declare const SplitButton: React.ForwardRefExoticComponent<Omit<SplitButtonProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/split-button/SplitButton.js

@@ -0,0 +1 @@
+import*as r from"react";import{skdxPart as n}from"../utils/part.js";import{Primitive as l}from"../utils/primitive.js";import{jsx as a}from"react/jsx-runtime";var s=r.forwardRef((t,o)=>a(l.div,{role:"group",...t,...n("split-button","root",t.className),ref:o}));s.displayName="SplitButton";import*as p from"react";import{skdxPart as u}from"../utils/part.js";import{Primitive as f}from"../utils/primitive.js";import{jsx as B}from"react/jsx-runtime";var i=p.forwardRef((t,o)=>B(f.button,{type:"button",...t,...u("split-button","action",t.className),ref:o}));i.displayName="SplitButtonAction";import*as e from"react";import{skdxPart as S}from"../utils/part.js";import{Primitive as c}from"../utils/primitive.js";import{jsx as g}from"react/jsx-runtime";var m=e.forwardRef((t,o)=>g(c.button,{type:"button","aria-haspopup":"menu",...t,...S("split-button","trigger",t.className),ref:o}));m.displayName="SplitButtonTrigger";export{s as SplitButton,i as SplitButtonAction,m as SplitButtonTrigger};

package/dist/split-button/SplitButtonAction.d.cts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import type { SplitButtonActionProps } from './types.cjs';
+/**
+ * The primary action button within a {@link SplitButton}: renders a
+ * `<button type="button">`.
+ *
+ * @example
+ * ```tsx
+ * <SplitButtonAction onClick={deploy}>Deploy</SplitButtonAction>
+ * ```
+ */
+export declare const SplitButtonAction: React.ForwardRefExoticComponent<Omit<SplitButtonActionProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;