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

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';

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 {};