asheeui 2.0.0 → 2.2.1

package/dist/theme/controller.js

@@ -1,66 +0,0 @@
-"use client";
-//#region src/theme/controller.ts
-var e = "ashee-theme", t = "theme-", n = new class {
-	selection = "light";
-	resolved = "light";
-	defaultTheme = "light";
-	availableThemes = [];
-	listeners = /* @__PURE__ */ new Set();
-	mediaQuery = null;
-	constructor() {
-		typeof window > "u" || (this.mediaQuery = window.matchMedia("(prefers-color-scheme: dark)"), this.mediaQuery.addEventListener("change", this.handleSystemChange));
-	}
-	configure({ defaultTheme: t, themes: n }) {
-		if (this.defaultTheme = t, this.availableThemes = n, typeof window > "u") {
-			console.log("[Theme] Running in non-browser environment, skipping localStorage operations.");
-			return;
-		}
-		let r = window.localStorage.getItem(e), i = r !== null && this.isValid(r);
-		i || r !== null && (console.log("[Theme] Invalid stored theme, removing from localStorage."), window.localStorage.removeItem(e)), this.selection = i ? r : t, this.applySelection(), this.listeners.forEach((e) => {
-			e();
-		});
-	}
-	setDefault = (e) => {
-		this.configure({
-			defaultTheme: e,
-			themes: this.availableThemes
-		});
-	};
-	getSelection = () => this.selection;
-	getResolvedTheme = () => this.resolved;
-	setTheme = (t) => {
-		let n = this.sanitize(t);
-		this.selection = n, typeof window < "u" && window.localStorage.setItem(e, n), this.applySelection(), this.listeners.forEach((e) => {
-			e();
-		});
-	};
-	subscribe = (e) => (this.listeners.add(e), () => this.listeners.delete(e));
-	getAvailableThemes = () => this.availableThemes;
-	toggleTheme = () => {
-		let e = Array.from(new Set(this.availableThemes)).filter((e) => e !== "system"), t = e.indexOf(this.selection), n = t === -1 ? 0 : (t + 1) % e.length;
-		this.setTheme(e[n]);
-	};
-	handleSystemChange = () => {
-		this.selection === "system" && (this.applySelection(), this.listeners.forEach((e) => {
-			e();
-		}));
-	};
-	sanitize(e) {
-		return this.isValid(e) ? e : this.defaultTheme;
-	}
-	isValid(e) {
-		return e === "system" ? !0 : this.availableThemes.length > 0 ? this.availableThemes.includes(e) : !0;
-	}
-	resolve(e) {
-		return e === "system" ? this.mediaQuery?.matches ? "dark" : "light" : e;
-	}
-	applySelection() {
-		let e = this.sanitize(this.selection), n = this.resolve(e);
-		if (this.availableThemes.length > 0 && !this.availableThemes.includes(n) && (n = this.availableThemes.includes(this.defaultTheme) ? this.defaultTheme : this.availableThemes[0]), this.resolved = n, typeof document > "u") return;
-		let r = document.documentElement, i = `${t}${n}`;
-		for (let e of Array.from(r.classList)) e.startsWith(t) && r.classList.remove(e);
-		r.classList.add(i);
-	}
-}();
-//#endregion
-export { e as THEME_STORAGE_KEY, n as themeController };

package/dist/theme/index.d.ts

@@ -1,4 +0,0 @@
-export * from './color';
-export * from './controller';
-export * from './useTheme';
-//# sourceMappingURL=index.d.ts.map

package/dist/theme/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/theme/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

package/dist/theme/useTheme.d.ts

@@ -1,77 +0,0 @@
-import { ThemeSelection } from './controller';
-/**
- * React hook that provides access to the current theme state and controls.
- *
- * This hook subscribes to the theme controller and returns the current
- * theme selection, resolved theme name, and functions for changing the theme.
- * Components using this hook will re-render automatically when the theme changes.
- *
- * The hook uses useSyncExternalStore to safely subscribe to the theme
- * controller's state, making it compatible with React's concurrent rendering.
- *
- * @returns An object containing the current theme state and control functions.
- *
- * @example
- * ```tsx
- * function ThemeToggle() {
- *   const { theme, setTheme, availableThemes } = useTheme();
- *
- *   return (
- *     <select value={theme} onChange={(e) => setTheme(e.target.value as ThemeSelection)}>
- *       {availableThemes.map(t => (
- *         <option key={t} value={t}>{t}</option>
- *       ))}
- *       <option value="system">System</option>
- *     </select>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * function ThemedComponent() {
- *   const { resolvedTheme } = useTheme();
- *
- *   return (
- *     <div className={resolvedTheme === 'dark' ? 'dark-styles' : 'light-styles'}>
- *       Current theme: {resolvedTheme}
- *     </div>
- *   );
- * }
- * ```
- *
- * @see ThemeController - The underlying class that manages theme state.
- * @see ThemeSelection - The type for theme selections including "system".
- * @see ThemeName - The type for resolved theme names.
- */
-export declare function useTheme(): {
-    /**
-     * The user's current theme selection.
-     * This can be either a specific theme name or "system".
-     */
-    theme: ThemeSelection;
-    /**
-     * The resolved theme name after applying the selection.
-     * If the selection is "system", this resolves to either "light" or "dark"
-     * based on the system preference.
-     */
-    resolvedTheme: keyof import('./color').AsheeColorRegistry;
-    /**
-     * Function to set the theme selection.
-     * This persists the selection to localStorage and applies the theme.
-     * @param selection - The theme to select, either "system" or a theme name.
-     */
-    setTheme: (selection: ThemeSelection) => void;
-    /**
-     * Function to cycle to the next available theme.
-     * This cycles through all available theme names, excluding "system".
-     * Loops back to the start when reaching the end of the list.
-     */
-    toggleTheme: () => void;
-    /**
-     * The list of available theme names in the application.
-     * This does not include "system" as it is not a theme name.
-     */
-    availableThemes: readonly string[];
-};
-//# sourceMappingURL=useTheme.d.ts.map

package/dist/theme/useTheme.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useTheme.d.ts","sourceRoot":"","sources":["../../src/theme/useTheme.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,KAAK,cAAc,EAAmB,MAAM,cAAc,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,QAAQ;IAcpB;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;EAGN"}

package/dist/theme/useTheme.js

@@ -1,16 +0,0 @@
-"use client";
-"use client";
-import { themeController as e } from "./controller.js";
-import { useSyncExternalStore as t } from "react";
-//#region src/theme/useTheme.ts
-function n() {
-	return {
-		theme: t(e.subscribe, e.getSelection, () => "light"),
-		resolvedTheme: t(e.subscribe, e.getResolvedTheme, () => "light"),
-		setTheme: e.setTheme,
-		toggleTheme: e.toggleTheme,
-		availableThemes: e.getAvailableThemes()
-	};
-}
-//#endregion
-export { n as useTheme };

package/dist/utils/cn.d.ts

@@ -1,20 +0,0 @@
-import { ClassValue } from 'clsx';
-/**
- * Merge Tailwind CSS class names, resolving conflicts deterministically.
- *
- * Combines `clsx` (conditional class composition) with `tailwind-merge`
- * (later conflicting utilities win), which keeps generated class
- * strings short and predictable.
- *
- * @param inputs - Class values: strings, objects, arrays, or falsy
- *   values that are ignored.
- * @returns A single space-separated class string.
- *
- * @example
- * ```ts
- * cn("px-2 p-4", isActive && "bg-primary", "rounded-md");
- * // isActive=false -> "p-4 rounded-md"; px-2 conflicts with p-4 and is dropped
- * ```
- */
-export declare function cn(...inputs: ClassValue[]): string;
-//# sourceMappingURL=cn.d.ts.map

package/dist/utils/cn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cn.d.ts","sourceRoot":"","sources":["../../src/utils/cn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAQ,MAAM,MAAM,CAAC;AAG7C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,CAElD"}

package/dist/utils/cn.js

@@ -1,9 +0,0 @@
-"use client";
-import { clsx as e } from "clsx";
-import { twMerge as t } from "tailwind-merge";
-//#region src/utils/cn.ts
-function n(...n) {
-	return t(e(n));
-}
-//#endregion
-export { n as cn };

package/dist/utils/index.d.ts

@@ -1,5 +0,0 @@
-export { cn } from './cn';
-export { mergeObject } from './merge-object';
-export { ASHEE_GLOBAL_LAYER, ASHEE_LAYER, establishesStackingContext, resolveBaseZIndex, resolveFloatingZIndex, } from './stacking';
-export type { DeepPartial } from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,MAAM,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,0BAA0B,EAC1B,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}

package/dist/utils/index.js

@@ -1,4 +0,0 @@
-export * from "./cn.js";
-export * from "./merge-object.js";
-export * from "./resolve-token.js";
-export * from "./stacking.js";

package/dist/utils/merge-object.d.ts

@@ -1,30 +0,0 @@
-import { DeepPartial } from './types';
-/**
- * Deeply merge a partial user config over a set of defaults.
- *
- * Nested plain objects are merged recursively; arrays and scalar
- * values from `userConfig` replace the default outright. Keys whose
- * user value is `undefined` are skipped, leaving the default intact.
- * The `defaults` object is not mutated.
- *
- * `T` is inferred exclusively from `defaults`; `U` (the override type) is a
- * separate type parameter constrained to a deep partial of `T`. This keeps
- * TypeScript from ever inferring `T` from the `userConfig` argument, which
- * would otherwise force a full `DeepPartial<T>` instantiation at every call
- * site (the source of "excessively deep type instantiation" errors).
- *
- * @param defaults - Baseline object providing fallback values.
- * @param userConfig - Optional partial override object.
- * @returns A new object with the user overrides applied.
- *
- * @example
- * ```ts
- * const config = mergeObject(
- *   { theme: { color: "primary", radius: "md" } },
- *   { theme: { radius: "lg" } },
- * );
- * // -> { theme: { color: "primary", radius: "lg" } }
- * ```
- */
-export declare function mergeObject<T extends Record<string, unknown>, U extends DeepPartial<T> = DeepPartial<T>>(defaults: T, userConfig?: U): T;
-//# sourceMappingURL=merge-object.d.ts.map

package/dist/utils/merge-object.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge-object.d.ts","sourceRoot":"","sources":["../../src/utils/merge-object.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAY3C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,WAAW,CACzB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,CAAC,SAAS,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EACzC,QAAQ,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,CAAC,GAAG,CAAC,CAuBhC"}

package/dist/utils/merge-object.js

@@ -1,16 +0,0 @@
-"use client";
-//#region src/utils/merge-object.ts
-function e(e) {
-	return typeof e == "object" && !!e && !Array.isArray(e);
-}
-function t(n, r) {
-	if (!r) return n;
-	let i = { ...n }, a = n, o = r;
-	for (let n of Object.keys(r)) {
-		let r = o[n], s = a[n];
-		r !== void 0 && (i[n] = e(s) && e(r) ? t(s, r) : r);
-	}
-	return i;
-}
-//#endregion
-export { t as mergeObject };

package/dist/utils/resolve-token.d.ts

@@ -1,131 +0,0 @@
-import { DeepPartial } from './types';
-/**
- * Resolves a value using the standard cascade precedence order.
- * Follows the hierarchy: instance prop > component config > global default > hard fallback.
- * This is the primary resolver for most component props.
- *
- * @param instance - The prop value passed directly to the component instance.
- * @param section - The value from the component's configuration section.
- * @param globalDefault - The global default value from the theme configuration.
- * @param hardFallback - The final fallback value if all others are undefined.
- * @returns The resolved value.
- *
- * @example
- * ```tsx
- * const variant = resolveCascade(
- *   props.variant,          // 'ghost'
- *   config.Button.variant,  // 'solid'
- *   theme.defaultVariant,   // 'faded'
- *   'solid'                 // hard fallback
- * );
- * // Returns 'ghost' because instance prop takes precedence
- * ```
- */
-export declare function resolveCascade<T>(instance: T | undefined, section: T | undefined, globalDefault: T | undefined, hardFallback: T): T;
-/**
- * Resolves a value for animation or transition contexts.
- * Similar to resolveCascade but without the global default tier.
- * This is useful for values that should not inherit from theme defaults.
- *
- * @param instance - The prop value passed directly to the component instance.
- * @param section - The value from the component's configuration section.
- * @param hardFallback - The final fallback value if all others are undefined.
- * @returns The resolved value.
- *
- * @example
- * ```tsx
- * const animate = resolveAnimate(
- *   props.animate,           // false
- *   config.Button.animate,   // true
- *   true                     // hard fallback
- * );
- * // Returns false because instance prop takes precedence
- * ```
- */
-export declare function resolveAnimate<T>(instance: T | undefined, section: T | undefined, hardFallback: T): T;
-/**
- * Resolves a radius value using the standard cascade precedence order.
- * This is a specialized version of resolveCascade that provides a default
- * hard fallback of "md" for radius values.
- *
- * @param instanceProp - The radius prop passed directly to the component instance.
- * @param sectionConfig - The radius from the component's configuration section.
- * @param globalDefaultRadius - The global default radius from the theme.
- * @param hardFallback - Optional custom fallback, defaults to "md".
- * @returns The resolved radius key.
- *
- * @example
- * ```tsx
- * const radius = resolveRadiusKey(
- *   props.radius,          // 'lg'
- *   config.Button.radius,  // 'md'
- *   theme.defaultRadius,   // 'sm'
- * );
- * // Returns 'lg' because instance prop takes precedence
- * ```
- */
-export declare function resolveRadiusKey<TKey>(instanceProp: TKey | undefined, sectionConfig: TKey | undefined, globalDefaultRadius: TKey | undefined, hardFallback?: TKey): TKey;
-/**
- * Resolve every option of a component's configuration in one step.
- *
- * A layout or pattern component usually exposes its whole configuration as a
- * set of optional props that resolve through the same cascade. Calling
- * {@link resolveCascade} once per key repeats the same precedence rule and the
- * same fallback argument for every option, which is where drift creeps in. This
- * helper applies the rule to every key of the hard fallback in one call, so a
- * component states its options once and the precedence is guaranteed to be
- * identical for all of them.
- *
- * The fallback object defines the shape: every key it declares is resolved and
- * returned, and a key it omits has no fallback at all (which is how optional
- * responsive keys stay undefined).
- *
- * @param instance - The props passed to the component instance.
- * @param section - The component's configuration section, if any.
- * @param fallback - The hard fallback for every option.
- * @returns A complete set of resolved values.
- *
- * @example
- * ```tsx
- * const resolved = resolveConfigCascade<HeroConfig, Required<HeroConfig>>(
- *   { align, spacing, background },
- *   config.components?.hero,
- *   FALLBACK_HERO_CONFIG,
- * );
- * // resolved.align is the prop, then components.hero.align, then the fallback
- * ```
- */
-export declare function resolveConfigCascade<C extends object, F extends Required<C>>(instance: Partial<C>, section: DeepPartial<C> | undefined, fallback: F): F;
-/**
- * Resolves a CSS class from a class map based on a key.
- * Returns the class string for the given key, falling back to the
- * fallback key's class if the key is not found. Returns an empty
- * string if neither the key nor the fallback key exist in the map.
- *
- * @param key - The key to look up in the class map.
- * @param classMap - The record mapping keys to CSS class strings.
- * @param fallbackKey - The fallback key to use if the primary key is not found.
- * @returns The CSS class string.
- *
- * @example
- * ```tsx
- * const classes = resolveClassKey(
- *   'lg',                          // key
- *   { sm: 'text-sm', lg: 'text-lg' }, // classMap
- *   'sm'                           // fallbackKey
- * );
- * // Returns 'text-lg'
- * ```
- *
- * @example
- * ```tsx
- * const classes = resolveClassKey(
- *   'xl',                          // key not in map
- *   { sm: 'text-sm', lg: 'text-lg' }, // classMap
- *   'sm'                           // fallbackKey
- * );
- * // Returns 'text-sm' from fallback key
- * ```
- */
-export declare function resolveClassKey<TKey extends PropertyKey>(key: TKey, classMap: Record<TKey, string>, fallbackKey: TKey): string;
-//# sourceMappingURL=resolve-token.d.ts.map

package/dist/utils/resolve-token.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-token.d.ts","sourceRoot":"","sources":["../../src/utils/resolve-token.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,QAAQ,EAAE,CAAC,GAAG,SAAS,EACvB,OAAO,EAAE,CAAC,GAAG,SAAS,EACtB,aAAa,EAAE,CAAC,GAAG,SAAS,EAC5B,YAAY,EAAE,CAAC,GACd,CAAC,CAEH;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,QAAQ,EAAE,CAAC,GAAG,SAAS,EACvB,OAAO,EAAE,CAAC,GAAG,SAAS,EACtB,YAAY,EAAE,CAAC,GACd,CAAC,CAEH;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EACnC,YAAY,EAAE,IAAI,GAAG,SAAS,EAC9B,aAAa,EAAE,IAAI,GAAG,SAAS,EAC/B,mBAAmB,EAAE,IAAI,GAAG,SAAS,EACrC,YAAY,GAAE,IAAmB,GAChC,IAAI,CAEN;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,QAAQ,CAAC,CAAC,CAAC,EAC1E,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,EACnC,QAAQ,EAAE,CAAC,GACV,CAAC,CAeH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,eAAe,CAAC,IAAI,SAAS,WAAW,EACtD,GAAG,EAAE,IAAI,EACT,QAAQ,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,EAC9B,WAAW,EAAE,IAAI,GAChB,MAAM,CAER"}

package/dist/utils/resolve-token.js

@@ -1,24 +0,0 @@
-"use client";
-//#region src/utils/resolve-token.ts
-function e(e, t, n, r) {
-	return e ?? t ?? n ?? r;
-}
-function t(e, t, n) {
-	return e ?? t ?? n;
-}
-function n(e, t, n, r = "md") {
-	return e ?? t ?? n ?? r;
-}
-function r(e, t, n) {
-	let r = { ...n }, i = t;
-	for (let t of Object.keys(n)) {
-		let a = e[t], o = i?.[t];
-		r[t] = a ?? o ?? n[t];
-	}
-	return r;
-}
-function i(e, t, n) {
-	return t[e] ?? t[n] ?? "";
-}
-//#endregion
-export { t as resolveAnimate, e as resolveCascade, i as resolveClassKey, r as resolveConfigCascade, n as resolveRadiusKey };

package/dist/utils/stacking.d.ts

@@ -1,76 +0,0 @@
-/**
- * Stacking-context utilities for AsheeUI floating elements.
- * This file provides the layering standard used by every floating component.
- *
- * Floating elements are portaled to `document.body`, which places them in the
- * root stacking context, so their `z-index` competes with app-level chrome
- * such as custom navbars. To layer correctly against both AsheeUI's own
- * components and arbitrary client components, a floating element derives its
- * `z-index` from the trigger's own stacking context:
- *
- *   floating z-index = outermost stacking context z-index of the trigger
- *                      + the component's layer delta
- *
- * The delta only orders AsheeUI's internal layers relative to each other
- * (dropdown < popover < tooltip). All elevation is carried by the derived
- * base, so an anchored popup stays above its own container (for example a
- * navbar) without ever outranking unrelated app chrome.
- */
-/**
- * Layer deltas for anchored floating elements (elements bound to a trigger).
- * Deltas are intentionally small integers so an anchored popup can never
- * leapfrog unrelated app chrome such as a high `z-index` navbar.
- */
-export declare const ASHEE_LAYER: {
-    /** Dropmenu, MultiSelect, Autocomplete, and the shared Menu. */
-    readonly dropdown: 10;
-    /** Calendar and other floating panels. */
-    readonly popover: 20;
-    /** Tooltips. */
-    readonly tooltip: 30;
-};
-/**
- * Fixed rungs for app-level overlays, which are not anchored to a trigger and
- * should sit above page chrome.
- */
-export declare const ASHEE_GLOBAL_LAYER: {
-    /** Modal and Drawer. */
-    readonly overlay: 1000;
-    /** Docked surfaces such as the on-screen keyboard. */
-    readonly docked: 1500;
-    /** Toasts. */
-    readonly toast: 2000;
-};
-/**
- * Determines whether an element establishes a stacking context, using the
- * conditions documented for CSS stacking contexts.
- *
- * @param element - The element to test.
- * @param computed - Optional precomputed style for the element.
- * @returns True when the element creates a stacking context.
- */
-export declare function establishesStackingContext(element: Element, computed?: CSSStyleDeclaration): boolean;
-/**
- * Resolves the `z-index` of the outermost stacking context that contains the
- * reference element — the context that governs where the reference's subtree
- * sits in the root stacking order.
- *
- * Walking outward matters: stacking contexts are atomic in their parent, so
- * only the outermost context ancestor decides the subtree's position.
- *
- * @param reference - The trigger element.
- * @returns The context's `z-index`, or 0 when the reference lives in the
- * plain root flow.
- */
-export declare function resolveBaseZIndex(reference: Element | null | undefined): number;
-/**
- * Resolves the `z-index` a portaled floating element should use so it renders
- * above its trigger's stacking context without outranking unrelated app
- * chrome.
- *
- * @param reference - The trigger element.
- * @param layerDelta - The component's layer delta from `ASHEE_LAYER`.
- * @returns The derived `z-index`.
- */
-export declare function resolveFloatingZIndex(reference: Element | null | undefined, layerDelta: number): number;
-//# sourceMappingURL=stacking.d.ts.map

package/dist/utils/stacking.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stacking.d.ts","sourceRoot":"","sources":["../../src/utils/stacking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW;IACtB,gEAAgE;;IAEhE,0CAA0C;;IAE1C,gBAAgB;;CAER,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,kBAAkB;IAC7B,wBAAwB;;IAExB,sDAAsD;;IAEtD,cAAc;;CAEN,CAAC;AAiBX;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,QAAQ,GAAE,mBAAsD,GAC/D,OAAO,CAmCT;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,GACpC,MAAM,CAwBR;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,EACrC,UAAU,EAAE,MAAM,GACjB,MAAM,CAER"}

package/dist/utils/stacking.js

@@ -1,34 +0,0 @@
-"use client";
-//#region src/utils/stacking.ts
-var e = {
-	dropdown: 10,
-	popover: 20,
-	tooltip: 30
-}, t = {
-	overlay: 1e3,
-	docked: 1500,
-	toast: 2e3
-};
-function n(e) {
-	if (e.parentElement) return e.parentElement;
-	let t = e.getRootNode();
-	return t instanceof ShadowRoot ? t.host : null;
-}
-function r(e, t = window.getComputedStyle(e)) {
-	return !!(t.position === "fixed" || t.position === "sticky" || (t.position === "absolute" || t.position === "relative") && t.zIndex !== "auto" || t.opacity !== "1" || t.transform !== "none" || t.filter !== "none" || t.getPropertyValue("backdrop-filter") !== "none" || t.getPropertyValue("perspective") !== "none" || t.getPropertyValue("clip-path") !== "none" || t.getPropertyValue("mix-blend-mode") !== "normal" || t.getPropertyValue("isolation") === "isolate" || /transform|opacity|filter/.test(t.getPropertyValue("will-change")) || /layout|paint|strict|content/.test(t.getPropertyValue("contain")));
-}
-function i(e) {
-	if (typeof window > "u" || !e) return 0;
-	let t = 0, i = n(e);
-	for (; i && i !== document.body && i !== document.documentElement;) {
-		let e = window.getComputedStyle(i);
-		if (r(i, e)) {
-			let n = Number.parseInt(e.zIndex, 10);
-			t = Number.isNaN(n) ? 0 : n;
-		}
-		i = n(i);
-	}
-	return Math.max(t, 0);
-}
-//#endregion
-export { t as ASHEE_GLOBAL_LAYER, e as ASHEE_LAYER, r as establishesStackingContext, i as resolveBaseZIndex };

package/dist/utils/types.d.ts

@@ -1,22 +0,0 @@
-/**
- * Built-in types that should never be recursed into.
- *
- * Functions (including React components/render callbacks), primitives, and
- * well-known built-in objects are terminal values for the deep mapping, so
- * `DeepPartial` stops instead of walking their members. This prevents
- * excessively deep/infinite type instantiation when configs reference React
- * nodes, DOM elements, or function-valued fields.
- */
-type Builtin = Date | Error | RegExp | boolean | number | string | symbol | null | undefined;
-/**
- * Recursively make every property of `T` optional.
- *
- * Built-ins (primitives, functions, dates, etc.) are left untouched and
- * arrays are mapped element-wise; only plain object properties are mapped
- * with optional keys. Useful for typed partial configuration overrides.
- */
-export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends object ? {
-    [K in keyof T]?: DeepPartial<T[K]>;
-} : T;
-export {};
-//# sourceMappingURL=types.d.ts.map

package/dist/utils/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/utils/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,KAAK,OAAO,GACR,IAAI,GACJ,KAAK,GACL,MAAM,GACN,OAAO,GACP,MAAM,GACN,MAAM,GACN,MAAM,GACN,IAAI,GACJ,SAAS,CAAC;AAEd;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,OAAO,GAC1C,CAAC,GACD,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GACtB,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GACrB,CAAC,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,GAC9B,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GAC7B,CAAC,SAAS,MAAM,GACd;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,GACtC,CAAC,CAAC"}