modern-cmdk 1.3.0 → 1.5.0

package/dist/codemod/transforms/import-rewrite.mjs

@@ -1,42 +1,401 @@
-// src/codemod/transforms/import-rewrite.ts
+import { t as printOptions } from "../chunk-print-options.mjs";
+// ../modern-cmdk-codemod/src/transforms/import-rewrite.ts
 const OLD_PACKAGE = "cmdk";
 const NEW_PACKAGE = "modern-cmdk/react";
 /**
-* jscodeshift transform — rewrites all import/require/re-export paths
-* from `cmdk` to `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 hasChanges = false;
-	root.find(j.ImportDeclaration, { source: { value: OLD_PACKAGE } }).forEach((path) => {
-		path.node.source.value = NEW_PACKAGE;
-		hasChanges = true;
-	});
-	root.find(j.ExportNamedDeclaration, { source: { value: OLD_PACKAGE } }).forEach((path) => {
-		if (path.node.source) {
-			path.node.source.value = NEW_PACKAGE;
-			hasChanges = true;
+	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;
 		}
-	});
-	root.find(j.ExportAllDeclaration, { source: { value: OLD_PACKAGE } }).forEach((path) => {
-		path.node.source.value = NEW_PACKAGE;
-		hasChanges = true;
-	});
-	root.find(j.CallExpression, { callee: { type: "Import" } }).forEach((path) => {
-		const arg = path.node.arguments[0];
-		if (arg && arg.type === "StringLiteral" && arg.value === OLD_PACKAGE) {
-			arg.value = NEW_PACKAGE;
-			hasChanges = true;
+		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;
 		}
-	});
-	root.find(j.CallExpression, { callee: { name: "require" } }).forEach((path) => {
-		const arg = path.node.arguments[0];
-		if (arg && arg.type === "StringLiteral" && arg.value === OLD_PACKAGE) {
-			arg.value = NEW_PACKAGE;
-			hasChanges = 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;
+			}
 		}
 	});
-	return hasChanges ? root.toSource() : fileInfo.source;
+	if (!changed) return fileInfo.source;
+	return root.toSource(printOptions(fileInfo.source, firstRaw));
 }
-export { transform as default };
+export { KNOWN_EXPORTS, transform as default };

package/dist/codemod/transforms/should-filter.mjs

@@ -1,18 +1,207 @@
-// src/codemod/transforms/should-filter.ts
+import { t as printOptions } from "../chunk-print-options.mjs";
+// ../modern-cmdk-codemod/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 shouldFilter prop to filter.
+* jscodeshift transform — migrates cmdk's shouldFilter/filter props on cmdk-bound elements.
 */
 function transform(fileInfo, api) {
-	if (!fileInfo.source.includes("shouldFilter")) return fileInfo.source;
+	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);
-	let hasChanges = false;
-	root.find(j.JSXAttribute, { name: { name: "shouldFilter" } }).forEach((path) => {
-		const value = path.node.value;
-		if (value && value.type === "JSXExpressionContainer" && value.expression.type === "BooleanLiteral" && value.expression.value === true || value === null) j(path).remove();
-		else path.node.name = j.jsxIdentifier("filter");
-		hasChanges = true;
+	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);
 	});
-	return hasChanges ? root.toSource() : fileInfo.source;
+	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/codemod/worker.mjs

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

package/dist/core/index.d.mts

@@ -134,6 +134,10 @@ type CommandEvent = {
 } | {
   readonly type: "ITEMS_LOADED";
   readonly items: readonly CommandItem[];
+} | {
+  readonly type: "LOADING";
+  readonly source: string;
+  readonly pending: boolean;
 } | {
   readonly type: "REGISTER_ITEM";
   readonly item: CommandItem;
@@ -172,7 +176,8 @@ interface FrecencyDecayConfig {
 }
 /** Frecency configuration options */
 interface FrecencyOptions {
-  readonly enabled: boolean;
+  /** Turns frecency tracking and re-ranking on. Default false. */
+  readonly enabled?: boolean | undefined;
   readonly storage?: FrecencyStorage | undefined;
   readonly namespace?: string | undefined;
   readonly decayConfig?: FrecencyDecayConfig | undefined;