modern-cmdk-codemod 0.0.0-stage → 1.0.0

package/dist/transforms/should-filter.mjs

@@ -0,0 +1,207 @@
+import { t as printOptions } from "../chunk-print-options.mjs";
+// src/transforms/should-filter.ts
+const SOURCES = /* @__PURE__ */ new Map([["cmdk", "cmdk"], ["modern-cmdk/react", "modern-cmdk/react"]]);
+const COMPONENTS = /* @__PURE__ */ new Set([
+	"Command",
+	"CommandRoot",
+	"CommandDialog"
+]);
+const adapterSource = (item, query, score, argCount) => {
+	return `(${item}, ${query}) => { const ${score} = __fn(${[
+		`${item}.value`,
+		query,
+		`${item}.keywords === undefined ? undefined : [...${item}.keywords]`
+	].slice(0, argCount).join(", ")}); return ${score} > 0 ? ${score} : false; }`;
+};
+function isFunctionLiteral(node) {
+	const type = node.type;
+	return type === "ArrowFunctionExpression" || type === "FunctionExpression";
+}
+function argCountOf(j, fn) {
+	if (!isFunctionLiteral(fn)) return 3;
+	if (fn.params.some((param) => param.type === "RestElement")) return 3;
+	if (j(fn).find(j.Identifier, { name: "arguments" }).size() > 0) return 3;
+	return Math.min(3, fn.params.length);
+}
+function freeName(name, used) {
+	let candidate = name;
+	while (used.has(candidate)) candidate += "_";
+	return candidate;
+}
+/**
+* jscodeshift transform — migrates cmdk's shouldFilter/filter props on cmdk-bound elements.
+*/
+function transform(fileInfo, api) {
+	const hasShouldFilter = fileInfo.source.includes("shouldFilter");
+	const hasFilter = fileInfo.source.includes("filter");
+	if (!hasShouldFilter && !hasFilter) return fileInfo.source;
+	const j = api.jscodeshift;
+	const root = j(fileInfo.source);
+	const bindings = /* @__PURE__ */ new Map();
+	let firstRaw;
+	root.find(j.ImportDeclaration).forEach((path) => {
+		const decl = path.node;
+		const origin = SOURCES.get(String(decl.source.value));
+		if (origin === void 0 || decl.importKind === "type") return;
+		firstRaw ??= decl.source.extra?.raw;
+		for (const spec of decl.specifiers ?? []) {
+			if (spec.type !== "ImportSpecifier") continue;
+			const imported = String(spec.imported.name);
+			if (!COMPONENTS.has(imported)) continue;
+			if (spec.importKind === "type") continue;
+			bindings.set(String(spec.local?.name ?? imported), origin);
+		}
+	});
+	if (bindings.size === 0) return fileInfo.source;
+	const originOf = (path) => {
+		const name = path.node.name;
+		let n;
+		if (name.type === "JSXIdentifier") n = name.name;
+		else if (name.type === "JSXMemberExpression" && name.object.type === "JSXIdentifier" && name.property.name === "Dialog") n = name.object.name;
+		else return;
+		const declaring = path.scope?.lookup(n);
+		if (declaring !== null && declaring !== void 0 && !declaring.isGlobal) return void 0;
+		return bindings.get(n);
+	};
+	let changed = false;
+	const typed = /.[cm]?tsx?$/.test(fileInfo.path);
+	root.find(j.JSXOpeningElement).forEach((path) => {
+		const origin = originOf(path);
+		if (origin === void 0) return;
+		const attrs = path.node.attributes ?? [];
+		const named = (n) => attrs.find((a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === n);
+		const shouldFilter = named("shouldFilter");
+		const filter = named("filter");
+		const line = path.node.loc?.start.line;
+		const where = `<${elementName(path.node)}> at line ${line ?? "?"}`;
+		if (shouldFilter?.type === "JSXAttribute" && filter !== void 0) {
+			api.report(`${where} has both shouldFilter and filter; left unchanged for manual migration (filter={false} replaces shouldFilter={false}; a filter takes (item, query) and returns a number or false)`);
+			return;
+		}
+		if (shouldFilter?.type === "JSXAttribute") {
+			changed = rewriteShouldFilter(j, api, path, shouldFilter, where) || changed;
+			return;
+		}
+		if (filter?.type === "JSXAttribute" && origin === "cmdk") changed = adaptFilter(j, api, filter, where, typed) || changed;
+	});
+	return changed ? root.toSource(printOptions(fileInfo.source, firstRaw)) : fileInfo.source;
+}
+function elementName(node) {
+	const name = node.name;
+	if (name.type === "JSXIdentifier") return name.name;
+	if (name.type === "JSXMemberExpression" && name.object.type === "JSXIdentifier") return `${name.object.name}.${name.property.name}`;
+	return "?";
+}
+function rewriteShouldFilter(j, api, path, attr, where) {
+	const value = attr.value;
+	const manual = (why) => {
+		api.report(`${where} has ${why}; left unchanged for manual migration`);
+		return false;
+	};
+	if (value === null || value === void 0) return remove(path, attr);
+	if (value.type !== "JSXExpressionContainer") return manual("a non-expression shouldFilter value");
+	const expr = value.expression;
+	if (expr.type === "JSXEmptyExpression") return manual("an empty shouldFilter value");
+	if (isBoolean(expr, true)) return remove(path, attr);
+	if (isBoolean(expr, false)) {
+		attr.name = j.jsxIdentifier("filter");
+		return true;
+	}
+	attr.name = j.jsxIdentifier("filter");
+	attr.value = j.jsxExpressionContainer(j.conditionalExpression(expr, j.identifier("undefined"), j.booleanLiteral(false)));
+	return true;
+}
+function isBoolean(expr, want) {
+	return (expr.type === "BooleanLiteral" || expr.type === "Literal") && expr.value === want;
+}
+function remove(path, attr) {
+	path.node.attributes = (path.node.attributes ?? []).filter((a) => a !== attr);
+	return true;
+}
+function isShouldFilterOutput(fn) {
+	return fn.type === "ConditionalExpression" && fn.consequent.type === "Identifier" && fn.consequent.name === "undefined" && isBoolean(fn.alternate, false);
+}
+function isAdapterOutput(fn) {
+	if (fn.type !== "ArrowFunctionExpression") return false;
+	const [first, second, ...rest] = fn.body.type === "BlockStatement" ? fn.body.body : [];
+	const [p0, p1, ...moreParams] = fn.params;
+	if (p0?.type !== "Identifier" || p1?.type !== "Identifier" || moreParams.length > 0) return false;
+	if (first?.type !== "VariableDeclaration" || first.kind !== "const") return false;
+	if (second?.type !== "ReturnStatement" || rest.length > 0) return false;
+	const [decl, ...moreDecls] = first.declarations;
+	if (decl?.type !== "VariableDeclarator" || moreDecls.length > 0) return false;
+	if (decl.id.type !== "Identifier" || decl.init?.type !== "CallExpression") return false;
+	const arg0 = decl.init.arguments[0];
+	if (arg0?.type !== "MemberExpression" || arg0.object.type !== "Identifier" || arg0.object.name !== p0.name || arg0.property.type !== "Identifier" || arg0.property.name !== "value") return false;
+	const id = decl.id.name;
+	const ret = second.argument;
+	return ret?.type === "ConditionalExpression" && ret.test.type === "BinaryExpression" && ret.test.operator === ">" && ret.test.left.type === "Identifier" && ret.test.left.name === id && ret.consequent.type === "Identifier" && ret.consequent.name === id && isBoolean(ret.alternate, false);
+}
+function isGuardedAdapterOutput(fn) {
+	return fn.type === "ConditionalExpression" && fn.test.type === "BinaryExpression" && fn.test.operator === "===" && fn.test.right.type === "Identifier" && fn.test.right.name === "undefined" && fn.consequent.type === "Identifier" && fn.consequent.name === "undefined" && isAdapterOutput(fn.alternate);
+}
+function isNamePath(node) {
+	if (node.type === "Identifier" || node.type === "ThisExpression") return true;
+	if (node.type !== "MemberExpression") return false;
+	const key = node.property.type;
+	if (node.computed && key !== "StringLiteral" && key !== "NumericLiteral") return false;
+	return isNamePath(node.object);
+}
+function cloneNamePath(j, node) {
+	if (node.type === "Identifier") return j.identifier(node.name);
+	if (node.type !== "MemberExpression") return j.thisExpression();
+	const key = node.property;
+	const property = key.type === "Identifier" ? j.identifier(key.name) : key.type === "PrivateName" ? j.privateName(j.identifier(String(key.id.name))) : key.type === "StringLiteral" ? j.stringLiteral(key.value) : j.numericLiteral(key.value);
+	return j.memberExpression(cloneNamePath(j, node.object), property, node.computed);
+}
+function adaptFilter(j, api, attr, where, typed) {
+	const value = attr.value;
+	if (value?.type !== "JSXExpressionContainer" || value.expression.type === "JSXEmptyExpression") {
+		api.report(`${where} has a filter value the transform cannot adapt; left unchanged for manual migration`);
+		return false;
+	}
+	const fn = value.expression;
+	if (isBoolean(fn, false) || isBoolean(fn, true)) return false;
+	if (isShouldFilterOutput(fn) || isAdapterOutput(fn) || isGuardedAdapterOutput(fn)) return false;
+	if (fn.type === "Identifier" && fn.name === "undefined") return false;
+	const type = fn.type;
+	if (type === "NullLiteral" || type === "Literal" && fn.value === null || type === "ConditionalExpression" || type === "LogicalExpression") {
+		api.report(`${where} has a filter expression that may not be a function; left unchanged for manual migration`);
+		return false;
+	}
+	if (!isFunctionLiteral(fn) && (fn.type === "ThisExpression" || !isNamePath(fn))) {
+		api.report(`${where} has a filter expression that is computed where it stands (a call or other computed value), which the adapter would re-evaluate on every item outside render; left unchanged for manual migration: hoist it to a const and pass the name`);
+		return false;
+	}
+	const used = /* @__PURE__ */ new Set();
+	if (fn.type === "Identifier") used.add(fn.name);
+	j(fn).find(j.Identifier).forEach((id) => {
+		used.add(id.node.name);
+	});
+	const adapter = j(adapterSource(freeName("item", used), freeName("query", used), freeName("score", used), argCountOf(j, fn))).find(j.ArrowFunctionExpression).get().node;
+	j(adapter).find(j.Identifier, { name: "__fn" }).replaceWith(() => typed && !isFunctionLiteral(fn) ? castToCmdkFilter(j, fn) : fn);
+	if (isFunctionLiteral(fn)) attr.value = j.jsxExpressionContainer(adapter);
+	else {
+		const copy = cloneNamePath(j, fn);
+		attr.value = j.jsxExpressionContainer(j.conditionalExpression(j.binaryExpression("===", copy, j.identifier("undefined")), j.identifier("undefined"), adapter));
+	}
+	return true;
+}
+function castToCmdkFilter(j, fn) {
+	const param = (name, type, optional = false) => {
+		const id = j.identifier(name);
+		id.typeAnnotation = j.tsTypeAnnotation(type);
+		if (optional) id.optional = true;
+		return id;
+	};
+	const signature = j.tsFunctionType([
+		param("value", j.tsStringKeyword()),
+		param("search", j.tsStringKeyword()),
+		param("keywords", j.tsArrayType(j.tsStringKeyword()), true)
+	]);
+	signature.typeAnnotation = j.tsTypeAnnotation(j.tsNumberKeyword());
+	const cast = j.tsAsExpression(fn, signature);
+	cast.extra = { parenthesized: true };
+	return cast;
+}
+export { transform as default };

package/dist/worker.mjs

@@ -0,0 +1 @@
+export { t as createApiFactory, n as transformFile } from "./chunk-worker.mjs";

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "modern-cmdk-codemod",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Codemods that migrate cmdk code to modern-cmdk",
+  "license": "MIT",
+  "homepage": "https://github.com/ABCrimson/modern-cmdk/tree/main/packages/modern-cmdk-codemod#readme",
+  "bugs": {
+    "url": "https://github.com/ABCrimson/modern-cmdk/issues"
+  },
+  "engines": {
+    "node": ">=26.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "modern-cmdk-codemod": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "jscodeshift": "17.4.0"
+  },
+  "devDependencies": {
+    "@types/jscodeshift": "17.3.0",
+    "@types/node": "26.6.6",
+    "tsdown": "0.23.7",
+    "typescript": "7.1.0-dev.20261107.1"
+  },
+  "keywords": [
+    "codemod",
+    "jscodeshift",
+    "cmdk",
+    "modern-cmdk",
+    "migration",
+    "command-palette",
+    "react"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ABCrimson/modern-cmdk.git",
+    "directory": "packages/modern-cmdk-codemod"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit"
+  }
 }