@tenphi/tasty 0.4.2 → 0.5.0

package/dist/pipeline/materialize.js

@@ -1,4 +1,5 @@
 import { Lru } from "../parser/lru.js";
+import { not } from "./conditions.js";
 
 //#region src/pipeline/materialize.ts
 /**
@@ -31,7 +32,7 @@ function emptyVariant() {
 		containerConditions: [],
 		supportsConditions: [],
 		rootConditions: [],
-		parentConditions: [],
+		parentGroups: [],
 		startingStyle: false
 	};
 }
@@ -65,36 +66,46 @@ function stateToCSS(state) {
 			}),
 			isImpossible: false
 		};
-		default: {
-			const variant = emptyVariant();
-			switch (state.type) {
-				case "modifier":
-					variant.modifierConditions.push(modifierToParsed(state));
-					break;
-				case "pseudo":
-					variant.pseudoConditions.push(pseudoToParsed(state));
-					break;
-				case "container":
-					variant.containerConditions.push(containerToParsed(state));
-					break;
-				case "supports":
-					variant.supportsConditions.push(supportsToParsed(state));
-					break;
-				case "root":
-					variant.rootConditions.push(rootToParsed(state));
-					break;
-				case "parent":
-					variant.parentConditions.push(parentToParsed(state));
-					break;
-				case "own":
-					variant.ownConditions.push(...ownToParsed(state));
-					break;
-				case "starting":
-					variant.startingStyle = !state.negated;
-					break;
-			}
+		case "root": return innerConditionToVariants(state.innerCondition, state.negated ?? false, "rootConditions");
+		case "parent": return parentConditionToVariants(state.innerCondition, state.negated ?? false, state.direct);
+		case "own": return innerConditionToVariants(state.innerCondition, state.negated ?? false, "ownConditions");
+		case "modifier": {
+			const v = emptyVariant();
+			v.modifierConditions.push(modifierToParsed(state));
+			return {
+				variants: [v],
+				isImpossible: false
+			};
+		}
+		case "pseudo": {
+			const v = emptyVariant();
+			v.pseudoConditions.push(pseudoToParsed(state));
+			return {
+				variants: [v],
+				isImpossible: false
+			};
+		}
+		case "container": {
+			const v = emptyVariant();
+			v.containerConditions.push(containerToParsed(state));
 			return {
-				variants: [variant],
+				variants: [v],
+				isImpossible: false
+			};
+		}
+		case "supports": {
+			const v = emptyVariant();
+			v.supportsConditions.push(supportsToParsed(state));
+			return {
+				variants: [v],
+				isImpossible: false
+			};
+		}
+		case "starting": {
+			const v = emptyVariant();
+			v.startingStyle = !state.negated;
+			return {
+				variants: [v],
 				isImpossible: false
 			};
 		}
@@ -233,12 +244,92 @@ function supportsToParsed(state) {
 	};
 }
 /**
-* Convert root condition to parsed structure
+* Collect all modifier and pseudo conditions from a variant as a flat array.
 */
-function rootToParsed(state) {
+function collectSelectorConditions(variant) {
+	return [...variant.modifierConditions, ...variant.pseudoConditions];
+}
+/**
+* Convert an inner condition tree into SelectorVariants.
+* Each inner OR branch becomes a separate variant, preserving disjunction.
+* Shared by @root() and @own().
+*/
+function innerConditionToVariants(innerCondition, negated, target) {
+	const innerCSS = conditionToCSS(negated ? not(innerCondition) : innerCondition);
+	if (innerCSS.isImpossible || innerCSS.variants.length === 0) return {
+		variants: [],
+		isImpossible: true
+	};
+	const variants = [];
+	for (const innerVariant of innerCSS.variants) {
+		const conditions = collectSelectorConditions(innerVariant);
+		if (conditions.length > 0) {
+			const v = emptyVariant();
+			v[target].push(...conditions);
+			variants.push(v);
+		}
+	}
+	if (variants.length === 0) return {
+		variants: [emptyVariant()],
+		isImpossible: false
+	};
 	return {
-		selector: state.selector,
-		negated: state.negated ?? false
+		variants,
+		isImpossible: false
+	};
+}
+/**
+* Convert a @parent() inner condition into SelectorVariants with ParentGroups.
+*
+* Positive: each inner OR branch becomes a separate variant with one :is() group.
+* Negated: !(A | B) = !A & !B — all branches become :not() groups collected
+* into a single variant so they produce :not([a] *):not([b] *) on one element.
+*/
+function parentConditionToVariants(innerCondition, negated, direct) {
+	const innerCSS = conditionToCSS(innerCondition);
+	if (innerCSS.isImpossible || innerCSS.variants.length === 0) return {
+		variants: [],
+		isImpossible: true
+	};
+	if (negated) {
+		const v = emptyVariant();
+		for (const innerVariant of innerCSS.variants) {
+			const conditions = collectSelectorConditions(innerVariant);
+			if (conditions.length > 0) v.parentGroups.push({
+				conditions,
+				direct,
+				negated: true
+			});
+		}
+		if (v.parentGroups.length === 0) return {
+			variants: [emptyVariant()],
+			isImpossible: false
+		};
+		return {
+			variants: [v],
+			isImpossible: false
+		};
+	}
+	const variants = [];
+	for (const innerVariant of innerCSS.variants) {
+		const conditions = collectSelectorConditions(innerVariant);
+		if (conditions.length > 0) {
+			const v = emptyVariant();
+			v.parentGroups.push({
+				conditions,
+				direct,
+				negated: false
+			});
+			variants.push(v);
+		}
+	}
+	if (variants.length === 0) return {
+		variants: [emptyVariant()],
+		isImpossible: false
+	};
+	return {
+		variants,
+		isImpossible: false
 	};
 }
 /**
@@ -247,49 +338,30 @@ function rootToParsed(state) {
 function rootConditionsToCSS(roots) {
 	if (roots.length === 0) return void 0;
 	let prefix = ":root";
-	for (const root of roots) if (root.negated) prefix += `:not(${root.selector})`;
-	else prefix += root.selector;
+	for (const cond of roots) prefix += selectorConditionToCSS(cond);
 	return prefix;
 }
 /**
-* Convert parent condition to parsed structure
+* Convert parent groups to CSS selector fragments (for final output).
+* Each group produces its own :is() wrapper.
 */
-function parentToParsed(state) {
-	return {
-		selector: state.selector,
-		direct: state.direct,
-		negated: state.negated ?? false
-	};
+function parentGroupsToCSS(groups) {
+	let result = "";
+	for (const group of groups) {
+		const combinator = group.direct ? " > *" : " *";
+		let parts = "";
+		for (const cond of group.conditions) parts += selectorConditionToCSS(cond);
+		const wrapper = group.negated ? ":not" : ":is";
+		result += `${wrapper}(${parts}${combinator})`;
+	}
+	return result;
 }
 /**
-* Convert parsed parent condition to CSS selector fragment (for final output)
-*
-* Positive: :is([selector] *) or :is([selector] > *)
-* Negative: :not([selector] *) or :not([selector] > *)
+* Convert a modifier or pseudo condition to a CSS selector fragment
 */
-function parentToCSS(parent) {
-	const combinator = parent.direct ? " > *" : " *";
-	if (parent.negated) return `:not(${parent.selector}${combinator})`;
-	return `:is(${parent.selector}${combinator})`;
-}
-/**
-* Convert own condition to parsed structures for sub-element
-*/
-function ownToParsed(state) {
-	const innerCSS = conditionToCSS(state.innerCondition);
-	if (innerCSS.isImpossible || innerCSS.variants.length === 0) return [];
-	const allConditions = [];
-	for (const variant of innerCSS.variants) {
-		for (const mod of variant.modifierConditions) allConditions.push({
-			...mod,
-			negated: state.negated ? !mod.negated : mod.negated
-		});
-		for (const pseudo of variant.pseudoConditions) allConditions.push({
-			...pseudo,
-			negated: state.negated ? !pseudo.negated : pseudo.negated
-		});
-	}
-	return allConditions;
+function selectorConditionToCSS(cond) {
+	if ("attribute" in cond) return modifierToCSS(cond);
+	return pseudoToCSS(cond);
 }
 /**
 * Get unique key for a modifier condition
@@ -305,91 +377,48 @@ function getPseudoKey(pseudo) {
 	return pseudo.negated ? `!${pseudo.pseudo}` : pseudo.pseudo;
 }
 /**
-* Get unique key for a root condition
-*/
-function getRootKey(root) {
-	return root.negated ? `!${root.selector}` : root.selector;
-}
-/**
-* Deduplicate modifier conditions
-*/
-function dedupeModifierConditions(conditions) {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const c of conditions) {
-		const key = getModifierKey(c);
-		if (!seen.has(key)) {
-			seen.add(key);
-			result.push(c);
-		}
-	}
-	return result;
-}
-/**
-* Deduplicate pseudo conditions
+* Get unique key for any selector condition (modifier or pseudo)
 */
-function dedupePseudoConditions(conditions) {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const c of conditions) {
-		const key = getPseudoKey(c);
-		if (!seen.has(key)) {
-			seen.add(key);
-			result.push(c);
-		}
-	}
-	return result;
+function getSelectorConditionKey(cond) {
+	return "attribute" in cond ? `mod:${getModifierKey(cond)}` : `pseudo:${getPseudoKey(cond)}`;
 }
 /**
-* Deduplicate root conditions
+* Deduplicate selector conditions (modifiers or pseudos).
+* Shared by root, parent, and own conditions.
 */
-function dedupeRootConditions(conditions) {
+function dedupeSelectorConditions(conditions) {
 	const seen = /* @__PURE__ */ new Set();
-	const result = [];
+	let result = [];
 	for (const c of conditions) {
-		const key = getRootKey(c);
+		const key = getSelectorConditionKey(c);
 		if (!seen.has(key)) {
 			seen.add(key);
 			result.push(c);
 		}
 	}
-	return result;
-}
-/**
-* Get unique key for a parent condition
-*/
-function getParentKey(parent) {
-	const base = `${parent.direct ? ">" : ""}${parent.selector}`;
-	return parent.negated ? `!${base}` : base;
-}
-/**
-* Deduplicate parent conditions
-*/
-function dedupeParentConditions(conditions) {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const c of conditions) {
-		const key = getParentKey(c);
-		if (!seen.has(key)) {
-			seen.add(key);
-			result.push(c);
-		}
-	}
-	return result;
-}
-/**
-* Deduplicate own conditions (modifiers or pseudos)
-*/
-function dedupeOwnConditions(conditions) {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const c of conditions) {
-		const key = "attribute" in c ? `mod:${getModifierKey(c)}` : `pseudo:${getPseudoKey(c)}`;
-		if (!seen.has(key)) {
-			seen.add(key);
-			result.push(c);
+	const negatedBooleanAttrs = /* @__PURE__ */ new Set();
+	const positiveExactValuesByAttr = /* @__PURE__ */ new Map();
+	for (const c of result) {
+		if (!("attribute" in c)) continue;
+		if (c.negated && c.value === void 0) negatedBooleanAttrs.add(c.attribute);
+		const op = c.operator ?? "=";
+		if (!c.negated && c.value !== void 0 && op === "=") {
+			let values = positiveExactValuesByAttr.get(c.attribute);
+			if (!values) {
+				values = /* @__PURE__ */ new Set();
+				positiveExactValuesByAttr.set(c.attribute, values);
+			}
+			values.add(c.value);
 		}
 	}
+	result = result.filter((c) => {
+		if (!("attribute" in c) || !c.negated || c.value === void 0) return true;
+		if (negatedBooleanAttrs.has(c.attribute)) return false;
+		if ((c.operator ?? "=") !== "=") return true;
+		const positiveValues = positiveExactValuesByAttr.get(c.attribute);
+		if (positiveValues !== void 0 && positiveValues.size === 1 && !positiveValues.has(c.value)) return false;
+		return true;
+	});
 	return result;
 }
 /**
@@ -418,34 +447,10 @@ function hasPseudoContradiction(conditions) {
 	return false;
 }
 /**
-* Check for root condition contradiction: same selector with opposite negation
+* Check for selector condition contradiction (modifier or pseudo with opposite negation).
+* Shared by root, parent, and own conditions.
 */
-function hasRootContradiction(conditions) {
-	const byKey = /* @__PURE__ */ new Map();
-	for (const root of conditions) {
-		const existing = byKey.get(root.selector);
-		if (existing !== void 0 && existing !== !root.negated) return true;
-		byKey.set(root.selector, !root.negated);
-	}
-	return false;
-}
-/**
-* Check for parent condition contradiction: same selector+direct with opposite negation
-*/
-function hasParentContradiction(conditions) {
-	const byKey = /* @__PURE__ */ new Map();
-	for (const parent of conditions) {
-		const baseKey = `${parent.direct ? ">" : ""}${parent.selector}`;
-		const existing = byKey.get(baseKey);
-		if (existing !== void 0 && existing !== !parent.negated) return true;
-		byKey.set(baseKey, !parent.negated);
-	}
-	return false;
-}
-/**
-* Check for own condition contradiction
-*/
-function hasOwnConditionContradiction(conditions) {
+function hasSelectorConditionContradiction(conditions) {
 	const modifiers = [];
 	const pseudos = [];
 	for (const c of conditions) if ("attribute" in c) modifiers.push(c);
@@ -453,22 +458,36 @@ function hasOwnConditionContradiction(conditions) {
 	return hasModifierContradiction(modifiers) || hasPseudoContradiction(pseudos);
 }
 /**
+* Check for parent group contradiction: same target (direct + conditions)
+* with opposite negation. E.g. :not([data-hovered] *) and :is([data-hovered] *)
+* in the same variant is impossible.
+*/
+function hasParentGroupContradiction(groups) {
+	const byBaseKey = /* @__PURE__ */ new Map();
+	for (const g of groups) {
+		const baseKey = `${g.direct ? ">" : ""}(${g.conditions.map(getSelectorConditionKey).sort().join(",")})`;
+		const existing = byBaseKey.get(baseKey);
+		if (existing !== void 0 && existing !== !g.negated) return true;
+		byBaseKey.set(baseKey, !g.negated);
+	}
+	return false;
+}
+/**
 * Merge two selector variants (AND operation)
 * Deduplicates conditions and checks for contradictions
 */
 function mergeVariants(a, b) {
 	const mergedMedia = dedupeMediaConditions([...a.mediaConditions, ...b.mediaConditions]);
 	if (hasMediaContradiction(mergedMedia)) return null;
-	const mergedRoots = dedupeRootConditions([...a.rootConditions, ...b.rootConditions]);
-	if (hasRootContradiction(mergedRoots)) return null;
-	const mergedModifiers = dedupeModifierConditions([...a.modifierConditions, ...b.modifierConditions]);
-	if (hasModifierContradiction(mergedModifiers)) return null;
-	const mergedPseudos = dedupePseudoConditions([...a.pseudoConditions, ...b.pseudoConditions]);
-	if (hasPseudoContradiction(mergedPseudos)) return null;
-	const mergedParents = dedupeParentConditions([...a.parentConditions, ...b.parentConditions]);
-	if (hasParentContradiction(mergedParents)) return null;
-	const mergedOwn = dedupeOwnConditions([...a.ownConditions, ...b.ownConditions]);
-	if (hasOwnConditionContradiction(mergedOwn)) return null;
+	const mergedRoots = dedupeSelectorConditions([...a.rootConditions, ...b.rootConditions]);
+	if (hasSelectorConditionContradiction(mergedRoots)) return null;
+	const mergedModifiers = dedupeSelectorConditions([...a.modifierConditions, ...b.modifierConditions]);
+	const mergedPseudos = dedupeSelectorConditions([...a.pseudoConditions, ...b.pseudoConditions]);
+	if (hasSelectorConditionContradiction([...mergedModifiers, ...mergedPseudos])) return null;
+	const mergedParentGroups = [...a.parentGroups, ...b.parentGroups];
+	if (hasParentGroupContradiction(mergedParentGroups)) return null;
+	const mergedOwn = dedupeSelectorConditions([...a.ownConditions, ...b.ownConditions]);
+	if (hasSelectorConditionContradiction(mergedOwn)) return null;
 	const mergedContainers = dedupeContainerConditions([...a.containerConditions, ...b.containerConditions]);
 	if (hasContainerStyleContradiction(mergedContainers)) return null;
 	const mergedSupports = dedupeSupportsConditions([...a.supportsConditions, ...b.supportsConditions]);
@@ -481,7 +500,7 @@ function mergeVariants(a, b) {
 		containerConditions: mergedContainers,
 		supportsConditions: mergedSupports,
 		rootConditions: mergedRoots,
-		parentConditions: mergedParents,
+		parentGroups: mergedParentGroups,
 		startingStyle: a.startingStyle || b.startingStyle
 	};
 }
@@ -631,7 +650,7 @@ function hasContainerStyleContradiction(conditions) {
 function getVariantKey(v) {
 	const modifierKey = v.modifierConditions.map(getModifierKey).sort().join("|");
 	const pseudoKey = v.pseudoConditions.map(getPseudoKey).sort().join("|");
-	const ownKey = v.ownConditions.map((c) => "attribute" in c ? `mod:${getModifierKey(c)}` : `pseudo:${getPseudoKey(c)}`).sort().join("|");
+	const ownKey = v.ownConditions.map(getSelectorConditionKey).sort().join("|");
 	const containerKey = v.containerConditions.map((c) => `${c.name ?? ""}:${c.negated ? "!" : ""}${c.condition}`).sort().join("|");
 	return [
 		modifierKey,
@@ -640,8 +659,8 @@ function getVariantKey(v) {
 		v.mediaConditions.map((c) => `${c.subtype}:${c.negated ? "!" : ""}${c.condition}`).sort().join("|"),
 		containerKey,
 		v.supportsConditions.map((c) => `${c.subtype}:${c.negated ? "!" : ""}${c.condition}`).sort().join("|"),
-		v.rootConditions.map(getRootKey).sort().join("|"),
-		v.parentConditions.map(getParentKey).sort().join("|"),
+		v.rootConditions.map(getSelectorConditionKey).sort().join("|"),
+		v.parentGroups.map(getParentGroupKey).sort().join("|"),
 		v.startingStyle ? "1" : "0"
 	].join("###");
 }
@@ -658,15 +677,16 @@ function getVariantKey(v) {
 */
 function isVariantSuperset(a, b) {
 	if (a.startingStyle !== b.startingStyle) return false;
-	if (!isRootConditionsSuperset(a.rootConditions, b.rootConditions)) return false;
+	if (!isSelectorConditionsSuperset(a.rootConditions, b.rootConditions)) return false;
 	if (!isMediaConditionsSuperset(a.mediaConditions, b.mediaConditions)) return false;
 	if (!isContainerConditionsSuperset(a.containerConditions, b.containerConditions)) return false;
 	if (!isSupportsConditionsSuperset(a.supportsConditions, b.supportsConditions)) return false;
 	if (!isModifierConditionsSuperset(a.modifierConditions, b.modifierConditions)) return false;
 	if (!isPseudoConditionsSuperset(a.pseudoConditions, b.pseudoConditions)) return false;
-	if (!isOwnConditionsSuperset(a.ownConditions, b.ownConditions)) return false;
-	if (!isParentConditionsSuperset(a.parentConditions, b.parentConditions)) return false;
-	return a.mediaConditions.length + a.containerConditions.length + a.supportsConditions.length + a.modifierConditions.length + a.pseudoConditions.length + a.rootConditions.length + a.parentConditions.length + a.ownConditions.length > b.mediaConditions.length + b.containerConditions.length + b.supportsConditions.length + b.modifierConditions.length + b.pseudoConditions.length + b.rootConditions.length + b.parentConditions.length + b.ownConditions.length;
+	if (!isSelectorConditionsSuperset(a.ownConditions, b.ownConditions)) return false;
+	if (!isParentGroupsSuperset(a.parentGroups, b.parentGroups)) return false;
+	const parentConditionCount = (groups) => groups.reduce((sum, g) => sum + g.conditions.length, 0);
+	return a.mediaConditions.length + a.containerConditions.length + a.supportsConditions.length + a.modifierConditions.length + a.pseudoConditions.length + a.rootConditions.length + parentConditionCount(a.parentGroups) + a.ownConditions.length > b.mediaConditions.length + b.containerConditions.length + b.supportsConditions.length + b.modifierConditions.length + b.pseudoConditions.length + b.rootConditions.length + parentConditionCount(b.parentGroups) + b.ownConditions.length;
 }
 /**
 * Check if media conditions A is a superset of B
@@ -718,31 +738,26 @@ function isPseudoConditionsSuperset(a, b) {
 	return true;
 }
 /**
-* Check if root conditions A is a superset of B
+* Check if selector conditions A is a superset of B.
+* Shared by root and own conditions.
 */
-function isRootConditionsSuperset(a, b) {
-	const aKeys = new Set(a.map(getRootKey));
-	for (const c of b) if (!aKeys.has(getRootKey(c))) return false;
+function isSelectorConditionsSuperset(a, b) {
+	const aKeys = new Set(a.map(getSelectorConditionKey));
+	for (const c of b) if (!aKeys.has(getSelectorConditionKey(c))) return false;
 	return true;
 }
 /**
-* Check if parent conditions A is a superset of B
+* Check if parent groups A is a superset of B.
+* Each group in B must have a matching group in A.
 */
-function isParentConditionsSuperset(a, b) {
-	const aKeys = new Set(a.map(getParentKey));
-	for (const c of b) if (!aKeys.has(getParentKey(c))) return false;
+function isParentGroupsSuperset(a, b) {
+	if (a.length < b.length) return false;
+	const aKeys = new Set(a.map(getParentGroupKey));
+	for (const g of b) if (!aKeys.has(getParentGroupKey(g))) return false;
 	return true;
 }
-/**
-* Check if own conditions A is a superset of B
-*/
-function isOwnConditionsSuperset(a, b) {
-	const aKeys = new Set(a.map((c) => "attribute" in c ? `mod:${getModifierKey(c)}` : `pseudo:${getPseudoKey(c)}`));
-	for (const c of b) {
-		const key = "attribute" in c ? `mod:${getModifierKey(c)}` : `pseudo:${getPseudoKey(c)}`;
-		if (!aKeys.has(key)) return false;
-	}
-	return true;
+function getParentGroupKey(g) {
+	return `${g.negated ? "!" : ""}${g.direct ? ">" : ""}(${g.conditions.map(getSelectorConditionKey).sort().join(",")})`;
 }
 /**
 * Deduplicate variants
@@ -761,9 +776,8 @@ function dedupeVariants(variants) {
 			result.push(v);
 		}
 	}
-	result.sort((a, b) => {
-		return a.modifierConditions.length + a.pseudoConditions.length + a.ownConditions.length + a.mediaConditions.length + a.containerConditions.length + a.supportsConditions.length + a.rootConditions.length + a.parentConditions.length - (b.modifierConditions.length + b.pseudoConditions.length + b.ownConditions.length + b.mediaConditions.length + b.containerConditions.length + b.supportsConditions.length + b.rootConditions.length + b.parentConditions.length);
-	});
+	const variantConditionCount = (v) => v.modifierConditions.length + v.pseudoConditions.length + v.ownConditions.length + v.mediaConditions.length + v.containerConditions.length + v.supportsConditions.length + v.rootConditions.length + v.parentGroups.reduce((sum, g) => sum + g.conditions.length, 0);
+	result.sort((a, b) => variantConditionCount(a) - variantConditionCount(b));
 	const filtered = [];
 	for (const candidate of result) {
 		let isRedundant = false;
@@ -890,5 +904,5 @@ function buildAtRulesFromVariant(variant) {
 }
 
 //#endregion
-export { buildAtRulesFromVariant, conditionToCSS, modifierToCSS, parentToCSS, pseudoToCSS, rootConditionsToCSS };
+export { buildAtRulesFromVariant, conditionToCSS, modifierToCSS, parentGroupsToCSS, pseudoToCSS, rootConditionsToCSS, selectorConditionToCSS };
 //# sourceMappingURL=materialize.js.map