@cube-dev/ui-kit 0.0.0-canary-ce17ba4 → 0.0.0-canary-1bcd6b2

package/es/tasty/utils/renderStyles.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-ce17ba4
+ * @cube-dev/ui-kit v0.0.0-canary-1bcd6b2
  * Released under the MIT license.
  */
 
@@ -20,14 +20,7 @@
 import { Lru } from '../parser/lru';
 import { createStyle, STYLE_HANDLER_MAP } from '../styles';
 import { getModCombinationsIterative } from './getModCombinations';
-import { normalizeStyleZones, pointsToZones, } from './responsive';
 import { computeState, getModSelector, stringifyStyles, styleStateMapToStyleStateDataList, } from './styles';
-// Detect if a value is a state map whose entries contain responsive arrays
-function stateMapHasResponsiveArrays(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return false;
-    return Object.values(value).some((v) => Array.isArray(v));
-}
 // Cache logical rules per styles+breakpoints to avoid recomputation across identical calls
 const logicalRulesCache = new Lru(5000);
 // Normalize selector suffixes coming from `$` in style handler results.
@@ -387,11 +380,10 @@ function filterModsByPriority(allMods, styleStates, lookupStyles, parsedModsCach
 }
 /**
  * Explode a style handler result into logical rules with proper mapping
- * Phase 1: Handler fan-out ($ selectors, arrays)
- * Phase 2: Responsive fan-out (breakpoint arrays)
- * Phase 3: Rule materialization
+ * Phase 1: Handler fan-out ($ selectors)
+ * Phase 2: Rule materialization
  */
-function explodeHandlerResult(result, zones, selectorSuffix = '', forceBreakpointIdx, responsiveOrigin = false) {
+function explodeHandlerResult(result, selectorSuffix = '') {
     if (!result)
         return [];
     // Phase 1: Handler fan-out - normalize to array
@@ -401,90 +393,34 @@ function explodeHandlerResult(result, zones, selectorSuffix = '', forceBreakpoin
         if (!item || typeof item !== 'object')
             continue;
         const { $, ...styleProps } = item;
-        // Phase 2: Responsive fan-out - handle array values
-        const breakpointGroups = new Map();
-        if (forceBreakpointIdx !== undefined) {
-            // When breakpoint is forced (from responsive processing), use all props for that breakpoint
-            const group = {};
-            for (const [prop, value] of Object.entries(styleProps)) {
-                if (value != null && value !== '') {
-                    group[prop] = String(value);
-                }
-            }
-            if (Object.keys(group).length > 0) {
-                breakpointGroups.set(forceBreakpointIdx, group);
-            }
-        }
-        else {
-            // Normal processing - handle responsive arrays
-            const responsiveProps = [];
-            for (const [prop, value] of Object.entries(styleProps)) {
-                if (Array.isArray(value)) {
-                    // Responsive array - create entry for each breakpoint
-                    value.forEach((val, idx) => {
-                        if (val != null && val !== '' && idx < zones.length) {
-                            responsiveProps.push({ prop, value: val, breakpointIdx: idx });
-                        }
-                    });
-                }
-                else if (value != null && value !== '') {
-                    // Single value - goes to base breakpoint
-                    responsiveProps.push({ prop, value, breakpointIdx: 0 });
-                }
-            }
-            // Group by breakpoint index
-            for (const { prop, value, breakpointIdx } of responsiveProps) {
-                const group = breakpointGroups.get(breakpointIdx) || {};
-                group[prop] = String(value);
-                breakpointGroups.set(breakpointIdx, group);
+        // Build declarations from style props
+        const declarations = {};
+        for (const [prop, value] of Object.entries(styleProps)) {
+            if (value != null && value !== '') {
+                declarations[prop] = String(value);
             }
         }
-        // Phase 3: Selector fan-out - handle $ suffixes
+        if (Object.keys(declarations).length === 0)
+            continue;
+        // Phase 2: Selector fan-out - handle $ suffixes
         // IMPORTANT: If we are already in a pseudo-element context (contains '::'),
         // CSS does not allow further descendant/child selectors (e.g., '>*') after
-        // a pseudo-element. In such cases we must ignore only the `$`-derived
-        // selectors while still preserving base declarations for the current
-        // selector. Previously this branch returned early and accidentally dropped
-        // all declarations computed before, including valid base ones.
+        // a pseudo-element. In such cases we must ignore the `$`-derived selectors.
         const inPseudoElementContext = selectorSuffix.includes('::');
         if (inPseudoElementContext && $) {
             // Skip this item entirely to avoid producing invalid selectors like
-            // `.t0::before>*`. Other items (without $) in the same handler result
-            // will still be processed and preserved.
+            // `.t0::before>*`.
             continue;
         }
         const suffixes = $
             ? (Array.isArray($) ? $ : [$]).map((s) => selectorSuffix + normalizeDollarSelectorSuffix(String(s)))
             : [selectorSuffix];
-        // Early identical-breakpoint coalescing: skip duplicate declarations
-        const seenDeclarations = new Map();
-        // Process breakpoints in order to prefer lower breakpoint indices
-        const sortedBreakpoints = Array.from(breakpointGroups.entries()).sort(([a], [b]) => a - b);
-        for (const [breakpointIdx, declarations] of sortedBreakpoints) {
-            if (Object.keys(declarations).length === 0)
-                continue;
-            // Create a stable hash key for identical declarations
-            const declarationKeys = Object.keys(declarations).sort();
-            const declarationHash = declarationKeys
-                .map((key) => `${key}:${declarations[key]}`)
-                .join(';');
-            const existingBreakpointIdx = seenDeclarations.get(declarationHash);
-            if (existingBreakpointIdx !== undefined) {
-                // Skip this breakpoint as it has identical declarations to a previous one
-                // The CSS cascade will handle the responsive behavior correctly
-                continue;
-            }
-            // Mark this declaration set as seen
-            seenDeclarations.set(declarationHash, breakpointIdx);
-            // Create logical rules for this unique declaration set
-            for (const suffix of suffixes) {
-                logicalRules.push({
-                    selectorSuffix: suffix,
-                    breakpointIdx,
-                    declarations,
-                    responsiveSource: responsiveOrigin || forceBreakpointIdx !== undefined,
-                });
-            }
+        // Create logical rules for each suffix
+        for (const suffix of suffixes) {
+            logicalRules.push({
+                selectorSuffix: suffix,
+                declarations: { ...declarations },
+            });
         }
     }
     return logicalRules;
@@ -548,7 +484,7 @@ function convertHandlerResultToCSS(result, selectorSuffix = '') {
  * This consolidates the common logic for handling mod combinations, priority filtering,
  * contradiction checking, and selector optimization.
  */
-function processStateMapsWithModCombinations(styleStates, lookupStyles, zones, handler, parentSuffix, allLogicalRules, cachedNormalizeStyleZones, breakpointIdx, responsiveOrigin = false) {
+function processStateMapsWithModCombinations(styleStates, lookupStyles, handler, parentSuffix, allLogicalRules) {
     // Collect all mods from style states
     const allMods = [];
     const seenMods = new Set();
@@ -579,7 +515,7 @@ function processStateMapsWithModCombinations(styleStates, lookupStyles, zones, h
         const result = handler(stateProps);
         if (!result)
             return;
-        const logicalRules = explodeHandlerResult(result, zones, parentSuffix, breakpointIdx, responsiveOrigin);
+        const logicalRules = explodeHandlerResult(result, parentSuffix);
         allLogicalRules.push(...logicalRules);
         return;
     }
@@ -625,46 +561,18 @@ function processStateMapsWithModCombinations(styleStates, lookupStyles, zones, h
             return sel.startsWith(':not(') ? sel.slice(5, -1) : `:not(${sel})`;
         })
             .join('')}`;
-        // Check if any state value is responsive (array)
-        const hasResponsiveStateValues = lookupStyles.some((style) => Array.isArray(stateProps[style]));
-        if (hasResponsiveStateValues) {
-            // Fan out by breakpoint for responsive state values
-            const propsByPoint = zones.map((_, i) => {
-                const pointProps = {};
-                lookupStyles.forEach((style) => {
-                    const v = stateProps[style];
-                    if (Array.isArray(v)) {
-                        const arr = cachedNormalizeStyleZones(v, zones.length);
-                        pointProps[style] = arr?.[i];
-                    }
-                    else {
-                        pointProps[style] = v;
-                    }
-                });
-                return pointProps;
-            });
-            propsByPoint.forEach((props, bpIdx) => {
-                const res = handler(props);
-                if (!res)
-                    return;
-                const logical = explodeHandlerResult(res, zones, `${modsSelectors}${parentSuffix}`, bpIdx, true);
-                allLogicalRules.push(...logical);
-            });
-        }
-        else {
-            // Simple non-responsive state values
-            const result = handler(stateProps);
-            if (!result)
-                return;
-            const logical = explodeHandlerResult(result, zones, `${modsSelectors}${parentSuffix}`, breakpointIdx, responsiveOrigin);
-            allLogicalRules.push(...logical);
-        }
+        // Simple non-responsive state values
+        const result = handler(stateProps);
+        if (!result)
+            return;
+        const logical = explodeHandlerResult(result, `${modsSelectors}${parentSuffix}`);
+        allLogicalRules.push(...logical);
     });
 }
 /**
  * Convert logical rules to final StyleResult format
  */
-function materializeRules(logicalRules, className, zones) {
+function materializeRules(logicalRules, className) {
     return logicalRules.map((rule) => {
         // Generate base selector
         let selector = `.${className}${rule.selectorSuffix}`;
@@ -675,16 +583,9 @@ function materializeRules(logicalRules, className, zones) {
         const declarations = Object.entries(rule.declarations)
             .map(([prop, value]) => `${prop}: ${value};`)
             .join(' ');
-        const q = rule.breakpointIdx > 0
-            ? zones[rule.breakpointIdx]?.mediaQuery
-            : rule.responsiveSource
-                ? zones[0]?.mediaQuery
-                : undefined;
-        const atRules = q ? [`@media ${q}`] : undefined;
         return {
             selector,
             declarations,
-            atRules,
         };
     });
 }
@@ -692,102 +593,8 @@ function materializeRules(logicalRules, className, zones) {
  * Core style processing logic that generates logical rules
  * Used by the unified renderStyles function
  */
-function generateLogicalRules(styles, responsive = [], parentSuffix = '') {
-    const zones = pointsToZones(responsive || []);
+function generateLogicalRules(styles, parentSuffix = '') {
     const allLogicalRules = [];
-    // Cache for normalizeStyleZones results to avoid repeated computation
-    // WeakMap allows automatic cleanup when arrays are garbage collected
-    const normalizeCache = new WeakMap();
-    // Helper function to get cached normalizeStyleZones result
-    function cachedNormalizeStyleZones(value, zoneNumber) {
-        // Only cache for arrays - other types are fast to process
-        if (!Array.isArray(value)) {
-            return normalizeStyleZones(value, zoneNumber);
-        }
-        // Check if we have a cache for this array reference
-        let zoneCache = normalizeCache.get(value);
-        if (!zoneCache) {
-            zoneCache = new Map();
-            normalizeCache.set(value, zoneCache);
-        }
-        // Check if we have a cached result for this zone count
-        let result = zoneCache.get(zoneNumber);
-        if (result === undefined) {
-            result = normalizeStyleZones(value, zoneNumber);
-            zoneCache.set(zoneNumber, result);
-        }
-        return result;
-    }
-    // Local versions of helpers that leverage cachedNormalizeStyleZones
-    function stateMapToArrayOfStateMapsLocal(value, zoneNumber) {
-        // Short-circuit for single zone - avoid array allocation
-        if (zoneNumber === 1) {
-            const singleMap = {};
-            for (const [state, stateValue] of Object.entries(value)) {
-                if (Array.isArray(stateValue)) {
-                    // Take the first value from the array or null if empty
-                    singleMap[state] = stateValue.length > 0 ? stateValue[0] : null;
-                }
-                else {
-                    singleMap[state] = stateValue;
-                }
-            }
-            return [singleMap];
-        }
-        const result = Array.from({ length: zoneNumber }, () => ({}));
-        for (const [state, stateValue] of Object.entries(value)) {
-            const perZone = Array.isArray(stateValue)
-                ? cachedNormalizeStyleZones(stateValue, zoneNumber)
-                : Array(zoneNumber).fill(stateValue);
-            for (let i = 0; i < zoneNumber; i++) {
-                const v = perZone[i];
-                result[i][state] = v;
-            }
-        }
-        return result;
-    }
-    function normalizeArrayWithStateMapsLocal(valueArray, zoneNumber) {
-        // Short-circuit for single zone - avoid array propagation and mapping
-        if (zoneNumber === 1) {
-            const firstEntry = valueArray.length > 0 ? valueArray[0] : null;
-            if (firstEntry &&
-                typeof firstEntry === 'object' &&
-                !Array.isArray(firstEntry)) {
-                return [firstEntry];
-            }
-            return [{ '': firstEntry }];
-        }
-        const propagated = cachedNormalizeStyleZones(valueArray, zoneNumber);
-        // Trim trailing null/undefined entries to reduce processing
-        let lastNonNullIndex = propagated.length - 1;
-        while (lastNonNullIndex >= 0 && propagated[lastNonNullIndex] == null) {
-            lastNonNullIndex--;
-        }
-        // If all entries are null, return minimal array
-        if (lastNonNullIndex < 0) {
-            return Array.from({ length: zoneNumber }, () => ({ '': null }));
-        }
-        // Process only up to the last non-null entry, then fill the rest with the last value
-        const result = [];
-        let lastProcessedEntry = null;
-        for (let i = 0; i <= lastNonNullIndex; i++) {
-            const entry = propagated[i];
-            let processedEntry;
-            if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
-                processedEntry = entry;
-            }
-            else {
-                processedEntry = { '': entry };
-            }
-            result.push(processedEntry);
-            lastProcessedEntry = processedEntry;
-        }
-        // Fill remaining slots with the last processed entry (CSS cascade behavior)
-        for (let i = lastNonNullIndex + 1; i < zoneNumber; i++) {
-            result.push(lastProcessedEntry || { '': null });
-        }
-        return result;
-    }
     // Process styles recursively, preserving mod selectors and combining with nested selector suffixes
     function processStyles(currentStyles, parentSuffix = '') {
         const keys = Object.keys(currentStyles || {});
@@ -816,119 +623,51 @@ function generateLogicalRules(styles, responsive = [], parentSuffix = '') {
                     return;
                 }
                 seenHandlers.add(handler);
-                let isResponsive = false;
                 const lookupStyles = handler.__lookupStyles;
                 const filteredStyleMap = lookupStyles.reduce((map, name) => {
                     const value = currentStyles?.[name];
                     if (value !== undefined) {
-                        // Case 1: state-map-of-arrays → array-of-state-maps
-                        if (value &&
-                            typeof value === 'object' &&
-                            !Array.isArray(value) &&
-                            stateMapHasResponsiveArrays(value)) {
-                            map[name] = stateMapToArrayOfStateMapsLocal(value, zones.length);
-                            isResponsive = true;
-                        }
-                        else if (Array.isArray(value)) {
-                            // Case 2: array that may contain state maps → normalize to array-of-state-maps
-                            if (value.length > 0) {
-                                map[name] = normalizeArrayWithStateMapsLocal(value, zones.length);
-                                isResponsive = true;
-                            }
-                        }
-                        else {
-                            map[name] = value;
-                        }
+                        map[name] = value;
                     }
                     return map;
                 }, {});
                 handlerQueue.push({
                     handler,
                     styleMap: filteredStyleMap,
-                    isResponsive,
                 });
             });
         });
-        // Process handlers using the three-phase approach
-        handlerQueue.forEach(({ handler, styleMap, isResponsive }) => {
+        // Process handlers
+        handlerQueue.forEach(({ handler, styleMap }) => {
             const lookupStyles = handler.__lookupStyles;
-            if (isResponsive) {
-                // For responsive styles, resolve arrays using normalizeStyleZones
-                const valueMap = lookupStyles.reduce((map, style) => {
-                    map[style] = cachedNormalizeStyleZones(styleMap[style], zones.length);
-                    return map;
-                }, {});
-                // Create props for each breakpoint
-                const propsByPoint = zones.map((zone, i) => {
-                    const pointProps = {};
-                    lookupStyles.forEach((style) => {
-                        if (valueMap != null && valueMap[style] != null) {
-                            pointProps[style] = valueMap[style][i];
-                        }
-                    });
-                    return pointProps;
-                });
-                // Call handler for each breakpoint, with state map processing if needed
-                propsByPoint.forEach((pointProps, breakpointIdx) => {
-                    const hasStateMapsAtPoint = lookupStyles.some((style) => {
-                        const v = pointProps[style];
-                        return v && typeof v === 'object' && !Array.isArray(v);
-                    });
-                    if (hasStateMapsAtPoint) {
-                        // Build styleStates from point props
-                        const styleStates = {};
-                        lookupStyles.forEach((style) => {
-                            const v = pointProps[style];
-                            if (v && typeof v === 'object' && !Array.isArray(v)) {
-                                const { states } = styleStateMapToStyleStateDataList(v);
-                                styleStates[style] = states;
-                            }
-                            else {
-                                styleStates[style] = [{ mods: [], notMods: [], value: v }];
-                            }
-                        });
-                        // Use the consolidated helper for mod combination processing
-                        processStateMapsWithModCombinations(styleStates, lookupStyles, zones || [], handler, parentSuffix, allLogicalRules, cachedNormalizeStyleZones, breakpointIdx, true);
+            // Check if any values have state maps
+            const hasStateMaps = lookupStyles.some((style) => {
+                const value = styleMap[style];
+                return value && typeof value === 'object' && !Array.isArray(value);
+            });
+            if (hasStateMaps) {
+                // Build styleStates from styleMap
+                const styleStates = {};
+                lookupStyles.forEach((style) => {
+                    const value = styleMap[style];
+                    if (value && typeof value === 'object' && !Array.isArray(value)) {
+                        const { states } = styleStateMapToStyleStateDataList(value);
+                        styleStates[style] = states;
                     }
                     else {
-                        const result = handler(pointProps);
-                        if (!result)
-                            return;
-                        const logicalRules = explodeHandlerResult(result, zones || [], parentSuffix, breakpointIdx, true);
-                        allLogicalRules.push(...logicalRules);
+                        // Simple value, create a single state
+                        styleStates[style] = [{ mods: [], notMods: [], value }];
                     }
                 });
+                // Use the consolidated helper for mod combination processing
+                processStateMapsWithModCombinations(styleStates, lookupStyles, handler, parentSuffix, allLogicalRules);
             }
             else {
-                // For non-responsive styles, check if any values have state maps
-                const hasStateMaps = lookupStyles.some((style) => {
-                    const value = styleMap[style];
-                    return value && typeof value === 'object' && !Array.isArray(value);
-                });
-                if (hasStateMaps) {
-                    // Build styleStates from styleMap
-                    const styleStates = {};
-                    lookupStyles.forEach((style) => {
-                        const value = styleMap[style];
-                        if (value && typeof value === 'object' && !Array.isArray(value)) {
-                            const { states } = styleStateMapToStyleStateDataList(value);
-                            styleStates[style] = states;
-                        }
-                        else {
-                            // Simple value, create a single state
-                            styleStates[style] = [{ mods: [], notMods: [], value }];
-                        }
-                    });
-                    // Use the consolidated helper for mod combination processing
-                    processStateMapsWithModCombinations(styleStates, lookupStyles, zones || [], handler, parentSuffix, allLogicalRules, cachedNormalizeStyleZones);
-                }
-                else {
-                    // Simple case: no state maps, call handler directly
-                    const result = handler(styleMap);
-                    if (result) {
-                        const logical = explodeHandlerResult(result, zones || [], parentSuffix);
-                        allLogicalRules.push(...logical);
-                    }
+                // Simple case: no state maps, call handler directly
+                const result = handler(styleMap);
+                if (result) {
+                    const logical = explodeHandlerResult(result, parentSuffix);
+                    allLogicalRules.push(...logical);
                 }
             }
         });
@@ -937,21 +676,18 @@ function generateLogicalRules(styles, responsive = [], parentSuffix = '') {
     processStyles(styles, parentSuffix);
     return allLogicalRules;
 }
-export function renderStyles(styles, responsive = [], classNameOrSelector) {
+export function renderStyles(styles, classNameOrSelector) {
     const directSelector = !!classNameOrSelector;
     if (!styles) {
         return directSelector ? [] : { rules: [] };
     }
-    // Generate logical rules using shared pipeline (memoized per styles+breakpoints)
+    // Generate logical rules using shared pipeline (memoized per styles)
     const stylesKey = stringifyStyles(styles);
-    const bpKey = (responsive || []).join(',');
-    const lrKey = `${stylesKey}#${bpKey}`;
-    let allLogicalRules = logicalRulesCache.get(lrKey);
+    let allLogicalRules = logicalRulesCache.get(stylesKey);
     if (!allLogicalRules) {
-        allLogicalRules = generateLogicalRules(styles, responsive);
-        logicalRulesCache.set(lrKey, allLogicalRules);
+        allLogicalRules = generateLogicalRules(styles);
+        logicalRulesCache.set(stylesKey, allLogicalRules);
     }
-    const zones = pointsToZones(responsive || []);
     if (directSelector) {
         // Direct selector mode: convert logical rules directly to StyleResult format
         if (!classNameOrSelector) {
@@ -973,24 +709,17 @@ export function renderStyles(styles, responsive = [], classNameOrSelector) {
             const declarations = Object.entries(rule.declarations)
                 .map(([prop, value]) => `${prop}: ${value};`)
                 .join(' ');
-            const q = rule.breakpointIdx > 0
-                ? zones[rule.breakpointIdx]?.mediaQuery
-                : rule.responsiveSource
-                    ? zones[0]?.mediaQuery
-                    : undefined;
-            const atRules = q ? [`@media ${q}`] : undefined;
             return {
                 selector: finalSelector,
                 declarations,
-                atRules,
             };
         });
     }
     // Standard mode: use accumulation and materialization with className
     const accumulatedRules = new Map();
     for (const rule of allLogicalRules) {
-        // Create a key based on breakpointIdx, selectorSuffix, and responsiveOrigin
-        const ruleKey = `${rule.breakpointIdx}|${rule.selectorSuffix}|${rule.responsiveSource}`;
+        // Create a key based on selectorSuffix
+        const ruleKey = rule.selectorSuffix;
         const existing = accumulatedRules.get(ruleKey);
         if (existing) {
             // Merge declarations from this rule into the existing one
@@ -1000,9 +729,7 @@ export function renderStyles(styles, responsive = [], classNameOrSelector) {
             // Create a new accumulated rule
             accumulatedRules.set(ruleKey, {
                 selectorSuffix: rule.selectorSuffix,
-                breakpointIdx: rule.breakpointIdx,
                 declarations: { ...rule.declarations },
-                responsiveSource: rule.responsiveSource,
             });
         }
     }
@@ -1012,16 +739,9 @@ export function renderStyles(styles, responsive = [], classNameOrSelector) {
             const declarations = Object.entries(rule.declarations)
                 .map(([prop, value]) => `${prop}: ${value};`)
                 .join(' ');
-            const q = rule.breakpointIdx > 0
-                ? zones[rule.breakpointIdx]?.mediaQuery
-                : rule.responsiveSource
-                    ? zones[0]?.mediaQuery
-                    : undefined;
-            const atRules = q ? [`@media ${q}`] : undefined;
             return {
                 selector: rule.selectorSuffix || '',
                 declarations,
-                atRules,
                 needsClassName: true, // Flag for injector to prepend className
             };
         });
@@ -1030,7 +750,7 @@ export function renderStyles(styles, responsive = [], classNameOrSelector) {
         };
     }
     // Materialize the accumulated logical rules into final format
-    const finalRulesRaw = materializeRules(Array.from(accumulatedRules.values()), classNameOrSelector, zones || []);
+    const finalRulesRaw = materializeRules(Array.from(accumulatedRules.values()), classNameOrSelector);
     // Simplified deduplication (should be much less work now)
     const seen = new Set();
     const finalRules = finalRulesRaw.filter((rule) => {

package/es/tasty/utils/string.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-ce17ba4
+ * @cube-dev/ui-kit v0.0.0-canary-1bcd6b2
  * Released under the MIT license.
  */
 

package/es/tasty/utils/styles.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-ce17ba4
+ * @cube-dev/ui-kit v0.0.0-canary-1bcd6b2
  * Released under the MIT license.
  */
 
@@ -10,9 +10,8 @@ import { cacheWrapper } from './cache-wrapper';
 import { camelToKebab } from './case-converter';
 const devMode = process.env.NODE_ENV !== 'production';
 // Precompiled regex patterns for parseColor optimization
-// Match var(--name-color...) and extract the name, regardless of fallbacks
-const COLOR_VAR_PATTERN = /var\(--([a-z0-9-]+)-color/;
-const COLOR_VAR_RGB_PATTERN = /var\(--([a-z0-9-]+)-color-rgb/;
+const COLOR_VAR_PATTERN = /var\(--([a-z0-9-]+)-color(?:-rgb)?\)/;
+const COLOR_VAR_RGB_PATTERN = /var\(--([a-z0-9-]+)-color-rgb\)/;
 const RGB_ALPHA_PATTERN = /\/\s*([0-9.]+)\)/;
 const SIMPLE_COLOR_PATTERNS = [
     /^#[0-9a-fA-F]{3,8}$/, // Hex colors: #fff, #ffffff, #ffff, #ffffffff

package/es/tasty/utils/warnings.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-ce17ba4
+ * @cube-dev/ui-kit v0.0.0-canary-1bcd6b2
  * Released under the MIT license.
  */
 

package/es/tokens.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-ce17ba4
+ * @cube-dev/ui-kit v0.0.0-canary-1bcd6b2
  * Released under the MIT license.
  */
 

package/es/utils/ResizeSensor.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-ce17ba4
+ * @cube-dev/ui-kit v0.0.0-canary-1bcd6b2
  * Released under the MIT license.
  */
 

package/es/utils/index.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-ce17ba4
+ * @cube-dev/ui-kit v0.0.0-canary-1bcd6b2
  * Released under the MIT license.
  */
 

package/es/utils/modules.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-ce17ba4
+ * @cube-dev/ui-kit v0.0.0-canary-1bcd6b2
  * Released under the MIT license.
  */
 

package/es/utils/promise.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-ce17ba4
+ * @cube-dev/ui-kit v0.0.0-canary-1bcd6b2
  * Released under the MIT license.
  */