knip 5.83.0 → 5.84.0

package/dist/compilers/index.js

@@ -1,21 +1,15 @@
-import Astro from './astro.js';
-import AstroMDX from './astro-mdx.js';
 import MDX from './mdx.js';
-import Prisma from './prisma.js';
 import SCSS from './scss.js';
-import Svelte from './svelte.js';
-import CSS from './tailwind.js';
-import Vue from './vue.js';
-const isAsync = (fn) => (fn ? fn.constructor.name === 'AsyncFunction' : false);
-const normalizeExt = (ext) => ext.replace(/^\.*/, '.');
+const isAsyncCompiler = (fn) => (fn ? fn.constructor.name === 'AsyncFunction' : false);
+export const normalizeCompilerExtension = (ext) => ext.replace(/^\.*/, '.');
 export const partitionCompilers = (rawLocalConfig) => {
     const syncCompilers = {};
     const asyncCompilers = {};
     for (const extension in rawLocalConfig.compilers) {
-        const ext = normalizeExt(extension);
+        const ext = normalizeCompilerExtension(extension);
         const compilerFn = rawLocalConfig.compilers[extension];
         if (typeof compilerFn === 'function') {
-            if (!rawLocalConfig.asyncCompilers?.[ext] && isAsync(compilerFn)) {
+            if (!rawLocalConfig.asyncCompilers?.[ext] && isAsyncCompiler(compilerFn)) {
                 asyncCompilers[ext] = compilerFn;
             }
             else {
@@ -27,28 +21,20 @@ export const partitionCompilers = (rawLocalConfig) => {
         }
     }
     for (const extension in rawLocalConfig.asyncCompilers) {
-        const ext = normalizeExt(extension);
+        const ext = normalizeCompilerExtension(extension);
         asyncCompilers[ext] = rawLocalConfig.asyncCompilers[extension];
     }
     return { ...rawLocalConfig, syncCompilers, asyncCompilers };
 };
 const compilers = new Map([
-    ['.astro', Astro],
-    ['.css', CSS],
     ['.mdx', MDX],
-    ['.prisma', Prisma],
     ['.sass', SCSS],
     ['.scss', SCSS],
-    ['.svelte', Svelte],
-    ['.vue', Vue],
 ]);
 export const getIncludedCompilers = (syncCompilers, asyncCompilers, dependencies) => {
     const hasDependency = (packageName) => dependencies.has(packageName);
     for (const [extension, { condition, compiler }] of compilers) {
-        if (extension === '.mdx' && AstroMDX.condition(hasDependency)) {
-            syncCompilers.set(extension, AstroMDX.compiler);
-        }
-        else if ((!syncCompilers.has(extension) && condition(hasDependency)) || syncCompilers.get(extension) === true) {
+        if ((!syncCompilers.has(extension) && condition(hasDependency)) || syncCompilers.get(extension) === true) {
             syncCompilers.set(extension, compiler);
         }
     }

package/dist/compilers/scss.d.ts

@@ -1,6 +1,6 @@
-import type { HasDependency, SyncCompilerFn } from './types.js';
+import type { CompilerSync, HasDependency } from './types.js';
 declare const _default: {
     condition: (hasDependency: HasDependency) => boolean;
-    compiler: SyncCompilerFn;
+    compiler: CompilerSync;
 };
 export default _default;

package/dist/compilers/types.d.ts

@@ -1,8 +1,9 @@
 type FileExtension = string;
-export type SyncCompilerFn = (source: string, path: string) => string;
-export type AsyncCompilerFn = (source: string, path: string) => Promise<string>;
-export type RawSyncCompilers = Map<FileExtension, SyncCompilerFn | true>;
-export type SyncCompilers = Map<FileExtension, SyncCompilerFn>;
-export type AsyncCompilers = Map<FileExtension, AsyncCompilerFn>;
+export type CompilerSync = (source: string, path: string) => string;
+export type CompilerAsync = (source: string, path: string) => Promise<string>;
+export type RawSyncCompilers = Map<FileExtension, CompilerSync | true>;
+export type SyncCompilers = Map<FileExtension, CompilerSync>;
+export type AsyncCompilers = Map<FileExtension, CompilerAsync>;
+export type Compilers = [SyncCompilers, AsyncCompilers];
 export type HasDependency = (pkgName: string) => boolean;
 export {};

package/dist/constants.js

@@ -43,6 +43,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'cp',
     'curl',
     'cut',
+    'date',
     'deno',
     'df',
     'dir',

package/dist/graph/analyze.js

@@ -11,9 +11,17 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
     const isReferencedInUsedExport = (exportedItem, filePath, includeEntryExports) => {
         if (!exportedItem.referencedIn)
             return false;
+        const file = graph.get(filePath);
+        if (!file)
+            return false;
         for (const containingExport of exportedItem.referencedIn) {
             if (explorer.isReferenced(filePath, containingExport, { includeEntryExports })[0])
                 return true;
+            const inExport = file.exports.get(containingExport);
+            if (!inExport)
+                return false;
+            if (inExport.hasRefsInFile && (inExport.type === 'type' || inExport.type === 'interface'))
+                return true;
         }
         return false;
     };
@@ -230,6 +238,9 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
         for (const identifier of unusedIgnoredWorkspaces) {
             collector.addConfigurationHint({ type: 'ignoreWorkspaces', identifier });
         }
+        for (const hint of collector.getUnusedIgnorePatternHints(options)) {
+            collector.addConfigurationHint(hint);
+        }
         for (const hint of chief.getConfigurationHints())
             collector.addConfigurationHint(hint);
     };

package/dist/graph/build.js

@@ -1,10 +1,10 @@
 import { _getInputsFromScripts } from '../binaries/index.js';
-import { getCompilerExtensions, getIncludedCompilers } from '../compilers/index.js';
+import { getCompilerExtensions, getIncludedCompilers, normalizeCompilerExtension } from '../compilers/index.js';
 import { DEFAULT_EXTENSIONS, FOREIGN_FILE_EXTENSIONS, IS_DTS } from '../constants.js';
 import { partition } from '../util/array.js';
 import { createInputHandler } from '../util/create-input-handler.js';
 import { debugLog, debugLogArray } from '../util/debug.js';
-import { _glob, _syncGlob, negate, prependDirToPattern } from '../util/glob.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';
 import { createFileNode, updateImportMap } from '../util/module-graph.js';
@@ -39,8 +39,8 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
         });
         counselor.addWorkspace(manifest);
     }
-    collector.addIgnorePatterns(chief.config.ignore.map(p => prependDirToPattern(options.cwd, p)));
-    collector.addIgnoreFilesPatterns(chief.config.ignoreFiles.map(p => prependDirToPattern(options.cwd, p)));
+    collector.addIgnorePatterns(chief.config.ignore.map(id => ({ pattern: prependDir(options.cwd, id), id })));
+    collector.addIgnoreFilesPatterns(chief.config.ignoreFiles.map(id => ({ pattern: prependDir(options.cwd, id), id })));
     for (const workspace of workspaces) {
         const { name, dir, ancestors, pkgName, manifestPath: filePath } = workspace;
         streamer.cast('Analyzing workspace', name);
@@ -48,10 +48,7 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
         if (!manifest)
             continue;
         const dependencies = deputy.getDependencies(name);
-        const compilers = getIncludedCompilers(chief.config.syncCompilers, chief.config.asyncCompilers, dependencies);
-        const extensions = getCompilerExtensions(compilers);
-        const extensionGlobStr = `.{${[...DEFAULT_EXTENSIONS, ...extensions].map(ext => ext.slice(1)).join(',')}}`;
-        const config = chief.getConfigForWorkspace(name, extensions);
+        const baseConfig = chief.getConfigForWorkspace(name);
         const tsConfigFilePath = join(dir, options.tsConfigFile ?? 'tsconfig.json');
         const { isFile, compilerOptions, fileNames } = await loadTSConfig(tsConfigFilePath);
         const [definitionPaths, tscSourcePaths] = partition(fileNames, filePath => IS_DTS.test(filePath));
@@ -60,7 +57,7 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
         const worker = new WorkspaceWorker({
             name,
             dir,
-            config,
+            config: baseConfig,
             manifest,
             dependencies,
             rootManifest,
@@ -74,6 +71,18 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
             options,
         });
         await worker.init();
+        const compilers = getIncludedCompilers(chief.config.syncCompilers, chief.config.asyncCompilers, dependencies);
+        const registerCompiler = async ({ extension, compiler }) => {
+            const ext = normalizeCompilerExtension(extension);
+            if (compilers[0].has(ext))
+                return;
+            compilers[0].set(ext, compiler);
+        };
+        await worker.registerCompilers(registerCompiler);
+        const extensions = getCompilerExtensions(compilers);
+        const extensionGlobStr = `.{${[...DEFAULT_EXTENSIONS, ...extensions].map(ext => ext.slice(1)).join(',')}}`;
+        const config = chief.getConfigForWorkspace(name, extensions);
+        worker.config = config;
         const inputs = new Set();
         if (definitionPaths.length > 0) {
             debugLogArray(name, 'Definition paths', definitionPaths);
@@ -81,8 +90,9 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                 inputs.add(toProductionEntry(id, { containingFilePath: tsConfigFilePath }));
         }
         const sharedGlobOptions = { cwd: options.cwd, dir, gitignore: options.gitignore };
-        collector.addIgnorePatterns(config.ignore.map(p => prependDirToPattern(options.cwd, prependDirToPattern(name, p))));
-        collector.addIgnoreFilesPatterns(config.ignoreFiles.map(p => prependDirToPattern(options.cwd, prependDirToPattern(name, p))));
+        const fn = (id) => ({ pattern: prependDir(options.cwd, prependDir(name, id)), id, workspaceName: name });
+        collector.addIgnorePatterns(config.ignore.map(fn));
+        collector.addIgnoreFilesPatterns(config.ignoreFiles.map(fn));
         const entrySpecifiersFromManifest = getEntrySpecifiersFromManifest(manifest);
         const label = 'entry paths from package.json';
         for (const filePath of await toSourceFilePaths(entrySpecifiersFromManifest, dir, extensionGlobStr, label)) {
@@ -111,6 +121,12 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
         for (const id of inputsFromPlugins)
             inputs.add(Object.assign(id, { skipExportsAnalysis: !id.allowIncludeExports }));
         enabledPluginsStore.set(name, worker.enabledPlugins);
+        worker.registerVisitors(visitors => {
+            if (visitors.dynamicImport)
+                principal.visitors.dynamicImport.push(...visitors.dynamicImport);
+            if (visitors.script)
+                principal.visitors.script.push(...visitors.script);
+        });
         const DEFAULT_GROUP = 'default';
         const createPatternMap = () => new Map([[DEFAULT_GROUP, new Set()]]);
         const groups = new Set([DEFAULT_GROUP]);
@@ -284,11 +300,9 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                     file.imports.external.add({ ...unresolvedImport, specifier: sanitizedSpecifier });
                 }
                 else {
-                    const isIgnored = isGitIgnored(join(dirname(filePath), sanitizedSpecifier));
-                    if (!isIgnored) {
+                    if (!isGitIgnored(join(dirname(filePath), sanitizedSpecifier))) {
                         const ext = extname(sanitizedSpecifier);
-                        const hasIgnoredExtension = FOREIGN_FILE_EXTENSIONS.has(ext);
-                        if (!ext || (ext !== '.json' && !hasIgnoredExtension))
+                        if (!ext || (ext !== '.json' && !FOREIGN_FILE_EXTENSIONS.has(ext)))
                             unresolvedImports.add(unresolvedImport);
                     }
                 }

package/dist/plugins/astro/compiler-mdx.d.ts

@@ -0,0 +1,2 @@
+declare const compiler: (text: string) => string;
+export default compiler;

package/dist/{compilers/astro-mdx.js → plugins/astro/compiler-mdx.js}

@@ -1,10 +1,8 @@
-import { fencedCodeBlockMatcher, importMatcher, importsWithinFrontmatter, inlineCodeMatcher } from './compilers.js';
-const astroMDXDependencies = ['@astrojs/mdx', '@astrojs/starlight'];
+import { fencedCodeBlockMatcher, importMatcher, importsWithinFrontmatter, inlineCodeMatcher, } from '../../compilers/compilers.js';
 const frontmatterImportFields = ['layout'];
-const condition = (hasDependency) => astroMDXDependencies.some(hasDependency);
 const compiler = (text) => {
     const imports = text.replace(fencedCodeBlockMatcher, '').replace(inlineCodeMatcher, '').matchAll(importMatcher);
     const frontmatterImports = importsWithinFrontmatter(text, frontmatterImportFields);
     return [...imports, frontmatterImports].join('\n');
 };
-export default { condition, compiler };
+export default compiler;

package/dist/plugins/astro/compiler.d.ts

@@ -0,0 +1,2 @@
+declare const compiler: (text: string, path: string) => string;
+export default compiler;

package/dist/{compilers/astro.js → plugins/astro/compiler.js}

@@ -1,5 +1,4 @@
-import { frontmatterMatcher, scriptBodies } from './compilers.js';
-const condition = (hasDependency) => hasDependency('astro');
+import { frontmatterMatcher, scriptBodies } from '../../compilers/compilers.js';
 const compiler = (text, path) => {
     const scripts = [];
     const frontmatter = text.match(frontmatterMatcher);
@@ -10,4 +9,4 @@ const compiler = (text, path) => {
         scripts.push(scriptContent);
     return scripts.join('\n');
 };
-export default { condition, compiler };
+export default compiler;

package/dist/plugins/astro/index.js

@@ -1,5 +1,7 @@
 import { toDependency, toEntry, toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
+import compiler from './compiler.js';
+import mdxCompiler from './compiler-mdx.js';
 import { getSrcDir } from './resolveFromAST.js';
 const title = 'Astro';
 const enablers = ['astro'];
@@ -22,6 +24,13 @@ const resolveFromAST = sourceFile => {
         ...production.map(setSrcDir).map(path => toProductionEntry(path)),
     ];
 };
+const registerCompilers = ({ registerCompiler, hasDependency }) => {
+    if (hasDependency('astro'))
+        registerCompiler({ extension: '.astro', compiler });
+    if (hasDependency('@astrojs/mdx') || hasDependency('@astrojs/starlight')) {
+        registerCompiler({ extension: '.mdx', compiler: mdxCompiler });
+    }
+};
 const resolve = options => {
     const { manifest, isProduction } = options;
     const inputs = [];
@@ -39,6 +48,7 @@ const plugin = {
     config,
     entry,
     production,
+    registerCompilers,
     resolveFromAST,
     resolve,
 };

package/dist/plugins/bun/index.js

@@ -1,18 +1,25 @@
 import parseArgs from 'minimist';
-import { toEntry } from '../../util/input.js';
+import { toDeferResolve, toEntry } from '../../util/input.js';
 const title = 'Bun';
 const enablers = ['bun'];
 const hasBunTest = (scripts) => scripts && Object.values(scripts).some(script => /(?<=^|\s)bun test/.test(script));
 const isEnabled = ({ manifest }) => !!hasBunTest(manifest.scripts);
+const config = ['bunfig.toml'];
 const patterns = ['**/*.{test,spec}.{js,jsx,ts,tsx}', '**/*_{test,spec}.{js,jsx,ts,tsx}'];
+const resolveConfig = localConfig => {
+    const preload = localConfig.test?.preload ?? [];
+    return preload.map(specifier => toDeferResolve(specifier));
+};
 const resolve = options => {
     const scripts = { ...options.rootManifest?.scripts, ...options.manifest.scripts };
     for (const script of Object.values(scripts)) {
         if (/(?<=^|\s)bun test/.test(script)) {
-            const parsed = parseArgs(script.split(' '));
-            if (parsed._.filter(id => id !== 'bun' && id !== 'test').length === 0) {
-                return patterns.map(toEntry);
-            }
+            const parsed = parseArgs(script.split(' '), { string: ['timeout', 'rerun-each', 'preload'] });
+            const args = parsed._.filter(id => id !== 'bun' && id !== 'test');
+            const inputs = (args.length === 0 ? patterns : args).map(toEntry);
+            for (const specifier of [parsed.preload ?? []].flat())
+                inputs.push(toDeferResolve(specifier));
+            return inputs;
         }
     }
     return [];
@@ -21,6 +28,8 @@ const plugin = {
     title,
     enablers,
     isEnabled,
+    config,
     resolve,
+    resolveConfig,
 };
 export default plugin;

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

@@ -0,0 +1,5 @@
+export type BunfigConfig = {
+    test?: {
+        preload?: string[];
+    };
+};

package/dist/plugins/bun/types.js

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

package/dist/plugins/c8/index.js

@@ -3,7 +3,7 @@ const title = 'c8';
 const args = {
     args: (args) => args.filter(arg => arg !== 'check-coverage'),
     boolean: ['all', 'check-coverage', 'clean', 'exclude-after-remap', 'per-file', 'skip-full'],
-    fromArgs: (parsed, args) => argsFrom(args, parsed._[0]),
+    fromArgs: (parsed, args) => (parsed._[0] ? argsFrom(args, parsed._[0]) : (parsed['--'] ?? [])),
 };
 const plugin = {
     title,

package/dist/plugins/convex/index.js

@@ -2,7 +2,7 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Convex';
 const enablers = ['convex'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const entry = ['convex/*.config.@(js|ts)', 'convex/_generated/*.@(js|ts)'];
+const entry = ['convex/*.config.@(js|ts)', 'convex/**/_generated/*.@(js|ts)'];
 const plugin = {
     title,
     enablers,

package/dist/plugins/dotenv/index.js

@@ -1,7 +1,14 @@
 import { argsFrom } from '../../binaries/util.js';
 const title = 'dotenv';
 const args = {
-    fromArgs: (parsed, args) => argsFrom(args, parsed._[0]),
+    fromArgs: (parsed, args) => {
+        if (parsed._[0])
+            return argsFrom(args, parsed._[0]);
+        if (!parsed['--'] || parsed['--'].length === 0)
+            return [];
+        const script = parsed['--'].map(arg => (arg.includes(' ') ? `"${arg}"` : arg)).join(' ');
+        return [script];
+    },
 };
 const plugin = {
     title,

package/dist/plugins/execa/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.js';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/execa/index.js

@@ -0,0 +1,15 @@
+import { hasDependency } from '../../util/plugin.js';
+import execaVisitor from './visitors/execa.js';
+const title = 'execa';
+const enablers = ['execa'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const registerVisitors = ({ registerVisitors }) => {
+    registerVisitors({ script: [execaVisitor] });
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    registerVisitors,
+};
+export default plugin;

package/dist/{typescript/visitors/scripts → plugins/execa/visitors}/execa.js

@@ -1,7 +1,7 @@
 import ts from 'typescript';
-import { stripQuotes } from '../../ast-helpers.js';
-import { hasImportSpecifier } from '../helpers.js';
-import { scriptVisitor as visit } from '../index.js';
+import { stripQuotes } from '../../../typescript/ast-helpers.js';
+import { hasImportSpecifier } from '../../../typescript/visitors/helpers.js';
+import { scriptVisitor as visit } from '../../../typescript/visitors/index.js';
 const tags = new Set(['$', '$sync']);
 const methods = new Set(['execa', 'execaSync', 'execaCommand', 'execaCommandSync', '$sync']);
 export default visit(sourceFile => sourceFile.statements.some(node => hasImportSpecifier(node, 'execa')), node => {

package/dist/plugins/index.d.ts

@@ -27,6 +27,7 @@ export declare const Plugins: {
     drizzle: import("../types/config.js").Plugin;
     eleventy: import("../types/config.js").Plugin;
     eslint: import("../types/config.js").Plugin;
+    execa: import("../types/config.js").Plugin;
     expo: import("../types/config.js").Plugin;
     'expressive-code': {
         title: string;
@@ -79,12 +80,14 @@ export declare const Plugins: {
     'playwright-ct': import("../types/config.js").Plugin;
     'playwright-test': import("../types/config.js").Plugin;
     plop: import("../types/config.js").Plugin;
+    pm2: import("../types/config.js").Plugin;
     pnpm: import("../types/config.js").Plugin;
     postcss: import("../types/config.js").Plugin;
     preconstruct: import("../types/config.js").Plugin;
     prettier: import("../types/config.js").Plugin;
     prisma: import("../types/config.js").Plugin;
     'react-cosmos': import("../types/config.js").Plugin;
+    'react-native': import("../types/config.js").Plugin;
     'react-router': import("../types/config.js").Plugin;
     relay: import("../types/config.js").Plugin;
     'release-it': import("../types/config.js").Plugin;
@@ -135,4 +138,5 @@ export declare const Plugins: {
     xo: import("../types/config.js").Plugin;
     yarn: import("../types/config.js").Plugin;
     yorkie: import("../types/config.js").Plugin;
+    zx: import("../types/config.js").Plugin;
 };

package/dist/plugins/index.js

@@ -26,6 +26,7 @@ import { default as dotenv } from './dotenv/index.js';
 import { default as drizzle } from './drizzle/index.js';
 import { default as eleventy } from './eleventy/index.js';
 import { default as eslint } from './eslint/index.js';
+import { default as execa } from './execa/index.js';
 import { default as expo } from './expo/index.js';
 import { default as expressiveCode } from './expressive-code/index.js';
 import { default as gatsby } from './gatsby/index.js';
@@ -73,12 +74,14 @@ import { default as playwright } from './playwright/index.js';
 import { default as playwrightCt } from './playwright-ct/index.js';
 import { default as playwrightTest } from './playwright-test/index.js';
 import { default as plop } from './plop/index.js';
+import { default as pm2 } from './pm2/index.js';
 import { default as pnpm } from './pnpm/index.js';
 import { default as postcss } from './postcss/index.js';
 import { default as preconstruct } from './preconstruct/index.js';
 import { default as prettier } from './prettier/index.js';
 import { default as prisma } from './prisma/index.js';
 import { default as reactCosmos } from './react-cosmos/index.js';
+import { default as reactNative } from './react-native/index.js';
 import { default as reactRouter } from './react-router/index.js';
 import { default as relay } from './relay/index.js';
 import { default as releaseIt } from './release-it/index.js';
@@ -129,6 +132,7 @@ import { default as wrangler } from './wrangler/index.js';
 import { default as xo } from './xo/index.js';
 import { default as yarn } from './yarn/index.js';
 import { default as yorkie } from './yorkie/index.js';
+import { default as zx } from './zx/index.js';
 export const Plugins = {
     angular,
     astro,
@@ -158,6 +162,7 @@ export const Plugins = {
     drizzle,
     eleventy,
     eslint,
+    execa,
     expo,
     'expressive-code': expressiveCode,
     gatsby,
@@ -205,12 +210,14 @@ export const Plugins = {
     'playwright-ct': playwrightCt,
     'playwright-test': playwrightTest,
     plop,
+    pm2,
     pnpm,
     postcss,
     preconstruct,
     prettier,
     prisma,
     'react-cosmos': reactCosmos,
+    'react-native': reactNative,
     'react-router': reactRouter,
     relay,
     'release-it': releaseIt,
@@ -261,4 +268,5 @@ export const Plugins = {
     xo,
     yarn,
     yorkie,
+    zx,
 };

package/dist/plugins/jest/index.js

@@ -1,5 +1,5 @@
 import { toDeferResolve, toEntry } from '../../util/input.js';
-import { isInternal, join, toAbsolute } from '../../util/path.js';
+import { isInternal, join, normalize, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getReportersDependencies, resolveExtensibleConfig } from './helpers.js';
 const title = 'Jest';
@@ -88,7 +88,7 @@ const resolveConfig = async (localConfig, options) => {
     if (localConfig.testMatch && !options.config.entry)
         entries.push(...mocks.map(id => toEntry(id)));
     const result = inputs.map(dependency => {
-        dependency.specifier = replaceRootDir(dependency.specifier);
+        dependency.specifier = normalize(replaceRootDir(dependency.specifier));
         return dependency;
     });
     return entries.concat(result);

package/dist/plugins/metro/index.js

@@ -3,12 +3,14 @@ import { toDeferResolve, toProductionEntry } from '../../util/input.js';
 import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Metro';
-const enablers = ['metro', 'react-native'];
+const enablers = ['metro', '@react-native/metro-config'];
 const isEnabled = options => hasDependency(options.dependencies, enablers);
 const config = ['metro.config.{js,cjs,json}', 'package.json'];
 const DEFAULT_PLATFORMS = ['ios', 'android', 'windows', 'web'];
 const PLATFORMS = [...DEFAULT_PLATFORMS, 'native', 'default'];
 const DEFAULT_EXTENSIONS = ['js', 'jsx', 'json', 'ts', 'tsx'];
+const DEFAULT_TRANSFORMER_PACKAGE = 'metro-transform-worker';
+const DEFAULT_MINIFIER_PACKAGE = 'metro-minify-terser';
 const production = [`src/**/*.{${PLATFORMS.join(',')}}.{${DEFAULT_EXTENSIONS.join(',')}}`];
 const resolveConfig = async (config) => {
     const { transformerPath, transformer } = config;
@@ -35,8 +37,11 @@ const resolveConfig = async (config) => {
         inputs.push(transformer.minifierPath);
     if (transformer?.babelTransformerPath)
         inputs.push(transformer.babelTransformerPath);
-    return Array.from(i).concat([...inputs].map(id => toDeferResolve(id)));
+    return Array.from(i).concat([...inputs].map(id => toDeferResolve(id, {
+        optional: id === DEFAULT_TRANSFORMER_PACKAGE || id === DEFAULT_MINIFIER_PACKAGE,
+    })));
 };
+const isFilterTransitiveDependencies = true;
 const note = `False positives for platform-specific unused files?
 Override the default \`entry\` patterns to match platforms and extensions.`;
 export const docs = { note };
@@ -47,5 +52,6 @@ const plugin = {
     config,
     production,
     resolveConfig,
+    isFilterTransitiveDependencies,
 };
 export default plugin;

package/dist/plugins/nx/index.js

@@ -71,7 +71,7 @@ const resolveConfig = async (localConfig, options) => {
     return compact([...executors, ...inputs, ...configInputs]).map(id => typeof id === 'string' ? toDependency(id) : id);
 };
 const args = {
-    fromArgs: (parsed) => (parsed._[0] === 'exec' ? parsed._.slice(1) : []),
+    fromArgs: (parsed) => (parsed._[0] === 'exec' ? [...parsed._.slice(1), ...(parsed['--'] ?? [])] : []),
 };
 export const docs = {
     note: `Also see [integrated monorepos](/features/integrated-monorepos) and the note regarding internal workspace dependencies.`,

package/dist/plugins/pm2/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.js';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/pm2/index.js

@@ -0,0 +1,34 @@
+import { toEntry } from '../../util/input.js';
+import { isInternal } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+const title = 'pm2';
+const enablers = ['pm2'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['pm2.config.{json,js,cjs,mjs}', 'ecosystem.config.{json,js,cjs,mjs}'];
+const addApplicationEntry = (application, entries) => {
+    if (application.script && isInternal(application.script))
+        entries.push(toEntry(application.script));
+};
+const resolveConfig = config => {
+    const entries = [];
+    if (Array.isArray(config)) {
+        for (const application of config)
+            addApplicationEntry(application, entries);
+        return entries;
+    }
+    addApplicationEntry(config, entries);
+    if (!config.apps)
+        return entries;
+    const applications = Array.isArray(config.apps) ? config.apps : [config.apps];
+    for (const application of applications)
+        addApplicationEntry(application, entries);
+    return entries;
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    resolveConfig,
+};
+export default plugin;

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

@@ -0,0 +1,9 @@
+export type PM2Application = {
+    script?: string;
+};
+type PM2Applications = PM2Application | PM2Application[];
+type PM2RootConfig = PM2Application & {
+    apps?: PM2Applications;
+};
+export type PM2Config = PM2RootConfig | PM2Application[];
+export {};

package/dist/plugins/pm2/types.js

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

package/dist/plugins/prettier/index.js

@@ -16,11 +16,13 @@ const resolveConfig = config => {
         ? config.plugins.filter((plugin) => typeof plugin === 'string').map(id => toDependency(id))
         : [];
 };
+const isFilterTransitiveDependencies = true;
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
     resolveConfig,
+    isFilterTransitiveDependencies,
 };
 export default plugin;

package/dist/plugins/prisma/compiler.d.ts

@@ -0,0 +1,2 @@
+declare const compiler: (text: string) => string;
+export default compiler;