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

package/dist/cjs/transformFamily.native.cjs

@@ -0,0 +1,517 @@
+"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 transformFamily_exports = {};
+__export(transformFamily_exports, {
+	composeTransformArray: () => composeTransformArray,
+	getTransformTargets: () => getTransformTargets,
+	legacyTransformKeysFor: () => legacyTransformKeysFor,
+	parseTransformString: () => parseTransformString,
+	transformAxisCompositions: () => transformAxisCompositions,
+	transformDeclarationUnit: () => transformDeclarationUnit,
+	transformDeclarationsFor: () => transformDeclarationsFor,
+	transformFamilyProps: () => transformFamilyProps,
+	transformFamilyTargets: () => transformFamilyTargets,
+	transformPropForDeclaration: () => transformPropForDeclaration,
+	uniformLegacySiblings: () => uniformLegacySiblings
+});
+module.exports = __toCommonJS(transformFamily_exports);
+var translateComposition = Object.freeze({
+	property: "translate",
+	defaults: Object.freeze({
+		"--t-x": "0px",
+		"--t-y": "0px"
+	}),
+	value: "var(--t-x, 0px) var(--t-y, 0px)"
+});
+var scaleComposition = Object.freeze({
+	property: "scale",
+	defaults: Object.freeze({
+		"--t-scale-x": "1",
+		"--t-scale-y": "1"
+	}),
+	value: "var(--t-scale-x, 1) var(--t-scale-y, 1)"
+});
+var transformFamilyTargets = Object.freeze({
+	x: {
+		prop: "x",
+		kind: "axis-variable",
+		declaration: "--t-x",
+		effectiveProperty: "translate",
+		composition: translateComposition
+	},
+	y: {
+		prop: "y",
+		kind: "axis-variable",
+		declaration: "--t-y",
+		effectiveProperty: "translate",
+		composition: translateComposition
+	},
+	scaleX: {
+		prop: "scaleX",
+		kind: "axis-variable",
+		declaration: "--t-scale-x",
+		effectiveProperty: "scale",
+		composition: scaleComposition
+	},
+	scaleY: {
+		prop: "scaleY",
+		kind: "axis-variable",
+		declaration: "--t-scale-y",
+		effectiveProperty: "scale",
+		composition: scaleComposition
+	},
+	rotate: {
+		prop: "rotate",
+		kind: "property",
+		declaration: "rotate",
+		effectiveProperty: "rotate"
+	}
+});
+var transformPropTargets = Object.freeze({
+	x: [transformFamilyTargets.x],
+	y: [transformFamilyTargets.y],
+	rotate: [transformFamilyTargets.rotate],
+	scaleX: [transformFamilyTargets.scaleX],
+	scaleY: [transformFamilyTargets.scaleY],
+	scale: [transformFamilyTargets.scaleX, transformFamilyTargets.scaleY]
+});
+var transformFamilyProps = new Set(Object.keys(transformPropTargets));
+var noTargets = Object.freeze([]);
+function getTransformTargets(prop) {
+	var _transformPropTargets_prop;
+	return (_transformPropTargets_prop = transformPropTargets[prop]) !== null && _transformPropTargets_prop !== void 0 ? _transformPropTargets_prop : noTargets;
+}
+function transformDeclarationsFor(prop) {
+	var _transformDeclarations_prop;
+	return (_transformDeclarations_prop = transformDeclarations[prop]) !== null && _transformDeclarations_prop !== void 0 ? _transformDeclarations_prop : noDeclarations;
+}
+var noDeclarations = Object.freeze([]);
+var transformDeclarations = Object.freeze({
+	x: ["--t-x"],
+	y: ["--t-y"],
+	rotate: ["rotate"],
+	scaleX: ["--t-scale-x"],
+	scaleY: ["--t-scale-y"],
+	scale: ["--t-scale-x", "--t-scale-y"]
+});
+var transformPropForDeclaration = Object.freeze({
+	"--t-x": "x",
+	"--t-y": "y",
+	"--t-scale-x": "scaleX",
+	"--t-scale-y": "scaleY",
+	rotate: "rotate"
+});
+var transformDeclarationUnit = Object.freeze({
+	"--t-x": "px",
+	"--t-y": "px",
+	"--t-scale-x": "none",
+	"--t-scale-y": "none",
+	rotate: "deg"
+});
+var legacyTransformKeysFor = Object.freeze({
+	"--t-x": ["x"],
+	"--t-y": ["y"],
+	"--t-scale-x": ["scaleX", "scale"],
+	"--t-scale-y": ["scaleY", "scale"],
+	rotate: ["rotate"]
+});
+var uniformLegacySiblings = Object.freeze({
+	"--t-scale-x": "scaleY",
+	"--t-scale-y": "scaleX"
+});
+var transformAxisCompositions = Object.freeze({
+	"--t-x": translateComposition,
+	"--t-y": translateComposition,
+	"--t-scale-x": scaleComposition,
+	"--t-scale-y": scaleComposition
+});
+function composeTransformArray(results, rawTransform) {
+	var transform = [];
+	var errors = [];
+	for (var _i = 0, _iter = [["x", "translateX"], ["y", "translateY"]]; _i < _iter.length; _i++) {
+		var [prop, key] = _iter[_i];
+		var value = results[prop];
+		if (value == null) continue;
+		var length = readLength(value, prop, errors);
+		if (length !== null) transform.push({ [key]: length });
+	}
+	if (results.rotate != null) {
+		var angle = readAngle(results.rotate, "rotate", errors);
+		if (angle !== null) transform.push({ rotate: angle });
+	}
+	var scaleX = results.scaleX == null ? null : readNumber(results.scaleX, "scaleX", errors);
+	var scaleY = results.scaleY == null ? null : readNumber(results.scaleY, "scaleY", errors);
+	if (scaleX !== null && scaleX === scaleY) {
+		transform.push({ scale: scaleX });
+	} else {
+		if (scaleX !== null) transform.push({ scaleX });
+		if (scaleY !== null) transform.push({ scaleY });
+	}
+	if (rawTransform != null) {
+		if (typeof rawTransform === "string") {
+			var parsed = parseTransformString(rawTransform);
+			var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+			try {
+				for (var _iterator = parsed.errors[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+					var error = _step.value;
+					errors.push(error);
+				}
+			} catch (err) {
+				_didIteratorError = true;
+				_iteratorError = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion && _iterator.return != null) {
+						_iterator.return();
+					}
+				} finally {
+					if (_didIteratorError) {
+						throw _iteratorError;
+					}
+				}
+			}
+			var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+			try {
+				for (var _iterator1 = parsed.transform[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+					var entry = _step1.value;
+					transform.push(entry);
+				}
+			} catch (err) {
+				_didIteratorError1 = true;
+				_iteratorError1 = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+						_iterator1.return();
+					}
+				} finally {
+					if (_didIteratorError1) {
+						throw _iteratorError1;
+					}
+				}
+			}
+		} else {
+			var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = void 0;
+			try {
+				for (var _iterator2 = rawTransform[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+					var entry1 = _step2.value;
+					transform.push(entry1);
+				}
+			} catch (err) {
+				_didIteratorError2 = true;
+				_iteratorError2 = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+						_iterator2.return();
+					}
+				} finally {
+					if (_didIteratorError2) {
+						throw _iteratorError2;
+					}
+				}
+			}
+		}
+	}
+	return {
+		transform,
+		errors
+	};
+}
+function parseTransformString(input) {
+	var transform = [];
+	var errors = [];
+	var index = 0;
+	var length = input.length;
+	while (index < length) {
+		var code = input.charCodeAt(index);
+		if (code === 32 || code === 9 || code === 10 || code === 13 || code === 12 || code === 44) {
+			index++;
+			continue;
+		}
+		var nameStart = index;
+		while (index < length && input.charCodeAt(index) !== 40) {
+			var inner = input.charCodeAt(index);
+			if (inner === 32 || inner === 44) break;
+			index++;
+		}
+		var name = input.slice(nameStart, index).trim();
+		if (input.charCodeAt(index) !== 40) {
+			errors.push({
+				code: "malformed-transform",
+				source: name || input.slice(nameStart),
+				message: `transform: expected "(" after "${name || input.slice(nameStart)}"`
+			});
+			return {
+				transform,
+				errors
+			};
+		}
+		index++;
+		var argsStart = index;
+		var depth = 1;
+		while (index < length && depth > 0) {
+			var inner1 = input.charCodeAt(index);
+			if (inner1 === 40) depth++;
+			else if (inner1 === 41) depth--;
+			if (depth > 0) index++;
+		}
+		if (depth !== 0) {
+			errors.push({
+				code: "malformed-transform",
+				source: name,
+				message: `transform: "${name}(" is never closed`
+			});
+			return {
+				transform,
+				errors
+			};
+		}
+		var args = input.slice(argsStart, index).split(",").map(function(arg) {
+			return arg.trim();
+		}).filter(function(arg) {
+			return arg.length > 0;
+		});
+		index++;
+		readFunction(name, args, transform, errors);
+	}
+	return {
+		transform,
+		errors
+	};
+}
+function readFunction(name, args, transform, errors) {
+	switch (name) {
+		case "translate": {
+			var _args_;
+			var x = readLength((_args_ = args[0]) !== null && _args_ !== void 0 ? _args_ : "0", "translate", errors);
+			if (x !== null) transform.push({ translateX: x });
+			if (args.length > 1) {
+				var y = readLength(args[1], "translate", errors);
+				if (y !== null) transform.push({ translateY: y });
+			}
+			return;
+		}
+		case "translateX":
+		case "translateY": {
+			var _args_1;
+			var value = readLength((_args_1 = args[0]) !== null && _args_1 !== void 0 ? _args_1 : "0", name, errors);
+			if (value !== null) transform.push({ [name]: value });
+			return;
+		}
+		case "translate3d": {
+			var _args_2;
+			var z = (_args_2 = args[2]) !== null && _args_2 !== void 0 ? _args_2 : "0";
+			if (readLength(z, name, []) !== 0) {
+				errors.push({
+					code: "unsupported-transform-function",
+					source: name,
+					message: `transform: "${name}" with a non-zero Z is not supported on native; RN has no translateZ`
+				});
+				return;
+			}
+			var _args_3;
+			var x1 = readLength((_args_3 = args[0]) !== null && _args_3 !== void 0 ? _args_3 : "0", name, errors);
+			if (x1 !== null) transform.push({ translateX: x1 });
+			var _args_4;
+			var y1 = readLength((_args_4 = args[1]) !== null && _args_4 !== void 0 ? _args_4 : "0", name, errors);
+			if (y1 !== null) transform.push({ translateY: y1 });
+			return;
+		}
+		case "scale": {
+			var _args_5;
+			var first = readNumber((_args_5 = args[0]) !== null && _args_5 !== void 0 ? _args_5 : "1", name, errors);
+			if (first === null) return;
+			if (args.length < 2) {
+				transform.push({ scale: first });
+				return;
+			}
+			var second = readNumber(args[1], name, errors);
+			if (second === null) return;
+			if (first === second) {
+				transform.push({ scale: first });
+				return;
+			}
+			transform.push({ scaleX: first });
+			transform.push({ scaleY: second });
+			return;
+		}
+		case "scaleX":
+		case "scaleY": {
+			var _args_6;
+			var value1 = readNumber((_args_6 = args[0]) !== null && _args_6 !== void 0 ? _args_6 : "1", name, errors);
+			if (value1 !== null) transform.push({ [name]: value1 });
+			return;
+		}
+		case "rotate":
+		case "rotateX":
+		case "rotateY":
+		case "rotateZ":
+		case "skewX":
+		case "skewY": {
+			var _args_7;
+			var value2 = readAngle((_args_7 = args[0]) !== null && _args_7 !== void 0 ? _args_7 : "0", name, errors);
+			if (value2 !== null) transform.push({ [name]: value2 });
+			return;
+		}
+		case "perspective": {
+			var _args_8;
+			var value3 = readLength((_args_8 = args[0]) !== null && _args_8 !== void 0 ? _args_8 : "0", name, errors);
+			if (typeof value3 === "number") transform.push({ perspective: value3 });
+			else if (value3 !== null) {
+				errors.push({
+					code: "unsupported-transform-unit",
+					source: name,
+					message: `transform: "${name}" needs an absolute length, not "${args[0]}"`
+				});
+			}
+			return;
+		}
+		case "matrix": {
+			var numbers = [];
+			var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+			try {
+				for (var _iterator = args[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+					var arg = _step.value;
+					var value4 = readNumber(arg, name, errors);
+					if (value4 === null) return;
+					numbers.push(value4);
+				}
+			} catch (err) {
+				_didIteratorError = true;
+				_iteratorError = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion && _iterator.return != null) {
+						_iterator.return();
+					}
+				} finally {
+					if (_didIteratorError) {
+						throw _iteratorError;
+					}
+				}
+			}
+			if (numbers.length !== 9 && numbers.length !== 16) {
+				errors.push({
+					code: "unsupported-matrix-length",
+					source: name,
+					message: `transform: "matrix()" needs 9 or 16 numbers on native, got ${numbers.length}. The six-number CSS form has no faithful native lowering.`
+				});
+				return;
+			}
+			transform.push({ matrix: numbers });
+			return;
+		}
+		default: {
+			errors.push({
+				code: "unsupported-transform-function",
+				source: name,
+				message: `transform: "${name}" has no faithful native lowering`
+			});
+		}
+	}
+}
+function readLength(value, source, errors) {
+	if (typeof value === "number") return value;
+	var text = value.trim();
+	if (text.endsWith("%")) {
+		return Number.isNaN(Number.parseFloat(text)) ? fail() : text;
+	}
+	if (text.endsWith("px")) {
+		var number = Number(text.slice(0, -2));
+		return Number.isFinite(number) ? number : fail();
+	}
+	var bare = Number(text);
+	if (Number.isFinite(bare)) {
+		if (bare === 0) return 0;
+		errors.push({
+			code: "unitless-transform-value",
+			source,
+			message: `transform: "${text}" needs a unit (px or %) in "${source}"; a bare number is invalid CSS`
+		});
+		return null;
+	}
+	return fail();
+	function fail() {
+		errors.push({
+			code: "unsupported-transform-unit",
+			source,
+			message: `transform: "${text}" is not a length native can carry in "${source}"; use px or %`
+		});
+		return null;
+	}
+}
+function readAngle(value, source, errors) {
+	if (typeof value === "number") {
+		if (value === 0) return "0deg";
+		errors.push({
+			code: "unitless-transform-value",
+			source,
+			message: `transform: "${source}" needs deg or rad, got the bare number ${value}`
+		});
+		return null;
+	}
+	var text = value.trim();
+	if (text.endsWith("deg") || text.endsWith("rad")) {
+		return Number.isFinite(Number.parseFloat(text)) ? text : angleFail();
+	}
+	if (Number(text) === 0) return "0deg";
+	if (text.endsWith("turn") || text.endsWith("grad")) {
+		errors.push({
+			code: "unsupported-transform-unit",
+			source,
+			message: `transform: "${text}" \u2014 RN supports only deg and rad, not ${text.endsWith("turn") ? "turn" : "grad"}`
+		});
+		return null;
+	}
+	if (Number.isFinite(Number(text))) {
+		errors.push({
+			code: "unitless-transform-value",
+			source,
+			message: `transform: "${source}" needs deg or rad, got "${text}"`
+		});
+		return null;
+	}
+	return angleFail();
+	function angleFail() {
+		errors.push({
+			code: "unsupported-transform-unit",
+			source,
+			message: `transform: "${text}" is not an angle native can carry in "${source}"`
+		});
+		return null;
+	}
+}
+function readNumber(value, source, errors) {
+	if (typeof value === "number") return value;
+	var text = value.trim();
+	var number = Number(text);
+	if (Number.isFinite(number) && text !== "") return number;
+	errors.push({
+		code: "unsupported-transform-unit",
+		source,
+		message: `transform: "${text}" is not a plain number in "${source}"; scale is unitless on native`
+	});
+	return null;
+}