@tamagui/codemod-flat-values 0.0.0-bootstrap.0 → 3.0.0-beta.643.1

package/dist/structuredNative.mjs

@@ -0,0 +1,275 @@
+import { Node, SyntaxKind } from "ts-morph";
+import { numericValue, unwrapExpression } from "./expressions.mjs";
+import { parseTransformString, sharedPayload } from "./grammar.mjs";
+
+const staticTransformOperations = /* @__PURE__ */ new Set([
+	"perspective",
+	"rotate",
+	"rotateX",
+	"rotateY",
+	"rotateZ",
+	"scale",
+	"scaleX",
+	"scaleY",
+	"skewX",
+	"skewY",
+	"translateX",
+	"translateY"
+]);
+function blocked(code, detail) {
+	return {
+		payload: null,
+		blocked: {
+			code,
+			detail
+		}
+	};
+}
+function staticString(expression) {
+	const current = unwrapExpression(expression);
+	return Node.isStringLiteral(current) || Node.isNoSubstitutionTemplateLiteral(current) ? current.getLiteralValue() : null;
+}
+function hasOnlyStringValues(expression) {
+	const current = unwrapExpression(expression);
+	if (Node.isStringLiteral(current) || Node.isNoSubstitutionTemplateLiteral(current) || Node.isTemplateExpression(current)) {
+		return true;
+	}
+	const type = current.getType();
+	const parts = type.isUnion() ? type.getUnionTypes() : [type];
+	let strings = 0;
+	for (const part of parts) {
+		if (part.isNull() || part.isUndefined()) continue;
+		if (!part.isString() && !part.isStringLiteral()) return false;
+		strings++;
+	}
+	return strings > 0;
+}
+function staticTransformArray(expression, source) {
+	const array = unwrapExpression(expression);
+	if (!Node.isArrayLiteralExpression(array)) {
+		return blocked("structured-transform-dynamic", `transform value "${source}" is not an inline transform array; keep dynamic and Animated arrays authored`);
+	}
+	const functions = [];
+	for (const element of array.getElements()) {
+		if (!Node.isObjectLiteralExpression(element)) {
+			return blocked("structured-transform-dynamic", `transform value "${source}" contains a spread or computed entry; keep dynamic and Animated arrays authored`);
+		}
+		const properties = element.getProperties();
+		if (properties.length !== 1 || !Node.isPropertyAssignment(properties[0])) {
+			return blocked("structured-transform-entry", `transform value "${source}" must have exactly one static operation per array entry`);
+		}
+		const property = properties[0];
+		const nameNode = property.getNameNode();
+		if (!Node.isIdentifier(nameNode) && !Node.isStringLiteral(nameNode)) {
+			return blocked("structured-transform-entry", `transform value "${source}" contains a computed operation name`);
+		}
+		const operation = Node.isStringLiteral(nameNode) ? nameNode.getLiteralValue() : nameNode.getText();
+		const initializer = unwrapExpression(property.getInitializerOrThrow());
+		if (operation === "matrix" || operation === "matrix3d") {
+			return blocked("structured-transform-matrix", `transform value "${source}" contains "${operation}", whose React Native array and portable CSS function shapes do not match; keep it authored`);
+		}
+		if (!staticTransformOperations.has(operation)) {
+			return blocked("structured-transform-operation", `transform value "${source}" uses unsupported operation "${operation}"`);
+		}
+		const number = numericValue(initializer);
+		let value;
+		if (number !== null) {
+			if (operation === "rotate" || operation === "rotateX" || operation === "rotateY" || operation === "rotateZ" || operation === "skewX" || operation === "skewY") {
+				return blocked("structured-transform-unit", `transform operation "${operation}" in "${source}" needs an explicit deg or rad string`);
+			}
+			value = operation === "scale" || operation === "scaleX" || operation === "scaleY" ? String(number) : `${number}px`;
+		} else if (Node.isStringLiteral(initializer) || Node.isNoSubstitutionTemplateLiteral(initializer)) {
+			value = initializer.getLiteralValue();
+		} else {
+			return blocked("structured-transform-dynamic", `transform operation "${operation}" in "${source}" is computed; keep dynamic and Animated arrays authored`);
+		}
+		functions.push(`${operation}(${value})`);
+	}
+	if (functions.length === 0) {
+		return blocked("structured-transform-empty", `transform value "${source}" is empty; no portable flat base can preserve its reset semantics`);
+	}
+	const payload = functions.join(" ");
+	const parsed = parseTransformString(payload);
+	if (parsed.errors.length) {
+		return blocked(`structured-transform-${parsed.errors[0].code}`, `${parsed.errors[0].message}; keep "${source}" authored`);
+	}
+	return {
+		payload,
+		blocked: null
+	};
+}
+function staticFontVariantArray(expression, source) {
+	const array = unwrapExpression(expression);
+	if (!Node.isArrayLiteralExpression(array)) {
+		return blocked("structured-font-variant-dynamic", `fontVariant value "${source}" is not an inline string array`);
+	}
+	const variants = [];
+	for (const element of array.getElements()) {
+		const variant = staticString(element);
+		if (variant === null) {
+			return blocked("structured-font-variant-dynamic", `fontVariant value "${source}" contains a computed entry; keep it authored`);
+		}
+		variants.push(variant);
+	}
+	return variants.length ? {
+		payload: variants.join(" "),
+		blocked: null
+	} : blocked("structured-font-variant-empty", `fontVariant value "${source}" is empty; no CSS token list preserves that reset`);
+}
+function staticBackgroundImageArray(expression, source) {
+	const array = unwrapExpression(expression);
+	if (!Node.isArrayLiteralExpression(array)) {
+		return blocked("structured-background-image-dynamic", `backgroundImage value "${source}" is not an inline gradient array`);
+	}
+	if (array.getElements().length !== 1) {
+		return blocked("structured-background-image-layers", `backgroundImage value "${source}" must contain exactly one gradient; native conditional evaluation does not accept multiple layers`);
+	}
+	const gradient = array.getElements()[0];
+	if (!Node.isObjectLiteralExpression(gradient)) {
+		return blocked("structured-background-image-dynamic", `backgroundImage value "${source}" contains a spread or computed gradient`);
+	}
+	const fields = /* @__PURE__ */ new Map();
+	for (const member of gradient.getProperties()) {
+		if (!Node.isPropertyAssignment(member)) {
+			return blocked("structured-background-image-dynamic", `backgroundImage value "${source}" contains a spread or computed gradient field`);
+		}
+		const nameNode = member.getNameNode();
+		if (!Node.isIdentifier(nameNode) && !Node.isStringLiteral(nameNode)) {
+			return blocked("structured-background-image-dynamic", `backgroundImage value "${source}" contains a computed gradient field`);
+		}
+		const name = Node.isStringLiteral(nameNode) ? nameNode.getLiteralValue() : nameNode.getText();
+		if (fields.has(name) || name !== "type" && name !== "direction" && name !== "colorStops") {
+			return blocked("structured-background-image-shape", `backgroundImage value "${source}" contains unsupported field "${name}"`);
+		}
+		fields.set(name, member.getInitializerOrThrow());
+	}
+	const type = fields.get("type");
+	const typeName = type ? staticString(type) : null;
+	if (typeName !== "linear-gradient") {
+		return blocked("structured-background-image-kind", `backgroundImage value "${source}" is not a static linear-gradient object`);
+	}
+	const parts = [];
+	const direction = fields.get("direction");
+	if (direction) {
+		const value = staticString(direction);
+		if (value === null) {
+			return blocked("structured-background-image-dynamic", `backgroundImage value "${source}" has a computed direction`);
+		}
+		parts.push(value);
+	}
+	const colorStopsExpression = fields.get("colorStops");
+	const colorStops = colorStopsExpression ? unwrapExpression(colorStopsExpression) : void 0;
+	if (!colorStops || !Node.isArrayLiteralExpression(colorStops)) {
+		return blocked("structured-background-image-dynamic", `backgroundImage value "${source}" does not have an inline colorStops array`);
+	}
+	if (colorStops.getElements().length < 2) {
+		return blocked("structured-background-image-stops", `backgroundImage value "${source}" needs at least two color stops`);
+	}
+	const stopElements = colorStops.getElements();
+	for (const [stopIndex, stop] of stopElements.entries()) {
+		if (!Node.isObjectLiteralExpression(stop)) {
+			return blocked("structured-background-image-dynamic", `backgroundImage value "${source}" contains a spread or computed color stop`);
+		}
+		let color;
+		let hasColor = false;
+		let positions = [];
+		let hasPositions = false;
+		for (const member of stop.getProperties()) {
+			if (!Node.isPropertyAssignment(member)) {
+				return blocked("structured-background-image-dynamic", `backgroundImage value "${source}" contains a spread or computed color-stop field`);
+			}
+			const nameNode = member.getNameNode();
+			if (!Node.isIdentifier(nameNode) && !Node.isStringLiteral(nameNode)) {
+				return blocked("structured-background-image-dynamic", `backgroundImage value "${source}" contains a computed color-stop field`);
+			}
+			const name = Node.isStringLiteral(nameNode) ? nameNode.getLiteralValue() : nameNode.getText();
+			if (name === "color" && !hasColor) {
+				hasColor = true;
+				const value = unwrapExpression(member.getInitializerOrThrow());
+				if (value.getKind() === SyntaxKind.NullKeyword) {
+					color = null;
+					continue;
+				}
+				const staticColor = staticString(value);
+				if (staticColor === null) {
+					return blocked("structured-background-image-dynamic", `backgroundImage value "${source}" contains a computed color`);
+				}
+				color = staticColor;
+				continue;
+			}
+			if (name === "positions" && !hasPositions) {
+				hasPositions = true;
+				const value = unwrapExpression(member.getInitializerOrThrow());
+				if (!Node.isArrayLiteralExpression(value)) {
+					return blocked("structured-background-image-dynamic", `backgroundImage value "${source}" contains computed color-stop positions`);
+				}
+				positions = [];
+				for (const positionExpression of value.getElements()) {
+					const number = numericValue(positionExpression);
+					if (number !== null) {
+						positions.push(`${number}px`);
+						continue;
+					}
+					const position = staticString(positionExpression);
+					if (position === null) {
+						return blocked("structured-background-image-dynamic", `backgroundImage value "${source}" contains a computed color-stop position`);
+					}
+					if (!position.endsWith("%")) {
+						return blocked("structured-background-image-position", `backgroundImage value "${source}" has position "${position}"; React Native gradient objects accept numeric points or percentage strings`);
+					}
+					positions.push(position);
+				}
+				continue;
+			}
+			return blocked("structured-background-image-shape", `backgroundImage value "${source}" contains unsupported or repeated color-stop field "${name}"`);
+		}
+		if (!hasColor || color === void 0) {
+			return blocked("structured-background-image-shape", `backgroundImage value "${source}" contains a color stop without a color`);
+		}
+		if (color === null) {
+			if (positions.length !== 1 || stopIndex === 0 || stopIndex === stopElements.length - 1) {
+				return blocked("structured-background-image-hint", `backgroundImage value "${source}" has an invalid transition hint; it needs one position between two colored stops`);
+			}
+			parts.push(positions[0]);
+		} else if (positions.length > 2) {
+			for (const position of positions) parts.push(`${color} ${position}`);
+		} else {
+			parts.push([color, ...positions].join(" "));
+		}
+	}
+	return {
+		payload: `linear-gradient(${parts.join(", ")})`,
+		blocked: null
+	};
+}
+const structuredNativeSerializers = Object.freeze({
+	backgroundImage: staticBackgroundImageArray,
+	fontVariant: staticFontVariantArray,
+	transform: staticTransformArray
+});
+function classifyStructuredNativeValue(property, expression, source, registry) {
+	const serializer = structuredNativeSerializers[property];
+	if (serializer) {
+		if (hasOnlyStringValues(expression)) return null;
+		const result = serializer(expression, source);
+		if (result.payload === null) return result;
+		const flattened = sharedPayload(property, result.payload, registry);
+		const error = flattened.errors[0];
+		if (error || flattened.payload === null) {
+			return blocked(error?.code ?? "unsupported-structured-value", `${property}: ${error?.message ?? `"${result.payload}" has no flat spelling`}`);
+		}
+		return {
+			payload: flattened.payload,
+			blocked: null
+		};
+	}
+	const current = unwrapExpression(expression);
+	if (!Node.isObjectLiteralExpression(current) && !Node.isArrayLiteralExpression(current)) {
+		return null;
+	}
+	const code = property.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+	return blocked(`structured-${code}`, `${property} value "${source}" has no verified CSS-shaped migration rule; keep it authored`);
+}
+
+export { classifyStructuredNativeValue };
+//# sourceMappingURL=structuredNative.mjs.map

package/dist/structuredNative.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"structuredNative.js","names":[],"sources":["structuredNative.js"],"sourcesContent":["import { Node, SyntaxKind } from \"ts-morph\";\nimport { numericValue, unwrapExpression } from \"./expressions\";\nimport { parseTransformString, sharedPayload } from \"./grammar\";\nconst staticTransformOperations = /* @__PURE__ */ new Set([\n  \"perspective\",\n  \"rotate\",\n  \"rotateX\",\n  \"rotateY\",\n  \"rotateZ\",\n  \"scale\",\n  \"scaleX\",\n  \"scaleY\",\n  \"skewX\",\n  \"skewY\",\n  \"translateX\",\n  \"translateY\"\n]);\nfunction blocked(code, detail) {\n  return { payload: null, blocked: { code, detail } };\n}\nfunction staticString(expression) {\n  const current = unwrapExpression(expression);\n  return Node.isStringLiteral(current) || Node.isNoSubstitutionTemplateLiteral(current) ? current.getLiteralValue() : null;\n}\nfunction hasOnlyStringValues(expression) {\n  const current = unwrapExpression(expression);\n  if (Node.isStringLiteral(current) || Node.isNoSubstitutionTemplateLiteral(current) || Node.isTemplateExpression(current)) {\n    return true;\n  }\n  const type = current.getType();\n  const parts = type.isUnion() ? type.getUnionTypes() : [type];\n  let strings = 0;\n  for (const part of parts) {\n    if (part.isNull() || part.isUndefined()) continue;\n    if (!part.isString() && !part.isStringLiteral()) return false;\n    strings++;\n  }\n  return strings > 0;\n}\nfunction staticTransformArray(expression, source) {\n  const array = unwrapExpression(expression);\n  if (!Node.isArrayLiteralExpression(array)) {\n    return blocked(\n      \"structured-transform-dynamic\",\n      `transform value \"${source}\" is not an inline transform array; keep dynamic and Animated arrays authored`\n    );\n  }\n  const functions = [];\n  for (const element of array.getElements()) {\n    if (!Node.isObjectLiteralExpression(element)) {\n      return blocked(\n        \"structured-transform-dynamic\",\n        `transform value \"${source}\" contains a spread or computed entry; keep dynamic and Animated arrays authored`\n      );\n    }\n    const properties = element.getProperties();\n    if (properties.length !== 1 || !Node.isPropertyAssignment(properties[0])) {\n      return blocked(\n        \"structured-transform-entry\",\n        `transform value \"${source}\" must have exactly one static operation per array entry`\n      );\n    }\n    const property = properties[0];\n    const nameNode = property.getNameNode();\n    if (!Node.isIdentifier(nameNode) && !Node.isStringLiteral(nameNode)) {\n      return blocked(\n        \"structured-transform-entry\",\n        `transform value \"${source}\" contains a computed operation name`\n      );\n    }\n    const operation = Node.isStringLiteral(nameNode) ? nameNode.getLiteralValue() : nameNode.getText();\n    const initializer = unwrapExpression(property.getInitializerOrThrow());\n    if (operation === \"matrix\" || operation === \"matrix3d\") {\n      return blocked(\n        \"structured-transform-matrix\",\n        `transform value \"${source}\" contains \"${operation}\", whose React Native array and portable CSS function shapes do not match; keep it authored`\n      );\n    }\n    if (!staticTransformOperations.has(operation)) {\n      return blocked(\n        \"structured-transform-operation\",\n        `transform value \"${source}\" uses unsupported operation \"${operation}\"`\n      );\n    }\n    const number = numericValue(initializer);\n    let value;\n    if (number !== null) {\n      if (operation === \"rotate\" || operation === \"rotateX\" || operation === \"rotateY\" || operation === \"rotateZ\" || operation === \"skewX\" || operation === \"skewY\") {\n        return blocked(\n          \"structured-transform-unit\",\n          `transform operation \"${operation}\" in \"${source}\" needs an explicit deg or rad string`\n        );\n      }\n      value = operation === \"scale\" || operation === \"scaleX\" || operation === \"scaleY\" ? String(number) : `${number}px`;\n    } else if (Node.isStringLiteral(initializer) || Node.isNoSubstitutionTemplateLiteral(initializer)) {\n      value = initializer.getLiteralValue();\n    } else {\n      return blocked(\n        \"structured-transform-dynamic\",\n        `transform operation \"${operation}\" in \"${source}\" is computed; keep dynamic and Animated arrays authored`\n      );\n    }\n    functions.push(`${operation}(${value})`);\n  }\n  if (functions.length === 0) {\n    return blocked(\n      \"structured-transform-empty\",\n      `transform value \"${source}\" is empty; no portable flat base can preserve its reset semantics`\n    );\n  }\n  const payload = functions.join(\" \");\n  const parsed = parseTransformString(payload);\n  if (parsed.errors.length) {\n    return blocked(\n      `structured-transform-${parsed.errors[0].code}`,\n      `${parsed.errors[0].message}; keep \"${source}\" authored`\n    );\n  }\n  return { payload, blocked: null };\n}\nfunction staticFontVariantArray(expression, source) {\n  const array = unwrapExpression(expression);\n  if (!Node.isArrayLiteralExpression(array)) {\n    return blocked(\n      \"structured-font-variant-dynamic\",\n      `fontVariant value \"${source}\" is not an inline string array`\n    );\n  }\n  const variants = [];\n  for (const element of array.getElements()) {\n    const variant = staticString(element);\n    if (variant === null) {\n      return blocked(\n        \"structured-font-variant-dynamic\",\n        `fontVariant value \"${source}\" contains a computed entry; keep it authored`\n      );\n    }\n    variants.push(variant);\n  }\n  return variants.length ? { payload: variants.join(\" \"), blocked: null } : blocked(\n    \"structured-font-variant-empty\",\n    `fontVariant value \"${source}\" is empty; no CSS token list preserves that reset`\n  );\n}\nfunction staticBackgroundImageArray(expression, source) {\n  const array = unwrapExpression(expression);\n  if (!Node.isArrayLiteralExpression(array)) {\n    return blocked(\n      \"structured-background-image-dynamic\",\n      `backgroundImage value \"${source}\" is not an inline gradient array`\n    );\n  }\n  if (array.getElements().length !== 1) {\n    return blocked(\n      \"structured-background-image-layers\",\n      `backgroundImage value \"${source}\" must contain exactly one gradient; native conditional evaluation does not accept multiple layers`\n    );\n  }\n  const gradient = array.getElements()[0];\n  if (!Node.isObjectLiteralExpression(gradient)) {\n    return blocked(\n      \"structured-background-image-dynamic\",\n      `backgroundImage value \"${source}\" contains a spread or computed gradient`\n    );\n  }\n  const fields = /* @__PURE__ */ new Map();\n  for (const member of gradient.getProperties()) {\n    if (!Node.isPropertyAssignment(member)) {\n      return blocked(\n        \"structured-background-image-dynamic\",\n        `backgroundImage value \"${source}\" contains a spread or computed gradient field`\n      );\n    }\n    const nameNode = member.getNameNode();\n    if (!Node.isIdentifier(nameNode) && !Node.isStringLiteral(nameNode)) {\n      return blocked(\n        \"structured-background-image-dynamic\",\n        `backgroundImage value \"${source}\" contains a computed gradient field`\n      );\n    }\n    const name = Node.isStringLiteral(nameNode) ? nameNode.getLiteralValue() : nameNode.getText();\n    if (fields.has(name) || name !== \"type\" && name !== \"direction\" && name !== \"colorStops\") {\n      return blocked(\n        \"structured-background-image-shape\",\n        `backgroundImage value \"${source}\" contains unsupported field \"${name}\"`\n      );\n    }\n    fields.set(name, member.getInitializerOrThrow());\n  }\n  const type = fields.get(\"type\");\n  const typeName = type ? staticString(type) : null;\n  if (typeName !== \"linear-gradient\") {\n    return blocked(\n      \"structured-background-image-kind\",\n      `backgroundImage value \"${source}\" is not a static linear-gradient object`\n    );\n  }\n  const parts = [];\n  const direction = fields.get(\"direction\");\n  if (direction) {\n    const value = staticString(direction);\n    if (value === null) {\n      return blocked(\n        \"structured-background-image-dynamic\",\n        `backgroundImage value \"${source}\" has a computed direction`\n      );\n    }\n    parts.push(value);\n  }\n  const colorStopsExpression = fields.get(\"colorStops\");\n  const colorStops = colorStopsExpression ? unwrapExpression(colorStopsExpression) : void 0;\n  if (!colorStops || !Node.isArrayLiteralExpression(colorStops)) {\n    return blocked(\n      \"structured-background-image-dynamic\",\n      `backgroundImage value \"${source}\" does not have an inline colorStops array`\n    );\n  }\n  if (colorStops.getElements().length < 2) {\n    return blocked(\n      \"structured-background-image-stops\",\n      `backgroundImage value \"${source}\" needs at least two color stops`\n    );\n  }\n  const stopElements = colorStops.getElements();\n  for (const [stopIndex, stop] of stopElements.entries()) {\n    if (!Node.isObjectLiteralExpression(stop)) {\n      return blocked(\n        \"structured-background-image-dynamic\",\n        `backgroundImage value \"${source}\" contains a spread or computed color stop`\n      );\n    }\n    let color;\n    let hasColor = false;\n    let positions = [];\n    let hasPositions = false;\n    for (const member of stop.getProperties()) {\n      if (!Node.isPropertyAssignment(member)) {\n        return blocked(\n          \"structured-background-image-dynamic\",\n          `backgroundImage value \"${source}\" contains a spread or computed color-stop field`\n        );\n      }\n      const nameNode = member.getNameNode();\n      if (!Node.isIdentifier(nameNode) && !Node.isStringLiteral(nameNode)) {\n        return blocked(\n          \"structured-background-image-dynamic\",\n          `backgroundImage value \"${source}\" contains a computed color-stop field`\n        );\n      }\n      const name = Node.isStringLiteral(nameNode) ? nameNode.getLiteralValue() : nameNode.getText();\n      if (name === \"color\" && !hasColor) {\n        hasColor = true;\n        const value = unwrapExpression(member.getInitializerOrThrow());\n        if (value.getKind() === SyntaxKind.NullKeyword) {\n          color = null;\n          continue;\n        }\n        const staticColor = staticString(value);\n        if (staticColor === null) {\n          return blocked(\n            \"structured-background-image-dynamic\",\n            `backgroundImage value \"${source}\" contains a computed color`\n          );\n        }\n        color = staticColor;\n        continue;\n      }\n      if (name === \"positions\" && !hasPositions) {\n        hasPositions = true;\n        const value = unwrapExpression(member.getInitializerOrThrow());\n        if (!Node.isArrayLiteralExpression(value)) {\n          return blocked(\n            \"structured-background-image-dynamic\",\n            `backgroundImage value \"${source}\" contains computed color-stop positions`\n          );\n        }\n        positions = [];\n        for (const positionExpression of value.getElements()) {\n          const number = numericValue(positionExpression);\n          if (number !== null) {\n            positions.push(`${number}px`);\n            continue;\n          }\n          const position = staticString(positionExpression);\n          if (position === null) {\n            return blocked(\n              \"structured-background-image-dynamic\",\n              `backgroundImage value \"${source}\" contains a computed color-stop position`\n            );\n          }\n          if (!position.endsWith(\"%\")) {\n            return blocked(\n              \"structured-background-image-position\",\n              `backgroundImage value \"${source}\" has position \"${position}\"; React Native gradient objects accept numeric points or percentage strings`\n            );\n          }\n          positions.push(position);\n        }\n        continue;\n      }\n      return blocked(\n        \"structured-background-image-shape\",\n        `backgroundImage value \"${source}\" contains unsupported or repeated color-stop field \"${name}\"`\n      );\n    }\n    if (!hasColor || color === void 0) {\n      return blocked(\n        \"structured-background-image-shape\",\n        `backgroundImage value \"${source}\" contains a color stop without a color`\n      );\n    }\n    if (color === null) {\n      if (positions.length !== 1 || stopIndex === 0 || stopIndex === stopElements.length - 1) {\n        return blocked(\n          \"structured-background-image-hint\",\n          `backgroundImage value \"${source}\" has an invalid transition hint; it needs one position between two colored stops`\n        );\n      }\n      parts.push(positions[0]);\n    } else if (positions.length > 2) {\n      for (const position of positions) parts.push(`${color} ${position}`);\n    } else {\n      parts.push([color, ...positions].join(\" \"));\n    }\n  }\n  return { payload: `linear-gradient(${parts.join(\", \")})`, blocked: null };\n}\nconst structuredNativeSerializers = Object.freeze({\n  backgroundImage: staticBackgroundImageArray,\n  fontVariant: staticFontVariantArray,\n  transform: staticTransformArray\n});\nfunction classifyStructuredNativeValue(property, expression, source, registry) {\n  const serializer = structuredNativeSerializers[property];\n  if (serializer) {\n    if (hasOnlyStringValues(expression)) return null;\n    const result = serializer(expression, source);\n    if (result.payload === null) return result;\n    const flattened = sharedPayload(property, result.payload, registry);\n    const error = flattened.errors[0];\n    if (error || flattened.payload === null) {\n      return blocked(\n        error?.code ?? \"unsupported-structured-value\",\n        `${property}: ${error?.message ?? `\"${result.payload}\" has no flat spelling`}`\n      );\n    }\n    return { payload: flattened.payload, blocked: null };\n  }\n  const current = unwrapExpression(expression);\n  if (!Node.isObjectLiteralExpression(current) && !Node.isArrayLiteralExpression(current)) {\n    return null;\n  }\n  const code = property.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);\n  return blocked(\n    `structured-${code}`,\n    `${property} value \"${source}\" has no verified CSS-shaped migration rule; keep it authored`\n  );\n}\nexport {\n  classifyStructuredNativeValue\n};\n//# sourceMappingURL=structuredNative.js.map\n"],"mappings":"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"}

package/package.json

@@ -1,16 +1,44 @@
 {
   "name": "@tamagui/codemod-flat-values",
-  "version": "0.0.0-bootstrap.0",
-  "description": "Tamagui v3 package bootstrap",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/tamagui/tamagui.git"
-  },
+  "version": "3.0.0-beta.643.1",
   "license": "MIT",
+  "type": "module",
+  "bin": {
+    "tamagui-codemod-flat-values": "dist/index.mjs"
+  },
+  "source": "src/index.ts",
   "files": [
-    "README.md"
+    "src",
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "build": "tamagui-build --skip-native --skip-types",
+    "watch": "bun run build --watch",
+    "clean": "tamagui-build clean",
+    "clean:build": "tamagui-build clean:build",
+    "dry-run": "cd ../../.. && bun code/core/codemod-flat-values/src/index.ts --report code/core/codemod-flat-values/dry-run-report.md code/kitchen-sink/src/usecases code/ui/tamagui/src/components/Button.tsx",
+    "write": "cd ../../.. && bun code/core/codemod-flat-values/src/index.ts --write --report code/core/codemod-flat-values/dry-run-report.md code/kitchen-sink/src/usecases code/ui/tamagui/src/components/Button.tsx",
+    "test": "bun test --timeout 20000 test",
+    "test:web": "bun test --timeout 20000 test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@tamagui/helpers": "3.0.0-beta.643.1",
+    "@tamagui/language-service": "3.0.0-beta.643.1",
+    "@tamagui/shorthands": "3.0.0-beta.643.1",
+    "@tamagui/style-grammar": "3.0.0-beta.643.1",
+    "ts-morph": "^28.0.0"
+  },
+  "devDependencies": {
+    "@tamagui/build": "3.0.0-beta.643.1",
+    "typescript": "~6.0.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tamagui/tamagui.git",
+    "directory": "code/core/codemod-flat-values"
   }
 }

package/src/builtInNames.ts

@@ -0,0 +1,21 @@
+import { v6ThemeNameReplacements } from '@tamagui/style-grammar/tooling'
+
+export const v6CodemodBuiltInNameReplacements = {
+  ...v6ThemeNameReplacements,
+  // v3 removed backgroundActive after its component defaults had already
+  // stopped resolving; press is the corrected active-state default
+  backgroundActive: 'background-press',
+} as const
+
+const builtInTokenPattern = new RegExp(
+  `\\$(${Object.keys(v6CodemodBuiltInNameReplacements).join('|')})(?![\\w-])`,
+  'g'
+)
+
+export function replaceV6BuiltInTokens(value: string): string {
+  return value.replace(
+    builtInTokenPattern,
+    (_, name: keyof typeof v6CodemodBuiltInNameReplacements) =>
+      `$${v6CodemodBuiltInNameReplacements[name]}`
+  )
+}

package/src/containers.ts

@@ -0,0 +1,227 @@
+// V3 splits the group from the query container, so a legacy group condition that
+// carries a container size (`$group-card-maxMd`) needs the element declaring the
+// group to declare a query container too.
+//
+// Which element that is has to be proven, never inferred. Declaring a container
+// changes containment and layout, so adding one to a `group="card"` in an
+// unrelated tree is a behavior change with no v1 counterpart. Only two answers
+// are allowed: the ancestor is visible in this file's JSX, or the site is flagged
+// for a human.
+
+import {
+  Node,
+  SyntaxKind,
+  type JsxAttribute,
+  type JsxOpeningElement,
+  type JsxSelfClosingElement,
+  type PropertyAssignment,
+  type SourceFile,
+} from 'ts-morph'
+import type { Flag } from './convert'
+import type { ModifierRegistryView } from './grammar'
+import { isLegacyConditionName, resolveLegacyName } from './legacyNames'
+
+/** the element or styled config that declares `group` */
+type Declaration = JsxAttribute | PropertyAssignment
+
+export interface ContainerTarget {
+  /** the group name the declaration carries, or the empty string for the unnamed group */
+  group: string
+  /** a consumer named this group, so the container needs a name to match */
+  named: boolean
+  /** set when the render-tree relationship could not be proven from the source */
+  flag: Flag | null
+}
+
+export interface ContainerPlan {
+  /** keyed by the node declaring `group`, for the declarations that get a container */
+  targets: ReadonlyMap<Node, ContainerTarget>
+  /** keyed by the node holding the legacy container-size condition */
+  unresolved: ReadonlyMap<Node, Flag>
+}
+
+const emptyPlan: ContainerPlan = {
+  targets: new Map(),
+  unresolved: new Map(),
+}
+
+/** the group name a declaration carries, or null when it is not statically known */
+function declaredGroup(declaration: Declaration): string | null {
+  if (Node.isJsxAttribute(declaration)) {
+    const initializer = declaration.getInitializer()
+    // a bare `group` prop declares the unnamed group
+    if (initializer === undefined) return ''
+    if (Node.isStringLiteral(initializer)) return initializer.getLiteralValue()
+    if (!Node.isJsxExpression(initializer)) return null
+    const expression = initializer.getExpression()
+    if (expression === undefined) return null
+    if (
+      Node.isStringLiteral(expression) ||
+      Node.isNoSubstitutionTemplateLiteral(expression)
+    ) {
+      return expression.getLiteralValue()
+    }
+    return expression.getKind() === SyntaxKind.TrueKeyword ? '' : null
+  }
+
+  const initializer = declaration.getInitializer()
+  if (initializer === undefined) return null
+  if (
+    Node.isStringLiteral(initializer) ||
+    Node.isNoSubstitutionTemplateLiteral(initializer)
+  ) {
+    return initializer.getLiteralValue()
+  }
+  return initializer.getKind() === SyntaxKind.TrueKeyword ? '' : null
+}
+
+function groupAttribute(
+  opening: JsxOpeningElement | JsxSelfClosingElement
+): JsxAttribute | null {
+  for (const attribute of opening.getAttributes()) {
+    if (!Node.isJsxAttribute(attribute)) continue
+    const name = attribute.getNameNode()
+    if (Node.isIdentifier(name) && name.getText() === 'group') return attribute
+  }
+  return null
+}
+
+/** an unnamed condition takes the nearest group; a named one takes its own */
+function matches(consumerGroup: string, declaration: string | null): boolean {
+  if (declaration === null) return true
+  return consumerGroup === '' || consumerGroup === declaration
+}
+
+interface Consumer {
+  /** the JSX attribute or object property holding the legacy condition */
+  node: Declaration
+  group: string
+}
+
+function containerConsumers(
+  sourceFile: SourceFile,
+  registry: ModifierRegistryView
+): Consumer[] {
+  const consumers: Consumer[] = []
+  const add = (node: Declaration, name: string): void => {
+    if (!isLegacyConditionName(name)) return
+    const resolution = resolveLegacyName(name, registry)
+    if (!resolution.ok || resolution.resolved.container === null) return
+    consumers.push({ node, group: resolution.resolved.container.group ?? '' })
+  }
+
+  for (const attribute of sourceFile.getDescendantsOfKind(SyntaxKind.JsxAttribute)) {
+    const name = attribute.getNameNode()
+    if (Node.isIdentifier(name)) add(attribute, name.getText())
+  }
+  for (const property of sourceFile.getDescendantsOfKind(SyntaxKind.PropertyAssignment)) {
+    const name = property.getNameNode()
+    if (Node.isComputedPropertyName(name)) continue
+    add(property, name.getText().replace(/^['"]|['"]$/g, ''))
+  }
+  return consumers
+}
+
+function declarations(sourceFile: SourceFile): Declaration[] {
+  const found: Declaration[] = []
+  for (const attribute of sourceFile.getDescendantsOfKind(SyntaxKind.JsxAttribute)) {
+    const name = attribute.getNameNode()
+    if (Node.isIdentifier(name) && name.getText() === 'group') found.push(attribute)
+  }
+  for (const property of sourceFile.getDescendantsOfKind(SyntaxKind.PropertyAssignment)) {
+    const name = property.getNameNode()
+    if (Node.isComputedPropertyName(name)) continue
+    if (name.getText().replace(/^['"]|['"]$/g, '') === 'group') found.push(property)
+  }
+  return found
+}
+
+/**
+ * The nearest JSX ancestor declaring the group, `'ambiguous'` when an ancestor
+ * declares a group name this pass cannot read, or null when no ancestor declares
+ * one at all.
+ */
+function provenAncestor(
+  consumer: Consumer
+): { declaration: JsxAttribute } | 'ambiguous' | null {
+  const owner = consumer.node.getFirstAncestor(
+    (node): node is JsxOpeningElement | JsxSelfClosingElement =>
+      Node.isJsxOpeningElement(node) || Node.isJsxSelfClosingElement(node)
+  )
+  if (owner === undefined) return null
+
+  // an element's own group never applies to itself, so the walk starts above it
+  for (const ancestor of owner.getAncestors()) {
+    if (!Node.isJsxElement(ancestor)) continue
+    const declaration = groupAttribute(ancestor.getOpeningElement())
+    if (declaration === null) continue
+    const group = declaredGroup(declaration)
+    if (group === null) return 'ambiguous'
+    if (matches(consumer.group, group)) return { declaration }
+  }
+  return null
+}
+
+export function planContainers(
+  sourceFile: SourceFile,
+  registry: ModifierRegistryView
+): ContainerPlan {
+  const consumers = containerConsumers(sourceFile, registry)
+  if (!consumers.length) return emptyPlan
+
+  const targets = new Map<Node, ContainerTarget>()
+  const unresolved = new Map<Node, Flag>()
+  const all = declarations(sourceFile)
+
+  const target = (declaration: Declaration, consumer: Consumer, flag: Flag | null) => {
+    const existing = targets.get(declaration)
+    if (existing) {
+      existing.named ||= consumer.group !== ''
+      existing.flag ??= flag
+      return
+    }
+    targets.set(declaration, {
+      group: declaredGroup(declaration) ?? consumer.group,
+      named: consumer.group !== '',
+      flag,
+    })
+  }
+
+  for (const consumer of consumers) {
+    const label =
+      consumer.group === '' ? 'the nearest group' : `group "${consumer.group}"`
+    const proven = provenAncestor(consumer)
+    if (proven === 'ambiguous') {
+      unresolved.set(consumer.node, {
+        code: 'ambiguous-container-group',
+        detail: `a JSX ancestor declares a group name this pass cannot read, so the element that has to declare the container for ${label} is not provable; add "container" by hand`,
+      })
+      continue
+    }
+    if (proven !== null) {
+      target(proven.declaration, consumer, null)
+      continue
+    }
+
+    const candidates = all.filter((declaration) =>
+      matches(consumer.group, declaredGroup(declaration))
+    )
+    if (candidates.length === 1) {
+      target(candidates[0], consumer, {
+        code: 'unproven-container-group',
+        detail: `a legacy container-size condition targets ${label} and this is the only declaration of it in the file, but no JSX ancestry proves it wraps that element; confirm the container belongs here`,
+      })
+      continue
+    }
+    unresolved.set(consumer.node, {
+      code: candidates.length
+        ? 'ambiguous-container-group'
+        : 'container-group-not-declared',
+      detail: candidates.length
+        ? `${candidates.length} declarations of ${label} are in this file and no JSX ancestry picks one, so the element that has to declare the container is not provable; add "container" by hand`
+        : `${label} is not declared in this file, so the "@…" query this condition becomes has no container to match; add "container" to the element declaring the group`,
+    })
+  }
+
+  return { targets, unresolved }
+}