modern-cmdk 1.4.0 → 1.5.0

package/dist/core/index.mjs

@@ -1051,6 +1051,7 @@ function createCommandMachine(options = {}) {
 	const scheduler = createScheduler();
 	const emitter = new TypedEmitter();
 	const keyboardRegistry = new KeyboardShortcutRegistry();
+	const pendingSources = /* @__PURE__ */ new Set();
 	let frecencyEngine = null;
 	if (options.frecency?.enabled) {
 		frecencyEngine = new FrecencyEngine(options.frecency);
@@ -1224,12 +1225,19 @@ function createCommandMachine(options = {}) {
 			case "ITEMS_LOADED":
 				registry.registerItems(event.items);
 				searchEngine.index(event.items);
-				state = {
-					...state,
-					loading: false
-				};
 				refilter(state.search);
 				break;
+			case "LOADING": {
+				if (event.pending) pendingSources.add(event.source);
+				else pendingSources.delete(event.source);
+				const loading = pendingSources.size > 0;
+				if (loading !== state.loading) setState({
+					...state,
+					loading,
+					lastUpdated: Date.now()
+				});
+				break;
+			}
 			case "REGISTER_ITEM":
 				registry.registerItem(event.item);
 				searchEngine.index([event.item]);

package/dist/react/dialog.mjs

@@ -1,3 +1,2 @@
 'use client';
-"use client";
 export { t as CommandDialog } from "./chunk-dialog.mjs";

package/dist/react/index.d.mts

@@ -17,14 +17,19 @@ interface CommandActivityProps {
  */
 export declare function CommandActivity({ mode, children }: CommandActivityProps): ReactNode;
 interface CommandAsyncItemsProps {
-  /** Promise that resolves to items */
+  /** Promise that resolves to items; keep it stable across renders (state, a ref, or `useMemo`) or the boundary re-suspends on every render */
   readonly items: Promise<readonly CommandItem$1[]>;
   /** Fallback content while loading */
   readonly fallback?: ReactNode;
   /** Render function for resolved items */
   readonly children: (items: readonly CommandItem$1[]) => ReactNode;
 }
-/** Suspense-based async item loader that resolves a promise of items using React 19 `use()`. */
+/**
+ * Suspense-based async item loader that resolves a promise of items using React 19 `use()`.
+ *
+ * The `items` promise must be kept stable across renders (held in state, a ref, or `useMemo`):
+ * a new promise on every render, such as `items={fetchItems()}`, suspends again on every render.
+ */
 export declare function CommandAsyncItems({ items, fallback, children }: CommandAsyncItemsProps): ReactNode;
 interface CommandBadgeProps extends ComponentPropsWithRef<"span"> {}
 /** Inline badge for categorization or status indicators on command items. */
@@ -60,6 +65,7 @@ export declare function CommandInput({ ref, placeholder, onValueChange, ...props
 interface CommandItemProps extends Omit<ComponentPropsWithRef<"div">, "onSelect" | "value"> {
   readonly value: string;
   readonly keywords?: readonly string[];
+  /** Called when the item is selected by click, Enter or shortcut (no argument in 1.x; the value arrives in 2.0) */
   readonly onSelect?: () => void;
   readonly disabled?: boolean;
   readonly shortcut?: string;
@@ -181,7 +187,16 @@ interface CommandGroupContextValue {
 }
 interface CommandErrorBoundaryProps {
   readonly children: ReactNode;
-  readonly fallback?: ReactNode | ((error: Error) => ReactNode);
+  /**
+   * Rendered in place of the children after an error. A function receives the error and a `reset`
+   * callback that clears it, so the children render again (a retry button, for example).
+   */
+  readonly fallback?: ReactNode | ((error: Error, reset: () => void) => ReactNode);
+  /**
+   * While the boundary shows its fallback, a change in these values (compared entry by entry with
+   * `Object.is`; a different length counts as a change) clears the error and renders the children again.
+   */
+  readonly resetKeys?: readonly unknown[];
   readonly onError?: (error: Error, errorInfo: ErrorInfo) => void;
 }
 interface CommandErrorBoundaryState {
@@ -192,6 +207,9 @@ export declare class CommandErrorBoundary extends Component<CommandErrorBoundary
   override state: CommandErrorBoundaryState;
   static getDerivedStateFromError(error: Error): CommandErrorBoundaryState;
   override componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+  override componentDidUpdate(prevProps: CommandErrorBoundaryProps, prevState: CommandErrorBoundaryState): void;
+  /** Clears the captured error so the children render again. */
+  reset: () => void;
   override render(): ReactNode;
 }
 interface UseCommandReturn {

package/dist/react/index.mjs

@@ -33,14 +33,42 @@ function AsyncItemsInner({ items: itemsPromise, children }) {
 	}, [stable.machine, items]);
 	return /* @__PURE__ */ jsx(Fragment, { children: children(items) });
 }
-/** Suspense-based async item loader that resolves a promise of items using React 19 `use()`. */
+/**
+* Rendered next to the Suspense fallback: while it is mounted its source counts as pending,
+* so `state.loading` (Command.Loading, the list's aria-busy) follows the suspended promise.
+* The fallback unmounts when the items resolve, reject into an error boundary, or this
+* AsyncItems unmounts, and the cleanup then clears the source.
+*/
+function PendingSignal() {
+	const stable = useStableContext("Command.AsyncItems");
+	const source = useId();
+	useLayoutEffect(() => {
+		stable.machine.send({
+			type: "LOADING",
+			source,
+			pending: true
+		});
+		return () => {
+			stable.machine.send({
+				type: "LOADING",
+				source,
+				pending: false
+			});
+		};
+	}, [stable.machine, source]);
+	return null;
+}
+/**
+* Suspense-based async item loader that resolves a promise of items using React 19 `use()`.
+*
+* The `items` promise must be kept stable across renders (held in state, a ref, or `useMemo`):
+* a new promise on every render, such as `items={fetchItems()}`, suspends again on every render.
+*/
 function CommandAsyncItems({ items, fallback, children }) {
-	const stableRef = useRef(items);
-	if (stableRef.current !== items) stableRef.current = items;
 	return /* @__PURE__ */ jsx(Suspense, {
-		fallback,
+		fallback: /* @__PURE__ */ jsxs(Fragment, { children: [fallback, /* @__PURE__ */ jsx(PendingSignal, {})] }),
 		children: /* @__PURE__ */ jsx(AsyncItemsInner, {
-			items: stableRef.current,
+			items,
 			children
 		})
 	});
@@ -678,10 +706,20 @@ var CommandErrorBoundary = class extends Component {
 	componentDidCatch(error, errorInfo) {
 		this.props.onError?.(error, errorInfo);
 	}
+	componentDidUpdate(prevProps, prevState) {
+		if (this.state.error === null || prevState.error === null) return;
+		const prev = prevProps.resetKeys;
+		const next = this.props.resetKeys;
+		if (prev !== next && (prev?.length !== next?.length || next?.some((key, index) => !Object.is(key, prev?.[index])))) this.reset();
+	}
+	/** Clears the captured error so the children render again. */
+	reset = () => {
+		this.setState(INITIAL_STATE);
+	};
 	render() {
 		if (this.state.error) {
 			const { fallback } = this.props;
-			if (typeof fallback === "function") return fallback(this.state.error);
+			if (typeof fallback === "function") return fallback(this.state.error, this.reset);
 			if (fallback) return fallback;
 			return null;
 		}
@@ -696,15 +734,7 @@ function useCommandState(selector) {
 	const getSnapshot = useCallback(() => selectorRef.current ? selectorRef.current(stable.machine.getState()) : stable.machine.getState(), [stable.machine]);
 	return useSyncExternalStore(stable.machine.subscribe, getSnapshot, getSnapshot);
 }
-// src/core/utils/env.ts
-/**
-* `true` unless `process.env.NODE_ENV` is `'production'`.
-*
-* Consumer bundlers (Vite, webpack, Next, esbuild) replace `process.env.NODE_ENV` statically,
-* so the dev-only branches guarded by this flag fold away in production builds. A browser
-* running the unbundled module throws a ReferenceError on the bare `process` reference;
-* the catch turns that into the production value (`false`), so dev-only code stays off.
-*/
+// src/react/hooks/use-devtools.ts
 const isDev = (() => {
 	try {
 		return process.env.NODE_ENV !== "production";
@@ -712,7 +742,6 @@ const isDev = (() => {
 		return false;
 	}
 })();
-// src/react/hooks/use-devtools.ts
 /** Branded key for the global devtools instance map */
 const DEVTOOLS_KEY = "__CRIMSON_COMMAND_DEVTOOLS__";
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modern-cmdk",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "type": "module",
   "description": "The definitive command palette engine for the modern web",
   "license": "MIT",
@@ -30,11 +30,12 @@
   "main": "./dist/core/index.mjs",
   "types": "./dist/core/index.d.mts",
   "bin": {
-    "modern-cmdk": "./dist/codemod/cli.mjs"
+    "modern-cmdk": "./dist/codemod/bin.mjs"
   },
   "files": [
     "dist",
-    "LICENSE"
+    "LICENSE",
+    "THIRD-PARTY-NOTICES.md"
   ],
   "sideEffects": [
     "./dist/react/styles.css"
@@ -56,10 +57,7 @@
     "idb-keyval": "6.3.0"
   },
   "devDependencies": {
-    "globby": "16.2.4",
-    "jscodeshift": "17.4.0",
-    "radix-ui": "1.8.2-rc.1791984254107",
-    "@types/jscodeshift": "17.3.0"
+    "radix-ui": "1.8.2-rc.1791984254107"
   },
   "keywords": [
     "command-palette",