@cube-dev/ui-kit 0.0.0-canary-76be278 → 0.0.0-canary-7e4ec9d

package/es/tasty/pipeline/conditions.js

@@ -1,469 +0,0 @@
-/**
- * @license MIT
- * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-76be278
- * Released under the MIT license.
- */
-
-/**
- * ConditionNode Types and Helpers
- *
- * Core data structures for representing style conditions as an abstract syntax tree.
- * Used throughout the pipeline for parsing, simplification, and CSS generation.
- */
-// ============================================================================
-// Constructor Functions
-// ============================================================================
-/**
- * Create a TRUE condition (matches everything)
- */
-export function trueCondition() {
-    return { kind: 'true' };
-}
-/**
- * Create a FALSE condition (matches nothing)
- */
-export function falseCondition() {
-    return { kind: 'false' };
-}
-/**
- * Create an AND compound condition
- */
-export function and(...children) {
-    const filtered = [];
-    for (const child of children) {
-        // Short-circuit on FALSE
-        if (child.kind === 'false') {
-            return falseCondition();
-        }
-        // Skip TRUE (identity for AND)
-        if (child.kind === 'true') {
-            continue;
-        }
-        // Flatten nested ANDs
-        if (child.kind === 'compound' && child.operator === 'AND') {
-            filtered.push(...child.children);
-        }
-        else {
-            filtered.push(child);
-        }
-    }
-    if (filtered.length === 0) {
-        return trueCondition();
-    }
-    if (filtered.length === 1) {
-        return filtered[0];
-    }
-    return {
-        kind: 'compound',
-        operator: 'AND',
-        children: filtered,
-    };
-}
-/**
- * Create an OR compound condition
- */
-export function or(...children) {
-    const filtered = [];
-    for (const child of children) {
-        // Short-circuit on TRUE
-        if (child.kind === 'true') {
-            return trueCondition();
-        }
-        // Skip FALSE (identity for OR)
-        if (child.kind === 'false') {
-            continue;
-        }
-        // Flatten nested ORs
-        if (child.kind === 'compound' && child.operator === 'OR') {
-            filtered.push(...child.children);
-        }
-        else {
-            filtered.push(child);
-        }
-    }
-    if (filtered.length === 0) {
-        return falseCondition();
-    }
-    if (filtered.length === 1) {
-        return filtered[0];
-    }
-    return {
-        kind: 'compound',
-        operator: 'OR',
-        children: filtered,
-    };
-}
-/**
- * Negate a condition
- */
-export function not(node) {
-    // NOT(TRUE) = FALSE
-    if (node.kind === 'true') {
-        return falseCondition();
-    }
-    // NOT(FALSE) = TRUE
-    if (node.kind === 'false') {
-        return trueCondition();
-    }
-    // NOT(state) = toggle negated flag
-    if (node.kind === 'state') {
-        return {
-            ...node,
-            negated: !node.negated,
-            uniqueId: node.negated
-                ? node.uniqueId.replace(/^!/, '')
-                : `!${node.uniqueId}`,
-        };
-    }
-    // NOT(AND(a, b, ...)) = OR(NOT(a), NOT(b), ...) - De Morgan's law
-    if (node.kind === 'compound' && node.operator === 'AND') {
-        return or(...node.children.map((c) => not(c)));
-    }
-    // NOT(OR(a, b, ...)) = AND(NOT(a), NOT(b), ...) - De Morgan's law
-    if (node.kind === 'compound' && node.operator === 'OR') {
-        return and(...node.children.map((c) => not(c)));
-    }
-    // Fallback - should not reach here
-    return node;
-}
-// ============================================================================
-// Condition Type Checking
-// ============================================================================
-/**
- * Check if a condition is a state condition
- */
-export function isStateCondition(node) {
-    return node.kind === 'state';
-}
-/**
- * Check if a condition is a compound condition
- */
-export function isCompoundCondition(node) {
-    return node.kind === 'compound';
-}
-/**
- * Check if a condition is TRUE
- */
-export function isTrueCondition(node) {
-    return node.kind === 'true';
-}
-/**
- * Check if a condition is FALSE
- */
-export function isFalseCondition(node) {
-    return node.kind === 'false';
-}
-// ============================================================================
-// UniqueId Generation
-// ============================================================================
-/**
- * Generate a normalized unique ID for a modifier condition
- */
-export function modifierUniqueId(attribute, value, operator = '=', negated = false) {
-    const base = value
-        ? `mod:${attribute}${operator}${value}`
-        : `mod:${attribute}`;
-    return negated ? `!${base}` : base;
-}
-/**
- * Generate a normalized unique ID for a pseudo condition
- */
-export function pseudoUniqueId(pseudo, negated = false) {
-    const base = `pseudo:${pseudo}`;
-    return negated ? `!${base}` : base;
-}
-/**
- * Generate a normalized unique ID for a media condition
- */
-export function mediaUniqueId(subtype, props, negated = false) {
-    let base;
-    if (subtype === 'dimension') {
-        const parts = ['media', 'dim', props.dimension];
-        if (props.lowerBound) {
-            parts.push(props.lowerBound.inclusive ? '>=' : '>');
-            parts.push(props.lowerBound.value);
-        }
-        if (props.upperBound) {
-            parts.push(props.upperBound.inclusive ? '<=' : '<');
-            parts.push(props.upperBound.value);
-        }
-        base = parts.join(':');
-    }
-    else if (subtype === 'feature') {
-        base = props.featureValue
-            ? `media:feat:${props.feature}:${props.featureValue}`
-            : `media:feat:${props.feature}`;
-    }
-    else {
-        base = `media:type:${props.mediaType}`;
-    }
-    return negated ? `!${base}` : base;
-}
-/**
- * Generate a normalized unique ID for a container condition
- */
-export function containerUniqueId(subtype, props, negated = false) {
-    let base;
-    const name = props.containerName || '_';
-    if (subtype === 'dimension') {
-        const parts = ['container', 'dim', name, props.dimension];
-        if (props.lowerBound) {
-            parts.push(props.lowerBound.inclusive ? '>=' : '>');
-            parts.push(props.lowerBound.value);
-        }
-        if (props.upperBound) {
-            parts.push(props.upperBound.inclusive ? '<=' : '<');
-            parts.push(props.upperBound.value);
-        }
-        base = parts.join(':');
-    }
-    else {
-        base = props.propertyValue
-            ? `container:style:${name}:--${props.property}:${props.propertyValue}`
-            : `container:style:${name}:--${props.property}`;
-    }
-    return negated ? `!${base}` : base;
-}
-/**
- * Generate a normalized unique ID for a root condition
- */
-export function rootUniqueId(selector, negated = false) {
-    const base = `root:${selector}`;
-    return negated ? `!${base}` : base;
-}
-/**
- * Generate a normalized unique ID for an own condition
- */
-export function ownUniqueId(innerUniqueId, negated = false) {
-    const base = `own:${innerUniqueId}`;
-    return negated ? `!${base}` : base;
-}
-/**
- * Generate a normalized unique ID for a starting condition
- */
-export function startingUniqueId(negated = false) {
-    return negated ? '!starting' : 'starting';
-}
-// ============================================================================
-// Condition Creation Helpers
-// ============================================================================
-/**
- * Create a modifier condition
- */
-export function createModifierCondition(attribute, value, operator = '=', negated = false, raw) {
-    return {
-        kind: 'state',
-        type: 'modifier',
-        negated,
-        raw: raw || (value ? `${attribute}${operator}${value}` : attribute),
-        uniqueId: modifierUniqueId(attribute, value, operator, negated),
-        attribute,
-        value,
-        operator: value ? operator : undefined,
-    };
-}
-/**
- * Create a pseudo condition
- */
-export function createPseudoCondition(pseudo, negated = false, raw) {
-    return {
-        kind: 'state',
-        type: 'pseudo',
-        negated,
-        raw: raw || pseudo,
-        uniqueId: pseudoUniqueId(pseudo, negated),
-        pseudo,
-    };
-}
-/**
- * Create a media dimension condition
- */
-export function createMediaDimensionCondition(dimension, lowerBound, upperBound, negated = false, raw) {
-    return {
-        kind: 'state',
-        type: 'media',
-        subtype: 'dimension',
-        negated,
-        raw: raw || `@media(${dimension})`,
-        uniqueId: mediaUniqueId('dimension', { dimension, lowerBound, upperBound }, negated),
-        dimension,
-        lowerBound,
-        upperBound,
-    };
-}
-/**
- * Create a media feature condition
- */
-export function createMediaFeatureCondition(feature, featureValue, negated = false, raw) {
-    return {
-        kind: 'state',
-        type: 'media',
-        subtype: 'feature',
-        negated,
-        raw: raw || `@media(${feature}${featureValue ? `: ${featureValue}` : ''})`,
-        uniqueId: mediaUniqueId('feature', { feature, featureValue }, negated),
-        feature,
-        featureValue,
-    };
-}
-/**
- * Create a media type condition
- */
-export function createMediaTypeCondition(mediaType, negated = false, raw) {
-    return {
-        kind: 'state',
-        type: 'media',
-        subtype: 'type',
-        negated,
-        raw: raw || `@media:${mediaType}`,
-        uniqueId: mediaUniqueId('type', { mediaType }, negated),
-        mediaType,
-    };
-}
-/**
- * Create a container dimension condition
- */
-export function createContainerDimensionCondition(dimension, lowerBound, upperBound, containerName, negated = false, raw) {
-    return {
-        kind: 'state',
-        type: 'container',
-        subtype: 'dimension',
-        negated,
-        raw: raw || `@(${containerName ? containerName + ', ' : ''}${dimension})`,
-        uniqueId: containerUniqueId('dimension', { containerName, dimension, lowerBound, upperBound }, negated),
-        containerName,
-        dimension,
-        lowerBound,
-        upperBound,
-    };
-}
-/**
- * Create a container style condition
- */
-export function createContainerStyleCondition(property, propertyValue, containerName, negated = false, raw) {
-    return {
-        kind: 'state',
-        type: 'container',
-        subtype: 'style',
-        negated,
-        raw: raw ||
-            `@(${containerName ? containerName + ', ' : ''}$${property}${propertyValue ? '=' + propertyValue : ''})`,
-        uniqueId: containerUniqueId('style', { containerName, property, propertyValue }, negated),
-        containerName,
-        property,
-        propertyValue,
-    };
-}
-/**
- * Create a root condition
- */
-export function createRootCondition(selector, negated = false, raw) {
-    return {
-        kind: 'state',
-        type: 'root',
-        negated,
-        raw: raw || `@root(${selector})`,
-        uniqueId: rootUniqueId(selector, negated),
-        selector,
-    };
-}
-/**
- * Create an own condition
- */
-export function createOwnCondition(innerCondition, negated = false, raw) {
-    const innerUniqueId = getConditionUniqueId(innerCondition);
-    return {
-        kind: 'state',
-        type: 'own',
-        negated,
-        raw: raw || `@own(...)`,
-        uniqueId: ownUniqueId(innerUniqueId, negated),
-        innerCondition,
-    };
-}
-/**
- * Create a starting condition
- */
-export function createStartingCondition(negated = false, raw) {
-    return {
-        kind: 'state',
-        type: 'starting',
-        negated,
-        raw: raw || '@starting',
-        uniqueId: startingUniqueId(negated),
-    };
-}
-// ============================================================================
-// Utility Functions
-// ============================================================================
-/**
- * Get the unique ID for any condition node
- */
-export function getConditionUniqueId(node) {
-    if (node.kind === 'true') {
-        return 'TRUE';
-    }
-    if (node.kind === 'false') {
-        return 'FALSE';
-    }
-    if (node.kind === 'state') {
-        return node.uniqueId;
-    }
-    if (node.kind === 'compound') {
-        const childIds = node.children.map(getConditionUniqueId).sort();
-        return `${node.operator}(${childIds.join(',')})`;
-    }
-    return 'UNKNOWN';
-}
-/**
- * Check if two conditions are equal based on their unique IDs
- */
-export function conditionsEqual(a, b) {
-    return getConditionUniqueId(a) === getConditionUniqueId(b);
-}
-/**
- * Get all state conditions from a condition tree (flattened)
- */
-export function getAllStateConditions(node) {
-    if (node.kind === 'true' || node.kind === 'false') {
-        return [];
-    }
-    if (node.kind === 'state') {
-        return [node];
-    }
-    if (node.kind === 'compound') {
-        const result = [];
-        for (const child of node.children) {
-            result.push(...getAllStateConditions(child));
-        }
-        return result;
-    }
-    return [];
-}
-/**
- * Clone a condition node (deep copy)
- */
-export function cloneCondition(node) {
-    if (node.kind === 'true' || node.kind === 'false') {
-        return { ...node };
-    }
-    if (node.kind === 'state') {
-        if (node.type === 'own') {
-            return {
-                ...node,
-                innerCondition: cloneCondition(node.innerCondition),
-            };
-        }
-        return { ...node };
-    }
-    if (node.kind === 'compound') {
-        return {
-            ...node,
-            children: node.children.map(cloneCondition),
-        };
-    }
-    return node;
-}
-
-        

package/es/tasty/pipeline/exclusive.js

@@ -1,193 +0,0 @@
-/**
- * @license MIT
- * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-76be278
- * Released under the MIT license.
- */
-
-/**
- * Exclusive Condition Builder
- *
- * Transforms parsed style entries into exclusive conditions.
- * Each entry's condition is ANDed with the negation of all higher-priority conditions,
- * ensuring exactly one condition matches at any given time.
- */
-import { and, isCompoundCondition, not, trueCondition, } from './conditions';
-import { simplifyCondition } from './simplify';
-// ============================================================================
-// Main Function
-// ============================================================================
-/**
- * Build exclusive conditions for a list of parsed style entries.
- *
- * The entries should be ordered by priority (highest priority first).
- *
- * For each entry, we compute:
- *   exclusiveCondition = condition & !prior[0] & !prior[1] & ...
- *
- * This ensures exactly one condition matches at any time.
- *
- * Example:
- *   Input (ordered highest to lowest priority):
- *     A: value1 (priority 2)
- *     B: value2 (priority 1)
- *     C: value3 (priority 0)
- *
- *   Output:
- *     A: A
- *     B: B & !A
- *     C: C & !A & !B
- *
- * @param entries Parsed style entries ordered by priority (highest first)
- * @returns Entries with exclusive conditions, filtered to remove impossible ones
- */
-export function buildExclusiveConditions(entries) {
-    const result = [];
-    const priorConditions = [];
-    for (const entry of entries) {
-        // Build: condition & !prior[0] & !prior[1] & ...
-        let exclusive = entry.condition;
-        for (const prior of priorConditions) {
-            // Skip negating "always true" (default state) - it would become "always false"
-            if (prior.kind !== 'true') {
-                exclusive = and(exclusive, not(prior));
-            }
-        }
-        // Simplify the exclusive condition
-        const simplified = simplifyCondition(exclusive);
-        // Skip impossible conditions (simplified to FALSE)
-        if (simplified.kind === 'false') {
-            continue;
-        }
-        result.push({
-            ...entry,
-            exclusiveCondition: simplified,
-        });
-        // Add non-default conditions to prior list for subsequent entries
-        if (entry.condition.kind !== 'true') {
-            priorConditions.push(entry.condition);
-        }
-    }
-    return result;
-}
-/**
- * Parse style entries from a value mapping object.
- *
- * @param styleKey The style key (e.g., 'padding')
- * @param valueMap The value mapping { '': '2x', 'compact': '1x', '@media(w < 768px)': '0.5x' }
- * @param parseCondition Function to parse state keys into conditions
- * @returns Parsed entries ordered by priority (highest first)
- */
-export function parseStyleEntries(styleKey, valueMap, parseCondition) {
-    const entries = [];
-    const keys = Object.keys(valueMap);
-    keys.forEach((stateKey, index) => {
-        const value = valueMap[stateKey];
-        const condition = stateKey === '' ? trueCondition() : parseCondition(stateKey);
-        entries.push({
-            styleKey,
-            stateKey,
-            value,
-            condition,
-            priority: index,
-        });
-    });
-    // Reverse so highest priority (last in object) comes first for exclusive building
-    // buildExclusiveConditions expects highest priority first
-    entries.reverse();
-    return entries;
-}
-/**
- * Check if a value is a style value mapping (object with state keys)
- */
-export function isValueMapping(value) {
-    return (value !== null &&
-        typeof value === 'object' &&
-        !Array.isArray(value) &&
-        !(value instanceof Date));
-}
-// ============================================================================
-// OR Expansion
-// ============================================================================
-/**
- * Expand OR conditions in parsed entries into multiple exclusive entries.
- *
- * For an entry with condition `A | B | C`, this creates 3 entries:
- *   - condition: A
- *   - condition: B & !A
- *   - condition: C & !A & !B
- *
- * This ensures OR branches are mutually exclusive BEFORE the main
- * exclusive condition building pass.
- *
- * @param entries Parsed entries (may contain OR conditions)
- * @returns Expanded entries with OR branches made exclusive
- */
-export function expandOrConditions(entries) {
-    const result = [];
-    for (const entry of entries) {
-        const expanded = expandSingleEntry(entry);
-        result.push(...expanded);
-    }
-    return result;
-}
-/**
- * Expand a single entry's OR condition into multiple exclusive entries
- */
-function expandSingleEntry(entry) {
-    const orBranches = collectOrBranches(entry.condition);
-    // If no OR (single branch), return as-is
-    if (orBranches.length <= 1) {
-        return [entry];
-    }
-    // Make each OR branch exclusive from prior branches
-    const result = [];
-    const priorBranches = [];
-    for (let i = 0; i < orBranches.length; i++) {
-        const branch = orBranches[i];
-        // Build: branch & !prior[0] & !prior[1] & ...
-        let exclusiveBranch = branch;
-        for (const prior of priorBranches) {
-            exclusiveBranch = and(exclusiveBranch, not(prior));
-        }
-        // Simplify to detect impossible combinations
-        const simplified = simplifyCondition(exclusiveBranch);
-        // Skip impossible branches
-        if (simplified.kind === 'false') {
-            priorBranches.push(branch);
-            continue;
-        }
-        result.push({
-            ...entry,
-            stateKey: `${entry.stateKey}[${i}]`, // Mark as expanded branch
-            condition: simplified,
-            // Keep same priority - all branches from same entry have same priority
-        });
-        priorBranches.push(branch);
-    }
-    return result;
-}
-/**
- * Collect top-level OR branches from a condition.
- *
- * For `A | B | C`, returns [A, B, C]
- * For `A & B`, returns [A & B] (single branch)
- * For `A | (B & C)`, returns [A, B & C]
- */
-function collectOrBranches(condition) {
-    if (condition.kind === 'true' || condition.kind === 'false') {
-        return [condition];
-    }
-    if (isCompoundCondition(condition) && condition.operator === 'OR') {
-        // Flatten nested ORs
-        const branches = [];
-        for (const child of condition.children) {
-            branches.push(...collectOrBranches(child));
-        }
-        return branches;
-    }
-    // Not an OR - return as single branch
-    return [condition];
-}
-
-