@svelte-atoms/core 1.0.0-alpha.44 → 1.0.0-alpha.46

package/README.md

@@ -1,5 +1,18 @@
 # @svelte-atoms/core
 
+> ⚠️ **Package renamed:** `@svelte-atoms/core` has moved to [`@ixirjs/ui`](https://www.npmjs.com/package/@ixirjs/ui).
+>
+> This package is deprecated and no longer maintained. To migrate:
+>
+> ```bash
+> npm uninstall @svelte-atoms/core
+> npm install @ixirjs/ui
+> ```
+>
+> Then update your imports from `'@svelte-atoms/core'` to `'@ixirjs/ui'`.
+>
+> Source: [github.com/ixirjs/ui](https://github.com/ixirjs/ui)
+
 > A modern, headless, and accessible Svelte 5 UI component library built for composability and extensibility.
 
 [![npm version](https://img.shields.io/npm/v/@svelte-atoms/core.svg)](https://www.npmjs.com/package/@svelte-atoms/core)

package/dist/components/accordion/item/accordion-item-body.svelte

@@ -12,10 +12,10 @@
 		children = undefined,
 		onmount = undefined,
 		ondestroy = undefined,
-		animate = undefined,
-		enter = enterAccordionItemBody(),
-		exit = exitAccordionItemBody(),
-		initial = undefined,
+		fallback = {
+			enter: enterAccordionItemBody(),
+			exit: exitAccordionItemBody()
+		},
 		preset = 'accordion.item.body',
 		...restProps
 	}: AccordionItemBodyProps<E, B> = $props();
@@ -35,10 +35,7 @@
 		class={['border-border box-content h-0 opacity-0', '$preset', klass]}
 		onmount={onmount?.bind(bond.state)}
 		ondestroy={ondestroy?.bind(bond.state)}
-		animate={animate?.bind(bond.state)}
-		enter={enter?.bind(bond.state)}
-		exit={exit?.bind(bond.state)}
-		initial={initial?.bind(bond.state)}
+		{fallback}
 		{...bodyProps}
 	>
 		{@render children?.({ accordionItem: bond })}

package/dist/components/accordion/item/accordion-item-header.svelte

@@ -7,13 +7,6 @@
 		class: klass = '',
 		as = 'button',
 		children = undefined,
-		onpointerdown = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = undefined,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
 		preset = 'accordion.item.header',
 		...restProps
 	}: AccordionItemHeaderProps = $props();
@@ -36,12 +29,6 @@
 		'$preset',
 		klass
 	]}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
 	tabindex={as !== 'button' ? 0 : undefined}
 	{...headerProps}
 >

package/dist/components/accordion/item/accordion-item-indicator.svelte

@@ -12,12 +12,6 @@
 	let {
 		class: klass = '',
 		children = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = _animate,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
 		preset = 'accordion.item.indicator',
 		...restProps
 	}: AccordionItemIndicatorProps<E, B> = $props();
@@ -35,12 +29,6 @@
 <HtmlAtom
 	{preset}
 	class={['border-border pointer-events-none flex items-center justify-center', '$preset', klass]}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
 	{...indicatorProps}
 >
 	{#if children}

package/dist/components/accordion/item/accordion-item-root.svelte

@@ -17,12 +17,6 @@
 		disabled = false,
 		factory = _factory,
 		children = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = undefined,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
 		preset = 'accordion.item',
 		...restProps
 	}: AccordionItemRootProps<E, B> = $props();
@@ -55,12 +49,6 @@
 	{bond}
 	{preset}
 	class={['border-border', '$preset', klass]}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
 	{...rootProps}
 >
 	{@render children?.({ accordionItem: bond })}

package/dist/components/alert/alert-actions.svelte

@@ -12,12 +12,6 @@
 		class: klass = '',
 		preset = 'alert.actions',
 		children = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = undefined,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
 		...restProps
 	}: AlertActionsProps<E, B> & HTMLAttributes<Element> = $props();
 
@@ -31,12 +25,6 @@
 	{bond}
 	{preset}
 	class={['alert-actions border-border mt-3 flex items-center gap-2', '$preset', klass]}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
 	{...actionsProps}
 >
 	{@render children?.({ alert: bond! })}

package/dist/components/alert/alert-close-button.svelte

@@ -17,12 +17,6 @@
 		as = 'button' as E,
 		preset = 'alert.close-button',
 		children = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = undefined,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
 		...restProps
 	}: AlertCloseButtonProps<E, B> & HTMLAttributes<Element> = $props();
 
@@ -41,12 +35,6 @@
 		'$preset',
 		klass
 	]}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
 	{...closeButtonProps}
 >
 	{#if children}

package/dist/components/alert/alert-content.svelte

@@ -12,12 +12,6 @@
 		class: klass = '',
 		preset = 'alert.content',
 		children = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = undefined,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
 		...restProps
 	}: AlertContentProps<E, B> & HTMLAttributes<Element> = $props();
 
@@ -31,12 +25,6 @@
 	{bond}
 	{preset}
 	class={['alert-content border-border flex-1 space-y-1', '$preset', klass]}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
 	{...contentProps}
 >
 	{@render children?.({ alert: bond! })}

package/dist/components/alert/alert-description.svelte

@@ -10,12 +10,6 @@
 		as = 'p' as E,
 		preset = 'alert.description',
 		children = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = undefined,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
 		...restProps
 	}: AlertDescriptionProps<E, B> = $props();
 
@@ -29,12 +23,6 @@
 	{bond}
 	{preset}
 	class={['alert-description border-border mt-1 text-sm leading-relaxed', '$preset', klass]}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
 	{as}
 	{...descriptionProps}
 >

package/dist/components/alert/alert-icon.svelte

@@ -11,12 +11,6 @@
 		base = Icon,
 		preset = 'alert.icon',
 		children = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = undefined,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
 		...restProps
 	}: AlertIconProps<E, B> = $props();
 
@@ -35,12 +29,6 @@
 		'$preset',
 		klass
 	]}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
 	{...iconProps}
 >
 	{@render children?.({ alert: bond! })}

package/dist/components/alert/alert-root.svelte

@@ -11,13 +11,7 @@
 		disabled = false,
 		extend = {},
 		factory = _factory,
-		children = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = undefined,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
+		children,
 		...restProps
 	}: AlertRootProps<E, B> = $props();
 
@@ -56,12 +50,6 @@
 		klass
 	]}
 	{bond}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
 	{...rootProps}
 >
 	{@render children?.({ alert: bond })}

package/dist/components/alert/alert-title.svelte

@@ -10,12 +10,6 @@
 		class: klass = '',
 		preset = 'alert.title',
 		children = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = undefined,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
 		...restProps
 	}: AlertTitleProps<E, B> = $props();
 
@@ -30,12 +24,6 @@
 	{bond}
 	{preset}
 	class={['alert-title border-border text-sm leading-tight font-medium', '$preset', klass]}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
 	{...titleProps}
 >
 	{@render children?.({ alert: bond! })}

package/dist/components/atom/html-atom.svelte

@@ -20,12 +20,13 @@
 
 	let {
 		class: klass = '',
-		as = 'div',
+		as = undefined,
 		base = undefined,
 		preset: presetKey = undefined,
 		bond = undefined,
 		variants = undefined,
-		children: childrenProp = undefined,
+		fallback = undefined,
+		children: children = undefined,
 		...restProps
 	}: HtmlAtomProps<E, B> = $props();
 
@@ -59,26 +60,39 @@
 
 	const finalBase = $derived(base ?? preset?.base);
 	const finalAs = $derived(as ?? preset?.as);
-	const finalRestProps = $derived(extractRestProps(preset, mergedVariants, restProps));
+	const finalRestProps = $derived(extractRestProps(preset, mergedVariants, restProps, fallback));
 
 	const atom = $derived(rootBond?.state?.props?.renderers?.html ?? HtmlElement);
 
-	const renderer = $derived.by(() => {
-		if (isSnippetBase(finalBase))
+	// Memoize the snippet check so the renderer component / props don't both
+	// recompute it on every reactive tick.
+	const baseIsSnippet = $derived(isSnippetBase(finalBase));
+
+	// Track the renderer component and its props as INDEPENDENT signals.
+	// - `rendererComponent` only flips when the underlying base/atom changes,
+	//   so Svelte won't tear down + remount when only props change.
+	// - `rendererProps` re-allocates when any prop changes, but doesn't drag
+	//   the component identity with it (no nested `{ component, props }` wrapper).
+	const RendererComponent = $derived(
+		baseIsSnippet ? (SnippetRenderer as unknown as Component) : ((finalBase ?? atom) as Component)
+	);
+
+	const rendererProps = $derived.by((): Record<string, unknown> => {
+		if (baseIsSnippet) {
 			return {
-				component: SnippetRenderer,
-				props: { snippet: finalBase, class: finalKlass, as: finalAs, children: childrenProp, ...finalRestProps }
+				snippet: finalBase,
+				class: finalKlass,
+				as: finalAs,
+				children: children,
+				...finalRestProps
 			};
+		}
+		return { class: finalKlass, as: finalAs, ...finalRestProps };
+	});
 
-		return {
-			component: finalBase ?? atom,
-			props: { class: finalKlass, as: finalAs, ...finalRestProps }
-		};
-	}) as { component: Component; props: Record<string, any> };
+	function forwardChildren(...args: any[]) {
+		return children?.(...args);
+	}
 </script>
 
-<renderer.component {...renderer.props}>
-	{#snippet children(args: any)}
-		{@render (childrenProp as any)?.(args)}
-	{/snippet}
-</renderer.component>
+<RendererComponent {...rendererProps} children={forwardChildren} />

package/dist/components/atom/types.d.ts

@@ -65,5 +65,14 @@ export interface HtmlAtomProps<E extends HtmlElementTagName = HtmlElementTagName
      * ```
      */
     variants?: Variants;
+    /**
+     * Fallback props applied **before** the preset, so user/preset configuration
+     * overrides them. Useful for component implementers who want sensible
+     * defaults (e.g. `animate`, `enter`, `exit`, `initial`) without preventing
+     * downstream consumers from customizing via presets.
+     *
+     * Merge order (last wins): `fallback` → `preset` → `variants` → `restProps`.
+     */
+    fallback?: Record<string, any> | undefined;
 }
 export type { ElementType };

package/dist/components/atom/utils/base.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns `true` when `base` is a Svelte 5 snippet (compiled to an arrow function
+ * with no `.prototype`), as opposed to a component (compiled to a named function
+ * that does have a `.prototype`).
+ */
+export declare function isSnippetBase(base: unknown): boolean;

package/dist/components/atom/utils/base.js

@@ -0,0 +1,8 @@
+/**
+ * Returns `true` when `base` is a Svelte 5 snippet (compiled to an arrow function
+ * with no `.prototype`), as opposed to a component (compiled to a named function
+ * that does have a `.prototype`).
+ */
+export function isSnippetBase(base) {
+    return typeof base === 'function' && !base.prototype;
+}

package/dist/components/atom/utils/cache.d.ts

@@ -0,0 +1,17 @@
+import type { Bond } from '../../../shared';
+export type ResolvedProps = Record<string, unknown>;
+export declare const MAX_CACHE_SIZE = 100;
+export declare function getCacheMap(bond: Bond | null | undefined): Map<string, ResolvedProps>;
+export declare function getDefCacheMap(def: object, bond: Bond | null | undefined): Map<string, ResolvedProps>;
+/**
+ * Performs a true-LRU lookup (touch on hit) and returns the cached value, or
+ * `undefined` if absent. Avoids the FIFO eviction bug of the previous impl.
+ */
+export declare function lruGet<V>(map: Map<string, V>, key: string): V | undefined;
+/** Insert with capacity eviction of the least-recently-used entry. */
+export declare function lruSet<V>(map: Map<string, V>, key: string, value: V, max: number): void;
+export declare function getCachedOwnKeys(obj: object | null | undefined): readonly string[];
+/** Returns true if `obj` has at least one own enumerable key. */
+export declare function hasOwnKeys(obj: object): boolean;
+export declare function hasOwnKeysCached(obj: object | null | undefined): boolean;
+export declare function getCompoundConditionKeys(compound: object): string[];

package/dist/components/atom/utils/cache.js

@@ -0,0 +1,134 @@
+/**
+ * Two-level cache for resolved variants (legacy / public API).
+ *
+ * - Outer key: bond instance (WeakMap — automatically GC'd when the bond is destroyed).
+ * - Inner key: JSON-stringified variant-relevant props.
+ * - Bond-less calls share a single flat Map.
+ *
+ * Kept exported for backward compatibility. Internal callers prefer
+ * `getDefCacheMap` which avoids global cross-component cache pollution.
+ */
+const variantCacheByBond = new WeakMap();
+const variantCacheNoBond = new Map();
+export const MAX_CACHE_SIZE = 100;
+export function getCacheMap(bond) {
+    if (!bond)
+        return variantCacheNoBond;
+    let map = variantCacheByBond.get(bond);
+    if (!map) {
+        map = new Map();
+        variantCacheByBond.set(bond, map);
+    }
+    return map;
+}
+/**
+ * Per-definition cache. The cache map is scoped to a `(def, bond)` pair, so
+ * different atoms never share the same eviction window — eliminating the
+ * cross-component thrash of the legacy global Map.
+ *
+ * `def` is keyed by reference via WeakMap, so cache entries are GC'd when
+ * the variant definition is no longer reachable.
+ */
+const defCacheBondMap = new WeakMap();
+const defCacheNoBondMap = new WeakMap();
+export function getDefCacheMap(def, bond) {
+    if (!bond) {
+        let m = defCacheNoBondMap.get(def);
+        if (!m) {
+            m = new Map();
+            defCacheNoBondMap.set(def, m);
+        }
+        return m;
+    }
+    const bondKey = bond;
+    let inner = defCacheBondMap.get(bondKey);
+    if (!inner) {
+        inner = new WeakMap();
+        defCacheBondMap.set(bondKey, inner);
+    }
+    let m = inner.get(def);
+    if (!m) {
+        m = new Map();
+        inner.set(def, m);
+    }
+    return m;
+}
+/**
+ * Performs a true-LRU lookup (touch on hit) and returns the cached value, or
+ * `undefined` if absent. Avoids the FIFO eviction bug of the previous impl.
+ */
+export function lruGet(map, key) {
+    const v = map.get(key);
+    if (v === undefined)
+        return undefined;
+    // Re-insert to mark as most-recently-used (Map preserves insertion order).
+    map.delete(key);
+    map.set(key, v);
+    return v;
+}
+/** Insert with capacity eviction of the least-recently-used entry. */
+export function lruSet(map, key, value, max) {
+    if (map.size >= max) {
+        const firstKey = map.keys().next().value;
+        if (firstKey !== undefined)
+            map.delete(firstKey);
+    }
+    map.set(key, value);
+}
+/**
+ * Cached `Object.keys(obj)` keyed by `obj` reference. Variant maps are stable
+ * per definition, so we avoid re-allocating the keys array every render.
+ */
+const ownKeysCache = new WeakMap();
+const EMPTY_KEYS = Object.freeze([]);
+export function getCachedOwnKeys(obj) {
+    if (!obj)
+        return EMPTY_KEYS;
+    let keys = ownKeysCache.get(obj);
+    if (!keys) {
+        keys = Object.keys(obj);
+        ownKeysCache.set(obj, keys);
+    }
+    return keys;
+}
+/** Returns true if `obj` has at least one own enumerable key. */
+export function hasOwnKeys(obj) {
+    for (const k in obj)
+        if (Object.hasOwn(obj, k))
+            return true;
+    return false;
+}
+/**
+ * Cached `hasOwnKeys` keyed weakly by the input object. Defaults objects are
+ * stable per variant definition, so we avoid re-walking the prototype chain
+ * on every render. Sentinel `null` is treated as "no" without consuming a slot.
+ */
+const hasOwnKeysCache = new WeakMap();
+export function hasOwnKeysCached(obj) {
+    if (!obj)
+        return false;
+    const cached = hasOwnKeysCache.get(obj);
+    if (cached !== undefined)
+        return cached;
+    const result = hasOwnKeys(obj);
+    hasOwnKeysCache.set(obj, result);
+    return result;
+}
+/**
+ * Cached non-`class` keys for a compound variant condition. Compounds are
+ * stable per variant definition, so their condition keys never change.
+ * Weakly keyed → freed when the compound object is unreachable.
+ */
+const compoundKeysCache = new WeakMap();
+export function getCompoundConditionKeys(compound) {
+    let keys = compoundKeysCache.get(compound);
+    if (!keys) {
+        keys = [];
+        for (const k in compound) {
+            if (Object.hasOwn(compound, k) && k !== 'class')
+                keys.push(k);
+        }
+        compoundKeysCache.set(compound, keys);
+    }
+    return keys;
+}

package/dist/components/atom/utils/classes.d.ts

@@ -0,0 +1,14 @@
+import { type ClassValue } from '../../../utils';
+/**
+ * Merges user-supplied class, preset class, and resolved variant class into a
+ * single Tailwind-safe class string.
+ *
+ * Supports the special `$preset` placeholder inside the user class string, which
+ * lets the caller control exactly where the preset classes are injected.
+ *
+ * Rules:
+ * - No `$preset` → normal merge: `cn(userClass, variantClass)`.
+ * - Has `$preset` → only the **last** occurrence acts as the injection point:
+ *   `beforePlaceholder + presetClass + variantClass + afterPlaceholder`.
+ */
+export declare function mergeClassesWithPreset(userClass: string | ClassValue | undefined, presetClass: ClassValue | undefined, variantClass: ClassValue | undefined): string;

package/dist/components/atom/utils/classes.js

@@ -0,0 +1,42 @@
+import { cn } from '../../../utils';
+/**
+ * Merges user-supplied class, preset class, and resolved variant class into a
+ * single Tailwind-safe class string.
+ *
+ * Supports the special `$preset` placeholder inside the user class string, which
+ * lets the caller control exactly where the preset classes are injected.
+ *
+ * Rules:
+ * - No `$preset` → normal merge: `cn(userClass, variantClass)`.
+ * - Has `$preset` → only the **last** occurrence acts as the injection point:
+ *   `beforePlaceholder + presetClass + variantClass + afterPlaceholder`.
+ */
+export function mergeClassesWithPreset(userClass, presetClass, variantClass) {
+    // Fast path: user class is a plain string and contains no `$preset` placeholder
+    // — by far the most common case. Skip the prelim `cn()` call entirely.
+    if (typeof userClass === 'string') {
+        if (userClass.indexOf('$preset') === -1) {
+            return cn(userClass, variantClass ?? '');
+        }
+    }
+    else if (userClass == null) {
+        return cn(variantClass ?? '');
+    }
+    else {
+        // Non-string ClassValue (array/object) — must run through `cn()` first
+        // to detect a `$preset` placeholder potentially nested inside.
+        const merged = cn(userClass);
+        if (merged.indexOf('$preset') === -1) {
+            return cn(merged, variantClass ?? '');
+        }
+        const lastIdx = merged.lastIndexOf('$preset');
+        return cn(merged.slice(0, lastIdx), cn(presetClass), variantClass ?? '', merged.slice(lastIdx + '$preset'.length));
+    }
+    // Slow path: `$preset` placeholder resolution for string `userClass`.
+    const klassStr = userClass;
+    const lastIdx = klassStr.lastIndexOf('$preset');
+    const beforeLastPlaceholder = klassStr.slice(0, lastIdx);
+    const afterLastPlaceholder = klassStr.slice(lastIdx + '$preset'.length);
+    const presetClassString = cn(presetClass);
+    return cn(beforeLastPlaceholder, presetClassString, variantClass ?? '', afterLastPlaceholder);
+}

package/dist/components/atom/utils/constants.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Props stripped when spreading preset props onto the element.
+ * These are internal atom configuration keys that are not valid DOM attributes.
+ */
+export declare const PRESET_SKIP: Set<string>;
+/**
+ * Props stripped when spreading resolved variant objects.
+ */
+export declare const VARIANTS_SKIP: Set<string>;

package/dist/components/atom/utils/constants.js

@@ -0,0 +1,9 @@
+/**
+ * Props stripped when spreading preset props onto the element.
+ * These are internal atom configuration keys that are not valid DOM attributes.
+ */
+export const PRESET_SKIP = new Set(['class', 'base', 'as', 'variants', 'compounds', 'defaults']);
+/**
+ * Props stripped when spreading resolved variant objects.
+ */
+export const VARIANTS_SKIP = new Set(['class', 'variants', 'compounds', 'defaults']);

package/dist/components/atom/utils/index.d.ts

@@ -0,0 +1,6 @@
+export { resolvePreset } from './preset';
+export { isSnippetBase } from './base';
+export { mergeClassesWithPreset } from './classes';
+export { resolveVariants, mergeVariants, resolveLocalVariants } from './variants';
+export { extractRestProps } from './props';
+export type { ResolvedProps } from './cache';

package/dist/components/atom/utils/index.js

@@ -0,0 +1,5 @@
+export { resolvePreset } from './preset';
+export { isSnippetBase } from './base';
+export { mergeClassesWithPreset } from './classes';
+export { resolveVariants, mergeVariants, resolveLocalVariants } from './variants';
+export { extractRestProps } from './props';