@nsaa/core 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/sound/sound-map.d.ts

@@ -0,0 +1,70 @@
+
+import "./sound.js";
+import { ReactNode } from "react";
+/**
+ * The one table of interface sounds: component × event → cue (feel layer, §4). Components play
+ * from here, so the map is reviewable in one place. Surfaces that aren't listed (Popover, Tooltip,
+ * Command, menu open and close, Select open, Tabs, Accordion, Collapsible, inputs) are silent: opening a light surface isn't a commit,
+ * and the palette is a 100+/day tool. Nothing plays on hover, load or typing.
+ */
+export declare const SOUND_MAP: {
+  readonly button: {
+    readonly press: "input.press";
+  };
+  readonly checkbox: {
+    readonly on: "input.toggle-on";
+    readonly off: "input.toggle-off";
+  };
+  readonly "radio-group": {
+    readonly change: "selection.select";
+  };
+  readonly switch: {
+    readonly on: "input.toggle-on";
+    readonly off: "input.toggle-off";
+  };
+  readonly slider: {
+    readonly commit: "movement.snap";
+  };
+  readonly "input-otp": {
+    readonly invalid: "feedback.error";
+  };
+  readonly alert: {
+    readonly destructive: "feedback.error";
+  };
+  readonly dialog: {
+    readonly open: "navigation.open";
+    readonly close: "navigation.close";
+  };
+  readonly "alert-dialog": {
+    readonly open: "navigation.open";
+    readonly close: "navigation.close";
+  };
+  readonly drawer: {
+    readonly open: "navigation.open";
+    readonly close: "navigation.close";
+    readonly snap: "movement.snap";
+  };
+  readonly select: {
+    readonly choose: "selection.select";
+  };
+  readonly calendar: {
+    readonly select: "selection.select";
+  };
+  readonly combobox: {
+    readonly choose: "selection.select";
+    readonly clear: "input.press";
+    readonly "chip-remove": "input.press";
+  };
+  readonly "dropdown-menu": {
+    readonly check: "selection.select";
+  };
+  readonly "context-menu": {
+    readonly check: "selection.select";
+  };
+  readonly toast: {
+    readonly success: "feedback.success";
+    readonly warning: "feedback.warning";
+    readonly error: "feedback.error";
+  };
+};
+export type SoundComponent = keyof typeof SOUND_MAP;

package/dist/sound/sound-map.js

@@ -0,0 +1,72 @@
+"use client";
+import { useSound } from "./sound.js";
+import { createContext, createElement, useCallback, useContext } from "react";
+// src/sound/sound-map.ts
+/**
+* The one table of interface sounds: component × event → cue (feel layer, §4). Components play
+* from here, so the map is reviewable in one place. Surfaces that aren't listed (Popover, Tooltip,
+* Command, menu open and close, Select open, Tabs, Accordion, Collapsible, inputs) are silent: opening a light surface isn't a commit,
+* and the palette is a 100+/day tool. Nothing plays on hover, load or typing.
+*/
+const SOUND_MAP = {
+	button: { press: "input.press" },
+	checkbox: {
+		on: "input.toggle-on",
+		off: "input.toggle-off"
+	},
+	"radio-group": { change: "selection.select" },
+	switch: {
+		on: "input.toggle-on",
+		off: "input.toggle-off"
+	},
+	slider: { commit: "movement.snap" },
+	"input-otp": { invalid: "feedback.error" },
+	alert: { destructive: "feedback.error" },
+	dialog: {
+		open: "navigation.open",
+		close: "navigation.close"
+	},
+	"alert-dialog": {
+		open: "navigation.open",
+		close: "navigation.close"
+	},
+	drawer: {
+		open: "navigation.open",
+		close: "navigation.close",
+		snap: "movement.snap"
+	},
+	select: { choose: "selection.select" },
+	calendar: { select: "selection.select" },
+	combobox: {
+		choose: "selection.select",
+		clear: "input.press",
+		"chip-remove": "input.press"
+	},
+	"dropdown-menu": { check: "selection.select" },
+	"context-menu": { check: "selection.select" },
+	toast: {
+		success: "feedback.success",
+		warning: "feedback.warning",
+		error: "feedback.error"
+	}
+};
+const SilentContext = createContext(false);
+/** Silences the sound map below it (CommandDialog reuses Dialog but stays silent, §4). */
+function SoundSilence({ children }) {
+	return createElement(SilentContext.Provider, { value: true }, children);
+}
+/** Plays a component's mapped cue for an event, through `useSound()` and its safeguards. */
+function useCue(component) {
+	const { play } = useSound();
+	const silent = useContext(SilentContext);
+	return useCallback((event, options) => {
+		if (silent) return;
+		const cue = SOUND_MAP[component][event];
+		if (cue) play(cue, options);
+	}, [
+		component,
+		play,
+		silent
+	]);
+}
+export { SOUND_MAP, SoundSilence, useCue };

package/dist/sound/sound.d.ts

@@ -0,0 +1,38 @@
+
+import { sound } from "../tokens/dist/motion.js";
+import { ReactNode } from "react";
+/** Cue names come from the tokens (`sound.cue` in packages/tokens/src/effects.json). */
+export type SoundCue = keyof typeof sound.cue;
+/**
+ * Plays a cue. App-supplied, so the library makes no network calls and the sound engine
+ * (UISFX or anything else) stays swappable. `asset` is the engine's cue name from the tokens.
+ */
+export type SoundPlayer = (cue: SoundCue, options: {
+  asset: string;
+  volume: number;
+}) => void | (() => void);
+export interface PlayOptions {
+  /** Give way to any other cue played during the same event (a Button press under a Dialog close). */
+  yield?: boolean | undefined;
+}
+export interface SoundProviderProps {
+  children: ReactNode;
+  /** Plays cues. Without one every cue is silent (the current stub behaviour). */
+  player?: SoundPlayer | undefined;
+  /** Apps can turn the default off (decision #30). */
+  enabled?: boolean | undefined;
+  volume?: number | undefined;
+}
+/** Global sound settings: one remembered mute for the whole app. */
+export declare function SoundProvider({ children, player, enabled, volume }: SoundProviderProps): import("react").JSX.Element;
+/**
+ * Plays interface sounds with manners: only from a user action (call `play` in an event handler),
+ * never when muted, turned off, or when the user asks for reduced motion; repeats are throttled.
+ */
+export declare function useSound(): {
+  play: (cue: SoundCue, options?: PlayOptions) => void;
+  loop: (cue: SoundCue) => (() => void);
+  muted: boolean;
+  setMuted: (muted: boolean) => void;
+  enabled: boolean;
+};

package/dist/sound/sound.js

@@ -0,0 +1,136 @@
+"use client";
+import { sound } from "../tokens/dist/motion.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useMemo, useRef, useState } from "react";
+import { useReducedMotionConfig } from "motion/react";
+// src/sound/sound.tsx
+/** One moment per player (per SoundProvider), outside React state: one cue per moment (#71). */
+const moments = /* @__PURE__ */ new WeakMap();
+function momentOf(player) {
+	let moment = moments.get(player);
+	if (!moment) {
+		moment = {
+			lastAt: 0,
+			pending: null
+		};
+		moments.set(player, moment);
+	}
+	return moment;
+}
+const MUTE_KEY = "nsaa-sound-muted";
+function readMuted() {
+	try {
+		return localStorage.getItem(MUTE_KEY) === "true";
+	} catch {
+		return false;
+	}
+}
+function writeMuted(muted) {
+	try {
+		localStorage.setItem(MUTE_KEY, String(muted));
+	} catch {}
+}
+const SoundContext = createContext(null);
+/** The app's own switch on <html data-motion> (feel.css reads it too): "reduce" silences sound,
+* "full" overrides the OS setting. */
+function htmlMotion() {
+	return typeof document === "undefined" ? void 0 : document.documentElement.dataset.motion;
+}
+/** Global sound settings: one remembered mute for the whole app. */
+function SoundProvider({ children, player, enabled = sound.enabled, volume = sound.volume }) {
+	const [muted, setMutedState] = useState(readMuted);
+	const setMuted = useCallback((next) => {
+		setMutedState(next);
+		writeMuted(next);
+	}, []);
+	const value = useMemo(() => ({
+		enabled,
+		volume,
+		muted,
+		setMuted,
+		player
+	}), [
+		enabled,
+		volume,
+		muted,
+		setMuted,
+		player
+	]);
+	return /* @__PURE__ */ jsx(SoundContext.Provider, {
+		value,
+		children
+	});
+}
+/**
+* Plays interface sounds with manners: only from a user action (call `play` in an event handler),
+* never when muted, turned off, or when the user asks for reduced motion; repeats are throttled.
+*/
+function useSound() {
+	const context = useContext(SoundContext);
+	const reducedMotion = useReducedMotionConfig() ?? false;
+	const enabled = context?.enabled ?? sound.enabled;
+	const muted = context?.muted ?? false;
+	const player = context?.player;
+	const volume = context?.volume ?? sound.volume;
+	const last = useRef(null);
+	return {
+		play: useCallback((cue, options) => {
+			if (!enabled || muted || !player) return;
+			const html = htmlMotion();
+			if (html === "reduce" || reducedMotion && html !== "full") return;
+			const moment = momentOf(player);
+			const fire = () => {
+				const now = Date.now();
+				if (last.current?.cue === cue && now - last.current.at < 80) return;
+				last.current = {
+					cue,
+					at: now
+				};
+				moment.lastAt = now;
+				player(cue, {
+					asset: sound.cue[cue],
+					volume
+				});
+			};
+			if (!options?.yield) {
+				if (moment.pending) clearTimeout(moment.pending);
+				moment.pending = null;
+				fire();
+				return;
+			}
+			const scheduledAt = Date.now();
+			if (moment.pending) clearTimeout(moment.pending);
+			moment.pending = setTimeout(() => {
+				moment.pending = null;
+				if (scheduledAt - moment.lastAt < 100) return;
+				fire();
+			}, 0);
+		}, [
+			enabled,
+			muted,
+			reducedMotion,
+			player,
+			volume
+		]),
+		loop: useCallback((cue) => {
+			if (!enabled || muted || !player) return () => {};
+			const html = htmlMotion();
+			if (html === "reduce" || reducedMotion && html !== "full") return () => {};
+			const stop = player(cue, {
+				asset: sound.cue[cue],
+				volume
+			});
+			return typeof stop === "function" ? stop : () => {};
+		}, [
+			enabled,
+			muted,
+			reducedMotion,
+			player,
+			volume
+		]),
+		muted,
+		setMuted: context?.setMuted ?? writeMuted,
+		enabled
+	};
+}
+export { SoundProvider, useSound };

package/dist/sound/uisfx.d.ts

@@ -0,0 +1,37 @@
+
+import { SoundPlayer } from "./sound.js";
+import { PackName } from "uisfx";
+export type SoundPack = PackName;
+/** Every UISFX pack, for pickers. */
+export declare const soundPacks: readonly SoundPack[];
+export interface UisfxPlayerOptions {
+  /** UISFX pack (sound family). Defaults to the `sound.feel` token. */
+  pack?: SoundPack | undefined;
+  /** Where to listen for the first user gesture. Defaults to `window`. */
+  target?: EventTarget | undefined;
+}
+/** A `SoundPlayer` for `SoundProvider`, plus controls for the engine. */
+export interface UisfxSoundPlayer extends SoundPlayer {
+  setPack: (pack: SoundPack) => void;
+  getPack: () => SoundPack;
+  /** True once a trusted pointer or key action has happened (or `unlock` was called from one). */
+  isUnlocked: () => boolean;
+  /** Unlock audio from your own user-gesture handler. Never call it on load. */
+  unlock: () => void;
+  /** Stops sounds, removes listeners and closes the audio context. */
+  destroy: () => Promise<void>;
+}
+/**
+ * Real sound for `SoundProvider`, synthesised live by UISFX (no network, no audio files).
+ * Manners: nothing plays, and no audio context is created, until the first trusted pointer or
+ * key action; mute, volume and reduced motion are handled by `SoundProvider`/`useSound`.
+ *
+ * Create one per app, at module scope (not inside a component, where StrictMode or re-renders
+ * would make extra engines):
+ *
+ * ```tsx
+ * const player = createUisfxPlayer({ pack: "soft" });
+ * <SoundProvider player={player}>…</SoundProvider>
+ * ```
+ */
+export declare function createUisfxPlayer({ pack, target }?: UisfxPlayerOptions): UisfxSoundPlayer;

package/dist/sound/uisfx.js

@@ -0,0 +1,59 @@
+"use client";
+import { sound } from "../tokens/dist/motion.js";
+import { createUISFX, cueNames, getPlaybackMode, packNames } from "uisfx";
+// src/sound/uisfx.ts
+/** Every UISFX pack, for pickers. */
+const soundPacks = packNames;
+const GESTURES = ["pointerdown", "keydown"];
+const CUES = new Set(cueNames);
+function isPack(value) {
+	return packNames.includes(value);
+}
+/**
+* Real sound for `SoundProvider`, synthesised live by UISFX (no network, no audio files).
+* Manners: nothing plays, and no audio context is created, until the first trusted pointer or
+* key action; mute, volume and reduced motion are handled by `SoundProvider`/`useSound`.
+*
+* Create one per app, at module scope (not inside a component, where StrictMode or re-renders
+* would make extra engines):
+*
+* ```tsx
+* const player = createUisfxPlayer({ pack: "soft" });
+* <SoundProvider player={player}>…</SoundProvider>
+* ```
+*/
+function createUisfxPlayer({ pack, target } = {}) {
+	const initialPack = pack ?? (isPack(sound.feel) ? sound.feel : "minimal");
+	const engine = createUISFX({
+		pack: initialPack,
+		volume: sound.volume
+	});
+	const listenOn = target ?? (typeof window === "undefined" ? void 0 : window);
+	let unlocked = false;
+	const unlock = () => {
+		if (unlocked) return;
+		unlocked = true;
+		for (const type of GESTURES) listenOn?.removeEventListener(type, onGesture, true);
+		engine.unlock();
+	};
+	function onGesture(event) {
+		if (event.isTrusted) unlock();
+	}
+	for (const type of GESTURES) listenOn?.addEventListener(type, onGesture, true);
+	const play = ((_cue, { asset, volume }) => {
+		if (!unlocked || !CUES.has(asset)) return;
+		if (engine.getVolume() !== volume) engine.setVolume(volume);
+		const playing = engine.play(asset);
+		if (getPlaybackMode(asset) === "loop") return () => playing?.stop();
+	});
+	play.setPack = (next) => engine.setPack(next);
+	play.getPack = () => engine.getPack();
+	play.isUnlocked = () => unlocked;
+	play.unlock = unlock;
+	play.destroy = async () => {
+		for (const type of GESTURES) listenOn?.removeEventListener(type, onGesture, true);
+		await engine.destroy();
+	};
+	return play;
+}
+export { createUisfxPlayer, soundPacks };

package/dist/sound-uisfx.d.ts

@@ -1,38 +1,3 @@
 
-import { n as SoundPlayer } from "./sound-DiYNAnR_.js";
-import { PackName } from "uisfx";
-type SoundPack = PackName;
-/** Every UISFX pack, for pickers. */
-export declare const soundPacks: readonly SoundPack[];
-interface UisfxPlayerOptions {
-  /** UISFX pack (sound family). Defaults to the `sound.feel` token. */
-  pack?: SoundPack | undefined;
-  /** Where to listen for the first user gesture. Defaults to `window`. */
-  target?: EventTarget | undefined;
-}
-/** A `SoundPlayer` for `SoundProvider`, plus controls for the engine. */
-interface UisfxSoundPlayer extends SoundPlayer {
-  setPack: (pack: SoundPack) => void;
-  getPack: () => SoundPack;
-  /** True once a trusted pointer or key action has happened (or `unlock` was called from one). */
-  isUnlocked: () => boolean;
-  /** Unlock audio from your own user-gesture handler. Never call it on load. */
-  unlock: () => void;
-  /** Stops sounds, removes listeners and closes the audio context. */
-  destroy: () => Promise<void>;
-}
-/**
- * Real sound for `SoundProvider`, synthesised live by UISFX (no network, no audio files).
- * Manners: nothing plays, and no audio context is created, until the first trusted pointer or
- * key action; mute, volume and reduced motion are handled by `SoundProvider`/`useSound`.
- *
- * Create one per app, at module scope (not inside a component, where StrictMode or re-renders
- * would make extra engines):
- *
- * ```tsx
- * const player = createUisfxPlayer({ pack: "soft" });
- * <SoundProvider player={player}>…</SoundProvider>
- * ```
- */
-export declare function createUisfxPlayer({ pack, target }?: UisfxPlayerOptions): UisfxSoundPlayer;
-export type { SoundPack, UisfxPlayerOptions, UisfxSoundPlayer };
+import { SoundPack, UisfxPlayerOptions, UisfxSoundPlayer, createUisfxPlayer, soundPacks } from "./sound/uisfx.js";
+export { type SoundPack, type UisfxPlayerOptions, type UisfxSoundPlayer, createUisfxPlayer, soundPacks };

package/dist/sound-uisfx.js

@@ -1,59 +1,2 @@
 "use client";
-import { i as sound } from "./motion-NQq2BA78.js";
-import { createUISFX, cueNames, getPlaybackMode, packNames } from "uisfx";
-// src/sound/uisfx.ts
-/** Every UISFX pack, for pickers. */
-const soundPacks = packNames;
-const GESTURES = ["pointerdown", "keydown"];
-const CUES = new Set(cueNames);
-function isPack(value) {
-	return packNames.includes(value);
-}
-/**
-* Real sound for `SoundProvider`, synthesised live by UISFX (no network, no audio files).
-* Manners: nothing plays, and no audio context is created, until the first trusted pointer or
-* key action; mute, volume and reduced motion are handled by `SoundProvider`/`useSound`.
-*
-* Create one per app, at module scope (not inside a component, where StrictMode or re-renders
-* would make extra engines):
-*
-* ```tsx
-* const player = createUisfxPlayer({ pack: "soft" });
-* <SoundProvider player={player}>…</SoundProvider>
-* ```
-*/
-function createUisfxPlayer({ pack, target } = {}) {
-	const initialPack = pack ?? (isPack(sound.feel) ? sound.feel : "minimal");
-	const engine = createUISFX({
-		pack: initialPack,
-		volume: sound.volume
-	});
-	const listenOn = target ?? (typeof window === "undefined" ? void 0 : window);
-	let unlocked = false;
-	const unlock = () => {
-		if (unlocked) return;
-		unlocked = true;
-		for (const type of GESTURES) listenOn?.removeEventListener(type, onGesture, true);
-		engine.unlock();
-	};
-	function onGesture(event) {
-		if (event.isTrusted) unlock();
-	}
-	for (const type of GESTURES) listenOn?.addEventListener(type, onGesture, true);
-	const play = ((_cue, { asset, volume }) => {
-		if (!unlocked || !CUES.has(asset)) return;
-		if (engine.getVolume() !== volume) engine.setVolume(volume);
-		const playing = engine.play(asset);
-		if (getPlaybackMode(asset) === "loop") return () => playing?.stop();
-	});
-	play.setPack = (next) => engine.setPack(next);
-	play.getPack = () => engine.getPack();
-	play.isUnlocked = () => unlocked;
-	play.unlock = unlock;
-	play.destroy = async () => {
-		for (const type of GESTURES) listenOn?.removeEventListener(type, onGesture, true);
-		await engine.destroy();
-	};
-	return play;
-}
-export { createUisfxPlayer, soundPacks };
+export { createUisfxPlayer, soundPacks } from "./sound/uisfx.js";

package/dist/spinner/index.d.ts

@@ -0,0 +1,5 @@
+
+import { LoaderProvider, LoaderProviderProps } from "./loader-provider.js";
+import { LoaderComponent, registerLoader, registerLoaders } from "./registry.js";
+import { Spinner, SpinnerProps, SpinnerVariant } from "./spinner.js";
+export { type LoaderComponent, LoaderProvider, type LoaderProviderProps, Spinner, type SpinnerProps, type SpinnerVariant, registerLoader, registerLoaders };

package/dist/spinner/loader-provider.d.ts

@@ -0,0 +1,16 @@
+
+import { ReactNode } from "react";
+export interface LoaderProviderProps {
+  children: ReactNode;
+  /** Pauses every loader inside (sets `data-loader-paused`, which the play state follows). */
+  paused?: boolean | undefined;
+  /** One speed for every loader inside, in ms. */
+  duration?: number | undefined;
+  /** Default Spinner label (e.g. a translation of "Loading"). */
+  label?: string | undefined;
+}
+/**
+ * Cascades the loader play state and speed to a region (`display: contents`, so it adds no box) and
+ * gives its Spinners a default label.
+ */
+export declare function LoaderProvider({ children, paused, duration, label }: LoaderProviderProps): import("react").JSX.Element;

package/dist/spinner/loader-provider.js

@@ -0,0 +1,28 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+// src/spinner/loader-provider.tsx
+const LoaderContext = createContext({});
+function useLoaderContext() {
+	return useContext(LoaderContext);
+}
+/**
+* Cascades the loader play state and speed to a region (`display: contents`, so it adds no box) and
+* gives its Spinners a default label.
+*/
+function LoaderProvider({ children, paused, duration, label }) {
+	const style = {
+		display: "contents",
+		...duration === void 0 ? null : { "--nsaa-loader-duration": `${duration}ms` }
+	};
+	return /* @__PURE__ */ jsx(LoaderContext.Provider, {
+		value: { label },
+		children: /* @__PURE__ */ jsx("div", {
+			"data-slot": "loader-provider",
+			"data-loader-paused": paused ? "" : void 0,
+			style,
+			children
+		})
+	});
+}
+export { LoaderProvider, useLoaderContext };

package/dist/spinner/registry.d.ts

@@ -0,0 +1,9 @@
+
+import { SpinnerProps } from "../loaders/types.js";
+import { ComponentType } from "react";
+/** A loader: a decorative, `aria-hidden` glyph painted with `currentColor` (the loader contract). */
+export type LoaderComponent = ComponentType<SpinnerProps>;
+/** Makes a loader available as `<Spinner variant={name} />`. A later registration replaces an earlier one. */
+export declare function registerLoader(name: string, component: LoaderComponent): void;
+/** Registers a map of loaders, e.g. `registerLoaders(LOADERS)` for all 29 from `@nsaa/core/loaders`. */
+export declare function registerLoaders(loaders: Record<string, LoaderComponent>): void;

package/dist/spinner/registry.js

@@ -0,0 +1,15 @@
+"use client";
+// src/spinner/registry.ts
+const registry = /* @__PURE__ */ new Map();
+/** Makes a loader available as `<Spinner variant={name} />`. A later registration replaces an earlier one. */
+function registerLoader(name, component) {
+	registry.set(name, component);
+}
+/** Registers a map of loaders, e.g. `registerLoaders(LOADERS)` for all 29 from `@nsaa/core/loaders`. */
+function registerLoaders(loaders) {
+	for (const [name, component] of Object.entries(loaders)) registry.set(name, component);
+}
+function getLoader(name) {
+	return registry.get(name);
+}
+export { getLoader, registerLoader, registerLoaders };

package/dist/spinner/spinner.d.ts

@@ -0,0 +1,26 @@
+
+import { LoaderSize } from "../loaders/types.js";
+import * as React from "react";
+export type SpinnerVariant = "arc" | "ring" | "classic" | "circular-dots" | "bouncing-dots" | "pulse" | "orbit" | "wave" | "lucide" | (string & {});
+export interface SpinnerProps extends Omit<React.ComponentProps<"span">, "children"> {
+  /** A registered loader name (the featured 8 built in, more via registerLoader) or "lucide". */
+  variant?: SpinnerVariant | undefined;
+  /** A token size (xs 12, sm 14, md 16, lg 20, xl 24) or pixels. */
+  size?: LoaderSize | number | undefined;
+  /** Announced, and shown as text under reduced motion. Default: the LoaderProvider's, else "Loading". */
+  label?: string | undefined;
+  /** Wait before showing, ms (loader.delay, 150; 0 inside a control). */
+  delay?: number | undefined;
+  /** Once shown, stay at least this long after `loading` turns false, ms (loader.min-display, 500). */
+  minDisplay?: number | undefined;
+  /** Turn false to hide it, honouring `minDisplay` (unmounting it hides it at once). Default true. */
+  loading?: boolean | undefined;
+  /** One turn, ms. Default: the loader's token. */
+  duration?: number | undefined;
+  /** Hold the animation. Offscreen and hidden-tab spinners pause on their own. */
+  paused?: boolean | undefined;
+  /** Play `progress.loop` while shown; it stops when the Spinner hides or unmounts. Default false. */
+  sound?: boolean | undefined;
+}
+declare function Spinner({ variant, size, label, delay: delayProp, minDisplay, loading, duration, paused, sound, className, style, ...props }: SpinnerProps): React.JSX.Element | null;
+export { Spinner };