modern-cmdk-codemod 0.0.0-stage → 1.0.0

package/dist/transforms/forward-ref.mjs

@@ -0,0 +1,214 @@
+import { t as printOptions } from "../chunk-print-options.mjs";
+import jscodeshift from "jscodeshift";
+// src/transforms/forward-ref.ts
+/**
+* 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;
+	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;
+		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) {
+			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 === 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]];
+		unwrapCall(path, renderFn);
+		hasChanges = true;
+	}
+	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) => jscodeshift.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;
+	}
+}
+/** 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 };

package/dist/transforms/import-rewrite.mjs

@@ -0,0 +1,401 @@
+import { t as printOptions } from "../chunk-print-options.mjs";
+// src/transforms/import-rewrite.ts
+const OLD_PACKAGE = "cmdk";
+const NEW_PACKAGE = "modern-cmdk/react";
+/**
+* The names modern-cmdk/react exports: the value exports and the `export type` names of
+* src/react/index.ts. tests/unit/codemod-import-rewrite.test.ts compares this set to that file,
+* so it fails when the library changes.
+*/
+const KNOWN_EXPORTS = /* @__PURE__ */ new Set([
+	"ActivityMode",
+	"Command",
+	"CommandActivity",
+	"CommandActivityProps",
+	"CommandAsyncItems",
+	"CommandAsyncItemsProps",
+	"CommandBadge",
+	"CommandBadgeProps",
+	"CommandContextValue",
+	"CommandDialog",
+	"CommandDialogProps",
+	"CommandEmpty",
+	"CommandEmptyProps",
+	"CommandErrorBoundary",
+	"CommandErrorBoundaryProps",
+	"CommandGroup",
+	"CommandGroupContextValue",
+	"CommandGroupProps",
+	"CommandHighlight",
+	"CommandHighlightProps",
+	"CommandInput",
+	"CommandInputProps",
+	"CommandItem",
+	"CommandItemProps",
+	"CommandList",
+	"CommandListProps",
+	"CommandLoading",
+	"CommandLoadingProps",
+	"CommandPage",
+	"CommandPageId",
+	"CommandPageProps",
+	"CommandRootId",
+	"CommandRootProps",
+	"CommandSeparator",
+	"CommandSeparatorProps",
+	"CommandShortcut",
+	"CommandShortcutProps",
+	"CommandStableContext",
+	"CommandStableContextValue",
+	"CommandStateContext",
+	"CommandStateContextValue",
+	"RegisterGroupOptions",
+	"RegisterItemOptions",
+	"UseCommandReturn",
+	"VirtualItem",
+	"VirtualizerOptions",
+	"VirtualizerReturn",
+	"createKeydownHandler",
+	"useCommand",
+	"useCommandDevtools",
+	"useCommandState",
+	"useRegisterGroup",
+	"useRegisterItem",
+	"useVirtualizer"
+]);
+/**
+* cmdk names that modern-cmdk/react exports under another name. cmdk's d.ts ends with
+* `export { pkg as Command, …, Command as CommandRoot, … }`: both are the root component. cmdk has
+* no default export; a default import (and `default as X`) is read as the root too.
+*/
+const RENAMED = /* @__PURE__ */ new Map([["CommandRoot", "Command"], ["default", "Command"]]);
+/** cmdk exports that have no modern-cmdk/react counterpart under the same name. */
+const CMDK_ONLY_NAMES = /* @__PURE__ */ new Set(["CommandRoot", "defaultFilter"]);
+const MOCK_OBJECTS = /* @__PURE__ */ new Set(["vi", "jest"]);
+const MOCK_METHODS = /* @__PURE__ */ new Set([
+	"mock",
+	"doMock",
+	"unmock",
+	"doUnmock",
+	"importActual",
+	"importMock",
+	"requireActual",
+	"requireMock"
+]);
+/** The modern-cmdk/react name for a cmdk name, or undefined when there is none. */
+function mapName(name) {
+	const renamed = RENAMED.get(name);
+	if (renamed !== void 0) return renamed;
+	return KNOWN_EXPORTS.has(name) ? name : void 0;
+}
+/** A string literal node (Babel StringLiteral or ESTree Literal), or undefined. */
+function asStringLiteral(node) {
+	if (typeof node !== "object" || node === null) return void 0;
+	const lit = node;
+	if (lit.type !== "StringLiteral" && lit.type !== "Literal") return void 0;
+	return typeof lit.value === "string" ? node : void 0;
+}
+/** A template literal with no expressions and one quasi (`cmdk`), or undefined. */
+function asPlainTemplate(node) {
+	if (typeof node !== "object" || node === null) return void 0;
+	const t = node;
+	if (t.type !== "TemplateLiteral" || t.expressions?.length !== 0 || t.quasis?.length !== 1) return;
+	return node;
+}
+/** The text of a string-literal or plain-template module source, or undefined. */
+function sourceText(node) {
+	const lit = asStringLiteral(node);
+	if (lit !== void 0) return lit.value;
+	return asPlainTemplate(node)?.quasis[0]?.value.cooked ?? void 0;
+}
+/** The name of an Identifier, JSXIdentifier or string-literal module-export name. */
+function nameOf(node) {
+	if (typeof node !== "object" || node === null) return void 0;
+	const n = node;
+	if ((n.type === "Identifier" || n.type === "JSXIdentifier") && typeof n.name === "string") return n.name;
+	return asStringLiteral(node)?.value;
+}
+/**
+* jscodeshift transform — rewrites cmdk imports to modern-cmdk/react, checking every imported
+* name against modern-cmdk/react's exports.
+*/
+function transform(fileInfo, api) {
+	if (!fileInfo.source.includes(OLD_PACKAGE)) return fileInfo.source;
+	const j = api.jscodeshift;
+	const root = j(fileInfo.source);
+	let changed = false;
+	let firstRaw;
+	const subpathReport = (specifier) => {
+		api.report(`'${specifier}' is a cmdk subpath with no modern-cmdk/react counterpart; left unchanged`);
+	};
+	/** Rewrite a module-specifier literal equal to 'cmdk'; report a 'cmdk/<subpath>' one. */
+	const rewriteSite = (node) => {
+		const text = sourceText(node);
+		if (text === void 0) return;
+		if (text === OLD_PACKAGE) {
+			const lit = asStringLiteral(node);
+			if (lit !== void 0) {
+				if (firstRaw === void 0) {
+					const raw = lit.extra?.raw ?? lit.raw;
+					if (typeof raw === "string") firstRaw = raw;
+				}
+				lit.value = NEW_PACKAGE;
+			} else {
+				const quasi = asPlainTemplate(node)?.quasis[0];
+				if (quasi === void 0) return;
+				quasi.value.raw = NEW_PACKAGE;
+				quasi.value.cooked = NEW_PACKAGE;
+			}
+			changed = true;
+		} else if (text.startsWith(`${OLD_PACKAGE}/`)) subpathReport(text);
+	};
+	/**
+	* Replace a declaration with several. The new nodes carry no source location, so recast prints
+	* them on consecutive lines instead of copying the original's trailing blank line between them.
+	*/
+	const replaceWith = (path, nodes) => {
+		nodes[0].comments = path.node.comments;
+		path.replace(...nodes);
+		changed = true;
+	};
+	const isCmdkSource = (node) => sourceText(node) === OLD_PACKAGE;
+	const handleImport = (path) => {
+		const node = path.node;
+		if (!isCmdkSource(node.source)) {
+			rewriteSite(node.source);
+			return;
+		}
+		const mapped = [];
+		const unmapped = [];
+		let namespace;
+		let rebuilt = false;
+		for (const spec of node.specifiers ?? []) {
+			if (spec.type === "ImportNamespaceSpecifier") {
+				namespace = spec;
+				continue;
+			}
+			if (spec.type === "ImportDefaultSpecifier") {
+				const local = nameOf(spec.local) ?? "Command";
+				mapped.push(j.importSpecifier(j.identifier("Command"), j.identifier(local)));
+				rebuilt = true;
+				continue;
+			}
+			const imported = nameOf(spec.imported) ?? "";
+			const target = mapName(imported);
+			if (target === void 0) {
+				unmapped.push(spec);
+				api.report(`${imported} has no modern-cmdk/react export; left on the cmdk import`);
+				continue;
+			}
+			if (imported === "useCommandState") api.report(`useCommandState was rewritten, but its state is modern-cmdk's CommandState, not cmdk's; review the selector`);
+			if (target === imported) {
+				mapped.push(spec);
+				continue;
+			}
+			const renamed = j.importSpecifier(j.identifier(target), j.identifier(nameOf(spec.local) ?? imported));
+			const kind = spec.importKind;
+			if (kind !== void 0) renamed.importKind = kind;
+			mapped.push(renamed);
+			rebuilt = true;
+		}
+		if (namespace === void 0 && mapped.length === 0 && unmapped.length > 0) return;
+		rewriteSite(node.source);
+		if (namespace !== void 0) {
+			if (mapped.length > 0) replaceWith(path, [j.importDeclaration([namespace], j.stringLiteral(NEW_PACKAGE), node.importKind), j.importDeclaration(mapped, j.stringLiteral(NEW_PACKAGE), node.importKind)]);
+			const local = nameOf(namespace.local);
+			if (local !== void 0) reportNamespaceMembers(path, local, `the namespace import ${local}`);
+		} else if (unmapped.length > 0) replaceWith(path, [j.importDeclaration(mapped, j.stringLiteral(NEW_PACKAGE), node.importKind), j.importDeclaration(unmapped, j.stringLiteral(OLD_PACKAGE), node.importKind)]);
+		else if (rebuilt) node.specifiers = mapped;
+	};
+	/** Report each `K.name` member access, `<K.name>` JSX tag and `K.name` type reference on a namespace import whose name has no export. */
+	const reportNamespaceMembers = (importPath, local, via) => {
+		const declaredHere = importPath.scope?.lookup(local);
+		const note = (member, scope) => {
+			if (scope?.lookup(local) !== declaredHere) return;
+			const name = nameOf(member);
+			if (name === void 0 || KNOWN_EXPORTS.has(name)) return;
+			api.report(`${name} has no modern-cmdk/react export; used through ${via}`);
+		};
+		root.find(j.MemberExpression, { object: {
+			type: "Identifier",
+			name: local
+		} }).forEach((p) => {
+			if (!p.node.computed) note(p.node.property, p.scope);
+		});
+		root.find(j.TSQualifiedName, { left: {
+			type: "Identifier",
+			name: local
+		} }).forEach((p) => {
+			note(p.node.right, p.scope);
+		});
+		root.find(j.JSXMemberExpression, { object: {
+			type: "JSXIdentifier",
+			name: local
+		} }).forEach((p) => {
+			let tag = p;
+			while (tag.parent?.node.type === "JSXMemberExpression") tag = tag.parent;
+			if (tag.parent?.node.type === "JSXClosingElement") return;
+			note(p.node.property, p.scope);
+		});
+	};
+	/**
+	* For a require()/import()/requireActual() call on 'cmdk' that is bound to a variable (directly
+	* or through await), report destructured names and member reads that modern-cmdk/react lacks.
+	*/
+	const reportBoundMembers = (callPath) => {
+		let p = callPath.parent;
+		if (p?.node.type === "AwaitExpression") p = p.parent;
+		if (p?.node.type !== "VariableDeclarator") return;
+		const id = p.node.id;
+		if (id?.type === "ObjectPattern") for (const prop of id.properties ?? []) {
+			const pr = prop;
+			if (pr.type !== "ObjectProperty" && pr.type !== "Property" || pr.computed === true) continue;
+			const name = nameOf(pr.key);
+			if (name === void 0 || mapName(name) === name) continue;
+			api.report(`${name} has no modern-cmdk/react export under that name; destructured from the cmdk module`);
+		}
+		else if (id?.type === "Identifier" && id.name !== void 0) reportNamespaceMembers(p, id.name, `${id.name}, bound to the cmdk module`);
+	};
+	const reportStarReexport = (form) => {
+		api.report(`${form} re-exported names that ${NEW_PACKAGE} lacks (${[...CMDK_ONLY_NAMES].join(", ")}); re-export the ${NEW_PACKAGE} names by hand`);
+	};
+	const handleExportFrom = (path) => {
+		const node = path.node;
+		if (!isCmdkSource(node.source)) {
+			rewriteSite(node.source);
+			return;
+		}
+		const mapped = [];
+		const unmapped = [];
+		let rebuilt = false;
+		for (const spec of node.specifiers ?? []) {
+			if (spec.type !== "ExportSpecifier") {
+				if (spec.type === "ExportNamespaceSpecifier") reportStarReexport(`export * as ${nameOf(spec.exported) ?? "*"} from '${OLD_PACKAGE}'`);
+				mapped.push(spec);
+				continue;
+			}
+			const exportedName = nameOf(spec.local);
+			if (exportedName === void 0) {
+				mapped.push(spec);
+				continue;
+			}
+			const target = mapName(exportedName);
+			if (target === void 0) {
+				unmapped.push(spec);
+				api.report(`${exportedName} has no modern-cmdk/react export; left on the cmdk export`);
+				continue;
+			}
+			if (exportedName === "useCommandState") api.report(`useCommandState was rewritten, but its state is modern-cmdk's CommandState, not cmdk's; review the selector`);
+			if (target === exportedName) {
+				mapped.push(spec);
+				continue;
+			}
+			const renamed = j.exportSpecifier.from({
+				local: j.identifier(target),
+				exported: j.identifier(nameOf(spec.exported) ?? exportedName)
+			});
+			const kind = spec.exportKind;
+			if (kind !== void 0) renamed.exportKind = kind;
+			mapped.push(renamed);
+			rebuilt = true;
+		}
+		if (mapped.length === 0 && unmapped.length > 0) return;
+		rewriteSite(node.source);
+		if (unmapped.length > 0) {
+			const kept = j.exportNamedDeclaration(null, mapped, j.stringLiteral(NEW_PACKAGE));
+			const rest = j.exportNamedDeclaration(null, unmapped, j.stringLiteral(OLD_PACKAGE));
+			if (node.exportKind !== void 0) {
+				kept.exportKind = node.exportKind;
+				rest.exportKind = node.exportKind;
+			}
+			replaceWith(path, [kept, rest]);
+		} else if (rebuilt) node.specifiers = mapped;
+	};
+	/** vi.mock('cmdk', factory) and friends: rewrite the path, report a factory naming cmdk-only names. */
+	const handleMockFactory = (path) => {
+		const factory = path.get("arguments", 1);
+		const type = factory.node?.type;
+		if (type !== "ArrowFunctionExpression" && type !== "FunctionExpression") return;
+		const found = /* @__PURE__ */ new Set();
+		j(factory).find(j.Identifier).forEach((p) => {
+			if (CMDK_ONLY_NAMES.has(p.node.name)) found.add(p.node.name);
+		});
+		j(factory).find(j.StringLiteral).forEach((p) => {
+			if (CMDK_ONLY_NAMES.has(p.node.value)) found.add(p.node.value);
+		});
+		if (found.size === 0) return;
+		api.report(`the mock factory for 'cmdk' names ${[...found].join(", ")}, which modern-cmdk/react does not export under that name; the factory body is not rewritten, check it by hand`);
+	};
+	root.find(j.Node).forEach((path) => {
+		const node = path.node;
+		switch (node.type) {
+			case "ImportDeclaration":
+				handleImport(path);
+				break;
+			case "ExportNamedDeclaration":
+				handleExportFrom(path);
+				break;
+			case "ExportAllDeclaration":
+				if (isCmdkSource(node.source)) reportStarReexport(`export * from '${OLD_PACKAGE}'`);
+				rewriteSite(node.source);
+				break;
+			case "ImportExpression": {
+				const isCmdk = isCmdkSource(node.source);
+				rewriteSite(node.source);
+				if (isCmdk) reportBoundMembers(path);
+				break;
+			}
+			case "TSImportEqualsDeclaration": {
+				const ref = node.moduleReference;
+				if (ref?.type === "TSExternalModuleReference") {
+					const isCmdk = isCmdkSource(ref.expression);
+					rewriteSite(ref.expression);
+					const id = node.id;
+					if (isCmdk && id?.type === "Identifier" && id.name !== void 0) reportNamespaceMembers(path, id.name, `the namespace import ${id.name}`);
+				}
+				break;
+			}
+			case "TSImportType": {
+				const arg = node.argument;
+				const lit = arg?.type === "TSLiteralType" ? arg.literal : arg;
+				const isCmdk = isCmdkSource(lit);
+				rewriteSite(lit);
+				if (isCmdk) {
+					let q = node.qualifier;
+					while (q?.type === "TSQualifiedName") q = q.left;
+					const name = nameOf(q);
+					if (name !== void 0 && !KNOWN_EXPORTS.has(name)) api.report(`${name} has no modern-cmdk/react export; used through import('cmdk')`);
+				}
+				break;
+			}
+			case "TSModuleDeclaration": {
+				const id = asStringLiteral(node.id);
+				if (id?.value === OLD_PACKAGE) api.report(`declare module '${OLD_PACKAGE}' was left unchanged; move the declaration to '${NEW_PACKAGE}' by hand`);
+				else if (id?.value.startsWith(`${OLD_PACKAGE}/`)) subpathReport(id.value);
+				break;
+			}
+			case "CallExpression": {
+				const call = path;
+				const callee = call.node.callee;
+				const arg = call.node.arguments[0];
+				const isCmdk = isCmdkSource(arg);
+				if (callee.type === "Import") {
+					rewriteSite(arg);
+					if (isCmdk) reportBoundMembers(path);
+				} else if (callee.type === "Identifier" && callee.name === "require") {
+					rewriteSite(arg);
+					if (isCmdk) reportBoundMembers(path);
+				} else if (callee.type === "MemberExpression" && callee.computed !== true && callee.object?.type === "Identifier" && MOCK_OBJECTS.has(callee.object.name ?? "") && callee.property?.type === "Identifier" && MOCK_METHODS.has(callee.property.name ?? "")) {
+					const a = arg;
+					if (isCmdk || a?.type === "ImportExpression" && isCmdkSource(a.source) || a?.type === "CallExpression" && a.callee?.type === "Import" && isCmdkSource(a.arguments?.[0])) handleMockFactory(call);
+					rewriteSite(arg);
+					if (isCmdk) reportBoundMembers(path);
+				}
+				break;
+			}
+		}
+	});
+	if (!changed) return fileInfo.source;
+	return root.toSource(printOptions(fileInfo.source, firstRaw));
+}
+export { KNOWN_EXPORTS, transform as default };