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

package/dist/esm/normalize.mjs

@@ -0,0 +1,604 @@
+import { childNode, childNodes, findAstNode, identifierName, isAstNode, walkAst } from "./ast.mjs";
+import { expressionReference, resolvedModuleId, spanOf } from "./contracts.mjs";
+import { linkedBailout, localBailout } from "./diagnostics.mjs";
+import { hostImportProvenance } from "./ir.mjs";
+
+function finalizeElement(base, entries, bailouts) {
+	if (bailouts.length === 0) {
+		return {
+			...base,
+			complete: true,
+			entries,
+			bailouts: []
+		};
+	}
+	return {
+		...base,
+		complete: false,
+		bailedEntries: entries,
+		bailouts
+	};
+}
+function definitionFromDeclaration(id, name, declaration, parentOf) {
+	let identifier = declaration;
+	let initializer = null;
+	let constant = false;
+	if (declaration.type === "VariableDeclarator") {
+		identifier = childNode(declaration, "id") ?? declaration;
+		initializer = childNode(declaration, "init");
+		const parent = parentOf(declaration);
+		constant = parent?.type === "VariableDeclaration" && parent.kind === "const";
+	} else if (declaration.type === "Identifier") {
+		const declarator = parentOf(declaration);
+		if (declarator?.type === "VariableDeclarator" && childNode(declarator, "id")?.start === declaration.start) {
+			initializer = childNode(declarator, "init");
+			const parent = parentOf(declarator);
+			constant = parent?.type === "VariableDeclaration" && parent.kind === "const";
+		}
+	}
+	return {
+		id: resolvedModuleId(id),
+		name,
+		start: identifier.start,
+		end: identifier.end,
+		initializer,
+		constant
+	};
+}
+function importBinding(program, localName) {
+	for (const statement of childNodes(program, "body")) {
+		if (statement.type !== "ImportDeclaration") continue;
+		const source = childNode(statement, "source");
+		const sourceValue = source && typeof source.value === "string" ? source.value : null;
+		if (!sourceValue) continue;
+		for (const specifier of childNodes(statement, "specifiers")) {
+			if (identifierName(childNode(specifier, "local")) !== localName) continue;
+			if (specifier.type === "ImportDefaultSpecifier") {
+				return {
+					source: sourceValue,
+					imported: "default"
+				};
+			}
+			if (specifier.type === "ImportNamespaceSpecifier") {
+				return {
+					source: sourceValue,
+					imported: "*"
+				};
+			}
+			const imported = childNode(specifier, "imported");
+			const importedName = identifierName(imported) ?? (typeof imported?.value === "string" ? imported.value : null);
+			return importedName ? {
+				source: sourceValue,
+				imported: importedName
+			} : null;
+		}
+	}
+	return null;
+}
+function asStaticValue(node) {
+	if (!node) return void 0;
+	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 elementValue(id, node) {
+	const staticValue = asStaticValue(node);
+	return staticValue === void 0 ? expressionReference(id, node) : {
+		kind: "static",
+		value: staticValue,
+		span: spanOf(id, node)
+	};
+}
+function symbolDefinition(definition) {
+	if (!definition) return null;
+	return {
+		id: definition.id,
+		name: definition.name,
+		span: {
+			id: definition.id,
+			start: definition.start,
+			end: definition.end
+		},
+		initializer: definition.initializer ? expressionReference(definition.id, definition.initializer) : null,
+		constant: definition.constant
+	};
+}
+function componentFromNode(candidate, id, program, imports, node, bailouts) {
+	const literal = asStaticValue(node);
+	if (typeof literal === "string") {
+		return {
+			kind: "intrinsic",
+			name: literal,
+			span: spanOf(id, node),
+			closingSpan: null,
+			definition: null,
+			provenance: null
+		};
+	}
+	if ((node.type === "MemberExpression" || node.type === "JSXMemberExpression") && node.computed !== true) {
+		const objectName = identifierName(childNode(node, "object"));
+		const memberName = identifierName(childNode(node, "property"));
+		const binding2 = objectName ? importBinding(program, objectName) : null;
+		if (memberName && binding2?.imported === "html") {
+			const provenance2 = hostImportProvenance(imports, binding2.source, binding2.imported);
+			if (provenance2) {
+				return {
+					kind: "binding",
+					name: memberName,
+					span: spanOf(id, node),
+					closingSpan: null,
+					definition: null,
+					provenance: provenance2
+				};
+			}
+		}
+	}
+	const name = identifierName(node);
+	if (!name) {
+		bailouts.push(localBailout("local/unsupported-element-name", spanOf(id, node), `Element target ${node.type} is not a stable identifier or intrinsic tag`));
+		return null;
+	}
+	const intrinsic = /^[a-z]/.test(name);
+	const binding = intrinsic ? null : importBinding(program, name);
+	const provenance = binding ? hostImportProvenance(imports, binding.source, binding.imported) : null;
+	const definition = intrinsic ? null : symbolDefinition(candidate.definitionOf(id, name));
+	if (!intrinsic && !definition && !provenance) {
+		bailouts.push(linkedBailout("linked/unresolved-component-binding", spanOf(id, node), `Component binding ${name} has no linked definition`));
+	}
+	return {
+		kind: intrinsic ? "intrinsic" : "binding",
+		name,
+		span: spanOf(id, node),
+		closingSpan: null,
+		definition,
+		provenance
+	};
+}
+function jsxComponentNode(opening) {
+	return childNode(opening, "name");
+}
+function jsxEntries(id, element, opening, bailouts) {
+	const entries = [];
+	for (const attribute of childNodes(opening, "attributes")) {
+		if (attribute.type === "JSXSpreadAttribute") {
+			const argument = childNode(attribute, "argument");
+			if (argument) {
+				entries.push({
+					kind: "spread",
+					span: spanOf(id, attribute),
+					value: expressionReference(id, argument)
+				});
+			}
+			continue;
+		}
+		if (attribute.type !== "JSXAttribute") continue;
+		const nameNode = childNode(attribute, "name");
+		const name = identifierName(nameNode);
+		if (!name) {
+			bailouts.push(localBailout("local/unsupported-prop-key", spanOf(id, attribute), "Namespaced JSX attributes are not statically supported"));
+			continue;
+		}
+		const rawValue = childNode(attribute, "value");
+		let value;
+		if (!rawValue) {
+			value = {
+				kind: "static",
+				value: true,
+				span: spanOf(id, attribute)
+			};
+		} else if (rawValue.type === "JSXExpressionContainer") {
+			const expression = childNode(rawValue, "expression");
+			if (!expression || expression.type === "JSXEmptyExpression") {
+				bailouts.push(localBailout("local/unsupported-expression", spanOf(id, rawValue), `JSX prop ${name} has no expression`));
+				continue;
+			}
+			value = elementValue(id, expression);
+		} else {
+			value = elementValue(id, rawValue);
+		}
+		entries.push({
+			kind: "prop",
+			name,
+			span: spanOf(id, attribute),
+			value
+		});
+	}
+	for (const child of childNodes(element, "children")) {
+		let value;
+		if (child.type === "JSXText") {
+			if (typeof child.value !== "string" || child.value.trim() === "") continue;
+			value = {
+				kind: "static",
+				value: child.value,
+				span: spanOf(id, child)
+			};
+		} else if (child.type === "JSXExpressionContainer") {
+			const expression = childNode(child, "expression");
+			value = !expression || expression.type === "JSXEmptyExpression" ? {
+				kind: "empty",
+				span: spanOf(id, child)
+			} : elementValue(id, expression);
+		} else if (child.type === "JSXElement" || child.type === "JSXFragment") {
+			value = {
+				kind: "element",
+				span: spanOf(id, child)
+			};
+		} else {
+			bailouts.push(localBailout("local/unsupported-child", spanOf(id, child), `JSX child ${child.type} cannot be normalized`));
+			continue;
+		}
+		entries.push({
+			kind: "child",
+			span: spanOf(id, child),
+			value
+		});
+	}
+	return entries.sort((left, right) => left.span.start - right.span.start);
+}
+function propertyName(property) {
+	if (property.computed === true) return null;
+	const key = childNode(property, "key");
+	const name = identifierName(key);
+	if (name) return name;
+	const literal = asStaticValue(key);
+	return typeof literal === "string" || typeof literal === "number" ? String(literal) : null;
+}
+function runtimeChildEntries(id, program, node, bailouts) {
+	const rawNodes = node.type === "ArrayExpression" ? node.elements : null;
+	if (Array.isArray(rawNodes) && rawNodes.some((child) => child === null || !isAstNode(child))) {
+		bailouts.push(localBailout("local/unsupported-child", spanOf(id, node), "Sparse compiled children cannot be normalized without changing order"));
+		return [];
+	}
+	const nodes = Array.isArray(rawNodes) ? rawNodes.filter(isAstNode) : [node];
+	return nodes.flatMap((child) => {
+		if (child.type === "SpreadElement") {
+			bailouts.push(localBailout("local/unsupported-child", spanOf(id, child), "Spread children cannot be statically ordered"));
+			return [];
+		}
+		if (child.type === "CallExpression" && runtimeCall(program, child)) {
+			return [{
+				kind: "child",
+				span: spanOf(id, child),
+				value: {
+					kind: "element",
+					span: spanOf(id, child)
+				}
+			}];
+		}
+		return [{
+			kind: "child",
+			span: spanOf(id, child),
+			value: elementValue(id, child)
+		}];
+	});
+}
+function objectEntries(id, program, object, bailouts) {
+	const entries = [];
+	for (const property of childNodes(object, "properties")) {
+		if (property.type === "SpreadElement") {
+			const argument = childNode(property, "argument");
+			if (argument) {
+				const spread = {
+					kind: "spread",
+					span: spanOf(id, property),
+					value: expressionReference(id, argument)
+				};
+				entries.push(spread);
+			}
+			continue;
+		}
+		if (property.type !== "Property" && property.type !== "ObjectProperty") {
+			bailouts.push(localBailout("local/unsupported-prop-key", spanOf(id, property), `Runtime props entry ${property.type} is not a data property`));
+			continue;
+		}
+		const name = propertyName(property);
+		const valueNode = childNode(property, "value");
+		if (!name || !valueNode) {
+			bailouts.push(localBailout("local/unsupported-prop-key", spanOf(id, property), "Computed runtime prop keys are not statically supported"));
+			continue;
+		}
+		if (name === "children") {
+			entries.push(...runtimeChildEntries(id, program, valueNode, bailouts));
+			continue;
+		}
+		const prop = {
+			kind: "prop",
+			name,
+			span: spanOf(id, property),
+			value: elementValue(id, valueNode)
+		};
+		entries.push(prop);
+	}
+	return entries;
+}
+function runtimeCall(program, call) {
+	const callee = childNode(call, "callee");
+	if (!callee) return null;
+	const directName = identifierName(callee);
+	if (directName) {
+		const provenance2 = importBinding(program, directName);
+		if (provenance2?.source === "react/jsx-runtime" && (provenance2.imported === "jsx" || provenance2.imported === "jsxs")) {
+			return { form: "jsx-runtime" };
+		}
+		if (provenance2?.source === "react" && provenance2.imported === "createElement") {
+			return { form: "create-element" };
+		}
+	}
+	if (callee.type !== "MemberExpression" || callee.computed === true) return null;
+	const objectName = identifierName(childNode(callee, "object"));
+	const propertyName2 = identifierName(childNode(callee, "property"));
+	if (propertyName2 !== "createElement" || !objectName) return null;
+	const provenance = importBinding(program, objectName);
+	return provenance?.source === "react" && (provenance.imported === "default" || provenance.imported === "*") ? { form: "create-element" } : null;
+}
+function normalizeRuntimeElement(candidate, id, program, imports, call, runtime, bailouts) {
+	const bailoutStart = bailouts.length;
+	const args = childNodes(call, "arguments");
+	const target = args[0];
+	if (!target) {
+		bailouts.push(localBailout("local/invalid-element-call", spanOf(id, call), `${runtime.form} call has no element target`));
+		return null;
+	}
+	const component = componentFromNode(candidate, id, program, imports, target, bailouts);
+	if (!component) return null;
+	const entries = [];
+	const props = args[1];
+	if (props && asStaticValue(props) !== null) {
+		if (props.type === "ObjectExpression") {
+			entries.push(...objectEntries(id, program, props, bailouts));
+		} else {
+			entries.push({
+				kind: "spread",
+				span: spanOf(id, props),
+				value: expressionReference(id, props)
+			});
+		}
+	}
+	if (runtime.form === "create-element") {
+		for (const child of args.slice(2)) {
+			entries.push(...runtimeChildEntries(id, program, child, bailouts));
+		}
+	}
+	return finalizeElement({
+		kind: "element",
+		form: runtime.form,
+		id,
+		span: spanOf(id, call),
+		propsSpan: props ? spanOf(id, props) : null,
+		component
+	}, entries.sort((left, right) => left.span.start - right.span.start), bailouts.slice(bailoutStart));
+}
+function styledDefinitions(candidate, id, program, imports, bailouts) {
+	const definitions = [];
+	walkAst(program, (node) => {
+		if (node.type !== "VariableDeclarator") return;
+		const identifier = childNode(node, "id");
+		const name = identifierName(identifier);
+		const call = childNode(node, "init");
+		if (!name || !identifier || call?.type !== "CallExpression") return;
+		const callee = childNode(call, "callee");
+		const factoryName = callee && identifierName(callee);
+		if (!factoryName) return;
+		const binding = importBinding(program, factoryName);
+		if (!binding || binding.imported !== "styled") return;
+		const factory = hostImportProvenance(imports, binding.source, binding.imported);
+		if (!factory) return;
+		const definitionBailouts = [];
+		const args = childNodes(call, "arguments");
+		const baseNode = args[0];
+		const objectForm = args[1]?.type === "ObjectExpression";
+		const optionsNode = objectForm ? args[1] : args.length >= 3 ? args[2] : args[1];
+		if (!baseNode || !optionsNode) {
+			definitionBailouts.push(localBailout("local/unsupported-styled-definition", spanOf(id, call), `styled definition ${name} must provide a base and options object`));
+			bailouts.push(...definitionBailouts);
+			return;
+		}
+		const base = componentFromNode(candidate, id, program, imports, baseNode, definitionBailouts);
+		if (!base) {
+			bailouts.push(...definitionBailouts);
+			return;
+		}
+		const baseClassNode = objectForm ? null : args.length >= 3 ? args[1] : null;
+		const staticConfigNode = objectForm && args.length >= 3 ? args[2] : null;
+		const baseDefinition = {
+			kind: "styled-definition",
+			id,
+			name,
+			span: spanOf(id, call),
+			definitionSpan: spanOf(id, identifier),
+			factory,
+			base,
+			baseClassName: baseClassNode ? elementValue(id, baseClassNode) : null,
+			options: expressionReference(id, optionsNode),
+			staticConfig: staticConfigNode ? expressionReference(id, staticConfigNode) : null
+		};
+		definitions.push(definitionBailouts.length === 0 ? {
+			...baseDefinition,
+			complete: true,
+			bailouts: []
+		} : {
+			...baseDefinition,
+			complete: false,
+			bailouts: definitionBailouts
+		});
+		bailouts.push(...definitionBailouts);
+	});
+	return definitions.sort((left, right) => left.span.start - right.span.start);
+}
+const DOM_STYLE_FRONTENDS = /* @__PURE__ */ new Set([
+	"tamagui/dom",
+	"@tamagui/core/dom",
+	"@tamagui/tailwind"
+]);
+const STYLE_FRONTENDS = /* @__PURE__ */ new Set([
+	...DOM_STYLE_FRONTENDS,
+	"tamagui",
+	"@tamagui/core",
+	"@tamagui/web"
+]);
+function domStyleDefinitions(id, program, imports) {
+	const definitions = [];
+	walkAst(program, (node) => {
+		if (node.type !== "VariableDeclarator") return;
+		const identifier = childNode(node, "id");
+		const name = identifierName(identifier);
+		const call = childNode(node, "init");
+		if (!name || !identifier || call?.type !== "CallExpression") return;
+		const callee = childNode(call, "callee");
+		const factoryName = callee && identifierName(callee);
+		if (!factoryName) return;
+		const binding = importBinding(program, factoryName);
+		if (!binding || binding.imported !== "style" || !STYLE_FRONTENDS.has(binding.source)) {
+			return;
+		}
+		const factory = hostImportProvenance(imports, binding.source, binding.imported);
+		const value = childNodes(call, "arguments")[0];
+		if (!factory || !value) return;
+		definitions.push({
+			kind: "dom-style-definition",
+			id,
+			name,
+			span: spanOf(id, call),
+			definitionSpan: spanOf(id, identifier),
+			factory,
+			value: expressionReference(id, value)
+		});
+	});
+	return definitions.sort((left, right) => left.span.start - right.span.start);
+}
+function domStyleArgument(candidate, id, program, node) {
+	let call = node;
+	if (node.type === "Identifier") {
+		const name = identifierName(node);
+		const definition = name ? candidate.definitionOf(id, name) : null;
+		if (!definition?.constant || !definition.initializer) return null;
+		call = definition.initializer;
+	}
+	if (call.type !== "CallExpression") return null;
+	const callee = childNode(call, "callee");
+	const factoryName = callee && identifierName(callee);
+	if (!factoryName) return null;
+	const binding = importBinding(program, factoryName);
+	if (!binding || binding.imported !== "style" || !STYLE_FRONTENDS.has(binding.source)) {
+		return null;
+	}
+	return childNodes(call, "arguments")[0] ?? null;
+}
+function domStyleProgram(candidate, id, program, node) {
+	if (node.type !== "ArrayExpression" || !Array.isArray(node.elements)) {
+		const argument = domStyleArgument(candidate, id, program, node);
+		return argument ? {
+			kind: "dom-style",
+			span: spanOf(id, node),
+			items: [{
+				condition: null,
+				value: expressionReference(id, argument)
+			}]
+		} : null;
+	}
+	const items = [];
+	for (const rawItem of node.elements) {
+		if (!isAstNode(rawItem)) return null;
+		let item = rawItem;
+		let condition = null;
+		if (item.type === "LogicalExpression" && item.operator === "&&") {
+			const left = childNode(item, "left");
+			const right = childNode(item, "right");
+			if (!left || !right) return null;
+			condition = expressionReference(id, left);
+			item = right;
+		}
+		const argument = domStyleArgument(candidate, id, program, item);
+		if (!argument) {
+			const staticValue = asStaticValue(item);
+			if (staticValue === false || staticValue === null) continue;
+			return null;
+		}
+		items.push({
+			condition,
+			value: expressionReference(id, argument)
+		});
+	}
+	return {
+		kind: "dom-style",
+		span: spanOf(id, node),
+		items
+	};
+}
+function normalizeElements(candidate, rawId, imports = []) {
+	const id = resolvedModuleId(rawId);
+	const program = candidate.programOf(id);
+	const elements = [];
+	const bailouts = [];
+	walkAst(program, (node) => {
+		if (node.type === "JSXElement") {
+			const bailoutStart = bailouts.length;
+			const opening = childNode(node, "openingElement");
+			const target = opening && jsxComponentNode(opening);
+			if (!opening || !target) return;
+			const component = componentFromNode(candidate, id, program, imports, target, bailouts);
+			if (!component) return;
+			const closingElement = childNode(node, "closingElement");
+			const closingName = closingElement && childNode(closingElement, "name");
+			if (closingName) component.closingSpan = spanOf(id, closingName);
+			const entries = jsxEntries(id, node, opening, bailouts);
+			for (const entry of entries) {
+				if (entry.kind !== "prop" || entry.name !== "style") continue;
+				const raw = entry.value.kind === "expression" ? nodeAtSpan(program, entry.value.start, entry.value.end) : null;
+				const styleProgram = raw && domStyleProgram(candidate, id, program, raw);
+				const argument = raw && domStyleArgument(candidate, id, program, raw);
+				if (styleProgram) entry.value = styleProgram;
+				else if (argument) entry.value = expressionReference(id, argument);
+			}
+			elements.push(finalizeElement({
+				kind: "element",
+				form: "jsx",
+				id,
+				span: spanOf(id, node),
+				propsSpan: spanOf(id, opening),
+				component
+			}, entries, bailouts.slice(bailoutStart)));
+			return;
+		}
+		if (node.type !== "CallExpression") return;
+		const runtime = runtimeCall(program, node);
+		if (!runtime) return;
+		const element = normalizeRuntimeElement(candidate, id, program, imports, node, runtime, bailouts);
+		if (element) {
+			const entries = element.complete ? element.entries : element.bailedEntries;
+			for (const entry of entries) {
+				if (entry.kind !== "prop" || entry.name !== "style") continue;
+				const raw = entry.value.kind === "expression" ? nodeAtSpan(program, entry.value.start, entry.value.end) : null;
+				const styleProgram = raw && domStyleProgram(candidate, id, program, raw);
+				const argument = raw && domStyleArgument(candidate, id, program, raw);
+				if (styleProgram) entry.value = styleProgram;
+				else if (argument) entry.value = expressionReference(id, argument);
+			}
+			elements.push(element);
+		}
+	});
+	return {
+		elements: elements.sort((left, right) => left.span.start - right.span.start),
+		styledDefinitions: styledDefinitions(candidate, id, program, imports, bailouts),
+		domStyleDefinitions: domStyleDefinitions(id, program, imports),
+		bailouts: bailouts.sort((left, right) => left.span.start - right.span.start)
+	};
+}
+function nodeAtSpan(program, start, end) {
+	return findAstNode(program, (node) => node.start === start && node.end === end, {
+		start,
+		end
+	});
+}
+function asAstNode(value, label) {
+	if (!isAstNode(value)) throw new Error(`${label} is not an AST node`);
+	return value;
+}
+
+export { asAstNode, definitionFromDeclaration, nodeAtSpan, normalizeElements };
+//# sourceMappingURL=normalize.mjs.map