@vizejs/ui 0.387.0 → 0.388.0

package/dist/sortable-DQl92bwo.d.mts

@@ -0,0 +1,206 @@
+import { S as DropTargetRect, a as DragSourceProps, g as DragPointerType } from "./drag-and-drop-controller-types-DoTSR_aM.mjs";
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/families/interaction/sortable/sortable-types.d.ts
+/** Spatial arrangement of one sortable container. */
+type SortableOrientation = "grid" | "horizontal" | "vertical";
+/** Resolved writing direction used by horizontal and grid arrow keys. */
+type SortableDirection = "ltr" | "rtl";
+/** Drop position relative to the item under the drag. */
+type SortablePosition = "after" | "before" | "inside";
+/** Lifecycle phases emitted by a sortable controller. */
+type SortableEventType = "sortcancel" | "sortcommit" | "sortpreview" | "sortstart";
+/** Immutable snapshot shared by every sortable lifecycle phase. */
+interface SortableEvent<Type extends SortableEventType = SortableEventType> {
+  /** Lifecycle phase represented by this immutable snapshot. */
+  readonly type: Type;
+  /** Input family that owns this sort. */
+  readonly pointerType: DragPointerType;
+  /** Key of the item being sorted. */
+  readonly key: string;
+  /**
+   * Zero-based index the move starts from. `sortstart`, `sortpreview`, and
+   * `sortcancel` report the item's current index; `sortcommit` reports the
+   * index captured when the item was picked up.
+   */
+  readonly fromIndex: number;
+  /**
+   * Zero-based destination index. `sortcancel` reports the index the item must
+   * return to; an `"inside"` move reports the receiving item's index.
+   */
+  readonly toIndex: number;
+  /** Key of the item the move is relative to, or `null` for index-only moves. */
+  readonly overKey: string | null;
+  /** Position relative to `overKey`, or `null` for index-only moves. */
+  readonly position: SortablePosition | null;
+  /** Native event responsible for this phase, or `null` for manual settlement. */
+  readonly originalEvent: Event | null;
+}
+/** Snapshot emitted once when an item is picked up. */
+type SortStartEvent = SortableEvent<"sortstart">;
+/** Snapshot emitted when the projected destination changes before a drop. */
+type SortPreviewEvent = SortableEvent<"sortpreview">;
+/** Snapshot emitted when a completed drop commits the move. */
+type SortCommitEvent = SortableEvent<"sortcommit">;
+/** Snapshot emitted when a sort is canceled and the item must return. */
+type SortCancelEvent = SortableEvent<"sortcancel">;
+/** Reactive indicator state for the projected destination. */
+interface SortableIndicatorState {
+  /** Key of the item the indicator is relative to. */
+  readonly key: string;
+  /** Position relative to `key`. */
+  readonly position: SortablePosition;
+  /** Zero-based projected destination index. */
+  readonly toIndex: number;
+  /** Rectangle of the reference item, or `null` when unmeasurable. */
+  readonly rect: DropTargetRect | null;
+  /** Zero-thickness line along the drop edge; `null` for `"inside"` drops. */
+  readonly line: DropTargetRect | null;
+}
+/** Context handed to announcement builders before speaking to assistive tech. */
+interface SortableAnnouncementContext {
+  readonly pointerType: DragPointerType;
+  readonly key: string;
+  readonly label: string;
+  /** Zero-based indexes; built-in messages render them one-based. */
+  readonly fromIndex: number;
+  readonly toIndex: number;
+  readonly count: number;
+  readonly overKey: string | null;
+  readonly overLabel: string | null;
+  readonly position: SortablePosition | null;
+}
+/** Localizable builders for grab, move, drop, and cancel announcements. */
+interface SortableAnnouncements {
+  /** Spoken when an item is picked up. Return `null` to stay silent. */
+  readonly grab?: (context: SortableAnnouncementContext) => string | null;
+  /** Spoken when the projected destination changes. */
+  readonly move?: (context: SortableAnnouncementContext) => string | null;
+  /** Spoken after a committed drop. */
+  readonly drop?: (context: SortableAnnouncementContext) => string | null;
+  /** Spoken after a canceled sort. */
+  readonly cancel?: (context: SortableAnnouncementContext) => string | null;
+}
+/** Options shared by `createSortable` and `useSortable`. */
+interface SortableOptions {
+  /**
+   * Spatial arrangement deciding drop edges and arrow-key geometry.
+   *
+   * @default "vertical"
+   */
+  readonly orientation?: MaybeRefOrGetter<SortableOrientation | undefined>;
+  /**
+   * Column count used by grid arrow-key geometry.
+   * The resolved value must be a finite integer greater than zero.
+   *
+   * @default 1
+   */
+  readonly columns?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Writing direction that flips horizontal and grid arrow keys.
+   *
+   * @default "ltr"
+   */
+  readonly direction?: MaybeRefOrGetter<SortableDirection | undefined>;
+  /**
+   * Allow `"inside"` drops so nested trees can re-parent items.
+   *
+   * @default false
+   */
+  readonly nesting?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Suppress new sorts and cancel the active sort on its next event.
+   *
+   * @default false
+   */
+  readonly isDisabled?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Chebyshev distance in CSS pixels a pointer must travel before a sort
+   * starts. The resolved value must be finite and greater than or equal to zero.
+   *
+   * @default 4
+   */
+  readonly startDistance?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Overrides merged over the built-in English announcement builders.
+   *
+   * @default built-in English announcements
+   */
+  readonly announcements?: SortableAnnouncements;
+  /** Called exactly once when an item is picked up. */
+  readonly onSortStart?: (event: SortStartEvent) => void;
+  /** Called when the projected destination changes before a drop. */
+  readonly onSortPreview?: (event: SortPreviewEvent) => void;
+  /** Called exactly once when a completed drop commits the move. */
+  readonly onSortCommit?: (event: SortCommitEvent) => void;
+  /** Called exactly once when a sort is canceled; the item must return. */
+  readonly onSortCancel?: (event: SortCancelEvent) => void;
+}
+/** Declaration of one sortable item owned by a controller. */
+interface SortableItemOptions {
+  /** Stable key unique among this controller's items. */
+  readonly key: string;
+  /** Element that owns this item's geometry and document order. */
+  readonly element: MaybeRefOrGetter<Element | null | undefined>;
+  /**
+   * Viewport rectangle used for hit testing and indicator geometry.
+   *
+   * @default the element's `getBoundingClientRect()`
+   */
+  readonly getRect?: () => DropTargetRect | DOMRectReadOnly | null | undefined;
+  /**
+   * Human-readable name used by announcements.
+   *
+   * @default the item key
+   */
+  readonly label?: MaybeRefOrGetter<string | undefined>;
+  /**
+   * Suppress sorting this item; it remains a valid drop reference.
+   *
+   * @default false
+   */
+  readonly isDisabled?: MaybeRefOrGetter<boolean | undefined>;
+}
+/** Live registration owned by one sortable item. */
+interface SortableItemRegistration {
+  /** Key this registration was created with. */
+  readonly key: string;
+  /** Whether this item owns the active sort. */
+  readonly isDragging: Readonly<ShallowRef<boolean>>;
+  /** Stable native handlers to spread or merge onto one item or its handle. */
+  readonly itemProps: Readonly<DragSourceProps>;
+  /** Remove the item; its active sort is canceled first. */
+  readonly dispose: () => void;
+}
+/** Stateful sortable coordinator with explicit ownership and disposal. */
+interface SortableController {
+  /** Whether a pointer or keyboard sort is active. */
+  readonly isSorting: Readonly<ShallowRef<boolean>>;
+  /** Key of the item that owns the active sort, or `null`. */
+  readonly activeKey: Readonly<ShallowRef<string | null>>;
+  /** Indicator state for the projected destination, or `null`. */
+  readonly indicator: Readonly<ShallowRef<SortableIndicatorState | null>>;
+  /** Register one sortable item. Duplicate keys are rejected. */
+  readonly registerItem: (options: SortableItemOptions) => SortableItemRegistration;
+  /**
+   * Cancel the active sort, including one that has not started yet.
+   *
+   * @returns `true` when an owned sort was settled.
+   * @throws An error carrying `VIZE_UI_SORTABLE_DISPOSED` after disposal.
+   */
+  readonly cancel: () => boolean;
+  /** Release listeners, the live region, and reactive state without callbacks. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/families/interaction/sortable/sortable-internal.d.ts
+/** Built-in English announcement builders; consumers override to localize. */
+declare const defaultSortableAnnouncements: Required<SortableAnnouncements>;
+//#endregion
+//#region src/families/interaction/sortable/sortable.d.ts
+/** Create an SSR-safe sortable coordinator for lists, grids, and trees. */
+declare function createSortable(options?: SortableOptions): SortableController;
+/** Create a sortable coordinator disposed with the current Vue effect scope. */
+declare function useSortable(options?: SortableOptions): SortableController;
+//#endregion
+export { SortableOptions as _, SortCommitEvent as a, SortableAnnouncementContext as c, SortableDirection as d, SortableEvent as f, SortableItemRegistration as g, SortableItemOptions as h, SortCancelEvent as i, SortableAnnouncements as l, SortableIndicatorState as m, useSortable as n, SortPreviewEvent as o, SortableEventType as p, defaultSortableAnnouncements as r, SortStartEvent as s, createSortable as t, SortableController as u, SortableOrientation as v, SortablePosition as y };

package/dist/sortable.d.mts

@@ -0,0 +1,2 @@
+import { _ as SortableOptions, a as SortCommitEvent, c as SortableAnnouncementContext, d as SortableDirection, f as SortableEvent, g as SortableItemRegistration, h as SortableItemOptions, i as SortCancelEvent, l as SortableAnnouncements, m as SortableIndicatorState, n as useSortable, o as SortPreviewEvent, p as SortableEventType, r as defaultSortableAnnouncements, s as SortStartEvent, t as createSortable, u as SortableController, v as SortableOrientation, y as SortablePosition } from "./sortable-DQl92bwo.mjs";
+export { type SortCancelEvent, type SortCommitEvent, type SortPreviewEvent, type SortStartEvent, type SortableAnnouncementContext, type SortableAnnouncements, type SortableController, type SortableDirection, type SortableEvent, type SortableEventType, type SortableIndicatorState, type SortableItemOptions, type SortableItemRegistration, type SortableOptions, type SortableOrientation, type SortablePosition, createSortable, defaultSortableAnnouncements, useSortable };

package/dist/sortable.mjs

@@ -0,0 +1,2 @@
+import { n as useSortable, r as defaultSortableAnnouncements, t as createSortable } from "./sortable-BntjgYra.mjs";
+export { createSortable, defaultSortableAnnouncements, useSortable };

package/dist/spacer-Bc0dInvi.mjs

@@ -0,0 +1,117 @@
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { computed, createBlock, defineComponent, mergeProps, openBlock, resolveDynamicComponent, useTemplateRef } from "vue";
+const SPACER_CROSS_AXIS_SIZE = "auto";
+function defaultSpacerDisplay(axis) {
+	return axis === "block" ? "block" : "inline-block";
+}
+function resolveInlineSize(axis, size) {
+	return axis === "inline" || axis === "both" ? size : SPACER_CROSS_AXIS_SIZE;
+}
+function resolveBlockSize(axis, size) {
+	return axis === "block" || axis === "both" ? size : SPACER_CROSS_AXIS_SIZE;
+}
+/** Resolve public spacer props into a native CSS logical-size contract. */
+function resolveSpacerLayout(options) {
+	const axis = options.axis ?? "block";
+	const size = options.size ?? "1rem";
+	const inlineSize = options.inlineSize ?? resolveInlineSize(axis, size);
+	const blockSize = options.blockSize ?? resolveBlockSize(axis, size);
+	const display = options.display ?? defaultSpacerDisplay(axis);
+	return {
+		axis,
+		blockSize,
+		display,
+		inlineSize,
+		state: "sized",
+		style: {
+			"--vize-ui-spacer-block-size": blockSize,
+			"--vize-ui-spacer-inline-size": inlineSize,
+			blockSize: "var(--vize-ui-spacer-block-size)",
+			display,
+			inlineSize: "var(--vize-ui-spacer-inline-size)"
+		}
+	};
+}
+//#endregion
+//#region src/families/layout/spacer/spacer.vue
+var spacer_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "spacer",
+	props: {
+		as: {
+			type: null,
+			required: false,
+			default: "span"
+		},
+		axis: {
+			type: String,
+			required: false,
+			default: "block"
+		},
+		size: {
+			type: String,
+			required: false,
+			default: "1rem"
+		},
+		inlineSize: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		blockSize: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		display: {
+			type: String,
+			required: false,
+			default: () => void 0
+		}
+	},
+	setup(__props, { expose: __expose }) {
+		const element = useTemplateRef("element");
+		const layout = computed(() => resolveSpacerLayout({
+			axis: __props.axis,
+			blockSize: __props.blockSize,
+			display: __props.display,
+			inlineSize: __props.inlineSize,
+			size: __props.size
+		}));
+		const axisState = computed(() => layout.value.axis);
+		const blockSizeState = computed(() => layout.value.blockSize);
+		const displayState = computed(() => layout.value.display);
+		const inlineSizeState = computed(() => layout.value.inlineSize);
+		const spacerState = computed(() => layout.value.state);
+		const spacerStyle = computed(() => layout.value.style);
+		const intrinsicProps = computed(() => ({ style: spacerStyle.value }));
+		__expose({
+			axis: axisState,
+			blockSize: blockSizeState,
+			display: displayState,
+			element,
+			inlineSize: inlineSizeState
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(__props.as), mergeProps({
+				ref_key: "element",
+				ref: element,
+				"aria-hidden": "true",
+				part: "root",
+				"data-vize-ui": "spacer",
+				"data-state": spacerState.value,
+				"data-axis": axisState.value,
+				"data-display": displayState.value,
+				"data-vize-spacer-inline-size": inlineSizeState.value,
+				"data-vize-spacer-block-size": blockSizeState.value
+			}, intrinsicProps.value), null, 16, [
+				"data-state",
+				"data-axis",
+				"data-display",
+				"data-vize-spacer-inline-size",
+				"data-vize-spacer-block-size"
+			]);
+		};
+	}
+}), [["__scopeId", "data-v-95ae3a30"]]);
+//#endregion
+export { spacer_default as t };

package/dist/spacer-DFstG4G-.d.mts

@@ -0,0 +1,105 @@
+import { t as PrimitiveAs } from "./primitive-BE2mdUcw.mjs";
+import { ComponentPublicInstance } from "vue";
+
+//#region src/families/layout/spacer/spacer-types.d.ts
+/** Logical axis controlled by {@link Spacer}. */
+type SpacerAxis = "block" | "inline" | "both";
+/** CSS display modes supported by {@link Spacer}. */
+type SpacerDisplay = "block" | "inline-block" | "flex" | "inline-flex" | "grid" | "inline-grid";
+/** Native CSS length, percentage, keyword, or custom property used by {@link Spacer}. */
+type SpacerSize = string;
+/** Rendered data state for {@link Spacer}. */
+type SpacerState = "sized";
+/** Rendered value exposed by {@link Spacer}. */
+type SpacerElement = Element | ComponentPublicInstance;
+/** Inline style applied to the rendered host for native logical sizing. */
+interface SpacerStyle {
+  /** Native CSS custom property read by the intrinsic inline-size style. */
+  readonly "--vize-ui-spacer-inline-size": SpacerSize;
+  /** Native CSS custom property read by the intrinsic block-size style. */
+  readonly "--vize-ui-spacer-block-size": SpacerSize;
+  /** CSS display mode required for the selected spacer axis. */
+  readonly display: SpacerDisplay;
+  /** Native logical inline size declaration. */
+  readonly inlineSize: string;
+  /** Native logical block size declaration. */
+  readonly blockSize: string;
+}
+/** Resolved layout state published by {@link Spacer}. */
+interface SpacerResolvedLayout {
+  /** Logical axis controlled by the spacer. */
+  readonly axis: SpacerAxis;
+  /** Resolved logical inline size. */
+  readonly inlineSize: SpacerSize;
+  /** Resolved logical block size. */
+  readonly blockSize: SpacerSize;
+  /** CSS display mode applied to the host. */
+  readonly display: SpacerDisplay;
+  /** Rendered data state. */
+  readonly state: SpacerState;
+  /** Native logical-size style object applied to the host. */
+  readonly style: SpacerStyle;
+}
+/** Public instance state exposed by the spacer component. */
+interface SpacerExpose {
+  /** Rendered host element or component instance. */
+  readonly element: SpacerElement | null;
+  /** Logical axis controlled by the spacer. */
+  readonly axis: SpacerAxis;
+  /** Resolved logical inline size. */
+  readonly inlineSize: SpacerSize;
+  /** Resolved logical block size. */
+  readonly blockSize: SpacerSize;
+  /** CSS display mode applied to the host. */
+  readonly display: SpacerDisplay;
+}
+//#endregion
+//#region src/families/layout/spacer/spacer.vue.d.ts
+type __VLS_Props = {
+  /**
+   * Native element, custom element, SVG element, or component to render.
+   *
+   * @default "span"
+   */
+  readonly as?: PrimitiveAs;
+  /**
+   * Logical axis that receives `size` when explicit axis sizes are omitted.
+   *
+   * @default "block"
+   */
+  readonly axis?: SpacerAxis;
+  /**
+   * Native CSS size applied to the selected axis.
+   *
+   * @default "1rem"
+   */
+  readonly size?: SpacerSize;
+  /**
+   * Native CSS logical inline size. Overrides `size` for the inline axis.
+   *
+   * @default undefined
+   */
+  readonly inlineSize?: SpacerSize;
+  /**
+   * Native CSS logical block size. Overrides `size` for the block axis.
+   *
+   * @default undefined
+   */
+  readonly blockSize?: SpacerSize;
+  /**
+   * CSS display mode applied to the spacer host.
+   *
+   * @default "block" for block axis, otherwise "inline-block"
+   */
+  readonly display?: SpacerDisplay;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+  axis: import("vue").ComputedRef<SpacerAxis>;
+  blockSize: import("vue").ComputedRef<string>;
+  display: import("vue").ComputedRef<SpacerDisplay>;
+  element: Readonly<import("vue").ShallowRef<SpacerElement | null>>;
+  inlineSize: import("vue").ComputedRef<string>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+//#endregion
+export { SpacerExpose as a, SpacerState as c, SpacerElement as i, SpacerStyle as l, SpacerAxis as n, SpacerResolvedLayout as o, SpacerDisplay as r, SpacerSize as s, _default as t };

package/dist/spacer.d.mts

@@ -0,0 +1,2 @@
+import { a as SpacerExpose, c as SpacerState, i as SpacerElement, l as SpacerStyle, n as SpacerAxis, o as SpacerResolvedLayout, r as SpacerDisplay, s as SpacerSize, t as _default } from "./spacer-DFstG4G-.mjs";
+export { _default as Spacer, type SpacerAxis, type SpacerDisplay, type SpacerElement, type SpacerExpose, type SpacerResolvedLayout, type SpacerSize, type SpacerState, type SpacerStyle };

package/dist/spacer.mjs

@@ -0,0 +1,2 @@
+import { t as spacer_default } from "./spacer-Bc0dInvi.mjs";
+export { spacer_default as Spacer };

package/dist/{spatial-navigation-CHj9mDZH.d.mts → spatial-navigation-BPVJGSiJ.d.mts}

@@ -1,7 +1,7 @@
-import { l as CollectionKey, p as CollectionRegistry, s as CollectionItem } from "./collection-B_dFZOHO.mjs";
+import { l as CollectionKey, p as CollectionRegistry, s as CollectionItem } from "./collection-BaPf8lgw.mjs";
 import { MaybeRefOrGetter } from "vue";
 
-//#region src/spatial-navigation-types.d.ts
+//#region src/families/interaction/spatial-navigation/spatial-navigation-types.d.ts
 /** Physical direction requested by spatial navigation. */
 type SpatialNavigationDirection = "down" | "left" | "right" | "up";
 /** Candidate ranking behavior aligned with CSS Spatial Navigation Level 1. */
@@ -97,7 +97,7 @@ interface SpatialNavigationController<Key extends CollectionKey> {
   readonly dispose: () => void;
 }
 //#endregion
-//#region src/spatial-navigation.d.ts
+//#region src/families/interaction/spatial-navigation/spatial-navigation.d.ts
 /** Create a geometry-driven, SSR-safe arrow navigation controller. */
 declare function createSpatialNavigation<Key extends CollectionKey, Value>(options: SpatialNavigationOptions<Key, Value>): SpatialNavigationController<Key>;
 /** Create a spatial controller disposed with the current Vue effect scope. */

package/dist/{spatial-navigation-D6-UDavU.mjs → spatial-navigation-DwcUYMyc.mjs}

@@ -1,5 +1,5 @@
 import { getCurrentScope, onScopeDispose, toValue } from "vue";
-//#region src/spatial-navigation-internal.ts
+//#region src/families/interaction/spatial-navigation/spatial-navigation-internal.ts
 const optionDiagnostic = "VIZE_UI_SPATIAL_NAVIGATION_OPTION";
 const rectDiagnostic = "VIZE_UI_SPATIAL_NAVIGATION_RECT";
 function capture(errors, callback) {
@@ -153,7 +153,7 @@ function isEditableDescendant(event) {
 	return false;
 }
 //#endregion
-//#region src/spatial-navigation.ts
+//#region src/families/interaction/spatial-navigation/spatial-navigation.ts
 const disposedDiagnostic = "VIZE_UI_SPATIAL_NAVIGATION_DISPOSED";
 const originDiagnostic = "VIZE_UI_SPATIAL_NAVIGATION_ORIGIN";
 const setupDiagnostic = "VIZE_UI_SPATIAL_NAVIGATION_SETUP";

package/dist/spatial-navigation.d.mts

@@ -1,2 +1,2 @@
-import { a as SpatialNavigationBoundaryBehavior, c as SpatialNavigationDirection, d as SpatialNavigationProps, f as SpatialNavigationRect, i as SpatialNavigationBoundary, l as SpatialNavigationFocusBehavior, n as useSpatialNavigation, o as SpatialNavigationChange, r as SpatialNavigationAlgorithm, s as SpatialNavigationController, t as createSpatialNavigation, u as SpatialNavigationOptions } from "./spatial-navigation-CHj9mDZH.mjs";
+import { a as SpatialNavigationBoundaryBehavior, c as SpatialNavigationDirection, d as SpatialNavigationProps, f as SpatialNavigationRect, i as SpatialNavigationBoundary, l as SpatialNavigationFocusBehavior, n as useSpatialNavigation, o as SpatialNavigationChange, r as SpatialNavigationAlgorithm, s as SpatialNavigationController, t as createSpatialNavigation, u as SpatialNavigationOptions } from "./spatial-navigation-BPVJGSiJ.mjs";
 export { type SpatialNavigationAlgorithm, type SpatialNavigationBoundary, type SpatialNavigationBoundaryBehavior, type SpatialNavigationChange, type SpatialNavigationController, type SpatialNavigationDirection, type SpatialNavigationFocusBehavior, type SpatialNavigationOptions, type SpatialNavigationProps, type SpatialNavigationRect, createSpatialNavigation, useSpatialNavigation };

package/dist/spatial-navigation.mjs

@@ -1,2 +1,2 @@
-import { n as useSpatialNavigation, t as createSpatialNavigation } from "./spatial-navigation-D6-UDavU.mjs";
+import { n as useSpatialNavigation, t as createSpatialNavigation } from "./spatial-navigation-DwcUYMyc.mjs";
 export { createSpatialNavigation, useSpatialNavigation };

package/dist/spinner-JnRs8fp-.d.mts

@@ -0,0 +1,155 @@
+import { t as PrimitiveAs } from "./primitive-BE2mdUcw.mjs";
+import { ComponentPublicInstance, ComputedRef } from "vue";
+
+//#region src/families/feedback/spinner/spinner-types.d.ts
+/** Accessibility role requested by the Spinner primitive. */
+type SpinnerRole = "progressbar" | "status";
+/** Accessibility semantics resolved from Spinner props. */
+type SpinnerAriaState = "decorative" | SpinnerRole;
+/** Progress value state exposed when Spinner uses `role="progressbar"`. */
+type SpinnerProgressState = "determinate" | "indeterminate" | "none";
+/** Visibility and loading state mirrored to `data-state`. */
+type SpinnerState = "complete" | "hidden" | "idle" | "loading";
+/** Rendered value exposed by {@link Spinner}. */
+type SpinnerElement = Element | ComponentPublicInstance;
+/** State exposed to the default Spinner slot. */
+interface SpinnerSlotState {
+  /** Whether the spinner represents pending work. */
+  readonly loading: boolean;
+  /** Whether the spinner remains visible in layout. */
+  readonly visible: boolean;
+  /** Stable state token for styling and tests. */
+  readonly state: SpinnerState;
+  /** Resolved accessibility semantics for the rendered host. */
+  readonly ariaState: SpinnerAriaState;
+  /** Progress value policy used by the rendered host. */
+  readonly progressState: SpinnerProgressState;
+  /** Current normalized value, or `null` when indeterminate. */
+  readonly value: number | null;
+  /** Normalized lower progress bound. */
+  readonly min: number;
+  /** Normalized upper progress bound. */
+  readonly max: number;
+  /** Current completion percentage from 0 to 100, or `null` when indeterminate. */
+  readonly percent: number | null;
+  /** Whether determinate progress has reached the normalized maximum. */
+  readonly complete: boolean;
+}
+/** Public component instance exposed by the Spinner primitive. */
+interface SpinnerExpose extends SpinnerSlotState {
+  /** Rendered host element or component instance. */
+  readonly element: SpinnerElement | null;
+}
+//#endregion
+//#region src/families/feedback/spinner/spinner.vue.d.ts
+type __VLS_Props = {
+  /**
+   * Native element, custom element, or component to render.
+   *
+   * @default "span"
+   */
+  readonly as?: PrimitiveAs;
+  /**
+   * Consumer-owned spinner id. `null` and `undefined` select a deterministic fallback.
+   *
+   * @default undefined
+   */
+  readonly id?: string | null;
+  /**
+   * Whether the spinner represents pending work.
+   *
+   * @default true
+   */
+  readonly loading?: boolean;
+  /**
+   * Whether the spinner remains rendered and visible in layout.
+   *
+   * @default true
+   */
+  readonly visible?: boolean;
+  /**
+   * Accessibility semantics for the host.
+   *
+   * @default "status"
+   */
+  readonly role?: SpinnerRole;
+  /**
+   * Optional determinate progress value for `role="progressbar"`.
+   *
+   * @default null
+   */
+  readonly value?: number | null;
+  /**
+   * Lower progress bound for `role="progressbar"`.
+   *
+   * @default 0
+   */
+  readonly min?: number;
+  /**
+   * Upper progress bound for `role="progressbar"`.
+   *
+   * @default 100
+   */
+  readonly max?: number;
+  /**
+   * Whether status announcements should be atomic.
+   *
+   * @default true
+   */
+  readonly atomic?: boolean;
+  /**
+   * Hide the spinner from assistive technology and suppress status/progress semantics.
+   *
+   * @default undefined
+   */
+  readonly ariaHidden?: boolean;
+  /**
+   * Accessible name when no visible label or `aria-labelledby` supplies one.
+   *
+   * @default undefined
+   */
+  readonly ariaLabel?: string;
+  /**
+   * Space-separated ids that label the spinner.
+   *
+   * @default undefined
+   */
+  readonly ariaLabelledby?: string;
+  /**
+   * Space-separated ids that describe the spinner.
+   *
+   * @default undefined
+   */
+  readonly ariaDescribedby?: string;
+  /**
+   * Human-readable progress value text for assistive technology.
+   *
+   * @default undefined
+   */
+  readonly ariaValueText?: string;
+};
+type __VLS_Slots = {
+  /** Optional spinner contents. Receives current state for composition. */default(props: SpinnerSlotState): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+  ariaState: ComputedRef<SpinnerAriaState>;
+  complete: ComputedRef<boolean>;
+  element: Readonly<import("vue").ShallowRef<SpinnerElement | null>>;
+  loading: ComputedRef<boolean>;
+  max: ComputedRef<number>;
+  min: ComputedRef<number>;
+  percent: ComputedRef<number | null>;
+  progressState: ComputedRef<SpinnerProgressState>;
+  state: ComputedRef<SpinnerState>;
+  value: ComputedRef<number | null>;
+  visible: ComputedRef<boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { SpinnerProgressState as a, SpinnerState as c, SpinnerExpose as i, SpinnerAriaState as n, SpinnerRole as o, SpinnerElement as r, SpinnerSlotState as s, _default as t };