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

package/dist/cjs/transformFamily.cjs

@@ -0,0 +1,425 @@
+
+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);
+const translateComposition = Object.freeze({
+	property: "translate",
+	defaults: Object.freeze({
+		"--t-x": "0px",
+		"--t-y": "0px"
+	}),
+	value: "var(--t-x, 0px) var(--t-y, 0px)"
+});
+const 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)"
+});
+const 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"
+	}
+});
+const transformPropTargets = Object.freeze({
+	x: [transformFamilyTargets.x],
+	y: [transformFamilyTargets.y],
+	rotate: [transformFamilyTargets.rotate],
+	scaleX: [transformFamilyTargets.scaleX],
+	scaleY: [transformFamilyTargets.scaleY],
+	scale: [transformFamilyTargets.scaleX, transformFamilyTargets.scaleY]
+});
+const transformFamilyProps = new Set(Object.keys(transformPropTargets));
+const noTargets = Object.freeze([]);
+function getTransformTargets(prop) {
+	return transformPropTargets[prop] ?? noTargets;
+}
+function transformDeclarationsFor(prop) {
+	return transformDeclarations[prop] ?? noDeclarations;
+}
+const noDeclarations = Object.freeze([]);
+const 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"]
+});
+const transformPropForDeclaration = Object.freeze({
+	"--t-x": "x",
+	"--t-y": "y",
+	"--t-scale-x": "scaleX",
+	"--t-scale-y": "scaleY",
+	rotate: "rotate"
+});
+const transformDeclarationUnit = Object.freeze({
+	"--t-x": "px",
+	"--t-y": "px",
+	"--t-scale-x": "none",
+	"--t-scale-y": "none",
+	rotate: "deg"
+});
+const legacyTransformKeysFor = Object.freeze({
+	"--t-x": ["x"],
+	"--t-y": ["y"],
+	"--t-scale-x": ["scaleX", "scale"],
+	"--t-scale-y": ["scaleY", "scale"],
+	rotate: ["rotate"]
+});
+const uniformLegacySiblings = Object.freeze({
+	"--t-scale-x": "scaleY",
+	"--t-scale-y": "scaleX"
+});
+const transformAxisCompositions = Object.freeze({
+	"--t-x": translateComposition,
+	"--t-y": translateComposition,
+	"--t-scale-x": scaleComposition,
+	"--t-scale-y": scaleComposition
+});
+function composeTransformArray(results, rawTransform) {
+	const transform = [];
+	const errors = [];
+	for (const [prop, key] of [["x", "translateX"], ["y", "translateY"]]) {
+		const value = results[prop];
+		if (value == null) continue;
+		const length = readLength(value, prop, errors);
+		if (length !== null) transform.push({ [key]: length });
+	}
+	if (results.rotate != null) {
+		const angle = readAngle(results.rotate, "rotate", errors);
+		if (angle !== null) transform.push({ rotate: angle });
+	}
+	const scaleX = results.scaleX == null ? null : readNumber(results.scaleX, "scaleX", errors);
+	const 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") {
+			const parsed = parseTransformString(rawTransform);
+			for (const error of parsed.errors) errors.push(error);
+			for (const entry of parsed.transform) transform.push(entry);
+		} else {
+			for (const entry of rawTransform) transform.push(entry);
+		}
+	}
+	return {
+		transform,
+		errors
+	};
+}
+function parseTransformString(input) {
+	const transform = [];
+	const errors = [];
+	let index = 0;
+	const length = input.length;
+	while (index < length) {
+		const code = input.charCodeAt(index);
+		if (code === 32 || code === 9 || code === 10 || code === 13 || code === 12 || code === 44) {
+			index++;
+			continue;
+		}
+		const nameStart = index;
+		while (index < length && input.charCodeAt(index) !== 40) {
+			const inner = input.charCodeAt(index);
+			if (inner === 32 || inner === 44) break;
+			index++;
+		}
+		const 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++;
+		const argsStart = index;
+		let depth = 1;
+		while (index < length && depth > 0) {
+			const inner = input.charCodeAt(index);
+			if (inner === 40) depth++;
+			else if (inner === 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
+			};
+		}
+		const args = input.slice(argsStart, index).split(",").map((arg) => arg.trim()).filter((arg) => arg.length > 0);
+		index++;
+		readFunction(name, args, transform, errors);
+	}
+	return {
+		transform,
+		errors
+	};
+}
+function readFunction(name, args, transform, errors) {
+	switch (name) {
+		case "translate": {
+			const x = readLength(args[0] ?? "0", "translate", errors);
+			if (x !== null) transform.push({ translateX: x });
+			if (args.length > 1) {
+				const y = readLength(args[1], "translate", errors);
+				if (y !== null) transform.push({ translateY: y });
+			}
+			return;
+		}
+		case "translateX":
+		case "translateY": {
+			const value = readLength(args[0] ?? "0", name, errors);
+			if (value !== null) transform.push({ [name]: value });
+			return;
+		}
+		case "translate3d": {
+			const z = 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;
+			}
+			const x = readLength(args[0] ?? "0", name, errors);
+			if (x !== null) transform.push({ translateX: x });
+			const y = readLength(args[1] ?? "0", name, errors);
+			if (y !== null) transform.push({ translateY: y });
+			return;
+		}
+		case "scale": {
+			const first = readNumber(args[0] ?? "1", name, errors);
+			if (first === null) return;
+			if (args.length < 2) {
+				transform.push({ scale: first });
+				return;
+			}
+			const 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": {
+			const value = readNumber(args[0] ?? "1", name, errors);
+			if (value !== null) transform.push({ [name]: value });
+			return;
+		}
+		case "rotate":
+		case "rotateX":
+		case "rotateY":
+		case "rotateZ":
+		case "skewX":
+		case "skewY": {
+			const value = readAngle(args[0] ?? "0", name, errors);
+			if (value !== null) transform.push({ [name]: value });
+			return;
+		}
+		case "perspective": {
+			const value = readLength(args[0] ?? "0", name, errors);
+			if (typeof value === "number") transform.push({ perspective: value });
+			else if (value !== null) {
+				errors.push({
+					code: "unsupported-transform-unit",
+					source: name,
+					message: `transform: "${name}" needs an absolute length, not "${args[0]}"`
+				});
+			}
+			return;
+		}
+		case "matrix": {
+			const numbers = [];
+			for (const arg of args) {
+				const value = readNumber(arg, name, errors);
+				if (value === null) return;
+				numbers.push(value);
+			}
+			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;
+	const text = value.trim();
+	if (text.endsWith("%")) {
+		return Number.isNaN(Number.parseFloat(text)) ? fail() : text;
+	}
+	if (text.endsWith("px")) {
+		const number = Number(text.slice(0, -2));
+		return Number.isFinite(number) ? number : fail();
+	}
+	const 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;
+	}
+	const 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;
+	const text = value.trim();
+	const 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;
+}