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

package/dist/cjs/candidate.native.cjs

@@ -0,0 +1,431 @@
+"use strict";
+
+
+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, {
+	getStyleGrammarConfig: () => getStyleGrammarConfig,
+	isTokenValueProp: () => isTokenValueProp,
+	preprocessTailwindClassName: () => preprocessTailwindClassName,
+	setInAuthoredOrder: () => setInAuthoredOrder
+});
+module.exports = __toCommonJS(candidate_exports);
+var import_constants = require("@tamagui/constants");
+var import_internal_runtime = require("@tamagui/core/internal-runtime");
+var import_runtime = require("@tamagui/style-grammar/runtime");
+var styleGrammarConfigCache = /* @__PURE__ */ new WeakMap();
+function getStyleGrammarConfig(config) {
+	var cached = styleGrammarConfigCache.get(config);
+	if (cached) return cached;
+	var view = (0, import_runtime.createGrammarConfigView)(config);
+	styleGrammarConfigCache.set(config, view);
+	return view;
+}
+function isTokenValueProp(prop) {
+	return (0, import_runtime.getTokenCategory)(prop) !== null;
+}
+function arbitraryValue(inner) {
+	var px = /^(-?\d*\.?\d+)px$/.exec(inner);
+	if (px) return Number(px[1]);
+	if (/^-?\d*\.?\d+$/.test(inner)) return Number(inner);
+	return inner;
+}
+function tailwindSizingValue(prop, value) {
+	if (value === "full") return "100%";
+	if (value === "auto") return "auto";
+	if (value === "screen") return /[Hh]eight/.test(prop) ? "100vh" : "100vw";
+	if (value === "min") return "min-content";
+	if (value === "max") return "max-content";
+	if (value === "fit") return "fit-content";
+	var frac = /^(\d+)\/(\d+)$/.exec(value);
+	if (frac && Number(frac[2]) !== 0) {
+		return `${Number(frac[1]) / Number(frac[2]) * 100}%`;
+	}
+	return null;
+}
+function borderDimValue(raw) {
+	var inner = raw;
+	if (raw.length > 1 && raw[0] === "[" && raw[raw.length - 1] === "]") {
+		inner = (0, import_runtime.decodeArbitrary)(raw.slice(1, -1));
+	}
+	var px = /^(-?\d*\.?\d+)px$/.exec(inner);
+	if (px) return Number.parseFloat(px[1]);
+	if (/^-?\d*\.?\d+$/.test(inner)) return Number(inner);
+	return inner;
+}
+function expandBorderCandidate(parsed, value) {
+	var _parsed_entry;
+	var prefix = parsed.prefix;
+	if (!prefix) return null;
+	if (prefix.startsWith("rounded-")) {
+		var props = import_runtime.radiusCornerProps[prefix.slice("rounded-".length)];
+		if (!props || props.length === 1) return null;
+		var out = {};
+		var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+		try {
+			for (var _iterator = props[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+				var p = _step.value;
+				out[p] = value;
+			}
+		} catch (err) {
+			_didIteratorError = true;
+			_iteratorError = err;
+		} finally {
+			try {
+				if (!_iteratorNormalCompletion && _iterator.return != null) {
+					_iterator.return();
+				}
+			} finally {
+				if (_didIteratorError) {
+					throw _iteratorError;
+				}
+			}
+		}
+		return out;
+	}
+	var m = /^border-([trblxy])$/.exec(prefix);
+	if (!m) return null;
+	var sides = import_runtime.borderSideSuffix[m[1]];
+	var suffix = ((_parsed_entry = parsed.entry) === null || _parsed_entry === void 0 ? void 0 : _parsed_entry.prop.endsWith("Width")) ? "Width" : "Color";
+	var out1 = {};
+	var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+	try {
+		for (var _iterator1 = sides[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+			var side = _step1.value;
+			out1[`border${side}${suffix}`] = value;
+		}
+	} catch (err) {
+		_didIteratorError1 = true;
+		_iteratorError1 = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+				_iterator1.return();
+			}
+		} finally {
+			if (_didIteratorError1) {
+				throw _iteratorError1;
+			}
+		}
+	}
+	return out1;
+}
+function tailwindClassToFlatProp(parsed) {
+	var _parsed_prefix;
+	if (parsed.kind !== "dynamic" || !parsed.entry || parsed.rawValue === void 0) {
+		return null;
+	}
+	var prop = parsed.entry.prop;
+	var category = parsed.entry.tokenCategory;
+	var value = parsed.rawValue;
+	if (prop.endsWith("Width") && ((_parsed_prefix = parsed.prefix) === null || _parsed_prefix === void 0 ? void 0 : _parsed_prefix.startsWith("border"))) {
+		if (parsed.valueKind === "token") {
+			value = `${parsed.negative ? "-" : ""}${value}`;
+		} else if (parsed.valueKind === "arbitrary") {
+			value = borderDimValue(value);
+		} else {
+			return null;
+		}
+		return {
+			key: prop,
+			value
+		};
+	}
+	if (prop === "fontFamily") {
+		var famValue;
+		if (value.length > 2 && value[0] === "[" && value[value.length - 1] === "]") {
+			famValue = (0, import_runtime.decodeArbitrary)(value.slice(1, -1));
+		} else {
+			var generic = {
+				sans: "sans-serif",
+				serif: "serif",
+				mono: "monospace"
+			};
+			famValue = parsed.valueKind === "token" ? value : generic[value] || value;
+		}
+		return {
+			key: "fontFamily",
+			value: famValue
+		};
+	}
+	if (prop === "fontSize") {
+		var fsValue;
+		if (value.length > 2 && value[0] === "[" && value[value.length - 1] === "]") {
+			fsValue = arbitraryValue((0, import_runtime.decodeArbitrary)(value.slice(1, -1)));
+		} else {
+			fsValue = value;
+		}
+		return {
+			key: "fontSize",
+			value: fsValue
+		};
+	}
+	if (prop === "lineHeight") {
+		var lhValue;
+		if (value.length > 2 && value[0] === "[" && value[value.length - 1] === "]") {
+			var inner = (0, import_runtime.decodeArbitrary)(value.slice(1, -1));
+			lhValue = /^-?\d*\.?\d+px$/.test(inner) ? Number.parseFloat(inner) : inner;
+		} else {
+			lhValue = value;
+		}
+		return {
+			key: "lineHeight",
+			value: lhValue
+		};
+	}
+	if (prop === "letterSpacing") {
+		var lsValue;
+		if (value.length > 2 && value[0] === "[" && value[value.length - 1] === "]") {
+			lsValue = arbitraryValue((0, import_runtime.decodeArbitrary)(value.slice(1, -1)));
+		} else {
+			lsValue = value;
+		}
+		return {
+			key: "letterSpacing",
+			value: lsValue
+		};
+	}
+	if (prop === "boxShadow" && value[0] === "[" && value[value.length - 1] === "]") {
+		return {
+			key: "boxShadow",
+			value: (0, import_runtime.decodeArbitrary)(value.slice(1, -1))
+		};
+	}
+	if (value.length > 2 && value[0] === "[" && value[value.length - 1] === "]") {
+		var inner1 = (0, import_runtime.decodeArbitrary)(value.slice(1, -1));
+		if (inner1 === "") return null;
+		return {
+			key: prop,
+			value: arbitraryValue(inner1)
+		};
+	}
+	if (category === "size" && parsed.valueKind !== "token") {
+		var sized = tailwindSizingValue(prop, value);
+		if (sized != null) {
+			return {
+				key: prop,
+				value: sized
+			};
+		}
+	}
+	var opacitySuffix = "";
+	if (category === "color" && typeof value === "string") {
+		var suffix = (0, import_runtime.splitColorOpacitySuffix)(value);
+		if (suffix.kind === "invalid") {
+			return {
+				key: prop,
+				value
+			};
+		}
+		if (suffix.kind === "valid") {
+			opacitySuffix = value.slice(suffix.name.length);
+			value = suffix.name;
+		}
+	}
+	if (import_runtime.percentUtilityProps.has(prop) && /^\d+$/.test(value)) {
+		value = Number(value) / 100;
+	} else if (/^\d+(\.\d+)?$/.test(value)) {
+		if (category === "zIndex" && parsed.valueKind === "convenience") {
+			value = Number(value);
+		} else if (category) {
+			value = `${parsed.negative ? "-" : ""}${value}`;
+		} else {
+			value = Number(value);
+		}
+	} else if (typeof value === "string") {
+		if (category && !((category === "space" || category === "size" || category === "radius") && (0, import_runtime.getSafeAreaEdge)(value))) {
+			value = `${parsed.negative ? "-" : ""}${value}`;
+		}
+	}
+	if (opacitySuffix && typeof value === "string") {
+		value = `${value}${opacitySuffix}`;
+	}
+	if (parsed.negative && !category) {
+		if (typeof value === "number") value = -value;
+		else if (typeof value === "string" && value[0] !== "-") value = `-${value}`;
+	}
+	return {
+		key: prop,
+		value
+	};
+}
+var classPlanCache = /* @__PURE__ */ new WeakMap();
+function getClassPlanCache(grammarConfig) {
+	var cache = classPlanCache.get(grammarConfig);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		classPlanCache.set(grammarConfig, cache);
+	}
+	return cache;
+}
+function createPlanEntry(property, value, modifiers) {
+	if (modifiers.length === 0) return [property, value];
+	var payload = (0, import_internal_runtime.plainValueToPayload)(value, property);
+	if (payload === null) return null;
+	return [null, (0, import_internal_runtime.createFrontendProgram)(property, {
+		base: null,
+		clauses: [{
+			modifiers,
+			payload
+		}]
+	})];
+}
+function computeClassPlan(cls, grammarConfig) {
+	var groupMarker = /^group(?:\/([A-Za-z0-9_-]+))?$/.exec(cls);
+	if (groupMarker) {
+		return {
+			entries: [["group", groupMarker[1] || true]],
+			preserveRawClass: import_constants.isWeb
+		};
+	}
+	var containerMarker = /^@container(-size)?(?:\/([A-Za-z0-9_-]+))?$/.exec(cls);
+	if (containerMarker) {
+		var isSize = containerMarker[1] !== void 0;
+		var name = containerMarker[2];
+		var entries = [];
+		if (name) entries.push(["containerName", name]);
+		if (isSize) {
+			entries.push(["containerType", "size"]);
+		} else if (name) {
+			entries.push(["containerType", "inline-size"]);
+		} else {
+			entries.push(["container", true]);
+		}
+		return {
+			entries,
+			preserveRawClass: import_constants.isWeb
+		};
+	}
+	var classification = (0, import_runtime.classifyCandidate)(cls, grammarConfig);
+	if (classification.kind === "passthrough") {
+		return import_constants.isWeb ? "raw" : null;
+	}
+	var parsed = classification.parsed;
+	var util = parsed.kind === "utility" ? parsed.properties : null;
+	if (util) {
+		var entries1 = [];
+		for (var p in util) {
+			var entry = createPlanEntry(p, util[p], parsed.modifiers);
+			if (!entry) return "raw";
+			entries1.push(entry);
+		}
+		return entries1;
+	}
+	var flatProp = tailwindClassToFlatProp(parsed);
+	if (flatProp) {
+		var expanded = expandBorderCandidate(parsed, flatProp.value);
+		if (expanded) {
+			var entries2 = [];
+			for (var p1 in expanded) {
+				var entry1 = createPlanEntry(p1, expanded[p1], parsed.modifiers);
+				if (!entry1) return "raw";
+				entries2.push(entry1);
+			}
+			return entries2;
+		}
+		var entry2 = createPlanEntry(flatProp.key, flatProp.value, parsed.modifiers);
+		return entry2 ? [entry2] : "raw";
+	}
+	return "raw";
+}
+var warnedNativePassthroughCandidates = /* @__PURE__ */ new Set();
+function setInAuthoredOrder(target, key, value) {
+	if (key in target) delete target[key];
+	target[key] = value;
+}
+function preprocessTailwindClassName(props, config) {
+	var preservePassthroughPosition = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+	var className = props.className;
+	if (!className || typeof className !== "string") {
+		return props;
+	}
+	var classes = className.split(/\s+/).filter(Boolean);
+	var result = {};
+	var grammarConfig = getStyleGrammarConfig(config);
+	var plans = getClassPlanCache(grammarConfig);
+	var classPlans = classes.map(function(cls2) {
+		var plan2 = plans.get(cls2);
+		if (plan2 === void 0) {
+			plan2 = computeClassPlan(cls2, grammarConfig);
+			plans.set(cls2, plan2);
+		}
+		return plan2;
+	});
+	var hasOwnedStyleCandidate = preservePassthroughPosition && classPlans.some(function(plan2) {
+		return Array.isArray(plan2);
+	});
+	var frontendProgramIndex = 0;
+	var passthroughIndex = 0;
+	var regularClasses = [];
+	var preserveRawClass = function(cls2) {
+		if (hasOwnedStyleCandidate) {
+			result[`${import_internal_runtime.STYLE_FRONTEND_PASSTHROUGH_PREFIX}${passthroughIndex++}`] = cls2;
+		} else {
+			regularClasses.push(cls2);
+		}
+	};
+	var applyEntry = function(param) {
+		var [key2, value] = param;
+		if (key2 === null) {
+			result[`__tamagui_frontend_program_${frontendProgramIndex++}`] = value;
+		} else {
+			setInAuthoredOrder(result, key2, value);
+		}
+	};
+	for (var key in props) {
+		if (key !== "className") {
+			setInAuthoredOrder(result, key, props[key]);
+			continue;
+		}
+		for (var classIndex = 0; classIndex < classes.length; classIndex++) {
+			var cls = classes[classIndex];
+			var plan = classPlans[classIndex];
+			if (plan === null) {
+				if (process.env.NODE_ENV !== "production" && !warnedNativePassthroughCandidates.has(cls)) {
+					warnedNativePassthroughCandidates.add(cls);
+					console.warn(`[tamagui] Tailwind candidate "${cls}" is web-only and was dropped on native. Use a Tamagui grammar candidate or a native style prop for cross-platform output.`);
+				}
+				continue;
+			}
+			if (plan === "raw") {
+				preserveRawClass(cls);
+				continue;
+			}
+			if (!Array.isArray(plan)) {
+				if (plan.preserveRawClass) {
+					preserveRawClass(cls);
+				}
+				for (var i = 0; i < plan.entries.length; i++) {
+					applyEntry(plan.entries[i]);
+				}
+				continue;
+			}
+			for (var i1 = 0; i1 < plan.length; i1++) {
+				applyEntry(plan[i1]);
+			}
+		}
+		if (regularClasses.length > 0) {
+			result.className = regularClasses.join(" ");
+		}
+	}
+	return result;
+}