@tamagui/compiler-core 0.0.0-bootstrap.0 → 3.0.0-beta.1093.1

package/dist/cjs/evaluate.cjs

@@ -0,0 +1,602 @@
+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 evaluate_exports = {};
+__export(evaluate_exports, {
+	collectBranchDependencies: () => collectBranchDependencies,
+	collectLeaves: () => collectLeaves,
+	evaluateBinding: () => evaluateBinding,
+	evaluateBranches: () => evaluateBranches,
+	evaluateDynamicExpression: () => evaluateDynamicExpression,
+	evaluateExpression: () => evaluateExpression
+});
+module.exports = __toCommonJS(evaluate_exports);
+var import_ast = require("./ast.cjs");
+var import_contracts = require("./contracts.cjs");
+var import_diagnostics = require("./diagnostics.cjs");
+function success(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+function literal(node) {
+	if (node.type === "NullLiteral") return null;
+	if (node.type === "Literal" || node.type.endsWith("Literal")) {
+		const value = node.value;
+		if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+			return value;
+		}
+	}
+	return void 0;
+}
+function unsupported(id, node, detail = `Expression ${node.type} is not statically supported`) {
+	return {
+		ok: false,
+		bailout: (0, import_diagnostics.localBailout)("local/unsupported-expression", (0, import_contracts.spanOf)(id, node), detail)
+	};
+}
+function evaluateDefinition(resolver, definition, useSpan, state) {
+	const key = `${definition.id}:${definition.span.start}`;
+	if (state.activeDefinitions.has(key)) {
+		return {
+			ok: false,
+			bailout: (0, import_diagnostics.localBailout)("local/static-evaluation-cycle", useSpan, `Static evaluation cycle reached ${definition.name}`)
+		};
+	}
+	if (!definition.initializer) {
+		return {
+			ok: false,
+			bailout: (0, import_diagnostics.linkedBailout)("linked/missing-initializer", useSpan, `Binding ${definition.name} has no static initializer`, definition.id)
+		};
+	}
+	if (!definition.constant) {
+		return {
+			ok: false,
+			bailout: (0, import_diagnostics.linkedBailout)("linked/unresolved-binding", useSpan, `Binding ${definition.name} is mutable and cannot be statically evaluated`, definition.id)
+		};
+	}
+	const initializer = resolver.expressionNode(definition.initializer);
+	if (!initializer) {
+		return {
+			ok: false,
+			bailout: (0, import_diagnostics.linkedBailout)("linked/missing-initializer", useSpan, `Binding ${definition.name} initializer is outside the linked graph`, definition.id)
+		};
+	}
+	state.dependencies.add(definition.id);
+	state.activeDefinitions.add(key);
+	try {
+		return evaluateNode(resolver, definition.id, initializer, state);
+	} finally {
+		state.activeDefinitions.delete(key);
+	}
+}
+function evaluateObject(resolver, id, node, state) {
+	const output = {};
+	for (const property of (0, import_ast.childNodes)(node, "properties")) {
+		if (property.type === "SpreadElement") {
+			const argument = (0, import_ast.childNode)(property, "argument");
+			if (!argument) return unsupported(id, property);
+			const spread = evaluateNode(resolver, id, argument, state);
+			if (!spread.ok) return spread;
+			if (!spread.value || typeof spread.value !== "object" || Array.isArray(spread.value)) {
+				return {
+					ok: false,
+					bailout: (0, import_diagnostics.localBailout)("local/non-object-spread", (0, import_contracts.spanOf)(id, property), "Static object spread did not evaluate to an object")
+				};
+			}
+			Object.assign(output, spread.value);
+			continue;
+		}
+		if (property.type !== "Property" && property.type !== "ObjectProperty") {
+			return unsupported(id, property);
+		}
+		const keyNode = (0, import_ast.childNode)(property, "key");
+		const valueNode = (0, import_ast.childNode)(property, "value");
+		if (!keyNode || !valueNode) return unsupported(id, property);
+		let key = (0, import_ast.identifierName)(keyNode) ?? void 0;
+		if (property.computed === true || key === void 0) {
+			const evaluatedKey = evaluateNode(resolver, id, keyNode, state);
+			if (!evaluatedKey.ok) return evaluatedKey;
+			key = evaluatedKey.value;
+		}
+		if (typeof key !== "string" && typeof key !== "number") {
+			return unsupported(id, keyNode, "Static object key is not a string or number");
+		}
+		const value = evaluateNode(resolver, id, valueNode, state);
+		if (!value.ok) return value;
+		output[String(key)] = value.value;
+	}
+	return success(output);
+}
+function evaluateArray(resolver, id, node, state) {
+	const output = [];
+	const rawElements = node.elements;
+	if (!Array.isArray(rawElements) || rawElements.some((element) => element === null || !(0, import_ast.isAstNode)(element))) {
+		return unsupported(id, node, "Sparse arrays are not statically supported");
+	}
+	for (const element of rawElements.filter(import_ast.isAstNode)) {
+		if (element.type === "SpreadElement") {
+			const argument = (0, import_ast.childNode)(element, "argument");
+			if (!argument) return unsupported(id, element);
+			const spread = evaluateNode(resolver, id, argument, state);
+			if (!spread.ok) return spread;
+			if (!Array.isArray(spread.value)) {
+				return unsupported(id, element, "Static array spread did not evaluate to an array");
+			}
+			output.push(...spread.value);
+			continue;
+		}
+		const value = evaluateNode(resolver, id, element, state);
+		if (!value.ok) return value;
+		output.push(value.value);
+	}
+	return success(output);
+}
+function evaluateNode(resolver, id, input, state) {
+	const node = (0, import_ast.unwrapExpression)(input);
+	const literalValue = literal(node);
+	if (literalValue !== void 0) return success(literalValue);
+	switch (node.type) {
+		case "Identifier": {
+			const name = (0, import_ast.identifierName)(node);
+			if (!name) return unsupported(id, node);
+			const definition = resolver.resolveReference((0, import_contracts.expressionReference)(id, node));
+			if (!definition) {
+				return {
+					ok: false,
+					bailout: (0, import_diagnostics.linkedBailout)("linked/unresolved-binding", (0, import_contracts.spanOf)(id, node), `Binding ${name} has no host-linked definition`)
+				};
+			}
+			return evaluateDefinition(resolver, definition, (0, import_contracts.spanOf)(id, node), state);
+		}
+		case "ObjectExpression": return evaluateObject(resolver, id, node, state);
+		case "ArrayExpression": return evaluateArray(resolver, id, node, state);
+		case "MemberExpression": {
+			const objectNode = (0, import_ast.childNode)(node, "object");
+			const propertyNode = (0, import_ast.childNode)(node, "property");
+			if (!objectNode || !propertyNode) return unsupported(id, node);
+			const object = evaluateNode(resolver, id, objectNode, state);
+			if (!object.ok) return object;
+			let property = (0, import_ast.identifierName)(propertyNode);
+			if (node.computed === true || property === null) {
+				const evaluatedProperty = evaluateNode(resolver, id, propertyNode, state);
+				if (!evaluatedProperty.ok) return evaluatedProperty;
+				property = evaluatedProperty.value;
+			}
+			if ((typeof object.value !== "object" || object.value === null) && typeof object.value !== "string") {
+				return unsupported(id, node, "Static member target is not indexable");
+			}
+			if (typeof property !== "string" && typeof property !== "number") {
+				return unsupported(id, propertyNode, "Static member key is not a string or number");
+			}
+			const value = object.value[String(property)];
+			return value === void 0 ? unsupported(id, node, `Static member ${String(property)} does not exist`) : success(value);
+		}
+		case "UnaryExpression": {
+			const argument = (0, import_ast.childNode)(node, "argument");
+			if (!argument) return unsupported(id, node);
+			const value = evaluateNode(resolver, id, argument, state);
+			if (!value.ok) return value;
+			if (node.operator === "-" && typeof value.value === "number") {
+				return success(-value.value);
+			}
+			if (node.operator === "+" && typeof value.value === "number") {
+				return success(value.value);
+			}
+			if (node.operator === "!") return success(!value.value);
+			return unsupported(id, node, `Unary operator ${String(node.operator)} is unsupported`);
+		}
+		case "BinaryExpression":
+		case "LogicalExpression": {
+			const leftNode = (0, import_ast.childNode)(node, "left");
+			const rightNode = (0, import_ast.childNode)(node, "right");
+			if (!leftNode || !rightNode) return unsupported(id, node);
+			const left = evaluateNode(resolver, id, leftNode, state);
+			if (!left.ok) return left;
+			if (node.type === "LogicalExpression") {
+				if (node.operator === "&&" && !left.value) return left;
+				if (node.operator === "||" && left.value) return left;
+				if (node.operator === "??" && left.value !== null) return left;
+			}
+			const right = evaluateNode(resolver, id, rightNode, state);
+			if (!right.ok) return right;
+			switch (node.operator) {
+				case "+":
+					if (typeof left.value === "number" && typeof right.value === "number") {
+						return success(left.value + right.value);
+					}
+					if (typeof left.value === "string" || typeof right.value === "string") {
+						return success(String(left.value) + String(right.value));
+					}
+					break;
+				case "-":
+					if (typeof left.value === "number" && typeof right.value === "number") {
+						return success(left.value - right.value);
+					}
+					break;
+				case "*":
+					if (typeof left.value === "number" && typeof right.value === "number") {
+						return success(left.value * right.value);
+					}
+					break;
+				case "/":
+					if (typeof left.value === "number" && typeof right.value === "number") {
+						return success(left.value / right.value);
+					}
+					break;
+				case "&&":
+				case "||":
+				case "??": return right;
+			}
+			return unsupported(id, node, `Binary operator ${String(node.operator)} is unsupported`);
+		}
+		case "ConditionalExpression": {
+			const testNode = (0, import_ast.childNode)(node, "test");
+			const consequent = (0, import_ast.childNode)(node, "consequent");
+			const alternate = (0, import_ast.childNode)(node, "alternate");
+			if (!testNode || !consequent || !alternate) return unsupported(id, node);
+			const test = evaluateNode(resolver, id, testNode, state);
+			if (!test.ok) return test;
+			return evaluateNode(resolver, id, test.value ? consequent : alternate, state);
+		}
+		case "TemplateLiteral": {
+			const quasis = (0, import_ast.childNodes)(node, "quasis");
+			const expressions = (0, import_ast.childNodes)(node, "expressions");
+			let output = "";
+			for (let index = 0; index < quasis.length; index++) {
+				output += quasiText(quasis[index]);
+				const expression = expressions[index];
+				if (expression) {
+					const value = evaluateNode(resolver, id, expression, state);
+					if (!value.ok) return value;
+					output += String(value.value);
+				}
+			}
+			return success(output);
+		}
+		default: return unsupported(id, node);
+	}
+}
+function quasiText(quasi) {
+	const cooked = quasi?.value?.cooked;
+	const raw = quasi?.value?.raw;
+	return typeof cooked === "string" ? cooked : typeof raw === "string" ? raw : "";
+}
+function dynamicPrimitive(value) {
+	if (value === null) return "null";
+	if (typeof value === "number") return "number";
+	if (typeof value === "string") return "string";
+	if (typeof value === "boolean") return "boolean";
+	return null;
+}
+function evaluateDynamicNode(resolver, id, input, state) {
+	const exact = evaluateNode(resolver, id, input, state);
+	if (exact.ok) {
+		const type = dynamicPrimitive(exact.value);
+		return type ? {
+			type,
+			values: [exact.value]
+		} : null;
+	}
+	const node = (0, import_ast.unwrapExpression)(input);
+	if (node.type === "Identifier") {
+		if (!(0, import_ast.identifierName)(node)) return null;
+		const definition = resolver.resolveReference((0, import_contracts.expressionReference)(id, node));
+		if (!definition?.constant || !definition.initializer) return null;
+		const key = `${definition.id}:${definition.span.start}`;
+		if (state.activeDefinitions.has(key)) return null;
+		const initializer = resolver.expressionNode(definition.initializer);
+		if (!initializer) return null;
+		state.dependencies.add(definition.id);
+		state.activeDefinitions.add(key);
+		try {
+			return evaluateDynamicNode(resolver, definition.id, initializer, state);
+		} finally {
+			state.activeDefinitions.delete(key);
+		}
+	}
+	if (node.type === "MemberExpression") {
+		const objectNode = (0, import_ast.childNode)(node, "object");
+		const propertyNode = (0, import_ast.childNode)(node, "property");
+		if (!objectNode || !propertyNode) return null;
+		const object = evaluateNode(resolver, id, objectNode, state);
+		if (!object.ok || !Array.isArray(object.value)) return null;
+		const property = evaluateDynamicNode(resolver, id, propertyNode, state);
+		if (property?.type !== "number" || object.value.length > 32) return null;
+		const values = [];
+		let type = null;
+		for (const value of object.value) {
+			const nextType = dynamicPrimitive(value);
+			if (!nextType || type && type !== nextType) return null;
+			type = nextType;
+			const primitive = value;
+			if (!values.includes(primitive)) values.push(primitive);
+		}
+		return type ? {
+			type,
+			values
+		} : null;
+	}
+	if (node.type === "BinaryExpression") {
+		const leftNode = (0, import_ast.childNode)(node, "left");
+		const rightNode = (0, import_ast.childNode)(node, "right");
+		if (!leftNode || !rightNode) return null;
+		const left = evaluateDynamicNode(resolver, id, leftNode, state);
+		const right = evaluateDynamicNode(resolver, id, rightNode, state);
+		if (node.operator === "+") {
+			return left?.type === "number" && right?.type === "number" ? { type: "number" } : null;
+		}
+		if (node.operator === "-" || node.operator === "*" || node.operator === "/" || node.operator === "%" || node.operator === "**") {
+			if (left?.type === "number" || right?.type === "number") {
+				return { type: "number" };
+			}
+		}
+	}
+	if (node.type === "TemplateLiteral") {
+		const quasis = (0, import_ast.childNodes)(node, "quasis");
+		const expressions = (0, import_ast.childNodes)(node, "expressions");
+		let values = [""];
+		for (let position = 0; position < quasis.length; position++) {
+			const text = quasiText(quasis[position]);
+			values = values.map((value) => value + text);
+			const expression = expressions[position];
+			if (!expression) continue;
+			const part = evaluateDynamicNode(resolver, id, expression, state);
+			if (!part?.values) return null;
+			const next = [];
+			for (const value of values) {
+				for (const primitive of part.values) {
+					const joined = value + String(primitive);
+					if (!next.includes(joined)) next.push(joined);
+				}
+			}
+			if (next.length > 32) return null;
+			values = next;
+		}
+		return {
+			type: "string",
+			values
+		};
+	}
+	return null;
+}
+function collectLeaves(node) {
+	if (node.kind === "leaf") return [node];
+	return [...collectLeaves(node.whenTrue), ...collectLeaves(node.whenFalse)];
+}
+function collectBranchDependencies(node) {
+	if (node.kind === "leaf") return node.dependencies;
+	return [.../* @__PURE__ */ new Set([...collectBranchDependencies(node.whenTrue), ...collectBranchDependencies(node.whenFalse)])].sort();
+}
+function evaluateBranchChild(resolver, id, node, depth, state, sourceId) {
+	const leafState = {
+		activeDefinitions: new Set(state.activeDefinitions),
+		dependencies: new Set(state.dependencies)
+	};
+	const leafRes = evaluateNode(resolver, id, node, leafState);
+	if (leafRes.ok) {
+		return {
+			kind: "leaf",
+			value: leafRes.value,
+			dependencies: [...leafState.dependencies].sort()
+		};
+	}
+	return evaluateBranchesNode(resolver, id, node, depth + 1, leafState, sourceId);
+}
+function evaluateBranchesNode(resolver, id, input, depth, state, sourceId) {
+	const node = (0, import_ast.unwrapExpression)(input);
+	if (!(0, import_ast.isAstNode)(node)) return null;
+	if (node.type === "Identifier") {
+		if (!(0, import_ast.identifierName)(node)) return null;
+		const definition = resolver.resolveReference((0, import_contracts.expressionReference)(id, node));
+		if (!definition || !definition.constant || !definition.initializer) return null;
+		const initializer = resolver.expressionNode(definition.initializer);
+		if (!initializer) return null;
+		const key = `${definition.id}:${definition.span.start}`;
+		if (state.activeDefinitions.has(key)) return null;
+		state.activeDefinitions.add(key);
+		state.dependencies.add(definition.id);
+		try {
+			return evaluateBranchesNode(resolver, definition.id, initializer, depth, state, sourceId);
+		} finally {
+			state.activeDefinitions.delete(key);
+		}
+	}
+	if (depth >= 3) return null;
+	if (node.type === "ConditionalExpression") {
+		const testNode = (0, import_ast.childNode)(node, "test");
+		const consequent = (0, import_ast.childNode)(node, "consequent");
+		const alternate = (0, import_ast.childNode)(node, "alternate");
+		if (!testNode || !consequent || !alternate) return null;
+		const test = (0, import_contracts.spanOf)(id, testNode);
+		if (test.id !== sourceId) return null;
+		const whenTrue = evaluateBranchChild(resolver, id, consequent, depth, state, sourceId);
+		if (!whenTrue) return null;
+		const whenFalse = evaluateBranchChild(resolver, id, alternate, depth, state, sourceId);
+		if (!whenFalse) return null;
+		return {
+			kind: "branch",
+			test,
+			whenTrue,
+			whenFalse
+		};
+	}
+	if (node.type === "TemplateLiteral") {
+		return templateBranchesNode(resolver, id, (0, import_ast.childNodes)(node, "quasis"), (0, import_ast.childNodes)(node, "expressions"), 0, "", depth, state, sourceId);
+	}
+	if (node.type === "LogicalExpression") {
+		const left = (0, import_ast.childNode)(node, "left");
+		const right = (0, import_ast.childNode)(node, "right");
+		if (!left || !right) return null;
+		if (node.operator === "&&") {
+			const test = (0, import_contracts.spanOf)(id, left);
+			if (test.id !== sourceId) return null;
+			const whenTrue = evaluateBranchChild(resolver, id, right, depth, state, sourceId);
+			if (!whenTrue) return null;
+			const whenFalse = {
+				kind: "leaf",
+				value: void 0,
+				dependencies: [...state.dependencies].sort()
+			};
+			return {
+				kind: "branch",
+				test,
+				whenTrue,
+				whenFalse
+			};
+		}
+		if (node.operator === "||" || node.operator === "??") {
+			const test = (0, import_contracts.spanOf)(id, left);
+			if (test.id !== sourceId) return null;
+			const leftState = {
+				activeDefinitions: new Set(state.activeDefinitions),
+				dependencies: new Set(state.dependencies)
+			};
+			const leftRes = evaluateNode(resolver, id, left, leftState);
+			if (!leftRes.ok) return null;
+			const whenTrue = {
+				kind: "leaf",
+				value: leftRes.value,
+				dependencies: [...leftState.dependencies].sort()
+			};
+			const whenFalse = evaluateBranchChild(resolver, id, right, depth, state, sourceId);
+			if (!whenFalse) return null;
+			return {
+				kind: "branch",
+				test,
+				whenTrue,
+				whenFalse
+			};
+		}
+	}
+	return null;
+}
+function mapBranchLeaves(node, map) {
+	if (node.kind === "leaf") return map(node);
+	const whenTrue = mapBranchLeaves(node.whenTrue, map);
+	if (!whenTrue) return null;
+	const whenFalse = mapBranchLeaves(node.whenFalse, map);
+	if (!whenFalse) return null;
+	return {
+		kind: "branch",
+		test: node.test,
+		whenTrue,
+		whenFalse
+	};
+}
+function templateBranchesNode(resolver, id, quasis, expressions, index, prefix, depth, state, sourceId) {
+	let text = prefix;
+	for (let position = index; position < quasis.length; position++) {
+		text += quasiText(quasis[position]);
+		const expression = expressions[position];
+		if (!expression) continue;
+		const exact = evaluateNode(resolver, id, expression, state);
+		if (exact.ok) {
+			const interpolated = templateInterpolation(exact.value);
+			if (interpolated === null) return null;
+			text += interpolated;
+			continue;
+		}
+		const tree = evaluateBranchesNode(resolver, id, expression, depth + 1, state, sourceId);
+		if (!tree) return null;
+		return mapBranchLeaves(tree, (leaf) => {
+			if (leaf.value === void 0) return null;
+			const interpolated = templateInterpolation(leaf.value);
+			if (interpolated === null) return null;
+			return templateBranchesNode(resolver, id, quasis, expressions, position + 1, text + interpolated, depth + 1, state, sourceId);
+		});
+	}
+	return {
+		kind: "leaf",
+		value: text,
+		dependencies: [...state.dependencies].sort()
+	};
+}
+function templateInterpolation(value) {
+	if (value === null) return "null";
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+		return String(value);
+	}
+	return null;
+}
+function evaluateBranches(resolver, reference) {
+	const node = resolver.expressionNode(reference);
+	if (!node) return null;
+	const state = {
+		activeDefinitions: /* @__PURE__ */ new Set(),
+		dependencies: /* @__PURE__ */ new Set()
+	};
+	const tree = evaluateBranchesNode(resolver, reference.id, node, 0, state, reference.id);
+	return tree?.kind === "branch" ? tree : null;
+}
+function evaluateExpression(resolver, reference) {
+	const node = resolver.expressionNode(reference);
+	if (!node) {
+		return {
+			ok: false,
+			bailout: (0, import_diagnostics.linkedBailout)("linked/missing-initializer", reference, "Expression is outside the linked project graph", reference.id)
+		};
+	}
+	const state = {
+		activeDefinitions: /* @__PURE__ */ new Set(),
+		dependencies: /* @__PURE__ */ new Set()
+	};
+	const result = evaluateNode(resolver, reference.id, node, state);
+	return result.ok ? {
+		ok: true,
+		value: result.value,
+		dependencies: [...state.dependencies].sort()
+	} : result;
+}
+function evaluateDynamicExpression(resolver, reference) {
+	const node = resolver.expressionNode(reference);
+	if (!node) return null;
+	const state = {
+		activeDefinitions: /* @__PURE__ */ new Set(),
+		dependencies: /* @__PURE__ */ new Set()
+	};
+	const result = evaluateDynamicNode(resolver, reference.id, node, state);
+	return result ? {
+		...result,
+		dependencies: [...state.dependencies].sort()
+	} : null;
+}
+function evaluateBinding(resolver, id, localName) {
+	const definition = resolver.resolveBinding(id, localName);
+	if (!definition) {
+		const emptySpan = {
+			id,
+			start: 0,
+			end: 0
+		};
+		return {
+			ok: false,
+			bailout: (0, import_diagnostics.linkedBailout)("linked/unresolved-binding", emptySpan, `Binding ${localName} has no host-linked definition`)
+		};
+	}
+	if (!definition.initializer) {
+		return {
+			ok: false,
+			bailout: (0, import_diagnostics.linkedBailout)("linked/missing-initializer", definition.span, `Binding ${localName} has no static initializer`, definition.id)
+		};
+	}
+	return evaluateExpression(resolver, (0, import_contracts.expressionReference)(definition.id, definition.initializer));
+}