@tamagui/style-grammar 0.0.0-bootstrap.0 → 3.0.0-beta.643.1

package/dist/cjs/candidate.cjs

@@ -0,0 +1,608 @@
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var candidate_exports = {};
+__export(candidate_exports, {
+	classifyCandidate: () => classifyCandidate,
+	decodeArbitrary: () => decodeArbitrary,
+	encodeArbitrary: () => encodeArbitrary,
+	formatCandidate: () => formatCandidate,
+	hasTokenName: () => hasTokenName,
+	parseCandidate: () => parseCandidate
+});
+module.exports = __toCommonJS(candidate_exports);
+var import_registry = require("./registry.cjs");
+var import_modifierRegistry = require("./modifierRegistry.cjs");
+var import_resolvePayload = require("./resolvePayload.cjs");
+var import_safeAreaVariables = require("./safeAreaVariables.cjs");
+const sizingConveniences = /* @__PURE__ */ new Set([
+	"full",
+	"auto",
+	"screen",
+	"min",
+	"max",
+	"fit"
+]);
+const fontGenerics = /* @__PURE__ */ new Set([
+	"sans",
+	"serif",
+	"mono"
+]);
+const numericPattern = /^\d+(?:\.\d+)?$/;
+const extraPrefixes = [
+	"border-x",
+	"border-y",
+	"rounded-t",
+	"rounded-r",
+	"rounded-b",
+	"rounded-l"
+];
+const negativeTokenProps = /* @__PURE__ */ new Set([
+	"margin",
+	"marginTop",
+	"marginRight",
+	"marginBottom",
+	"marginLeft",
+	"marginHorizontal",
+	"marginVertical",
+	"top",
+	"right",
+	"bottom",
+	"left",
+	"inset",
+	"x",
+	"y",
+	"letterSpacing"
+]);
+const borderWidthKeywords = /* @__PURE__ */ new Set([
+	"thin",
+	"medium",
+	"thick"
+]);
+const ambiguousCssKeywords = /* @__PURE__ */ new Set([
+	"auto",
+	"dashed",
+	"dotted",
+	"double",
+	"groove",
+	"hidden",
+	"inherit",
+	"initial",
+	"inset",
+	"none",
+	"outset",
+	"revert",
+	"revert-layer",
+	"ridge",
+	"solid",
+	"unset"
+]);
+const cssLengthUnits = "(?:px|em|rem|ex|ch|cap|ic|lh|rlh|vw|vh|vmin|vmax|svw|svh|svmin|svmax|lvw|lvh|lvmin|lvmax|dvw|dvh|dvmin|dvmax|cm|mm|q|in|pt|pc)";
+const cssLengthPattern = new RegExp(`^-?(?:\\d+|\\d*\\.\\d+)${cssLengthUnits}$`, "i");
+function hasName(names, name) {
+	if (!names) return false;
+	if (Array.isArray(names)) return names.includes(name);
+	if (names instanceof Set) return names.has(name);
+	return Object.prototype.hasOwnProperty.call(names, name);
+}
+function splitCandidate(candidate) {
+	const parts = [];
+	let current = "";
+	let bracketDepth = 0;
+	let escaped = false;
+	for (const char of candidate) {
+		if (escaped) {
+			current += char;
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			current += char;
+			escaped = true;
+			continue;
+		}
+		if (char === "[") bracketDepth++;
+		if (char === "]") bracketDepth--;
+		if (char === ":" && bracketDepth === 0) {
+			parts.push(current);
+			current = "";
+		} else {
+			current += char;
+		}
+	}
+	if (!current || bracketDepth !== 0) return null;
+	return {
+		modifiers: parts,
+		base: current
+	};
+}
+const modifierRegistryCache = /* @__PURE__ */ new WeakMap();
+function getModifierRegistry(config) {
+	let registry = modifierRegistryCache.get(config);
+	if (!registry) {
+		registry = (0, import_modifierRegistry.createModifierRegistry)(config).registry;
+		modifierRegistryCache.set(config, registry);
+	}
+	return registry;
+}
+function modifierKind(modifier, config) {
+	const canonical = import_registry.modifierAliases[modifier] || modifier;
+	return getModifierRegistry(config).get(canonical) || null;
+}
+function modifiersAreKnown(modifiers, config) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const modifier of modifiers) {
+		const kind = modifierKind(modifier, config);
+		if (!kind || seen.has(kind)) return false;
+		seen.add(kind);
+	}
+	return true;
+}
+function hasTokenDomain(config, category) {
+	return config.tokenNames?.[category] !== void 0;
+}
+function hasTokenName(config, category, name) {
+	return hasName(config.tokenNames?.[category], name);
+}
+function resolveEntries(prefix, config) {
+	const registered = import_registry.prefixToEntries[prefix];
+	if (registered) return registered;
+	if (prefix === "border-x" || prefix === "border-y") {
+		const props = prefix === "border-x" ? ["borderLeft", "borderRight"] : ["borderTop", "borderBottom"];
+		return import_registry.grammarEntries.filter((entry) => props.some((prop) => entry.prop === `${prop}Width` || entry.prop === `${prop}Color`));
+	}
+	if (prefix.startsWith("rounded-")) {
+		const props = import_registry.radiusCornerProps[prefix.slice("rounded-".length)];
+		return props ? import_registry.grammarEntries.filter((entry) => props.includes(entry.prop)) : [];
+	}
+	const expanded = config.shorthands?.[prefix];
+	if (!expanded) return [];
+	return import_registry.grammarEntries.filter((entry) => entry.prop === expanded);
+}
+function findPrefix(base, config) {
+	const prefixes = new Set(Object.keys(import_registry.prefixToEntries));
+	for (const prefix of extraPrefixes) prefixes.add(prefix);
+	for (const shorthand in config.shorthands) prefixes.add(shorthand);
+	let found = null;
+	for (const prefix of prefixes) {
+		if (base.startsWith(`${prefix}-`) && (!found || prefix.length > found.length)) {
+			found = prefix;
+		}
+	}
+	return found;
+}
+function arbitraryInner(rawValue) {
+	if (rawValue.length <= 2 || rawValue[0] !== "[" || rawValue.at(-1) !== "]") {
+		return null;
+	}
+	const inner = rawValue.slice(1, -1);
+	return arbitraryValueIsBalanced(decodeArbitrary(inner)) ? inner : null;
+}
+function arbitraryValueIsBalanced(value) {
+	const opening = /* @__PURE__ */ new Set([
+		"(",
+		"[",
+		"{"
+	]);
+	const matching = {
+		")": "(",
+		"]": "[",
+		"}": "{"
+	};
+	const stack = [];
+	let quote = "";
+	let escaped = false;
+	for (const char of value) {
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (quote) {
+			if (char === quote) quote = "";
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (opening.has(char)) {
+			stack.push(char);
+			continue;
+		}
+		const expected = matching[char];
+		if (expected && stack.pop() !== expected) return false;
+	}
+	return !escaped && !quote && stack.length === 0;
+}
+function fractionIsValid(value) {
+	const fraction = /^(\d+)\/(\d+)$/.exec(value);
+	return !!fraction && Number(fraction[2]) !== 0;
+}
+function arbitraryBorderKind(value) {
+	if (/^-?(?:\d+|\d*\.\d+)$/.test(value)) return "width";
+	if (cssLengthPattern.test(value) || borderWidthKeywords.has(value)) return "width";
+	if (/^(?:calc|min|max|clamp)\(/.test(value)) return "width";
+	if (ambiguousCssKeywords.has(value) || value.startsWith("var(")) return null;
+	if (value.startsWith("#") || /^(?:rgb|hsl|hwb|lab|lch|oklab|oklch|color|color-mix|light-dark)\(/.test(value) || /^[a-zA-Z][a-zA-Z0-9-]*$/.test(value)) {
+		return "color";
+	}
+	return null;
+}
+function tokenLookupName(category, value) {
+	if (category !== "color") return value;
+	const suffix = (0, import_resolvePayload.splitColorOpacitySuffix)(value);
+	return suffix.kind === "none" ? value : suffix.name;
+}
+function chooseEntry(entries, prefix, rawValue, negative, config) {
+	if ((0, import_safeAreaVariables.getSafeAreaEdge)(rawValue)) {
+		const entry = entries.find(({ tokenCategory }) => tokenCategory === "space" || tokenCategory === "size" || tokenCategory === "radius" || tokenCategory === "fontSize" || tokenCategory === "lineHeight" || tokenCategory === "letterSpacing");
+		if (entry) {
+			return {
+				entry,
+				valueKind: "convenience",
+				convenience: "safe-area"
+			};
+		}
+	}
+	const arbitrary = arbitraryInner(rawValue);
+	if (arbitrary !== null) {
+		if (!arbitrary) return null;
+		if (prefix.startsWith("border")) {
+			const width = entries.find((entry) => entry.prop.endsWith("Width"));
+			const color = entries.find((entry) => entry.prop.endsWith("Color"));
+			const kind = arbitraryBorderKind(decodeArbitrary(arbitrary));
+			if (!kind || !width || !color) return null;
+			return {
+				entry: kind === "width" ? width : color,
+				valueKind: "arbitrary"
+			};
+		}
+		if (prefix === "text") {
+			return {
+				entry: entries.find((entry) => entry.prop === "fontSize"),
+				valueKind: "arbitrary"
+			};
+		}
+		if (prefix === "font") {
+			return {
+				entry: entries.find((entry) => entry.prop === "fontFamily"),
+				valueKind: "arbitrary"
+			};
+		}
+		return {
+			entry: entries[0],
+			valueKind: "arbitrary"
+		};
+	}
+	if (prefix === "text") {
+		const fontSize = entries.find((entry) => entry.prop === "fontSize");
+		if (fontSize && hasTokenName(config, "fontSize", rawValue)) {
+			return {
+				entry: fontSize,
+				valueKind: "token"
+			};
+		}
+		if (import_registry.textAlignKeywords.has(rawValue)) {
+			return {
+				entry: entries.find((entry) => entry.prop === "textAlign"),
+				valueKind: "enum"
+			};
+		}
+		return null;
+	}
+	if (prefix === "font") {
+		const fontFamily = entries.find((entry) => entry.prop === "fontFamily");
+		const fontWeight = entries.find((entry) => entry.prop === "fontWeight");
+		if (!fontFamily) return null;
+		const matchesFamily = hasTokenName(config, "fontFamily", rawValue);
+		const matchesWeight = fontWeight && hasTokenName(config, "fontWeight", rawValue);
+		if (matchesFamily && matchesWeight) return null;
+		if (matchesFamily) {
+			return {
+				entry: fontFamily,
+				valueKind: "token"
+			};
+		}
+		if (matchesWeight) {
+			return {
+				entry: fontWeight,
+				valueKind: "token"
+			};
+		}
+		return fontGenerics.has(rawValue) ? {
+			entry: fontFamily,
+			valueKind: "convenience",
+			convenience: "font-generic"
+		} : null;
+	}
+	if (prefix.startsWith("border")) {
+		const width = entries.find((entry) => entry.prop.endsWith("Width"));
+		const color = entries.find((entry) => entry.prop.endsWith("Color"));
+		const token = negative ? `-${rawValue}` : rawValue;
+		const matchesWidth = width && hasTokenName(config, "space", token);
+		const colorName = tokenLookupName("color", rawValue);
+		const matchesColor = color && hasTokenName(config, "color", colorName);
+		if (matchesWidth && matchesColor) return null;
+		if (matchesWidth) {
+			return {
+				entry: width,
+				valueKind: "token"
+			};
+		}
+		if (matchesColor) {
+			return {
+				entry: color,
+				valueKind: "token"
+			};
+		}
+		return null;
+	}
+	for (const entry of entries) {
+		if (entry.tokenCategory) {
+			const name = negative ? `-${rawValue}` : rawValue;
+			const tokenName = tokenLookupName(entry.tokenCategory, name);
+			if (hasTokenName(config, entry.tokenCategory, tokenName)) {
+				return {
+					entry,
+					valueKind: "token"
+				};
+			}
+			if (entry.tokenCategory === "size" && (sizingConveniences.has(rawValue) || fractionIsValid(rawValue))) {
+				return {
+					entry,
+					valueKind: "convenience",
+					convenience: "sizing-keyword"
+				};
+			}
+			if (entry.tokenCategory === "zIndex" && numericPattern.test(rawValue)) {
+				return {
+					entry,
+					valueKind: "convenience",
+					convenience: "integer"
+				};
+			}
+			continue;
+		}
+		if (prefix === "opacity" || prefix === "scale") {
+			if (numericPattern.test(rawValue)) {
+				return {
+					entry,
+					valueKind: "convenience",
+					convenience: "percentage"
+				};
+			}
+			continue;
+		}
+		if (entry.prop === "zIndex" && numericPattern.test(rawValue)) {
+			return {
+				entry,
+				valueKind: "convenience",
+				convenience: "integer"
+			};
+		}
+	}
+	return null;
+}
+function parseCandidate(candidate, config) {
+	const split = splitCandidate(candidate);
+	if (!split || !modifiersAreKnown(split.modifiers, config)) {
+		return null;
+	}
+	const modifiers = split.modifiers.map((modifier) => import_registry.modifierAliases[modifier] || modifier);
+	const negative = split.base[0] === "-";
+	const core = negative ? split.base.slice(1) : split.base;
+	const prefix = findPrefix(core, config);
+	let dynamic;
+	if (prefix) {
+		const rawValue = core.slice(prefix.length + 1);
+		if (rawValue) {
+			const entries = resolveEntries(prefix, config);
+			const selected = chooseEntry(entries, prefix, rawValue, negative, config);
+			if (selected && (!negative || selected.valueKind === "token" && negativeTokenProps.has(selected.entry.prop))) {
+				dynamic = {
+					prefix,
+					rawValue,
+					selected
+				};
+				if (selected.valueKind === "token") {
+					return {
+						candidate,
+						base: split.base,
+						modifiers,
+						negative,
+						kind: "dynamic",
+						prefix,
+						rawValue,
+						arbitrary: arbitraryInner(rawValue) !== null,
+						entry: selected.entry,
+						valueKind: selected.valueKind,
+						convenience: selected.convenience
+					};
+				}
+			}
+		}
+	}
+	const direct = import_registry.wholeClassUtilities[split.base];
+	if (!negative && direct) {
+		const convenience = import_registry.wholeClassConveniences[split.base];
+		return {
+			candidate,
+			base: split.base,
+			modifiers,
+			kind: "utility",
+			valueKind: convenience ? "convenience" : "enum",
+			properties: direct,
+			convenience,
+			negative: false
+		};
+	}
+	if (dynamic) {
+		return {
+			candidate,
+			base: split.base,
+			modifiers,
+			negative,
+			kind: "dynamic",
+			prefix: dynamic.prefix,
+			rawValue: dynamic.rawValue,
+			arbitrary: arbitraryInner(dynamic.rawValue) !== null,
+			entry: dynamic.selected.entry,
+			valueKind: dynamic.selected.valueKind,
+			convenience: dynamic.selected.convenience
+		};
+	}
+	return null;
+}
+function classifyCandidate(candidate, config) {
+	const parsed = parseCandidate(candidate, config);
+	return parsed ? {
+		kind: "tamagui",
+		parsed
+	} : {
+		kind: "passthrough",
+		reason: "not in the configured Tamagui grammar"
+	};
+}
+function tokenValidationConfig(entry, value, config) {
+	const tokenNames = { ...config?.tokenNames };
+	const category = entry.tokenCategory;
+	if (tokenNames[category] === void 0) {
+		tokenNames[category] = [tokenLookupName(category, value)];
+	}
+	for (const other of import_registry.prefixToEntries[entry.prefix] || []) {
+		if (other.tokenCategory && tokenNames[other.tokenCategory] === void 0) {
+			tokenNames[other.tokenCategory] = [];
+		}
+	}
+	return {
+		...config,
+		tokenNames
+	};
+}
+function formatCandidate({ prop, value, valueKind, modifiers = [] }, config) {
+	const entry = import_registry.grammarEntries.find((candidate2) => candidate2.prop === prop);
+	if (!entry) return null;
+	if (valueKind === "arbitrary" && value === "") return null;
+	if (!modifiersAreKnown(modifiers, config || {})) return null;
+	const normalizedModifiers = modifiers.map((modifier) => import_registry.modifierAliases[modifier] || modifier);
+	if (valueKind === "enum") {
+		const whole2 = import_registry.standaloneValueProps[prop]?.[value];
+		if (whole2) {
+			const candidate2 = normalizedModifiers.length ? `${normalizedModifiers.join(":")}:${whole2}` : whole2;
+			if (config) {
+				const parsed2 = parseCandidate(candidate2, config);
+				if (!parsed2?.properties || parsed2.properties[prop] !== value) return null;
+			}
+			return candidate2;
+		}
+		if (prop === "fontWeight") {
+			const name = import_registry.fontWeightNames[value];
+			if (!name) return null;
+			const core2 = `font-${name}`;
+			if (String(import_registry.wholeClassUtilities[core2]?.fontWeight) !== value) return null;
+			const candidate2 = normalizedModifiers.length ? `${normalizedModifiers.join(":")}:${core2}` : core2;
+			if (config) {
+				const parsed2 = parseCandidate(candidate2, config);
+				if (!parsed2?.properties || String(parsed2.properties.fontWeight) !== value) {
+					return null;
+				}
+			}
+			return candidate2;
+		}
+	}
+	if (!entry.prefix) return null;
+	if (valueKind === "token") {
+		if (!entry.tokenCategory) return null;
+		const sourceDomainKnown = !!config && hasTokenDomain(config, entry.tokenCategory);
+		const lookupName = tokenLookupName(entry.tokenCategory, value);
+		if (sourceDomainKnown && !hasTokenName(config, entry.tokenCategory, lookupName)) return null;
+		const colliding = import_registry.prefixToEntries[entry.prefix].filter((other) => other.prop !== prop && other.tokenCategory);
+		if (colliding.length) {
+			if (!config || !sourceDomainKnown) return null;
+			for (const other of colliding) {
+				if (!hasTokenDomain(config, other.tokenCategory)) return null;
+				if (hasTokenName(config, other.tokenCategory, value)) return null;
+			}
+		}
+	}
+	const formattedValue = valueKind === "arbitrary" ? `[${encodeArbitrary(value)}]` : value;
+	const core = formattedValue[0] === "-" && formattedValue[1] !== "[" ? `-${entry.prefix}-${formattedValue.slice(1)}` : formattedValue ? `${entry.prefix}-${formattedValue}` : entry.prefix;
+	const candidate = normalizedModifiers.length ? `${normalizedModifiers.join(":")}:${core}` : core;
+	const whole = import_registry.wholeClassUtilities[core];
+	if (whole) {
+		if (valueKind === "token") {
+			if (!config || !hasTokenDomain(config, entry.tokenCategory)) return null;
+		} else if (config) {
+			const parsed2 = parseCandidate(candidate, config);
+			if (parsed2?.kind === "utility") {
+				return Object.prototype.hasOwnProperty.call(parsed2.properties, prop) && String(parsed2.properties?.[prop]) === value ? candidate : null;
+			}
+			return parsed2?.entry?.prop === prop && parsed2.valueKind === valueKind ? candidate : null;
+		} else if (Object.prototype.hasOwnProperty.call(whole, prop) && String(whole[prop]) === value) {
+			return candidate;
+		} else {
+			return null;
+		}
+	}
+	if (valueKind === "token") {
+		if (!hasTokenDomain(config || {}, entry.tokenCategory) && parseCandidate(candidate, config || {})) {
+			return null;
+		}
+		const parsed2 = parseCandidate(candidate, tokenValidationConfig(entry, value, config));
+		const parsedValue = parsed2?.rawValue ? `${parsed2.negative ? "-" : ""}${parsed2.rawValue}` : null;
+		if (parsed2?.kind !== "dynamic" || parsed2.entry?.prop !== prop || parsed2.valueKind !== "token" || parsedValue !== value) {
+			return null;
+		}
+		return candidate;
+	}
+	const parsed = parseCandidate(candidate, config || {});
+	if (!parsed || parsed.entry?.prop !== prop || parsed.valueKind !== valueKind) return null;
+	return candidate;
+}
+function encodeArbitrary(value) {
+	let encoded = "";
+	for (const char of value) {
+		if (char === "\\" || char === "_" || char === "[" || char === "]") {
+			encoded += `\\${char}`;
+		} else if (/\s/.test(char)) {
+			encoded += "_";
+		} else {
+			encoded += char;
+		}
+	}
+	return encoded;
+}
+function decodeArbitrary(value) {
+	let decoded = "";
+	for (let index = 0; index < value.length; index++) {
+		const char = value[index];
+		if (char === "\\" && index + 1 < value.length) {
+			decoded += value[++index];
+		} else {
+			decoded += char === "_" ? " " : char;
+		}
+	}
+	return decoded;
+}