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

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

@@ -0,0 +1,22 @@
+import type { PresetEntryRecord, PresetEntryValue } from '../../../context/preset.svelte';
+/**
+ * Merges an ordered list of {@link PresetEntryRecord}s into a single record.
+ *
+ * - `class`: collected into an array (all classes preserved, later ones appended)
+ * - `compounds`: arrays concatenated
+ * - `attachments`: arrays concatenated
+ * - `variants`: deep-merged
+ * - `defaults`: shallow-merged
+ * - any other field: last entry wins
+ */
+export declare function mergePresetRecords(records: PresetEntryRecord[]): PresetEntryRecord | undefined;
+/**
+ * Resolves a preset to its concrete value.
+ *
+ * - If `preset` is falsy, returns `undefined`.
+ * - If it is an array, each entry is resolved (unwrapping deferred factories)
+ *   and the results are merged via {@link mergePresetRecords}.
+ * - Otherwise, unwraps up to two levels of factory functions.
+ */
+export declare function resolvePreset(preset: PresetEntryValue | Array<PresetEntryValue> | undefined): PresetEntryRecord | undefined;
+export declare function resolvePreset<T>(preset: T | (() => T) | undefined): T | undefined;

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

@@ -0,0 +1,94 @@
+import { merge } from 'es-toolkit';
+import { call } from '../../../utils/function';
+/**
+ * Merges an ordered list of {@link PresetEntryRecord}s into a single record.
+ *
+ * - `class`: collected into an array (all classes preserved, later ones appended)
+ * - `compounds`: arrays concatenated
+ * - `attachments`: arrays concatenated
+ * - `variants`: deep-merged
+ * - `defaults`: shallow-merged
+ * - any other field: last entry wins
+ */
+export function mergePresetRecords(records) {
+    const len = records.length;
+    if (!len)
+        return undefined;
+    if (len === 1)
+        return records[0];
+    const result = {};
+    const classes = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const compounds = [];
+    const attachments = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const variantsList = [];
+    for (let i = 0; i < len; i++) {
+        const record = records[i];
+        if (!record)
+            continue;
+        if (record.class !== undefined)
+            classes.push(record.class);
+        const recCompounds = record.compounds;
+        if (recCompounds?.length) {
+            for (let j = 0, jlen = recCompounds.length; j < jlen; j++)
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                compounds.push(recCompounds[j]);
+        }
+        const recAttachments = record.attachments;
+        if (recAttachments?.length) {
+            for (let j = 0, jlen = recAttachments.length; j < jlen; j++)
+                attachments.push(recAttachments[j]);
+        }
+        if (record.variants)
+            variantsList.push(record.variants);
+        if (record.defaults)
+            result.defaults =
+                result.defaults !== undefined
+                    ? { ...result.defaults, ...record.defaults }
+                    : record.defaults;
+        // Copy remaining own keys directly — avoids allocating an intermediate `rest` object.
+        // Use hasOwnProperty guard so prototype-chain properties are never copied.
+        for (const key in record) {
+            if (!Object.prototype.hasOwnProperty.call(record, key) ||
+                key === 'class' ||
+                key === 'compounds' ||
+                key === 'attachments' ||
+                key === 'variants' ||
+                key === 'defaults')
+                continue;
+            result[key] = record[key];
+        }
+    }
+    if (classes.length)
+        result.class = classes.length === 1 ? classes[0] : classes;
+    if (compounds.length)
+        result.compounds = compounds;
+    if (attachments.length)
+        result.attachments = attachments;
+    // Single merge pass over all variant maps — avoids N-1 intermediate objects
+    if (variantsList.length) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let merged = {};
+        for (let j = 0; j < variantsList.length; j++)
+            merged = merge(merged, variantsList[j]);
+        result.variants = merged;
+    }
+    return result;
+}
+export function resolvePreset(preset) {
+    if (!preset)
+        return undefined;
+    if (Array.isArray(preset)) {
+        const resolved = [];
+        for (const entry of preset) {
+            const value = resolvePreset(entry);
+            if (value)
+                resolved.push(value);
+        }
+        return mergePresetRecords(resolved);
+    }
+    const result = call(preset);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return typeof result === 'function' ? result() : result;
+}

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

@@ -0,0 +1,13 @@
+import type { ResolvedProps } from './cache';
+/**
+ * Builds the final spread-ready props object by layering, in ascending priority:
+ * fallback → preset → mergedVariants → restProps.
+ *
+ * `fallback` is the lowest-priority source and is intended for internal defaults
+ * (e.g. a default `animate` function) that should only apply when neither the
+ * preset nor the consumer has specified the prop.
+ *
+ * Internal atom keys (`class`, `base`, `as`, …) are stripped; Symbol-keyed
+ * attachment props are preserved at every layer.
+ */
+export declare function extractRestProps(preset: Record<string, any> | undefined, mergedVariants: ResolvedProps | undefined, restProps: Record<string, unknown>, fallback?: Record<string, any> | undefined): Record<string, unknown>;

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

@@ -0,0 +1,60 @@
+import { PRESET_SKIP, VARIANTS_SKIP } from './constants';
+/**
+ * Copies own string-keyed props from `src` into `result`, skipping any keys in
+ * `skip` (or no skip list when `skip` is undefined). Falls back to `for...in`
+ * which only iterates own + enumerable inherited keys; the additional
+ * `Object.hasOwn` guard mirrors the original behavior for safety.
+ */
+function copyStringKeys(src, skip, result) {
+    for (const k in src) {
+        if (!Object.hasOwn(src, k))
+            continue;
+        if (skip && skip.has(k))
+            continue;
+        result[k] = src[k];
+    }
+}
+/**
+ * Copies symbol-keyed props from `src` into `result`. Only allocates the
+ * symbols array when the source actually has any (the 99% case has none).
+ */
+function copySymbolKeys(src, result) {
+    const syms = Object.getOwnPropertySymbols(src);
+    if (syms.length === 0)
+        return;
+    for (const s of syms)
+        result[s] = src[s];
+}
+/**
+ * Builds the final spread-ready props object by layering, in ascending priority:
+ * fallback → preset → mergedVariants → restProps.
+ *
+ * `fallback` is the lowest-priority source and is intended for internal defaults
+ * (e.g. a default `animate` function) that should only apply when neither the
+ * preset nor the consumer has specified the prop.
+ *
+ * Internal atom keys (`class`, `base`, `as`, …) are stripped; Symbol-keyed
+ * attachment props are preserved at every layer.
+ */
+export function extractRestProps(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+preset, mergedVariants, restProps, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+fallback) {
+    const result = {};
+    if (fallback) {
+        copyStringKeys(fallback, PRESET_SKIP, result);
+        copySymbolKeys(fallback, result);
+    }
+    if (preset) {
+        copyStringKeys(preset, PRESET_SKIP, result);
+        copySymbolKeys(preset, result);
+    }
+    if (mergedVariants) {
+        copyStringKeys(mergedVariants, VARIANTS_SKIP, result);
+        copySymbolKeys(mergedVariants, result);
+    }
+    copyStringKeys(restProps, undefined, result);
+    copySymbolKeys(restProps, result);
+    return result;
+}

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

@@ -0,0 +1,31 @@
+import type { Bond } from '../../../shared';
+import { type ClassValue, type VariantDefinition } from '../../../utils';
+import { type ResolvedProps } from './cache';
+type AnyVariantDefinition = VariantDefinition<any>;
+/**
+ * Resolves a `VariantDefinition` to a concrete `ResolvedProps` object.
+ *
+ * Results are cached in a per-definition LRU keyed by bond instance + a fast
+ * structural key over variant-relevant props, so the same inputs always return
+ * the same (reference-equal) object without re-computing.
+ */
+export declare function resolveVariants(def: AnyVariantDefinition, bond: Bond | null | undefined, props: Record<string, unknown>): ResolvedProps;
+/**
+ * Merges preset variant definitions with locally-supplied resolved variant props.
+ * Local values always take precedence; classes are concatenated (preset first).
+ */
+export declare function mergeVariants(presetVariants: Record<string, any> | undefined, presetClass: ClassValue | undefined, presetCompounds: Array<Record<string, any>> | undefined, presetDefaults: Record<string, any> | undefined, localVariants: ResolvedProps | undefined, bond: Bond | null | undefined, props: Record<string, unknown>): ResolvedProps | undefined;
+/**
+ * Resolves locally-supplied `variants` to a `ResolvedProps` object.
+ *
+ * Handles three shapes:
+ * - A function tagged with `VARIANT_DEF_TAG` (created by `defineVariants`) → routed through the
+ *   cached `resolveVariants` engine.
+ * - A plain function (manual/legacy) → called with a per-(fn, bond) snapshot
+ *   cache so re-renders with the same primitive props return the same result
+ *   reference. Falls back to direct invocation when props contain non-primitive
+ *   values.
+ * - A raw `VariantDefinition` object → resolved through the cache.
+ */
+export declare function resolveLocalVariants(variants: any, bond: Bond | null | undefined, props: Record<string, unknown>): ResolvedProps | undefined;
+export {};

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

@@ -0,0 +1,270 @@
+import { VARIANT_DEF_TAG } from '../../../utils';
+import { getDefCacheMap, getCachedOwnKeys, getCompoundConditionKeys, hasOwnKeysCached, lruGet, lruSet, MAX_CACHE_SIZE } from './cache';
+/**
+ * Builds a compact cache key from variant-relevant prop values without
+ * paying the cost of `JSON.stringify`. Variant prop values are almost always
+ * primitives (the keys of a variant map), so we serialize inline and only fall
+ * back to `JSON.stringify` for the rare object value.
+ */
+function buildVariantKey(variantKeys, finalProps) {
+    let key = '';
+    for (const k of variantKeys) {
+        if (!(k in finalProps))
+            continue;
+        const v = finalProps[k];
+        // Discriminate type so e.g. `"true"` and `true` don't collide.
+        const t = typeof v;
+        if (v === undefined) {
+            key += k + '=u|';
+        }
+        else if (v === null) {
+            key += k + '=n|';
+        }
+        else if (t === 'string' || t === 'number' || t === 'boolean') {
+            key += k + '=' + t[0] + ':' + v + '|';
+        }
+        else {
+            key += k + '=o:' + JSON.stringify(v) + '|';
+        }
+    }
+    return key;
+}
+/**
+ * Resolves a `VariantDefinition` to a concrete `ResolvedProps` object.
+ *
+ * Results are cached in a per-definition LRU keyed by bond instance + a fast
+ * structural key over variant-relevant props, so the same inputs always return
+ * the same (reference-equal) object without re-computing.
+ */
+export function resolveVariants(def, bond, props) {
+    const { variants: variantMap, compounds, defaults, class: baseClass } = def;
+    const finalProps = hasOwnKeysCached(defaults) ? { ...defaults, ...props } : props;
+    const variantKeys = getCachedOwnKeys(variantMap);
+    // Fast path: no variants or compounds — cached per `def` reference so
+    // repeated renders return the SAME object (preserves downstream identity).
+    if (variantKeys.length === 0 && !compounds?.length) {
+        const fastMap = getDefCacheMap(def, bond);
+        const fastHit = lruGet(fastMap, '');
+        if (fastHit !== undefined)
+            return fastHit;
+        const fastResult = { class: baseClass ? [baseClass] : [] };
+        lruSet(fastMap, '', fastResult, MAX_CACHE_SIZE);
+        return fastResult;
+    }
+    const cacheKey = buildVariantKey(variantKeys, finalProps);
+    const cacheMap = getDefCacheMap(def, bond);
+    const hit = lruGet(cacheMap, cacheKey);
+    if (hit !== undefined)
+        return hit;
+    const classes = [];
+    const attributes = {};
+    if (baseClass)
+        classes.push(baseClass);
+    if (variantMap) {
+        for (const key of variantKeys) {
+            const value = finalProps[key];
+            if (value === undefined)
+                continue;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const variantValue = variantMap[key]?.[value];
+            if (variantValue === undefined)
+                continue;
+            const resolved = typeof variantValue === 'function' ? variantValue(bond) : variantValue;
+            if (typeof resolved === 'string') {
+                classes.push(resolved);
+            }
+            else if (typeof resolved === 'object' && resolved !== null) {
+                if ('class' in resolved)
+                    classes.push(resolved.class);
+                const syms = Object.getOwnPropertySymbols(resolved);
+                if (syms.length) {
+                    const src = resolved;
+                    for (const sym of syms)
+                        attributes[sym] = src[sym];
+                }
+            }
+        }
+    }
+    if (compounds?.length) {
+        for (const compound of compounds) {
+            const compoundClass = compound.class;
+            const conditionKeys = getCompoundConditionKeys(compound);
+            let matches = true;
+            for (const key of conditionKeys) {
+                if (finalProps[key] !== compound[key]) {
+                    matches = false;
+                    break;
+                }
+            }
+            if (!matches)
+                continue;
+            if (compoundClass)
+                classes.push(compoundClass);
+        }
+    }
+    const result = { class: classes, ...attributes };
+    lruSet(cacheMap, cacheKey, result, MAX_CACHE_SIZE);
+    return result;
+}
+/**
+ * Cache constructed preset variant defs by `presetVariants` reference so the
+ * downstream per-def cache (`getDefCacheMap`) hits across renders.
+ */
+const presetDefCache = new WeakMap();
+function getOrBuildPresetDef(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+presetVariants, presetClass, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+presetCompounds, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+presetDefaults) {
+    const cached = presetDefCache.get(presetVariants);
+    if (cached)
+        return cached;
+    const built = {
+        class: presetClass ?? '',
+        variants: presetVariants,
+        compounds: presetCompounds ?? [],
+        defaults: presetDefaults ?? {}
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    };
+    presetDefCache.set(presetVariants, built);
+    return built;
+}
+/**
+ * Merge cache: chained WeakMaps keyed by `(presetResolved, localVariants)`.
+ *
+ * Both inputs come from `resolveVariants` / `resolveLocalVariants`, which
+ * return reference-stable objects across renders. When neither flips, we
+ * return the SAME merged object every time — eliminating a fresh array+spread
+ * allocation on the hot path. Keys are weak so entries are GC'd whenever
+ * either input is unreachable.
+ */
+const mergeCache = new WeakMap();
+function getCachedMerge(presetResolved, localVariants) {
+    const inner = mergeCache.get(presetResolved);
+    return inner?.get(localVariants);
+}
+function setCachedMerge(presetResolved, localVariants, merged) {
+    let inner = mergeCache.get(presetResolved);
+    if (!inner) {
+        inner = new WeakMap();
+        mergeCache.set(presetResolved, inner);
+    }
+    inner.set(localVariants, merged);
+}
+/**
+ * Merges preset variant definitions with locally-supplied resolved variant props.
+ * Local values always take precedence; classes are concatenated (preset first).
+ */
+export function mergeVariants(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+presetVariants, presetClass, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+presetCompounds, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+presetDefaults, localVariants, bond, props) {
+    if (!presetVariants && !localVariants)
+        return undefined;
+    if (presetVariants && !localVariants) {
+        const variantDef = getOrBuildPresetDef(presetVariants, presetClass, presetCompounds, presetDefaults);
+        return resolveVariants(variantDef, bond, props);
+    }
+    if (!presetVariants && localVariants)
+        return localVariants;
+    const presetVariantDef = getOrBuildPresetDef(
+    // `presetVariants` is non-null in this branch (TS narrowing lost via `&&`).
+    presetVariants, presetClass, presetCompounds, presetDefaults);
+    const presetResolved = resolveVariants(presetVariantDef, bond, props);
+    // `localVariants` is guaranteed non-null in this branch.
+    const local = localVariants;
+    const cachedMerge = getCachedMerge(presetResolved, local);
+    if (cachedMerge !== undefined)
+        return cachedMerge;
+    const presetClasses = Array.isArray(presetResolved.class)
+        ? presetResolved.class
+        : [presetResolved.class];
+    const localClasses = Array.isArray(local.class) ? local.class : [local.class];
+    const merged = {
+        ...presetResolved,
+        ...local,
+        class: [...presetClasses, ...localClasses].filter(Boolean)
+    };
+    setCachedMerge(presetResolved, local, merged);
+    return merged;
+}
+const plainFnCacheBond = new WeakMap();
+const plainFnCacheNoBond = new WeakMap();
+function getPlainFnEntry(fn, bond) {
+    if (!bond)
+        return plainFnCacheNoBond.get(fn);
+    const inner = plainFnCacheBond.get(fn);
+    return inner?.get(bond);
+}
+function setPlainFnEntry(fn, bond, entry) {
+    if (!bond) {
+        plainFnCacheNoBond.set(fn, entry);
+        return;
+    }
+    let inner = plainFnCacheBond.get(fn);
+    if (!inner) {
+        inner = new WeakMap();
+        plainFnCacheBond.set(fn, inner);
+    }
+    inner.set(bond, entry);
+}
+function snapshotPrimitiveProps(props) {
+    let s = '';
+    const keys = Object.keys(props).sort();
+    for (const k of keys) {
+        const v = props[k];
+        const t = typeof v;
+        if (v === null) {
+            s += k + '=n|';
+        }
+        else if (t === 'string' || t === 'number' || t === 'boolean' || t === 'undefined') {
+            s += k + '=' + (t === 'undefined' ? 'u' : t[0]) + ':' + String(v) + '|';
+        }
+        else {
+            // Non-primitive value: cannot safely structural-compare — bail out.
+            return null;
+        }
+    }
+    return s;
+}
+/**
+ * Resolves locally-supplied `variants` to a `ResolvedProps` object.
+ *
+ * Handles three shapes:
+ * - A function tagged with `VARIANT_DEF_TAG` (created by `defineVariants`) → routed through the
+ *   cached `resolveVariants` engine.
+ * - A plain function (manual/legacy) → called with a per-(fn, bond) snapshot
+ *   cache so re-renders with the same primitive props return the same result
+ *   reference. Falls back to direct invocation when props contain non-primitive
+ *   values.
+ * - A raw `VariantDefinition` object → resolved through the cache.
+ */
+export function resolveLocalVariants(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+variants, bond, props) {
+    if (!variants)
+        return undefined;
+    if (typeof variants === 'function' && VARIANT_DEF_TAG in variants) {
+        const config = variants[VARIANT_DEF_TAG];
+        const resolvedConfig = typeof config === 'function' ? config(bond) : config;
+        return resolveVariants(resolvedConfig, bond, props);
+    }
+    if (typeof variants === 'function') {
+        const snapshot = snapshotPrimitiveProps(props);
+        if (snapshot !== null) {
+            const cached = getPlainFnEntry(variants, bond);
+            if (cached && cached.snapshot === snapshot)
+                return cached.result;
+            const result = variants(bond, props);
+            setPlainFnEntry(variants, bond, { snapshot, result });
+            return result;
+        }
+        return variants(bond, props);
+    }
+    return resolveVariants(variants, bond, props);
+}

package/dist/components/card/card-body.svelte

@@ -8,12 +8,6 @@
 	let {
 		class: klass = '',
 		children = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = undefined,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
 		...restProps
 	}: CardContentProps<E, B> = $props();
 
@@ -27,12 +21,6 @@
 	{bond}
 	preset="card.content"
 	class={['card-content border-border px-4 pb-4', '$preset', klass]}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
 	{...contentProps}
 >
 	{@render children?.()}

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

@@ -9,12 +9,6 @@
 		class: klass = '',
 		as = 'p' as E,
 		children = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = undefined,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
 		...restProps
 	}: CardDescriptionProps<E, B> = $props();
 
@@ -29,12 +23,6 @@
 	{bond}
 	preset="card.description"
 	class={['card-description border-border text-sm text-gray-500', '$preset', klass]}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
 	{...descriptionProps}
 >
 	{@render children?.()}

package/dist/components/card/card-footer.svelte

@@ -9,12 +9,6 @@
 		class: klass = '',
 		as = 'div' as E,
 		children = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = undefined,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
 		...restProps
 	}: CardFooterProps<E, B> = $props();
 
@@ -29,12 +23,6 @@
 	{bond}
 	preset="card.footer"
 	class={['card-footer border-border flex items-center gap-2 px-4 pb-4', '$preset', klass]}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
 	{...footerProps}
 >
 	{@render children?.()}

package/dist/components/card/card-header.svelte

@@ -9,12 +9,6 @@
 		class: klass = '',
 		as = 'div' as E,
 		children = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = undefined,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
 		...restProps
 	}: CardHeaderProps<E, B> = $props();
 
@@ -29,12 +23,6 @@
 	{bond}
 	preset="card.header"
 	class={['card-header border-border flex flex-col space-y-1.5 px-4 py-4', '$preset', klass]}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
 	{...headerProps}
 >
 	{@render children?.()}

package/dist/components/card/card-media.svelte

@@ -9,12 +9,6 @@
 		class: klass = '',
 		as = 'div' as E,
 		children = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = undefined,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
 		...restProps
 	}: CardMediaProps<E, B> = $props();
 
@@ -29,12 +23,6 @@
 	{bond}
 	preset="card.media"
 	class={['card-media border-border overflow-hidden', '$preset', klass]}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
 	{...mediaProps}
 >
 	{@render children?.()}

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

@@ -13,12 +13,6 @@
 		children = undefined,
 		onclick = undefined,
 		onkeydown = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = undefined,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
 		...restProps
 	}: CardRootProps<E, B> = $props();
 
@@ -78,12 +72,6 @@
 		klass
 	]}
 	{bond}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
 	onclick={handleClick}
 	onkeydown={handleKeydown}
 	{...rootProps}

package/dist/components/card/card-subtitle.svelte

@@ -9,12 +9,6 @@
 		class: klass = '',
 		as = 'p' as E,
 		children = undefined,
-		onmount = undefined,
-		ondestroy = undefined,
-		animate = undefined,
-		enter = undefined,
-		exit = undefined,
-		initial = undefined,
 		...restProps
 	}: CardSubtitleProps<E, B> = $props();
 
@@ -29,12 +23,6 @@
 	{bond}
 	preset="card.subtitle"
 	class={['card-subtitle border-border text-sm font-medium text-gray-600', '$preset', klass]}
-	enter={enter?.bind(bond.state)}
-	exit={exit?.bind(bond.state)}
-	initial={initial?.bind(bond.state)}
-	animate={animate?.bind(bond.state)}
-	onmount={onmount?.bind(bond.state)}
-	ondestroy={ondestroy?.bind(bond.state)}
 	{...subtitleProps}
 >
 	{@render children?.()}