modern-cmdk 1.4.0 → 1.5.0

package/dist/codemod/chunk-print-options.mjs

@@ -0,0 +1,43 @@
+// ../modern-cmdk-codemod/src/print-options.ts
+const TOKEN = /\/\/[^\n]*|\/\*[\s\S]*?\*\/|`(?:[^`\\]|\\[\s\S])*`|(?<s>'(?:[^'\\\n]|\\.)*'|"(?:[^"\\\n]|\\.)*")/g;
+const SPECIFIER_CONTEXT = /(?:\bfrom|\bimport|\brequire\s*\(|\bimport\s*\()\s*$/;
+function quoteOf(raw) {
+	if (raw.startsWith("'")) return "single";
+	if (raw.startsWith("\"")) return "double";
+}
+/**
+* Print options that reproduce the source file's line terminator and quote style.
+*
+* - lineTerminator: CRLF when the source contains a CRLF, else LF.
+* - quote: the quote of `sampleRaw` when it starts with one; otherwise the quote of the first
+*   import, export-from, require or dynamic-import specifier; otherwise the more frequent quote
+*   of the file's string literals, a tie giving double.
+*/
+function printOptions(source, sampleRaw) {
+	const lineTerminator = source.includes("\r\n") ? "\r\n" : "\n";
+	const sampled = sampleRaw === void 0 ? void 0 : quoteOf(sampleRaw);
+	if (sampled !== void 0) return {
+		quote: sampled,
+		lineTerminator
+	};
+	let single = 0;
+	let double = 0;
+	let specifier;
+	for (const match of source.matchAll(TOKEN)) {
+		const raw = match.groups?.s;
+		if (raw === void 0) continue;
+		const quote = raw.startsWith("'") ? "single" : "double";
+		if (quote === "single") single++;
+		else double++;
+		if (specifier === void 0 && SPECIFIER_CONTEXT.test(source.slice(Math.max(0, match.index - 32), match.index))) specifier = quote;
+	}
+	if (specifier !== void 0) return {
+		quote: specifier,
+		lineTerminator
+	};
+	return {
+		quote: single > double ? "single" : "double",
+		lineTerminator
+	};
+}
+export { printOptions as t };

package/dist/codemod/chunk-worker.mjs

@@ -0,0 +1,476 @@
+import { n as __toESM, t as require_jscodeshift } from "./chunk-jscodeshift.mjs";
+import { access, constants, glob, lstat, readFile, realpath, stat } from "node:fs/promises";
+import { basename, delimiter, dirname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
+import { isMainThread, parentPort, workerData } from "node:worker_threads";
+import { execFile } from "node:child_process";
+// ../modern-cmdk-codemod/src/files.ts
+const PARSERS = /* @__PURE__ */ new Map([
+	[".ts", "ts"],
+	[".mts", "ts"],
+	[".cts", "ts"],
+	[".tsx", "tsx"],
+	[".js", "babel"],
+	[".jsx", "babel"],
+	[".mjs", "babel"],
+	[".cjs", "babel"]
+]);
+const STYLESHEETS = /* @__PURE__ */ new Set([".css", ".scss"]);
+function extensionOf(path) {
+	const dot = path.lastIndexOf(".");
+	return dot > Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\")) ? path.slice(dot).toLowerCase() : "";
+}
+/**
+* The jscodeshift parser for a script file: `ts` for .ts/.mts/.cts, `tsx` for .tsx, `babel` (which
+* parses JSX) for .js/.jsx/.mjs/.cjs. `undefined` for anything that is not a script.
+*/
+function parserFor(path) {
+	return PARSERS.get(extensionOf(path));
+}
+function routeFor(path) {
+	if (PARSERS.has(extensionOf(path))) return "script";
+	return STYLESHEETS.has(extensionOf(path)) ? "stylesheet" : "skip";
+}
+/** What a directory argument expands to, relative to that directory. */
+const DIRECTORY_GLOB = "**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,css,scss}";
+/**
+* On win32 every backslash of a command-line pattern becomes '/' (glob syntax has no other use for
+* it there). Elsewhere a backslash is an escape and stays. Braces are never escaped: the directory
+* form needs them.
+*/
+function normalizePattern(arg, platform = process.platform) {
+	return platform === "win32" ? arg.replaceAll("\\", "/") : arg;
+}
+const LEGACY_EXCLUDES = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	".next"
+]);
+const CODEMOD_EXCLUDES = /* @__PURE__ */ new Set([
+	...LEGACY_EXCLUDES,
+	".git",
+	"coverage",
+	".turbo",
+	"out",
+	"storybook-static",
+	".vercel"
+]);
+/**
+* The directory that holds the `.git/modules` a gitdir target lies under, else `undefined`. A
+* submodule's `.git` file reads `gitdir: <super>/.git/modules/<name>`; a linked worktree's reads
+* `gitdir: <main>/.git/worktrees/<name>`. `target` is a realpath.
+*/
+function superprojectOf(target) {
+	const segments = target.split(sep);
+	const at = segments.findLastIndex((segment, index) => segment === ".git" && segments[index + 1] === "modules");
+	return at < 1 ? void 0 : segments.slice(0, at).join(sep);
+}
+/**
+* The trust boundary of one operation: the realpath of the nearest directory, from `realpath(cwd)`
+* upward, that holds a `.git` entry (a directory, or the file a worktree or submodule has), else
+* `realpath(cwd)` when no ancestor holds one. It is the work tree `git rev-parse --show-toplevel`
+* reports, computed without spawning git, and realpath'd so that a linked cwd (macOS's `/var` ->
+* `/private/var`) or a short Windows path (`RUNNER~1`) compares equal to what git prints. Not the
+* cwd, which may be a subdirectory of the tree whose other directories a planted git can sit in.
+* Not the outermost work tree either: a dotfiles repository at the home directory would exclude
+* every PATH entry under the home (shims, `~/.local/bin`) and leave the user with no git.
+* Three cases make a `.git` entry reach further. A `.git` directory (an ordinary repository, a
+* nested one included) stops the climb. A `.git` file whose `gitdir:` target lies under a
+* `.git/modules` directory is a submodule: the superproject around it came from the same clone,
+* so the climb goes on from there, and again while that superproject is itself a submodule. A `.git`
+* file for a linked worktree (target under `.git/worktrees`), or one that cannot be read or
+* resolved, stops the climb: the main repository of a worktree is the user's own.
+*/
+async function trustBoundary(cwd) {
+	const start = await realpath(cwd);
+	let at = start;
+	for (;;) {
+		const entry = await lstat(join(at, ".git")).catch(() => void 0);
+		if (entry === void 0) {
+			if (dirname(at) === at) return start;
+			at = dirname(at);
+			continue;
+		}
+		const superproject = entry.isFile() ? await superprojectAbove(at) : void 0;
+		if (superproject === void 0) return at;
+		at = superproject;
+	}
+}
+/** The superproject of the submodule checked out at `at`, from its `.git` file; `undefined` if it is not one. */
+async function superprojectAbove(at) {
+	try {
+		const link = /^gitdir:\s*(.+?)\s*$/m.exec(await readFile(join(at, ".git"), "utf8"));
+		return link?.[1] === void 0 ? void 0 : superprojectOf(await realpath(resolve(at, link[1])));
+	} catch {
+		return;
+	}
+}
+/** True when `path` is `boundary` or lies under it. Written once, for gitSearchDirs and resolveGit. */
+function inside(boundary, path) {
+	const rel = relative(boundary, path);
+	return rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+/**
+* The directories of a PATH value that may hold git: absolute entries outside `boundary`, the work
+* tree being migrated. Empty and relative entries are dropped (they name the working directory), and
+* so is any entry equal to or under `boundary`, which may carry a planted executable. Order is kept.
+* This is the syntactic filter; resolveGit also compares real paths.
+*/
+function gitSearchDirs(pathValue, boundary) {
+	return (pathValue ?? "").split(delimiter).filter((entry) => entry !== "" && isAbsolute(entry) && !inside(boundary, entry));
+}
+/**
+* True when `candidate` is a regular file (a directory named git is not git) that the process may
+* execute (`access` with X_OK is a plain existence check on Windows) and whose own realpath lies
+* outside `boundary`, so a link into the tree is refused.
+*/
+async function isGitOutside(candidate, boundary) {
+	try {
+		if (!(await stat(candidate)).isFile()) return false;
+		await access(candidate, constants.X_OK);
+		return !inside(boundary, await realpath(candidate));
+	} catch {
+		return false;
+	}
+}
+const resolvedGit = /* @__PURE__ */ new Map();
+/**
+* The absolute path of the first git executable in PATH's `gitSearchDirs`, so the spawn does no
+* search of its own. A kept entry is skipped when its realpath is inside `boundary` (a link or an
+* alias into the tree) or does not resolve. Looks for `git.exe` then `git.com` on win32 (the names
+* libuv tries) and `git` elsewhere; isGitOutside says what a candidate must be. `boundary` comes
+* from trustBoundary and is the same for every spawn of one operation, so a submodule's directory
+* or a subdirectory cwd never narrows it. The answer is kept per boundary and PATH value for the
+* life of the process. Rejects with ENOENT, naming `boundary`, when there is none.
+*/
+function resolveGit(boundary) {
+	const pathValue = process.env.PATH;
+	const cacheKey = JSON.stringify([boundary, pathValue]);
+	const cached = resolvedGit.get(cacheKey);
+	if (cached !== void 0) return cached;
+	const names = process.platform === "win32" ? ["git.exe", "git.com"] : ["git"];
+	const found = (async () => {
+		for (const searchDir of gitSearchDirs(pathValue, boundary)) {
+			const realDir = await realpath(searchDir).catch(() => void 0);
+			if (realDir === void 0 || inside(boundary, realDir)) continue;
+			for (const name of names) {
+				const candidate = join(searchDir, name);
+				if (await isGitOutside(candidate, boundary)) return candidate;
+			}
+		}
+		throw Object.assign(/* @__PURE__ */ new Error(`git was not found on PATH outside ${boundary}`), { code: "ENOENT" });
+	})();
+	resolvedGit.set(cacheKey, found);
+	found.catch(() => resolvedGit.delete(cacheKey));
+	return found;
+}
+/**
+* Run git in `cwd` with execFile on the absolute path resolveGit finds outside `boundary`. The two
+* differ on purpose: `cwd` is where git runs (the repository root, a submodule's directory or a
+* subdirectory); `boundary` is the operation's trustBoundary, what PATH is filtered against. Resolves
+* on any exit code; rejects on a spawn failure, and with ENOENT when git is missing. Reads
+* process.env.PATH at each call, so tests steer it with vi.stubEnv.
+*/
+async function runGit(args, cwd, boundary, input = "") {
+	const executable = await resolveGit(boundary);
+	const { promise, resolve: done, reject } = Promise.withResolvers();
+	const child = execFile(executable, [...args], {
+		cwd,
+		encoding: "utf8",
+		maxBuffer: 1024 ** 3,
+		windowsHide: true
+	}, (error, stdout, stderr) => {
+		if (error === null) return done({
+			code: 0,
+			stdout,
+			stderr
+		});
+		const code = error.code;
+		if (typeof code === "number") return done({
+			code,
+			stdout,
+			stderr
+		});
+		reject(error);
+	});
+	child.stdin?.on("error", () => {});
+	child.stdin?.end(input);
+	return promise;
+}
+async function locateRepo(cwd, boundary) {
+	try {
+		const { code, stdout } = await runGit(["rev-parse", "--show-toplevel"], cwd, boundary);
+		return code === 0 ? {
+			kind: "repo",
+			root: resolve(stdout.trim())
+		} : { kind: "none" };
+	} catch (error) {
+		if (error.code === "ENOENT") return { kind: "missing" };
+		throw error;
+	}
+}
+/** Paths of `files` relative to the repo root (forward slashes), `undefined` for those outside it. */
+async function relativeToRoot(files, cwd, root) {
+	const prefix = relative(await realpath(root), await realpath(cwd));
+	return files.map((file) => {
+		const rel = normalize(join(prefix, relative(cwd, file)));
+		return rel.startsWith("..") || isAbsolute(rel) ? void 0 : rel.replaceAll("\\", "/");
+	});
+}
+const key = (path) => process.platform === "win32" ? path.toLowerCase() : path;
+/**
+* Root-relative paths of the gitlinks (mode 160000: submodules) in the repository at `root`. One
+* level is enough: a submodule nested inside a submodule is not looked for.
+*/
+async function gitlinksOf(root, boundary) {
+	const { code, stdout, stderr } = await runGit([
+		"ls-files",
+		"-s",
+		"-z"
+	], root, boundary);
+	if (code !== 0) throw new Error(`git ls-files failed (exit ${code}): ${stderr.trim()}`);
+	return stdout.split("\0").filter((entry) => entry.startsWith("160000 ")).map((entry) => entry.slice(entry.indexOf("	") + 1));
+}
+/** The paths of `rels` that `git check-ignore` run in `owner` reports as ignored. */
+async function ignoredIn(owner, rels, boundary) {
+	const { code, stdout, stderr } = await runGit([
+		"check-ignore",
+		"-z",
+		"--stdin"
+	], owner, boundary, rels.join("\0"));
+	if (code !== 0 && code !== 1) throw new Error(`git check-ignore failed (exit ${code}): ${stderr.trim()}`);
+	return new Set(stdout.split("\0").filter((p) => p !== ""));
+}
+async function dropGitIgnored(files, cwd, boundary, warn) {
+	const repo = await locateRepo(cwd, boundary);
+	if (repo.kind === "missing") {
+		warn("warning: git not found; .gitignore is not applied");
+		return files;
+	}
+	if (repo.kind === "none") return files;
+	const rels = await relativeToRoot(files, cwd, repo.root);
+	if (!rels.some((rel) => rel !== void 0)) return files;
+	const gitlinks = (await gitlinksOf(repo.root, boundary)).map(key);
+	const groups = /* @__PURE__ */ new Map();
+	rels.forEach((rel, index) => {
+		if (rel === void 0) return;
+		const link = gitlinks.filter((g) => key(rel).startsWith(`${g}/`)).reduce((deepest, g) => g.length > deepest.length ? g : deepest, "");
+		const group = groups.get(link) ?? {
+			root: link === "" ? repo.root : join(repo.root, rel.slice(0, link.length)),
+			indexes: [],
+			paths: []
+		};
+		group.indexes.push(index);
+		group.paths.push(link === "" ? rel : rel.slice(link.length + 1));
+		groups.set(link, group);
+	});
+	const drop = /* @__PURE__ */ new Set();
+	for (const group of groups.values()) {
+		const ignored = await ignoredIn(group.root, group.paths, boundary);
+		group.paths.forEach((path, i) => {
+			if (ignored.has(path)) drop.add(group.indexes[i]);
+		});
+	}
+	return files.filter((_, index) => !drop.has(index));
+}
+/** realpath of a file; for one deleted since discovery, its parent's realpath plus its name. */
+async function realpathOrParent(file) {
+	try {
+		return await realpath(file);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		return join(await realpath(dirname(file)), basename(file));
+	}
+}
+/**
+* `git status --porcelain -z` in `cwd`, intersected with `files`. Untracked files count as dirty
+* (a codemod write to one cannot be undone); ignored files were already dropped by discovery. A
+* modified submodule (status runs with `--ignore-submodules=none`, so modified or untracked files in
+* it count) or an untracked directory entry (a nested repository, which git never descends into, or
+* any untracked directory) makes every matched file under it dirty.
+*/
+async function findDirtyFiles(files, cwd) {
+	const boundary = await trustBoundary(cwd);
+	const repo = await locateRepo(cwd, boundary);
+	if (repo.kind === "missing") return { kind: "no-git" };
+	if (repo.kind === "none") return { kind: "no-repo" };
+	const { code, stdout, stderr } = await runGit([
+		"--no-optional-locks",
+		"status",
+		"--porcelain",
+		"-z",
+		"--untracked-files=all",
+		"--ignore-submodules=none"
+	], cwd, boundary);
+	if (code !== 0) throw new Error(`git status failed (exit ${code}): ${stderr.trim()}`);
+	const dirty = /* @__PURE__ */ new Set();
+	const dirtyDirs = [];
+	const entries = stdout.split("\0");
+	for (let i = 0; i < entries.length; i++) {
+		const entry = entries[i];
+		if (entry.length < 4) continue;
+		const path = entry.slice(3);
+		if (path.endsWith("/")) dirtyDirs.push(key(path));
+		else {
+			dirty.add(key(path));
+			if ((await lstat(join(repo.root, path)).catch(() => void 0))?.isDirectory()) dirtyDirs.push(`${key(path)}/`);
+		}
+		if (/[RC]/.test(entry.slice(0, 2))) {
+			const origin = entries[++i];
+			if (origin !== void 0) dirty.add(key(origin));
+		}
+	}
+	const realRoot = await realpath(repo.root);
+	const outside = [];
+	for (const file of files) {
+		const r = relative(realRoot, await realpathOrParent(file));
+		if (r.startsWith("..") || isAbsolute(r)) outside.push(file);
+	}
+	if (outside.length > 0) return {
+		kind: "outside",
+		paths: outside
+	};
+	const rels = await relativeToRoot(files, cwd, repo.root);
+	const paths = files.filter((_, index) => {
+		const rel = rels[index];
+		return rel !== void 0 && (dirty.has(key(rel)) || dirtyDirs.some((d) => key(rel).startsWith(d)));
+	});
+	return paths.length === 0 ? { kind: "clean" } : {
+		kind: "dirty",
+		paths
+	};
+}
+/** True when a directory between cwd and `file` is a symbolic link (or junction). */
+async function reachedThroughSymlink(file, cwd) {
+	const rel = relative(cwd, file);
+	if (rel.startsWith("..") || isAbsolute(rel)) return false;
+	let at = cwd;
+	for (const part of rel.split(sep).slice(0, -1)) {
+		at = join(at, part);
+		if ((await lstat(at)).isSymbolicLink()) return true;
+	}
+	return false;
+}
+async function isDirectory(path) {
+	try {
+		return (await stat(path)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/**
+* Resolve command-line patterns to absolute, de-duplicated, sorted file paths. A directory argument
+* expands to its script and stylesheet files. `modern-cmdk-codemod` also skips more build
+* directories and the paths .gitignore covers. `**` descends no symlinked directory in either program;
+* modern-cmdk-codemod also drops every file reached through a symlinked directory below cwd.
+*/
+async function discoverFiles(patterns, { program, cwd, warn }) {
+	const dirs = [];
+	const globs = [];
+	for (const arg of patterns) {
+		const pattern = normalizePattern(arg);
+		const abs = resolve(cwd, pattern);
+		if (await isDirectory(abs)) dirs.push(abs);
+		else globs.push(pattern);
+	}
+	const excluded = program === "modern-cmdk-codemod" ? CODEMOD_EXCLUDES : LEGACY_EXCLUDES;
+	const exclude = (d) => excluded.has(d.name);
+	const entries = [...globs.length > 0 ? await Array.fromAsync(glob(globs, {
+		cwd,
+		withFileTypes: true,
+		exclude
+	})) : [], ...(await Promise.all(dirs.map((d) => Array.fromAsync(glob(DIRECTORY_GLOB, {
+		cwd: d,
+		withFileTypes: true,
+		exclude
+	}))))).flat()];
+	const files = [...new Set(entries.filter((d) => d.isFile()).map((d) => resolve(d.parentPath, d.name)))].filter((file) => !relative(cwd, file).split(sep).some((segment) => excluded.has(segment))).sort();
+	if (program !== "modern-cmdk-codemod") return files;
+	const through = await Promise.all(files.map((file) => reachedThroughSymlink(file, cwd)));
+	return dropGitIgnored(files.filter((_, index) => !through[index]), cwd, await trustBoundary(cwd), warn);
+}
+// ../modern-cmdk-codemod/src/worker.ts
+var import_jscodeshift = /* @__PURE__ */ __toESM(require_jscodeshift(), 1);
+/** One jscodeshift API per parser; the API object itself is per file so reports carry the file. */
+function createApiFactory() {
+	const parsers = /* @__PURE__ */ new Map();
+	return (parser, report) => {
+		let j = parsers.get(parser);
+		if (j === void 0) {
+			j = import_jscodeshift.default.withParser(parser);
+			parsers.set(parser, j);
+		}
+		return {
+			jscodeshift: j,
+			j,
+			stats: () => {},
+			report
+		};
+	};
+}
+/** Transform one file; a thrown error becomes `error`, with the reports made before it. */
+async function transformFile(path, mod, apiForParser, keepSource) {
+	const reports = [];
+	const report = (message) => void reports.push(message);
+	try {
+		const route = routeFor(path);
+		if (route === "skip" || route === "stylesheet" && mod.transformStylesheet === void 0) return {
+			path,
+			changed: false,
+			skipped: true,
+			reports
+		};
+		const source = await readFile(path, "utf-8");
+		const output = route === "script" ? mod.default({
+			path,
+			source
+		}, apiForParser(parserFor(path), report)) : mod.transformStylesheet(source, report);
+		if (output === source) return {
+			path,
+			changed: false,
+			reports
+		};
+		return {
+			path,
+			changed: true,
+			output,
+			...keepSource ? { source } : {},
+			reports
+		};
+	} catch (err) {
+		return {
+			path,
+			changed: false,
+			error: err instanceof Error ? err.message : String(err),
+			reports
+		};
+	}
+}
+function isWorkerInit(value) {
+	return typeof value === "object" && value !== null && value.kind === "modern-cmdk-codemod-worker";
+}
+if (!isMainThread && parentPort !== null && isWorkerInit(workerData)) {
+	const port = parentPort;
+	const { transform, keepSource } = workerData;
+	const apiForParser = createApiFactory();
+	const loaded = import(
+		/* @vite-ignore */
+		new URL(`./transforms/${transform}.mjs`, import.meta.url).href
+);
+	loaded.catch(() => {});
+	port.on("message", async (path) => {
+		let outcome;
+		try {
+			outcome = await transformFile(path, await loaded, apiForParser, keepSource);
+		} catch (err) {
+			outcome = {
+				path,
+				changed: false,
+				error: `cannot load transform "${transform}": ${err instanceof Error ? err.message : String(err)}`,
+				reports: []
+			};
+		}
+		port.postMessage(outcome);
+	});
+}
+export { findDirtyFiles as i, transformFile as n, discoverFiles as r, createApiFactory as t };