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

package/dist/cjs/transition.native.cjs

@@ -0,0 +1,499 @@
+"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 transition_exports = {};
+__export(transition_exports, {
+	parseTransition: () => parseTransition,
+	parseTransitionLonghands: () => parseTransitionLonghands,
+	serializeTransition: () => serializeTransition
+});
+module.exports = __toCommonJS(transition_exports);
+var globalValues = /* @__PURE__ */ new Set([
+	"inherit",
+	"initial",
+	"revert",
+	"revert-layer",
+	"unset"
+]);
+var timingKeywords = /* @__PURE__ */ new Set([
+	"ease",
+	"linear",
+	"ease-in",
+	"ease-out",
+	"ease-in-out",
+	"step-start",
+	"step-end"
+]);
+var behaviorValues = /* @__PURE__ */ new Set(["normal", "allow-discrete"]);
+var reservedPresetNames = /* @__PURE__ */ new Set([
+	...globalValues,
+	...timingKeywords,
+	...behaviorValues,
+	"all",
+	"none"
+]);
+var noPresetNames = /* @__PURE__ */ new Set();
+var identifierPattern = /^-?(?:[_a-zA-Z]|[^\0-\x7f])(?:[-_a-zA-Z0-9]|[^\0-\x7f])*$/;
+var timePattern = /^([+-]?(?:\d+(?:\.\d*)?|\.\d+))(ms|s)$/;
+function splitTopLevel(input, separator) {
+	var values = [];
+	var start = 0;
+	var depth = 0;
+	var quote = "";
+	for (var index = 0; index < input.length; index++) {
+		var 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;
+		var matches = separator === "," ? character === "," : /\s/.test(character);
+		if (!matches) continue;
+		var 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)) {
+		var values = value.slice(value.indexOf("(") + 1, -1).split(",");
+		if (values.length !== 4) return false;
+		var numbers = [];
+		for (var index = 0; index < values.length; index++) {
+			var 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)) {
+		var _parts_;
+		var parts = value.slice(value.indexOf("(") + 1, -1).split(",");
+		if (parts.length > 2) return false;
+		var count = Number(parts[0].trim());
+		if (!Number.isInteger(count) || count <= 0) return false;
+		var position = (_parts_ = parts[1]) === null || _parts_ === void 0 ? void 0 : _parts_.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) {
+	var tokens = splitTopLevel(item, " ");
+	if (tokens === null || tokens.length === 0) {
+		return {
+			code: "transition-invalid-token",
+			item,
+			message: `"${item}" is not a balanced CSS transition`
+		};
+	}
+	for (var index = 0; index < tokens.length; index++) {
+		if (!tokens[index]) {
+			return {
+				code: "transition-invalid-token",
+				item,
+				message: `"${item}" is not a balanced CSS transition`
+			};
+		}
+	}
+	var property;
+	var duration;
+	var delay;
+	var timingFunction;
+	var behavior;
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = tokens[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var token = _step.value;
+			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) {
+					var _token_match;
+					if (Number((_token_match = token.match(timePattern)) === null || _token_match === void 0 ? void 0 : _token_match[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`
+			};
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	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 !== null && property !== void 0 ? property : "all",
+		timing: {
+			type: "css",
+			duration: duration !== null && duration !== void 0 ? duration : "0s",
+			timingFunction: timingFunction !== null && timingFunction !== void 0 ? timingFunction : "ease"
+		},
+		delay: delay !== null && delay !== void 0 ? delay : "0s",
+		behavior: behavior !== null && behavior !== void 0 ? behavior : "normal"
+	};
+}
+function parseTransition(input) {
+	var presetNames = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noPresetNames;
+	var 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"
+				}]
+			}
+		};
+	}
+	var items = splitTopLevel(value, ",");
+	if (items === null) {
+		return {
+			ok: false,
+			diagnostics: [{
+				code: "transition-invalid-token",
+				item: value,
+				message: `"${value}" is not a balanced CSS transition`
+			}]
+		};
+	}
+	var entries = [];
+	var diagnostics = [];
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = items[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var item = _step.value;
+			if (!item) {
+				diagnostics.push({
+					code: "transition-empty-item",
+					message: "transition lists cannot contain an empty item"
+				});
+				continue;
+			}
+			var parsed = parseSingleTransition(item);
+			if ("code" in parsed) diagnostics.push(parsed);
+			else entries.push(parsed);
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	var hasNone = false;
+	for (var 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];
+	var values = splitTopLevel(value, ",");
+	if (!(values === null || values === void 0 ? void 0 : values.length)) return null;
+	for (var index = 0; index < values.length; index++) {
+		if (!values[index]) return null;
+	}
+	return values;
+}
+function parseTransitionLonghands(input) {
+	var properties = parseLonghandList(input.transitionProperty, "all");
+	var durations = parseLonghandList(input.transitionDuration, "0s");
+	var timings = parseLonghandList(input.transitionTimingFunction, "ease");
+	var delays = parseLonghandList(input.transitionDelay, "0s");
+	var 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"
+			}]
+		};
+	}
+	var entries = [];
+	var diagnostics = [];
+	for (var index = 0; index < properties.length; index++) {
+		var _duration_match;
+		var property = properties[index];
+		var duration = durations[index % durations.length];
+		var timingFunction = timings[index % timings.length];
+		var delay = delays[index % delays.length];
+		var 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 = duration.match(timePattern)) === null || _duration_match === void 0 ? void 0 : _duration_match[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
+		});
+	}
+	var hasNone = false;
+	for (var index1 = 0; index1 < properties.length; index1++) {
+		if (properties[index1] === "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 (var index = 0; index < value.entries.length; index++) {
+		if (value.entries[index].timing.type === "preset") return null;
+	}
+	var serialized = "";
+	for (var index1 = 0; index1 < value.entries.length; index1++) {
+		var entry = value.entries[index1];
+		if (index1) 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;
+}