@cube-dev/ui-kit 0.0.0-canary-2d5ce5e → 0.0.0-canary-42c23bd

package/types/tasty/styles/dimension.d.ts

@@ -1 +1,4 @@
-export declare function dimensionStyle(name: any): (val: any) => "" | Record<string, string | string[]>;
+export declare function dimensionStyle(name: any): (val: any) => "" | {
+    [x: string]: string;
+    [x: number]: string;
+};

package/types/tasty/styles/height.d.ts

@@ -1,6 +1,9 @@
 export declare function heightStyle({ height }: {
     height: any;
-}): "" | Record<string, string | string[]>;
+}): "" | {
+    [x: string]: string;
+    [x: number]: string;
+};
 export declare namespace heightStyle {
     var __lookupStyles: string[];
 }

package/types/tasty/styles/width.d.ts

@@ -1,6 +1,9 @@
 export declare function widthStyle({ width }: {
     width: any;
-}): "" | Record<string, string | string[]>;
+}): "" | {
+    [x: string]: string;
+    [x: number]: string;
+};
 export declare namespace widthStyle {
     var __lookupStyles: string[];
 }

package/types/tasty/utils/styles.d.ts

@@ -1,5 +1,4 @@
 import { Styles } from '../styles/types';
-import type { ProcessedStyle, StyleDetails } from '../../parser/types';
 export type StyleValue<T = string> = T | boolean | number | null | undefined;
 export type StyleValueStateMap<T = string> = {
     [key: string]: StyleValue<T>;
@@ -94,22 +93,13 @@ export declare const CUSTOM_UNITS: {
 };
 export declare const DIRECTIONS: string[];
 export declare function createRule(prop: string, value: StyleValue, selector?: string): string;
-export declare function customFunc(name: string, fn: (groups: StyleDetails[]) => string): void;
 /**
  *
  * @param {String} value
  * @param {Number} mode
  * @returns {Object<String,String|Array>}
  */
-export declare function parseStyle(value: StyleValue, mode?: number): ProcessedStyle;
-export declare function flattenStyleDetails(processed: ProcessedStyle): {
-    values: string[];
-    mods: string[];
-    colors: string[];
-    all: string[];
-    value: string;
-    color: string | undefined;
-};
+export declare function parseStyle(value: StyleValue, mode?: number): ParsedStyle;
 /**
  * Parse color. Find it value, name and opacity.
  */

package/es/parser/classify.js

@@ -1,156 +0,0 @@
-/**
- * @license MIT
- * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-2d5ce5e
- * Released under the MIT license.
- */
-
-import { COLOR_FUNCS, RE_HEX, RE_NUMBER, RE_UNIT_NUM, VALUE_KEYWORDS, } from './const';
-import { StyleParser } from './parser';
-import { Bucket } from './types';
-export function classify(raw, opts, recurse) {
-    const token = raw.trim();
-    if (!token)
-        return { bucket: Bucket.Mod, processed: '' };
-    // Quoted string literals should be treated as value tokens (e.g., "" for content)
-    if ((token.startsWith('"') && token.endsWith('"')) ||
-        (token.startsWith("'") && token.endsWith("'"))) {
-        return { bucket: Bucket.Value, processed: token };
-    }
-    // 0. Direct var(--*-color) token
-    const varColorMatch = token.match(/^var\(--([a-z0-9-]+)-color\)$/);
-    if (varColorMatch) {
-        return { bucket: Bucket.Color, processed: token };
-    }
-    // 1. URL
-    if (token.startsWith('url(')) {
-        return { bucket: Bucket.Value, processed: token };
-    }
-    // 2. Custom property
-    if (token[0] === '@') {
-        const match = token.match(/^@\(([a-z0-9-_]+)\s*,\s*(.*)\)$/);
-        if (match) {
-            const [, name, fallback] = match;
-            const processedFallback = recurse(fallback).output;
-            return {
-                bucket: Bucket.Value,
-                processed: `var(--${name}, ${processedFallback})`,
-            };
-        }
-        const identMatch = token.match(/^@([a-z0-9-_]+)$/);
-        if (identMatch) {
-            const name = identMatch[1];
-            const processed = `var(--${name})`;
-            const bucketType = name.endsWith('-color') ? Bucket.Color : Bucket.Value;
-            return {
-                bucket: bucketType,
-                processed,
-            };
-        }
-        // invalid custom property → modifier
-    }
-    // 3. Hash colors (with optional alpha suffix e.g., #purple.5)
-    if (token[0] === '#' && token.length > 1) {
-        // alpha form: #name.alpha
-        const alphaMatch = token.match(/^#([a-z0-9-]+)\.([0-9]+)$/i);
-        if (alphaMatch) {
-            const [, base, rawAlpha] = alphaMatch;
-            let alpha;
-            if (rawAlpha === '0')
-                alpha = '0';
-            else
-                alpha = `.${rawAlpha}`;
-            return {
-                bucket: Bucket.Color,
-                processed: `rgb(var(--${base}-color-rgb) / ${alpha})`,
-            };
-        }
-        // hyphenated names like #dark-05 should keep full name
-        const name = token.slice(1);
-        // valid hex → treat as hex literal with fallback
-        if (RE_HEX.test(name)) {
-            return {
-                bucket: Bucket.Color,
-                processed: `var(--${name}-color, #${name})`,
-            };
-        }
-        // simple color name token → css variable lookup with rgb fallback
-        return { bucket: Bucket.Color, processed: `var(--${name}-color)` };
-    }
-    // 4 & 5. Functions
-    const openIdx = token.indexOf('(');
-    if (openIdx > 0 && token.endsWith(')')) {
-        const fname = token.slice(0, openIdx);
-        const inner = token.slice(openIdx + 1, -1); // without ()
-        if (COLOR_FUNCS.has(fname)) {
-            // Process inner to expand nested colors or units.
-            const argProcessed = recurse(inner).output.replace(/,\s+/g, ','); // color funcs expect no spaces after commas
-            return { bucket: Bucket.Color, processed: `${fname}(${argProcessed})` };
-        }
-        // user function (provided via opts)
-        if (opts.funcs && fname in opts.funcs) {
-            // split by top-level commas within inner
-            const tmp = new StyleParser(opts).process(inner); // fresh parser w/ same opts but no cache share issues
-            const argProcessed = opts.funcs[fname](tmp.groups);
-            return { bucket: Bucket.Value, processed: argProcessed };
-        }
-        // generic: process inner and rebuild
-        const argProcessed = recurse(inner).output;
-        return { bucket: Bucket.Value, processed: `${fname}(${argProcessed})` };
-    }
-    // 6. Auto-calc group
-    if (token[0] === '(' && token[token.length - 1] === ')') {
-        const inner = token.slice(1, -1);
-        const innerProcessed = recurse(inner).output;
-        return { bucket: Bucket.Value, processed: `calc(${innerProcessed})` };
-    }
-    // 7. Unit number
-    const um = token.match(RE_UNIT_NUM);
-    if (um) {
-        const unit = um[1];
-        const numericPart = parseFloat(token.slice(0, -unit.length));
-        const handler = opts.units && opts.units[unit];
-        if (handler) {
-            if (typeof handler === 'string') {
-                // Special-case the common `x` → gap mapping used by tests.
-                const base = unit === 'x' ? 'var(--gap)' : handler;
-                if (numericPart === 1) {
-                    return { bucket: Bucket.Value, processed: base };
-                }
-                return {
-                    bucket: Bucket.Value,
-                    processed: `calc(${numericPart} * ${base})`,
-                };
-            }
-            else {
-                const inner = handler(numericPart);
-                // Avoid double wrapping if handler already returns a calc(...)
-                return {
-                    bucket: Bucket.Value,
-                    processed: inner.startsWith('calc(') ? inner : `calc(${inner})`,
-                };
-            }
-        }
-    }
-    // 7b. Unknown numeric+unit → treat as literal value (e.g., 1fr)
-    if (/^[+-]?(?:\d*\.\d+|\d+)[a-z%]+$/.test(token)) {
-        return { bucket: Bucket.Value, processed: token };
-    }
-    // 7c. Plain unit-less numbers should be treated as value tokens so that
-    // code such as `scrollbar={10}` resolves correctly.
-    if (RE_NUMBER.test(token)) {
-        return { bucket: Bucket.Value, processed: token };
-    }
-    // 8. Literal value keywords
-    if (VALUE_KEYWORDS.has(token)) {
-        return { bucket: Bucket.Value, processed: token };
-    }
-    // 8b. Special keyword colors
-    if (token === 'transparent' || token === 'currentcolor') {
-        return { bucket: Bucket.Color, processed: token };
-    }
-    // 9. Fallback modifier
-    return { bucket: Bucket.Mod, processed: token };
-}
-
-        

package/es/parser/const.js

@@ -1,36 +0,0 @@
-/**
- * @license MIT
- * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-2d5ce5e
- * Released under the MIT license.
- */
-
-export const VALUE_KEYWORDS = new Set([
-    'auto',
-    'max-content',
-    'min-content',
-    'fit-content',
-    'stretch',
-    'initial',
-]);
-export const COLOR_FUNCS = new Set([
-    'rgb',
-    'rgba',
-    'hsl',
-    'hsla',
-    'hwb',
-    'lab',
-    'lch',
-    'oklab',
-    'oklch',
-    'color',
-    'device-cmyk',
-    'gray',
-    'color-mix',
-    'color-contrast',
-]);
-export const RE_UNIT_NUM = /^[+-]?(?:\d*\.\d+|\d+)([a-z][a-z0-9]*)$/;
-export const RE_NUMBER = /^[+-]?(?:\d*\.\d+|\d+)$/;
-export const RE_HEX = /^(?:[0-9a-f]{3,4}|[0-9a-f]{6}(?:[0-9a-f]{2})?)$/;
-
-        

package/es/parser/lru.js

@@ -1,73 +0,0 @@
-/**
- * @license MIT
- * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-2d5ce5e
- * Released under the MIT license.
- */
-
-export class Lru {
-    limit;
-    map = new Map();
-    head = null;
-    tail = null;
-    constructor(limit = 1000) {
-        this.limit = limit;
-    }
-    get(key) {
-        const node = this.map.get(key);
-        if (!node)
-            return undefined;
-        this.touch(key, node);
-        return node.value;
-    }
-    set(key, value) {
-        let node = this.map.get(key);
-        if (node) {
-            node.value = value;
-            this.touch(key, node);
-            return;
-        }
-        node = { prev: null, next: this.head, value };
-        if (this.head)
-            this.map.get(this.head).prev = key;
-        this.head = key;
-        if (!this.tail)
-            this.tail = key;
-        this.map.set(key, node);
-        if (this.map.size > this.limit)
-            this.evict();
-    }
-    touch(key, node) {
-        if (this.head === key)
-            return; // already MRU
-        // detach
-        if (node.prev)
-            this.map.get(node.prev).next = node.next;
-        if (node.next)
-            this.map.get(node.next).prev = node.prev;
-        if (this.tail === key)
-            this.tail = node.prev;
-        // move to head
-        node.prev = null;
-        node.next = this.head;
-        if (this.head)
-            this.map.get(this.head).prev = key;
-        this.head = key;
-    }
-    evict() {
-        const old = this.tail;
-        if (!old)
-            return;
-        const node = this.map.get(old);
-        if (node.prev)
-            this.map.get(node.prev).next = null;
-        this.tail = node.prev;
-        this.map.delete(old);
-    }
-    clear() {
-        this.map.clear();
-        this.head = this.tail = null;
-    }
-}
-
-        

package/es/parser/parser.js

@@ -1,104 +0,0 @@
-/**
- * @license MIT
- * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-2d5ce5e
- * Released under the MIT license.
- */
-
-import { classify } from './classify';
-import { Lru } from './lru';
-import { scan } from './tokenizer';
-import { Bucket, finalizeGroup, makeEmptyDetails, } from './types';
-export class StyleParser {
-    opts;
-    cache;
-    constructor(opts = {}) {
-        this.opts = opts;
-        this.cache = new Lru(this.opts.cacheSize ?? 1000);
-    }
-    /* ---------------- Public API ---------------- */
-    process(src) {
-        const key = String(src);
-        const hit = this.cache.get(key);
-        if (hit)
-            return hit;
-        // strip comments & lower-case once
-        const stripped = src
-            .replace(/\/\*[^*]*\*+(?:[^/*][^*]*\*+)*\//g, '')
-            .toLowerCase();
-        const groups = [];
-        let current = makeEmptyDetails();
-        const pushToken = (bucket, processed) => {
-            if (!processed)
-                return;
-            // If the previous token was a url(...) value, merge this token into it so that
-            // background layer segments like "url(img) no-repeat center/cover" are kept
-            // as a single value entry.
-            const mergeIntoPrevUrl = () => {
-                const lastIdx = current.values.length - 1;
-                current.values[lastIdx] += ` ${processed}`;
-                const lastAllIdx = current.all.length - 1;
-                current.all[lastAllIdx] += ` ${processed}`;
-            };
-            const prevIsUrlValue = current.values.length > 0 &&
-                current.values[current.values.length - 1].startsWith('url(');
-            if (prevIsUrlValue) {
-                // Extend the existing url(...) value regardless of current bucket.
-                mergeIntoPrevUrl();
-                // Additionally, for non-value buckets we need to remove their own storage.
-                // So early return.
-                return;
-            }
-            switch (bucket) {
-                case Bucket.Color:
-                    current.colors.push(processed);
-                    break;
-                case Bucket.Value:
-                    current.values.push(processed);
-                    break;
-                case Bucket.Mod:
-                    current.mods.push(processed);
-                    break;
-            }
-            current.all.push(processed);
-        };
-        const endGroup = () => {
-            finalizeGroup(current);
-            groups.push(current);
-            current = makeEmptyDetails();
-        };
-        scan(stripped, (tok, isComma, prevChar) => {
-            if (tok) {
-                const { bucket, processed } = classify(tok, this.opts, (sub) => this.process(sub));
-                pushToken(bucket, processed);
-            }
-            if (isComma)
-                endGroup();
-        });
-        // push final group if not already
-        if (current.all.length || !groups.length)
-            endGroup();
-        const output = groups.map((g) => g.output).join(', ');
-        const result = { output, groups };
-        Object.freeze(result);
-        this.cache.set(key, result);
-        return result;
-    }
-    setFuncs(funcs) {
-        this.opts.funcs = funcs;
-        this.cache.clear();
-    }
-    setUnits(units) {
-        this.opts.units = units;
-        this.cache.clear();
-    }
-    updateOptions(patch) {
-        Object.assign(this.opts, patch);
-        if (patch.cacheSize)
-            this.cache = new Lru(patch.cacheSize);
-        else
-            this.cache.clear();
-    }
-}
-
-        

package/es/parser/tokenizer.js

@@ -1,73 +0,0 @@
-/**
- * @license MIT
- * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-2d5ce5e
- * Released under the MIT license.
- */
-
-export function scan(src, cb) {
-    let depth = 0;
-    let inUrl = false;
-    let inQuote = 0;
-    let start = 0;
-    let i = 0;
-    const flush = (isComma) => {
-        if (start < i) {
-            const prevChar = start > 0 ? src[start - 1] : null;
-            cb(src.slice(start, i), isComma, prevChar);
-        }
-        else if (isComma) {
-            cb('', true, null); // empty token followed by comma => group break.
-        }
-        start = i + 1;
-    };
-    for (; i < src.length; i++) {
-        const ch = src[i];
-        // quote mode
-        if (inQuote) {
-            if (ch === inQuote && src[i - 1] !== '\\')
-                inQuote = 0;
-            continue;
-        }
-        if (ch === '"' || ch === "'") {
-            inQuote = ch;
-            continue;
-        }
-        // paren & url tracking (not inside quotes)
-        if (ch === '(') {
-            // detect url(
-            if (!depth) {
-                const maybe = src.slice(Math.max(0, i - 3), i + 1);
-                if (maybe === 'url(')
-                    inUrl = true;
-            }
-            depth++;
-            continue;
-        }
-        if (ch === ')') {
-            depth = Math.max(0, depth - 1);
-            if (inUrl && depth === 0)
-                inUrl = false;
-            continue;
-        }
-        if (inUrl)
-            continue; // inside url(...) treat everything as part of token
-        if (!depth) {
-            if (ch === ',') {
-                flush(true);
-                continue;
-            }
-            if (ch === ' ' ||
-                ch === '\n' ||
-                ch === '\t' ||
-                ch === '\r' ||
-                ch === '\f') {
-                flush(false);
-                continue;
-            }
-        }
-    }
-    flush(false); // tail
-}
-
-        

package/es/parser/types.js

@@ -1,27 +0,0 @@
-/**
- * @license MIT
- * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-2d5ce5e
- * Released under the MIT license.
- */
-
-export var Bucket;
-(function (Bucket) {
-    Bucket[Bucket["Color"] = 0] = "Color";
-    Bucket[Bucket["Value"] = 1] = "Value";
-    Bucket[Bucket["Mod"] = 2] = "Mod";
-})(Bucket || (Bucket = {}));
-export const makeEmptyDetails = () => ({
-    output: '',
-    mods: [],
-    values: [],
-    colors: [],
-    all: [],
-});
-export const finalizeGroup = (d) => {
-    // Join processed pieces already stored in `all` with single spaces.
-    d.output = d.all.join(' ');
-    return d;
-};
-
-        

package/types/parser/classify.d.ts

@@ -1,5 +0,0 @@
-import { Bucket, ParserOptions, ProcessedStyle } from './types';
-export declare function classify(raw: string, opts: ParserOptions, recurse: (str: string) => ProcessedStyle): {
-    bucket: Bucket;
-    processed: string;
-};

package/types/parser/const.d.ts

@@ -1,5 +0,0 @@
-export declare const VALUE_KEYWORDS: Set<string>;
-export declare const COLOR_FUNCS: Set<string>;
-export declare const RE_UNIT_NUM: RegExp;
-export declare const RE_NUMBER: RegExp;
-export declare const RE_HEX: RegExp;

package/types/parser/lru.d.ts

@@ -1,12 +0,0 @@
-export declare class Lru<K, V> {
-    private limit;
-    private map;
-    private head;
-    private tail;
-    constructor(limit?: number);
-    get(key: K): V | undefined;
-    set(key: K, value: V): void;
-    private touch;
-    private evict;
-    clear(): void;
-}

package/types/parser/parser.d.ts

@@ -1,11 +0,0 @@
-import { ParserOptions, ProcessedStyle } from './types';
-export declare class StyleParser {
-    private opts;
-    private cache;
-    constructor(opts?: ParserOptions);
-    process(src: string): ProcessedStyle;
-    setFuncs(funcs: Required<ParserOptions>['funcs']): void;
-    setUnits(units: Required<ParserOptions>['units']): void;
-    updateOptions(patch: Partial<ParserOptions>): void;
-}
-export type { StyleDetails, ProcessedStyle } from './types';

package/types/parser/tokenizer.d.ts

@@ -1,2 +0,0 @@
-export type TokenCallback = (token: string, isComma: boolean, precedingChar: string | null) => void;
-export declare function scan(src: string, cb: TokenCallback): void;

package/types/parser/types.d.ts

@@ -1,24 +0,0 @@
-export declare enum Bucket {
-    Color = 0,
-    Value = 1,
-    Mod = 2
-}
-export interface StyleDetails {
-    output: string;
-    mods: string[];
-    values: string[];
-    colors: string[];
-    all: string[];
-}
-export interface ProcessedStyle {
-    output: string;
-    groups: StyleDetails[];
-}
-export type UnitHandler = (scalar: number) => string;
-export interface ParserOptions {
-    funcs?: Record<string, (parsed: StyleDetails[]) => string>;
-    units?: Record<string, string | UnitHandler>;
-    cacheSize?: number;
-}
-export declare const makeEmptyDetails: () => StyleDetails;
-export declare const finalizeGroup: (d: StyleDetails) => StyleDetails;