Introduce Manifest wrapper with scriptNames + getMajor helpers

webpro · webpro · commit 6fded2f00f4e · 2026-04-22T08:36:52.000+02:00
diff --git a/packages/knip/src/WorkspaceWorker.ts b/packages/knip/src/WorkspaceWorker.ts
@@ -19,6 +19,7 @@ import type { ConfigurationHint } from './types/issues.ts';
 import type { PluginName } from './types/PluginNames.ts';
 import type { PackageJson } from './types/package-json.ts';
 import type { DependencySet } from './types/workspace.ts';
+import { createManifest, type Manifest } from './util/package-json.ts';
 import { collectStringLiterals, isExternalReExportsOnly } from './typescript/ast-helpers.ts';
 import { parseFile } from './typescript/visitors/helpers.ts';
 import { compact } from './util/array.ts';
@@ -50,7 +51,7 @@ type WorkspaceManagerOptions = {
   config: WorkspaceConfiguration;
   manifest: PackageJson;
   dependencies: DependencySet;
-  rootManifest: PackageJson | undefined;
+  rootManifest: Manifest | undefined;
   handleInput: HandleInput;
   findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
   readFile: (filePath: string) => string;
@@ -80,8 +81,8 @@ export class WorkspaceWorker {
   name: string;
   dir: string;
   config: WorkspaceConfiguration;
-  manifest: PackageJson;
-  rootManifest: PackageJson | undefined;
+  manifest: Manifest;
+  rootManifest: Manifest | undefined;
   dependencies: DependencySet;
   handleInput: HandleInput;
   findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
@@ -118,7 +119,7 @@ export class WorkspaceWorker {
     this.name = name;
     this.dir = dir;
     this.config = config;
-    this.manifest = manifest;
+    this.manifest = createManifest(manifest);
     this.rootManifest = rootManifest;
     this.dependencies = dependencies;
     this.negatedWorkspacePatterns = negatedWorkspacePatterns;
@@ -296,12 +297,11 @@ export class WorkspaceWorker {
     const isProduction = this.options.isProduction;
     const knownBinsOnly = false;
 
-    const manifestScriptNames = new Set(Object.keys(manifest.scripts ?? {}));
     const rootManifest = this.rootManifest;
-    const baseOptions = { manifestScriptNames, rootManifest, cwd, rootCwd, containingFilePath, knownBinsOnly };
+    const baseOptions = { manifest, rootManifest, cwd, rootCwd, containingFilePath, knownBinsOnly };
 
     // Get dependencies from package.json#scripts
-    const baseScriptOptions = { ...baseOptions, manifest, isProduction, enabledPlugins: this.enabledPlugins };
+    const baseScriptOptions = { ...baseOptions, isProduction, enabledPlugins: this.enabledPlugins };
     const [productionScripts, developmentScripts] = getFilteredScripts(manifest.scripts ?? {});
     const inputsFromManifest = _getInputsFromScripts(Object.values(developmentScripts), baseOptions);
     const productionInputsFromManifest = _getInputsFromScripts(Object.values(productionScripts), baseOptions);
diff --git a/packages/knip/src/binaries/plugins.ts b/packages/knip/src/binaries/plugins.ts
@@ -13,7 +13,7 @@ const isGlobLike = (value: string) => isGlobLikeMatch.test(value);
 const nodeLoadersArgs = { import: ['r', 'experimental-loader', 'require', 'loader'] };
 
 export const resolve: BinaryResolver = (binary, _args, options) => {
-  const { cwd, fromArgs, containingFilePath } = options;
+  const { cwd, fromArgs, containingFilePath, manifest } = options;
   const [pluginName, pluginArgs] = pluginArgsMap.get(binary) ?? [];
 
   if (!pluginArgs) return fallbackResolve(binary, _args, options);
@@ -69,7 +69,7 @@ export const resolve: BinaryResolver = (binary, _args, options) => {
   };
   const configFilePaths = config.flatMap(mapToConfigPattern);
 
-  const inputs: Input[] = pluginArgs.resolveInputs?.(parsed, { args, cwd }) ?? [];
+  const inputs: Input[] = pluginArgs.resolveInputs?.(parsed, { args, cwd, manifest }) ?? [];
 
   return [
     toBinary(binary, inputOpts),
diff --git a/packages/knip/src/binaries/resolvers/bun.ts b/packages/knip/src/binaries/resolvers/bun.ts
@@ -62,10 +62,10 @@ export const resolve: BinaryResolver = (_binary, args, options) => {
     return resolveX(argsForX, options);
   }
 
-  const { manifestScriptNames, cwd, fromArgs } = options;
+  const { manifest, cwd, fromArgs } = options;
 
-  if (command === 'run' && manifestScriptNames.has(script)) return [];
-  if (manifestScriptNames.has(command)) return [];
+  if (command === 'run' && manifest.scriptNames.has(script)) return [];
+  if (manifest.scriptNames.has(command)) return [];
   if (command !== 'run' && commands.has(command)) return [];
 
   const filePath = command === 'run' ? script : command;
diff --git a/packages/knip/src/binaries/resolvers/npm.ts b/packages/knip/src/binaries/resolvers/npm.ts
@@ -2,11 +2,11 @@ import parseArgs from 'minimist';
 import type { BinaryResolver } from '../../types/config.ts';
 
 export const resolve: BinaryResolver = (_binary, args, options) => {
-  const { fromArgs, manifestScriptNames } = options;
+  const { fromArgs, manifest } = options;
   const parsed = parseArgs(args, { '--': true });
   const [command, script] = parsed._;
   const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
   if (command === 'exec') return _childArgs;
-  if (command === 'run' && manifestScriptNames.has(script)) return _childArgs;
+  if (command === 'run' && manifest.scriptNames.has(script)) return _childArgs;
   return [];
 };
diff --git a/packages/knip/src/binaries/resolvers/pnpm.ts b/packages/knip/src/binaries/resolvers/pnpm.ts
@@ -80,7 +80,7 @@ export const resolve: BinaryResolver = (_binary, args, options) => {
     return resolveDlx(argsForDlx, options);
   }
 
-  const { manifestScriptNames, fromArgs } = options;
+  const { manifest, fromArgs } = options;
 
   if (parsed.filter && !parsed.recursive) return [];
 
@@ -90,7 +90,7 @@ export const resolve: BinaryResolver = (_binary, args, options) => {
     return childInputs.length > 0 ? childInputs : fromArgs(parsed._.slice(1));
   }
 
-  const isScript = manifestScriptNames.has(command);
+  const isScript = manifest.scriptNames.has(command);
   if (isScript || commands.includes(command)) return childInputs;
 
   return command && isValidBinary(command) ? [toBinary(command)] : [];
diff --git a/packages/knip/src/binaries/resolvers/yarn.ts b/packages/knip/src/binaries/resolvers/yarn.ts
@@ -57,7 +57,7 @@ const resolveDlx = (args: string[], options: BinaryResolverOptions) => {
 };
 
 export const resolve: BinaryResolver = (_binary, args, options) => {
-  const { manifestScriptNames, fromArgs, cwd, rootCwd } = options;
+  const { manifest, fromArgs, cwd, rootCwd } = options;
   const parsed = parseArgs(args, { boolean: ['top-level'], string: ['cwd'], '--': true });
   const dir = parsed['top-level'] ? rootCwd : parsed.cwd ? join(cwd, parsed.cwd) : undefined;
   const [command, binary] = parsed._;
@@ -67,7 +67,7 @@ export const resolve: BinaryResolver = (_binary, args, options) => {
   const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
 
   if (command === 'run') {
-    if (manifestScriptNames.has(binary)) return _childArgs;
+    if (manifest.scriptNames.has(binary)) return _childArgs;
     const bin = toBinary(binary, { optional: true });
     if (dir) Object.assign(bin, { dir });
     return [bin, ..._childArgs];
@@ -80,7 +80,7 @@ export const resolve: BinaryResolver = (_binary, args, options) => {
     return resolveDlx(argsForDlx, options);
   }
 
-  if ((!dir && manifestScriptNames.has(command)) || commands.includes(command)) return _childArgs;
+  if ((!dir && manifest.scriptNames.has(command)) || commands.includes(command)) return _childArgs;
 
   const opts = dir ? { cwd: dir } : {};
   return fromArgs(argsFrom(args, command === 'exec' ? binary : command), opts);
diff --git a/packages/knip/src/graph/build.ts b/packages/knip/src/graph/build.ts
@@ -17,6 +17,7 @@ import type { MainOptions } from '../util/create-options.ts';
 import { debugLog, debugLogArray } from '../util/debug.ts';
 import { existsSync } from 'node:fs';
 import { tryRealpath } from '../util/fs.ts';
+import { createManifest } from '../util/package-json.ts';
 import { _glob, _syncGlob, negate, prependDirToPattern as prependDir } from '../util/glob.ts';
 import {
   type Input,
@@ -75,7 +76,8 @@ export async function build({
 
   const handleInput = createInputHandler(deputy, chief, isGitIgnored, addIssue, externalRefsFromInputs, options);
 
-  const rootManifest = chief.getManifestForWorkspace('.');
+  const rawRootManifest = chief.getManifestForWorkspace('.');
+  const rootManifest = rawRootManifest ? createManifest(rawRootManifest) : undefined;
 
   for (const workspace of workspaces) {
     const { name, dir, manifestPath, manifestStr } = workspace;
@@ -425,16 +427,16 @@ export async function build({
         }
       }
 
-      if (file.scripts && file.scripts.size > 0) {
+      const manifest = chief.getManifestForWorkspace(workspace.name);
+      if (manifest && file.scripts && file.scripts.size > 0) {
         const dependencies = deputy.getDependencies(workspace.name);
-        const manifestScriptNames = new Set(Object.keys(chief.getManifestForWorkspace(workspace.name)?.scripts ?? {}));
         const dir = dirname(filePath);
         const opts = {
           cwd: dir,
           rootCwd: options.cwd,
           containingFilePath: filePath,
           dependencies,
-          manifestScriptNames,
+          manifest: createManifest(manifest),
           rootManifest,
         };
         const inputs = _getInputsFromScripts(file.scripts, opts);
diff --git a/packages/knip/src/plugins/eslint/index.ts b/packages/knip/src/plugins/eslint/index.ts
@@ -33,14 +33,7 @@ const config = [
 const isLoadConfig: IsLoadConfig = ({ configFileName, manifest }, dependencies) => {
   // Flat configs (eslint.config.*) are handled by resolveFromAST — skip loading
   if (isFlatConfig(configFileName)) return false;
-
-  const version = manifest.devDependencies?.['eslint'] || manifest.dependencies?.['eslint'];
-  if (version) {
-    const major = version.match(/\d+/);
-    if (major && Number.parseInt(major[0], 10) === 9 && dependencies.has('eslint-config-next')) {
-      return false;
-    }
-  }
+  if (manifest.getMajor('eslint') === 9 && dependencies.has('eslint-config-next')) return false;
   return true;
 };
 
diff --git a/packages/knip/src/plugins/react-email/index.ts b/packages/knip/src/plugins/react-email/index.ts
@@ -1,9 +1,6 @@
-import { readFileSync } from 'node:fs';
 import type { Args } from '../../types/args.ts';
 import type { IsPluginEnabled, Plugin } from '../../types/config.ts';
-import type { PackageJson } from '../../types/package-json.ts';
 import { toDependency, toEntry } from '../../util/input.ts';
-import { join } from '../../util/path.ts';
 import { hasDependency } from '../../util/plugin.ts';
 
 // https://react.email/docs/cli
@@ -18,21 +15,14 @@ const entry = ['emails/**/*.tsx'];
 
 const previewCommands = new Set(['build', 'dev', 'start']);
 
-const getPreviewDependency = (cwd: string): string => {
-  try {
-    const manifest: PackageJson = JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf8'));
-    const range = manifest.dependencies?.['react-email'] ?? manifest.devDependencies?.['react-email'];
-    const major = range?.match(/\d+/)?.[0];
-    if (major && Number.parseInt(major, 10) >= 6) return '@react-email/ui';
-  } catch {}
-  return '@react-email/preview-server';
-};
-
 const args: Args = {
   binaries: ['email'],
-  resolveInputs: (parsed, { cwd }) => {
+  resolveInputs: (parsed, { manifest }) => {
     const inputs = [];
-    if (previewCommands.has(parsed._[0])) inputs.push(toDependency(getPreviewDependency(cwd)));
+    if (previewCommands.has(parsed._[0])) {
+      const dep = (manifest.getMajor('react-email') ?? 0) >= 6 ? '@react-email/ui' : '@react-email/preview-server';
+      inputs.push(toDependency(dep));
+    }
     if (parsed.dir) inputs.push(toEntry(`${parsed.dir}/**/*.tsx`));
     return inputs;
   },
diff --git a/packages/knip/src/types/args.ts b/packages/knip/src/types/args.ts
@@ -1,5 +1,6 @@
 import type { ParsedArgs } from 'minimist';
 import type { Input } from '../util/input.ts';
+import type { Manifest } from '../util/package-json.ts';
 
 export type ConfigArg = boolean | (string | [string, (id: string) => string])[];
 
@@ -97,5 +98,5 @@ export type Args = {
    *
    * @default undefined
    */
-  resolveInputs?: (parsed: ParsedArgs, options: { cwd: string; args: string[] }) => Input[];
+  resolveInputs?: (parsed: ParsedArgs, options: { cwd: string; args: string[]; manifest: Manifest }) => Input[];
 };
diff --git a/packages/knip/src/types/config.ts b/packages/knip/src/types/config.ts
@@ -5,6 +5,7 @@ import type { knipConfigurationSchema, workspaceConfigurationSchema } from '../s
 import type { pluginSchema } from '../schema/plugins.ts';
 import type { ParsedCLIArgs } from '../util/cli-arguments.ts';
 import type { Input } from '../util/input.ts';
+import type { Manifest } from '../util/package-json.ts';
 import type { Args } from './args.ts';
 import type { IssueType, SymbolType } from './issues.ts';
 import type { Tags } from './options.ts';
@@ -102,21 +103,20 @@ export interface WorkspaceConfiguration extends BaseWorkspaceConfiguration, Part
 interface BaseOptions {
   rootCwd: string;
   cwd: string;
-  manifestScriptNames: Set<string>;
-  rootManifest: PackageJson | undefined;
+  manifest: Manifest;
+  rootManifest: Manifest | undefined;
 }
 
 type IsPluginEnabledOptions = {
   cwd: string;
-  manifest: PackageJson;
+  manifest: Manifest;
   dependencies: Set<string>;
   config: WorkspaceConfiguration;
 };
 
 export type IsPluginEnabled = (options: IsPluginEnabledOptions) => boolean | Promise<boolean>;
 
 export interface PluginOptions extends BaseOptions {
-  manifest: PackageJson;
   config: EnsuredPluginConfiguration;
   configFileDir: string;
   configFileName: string;
@@ -138,10 +138,10 @@ export type SourceMap = { srcDir: string; outDir: string };
 
 export interface ResolveSourceMapOptions {
   cwd: string;
-  manifest: PackageJson;
+  manifest: Manifest;
   dependencies: Set<string>;
   rootCwd: string;
-  rootManifest: PackageJson | undefined;
+  rootManifest: Manifest | undefined;
 }
 
 export type ResolveSourceMap = (options: ResolveSourceMapOptions) => Promise<SourceMap[]> | SourceMap[];
diff --git a/packages/knip/src/util/package-json.ts b/packages/knip/src/util/package-json.ts
@@ -92,6 +92,22 @@ export const getEntrySpecifiersFromManifest = (manifest: PackageJson) => {
   return entryPaths;
 };
 
+export type Manifest = PackageJson & {
+  scriptNames: Set<string>;
+  getMajor: (name: string) => number | undefined;
+};
+
+export const createManifest = (raw: PackageJson): Manifest =>
+  Object.assign(raw, {
+    ...raw,
+    scriptNames: new Set(Object.keys(raw.scripts ?? {})),
+    getMajor(name: string) {
+      const range = raw.dependencies?.[name] ?? raw.devDependencies?.[name];
+      const match = range?.match(/\d+/)?.[0];
+      return match ? Number.parseInt(match, 10) : undefined;
+    },
+  });
+
 export const getManifestImportDependencies = (manifest: PackageJson) => {
   const dependencies = new Set<string>();
   if (!manifest.imports) return dependencies;
diff --git a/packages/knip/test/util/get-inputs-from-scripts.test.ts b/packages/knip/test/util/get-inputs-from-scripts.test.ts
@@ -4,25 +4,28 @@ import assert from 'node:assert/strict';
 import test from 'node:test';
 import { _getInputsFromScripts } from '../../src/binaries/index.ts';
 import { type Input, toBinary, toConfig, toDeferResolve, toDeferResolveEntry, toDependency, toEntry } from '../../src/util/input.ts';
+import { createManifest } from '../../src/util/package-json.ts';
 import { join } from '../../src/util/path.ts';
 import { resolve } from '../helpers/resolve.ts';
 
 const cwd = resolve('fixtures/binaries');
 const containingFilePath = join(cwd, 'package.json');
-const pkgScripts = { cwd, manifestScriptNames: new Set(['program', 'spl:t']) };
+const toManifest = (scriptNames: string[] = []) =>
+  createManifest({ scripts: Object.fromEntries(scriptNames.map(name => [name, ''])) });
+const pkgScripts = { cwd, manifest: toManifest(['program', 'spl:t']) };
 const knownOnly = { cwd, knownBinsOnly: true };
 const opt = { optional: true };
 
 const js = toDeferResolveEntry('./script.js', opt);
 const ts = toDeferResolveEntry('./main.ts', opt);
 const req = toDeferResolve('./require.js');
 
-type T = (script: string | string[], dependencies: Input[], options?: { cwd?: string; manifestScriptNames?: Set<string> }) => void;
+type T = (script: string | string[], dependencies: Input[], options?: { cwd?: string; manifest?: ReturnType<typeof toManifest> }) => void;
 const t: T = (script, dependencies = [], options = { cwd }) =>
   assert.deepEqual(
     _getInputsFromScripts(script, {
       rootCwd: cwd,
-      manifestScriptNames: new Set(),
+      manifest: toManifest(),
       containingFilePath,
       ...options,
     }),
@@ -227,7 +230,7 @@ test('getInputsFromScripts (pnpx/pnpm dlx)', () => {
   t('pnpx --package cowsay --package lolcatjs -c \'echo "hi pnpm" | cowsay | lolcatjs\'', inputs);
   t('pnpm --package cowsay --package lolcatjs -c dlx \'echo "hi pnpm" | cowsay | lolcatjs\'', inputs);
   t('pnpm --recursive --parallel exec program', [toBinary('program')]);
-  t('pnpm --recursive --parallel exec program', [toBinary('program')], { manifestScriptNames: new Set(['program']) });
+  t('pnpm --recursive --parallel exec program', [toBinary('program')], { manifest: toManifest(['program']) });
 });
 
 test('getInputsFromScripts (yarn)', () => {

Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ export const resolve: BinaryResolver = (_binary, args, options) => {`
`80`	`80`	`return resolveDlx(argsForDlx, options);`
`81`	`81`	`}`
`82`	`82`
`83`		`- const { manifestScriptNames, fromArgs } = options;`
	`83`	`+ const { manifest, fromArgs } = options;`
`84`	`84`
`85`	`85`	`if (parsed.filter && !parsed.recursive) return [];`
`86`	`86`
`@@ -90,7 +90,7 @@ export const resolve: BinaryResolver = (_binary, args, options) => {`
`90`	`90`	`return childInputs.length > 0 ? childInputs : fromArgs(parsed._.slice(1));`
`91`	`91`	`}`
`92`	`92`
`93`		`- const isScript = manifestScriptNames.has(command);`
	`93`	`+ const isScript = manifest.scriptNames.has(command);`
`94`	`94`	`if (isScript \|\| commands.includes(command)) return childInputs;`
`95`	`95`
`96`	`96`	`return command && isValidBinary(command) ? [toBinary(command)] : [];`