knip 6.6.0 → 6.6.1

package/dist/WorkspaceWorker.d.ts

@@ -5,6 +5,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 { type Manifest } from './util/package-json.ts';
 import type { MainOptions } from './util/create-options.ts';
 import { type Input } from './util/input.ts';
 type WorkspaceManagerOptions = {
@@ -13,7 +14,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;
@@ -32,8 +33,8 @@ export declare 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;

package/dist/WorkspaceWorker.js

@@ -5,6 +5,7 @@ import { isDefaultPattern } from './ConfigurationChief.js';
 import { DEFAULT_EXTENSIONS, ROOT_WORKSPACE_NAME } from './constants.js';
 import { getFilteredScripts } from './manifest/helpers.js';
 import { PluginEntries, Plugins } from './plugins.js';
+import { createManifest } from './util/package-json.js';
 import { collectStringLiterals, isExternalReExportsOnly } from './typescript/ast-helpers.js';
 import { parseFile } from './typescript/visitors/helpers.js';
 import { compact } from './util/array.js';
@@ -42,7 +43,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;
@@ -207,10 +208,9 @@ export class WorkspaceWorker {
         const containingFilePath = join(cwd, 'package.json');
         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 baseScriptOptions = { ...baseOptions, manifest, isProduction, enabledPlugins: this.enabledPlugins };
+        const baseOptions = { manifest, rootManifest, cwd, rootCwd, containingFilePath, knownBinsOnly };
+        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);

package/dist/binaries/plugins.js

@@ -9,7 +9,7 @@ const isGlobLikeMatch = /(^!|[*+\\(|{^$])/;
 const isGlobLike = (value) => isGlobLikeMatch.test(value);
 const nodeLoadersArgs = { import: ['r', 'experimental-loader', 'require', 'loader'] };
 export const resolve = (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);
@@ -59,7 +59,7 @@ export const resolve = (binary, _args, options) => {
         return parsed[id] && pluginName ? [toConfig(pluginName, fn(parsed[id]), inputOpts)] : [];
     };
     const configFilePaths = config.flatMap(mapToConfigPattern);
-    const inputs = pluginArgs.resolveInputs?.(parsed, { args, cwd }) ?? [];
+    const inputs = pluginArgs.resolveInputs?.(parsed, { args, cwd, manifest }) ?? [];
     return [
         toBinary(binary, inputOpts),
         ...positionals,

package/dist/binaries/resolvers/bun.js

@@ -57,10 +57,10 @@ export const resolve = (_binary, args, options) => {
         const argsForX = args.filter(arg => arg !== 'x');
         return resolveX(argsForX, options);
     }
-    const { manifestScriptNames, cwd, fromArgs } = options;
-    if (command === 'run' && manifestScriptNames.has(script))
+    const { manifest, cwd, fromArgs } = options;
+    if (command === 'run' && manifest.scriptNames.has(script))
         return [];
-    if (manifestScriptNames.has(command))
+    if (manifest.scriptNames.has(command))
         return [];
     if (command !== 'run' && commands.has(command))
         return [];

package/dist/binaries/resolvers/npm.js

@@ -1,12 +1,12 @@
 import parseArgs from 'minimist';
 export const resolve = (_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))
+    if (command === 'run' && manifest.scriptNames.has(script))
         return _childArgs;
     return [];
 };

package/dist/binaries/resolvers/pnpm.js

@@ -73,14 +73,14 @@ export const resolve = (_binary, args, options) => {
         const argsForDlx = args.filter(arg => arg !== 'dlx');
         return resolveDlx(argsForDlx, options);
     }
-    const { manifestScriptNames, fromArgs } = options;
+    const { manifest, fromArgs } = options;
     if (parsed.filter && !parsed.recursive)
         return [];
     const childInputs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
     if (command === 'exec') {
         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)] : [];

package/dist/binaries/resolvers/yarn.js

@@ -49,7 +49,7 @@ const resolveDlx = (args, options) => {
     return [...packages.map(id => toDependency(id)), ...command].map(id => isDependency(id) || isBinary(id) ? Object.assign(id, { optional: true }) : id);
 };
 export const resolve = (_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._;
@@ -57,7 +57,7 @@ export const resolve = (_binary, args, options) => {
         return [];
     const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
     if (command === 'run') {
-        if (manifestScriptNames.has(binary))
+        if (manifest.scriptNames.has(binary))
             return _childArgs;
         const bin = toBinary(binary, { optional: true });
         if (dir)
@@ -70,7 +70,7 @@ export const resolve = (_binary, args, options) => {
         const argsForDlx = args.filter(arg => arg !== 'dlx');
         return resolveDlx(argsForDlx, options);
     }
-    if ((!dir && manifestScriptNames.has(command)) || commands.includes(command))
+    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);

package/dist/graph/build.js

@@ -6,6 +6,7 @@ import { createInputHandler } from '../util/create-input-handler.js';
 import { debugLog, debugLogArray } from '../util/debug.js';
 import { existsSync } from 'node:fs';
 import { tryRealpath } from '../util/fs.js';
+import { createManifest } from '../util/package-json.js';
 import { _glob, _syncGlob, negate, prependDirToPattern as prependDir } from '../util/glob.js';
 import { isAlias, isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isIgnore, isProductionEntry, isProject, toProductionEntry, } from '../util/input.js';
 import { loadTSConfig } from '../util/load-tsconfig.js';
@@ -24,7 +25,8 @@ export async function build({ chief, collector, counselor, deputy, principal, is
     const addIssue = (issue) => collector.addIssue(issue) && options.isWatch && collector.retainIssue(issue);
     const externalRefsFromInputs = options.isSession ? new Map() : undefined;
     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;
         const manifest = chief.getManifestForWorkspace(name);
@@ -330,16 +332,16 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                     }
                 }
             }
-            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);

package/dist/plugins/eslint/index.js

@@ -17,13 +17,8 @@ const config = [
 const isLoadConfig = ({ configFileName, manifest }, dependencies) => {
     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;
 };
 const resolveConfig = (localConfig, options) => getInputs(localConfig, options);

package/dist/plugins/react-email/index.js

@@ -7,10 +7,12 @@ const entry = ['emails/**/*.tsx'];
 const previewCommands = new Set(['build', 'dev', 'start']);
 const args = {
     binaries: ['email'],
-    resolveInputs: parsed => {
+    resolveInputs: (parsed, { manifest }) => {
         const inputs = [];
-        if (previewCommands.has(parsed._[0]))
-            inputs.push(toDependency('@react-email/preview-server'));
+        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;

package/dist/plugins/rslib/index.js

@@ -1,16 +1,19 @@
+import { toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
+import { getEntryFromAST } from './resolveFromAST.js';
 const title = 'Rslib';
 const enablers = ['@rslib/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const entry = ['rslib*.config.{mjs,ts,js,cjs,mts,cts}'];
-const resolveConfig = () => {
-    return [];
+const config = ['rslib*.config.{mjs,ts,js,cjs,mts,cts}'];
+const resolveFromAST = program => {
+    const entries = getEntryFromAST(program);
+    return [...entries].map(id => toProductionEntry(id, { allowIncludeExports: true }));
 };
 const plugin = {
     title,
     enablers,
     isEnabled,
-    entry,
-    resolveConfig,
+    config,
+    resolveFromAST,
 };
 export default plugin;

package/dist/plugins/rslib/resolveFromAST.d.ts

@@ -0,0 +1,2 @@
+import type { Program } from 'oxc-parser';
+export declare const getEntryFromAST: (program: Program) => Set<string>;

package/dist/plugins/rslib/resolveFromAST.js

@@ -0,0 +1,4 @@
+import { collectPropertyValues } from '../../typescript/ast-helpers.js';
+export const getEntryFromAST = (program) => {
+    return collectPropertyValues(program, 'entry');
+};

package/dist/types/args.d.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])[];
 export type Args = {
     binaries?: string[];
@@ -15,5 +16,6 @@ export type Args = {
     resolveInputs?: (parsed: ParsedArgs, options: {
         cwd: string;
         args: string[];
+        manifest: Manifest;
     }) => Input[];
 };

package/dist/types/config.d.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';
@@ -72,18 +73,17 @@ 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;
@@ -102,10 +102,10 @@ export type SourceMap = {
 };
 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[];
 export type HandleInput = (input: Input) => string | undefined;

package/dist/util/package-json.d.ts

@@ -8,5 +8,10 @@ interface ExtendedPackageJson extends PackageJson {
 export declare const load: (filePath: string) => Promise<ExtendedPackageJson>;
 export declare const save: (filePath: string, content: ExtendedPackageJson) => Promise<void>;
 export declare const getEntrySpecifiersFromManifest: (manifest: PackageJson) => Set<string>;
+export type Manifest = PackageJson & {
+    scriptNames: Set<string>;
+    getMajor: (name: string) => number | undefined;
+};
+export declare const createManifest: (raw: PackageJson) => Manifest;
 export declare const getManifestImportDependencies: (manifest: PackageJson) => Set<string>;
 export {};

package/dist/util/package-json.js

@@ -87,6 +87,15 @@ export const getEntrySpecifiersFromManifest = (manifest) => {
     }
     return entryPaths;
 };
+export const createManifest = (raw) => Object.assign(raw, {
+    ...raw,
+    scriptNames: new Set(Object.keys(raw.scripts ?? {})),
+    getMajor(name) {
+        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) => {
     const dependencies = new Set();
     if (!manifest.imports)

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.6.0";
+export declare const version = "6.6.1";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.6.0';
+export const version = '6.6.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.6.0",
+  "version": "6.6.1",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",

package/dist/plugins/rslib/types.d.ts

@@ -1 +0,0 @@
-export type RslibConfig = {};

package/dist/plugins/rslib/types.js

@@ -1 +0,0 @@
-export {};