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

package/dist/cjs/materialize.cjs

@@ -0,0 +1,222 @@
+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 materialize_exports = {};
+__export(materialize_exports, { materializeModule: () => materializeModule });
+module.exports = __toCommonJS(materialize_exports);
+var import_evaluate = require("./evaluate.cjs");
+function compareCodeUnits(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function materializeValue(graph, value) {
+	if (value.kind === "static") {
+		return {
+			kind: "static",
+			value: value.value,
+			dependencies: [],
+			span: value.span,
+			literalOrigin: true
+		};
+	}
+	if (value.kind === "dom-style") {
+		return {
+			kind: "dom-style",
+			span: value.span,
+			items: value.items.map((item) => ({
+				condition: item.condition,
+				value: materializeValue(graph, item.value)
+			}))
+		};
+	}
+	const result = graph.evaluate(value);
+	if (result.ok) {
+		return {
+			kind: "static",
+			value: result.value,
+			dependencies: result.dependencies,
+			span: value
+		};
+	}
+	const tree = graph.evaluateBranches(value);
+	if (tree) {
+		return {
+			kind: "conditional",
+			tree,
+			dependencies: (0, import_evaluate.collectBranchDependencies)(tree).sort(compareCodeUnits),
+			bailout: result.bailout,
+			span: value
+		};
+	}
+	return {
+		kind: "bailout",
+		bailout: result.bailout,
+		span: value,
+		dynamic: graph.evaluateDynamic(value)
+	};
+}
+function materializeStyleObject(graph, reference, bailout) {
+	const members = graph.objectMembers(reference);
+	if (!members) return null;
+	return {
+		kind: "object",
+		span: reference,
+		members: members.map((member) => ({
+			name: member.name,
+			span: member.span,
+			value: materializeValue(graph, member.value)
+		})),
+		bailout
+	};
+}
+function materializeEntry(graph, entry) {
+	if (entry.kind === "prop") {
+		const value = materializeValue(graph, entry.value);
+		return {
+			kind: entry.kind,
+			name: entry.name,
+			span: entry.span,
+			value: entry.name === "style" && value.kind === "bailout" && entry.value.kind === "expression" ? materializeStyleObject(graph, entry.value, value.bailout) ?? value : value
+		};
+	}
+	if (entry.kind === "spread") {
+		return {
+			kind: entry.kind,
+			span: entry.span,
+			value: materializeValue(graph, entry.value)
+		};
+	}
+	if (entry.value.kind === "element" || entry.value.kind === "empty") {
+		return {
+			kind: entry.kind,
+			span: entry.span,
+			value: entry.value
+		};
+	}
+	return {
+		kind: entry.kind,
+		span: entry.span,
+		value: materializeValue(graph, entry.value)
+	};
+}
+function materializeElement(graph, element) {
+	const entries = element.complete ? element.entries : element.bailedEntries;
+	return {
+		kind: element.kind,
+		form: element.form,
+		id: element.id,
+		span: element.span,
+		propsSpan: element.propsSpan,
+		component: element.component,
+		complete: element.complete,
+		entries: entries.map((entry) => materializeEntry(graph, entry)),
+		bailouts: [...element.bailouts]
+	};
+}
+function materializeStyledDefinition(graph, definition) {
+	return {
+		kind: definition.kind,
+		id: definition.id,
+		name: definition.name,
+		span: definition.span,
+		definitionSpan: definition.definitionSpan,
+		factory: definition.factory,
+		base: definition.base,
+		baseClassName: definition.baseClassName ? materializeValue(graph, definition.baseClassName) : null,
+		options: materializeValue(graph, definition.options),
+		staticConfig: definition.staticConfig ? materializeValue(graph, definition.staticConfig) : null,
+		complete: definition.complete,
+		bailouts: [...definition.bailouts]
+	};
+}
+function collectDependencies(module2) {
+	const dependencies = /* @__PURE__ */ new Set();
+	const collect = (value) => {
+		if (value.kind === "static" || value.kind === "conditional") {
+			for (const dependency of value.dependencies) dependencies.add(dependency);
+		} else if (value.kind === "dom-style") {
+			for (const item of value.items) collect(item.value);
+		} else if (value.kind === "object") {
+			for (const member of value.members) collect(member.value);
+			if (value.bailout.dependencyId) dependencies.add(value.bailout.dependencyId);
+		} else {
+			for (const dependency of value.dynamic?.dependencies ?? []) {
+				dependencies.add(dependency);
+			}
+			if (value.bailout.dependencyId) dependencies.add(value.bailout.dependencyId);
+		}
+	};
+	for (const element of module2.elements) {
+		if (element.component.provenance) {
+			dependencies.add(element.component.provenance.resolvedId);
+		}
+		if (element.component.definition) dependencies.add(element.component.definition.id);
+		for (const entry of element.entries) {
+			if ("value" in entry && entry.value.kind !== "element" && entry.value.kind !== "empty") {
+				collect(entry.value);
+			}
+		}
+	}
+	for (const definition of module2.styledDefinitions) {
+		dependencies.add(definition.factory.resolvedId);
+		if (definition.base.provenance) dependencies.add(definition.base.provenance.resolvedId);
+		if (definition.base.definition) dependencies.add(definition.base.definition.id);
+		if (definition.baseClassName) collect(definition.baseClassName);
+		collect(definition.options);
+		if (definition.staticConfig) collect(definition.staticConfig);
+	}
+	for (const definition of module2.domStyleDefinitions) {
+		dependencies.add(definition.factory.resolvedId);
+		collect(definition.value);
+	}
+	return [...dependencies].sort(compareCodeUnits);
+}
+function materializeModule(graph, id) {
+	const inputHash = graph.contentHash(id);
+	if (!inputHash) throw new Error(`Cannot materialize unknown host module ${id}`);
+	const result = graph.elementsOf(id);
+	const definitions = [...result.styledDefinitions];
+	const definitionKeys = new Set(definitions.map((definition) => `${definition.id}\0${definition.name}`));
+	for (const element of result.elements) {
+		const linked = element.component.definition;
+		if (!linked || linked.id === id) continue;
+		const definition = graph.elementsOf(linked.id).styledDefinitions.find((candidate) => candidate.id === linked.id && candidate.name === linked.name);
+		const key = definition && `${definition.id}\0${definition.name}`;
+		if (definition && key && !definitionKeys.has(key)) {
+			definitionKeys.add(key);
+			definitions.push(definition);
+		}
+	}
+	const base = {
+		version: 1,
+		id,
+		inputHash,
+		elements: result.elements.map((element) => materializeElement(graph, element)),
+		styledDefinitions: definitions.map((definition) => materializeStyledDefinition(graph, definition)),
+		domStyleDefinitions: result.domStyleDefinitions.map((definition) => ({
+			...definition,
+			value: materializeValue(graph, definition.value)
+		})),
+		diagnostics: graph.diagnostics().filter(({ span }) => span.id === id)
+	};
+	return {
+		...base,
+		dependencies: collectDependencies(base)
+	};
+}