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

package/dist/context/preset.svelte.d.ts

@@ -12,7 +12,17 @@ export interface PresetEntryRecord {
     defaults?: Record<string, any>;
     attachments?: Attachment[];
 }
-export type PresetEntry = (bond: Bond | undefined | null, ...args: any[]) => PresetEntryRecord | (() => PresetEntryRecord);
+/** A single preset entry value — either a record or a deferred factory returning one. */
+export type PresetEntryValue = PresetEntryRecord | (() => PresetEntryRecord);
+/**
+ * A preset entry — invoked with a bond and returns either a single
+ * {@link PresetEntryValue} or an array of them.
+ *
+ * Returning an array makes it easy to layer/merge preset configurations
+ * (e.g. base preset + per-route override + per-component override). Entries
+ * are merged in order, with later entries taking precedence.
+ */
+export type PresetEntry = (bond: Bond | undefined | null, ...args: any[]) => PresetEntryValue | Array<PresetEntryValue>;
 /**
  * Registry of all preset slot names → their PresetEntry type.
  *
@@ -31,7 +41,7 @@ export type PresetEntry = (bond: Bond | undefined | null, ...args: any[]) => Pre
  * ```
  */
 export interface PresetModuleMap {
-    'accordion': PresetEntry;
+    accordion: PresetEntry;
     'accordion.item.body': PresetEntry;
     'accordion.item.header': PresetEntry;
     'accordion.item.indicator': PresetEntry;
@@ -41,7 +51,7 @@ export interface PresetModuleMap {
     'alert.content': PresetEntry;
     'alert.description': PresetEntry;
     'alert.icon': PresetEntry;
-    'alert': PresetEntry;
+    alert: PresetEntry;
     'alert.title': PresetEntry;
     'card.content': PresetEntry;
     'card.description': PresetEntry;
@@ -49,13 +59,13 @@ export interface PresetModuleMap {
     'card.header': PresetEntry;
     'card.body': PresetEntry;
     'card.media': PresetEntry;
-    'card': PresetEntry;
+    card: PresetEntry;
     'card.subtitle': PresetEntry;
     'card.title': PresetEntry;
     'collapsible.body': PresetEntry;
     'collapsible.header': PresetEntry;
     'collapsible.indicator': PresetEntry;
-    'collapsible': PresetEntry;
+    collapsible: PresetEntry;
     'combobox.control': PresetEntry;
     'combobox.trigger': PresetEntry;
     'combobox.item': PresetEntry;
@@ -65,30 +75,30 @@ export interface PresetModuleMap {
     'dialog.description': PresetEntry;
     'dialog.footer': PresetEntry;
     'dialog.header': PresetEntry;
-    'dialog': PresetEntry;
+    dialog: PresetEntry;
     'dialog.title': PresetEntry;
-    'divider': PresetEntry;
+    divider: PresetEntry;
     'dropdown.placeholder': PresetEntry;
     'dropdown.query': PresetEntry;
     'dropdown.trigger': PresetEntry;
     'dropdown.selections': PresetEntry;
     'dropdown.selection': PresetEntry;
-    'dropdown': PresetEntry;
+    dropdown: PresetEntry;
     'dropdown.item': PresetEntry;
     'field.control': PresetEntry;
     'field.label': PresetEntry;
     'field.helper-text': PresetEntry;
-    'field': PresetEntry;
-    'form': PresetEntry;
-    'icon': PresetEntry;
-    'input': PresetEntry;
+    field: PresetEntry;
+    form: PresetEntry;
+    icon: PresetEntry;
+    input: PresetEntry;
     'input.control': PresetEntry;
     'input.password': PresetEntry;
     'input.placeholder': PresetEntry;
-    'label': PresetEntry;
+    label: PresetEntry;
     'layer.inner': PresetEntry;
-    'layer': PresetEntry;
-    'link': PresetEntry;
+    layer: PresetEntry;
+    link: PresetEntry;
     'list.divider': PresetEntry;
     'list.group': PresetEntry;
     'list.item': PresetEntry;
@@ -98,11 +108,11 @@ export interface PresetModuleMap {
     'popover.content': PresetEntry;
     'popover.trigger': PresetEntry;
     'portal.inner': PresetEntry;
-    'portal': PresetEntry;
-    'root': PresetEntry;
+    portal: PresetEntry;
+    root: PresetEntry;
     'root.portals': PresetEntry;
     'sidebar.content': PresetEntry;
-    'sidebar': PresetEntry;
+    sidebar: PresetEntry;
     'drawer.backdrop': PresetEntry;
     'drawer.body': PresetEntry;
     'drawer.content': PresetEntry;
@@ -110,10 +120,10 @@ export interface PresetModuleMap {
     'drawer.title': PresetEntry;
     'drawer.footer': PresetEntry;
     'drawer.header': PresetEntry;
-    'drawer': PresetEntry;
+    drawer: PresetEntry;
     'stack.root': PresetEntry;
     'stack.item': PresetEntry;
-    'stepper': PresetEntry;
+    stepper: PresetEntry;
     'stepper.header': PresetEntry;
     'stepper.body': PresetEntry;
     'stepper.footer': PresetEntry;
@@ -124,16 +134,16 @@ export interface PresetModuleMap {
     'stepper.step.separator': PresetEntry;
     'tabs.body': PresetEntry;
     'tabs.header': PresetEntry;
-    'tabs': PresetEntry;
+    tabs: PresetEntry;
     'tab.header': PresetEntry;
     'tab.body': PresetEntry;
     'tab.description': PresetEntry;
-    'tab': PresetEntry;
+    tab: PresetEntry;
     'tree.body': PresetEntry;
     'tree.header': PresetEntry;
     'tree.indicator': PresetEntry;
-    'tree': PresetEntry;
-    'datagrid': PresetEntry;
+    tree: PresetEntry;
+    datagrid: PresetEntry;
     'datagrid.header': PresetEntry;
     'datagrid.column': PresetEntry;
     'datagrid.body': PresetEntry;
@@ -142,31 +152,29 @@ export interface PresetModuleMap {
     'datagrid.footer': PresetEntry;
     'datagrid.checkbox': PresetEntry;
     'datagrid.sort-icon': PresetEntry;
-    'scrollable': PresetEntry;
+    scrollable: PresetEntry;
     'scrollable.container': PresetEntry;
     'scrollable.content': PresetEntry;
     'scrollable.track': PresetEntry;
     'scrollable.thumb': PresetEntry;
-    'toast': PresetEntry;
-    'toast.toaster': PresetEntry;
-    'toast.item': PresetEntry;
+    toast: PresetEntry;
     'toast.title': PresetEntry;
     'toast.description': PresetEntry;
-    'toast.close-button': PresetEntry;
-    'breadcrumb': PresetEntry;
+    'toast.close': PresetEntry;
+    breadcrumb: PresetEntry;
     'breadcrumb.item': PresetEntry;
     'breadcrumb.separator': PresetEntry;
-    'badge': PresetEntry;
-    'chip': PresetEntry;
+    badge: PresetEntry;
+    chip: PresetEntry;
     'chip.close-button': PresetEntry;
-    'button': PresetEntry;
-    'checkbox': PresetEntry;
+    button: PresetEntry;
+    checkbox: PresetEntry;
     'checkbox.checkmark': PresetEntry;
     'checkbox.indeterminate': PresetEntry;
-    'radio': PresetEntry;
+    radio: PresetEntry;
     'radio.group': PresetEntry;
-    'container': PresetEntry;
-    'calendar': PresetEntry;
+    container: PresetEntry;
+    calendar: PresetEntry;
     'calendar.day': PresetEntry;
     'calendar.header': PresetEntry;
     'calendar.weekday': PresetEntry;
@@ -176,6 +184,13 @@ export interface PresetModuleMap {
     'datepicker.years': PresetEntry;
     'datepicker.months': PresetEntry;
     'datepicker.header': PresetEntry;
+    progress: PresetEntry;
+    'progress.linear': PresetEntry;
+    'progress.linear.track': PresetEntry;
+    'progress.linear.fill': PresetEntry;
+    'progress.circular': PresetEntry;
+    'progress.circular.track': PresetEntry;
+    'progress.circular.fill': PresetEntry;
 }
 /** All valid preset slot names — derived from PresetModuleMap for extensibility. */
 export type PresetModuleName = keyof PresetModuleMap;
@@ -185,3 +200,4 @@ export type Preset = {
 export declare function getPreset<K extends PresetModuleName>(key: K): PresetEntry | undefined;
 export declare function getPreset(): Partial<Preset> | undefined;
 export declare function setPreset(preset: Partial<Preset>): Partial<Preset>;
+export declare function mergePreset(callback: (currentPreset: Partial<Preset> | undefined) => Partial<Preset>): Partial<Preset>;

package/dist/context/preset.svelte.js

@@ -1,5 +1,5 @@
 import { getContext, setContext } from 'svelte';
-import { merge } from 'es-toolkit';
+import { mergePresetRecords, resolvePreset } from '../components/atom/utils/preset';
 const CONTEXT_KEY = '@svelte-atoms/context/preset';
 export function getPreset(...args) {
     const context = getContext(CONTEXT_KEY);
@@ -10,6 +10,32 @@ export function getPreset(...args) {
     return context;
 }
 export function setPreset(preset) {
-    const currentPreset = getPreset() || {};
-    return setContext(CONTEXT_KEY, merge(currentPreset, preset));
+    return mergePreset(() => preset);
+}
+export function mergePreset(callback) {
+    const currentPreset = getPreset();
+    const override = callback(currentPreset);
+    const result = { ...currentPreset };
+    const keys = Object.keys(override);
+    for (let i = 0; i < keys.length; i++) {
+        const k = keys[i];
+        const next = override[k];
+        if (!next)
+            continue;
+        const existing = currentPreset?.[k];
+        if (existing) {
+            const e = existing, n = next;
+            result[k] = ((bond, ...args) => {
+                const a = resolvePreset(e(bond, ...args));
+                const b = resolvePreset(n(bond, ...args));
+                if (a && b)
+                    return mergePresetRecords([a, b]);
+                return a ?? b;
+            });
+        }
+        else {
+            result[k] = next;
+        }
+    }
+    return setContext(CONTEXT_KEY, result);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@svelte-atoms/core",
-	"version": "1.0.0-alpha.44",
+	"version": "1.0.0-alpha.46",
 	"description": "A modular, accessible, and extensible Svelte UI component library.",
 	"repository": {
 		"type": "git",

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

@@ -1,44 +0,0 @@
-import type { Bond } from '../../shared';
-import { type ClassValue, type VariantDefinition } from '../../utils';
-type ResolvedProps = Record<string, unknown>;
-type AnyVariantDefinition = VariantDefinition<any>;
-/**
- * Resolves preset to its final value, handling both direct values and factory functions
- */
-export declare function resolvePreset<T>(preset: T | (() => T) | undefined): T | undefined;
-/**
- * Pure function to resolve variant definition to props
- * Caches results to avoid recomputation with same inputs
- */
-export declare function resolveVariants(def: AnyVariantDefinition, bond: Bond | null | undefined, props: Record<string, unknown>): ResolvedProps;
-/**
- * Pure function to merge preset and local variant definitions
- * Returns merged variant props with local overriding preset
- */
-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;
-/**
- * Pure function to merge classes with $preset placeholder support
- * Handles the special $preset placeholder for precise positioning of preset classes
- */
-export declare function mergeClassesWithPreset(userClass: string | ClassValue | undefined, presetClass: ClassValue | undefined, variantClass: ClassValue | undefined): string;
-/**
- * Pure function to resolve local variants.
- * Handles both function-based and VariantDefinition-based variants.
- *
- * If the function was created by `defineVariants`, it carries a VARIANT_DEF_TAG
- * symbol with the original config. We detect this and route through the cached
- * resolveVariants engine so defineVariants-based variants benefit from the same
- * two-level WeakMap cache as raw VariantDefinition objects.
- */
-export declare function resolveLocalVariants(variants: any, bond: Bond | null | undefined, props: Record<string, unknown>): ResolvedProps | undefined;
-/**
- * Pure function to extract rest props by filtering out preset and variant-specific props
- */
-export declare function extractRestProps(preset: Record<string, any> | undefined, mergedVariants: ResolvedProps | undefined, restProps: Record<string, unknown>): Record<string, unknown>;
-/**
- * Pure function to check if a base is a snippet.
- * Svelte 5 snippets compile to arrow functions (no prototype),
- * while components compile to named functions (with prototype).
- */
-export declare function isSnippetBase(base: unknown): boolean;
-export {};

package/dist/components/atom/utils.js

@@ -1,275 +0,0 @@
-import { cn, VARIANT_DEF_TAG } from '../../utils';
-import { call } from '../../utils/function';
-/**
- * Two-level cache for resolved variants.
- * Outer key: bond instance identity (WeakMap for automatic GC when bond is destroyed).
- * Inner key: JSON stringified variant-relevant props.
- * Bond-less calls share a single flat Map.
- */
-const variantCacheByBond = new WeakMap();
-const variantCacheNoBond = new Map();
-const MAX_CACHE_SIZE = 100;
-function getCacheMap(bond) {
-    if (!bond)
-        return variantCacheNoBond;
-    let map = variantCacheByBond.get(bond);
-    if (!map) {
-        map = new Map();
-        variantCacheByBond.set(bond, map);
-    }
-    return map;
-}
-function hasOwnKeys(obj) {
-    for (const k in obj)
-        if (Object.hasOwn(obj, k))
-            return true;
-    return false;
-}
-const PRESET_SKIP = new Set(['class', 'base', 'as', 'variants', 'compounds', 'defaults']);
-const VARIANTS_SKIP = new Set(['class', 'variants', 'compounds', 'defaults']);
-/**
- * Resolves preset to its final value, handling both direct values and factory functions
- */
-export function resolvePreset(preset) {
-    if (!preset)
-        return undefined;
-    const result = call(preset);
-    // If call returns a function, call it again (handle deferred preset)
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return typeof result === 'function' ? result() : result;
-}
-/**
- * Pure function to resolve variant definition to props
- * Caches results to avoid recomputation with same inputs
- */
-export function resolveVariants(def, bond, props) {
-    const { variants: variantMap, compounds, defaults, class: baseClass } = def;
-    // Merge props with defaults
-    const finalProps = defaults && hasOwnKeys(defaults) ? { ...defaults, ...props } : props;
-    const variantKeys = variantMap ? Object.keys(variantMap) : [];
-    // Fast path: no variants or compounds — skip cache entirely
-    if (variantKeys.length === 0 && !compounds?.length) {
-        return { class: baseClass ? [baseClass] : [] };
-    }
-    // Build cache key only when variants are present
-    const relevantProps = {};
-    for (const key of variantKeys)
-        if (key in finalProps)
-            relevantProps[key] = finalProps[key];
-    const cacheKey = JSON.stringify({ relevantProps, baseClass, compounds });
-    const cacheMap = getCacheMap(bond);
-    if (cacheMap.has(cacheKey)) {
-        return cacheMap.get(cacheKey);
-    }
-    const classes = [];
-    const attributes = {};
-    // Add base class
-    if (baseClass)
-        classes.push(baseClass);
-    // Add variant classes
-    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) {
-                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);
-                    }
-                    // Add other attributes (including Symbol-based attachment keys)
-                    Object.getOwnPropertySymbols(resolved).forEach((sym) => {
-                        attributes[sym] = resolved[sym];
-                    });
-                }
-            }
-        }
-    }
-    // Add compound variants
-    if (compounds?.length) {
-        for (const compound of compounds) {
-            const compoundClass = compound.class;
-            const compoundPropKeys = new Set(Object.keys(compound).filter((k) => k !== 'class'));
-            let matches = true;
-            for (const key of compoundPropKeys) {
-                if (finalProps[key] !== compound[key]) {
-                    matches = false;
-                    break;
-                }
-            }
-            if (matches) {
-                if (compoundClass)
-                    classes.push(compoundClass);
-                // Add compound attributes (string keys that are not condition keys or 'class')
-                for (const [k, v] of Object.entries(compound)) {
-                    if (k !== 'class' && !compoundPropKeys.has(k))
-                        attributes[k] = v;
-                }
-            }
-        }
-    }
-    const result = {
-        class: classes,
-        ...attributes
-    };
-    // Store in cache (limit per-bond cache size to prevent memory leaks)
-    if (cacheMap.size >= MAX_CACHE_SIZE) {
-        const firstKey = cacheMap.keys().next().value;
-        if (firstKey)
-            cacheMap.delete(firstKey);
-    }
-    cacheMap.set(cacheKey, result);
-    return result;
-}
-/**
- * Pure function to merge preset and local variant definitions
- * Returns merged variant props with local overriding preset
- */
-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) {
-    // No variants at all
-    if (!presetVariants && !localVariants)
-        return undefined;
-    // Only preset variants (raw object from preset)
-    if (presetVariants && !localVariants) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const variantDef = {
-            class: presetClass ?? '',
-            variants: presetVariants,
-            compounds: presetCompounds ?? [],
-            defaults: presetDefaults ?? {}
-        };
-        return resolveVariants(variantDef, bond, props);
-    }
-    // Only local variants
-    if (!presetVariants && localVariants) {
-        return localVariants;
-    }
-    // Both exist - merge them
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const presetVariantDef = {
-        class: presetClass ?? '',
-        variants: presetVariants ?? {},
-        compounds: presetCompounds ?? [],
-        defaults: presetDefaults ?? {}
-    };
-    const presetResolved = resolveVariants(presetVariantDef, bond, props);
-    // Merge the resolved variant props
-    // Local variant classes and attributes override preset
-    const presetClasses = Array.isArray(presetResolved.class)
-        ? presetResolved.class
-        : [presetResolved.class];
-    const localClasses = Array.isArray(localVariants?.class)
-        ? localVariants.class
-        : [localVariants?.class];
-    return {
-        ...presetResolved,
-        ...localVariants,
-        class: [...presetClasses, ...localClasses].filter(Boolean)
-    };
-}
-/**
- * Pure function to merge classes with $preset placeholder support
- * Handles the special $preset placeholder for precise positioning of preset classes
- */
-export function mergeClassesWithPreset(userClass, presetClass, variantClass) {
-    const klassStr = cn(userClass ?? '');
-    // Check for $preset placeholder first
-    if (!klassStr.includes('$preset')) {
-        // No placeholder - normal merge: variants override direct class
-        return cn(userClass, variantClass ?? '');
-    }
-    // Has placeholder - calculate position and inject preset classes
-    const parts = klassStr.split('$preset');
-    // Only keep the last $preset placeholder
-    const beforeLastPlaceholder = parts.slice(0, -1).join('');
-    const afterLastPlaceholder = parts[parts.length - 1];
-    const presetClassString = cn(presetClass);
-    // Merge: before + preset + variants + after
-    return cn(beforeLastPlaceholder, presetClassString, variantClass ?? '', afterLastPlaceholder);
-}
-/**
- * Pure function to resolve local variants.
- * Handles both function-based and VariantDefinition-based variants.
- *
- * If the function was created by `defineVariants`, it carries a VARIANT_DEF_TAG
- * symbol with the original config. We detect this and route through the cached
- * resolveVariants engine so defineVariants-based variants benefit from the same
- * two-level WeakMap cache as raw VariantDefinition objects.
- */
-export function resolveLocalVariants(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-variants, bond, props) {
-    if (!variants)
-        return undefined;
-    // Detect functions tagged by defineVariants — route through the cache
-    if (typeof variants === 'function' && VARIANT_DEF_TAG in variants) {
-        const config = variants[VARIANT_DEF_TAG];
-        // If config is a function (dynamic/bond-based), resolve it to a VariantDefinition first
-        const resolvedConfig = typeof config === 'function' ? config(bond) : config;
-        return resolveVariants(resolvedConfig, bond, props);
-    }
-    // Plain function (legacy / manual variants fn) — call directly, no cache
-    if (typeof variants === 'function') {
-        return variants(bond, props);
-    }
-    // Raw VariantDefinition object — resolve through cache
-    return resolveVariants(variants, bond, props);
-}
-/**
- * Internal keys that are never valid DOM attributes — stripped before spreading onto element
- */
-const INTERNAL_PROPS = new Set(['class', 'base', 'as', 'variants', 'compounds', 'defaults']);
-/**
- * Pure function to extract rest props by filtering out preset and variant-specific props
- */
-export function extractRestProps(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-preset, mergedVariants, restProps) {
-    const result = {};
-    if (preset) {
-        for (const k in preset)
-            if (Object.hasOwn(preset, k) && !PRESET_SKIP.has(k))
-                result[k] = preset[k];
-        // Preserve Symbol-keyed attachment props (e.g. from createAttachmentKey())
-        const symPreset = preset;
-        for (const s of Object.getOwnPropertySymbols(preset))
-            result[s] = symPreset[s];
-    }
-    if (mergedVariants) {
-        for (const k in mergedVariants)
-            if (Object.hasOwn(mergedVariants, k) && !VARIANTS_SKIP.has(k))
-                result[k] = mergedVariants[k];
-        // Preserve Symbol-keyed attachment props (e.g. from variant definitions)
-        const symProps = mergedVariants;
-        for (const s of Object.getOwnPropertySymbols(mergedVariants))
-            result[s] = symProps[s];
-    }
-    for (const k in restProps)
-        if (Object.hasOwn(restProps, k))
-            result[k] = restProps[k];
-    // Preserve Symbol-keyed attachment props from restProps (e.g. {@attach} directives)
-    const symRestProps = restProps;
-    for (const s of Object.getOwnPropertySymbols(restProps))
-        result[s] = symRestProps[s];
-    return result;
-}
-/**
- * Pure function to check if a base is a snippet.
- * Svelte 5 snippets compile to arrow functions (no prototype),
- * while components compile to named functions (with prototype).
- */
-export function isSnippetBase(base) {
-    return typeof base === 'function' && !base.prototype;
-}