modern-cmdk 1.4.0 → 1.5.0

package/dist/codemod/transforms/forward-ref.mjs

@@ -1,50 +1,215 @@
-// src/codemod/transforms/forward-ref.ts
+import { n as __toESM, t as require_jscodeshift } from "../chunk-jscodeshift.mjs";
+import { t as printOptions } from "../chunk-print-options.mjs";
+// ../modern-cmdk-codemod/src/transforms/forward-ref.ts
+var import_jscodeshift = /* @__PURE__ */ __toESM(require_jscodeshift(), 1);
 /**
-* jscodeshift transform — removes forwardRef wrappers and merges the
-* ref parameter into the props object as a regular prop.
+* jscodeshift transform — unwraps forwardRef and binds the ref parameter as a `ref` prop.
 */
 function transform(fileInfo, api) {
 	if (!fileInfo.source.includes("forwardRef")) return fileInfo.source;
 	const j = api.jscodeshift;
 	const root = j(fileInfo.source);
+	const reactImports = root.find(j.ImportDeclaration).filter((path) => {
+		return path.node.source.value === "react" && path.node.importKind !== "type";
+	});
+	const programScope = root.find(j.Program).get().scope;
+	const bindings = {
+		forwardRefs: /* @__PURE__ */ new Set(),
+		namespaces: []
+	};
+	reactImports.forEach((path) => {
+		for (const specifier of path.node.specifiers ?? []) if (specifier.type === "ImportSpecifier") {
+			if (specifier.imported.name === "forwardRef") bindings.forwardRefs.add((specifier.local ?? specifier.imported).name);
+		} else if (specifier.local) bindings.namespaces.push(specifier.local.name);
+	});
+	if (bindings.forwardRefs.size === 0 && bindings.namespaces.length === 0) return fileInfo.source;
+	/** Whether a declaration other than a react import specifier binds `name` as a type anywhere in the file. */
+	const redeclaresType = (name) => root.find(j.TSTypeParameter, { name }).size() > 0 || root.find(j.TSTypeAliasDeclaration, { id: { name } }).size() > 0 || root.find(j.TSInterfaceDeclaration, { id: { name } }).size() > 0 || root.find(j.TSEnumDeclaration, { id: { name } }).size() > 0 || root.find(j.TSModuleDeclaration, { id: { name } }).size() > 0 || root.find(j.ClassDeclaration, { id: { name } }).size() > 0 || root.find(j.ClassExpression, { id: { name } }).size() > 0 || root.find(j.TSImportEqualsDeclaration, { id: { name } }).size() > 0;
+	/**
+	* `Ref` as a type name: `<Namespace>.Ref` when react has a default or namespace import, else a
+	* `Ref` specifier (existing, or a type-only one added once) on the react named import.
+	*/
+	let refResolved = false;
+	let refLocal = "Ref";
+	const refTypeName = () => {
+		const namespace = bindings.namespaces[0];
+		if (namespace !== void 0) return j.tsQualifiedName(j.identifier(namespace), j.identifier("Ref"));
+		if (!refResolved) {
+			refResolved = true;
+			const existing = root.find(j.ImportDeclaration, { source: { value: "react" } }).find(j.ImportSpecifier, { imported: { name: "Ref" } }).paths()[0];
+			const existingLocal = existing && (existing.node.local ?? existing.node.imported).name;
+			if (existingLocal !== void 0 && !redeclaresType(existingLocal)) refLocal = existingLocal;
+			else {
+				let suffix = 1;
+				while (root.find(j.Identifier, { name: refLocal }).size() > 0) {
+					suffix += 1;
+					refLocal = suffix === 2 ? "ReactRef" : `ReactRef${suffix - 1}`;
+				}
+				reactImports.filter((path) => (path.node.specifiers ?? []).some((s) => s.type === "ImportSpecifier")).paths()[0]?.node.specifiers?.push(Object.assign(j.importSpecifier(j.identifier("Ref"), refLocal === "Ref" ? null : j.identifier(refLocal)), { importKind: "type" }));
+			}
+		}
+		return j.identifier(refLocal);
+	};
 	let hasChanges = false;
-	root.find(j.CallExpression).filter((path) => {
+	const manual = (message) => {
+		api.report(message);
+	};
+	const isForwardRefCall = (node) => {
+		const callee = node.callee;
+		if (callee.type === "Identifier") return bindings.forwardRefs.has(callee.name);
+		return callee.type === "MemberExpression" && !callee.computed && callee.object.type === "Identifier" && bindings.namespaces.includes(callee.object.name) && callee.property.type === "Identifier" && callee.property.name === "forwardRef";
+	};
+	const calls = root.find(j.CallExpression).filter((path) => {
+		if (!isForwardRefCall(path.node)) return false;
 		const callee = path.node.callee;
-		if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "React" && callee.property.type === "Identifier" && callee.property.name === "forwardRef") return true;
-		if (callee.type === "Identifier" && callee.name === "forwardRef") return true;
-		return false;
-	}).forEach((path) => {
-		const args = path.node.arguments;
-		if (args.length === 0) return;
-		const renderFn = args[0];
-		if (!renderFn) return;
-		if (renderFn.type !== "ArrowFunctionExpression" && renderFn.type !== "FunctionExpression") return;
+		const name = callee.type === "Identifier" ? callee.name : callee.object.name;
+		return path.scope.lookup(name) === programScope;
+	}).paths();
+	for (const path of calls) {
+		const call = path.node;
+		const renderFn = call.arguments[0];
+		if (renderFn === void 0) {
+			manual("forwardRef() without a render function: unwrap by hand");
+			continue;
+		}
+		if (renderFn.type !== "ArrowFunctionExpression" && renderFn.type !== "FunctionExpression") {
+			manual(renderFn.type === "Identifier" ? `forwardRef(${renderFn.name}): unwrap by hand` : "forwardRef(<expression>): unwrap by hand");
+			continue;
+		}
 		const params = renderFn.params;
-		if (params.length < 2) return;
+		if (params.length > 2) {
+			manual("forwardRef render function with more than two parameters: unwrap by hand");
+			continue;
+		}
+		const typeArgs = ((call.typeArguments ?? call.typeParameters)?.params ?? []).filter(isTsType);
+		const typeArgRef = typeArgs[0];
+		const typeArgProps = typeArgs[1];
 		const propsParam = params[0];
 		const refParam = params[1];
-		if (!propsParam || !refParam) return;
-		const refName = refParam.type === "Identifier" ? refParam.name : "ref";
-		const refProperty = j.objectProperty(j.identifier(refName), j.identifier(refName));
-		refProperty.shorthand = true;
-		if (propsParam.type === "ObjectPattern") propsParam.properties.unshift(refProperty);
-		else if (propsParam.type === "Identifier") {
-			const restElement = j.restElement(j.identifier(propsParam.name));
-			const newParam = j.objectPattern([refProperty, restElement]);
-			if ("typeAnnotation" in propsParam && propsParam.typeAnnotation) newParam.typeAnnotation = propsParam.typeAnnotation;
-			renderFn.params[0] = newParam;
+		if (propsParam === void 0) {
+			if (typeArgRef !== void 0) {
+				manual("forwardRef<T>() render function without parameters: unwrap by hand");
+				continue;
+			}
+			unwrapCall(path, renderFn);
+			hasChanges = true;
+			continue;
+		}
+		const target = propsParam.type === "AssignmentPattern" ? propsParam.left : propsParam;
+		if (target.type !== "Identifier" && target.type !== "ObjectPattern") {
+			manual("forwardRef props parameter is not an identifier or object pattern: unwrap by hand");
+			continue;
+		}
+		const propsAnnotation = target.typeAnnotation;
+		const propsType = tsTypeOf(propsAnnotation) ?? typeArgProps;
+		if (target.type === "ObjectPattern" && target.properties.some((p) => (p.type === "ObjectProperty" || p.type === "Property") && p.computed && p.key.type !== "StringLiteral" && p.key.type !== "NumericLiteral" && p.key.type !== "BigIntLiteral" && !(p.key.type === "TemplateLiteral" && p.key.expressions.length === 0))) {
+			manual("forwardRef props pattern has a computed key that may be 'ref': unwrap by hand");
+			continue;
+		}
+		if (target.type === "ObjectPattern" && target.properties.some((p) => (p.type === "ObjectProperty" || p.type === "Property") && (!p.computed && p.key.type === "Identifier" && p.key.name === "ref" || p.key.type === "StringLiteral" && p.key.value === "ref" || p.computed && p.key.type === "TemplateLiteral" && p.key.expressions.length === 0 && p.key.quasis[0]?.value.cooked === "ref"))) {
+			manual("forwardRef props pattern already has a 'ref' key: unwrap by hand");
+			continue;
 		}
+		if (refParam === void 0) {
+			if (typeArgRef === void 0 && tsTypeOf(propsAnnotation) !== void 0 && j(renderFn).find(j.JSXSpreadAttribute).size() > 0) {
+				manual("forwardRef render function has a JSX spread and no ref type argument: unwrap by hand");
+				continue;
+			}
+			const singleRef = typeArgRef ?? (tsTypeOf(propsAnnotation) !== void 0 ? j.tsUnknownKeyword() : void 0);
+			if (singleRef !== void 0) {
+				const member = j.tsTypeLiteral([Object.assign(j.tsPropertySignature(j.identifier("ref"), j.tsTypeAnnotation(j.tsTypeReference(refTypeName(), j.tsTypeParameterInstantiation([singleRef])))), { optional: true })]);
+				target.typeAnnotation = j.tsTypeAnnotation(propsType !== void 0 ? j.tsIntersectionType([intersectable(j, propsType), member]) : member);
+			} else if (propsAnnotation == null && typeArgProps !== void 0) target.typeAnnotation = j.tsTypeAnnotation(typeArgProps);
+			unwrapCall(path, renderFn);
+			hasChanges = true;
+			continue;
+		}
+		if (refParam.type !== "Identifier") {
+			manual("forwardRef ref parameter is not a plain identifier: unwrap by hand");
+			continue;
+		}
+		const refAnnotation = refParam.typeAnnotation;
+		let refType;
+		const annotatedRef = tsTypeOf(refAnnotation);
+		if (annotatedRef !== void 0) refType = annotatedRef;
+		else if (typeArgRef !== void 0) refType = j.tsTypeReference(refTypeName(), j.tsTypeParameterInstantiation([typeArgRef]));
+		if (refType === void 0 && propsType !== void 0) refType = j.tsTypeReference(refTypeName(), j.tsTypeParameterInstantiation([j.tsUnknownKeyword()]));
+		let annotation;
+		if (refType !== void 0) {
+			const refMember = j.tsTypeLiteral([Object.assign(j.tsPropertySignature(j.identifier("ref"), j.tsTypeAnnotation(refType)), { optional: true })]);
+			if (propsType !== void 0) annotation = j.tsIntersectionType([intersectable(j, propsType), refMember]);
+			else if (typeArgs.length > 0) annotation = refMember;
+			else {
+				manual("forwardRef ref is annotated but the props type is unknown: unwrap by hand");
+				continue;
+			}
+		} else if (propsType !== void 0) annotation = propsType;
+		const refProperty = j.objectProperty(j.identifier("ref"), j.identifier(refParam.name));
+		refProperty.shorthand = refParam.name === "ref";
+		let pattern;
+		if (target.type === "ObjectPattern") {
+			target.properties.unshift(refProperty);
+			pattern = target;
+		} else pattern = j.objectPattern.from({ properties: [refProperty, j.restElement(j.identifier(target.name))] });
+		if (annotation !== void 0) pattern.typeAnnotation = j.tsTypeAnnotation(annotation);
+		else if (target.type === "Identifier" && target.typeAnnotation) pattern.typeAnnotation = target.typeAnnotation;
+		if (propsParam.type === "AssignmentPattern") propsParam.left = pattern;
+		else renderFn.params[0] = pattern;
 		renderFn.params = [renderFn.params[0]];
-		j(path).replaceWith(renderFn);
+		unwrapCall(path, renderFn);
 		hasChanges = true;
-	});
-	if (hasChanges) {
-		if (root.find(j.Identifier, { name: "forwardRef" }).filter((path) => path.parent.node.type !== "ImportSpecifier").length === 0) root.find(j.ImportSpecifier, { imported: { name: "forwardRef" } }).forEach((path) => {
-			const importDecl = path.parent.node;
-			if (importDecl.specifiers && importDecl.specifiers.length === 1) j(path.parent).remove();
-			else j(path).remove();
+	}
+	if (!hasChanges) return fileInfo.source;
+	reactImports.forEach((declaration) => {
+		const specifiers = declaration.node.specifiers ?? [];
+		const before = specifiers.length;
+		const kept = specifiers.filter((specifier) => {
+			if (specifier.type !== "ImportSpecifier" || specifier.imported.name !== "forwardRef") return true;
+			const local = (specifier.local ?? specifier.imported).name;
+			return isReferenced(j, root, programScope, local);
 		});
+		if (kept.length === before) return;
+		if (kept.length === 0) {
+			const comments = declaration.node.comments;
+			const siblings = declaration.parent.node.body;
+			const next = siblings[siblings.indexOf(declaration.node) + 1];
+			if (comments && next) next.comments = [...comments, ...next.comments ?? []];
+			j(declaration).remove();
+		} else declaration.node.specifiers = kept;
+	});
+	return root.toSource(printOptions(fileInfo.source));
+}
+/** Replace the forwardRef call with its render function, keeping the call's own comments. */
+function unwrapCall(path, renderFn) {
+	const comments = path.node.comments;
+	if (comments) renderFn.comments = [...comments, ...renderFn.comments ?? []];
+	path.replace(renderFn);
+}
+/** Flow type arguments (a .js file with Flow) are not TypeScript types and are never used. */
+const isTsType = (type) => import_jscodeshift.default.TSType.check(type);
+/** The TypeScript type inside a `: T` annotation, if the annotation is one. */
+function tsTypeOf(annotation) {
+	return annotation?.type === "TSTypeAnnotation" && isTsType(annotation.typeAnnotation) ? annotation.typeAnnotation : void 0;
+}
+/** A type that binds looser than `&` gets parentheses before it joins an intersection. */
+function intersectable(j, type) {
+	switch (type.type) {
+		case "TSUnionType":
+		case "TSFunctionType":
+		case "TSConstructorType":
+		case "TSConditionalType": return j.tsParenthesizedType(type);
+		default: return type;
 	}
-	return hasChanges ? root.toSource() : fileInfo.source;
+}
+/** Whether an Identifier named `name` is a reference outside any import specifier. */
+function isReferenced(j, root, programScope, name) {
+	return root.find(j.Identifier, { name }).filter((path) => {
+		if (path.scope.lookup(name) !== programScope) return false;
+		const parent = path.parent.node;
+		if (parent.type === "ImportSpecifier" || parent.type === "ImportDefaultSpecifier" || parent.type === "ImportNamespaceSpecifier") return false;
+		if ((parent.type === "MemberExpression" || parent.type === "OptionalMemberExpression") && parent.property === path.node && !parent.computed) return false;
+		if ((parent.type === "ObjectProperty" || parent.type === "Property") && parent.key === path.node && !parent.computed && !parent.shorthand) return false;
+		return true;
+	}).size() > 0;
 }
 export { transform as default };