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

package/dist/cjs/transition.cjs

@@ -0,0 +1,459 @@
+
+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 transition_exports = {};
+__export(transition_exports, {
+	parseTransition: () => parseTransition,
+	parseTransitionLonghands: () => parseTransitionLonghands,
+	serializeTransition: () => serializeTransition
+});
+module.exports = __toCommonJS(transition_exports);
+const globalValues = /* @__PURE__ */ new Set([
+	"inherit",
+	"initial",
+	"revert",
+	"revert-layer",
+	"unset"
+]);
+const timingKeywords = /* @__PURE__ */ new Set([
+	"ease",
+	"linear",
+	"ease-in",
+	"ease-out",
+	"ease-in-out",
+	"step-start",
+	"step-end"
+]);
+const behaviorValues = /* @__PURE__ */ new Set(["normal", "allow-discrete"]);
+const reservedPresetNames = /* @__PURE__ */ new Set([
+	...globalValues,
+	...timingKeywords,
+	...behaviorValues,
+	"all",
+	"none"
+]);
+const noPresetNames = /* @__PURE__ */ new Set();
+const identifierPattern = /^-?(?:[_a-zA-Z]|[^\0-\x7f])(?:[-_a-zA-Z0-9]|[^\0-\x7f])*$/;
+const timePattern = /^([+-]?(?:\d+(?:\.\d*)?|\.\d+))(ms|s)$/;
+function splitTopLevel(input, separator) {
+	const values = [];
+	let start = 0;
+	let depth = 0;
+	let quote = "";
+	for (let index = 0; index < input.length; index++) {
+		const character = input[index];
+		if (quote) {
+			if (character === "\\") index++;
+			else if (character === quote) quote = "";
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			continue;
+		}
+		if (character === "(") {
+			depth++;
+			continue;
+		}
+		if (character === ")") {
+			depth--;
+			if (depth < 0) return null;
+			continue;
+		}
+		if (depth !== 0) continue;
+		const matches = separator === "," ? character === "," : /\s/.test(character);
+		if (!matches) continue;
+		const value = input.slice(start, index).trim();
+		if (value) values.push(value);
+		else if (separator === ",") values.push("");
+		start = index + 1;
+		if (separator === " ") {
+			while (start < input.length && /\s/.test(input[start])) start++;
+			index = start - 1;
+		}
+	}
+	if (depth !== 0 || quote) return null;
+	values.push(input.slice(start).trim());
+	return values;
+}
+function isTime(value) {
+	return timePattern.test(value);
+}
+function isTimingFunction(value) {
+	if (timingKeywords.has(value)) return true;
+	if (/^cubic-bezier\(\s*[^)]+\s*\)$/.test(value)) {
+		const values = value.slice(value.indexOf("(") + 1, -1).split(",");
+		if (values.length !== 4) return false;
+		const numbers = [];
+		for (let index = 0; index < values.length; index++) {
+			const number = Number(values[index].trim());
+			if (!Number.isFinite(number)) return false;
+			numbers.push(number);
+		}
+		return numbers[0] >= 0 && numbers[0] <= 1 && numbers[2] >= 0 && numbers[2] <= 1;
+	}
+	if (/^steps\(\s*[^)]+\s*\)$/.test(value)) {
+		const parts = value.slice(value.indexOf("(") + 1, -1).split(",");
+		if (parts.length > 2) return false;
+		const count = Number(parts[0].trim());
+		if (!Number.isInteger(count) || count <= 0) return false;
+		const position = parts[1]?.trim();
+		if (position !== void 0 && !/^(jump-start|jump-end|jump-none|jump-both|start|end)$/.test(position)) {
+			return false;
+		}
+		return position !== "jump-none" || count > 1;
+	}
+	if (/^linear\(\s*[^)]+\s*\)$/.test(value)) return true;
+	return false;
+}
+function parseSingleTransition(item) {
+	const tokens = splitTopLevel(item, " ");
+	if (tokens === null || tokens.length === 0) {
+		return {
+			code: "transition-invalid-token",
+			item,
+			message: `"${item}" is not a balanced CSS transition`
+		};
+	}
+	for (let index = 0; index < tokens.length; index++) {
+		if (!tokens[index]) {
+			return {
+				code: "transition-invalid-token",
+				item,
+				message: `"${item}" is not a balanced CSS transition`
+			};
+		}
+	}
+	let property;
+	let duration;
+	let delay;
+	let timingFunction;
+	let behavior;
+	for (const token of tokens) {
+		if (globalValues.has(token)) {
+			return {
+				code: "transition-invalid-list",
+				item,
+				token,
+				message: `CSS-wide value "${token}" must be the whole transition`
+			};
+		}
+		if (isTime(token)) {
+			if (duration === void 0) {
+				if (Number(token.match(timePattern)?.[1]) < 0) {
+					return {
+						code: "transition-invalid-duration",
+						item,
+						token,
+						message: `transition duration "${token}" cannot be negative`
+					};
+				}
+				duration = token;
+			} else if (delay === void 0) {
+				delay = token;
+			} else {
+				return {
+					code: "transition-duplicate-component",
+					item,
+					token,
+					message: `"${item}" has more than two time values`
+				};
+			}
+			continue;
+		}
+		if (isTimingFunction(token)) {
+			if (timingFunction !== void 0) {
+				return {
+					code: "transition-duplicate-component",
+					item,
+					token,
+					message: `"${item}" has more than one timing function`
+				};
+			}
+			timingFunction = token;
+			continue;
+		}
+		if (behaviorValues.has(token)) {
+			if (behavior !== void 0) {
+				return {
+					code: "transition-duplicate-component",
+					item,
+					token,
+					message: `"${item}" has more than one transition behavior`
+				};
+			}
+			behavior = token;
+			continue;
+		}
+		if (identifierPattern.test(token) || /^--[-_a-zA-Z0-9]+$/.test(token)) {
+			if (property !== void 0) {
+				return {
+					code: "transition-duplicate-component",
+					item,
+					token,
+					message: `"${item}" has more than one transition property`
+				};
+			}
+			property = token;
+			continue;
+		}
+		return {
+			code: "transition-invalid-token",
+			item,
+			token,
+			message: `"${token}" is not valid in a CSS transition`
+		};
+	}
+	if (property === "none" && (duration !== void 0 || delay !== void 0 || timingFunction !== void 0 || behavior !== void 0)) {
+		return {
+			code: "transition-invalid-list",
+			item,
+			message: "\"none\" cannot be combined with other transition components"
+		};
+	}
+	return {
+		property: property ?? "all",
+		timing: {
+			type: "css",
+			duration: duration ?? "0s",
+			timingFunction: timingFunction ?? "ease"
+		},
+		delay: delay ?? "0s",
+		behavior: behavior ?? "normal"
+	};
+}
+function parseTransition(input, presetNames = noPresetNames) {
+	const value = input.trim();
+	if (!value) {
+		return {
+			ok: false,
+			diagnostics: [{
+				code: "transition-empty-item",
+				message: "transition cannot be empty"
+			}]
+		};
+	}
+	if (globalValues.has(value)) {
+		return {
+			ok: true,
+			value: {
+				kind: "global",
+				value
+			}
+		};
+	}
+	if (identifierPattern.test(value) && !reservedPresetNames.has(value) && presetNames.has(value)) {
+		return {
+			ok: true,
+			value: {
+				kind: "transition",
+				entries: [{
+					property: "all",
+					timing: {
+						type: "preset",
+						name: value
+					},
+					delay: "0s",
+					behavior: "normal"
+				}]
+			}
+		};
+	}
+	const items = splitTopLevel(value, ",");
+	if (items === null) {
+		return {
+			ok: false,
+			diagnostics: [{
+				code: "transition-invalid-token",
+				item: value,
+				message: `"${value}" is not a balanced CSS transition`
+			}]
+		};
+	}
+	const entries = [];
+	const diagnostics = [];
+	for (const item of items) {
+		if (!item) {
+			diagnostics.push({
+				code: "transition-empty-item",
+				message: "transition lists cannot contain an empty item"
+			});
+			continue;
+		}
+		const parsed = parseSingleTransition(item);
+		if ("code" in parsed) diagnostics.push(parsed);
+		else entries.push(parsed);
+	}
+	let hasNone = false;
+	for (let index = 0; index < entries.length; index++) {
+		if (entries[index].property === "none") {
+			hasNone = true;
+			break;
+		}
+	}
+	if (hasNone && entries.length > 1) {
+		diagnostics.push({
+			code: "transition-invalid-list",
+			message: "\"none\" cannot be combined with other transition items"
+		});
+	}
+	return diagnostics.length ? {
+		ok: false,
+		diagnostics
+	} : {
+		ok: true,
+		value: {
+			kind: "transition",
+			entries
+		}
+	};
+}
+function parseLonghandList(value, fallback) {
+	if (value === void 0) return [fallback];
+	const values = splitTopLevel(value, ",");
+	if (!values?.length) return null;
+	for (let index = 0; index < values.length; index++) {
+		if (!values[index]) return null;
+	}
+	return values;
+}
+function parseTransitionLonghands(input) {
+	const properties = parseLonghandList(input.transitionProperty, "all");
+	const durations = parseLonghandList(input.transitionDuration, "0s");
+	const timings = parseLonghandList(input.transitionTimingFunction, "ease");
+	const delays = parseLonghandList(input.transitionDelay, "0s");
+	const behaviors = parseLonghandList(input.transitionBehavior, "normal");
+	if (!properties || !durations || !timings || !delays || !behaviors) {
+		return {
+			ok: false,
+			diagnostics: [{
+				code: "transition-invalid-list",
+				message: "transition longhands must be non-empty comma-separated lists"
+			}]
+		};
+	}
+	const entries = [];
+	const diagnostics = [];
+	for (let index = 0; index < properties.length; index++) {
+		const property = properties[index];
+		const duration = durations[index % durations.length];
+		const timingFunction = timings[index % timings.length];
+		const delay = delays[index % delays.length];
+		const behavior = behaviors[index % behaviors.length];
+		if (globalValues.has(property) || globalValues.has(duration) || globalValues.has(timingFunction) || globalValues.has(delay) || globalValues.has(behavior)) {
+			diagnostics.push({
+				code: "transition-invalid-list",
+				message: "CSS-wide values cannot be mixed into transition longhand lists; use the transition shorthand global value"
+			});
+			break;
+		}
+		if (!(identifierPattern.test(property) || /^--[-_a-zA-Z0-9]+$/.test(property))) {
+			diagnostics.push({
+				code: "transition-invalid-token",
+				token: property,
+				message: `"${property}" is not a transition property`
+			});
+		}
+		if (!isTime(duration) || Number(duration.match(timePattern)?.[1]) < 0) {
+			diagnostics.push({
+				code: "transition-invalid-duration",
+				token: duration,
+				message: `"${duration}" is not a non-negative transition duration`
+			});
+		}
+		if (!isTimingFunction(timingFunction)) {
+			diagnostics.push({
+				code: "transition-invalid-token",
+				token: timingFunction,
+				message: `"${timingFunction}" is not a transition timing function`
+			});
+		}
+		if (!isTime(delay)) {
+			diagnostics.push({
+				code: "transition-invalid-token",
+				token: delay,
+				message: `"${delay}" is not a transition delay`
+			});
+		}
+		if (!behaviorValues.has(behavior)) {
+			diagnostics.push({
+				code: "transition-invalid-token",
+				token: behavior,
+				message: `"${behavior}" is not a transition behavior`
+			});
+		}
+		entries.push({
+			property,
+			timing: {
+				type: "css",
+				duration,
+				timingFunction
+			},
+			delay,
+			behavior
+		});
+	}
+	let hasNone = false;
+	for (let index = 0; index < properties.length; index++) {
+		if (properties[index] === "none") {
+			hasNone = true;
+			break;
+		}
+	}
+	if (hasNone && properties.length > 1) {
+		diagnostics.push({
+			code: "transition-invalid-list",
+			message: "\"none\" cannot be combined with other transition properties"
+		});
+	}
+	return diagnostics.length ? {
+		ok: false,
+		diagnostics
+	} : {
+		ok: true,
+		value: {
+			kind: "transition",
+			entries
+		}
+	};
+}
+function serializeTransition(value) {
+	if (value.kind === "global") return value.value;
+	if (value.enter || value.exit || value.config) return null;
+	for (let index = 0; index < value.entries.length; index++) {
+		if (value.entries[index].timing.type === "preset") return null;
+	}
+	let serialized = "";
+	for (let index = 0; index < value.entries.length; index++) {
+		const entry = value.entries[index];
+		if (index) serialized += ", ";
+		if (entry.timing.type !== "css") return null;
+		if (entry.property === "none") {
+			if (entry.timing.duration !== "0s" || entry.timing.timingFunction !== "ease" || entry.delay !== "0s" || entry.behavior !== "normal") {
+				return null;
+			}
+			serialized += "none";
+			continue;
+		}
+		serialized += `${entry.property} ${entry.timing.duration} ${entry.timing.timingFunction} ${entry.delay} ${entry.behavior}`;
+	}
+	return serialized;
+}