@lablup/ui-common-cli 0.2.0-alpha.15

package/cli/paths.mjs

@@ -0,0 +1,290 @@
+/**
+ * Where things live. Two packages are involved, and they are found apart:
+ *
+ * - The CLI's own package, @lablup/ui-common-cli: the Astryx CLI it pins,
+ *   jscodeshift, the codemods and the migration map.
+ * - The @lablup/ui-common package the CLI works for: its version, its export
+ *   lists (exports.exclude.json, exports.customs.json) and the Astryx packages
+ *   it pins (core, theme-neutral, lab). A consumer depends on ui-common, so
+ *   under pnpm's isolated layout those are reachable from ui-common's install
+ *   location and not from the consumer's own directory.
+ *
+ * Nothing is resolved from the working directory except the project's own
+ * @lablup/ui-common.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+export const UI_COMMON = "@lablup/ui-common";
+
+/** Root of the installed @lablup/ui-common-cli package. */
+export const CLI_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+/** @param {string} file */
+export function readJson(file) {
+  return JSON.parse(readFileSync(file, "utf8"));
+}
+
+/** @returns {{name: string, version: string, dependencies?: Record<string,string>, peerDependencies?: Record<string,string>}} */
+export function cliPackageJson() {
+  return readJson(join(CLI_ROOT, "package.json"));
+}
+
+/**
+ * The @lablup/ui-common package root `fromDir` resolves, or null. Its
+ * `exports` map lists `./package.json`, so this works from a consumer, from
+ * the CLI package (its peer) and, by self-reference, from this repository.
+ *
+ * @param {string} fromDir
+ */
+function resolveUiCommonFrom(fromDir) {
+  try {
+    const req = createRequire(join(fromDir, "package.json"));
+    return dirname(req.resolve(`${UI_COMMON}/package.json`));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Root of the @lablup/ui-common a command works on: the project's own install
+ * first, so the CLI reads the ui-common the project actually has, then the one
+ * beside the CLI (its peer, which a `pnpm dlx` run installs).
+ *
+ * @param {string} [cwd]
+ */
+export function uiCommonRoot(cwd = process.cwd()) {
+  const project = findProjectDir(cwd);
+  const dir =
+    (project && resolveUiCommonFrom(project)) ?? resolveUiCommonFrom(CLI_ROOT);
+  if (!dir) {
+    throw new Error(
+      `${UI_COMMON} is not installed. Add it to the project (the CLI is @lablup/ui-common-cli, a devDependency next to it).`,
+    );
+  }
+  return dir;
+}
+
+/**
+ * Root of the @lablup/ui-common this CLI release ships with: its peer, at the
+ * same version. `upgrade` reads its target's pins from here, since the project
+ * may still be on the version it is upgrading from. Falls back to the
+ * project's when the peer is not reachable from the CLI.
+ *
+ * @param {string} [cwd]
+ */
+export function targetUiCommonRoot(cwd = process.cwd()) {
+  return resolveUiCommonFrom(CLI_ROOT) ?? uiCommonRoot(cwd);
+}
+
+/**
+ * package.json of the @lablup/ui-common a command works on (see uiCommonRoot).
+ *
+ * @param {string} [root]
+ * @returns {{name: string, version: string, dependencies?: Record<string,string>, peerDependencies?: Record<string,string>, devDependencies?: Record<string,string>}}
+ */
+export function uiCommonPackageJson(root = uiCommonRoot()) {
+  return readJson(join(root, "package.json"));
+}
+
+/** Walk up from a resolved file to the directory holding its package.json. */
+function packageDirOf(file, name) {
+  let dir = dirname(file);
+  for (;;) {
+    const pkg = join(dir, "package.json");
+    if (existsSync(pkg)) {
+      try {
+        if (readJson(pkg).name === name) return dir;
+      } catch {
+        // keep walking
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+/**
+ * The directory of a package as `fromDir` resolves it, or null. Resolution
+ * goes through the package's main entry, because not every Astryx package
+ * exports its package.json.
+ *
+ * @param {string} name
+ * @param {string} fromDir
+ */
+function packageDirFrom(name, fromDir) {
+  try {
+    const req = createRequire(join(fromDir, "package.json"));
+    return packageDirOf(req.resolve(name), name);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The directory of a dependency of @lablup/ui-common (an Astryx package it
+ * pins), or null.
+ *
+ * @param {string} name
+ * @param {string} [root] the ui-common root to resolve from
+ */
+export function dependencyDir(name, root) {
+  let from = root;
+  if (!from) {
+    try {
+      from = uiCommonRoot();
+    } catch {
+      return null;
+    }
+  }
+  return packageDirFrom(name, from);
+}
+
+/**
+ * The directory of a dependency of the CLI package itself, or null.
+ *
+ * @param {string} name
+ */
+export function cliDependencyDir(name) {
+  return packageDirFrom(name, CLI_ROOT);
+}
+
+/** Root of the exact-pinned @astryxdesign/cli. */
+export function astryxCliRoot() {
+  const dir = cliDependencyDir("@astryxdesign/cli");
+  if (!dir) {
+    throw new Error(
+      "@astryxdesign/cli is not installed next to @lablup/ui-common-cli. Reinstall @lablup/ui-common-cli.",
+    );
+  }
+  return dir;
+}
+
+/** The `astryx` bin script of the pinned CLI. */
+export function astryxBin() {
+  const root = astryxCliRoot();
+  const bin = readJson(join(root, "package.json")).bin?.astryx;
+  return join(root, bin ?? "clients/cli/bin/astryx.mjs");
+}
+
+/**
+ * Import a module file from inside the pinned Astryx CLI. These are internals,
+ * not the CLI's public API; the pin is exact and `sync-astryx` re-runs the
+ * tests that use them on every bump.
+ *
+ * @param {string} relative path under the CLI root
+ */
+export async function importAstryxInternal(relative) {
+  const file = join(astryxCliRoot(), relative);
+  return import(pathToFileURL(file).href);
+}
+
+/**
+ * Version of an installed dependency of ui-common, or null.
+ *
+ * @param {string} name
+ * @param {string} [root] the ui-common root to resolve from
+ */
+export function dependencyVersion(name, root) {
+  const dir = dependencyDir(name, root);
+  return dir ? readJson(join(dir, "package.json")).version : null;
+}
+
+/**
+ * Version of an installed dependency of the CLI package, or null.
+ *
+ * @param {string} name
+ */
+export function cliDependencyVersion(name) {
+  const dir = cliDependencyDir(name);
+  return dir ? readJson(join(dir, "package.json")).version : null;
+}
+
+/** `exports.exclude.json`: Astryx subpaths ui-common hides, with replacements. */
+export function excludedExports(root = uiCommonRoot()) {
+  const file = join(root, "exports.exclude.json");
+  if (!existsSync(file)) return [];
+  return /** @type {Array<{name: string, exports?: string[], replacedBy: string|null, reason: string}>} */ (
+    readJson(file)
+  );
+}
+
+/** `exports.customs.json`: ui-common's own exports. */
+export function customExports(root = uiCommonRoot()) {
+  const file = join(root, "exports.customs.json");
+  if (!existsSync(file)) return [];
+  return /** @type {Array<{name: string, source: string, subpath?: string, fork?: string, legacy?: object}>} */ (
+    readJson(file)
+  );
+}
+
+/**
+ * ui-common's own copies of Astryx components (src/forks/): same names and
+ * import paths as Astryx's, which exports.exclude.json hides. `names` are the
+ * names a reader may meet it by; `from` is where a consumer imports it.
+ *
+ * @returns {Array<{name: string, from: string, names: string[], reason: string}>}
+ */
+export function forkedExports() {
+  const exclusions = excludedExports();
+  return customExports()
+    .filter((c) => c.fork !== undefined)
+    .map((c) => {
+      const exclusion = exclusions.find((e) => e.replacedBy === c.name);
+      return {
+        name: c.name,
+        from: `@lablup/ui-common/${c.subpath ?? exclusion?.name ?? ""}`,
+        names: exclusion?.exports ?? [c.name],
+        reason: exclusion?.reason ?? "",
+      };
+    });
+}
+
+/**
+ * The exclusions that hide an Astryx name behind a different one. A fork's
+ * exclusion is not one: the name stays, now ui-common's.
+ */
+export function hiddenExports() {
+  const forks = new Set(forkedExports().map((f) => f.name));
+  return excludedExports().filter(
+    (e) => e.replacedBy === null || !forks.has(e.replacedBy),
+  );
+}
+
+/**
+ * The nearest directory at or above `start` holding a package.json.
+ *
+ * @param {string} start
+ */
+export function findProjectDir(start) {
+  let dir = resolve(start);
+  for (;;) {
+    if (existsSync(join(dir, "package.json"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+/**
+ * How this project runs a locally installed bin, from its lockfile.
+ *
+ * @param {string} projectDir
+ */
+export function binInvocation(projectDir, bin = "ui-common") {
+  let dir = resolve(projectDir);
+  for (;;) {
+    if (existsSync(join(dir, "pnpm-lock.yaml"))) return `pnpm exec ${bin}`;
+    if (existsSync(join(dir, "yarn.lock"))) return `yarn ${bin}`;
+    if (existsSync(join(dir, "bun.lock")) || existsSync(join(dir, "bun.lockb"))) {
+      return `bunx ${bin}`;
+    }
+    if (existsSync(join(dir, "package-lock.json"))) return `npx ${bin}`;
+    const parent = dirname(dir);
+    if (parent === dir) return `npx ${bin}`;
+    dir = parent;
+  }
+}

package/cli/report.mjs

@@ -0,0 +1,157 @@
+/**
+ * `ui-common-upgrade-report.md`: what `ui-common upgrade` changed, and what it
+ * left for a person. Deterministic (no timestamps), so a report can be
+ * committed and diffed between runs.
+ */
+
+/** The report's first line; `ui-common upgrade` overwrites only a file that starts with it. */
+export const REPORT_HEADING = "# ui-common upgrade report";
+
+/** @param {string} text */
+function code(text) {
+  const ticks = text.includes("`") ? "``" : "`";
+  const pad = text.startsWith("`") || text.endsWith("`") ? " " : "";
+  return `${ticks}${pad}${text}${pad}${ticks}`;
+}
+
+/** @param {string} text */
+function escapeCell(text) {
+  return text.replace(/\|/g, "\\|");
+}
+
+/**
+ * @param {object} data
+ * @param {string} data.from
+ * @param {string} data.to
+ * @param {string} data.version installed ui-common
+ * @param {boolean} data.dryRun
+ * @param {string[]} data.roots
+ * @param {number} data.fileCount
+ * @param {string[]} [data.scanRoots] where the manual-review scan looked
+ * @param {number} [data.scanCount]
+ * @param {Array<{version: string, title: string, notes: string[]}>} data.steps
+ * @param {Array<{file: string, created: boolean, transforms: string[], added: number, removed: number}>} data.changed
+ * @param {{changed: boolean, notes: string[]}} data.packageJson
+ * @param {Array<{file: string, line: number, text: string}>} data.todos
+ * @param {Array<{category: string, file: string, line: number, text: string, detail?: string}>} data.findings
+ * @param {Record<string, {title: string, help: string}>} data.categories
+ * @param {Array<{file: string, transform: string, error: string}>} data.errors
+ * @param {string[]} [data.notices] where the run did something other than the usual
+ * @param {string[]} [data.alerts] what has to be done before the app works; first in the report
+ * @param {number} data.tokenReads
+ */
+export function renderReport(data) {
+  const out = [];
+  out.push(REPORT_HEADING, "");
+  out.push(
+    `\`ui-common upgrade\` ${data.from} → ${data.to} (@lablup/ui-common-cli ${data.version})` +
+      `${data.dryRun ? ", **dry run: nothing was written**" : ""}.`,
+    "",
+    `Ran the codemods over ${data.fileCount} file${data.fileCount === 1 ? "" : "s"} under ${data.roots.map(code).join(", ")}` +
+      (data.scanRoots
+        ? `; searched ${data.scanCount ?? 0} file${data.scanCount === 1 ? "" : "s"} under ${data.scanRoots.map((r) => (r === "." ? "the project root" : code(r))).join(", ")} for manual-review findings.`
+        : "."),
+    "",
+  );
+
+  if (data.alerts && data.alerts.length > 0) {
+    out.push("## Action required", "");
+    for (const alert of data.alerts) out.push(`- ${alert}`);
+    out.push("");
+  }
+
+  const manual = data.findings.length;
+  out.push("## Summary", "");
+  out.push("| | Count |", "|---|---:|");
+  out.push(
+    `| Files ${data.dryRun ? "that would change" : "changed"} | ${data.changed.length} |`,
+  );
+  out.push(
+    `| package.json ${data.dryRun ? "would change" : "changed"} | ${data.packageJson.changed ? "yes" : "no"} |`,
+  );
+  out.push(`| TODO markers left in code | ${data.todos.length} |`);
+  out.push(`| Manual-review findings | ${manual} |`);
+  if (data.errors.length > 0)
+    out.push(`| Files the codemods could not transform | ${data.errors.length} |`);
+  out.push("");
+
+  out.push("## Steps", "");
+  for (const step of data.steps) out.push(`- ${step.version}: ${step.title}`);
+  out.push("");
+
+  if (data.errors.length > 0) {
+    out.push(
+      "## Errors",
+      "",
+      "These files were left as they were. Migrate them by hand.",
+      "",
+    );
+    for (const e of data.errors)
+      out.push(`- ${code(e.file)} (${e.transform}): ${e.error}`);
+    out.push("");
+  }
+
+  out.push(`## ${data.dryRun ? "Files that would change" : "Changed files"}`, "");
+  if (data.changed.length === 0) out.push("None.");
+  for (const c of data.changed) {
+    out.push(
+      `- ${code(c.file)}${c.created ? " (new)" : ""}: +${c.added} −${c.removed}, ${c.transforms.join(", ")}`,
+    );
+  }
+  out.push("");
+
+  out.push("## package.json", "");
+  if (data.packageJson.notes.length === 0) out.push("No change.");
+  for (const note of data.packageJson.notes) out.push(`- ${note}`);
+  out.push("");
+
+  out.push("## Manual review", "");
+  out.push(`### TODO markers (${data.todos.length})`, "");
+  if (data.todos.length === 0) {
+    out.push("None.", "");
+  } else {
+    out.push(
+      "Each is a `TODO(ui-common-upgrade)` comment in the code, above the call it is about. Resolve it, then delete the comment.",
+      "",
+    );
+    for (const t of data.todos) out.push(`- ${code(`${t.file}:${t.line}`)} ${t.text}`);
+    out.push("");
+  }
+
+  const byCategory = new Map();
+  for (const f of data.findings) {
+    const list = byCategory.get(f.category) ?? [];
+    list.push(f);
+    byCategory.set(f.category, list);
+  }
+  for (const [category, meta] of Object.entries(data.categories)) {
+    const list = byCategory.get(category) ?? [];
+    out.push(`### ${meta.title} (${list.length})`, "");
+    if (list.length === 0) {
+      out.push("None.", "");
+      continue;
+    }
+    out.push(meta.help, "");
+    out.push("| Where | What | Detail |", "|---|---|---|");
+    for (const f of list) {
+      out.push(
+        `| ${code(`${f.file}:${f.line}`)} | ${escapeCell(code(f.text.length > 120 ? `${f.text.slice(0, 117)}...` : f.text))} | ${escapeCell(f.detail ?? "")} |`,
+      );
+    }
+    out.push("");
+  }
+
+  const notes = [...(data.notices ?? []), ...data.steps.flatMap((s) => s.notes)];
+  if (notes.length > 0 || data.tokenReads > 0) {
+    out.push("## Notes", "");
+    for (const note of notes) out.push(`- ${note}`);
+    if (data.tokenReads > 0) {
+      out.push(
+        `- ${data.tokenReads} \`var(--token-*)\` read${data.tokenReads === 1 ? "" : "s"} left as they are. \`@lablup/ui-common/legacy-tokens.css\` declares the 0.1 names (deprecated, removed in 0.3).`,
+      );
+    }
+    out.push("");
+  }
+
+  return `${out.join("\n").replace(/\n+$/, "")}\n`;
+}

package/cli/resolve.mjs

@@ -0,0 +1,257 @@
+/**
+ * Resolve a project's own import specifiers to files, the way its bundler
+ * would for the common cases: relative paths, and the `paths` / `baseUrl`
+ * aliases its tsconfig declares (`@/components/common`). A specifier that
+ * resolves neither way and is not an installed package is recorded as an
+ * unresolved alias (a Vite `resolve.alias`, say), for the report.
+ *
+ * Only what `ui-common upgrade` needs: file-to-file resolution inside the
+ * project. Packages are never resolved.
+ */
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { builtinModules } from "node:module";
+import { dirname, join, resolve } from "node:path";
+
+const SCRIPT_EXTENSIONS = [
+  ".tsx",
+  ".ts",
+  ".jsx",
+  ".js",
+  ".mts",
+  ".mjs",
+  ".cts",
+  ".cjs",
+];
+
+/**
+ * JSON with comments and trailing commas, as tsconfig allows.
+ *
+ * @param {string} text
+ */
+export function parseJsonc(text) {
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === '"') {
+      const start = i;
+      for (i++; i < text.length && text[i] !== '"'; i++) if (text[i] === "\\") i++;
+      out += text.slice(start, i + 1);
+    } else if (ch === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i++;
+      out += "\n";
+    } else if (ch === "/" && text[i + 1] === "*") {
+      const end = text.indexOf("*/", i + 2);
+      i = end === -1 ? text.length : end + 1;
+    } else out += ch;
+  }
+  return JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+}
+
+/** @param {string} path */
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * The file an import of `base` (no extension, or a `.js` one standing for a
+ * `.ts` source) loads: `base` itself, `base.<ext>`, or `base/index.<ext>`.
+ *
+ * @param {string} base absolute
+ */
+export function resolveFile(base) {
+  if (isFile(base) && SCRIPT_EXTENSIONS.some((e) => base.endsWith(e))) return base;
+  for (const ext of SCRIPT_EXTENSIONS)
+    if (isFile(`${base}${ext}`)) return `${base}${ext}`;
+  const js = /\.(m|c)?jsx?$/.exec(base);
+  if (js) {
+    const stem = base.slice(0, js.index);
+    for (const ext of SCRIPT_EXTENSIONS)
+      if (isFile(`${stem}${ext}`)) return `${stem}${ext}`;
+  }
+  for (const ext of SCRIPT_EXTENSIONS) {
+    const index = join(base, `index${ext}`);
+    if (isFile(index)) return index;
+  }
+  return null;
+}
+
+/**
+ * `compilerOptions` of a tsconfig, merged over what it extends (relative
+ * `extends` only), with `paths` and `baseUrl` made absolute.
+ *
+ * @param {string} file
+ * @param {Set<string>} [seen]
+ * @returns {{baseUrl?: string, paths?: Record<string, string[]>, pathsBase?: string}}
+ */
+function readTsconfig(file, seen = new Set()) {
+  if (seen.has(file) || !isFile(file)) return {};
+  seen.add(file);
+  let json;
+  try {
+    json = parseJsonc(readFileSync(file, "utf8"));
+  } catch {
+    return {};
+  }
+  const dir = dirname(file);
+  /** @type {{baseUrl?: string, paths?: Record<string, string[]>, pathsBase?: string}} */
+  let merged = {};
+  const parents = Array.isArray(json.extends) ? json.extends : [json.extends];
+  for (const parent of parents) {
+    if (typeof parent !== "string" || !parent.startsWith(".")) continue;
+    const target = resolve(dir, parent);
+    merged = {
+      ...merged,
+      ...readTsconfig(target.endsWith(".json") ? target : `${target}.json`, seen),
+    };
+  }
+  const options = json.compilerOptions ?? {};
+  if (typeof options.baseUrl === "string")
+    merged.baseUrl = resolve(dir, options.baseUrl);
+  if (options.paths && typeof options.paths === "object") {
+    merged.paths = options.paths;
+    merged.pathsBase = merged.baseUrl ?? dir;
+  } else if (merged.paths && typeof options.baseUrl === "string") {
+    merged.pathsBase = merged.baseUrl;
+  }
+  return merged;
+}
+
+/**
+ * Every tsconfig of the project that may declare aliases: `tsconfig.json`,
+ * the configs it references, and the usual Vite split (`tsconfig.app.json`).
+ *
+ * @param {string} projectDir
+ */
+function projectTsconfigs(projectDir) {
+  const root = join(projectDir, "tsconfig.json");
+  const files = [root, join(projectDir, "tsconfig.app.json")];
+  try {
+    const json = parseJsonc(readFileSync(root, "utf8"));
+    for (const ref of json.references ?? []) {
+      if (typeof ref?.path !== "string") continue;
+      const target = resolve(projectDir, ref.path);
+      files.push(target.endsWith(".json") ? target : join(target, "tsconfig.json"));
+    }
+  } catch {
+    // No tsconfig, or one this cannot read: relative imports only.
+  }
+  return [...new Set(files)].filter(isFile);
+}
+
+/** @param {string} specifier */
+function packageName(specifier) {
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+
+const BUILTINS = new Set(builtinModules);
+
+/**
+ * @param {string} projectDir
+ */
+export function createResolver(projectDir) {
+  const configs = projectTsconfigs(projectDir).map((f) => readTsconfig(f));
+  /** @type {Array<{prefix: string, suffix: string, wildcard: boolean, targets: string[]}>} */
+  const aliases = [];
+  /** @type {string[]} */
+  const baseUrls = [];
+  for (const config of configs) {
+    if (config.baseUrl) baseUrls.push(config.baseUrl);
+    if (!config.paths || !config.pathsBase) continue;
+    for (const [pattern, targets] of Object.entries(config.paths)) {
+      if (!Array.isArray(targets)) continue;
+      const star = pattern.indexOf("*");
+      aliases.push({
+        prefix: star === -1 ? pattern : pattern.slice(0, star),
+        suffix: star === -1 ? "" : pattern.slice(star + 1),
+        wildcard: star !== -1,
+        targets: targets.map((t) =>
+          resolve(/** @type {string} */ (config.pathsBase), t),
+        ),
+      });
+    }
+  }
+  // Longest prefix first, as TypeScript matches.
+  aliases.sort((a, b) => b.prefix.length - a.prefix.length);
+
+  /** @type {Map<string, boolean>} */
+  const installed = new Map();
+  /** @param {string} name */
+  const isInstalled = (name) => {
+    let hit = installed.get(name);
+    if (hit !== undefined) return hit;
+    hit = false;
+    for (let dir = projectDir; ;) {
+      if (existsSync(join(dir, "node_modules", name))) {
+        hit = true;
+        break;
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    installed.set(name, hit);
+    return hit;
+  };
+
+  /** Alias-like specifiers nothing resolved, by their first segment. @type {Map<string, number>} */
+  const unresolved = new Map();
+
+  /**
+   * @param {string} fromFile absolute
+   * @param {string} specifier
+   * @param {{probe?: boolean}} [options] probe: a lookup that records no miss
+   * @returns {string | null}
+   */
+  function resolveImport(fromFile, specifier, { probe = false } = {}) {
+    if (specifier.startsWith(".") || specifier.startsWith("/")) {
+      return resolveFile(resolve(dirname(fromFile), specifier));
+    }
+    if (specifier.includes(":") || BUILTINS.has(packageName(specifier))) return null;
+    let aliased = false;
+    for (const alias of aliases) {
+      let rest;
+      if (alias.wildcard) {
+        if (!specifier.startsWith(alias.prefix) || !specifier.endsWith(alias.suffix))
+          continue;
+        rest = specifier.slice(
+          alias.prefix.length,
+          specifier.length - alias.suffix.length,
+        );
+      } else if (specifier !== alias.prefix) continue;
+      aliased = true;
+      for (const target of alias.targets) {
+        const hit = resolveFile(
+          rest === undefined ? target : target.replace("*", rest),
+        );
+        if (hit) return hit;
+      }
+    }
+    // A tsconfig alias to a stylesheet or JSON file: resolved, just not a script.
+    if (aliased) return null;
+    const name = packageName(specifier);
+    if (isInstalled(name)) return null;
+    for (const base of baseUrls) {
+      const hit = resolveFile(join(base, specifier));
+      if (hit) return hit;
+    }
+    if (probe) return null;
+    // Only what looks like an alias is worth reporting: a bare name that is
+    // not installed is as likely a package this checkout has not installed.
+    const first = specifier.split("/")[0];
+    if (
+      (/^[@~#$]/.test(specifier) && !/^@[\w-]/.test(specifier)) ||
+      existsSync(join(projectDir, first))
+    ) {
+      const key = `${first}/`;
+      unresolved.set(key, (unresolved.get(key) ?? 0) + 1);
+    }
+    return null;
+  }
+
+  return { resolveImport, unresolved };
+}