@cube-dev/ui-kit 0.0.0-canary-cb1c485 → 0.0.0-canary-99c26e2

package/dist/tasty/pipeline/exclusive.js

@@ -1,232 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-cb1c485 | Cube Dev Team */
-import { and, isCompoundCondition, not, trueCondition } from "./conditions.js";
-import { simplifyCondition } from "./simplify.js";
-
-//#region src/tasty/pipeline/exclusive.ts
-/**
-* 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
-*/
-function buildExclusiveConditions(entries) {
-	const result = [];
-	const priorConditions = [];
-	for (const entry of entries) {
-		let exclusive = entry.condition;
-		for (const prior of priorConditions) if (prior.kind !== "true") exclusive = and(exclusive, not(prior));
-		const simplified = simplifyCondition(exclusive);
-		if (simplified.kind === "false") continue;
-		result.push({
-			...entry,
-			exclusiveCondition: simplified
-		});
-		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)
-*/
-function parseStyleEntries(styleKey, valueMap, parseCondition) {
-	const entries = [];
-	Object.keys(valueMap).forEach((stateKey, index) => {
-		const value = valueMap[stateKey];
-		const condition = stateKey === "" ? trueCondition() : parseCondition(stateKey);
-		entries.push({
-			styleKey,
-			stateKey,
-			value,
-			condition,
-			priority: index
-		});
-	});
-	entries.reverse();
-	return entries;
-}
-/**
-* Check if a value is a style value mapping (object with state keys)
-*/
-function isValueMapping(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
-}
-/**
-* 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
-*/
-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 (orBranches.length <= 1) return [entry];
-	const result = [];
-	const priorBranches = [];
-	for (let i = 0; i < orBranches.length; i++) {
-		const branch = orBranches[i];
-		let exclusiveBranch = branch;
-		for (const prior of priorBranches) exclusiveBranch = and(exclusiveBranch, not(prior));
-		const simplified = simplifyCondition(exclusiveBranch);
-		if (simplified.kind === "false") {
-			priorBranches.push(branch);
-			continue;
-		}
-		result.push({
-			...entry,
-			stateKey: `${entry.stateKey}[${i}]`,
-			condition: simplified
-		});
-		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") {
-		const branches = [];
-		for (const child of condition.children) branches.push(...collectOrBranches(child));
-		return branches;
-	}
-	return [condition];
-}
-/**
-* Expand OR conditions in exclusive entries AFTER buildExclusiveConditions.
-*
-* This handles ORs that arise from De Morgan expansion during negation:
-*   !(A & B) = !A | !B
-*
-* These ORs need to be made exclusive to avoid overlapping CSS rules:
-*   !A | !B  →  !A | (A & !B)
-*
-* This is logically equivalent but ensures each branch has proper context.
-*
-* Example:
-*   Input: { "": V1, "@supports(...) & :has()": V2 }
-*   V2's exclusive = @supports & :has
-*   V1's exclusive = !(@supports & :has) = !@supports | !:has
-*
-*   Without this fix: V1 gets two rules:
-*     - @supports (not ...) → V1  ✓
-*     - :not(:has()) → V1  ✗ (missing @supports context!)
-*
-*   With this fix: V1 gets two exclusive rules:
-*     - @supports (not ...) → V1  ✓
-*     - @supports (...) { :not(:has()) } → V1  ✓ (proper context!)
-*/
-function expandExclusiveOrs(entries) {
-	const result = [];
-	for (const entry of entries) {
-		const expanded = expandExclusiveConditionOrs(entry);
-		result.push(...expanded);
-	}
-	return result;
-}
-/**
-* Check if a condition involves at-rules (media, container, supports, starting)
-*/
-function hasAtRuleContext(node) {
-	if (node.kind === "true" || node.kind === "false") return false;
-	if (node.kind === "state") return node.type === "media" || node.type === "container" || node.type === "supports" || node.type === "starting";
-	if (node.kind === "compound") return node.children.some(hasAtRuleContext);
-	return false;
-}
-/**
-* Sort OR branches to prioritize at-rule conditions first.
-*
-* This is critical for correct CSS generation. For `!A | !B` where A is at-rule
-* and B is modifier, we want:
-*   - Branch 0: !A (at-rule negation - covers "no @supports/media" case)
-*   - Branch 1: A & !B (modifier negation with at-rule context)
-*
-* If we process in wrong order (!B first), we'd get:
-*   - Branch 0: !B (modifier negation WITHOUT at-rule context - WRONG!)
-*   - Branch 1: B & !A (at-rule negation with modifier - incomplete coverage)
-*/
-function sortOrBranchesForExpansion(branches) {
-	return [...branches].sort((a, b) => {
-		const aHasAtRule = hasAtRuleContext(a);
-		const bHasAtRule = hasAtRuleContext(b);
-		if (aHasAtRule && !bHasAtRule) return -1;
-		if (!aHasAtRule && bHasAtRule) return 1;
-		return 0;
-	});
-}
-/**
-* Expand ORs in a single entry's exclusive condition
-*/
-function expandExclusiveConditionOrs(entry) {
-	let orBranches = collectOrBranches(entry.exclusiveCondition);
-	if (orBranches.length <= 1) return [entry];
-	orBranches = sortOrBranchesForExpansion(orBranches);
-	const result = [];
-	const priorBranches = [];
-	for (let i = 0; i < orBranches.length; i++) {
-		const branch = orBranches[i];
-		let exclusiveBranch = branch;
-		for (const prior of priorBranches) exclusiveBranch = and(exclusiveBranch, not(prior));
-		const simplified = simplifyCondition(exclusiveBranch);
-		if (simplified.kind === "false") {
-			priorBranches.push(branch);
-			continue;
-		}
-		result.push({
-			...entry,
-			stateKey: `${entry.stateKey}[or:${i}]`,
-			exclusiveCondition: simplified
-		});
-		priorBranches.push(branch);
-	}
-	return result;
-}
-
-//#endregion
-export { buildExclusiveConditions, expandExclusiveOrs, expandOrConditions, isValueMapping, parseStyleEntries };
-//# sourceMappingURL=exclusive.js.map

package/dist/tasty/pipeline/exclusive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"exclusive.js","names":[],"sources":["../../../src/tasty/pipeline/exclusive.ts"],"sourcesContent":["/**\n * Exclusive Condition Builder\n *\n * Transforms parsed style entries into exclusive conditions.\n * Each entry's condition is ANDed with the negation of all higher-priority conditions,\n * ensuring exactly one condition matches at any given time.\n */\n\nimport { StyleValue } from '../utils/styles';\n\nimport {\n  and,\n  ConditionNode,\n  isCompoundCondition,\n  not,\n  trueCondition,\n} from './conditions';\nimport { simplifyCondition } from './simplify';\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/**\n * Parsed style entry with condition\n */\nexport interface ParsedStyleEntry {\n  styleKey: string; // e.g., 'padding', 'fill'\n  stateKey: string; // Original key: '', 'compact', '@media(w < 768px)'\n  value: StyleValue; // The style value (before handler processing)\n  condition: ConditionNode; // Parsed condition tree\n  priority: number; // Order in original object (higher = higher priority)\n}\n\n/**\n * Style entry with exclusive condition\n */\nexport interface ExclusiveStyleEntry extends ParsedStyleEntry {\n  exclusiveCondition: ConditionNode; // condition & !higherPriorityConditions\n}\n\n// ============================================================================\n// Main Function\n// ============================================================================\n\n/**\n * Build exclusive conditions for a list of parsed style entries.\n *\n * The entries should be ordered by priority (highest priority first).\n *\n * For each entry, we compute:\n *   exclusiveCondition = condition & !prior[0] & !prior[1] & ...\n *\n * This ensures exactly one condition matches at any time.\n *\n * Example:\n *   Input (ordered highest to lowest priority):\n *     A: value1 (priority 2)\n *     B: value2 (priority 1)\n *     C: value3 (priority 0)\n *\n *   Output:\n *     A: A\n *     B: B & !A\n *     C: C & !A & !B\n *\n * @param entries Parsed style entries ordered by priority (highest first)\n * @returns Entries with exclusive conditions, filtered to remove impossible ones\n */\nexport function buildExclusiveConditions(\n  entries: ParsedStyleEntry[],\n): ExclusiveStyleEntry[] {\n  const result: ExclusiveStyleEntry[] = [];\n  const priorConditions: ConditionNode[] = [];\n\n  for (const entry of entries) {\n    // Build: condition & !prior[0] & !prior[1] & ...\n    let exclusive: ConditionNode = entry.condition;\n\n    for (const prior of priorConditions) {\n      // Skip negating \"always true\" (default state) - it would become \"always false\"\n      if (prior.kind !== 'true') {\n        exclusive = and(exclusive, not(prior));\n      }\n    }\n\n    // Simplify the exclusive condition\n    const simplified = simplifyCondition(exclusive);\n\n    // Skip impossible conditions (simplified to FALSE)\n    if (simplified.kind === 'false') {\n      continue;\n    }\n\n    result.push({\n      ...entry,\n      exclusiveCondition: simplified,\n    });\n\n    // Add non-default conditions to prior list for subsequent entries\n    if (entry.condition.kind !== 'true') {\n      priorConditions.push(entry.condition);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Parse style entries from a value mapping object.\n *\n * @param styleKey The style key (e.g., 'padding')\n * @param valueMap The value mapping { '': '2x', 'compact': '1x', '@media(w < 768px)': '0.5x' }\n * @param parseCondition Function to parse state keys into conditions\n * @returns Parsed entries ordered by priority (highest first)\n */\nexport function parseStyleEntries(\n  styleKey: string,\n  valueMap: Record<string, StyleValue>,\n  parseCondition: (stateKey: string) => ConditionNode,\n): ParsedStyleEntry[] {\n  const entries: ParsedStyleEntry[] = [];\n  const keys = Object.keys(valueMap);\n\n  keys.forEach((stateKey, index) => {\n    const value = valueMap[stateKey];\n    const condition =\n      stateKey === '' ? trueCondition() : parseCondition(stateKey);\n\n    entries.push({\n      styleKey,\n      stateKey,\n      value,\n      condition,\n      priority: index,\n    });\n  });\n\n  // Reverse so highest priority (last in object) comes first for exclusive building\n  // buildExclusiveConditions expects highest priority first\n  entries.reverse();\n\n  return entries;\n}\n\n/**\n * Check if a value is a style value mapping (object with state keys)\n */\nexport function isValueMapping(\n  value: StyleValue | Record<string, StyleValue>,\n): value is Record<string, StyleValue> {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    !Array.isArray(value) &&\n    !(value instanceof Date)\n  );\n}\n\n// ============================================================================\n// OR Expansion\n// ============================================================================\n\n/**\n * Expand OR conditions in parsed entries into multiple exclusive entries.\n *\n * For an entry with condition `A | B | C`, this creates 3 entries:\n *   - condition: A\n *   - condition: B & !A\n *   - condition: C & !A & !B\n *\n * This ensures OR branches are mutually exclusive BEFORE the main\n * exclusive condition building pass.\n *\n * @param entries Parsed entries (may contain OR conditions)\n * @returns Expanded entries with OR branches made exclusive\n */\nexport function expandOrConditions(\n  entries: ParsedStyleEntry[],\n): ParsedStyleEntry[] {\n  const result: ParsedStyleEntry[] = [];\n\n  for (const entry of entries) {\n    const expanded = expandSingleEntry(entry);\n    result.push(...expanded);\n  }\n\n  return result;\n}\n\n/**\n * Expand a single entry's OR condition into multiple exclusive entries\n */\nfunction expandSingleEntry(entry: ParsedStyleEntry): ParsedStyleEntry[] {\n  const orBranches = collectOrBranches(entry.condition);\n\n  // If no OR (single branch), return as-is\n  if (orBranches.length <= 1) {\n    return [entry];\n  }\n\n  // Make each OR branch exclusive from prior branches\n  const result: ParsedStyleEntry[] = [];\n  const priorBranches: ConditionNode[] = [];\n\n  for (let i = 0; i < orBranches.length; i++) {\n    const branch = orBranches[i];\n\n    // Build: branch & !prior[0] & !prior[1] & ...\n    let exclusiveBranch: ConditionNode = branch;\n    for (const prior of priorBranches) {\n      exclusiveBranch = and(exclusiveBranch, not(prior));\n    }\n\n    // Simplify to detect impossible combinations\n    const simplified = simplifyCondition(exclusiveBranch);\n\n    // Skip impossible branches\n    if (simplified.kind === 'false') {\n      priorBranches.push(branch);\n      continue;\n    }\n\n    result.push({\n      ...entry,\n      stateKey: `${entry.stateKey}[${i}]`, // Mark as expanded branch\n      condition: simplified,\n      // Keep same priority - all branches from same entry have same priority\n    });\n\n    priorBranches.push(branch);\n  }\n\n  return result;\n}\n\n/**\n * Collect top-level OR branches from a condition.\n *\n * For `A | B | C`, returns [A, B, C]\n * For `A & B`, returns [A & B] (single branch)\n * For `A | (B & C)`, returns [A, B & C]\n */\nfunction collectOrBranches(condition: ConditionNode): ConditionNode[] {\n  if (condition.kind === 'true' || condition.kind === 'false') {\n    return [condition];\n  }\n\n  if (isCompoundCondition(condition) && condition.operator === 'OR') {\n    // Flatten nested ORs\n    const branches: ConditionNode[] = [];\n    for (const child of condition.children) {\n      branches.push(...collectOrBranches(child));\n    }\n    return branches;\n  }\n\n  // Not an OR - return as single branch\n  return [condition];\n}\n\n// ============================================================================\n// Post-Build OR Expansion (for De Morgan ORs)\n// ============================================================================\n\n/**\n * Expand OR conditions in exclusive entries AFTER buildExclusiveConditions.\n *\n * This handles ORs that arise from De Morgan expansion during negation:\n *   !(A & B) = !A | !B\n *\n * These ORs need to be made exclusive to avoid overlapping CSS rules:\n *   !A | !B  →  !A | (A & !B)\n *\n * This is logically equivalent but ensures each branch has proper context.\n *\n * Example:\n *   Input: { \"\": V1, \"@supports(...) & :has()\": V2 }\n *   V2's exclusive = @supports & :has\n *   V1's exclusive = !(@supports & :has) = !@supports | !:has\n *\n *   Without this fix: V1 gets two rules:\n *     - @supports (not ...) → V1  ✓\n *     - :not(:has()) → V1  ✗ (missing @supports context!)\n *\n *   With this fix: V1 gets two exclusive rules:\n *     - @supports (not ...) → V1  ✓\n *     - @supports (...) { :not(:has()) } → V1  ✓ (proper context!)\n */\nexport function expandExclusiveOrs(\n  entries: ExclusiveStyleEntry[],\n): ExclusiveStyleEntry[] {\n  const result: ExclusiveStyleEntry[] = [];\n\n  for (const entry of entries) {\n    const expanded = expandExclusiveConditionOrs(entry);\n    result.push(...expanded);\n  }\n\n  return result;\n}\n\n/**\n * Check if a condition involves at-rules (media, container, supports, starting)\n */\nfunction hasAtRuleContext(node: ConditionNode): boolean {\n  if (node.kind === 'true' || node.kind === 'false') {\n    return false;\n  }\n\n  if (node.kind === 'state') {\n    // These condition types generate at-rules\n    return (\n      node.type === 'media' ||\n      node.type === 'container' ||\n      node.type === 'supports' ||\n      node.type === 'starting'\n    );\n  }\n\n  if (node.kind === 'compound') {\n    return node.children.some(hasAtRuleContext);\n  }\n\n  return false;\n}\n\n/**\n * Sort OR branches to prioritize at-rule conditions first.\n *\n * This is critical for correct CSS generation. For `!A | !B` where A is at-rule\n * and B is modifier, we want:\n *   - Branch 0: !A (at-rule negation - covers \"no @supports/media\" case)\n *   - Branch 1: A & !B (modifier negation with at-rule context)\n *\n * If we process in wrong order (!B first), we'd get:\n *   - Branch 0: !B (modifier negation WITHOUT at-rule context - WRONG!)\n *   - Branch 1: B & !A (at-rule negation with modifier - incomplete coverage)\n */\nfunction sortOrBranchesForExpansion(\n  branches: ConditionNode[],\n): ConditionNode[] {\n  return [...branches].sort((a, b) => {\n    const aHasAtRule = hasAtRuleContext(a);\n    const bHasAtRule = hasAtRuleContext(b);\n\n    // At-rule conditions come first\n    if (aHasAtRule && !bHasAtRule) return -1;\n    if (!aHasAtRule && bHasAtRule) return 1;\n\n    // Same type - keep original order (stable sort)\n    return 0;\n  });\n}\n\n/**\n * Expand ORs in a single entry's exclusive condition\n */\nfunction expandExclusiveConditionOrs(\n  entry: ExclusiveStyleEntry,\n): ExclusiveStyleEntry[] {\n  let orBranches = collectOrBranches(entry.exclusiveCondition);\n\n  // If no OR (single branch), return as-is\n  if (orBranches.length <= 1) {\n    return [entry];\n  }\n\n  // Sort branches so at-rule conditions come first\n  // This ensures proper context inheritance during expansion\n  orBranches = sortOrBranchesForExpansion(orBranches);\n\n  // Make each OR branch exclusive from prior branches\n  const result: ExclusiveStyleEntry[] = [];\n  const priorBranches: ConditionNode[] = [];\n\n  for (let i = 0; i < orBranches.length; i++) {\n    const branch = orBranches[i];\n\n    // Build: branch & !prior[0] & !prior[1] & ...\n    // This transforms: !A | !B  →  !A, !B & !!A  =  !A, (A & !B)\n    let exclusiveBranch: ConditionNode = branch;\n    for (const prior of priorBranches) {\n      exclusiveBranch = and(exclusiveBranch, not(prior));\n    }\n\n    // Simplify to detect impossible combinations and clean up double negations\n    const simplified = simplifyCondition(exclusiveBranch);\n\n    // Skip impossible branches\n    if (simplified.kind === 'false') {\n      priorBranches.push(branch);\n      continue;\n    }\n\n    result.push({\n      ...entry,\n      stateKey: `${entry.stateKey}[or:${i}]`, // Mark as expanded OR branch\n      exclusiveCondition: simplified,\n    });\n\n    priorBranches.push(branch);\n  }\n\n  return result;\n}\n"],"mappings":"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"}

package/dist/tasty/pipeline/index.d.ts

@@ -1,54 +0,0 @@
-
-import { Styles } from "../styles/types.js";
-import "./parseStateKey.js";
-import "./exclusive.js";
-
-//#region src/tasty/pipeline/index.d.ts
-/**
- * Matches the old StyleResult interface for backward compatibility
- */
-interface StyleResult {
-  selector: string;
-  declarations: string;
-  atRules?: string[];
-  needsClassName?: boolean;
-  rootPrefix?: string;
-}
-/**
- * Matches the old RenderResult interface for backward compatibility
- */
-interface RenderResult {
-  rules: StyleResult[];
-  className?: string;
-}
-/**
- * Check if a key is a CSS selector
- */
-declare function isSelector(key: string): boolean;
-/**
- * Options for renderStyles when using direct selector mode.
- */
-interface RenderStylesOptions {
-  /**
-   * Whether to double the class selector for increased specificity.
-   * When true, `.myClass` becomes `.myClass.myClass` for higher specificity.
-   *
-   * @default false - User-provided selectors are not doubled.
-   *
-   * Note: This only applies when a classNameOrSelector is provided.
-   * When renderStyles returns RenderResult with needsClassName=true,
-   * the injector handles doubling automatically.
-   */
-  doubleSelector?: boolean;
-}
-/**
- * Render styles to CSS rules.
- *
- * When called without classNameOrSelector, returns RenderResult with needsClassName=true.
- * When called with a selector/className string, returns StyleResult[] for direct injection.
- */
-declare function renderStyles(styles?: Styles): RenderResult;
-declare function renderStyles(styles: Styles | undefined, classNameOrSelector: string, options?: RenderStylesOptions): StyleResult[];
-//#endregion
-export { RenderResult, StyleResult, isSelector, renderStyles };
-//# sourceMappingURL=index.d.ts.map