knip 5.42.0 → 5.42.2

package/dist/plugins/github-actions/index.js

@@ -8,8 +8,17 @@ const isEnabled = async ({ cwd }) => Boolean(await _firstGlob({ cwd, patterns: [
 const isRootOnly = true;
 const config = ['.github/workflows/*.{yml,yaml}', '.github/**/action.{yml,yaml}'];
 const isString = (value) => typeof value === 'string';
+const getActionDependencies = (config, options) => {
+    const { configFileDir, configFileName } = options;
+    const isActionManifest = configFileName === 'action.yml' || configFileName === 'action.yaml';
+    if (!(isActionManifest && config?.runs?.using?.startsWith('node')))
+        return [];
+    const runs = config.runs;
+    const scripts = [runs.pre, runs.main, runs.post].filter(isString);
+    return scripts.map(script => join(configFileDir, script));
+};
 const resolveConfig = async (config, options) => {
-    const { configFileDir, configFileName, rootCwd, getInputsFromScripts } = options;
+    const { rootCwd, getInputsFromScripts, isProduction } = options;
     const inputs = new Set();
     const jobs = findByKeyDeep(config, 'steps');
     for (const steps of jobs) {
@@ -22,21 +31,17 @@ const resolveConfig = async (config, options) => {
             const dir = join(rootCwd, path && workingDir ? relative(workingDir, path) : workingDir ? workingDir : '.');
             if (step.run) {
                 for (const input of getInputsFromScripts([step.run], { knownBinsOnly: true })) {
-                    if (isDeferResolveEntry(input) && path && !workingDir)
+                    if (isDeferResolveEntry(input) && path && !workingDir) {
                         input.specifier = relative(join(dir, path), join(rootCwd, input.specifier));
+                    }
+                    if (isProduction)
+                        Object.assign(input, { optional: true });
                     inputs.add({ ...input, dir });
                 }
             }
         }
     }
-    const getActionDependencies = () => {
-        const isActionManifest = configFileName === 'action.yml' || configFileName === 'action.yaml';
-        if (!(isActionManifest && config?.runs?.using?.startsWith('node')))
-            return [];
-        const scripts = [config.runs.pre, config.runs.main, config.runs.post].filter(isString);
-        return scripts.map(script => join(configFileDir, script));
-    };
-    return [...getActionDependencies().map(toEntry), ...inputs];
+    return [...inputs, ...getActionDependencies(config, options).map(toEntry)];
 };
 export default {
     title,

package/dist/plugins/github-actions/types.d.ts

@@ -0,0 +1,20 @@
+type Step = {
+    run?: string;
+    uses?: string;
+    with?: {
+        repository: string;
+        path: string;
+    };
+    'working-directory'?: string;
+};
+type Steps = Step[];
+export type Job = {
+    steps: Steps;
+};
+export type Runs = {
+    using: string;
+    main?: string;
+    pre?: string;
+    post?: string;
+};
+export {};

package/dist/plugins/github-actions/types.js

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

package/dist/plugins/graphql-codegen/index.js

@@ -48,7 +48,7 @@ const resolveConfig = config => {
             return [];
         if (isInternal(plugin))
             return [toEntry(plugin)];
-        return [plugin.includes('codegen-') ? plugin : `@graphql-codegen/${plugin}`].map(toDependency);
+        return [plugin.includes('codegen-') ? plugin : `@graphql-codegen/${plugin}`].map(id => toDependency(id));
     });
     return [...presets, ...flatPlugins, ...nestedPlugins].map(id => (typeof id === 'string' ? toDependency(id) : id));
 };

package/dist/plugins/index.d.ts

@@ -94,6 +94,16 @@ export declare const Plugins: {
         resolveEntryPaths: import("../types/config.js").ResolveEntryPaths;
         resolveConfig: import("../types/config.js").ResolveConfig<import("./cypress/types.js").CypressConfig>;
     };
+    'dependency-cruiser': {
+        title: string;
+        enablers: string[];
+        isEnabled: import("../types/config.js").IsPluginEnabled;
+        config: string[];
+        args: {
+            binaries: string[];
+            config: boolean;
+        };
+    };
     dotenv: {
         title: string;
         args: {
@@ -251,7 +261,6 @@ export declare const Plugins: {
     };
     metro: {
         title: string;
-        note: string;
         enablers: string[];
         isEnabled: import("../types/config.js").IsPluginEnabled;
         config: string[];
@@ -341,7 +350,6 @@ export declare const Plugins: {
     };
     nuxt: {
         title: string;
-        note: string;
         enablers: string[];
         isEnabled: import("../types/config.js").IsPluginEnabled;
         entry: string[];

package/dist/plugins/index.js

@@ -10,6 +10,7 @@ import { default as commitlint } from './commitlint/index.js';
 import { default as cspell } from './cspell/index.js';
 import { default as cucumber } from './cucumber/index.js';
 import { default as cypress } from './cypress/index.js';
+import { default as dependencyCruiser } from './dependency-cruiser/index.js';
 import { default as dotenv } from './dotenv/index.js';
 import { default as drizzle } from './drizzle/index.js';
 import { default as eleventy } from './eleventy/index.js';
@@ -101,6 +102,7 @@ export const Plugins = {
     cspell,
     cucumber,
     cypress,
+    'dependency-cruiser': dependencyCruiser,
     dotenv,
     drizzle,
     eleventy,

package/dist/plugins/lefthook/index.js

@@ -10,7 +10,7 @@ const gitHookPaths = getGitHookPaths();
 const config = ['lefthook.yml', ...gitHookPaths];
 const resolveConfig = async (localConfig, options) => {
     const { manifest, configFileName, cwd, getInputsFromScripts } = options;
-    const inputs = manifest.devDependencies ? Object.keys(manifest.devDependencies).map(toDependency) : [];
+    const inputs = manifest.devDependencies ? Object.keys(manifest.devDependencies).map(id => toDependency(id)) : [];
     if (extname(configFileName) === '.yml') {
         const scripts = findByKeyDeep(localConfig, 'run').flatMap(command => {
             const deps = getInputsFromScripts([command.run], { ...options, knownBinsOnly: true });
@@ -18,7 +18,7 @@ const resolveConfig = async (localConfig, options) => {
             return deps.flatMap(dependency => ({ ...dependency, dir }));
         });
         const lefthook = process.env.CI
-            ? enablers.filter(dependency => inputs.some(d => d.specifier === dependency)).map(toDependency)
+            ? enablers.filter(dependency => inputs.some(d => d.specifier === dependency)).map(id => toDependency(id))
             : [];
         return [...scripts, ...lefthook];
     }

package/dist/plugins/markdownlint/index.js

@@ -14,7 +14,7 @@ const resolveConfig = (config, options) => {
     const uses = scripts
         .filter(script => script.includes('markdownlint '))
         .flatMap(script => getArgumentValues(script, / (--rules|-r)[ =]([^ ]+)/g));
-    return [...extend, ...uses].map(toDependency);
+    return [...extend, ...uses].map(id => toDependency(id));
 };
 export default {
     title,

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

@@ -1,11 +1,11 @@
 import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '../../types/config.js';
 import type { MetroConfig } from './types.js';
 export declare const docs: {
+    note: string;
     production: string[];
 };
 declare const _default: {
     title: string;
-    note: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     config: string[];

package/dist/plugins/metro/index.js

@@ -3,8 +3,6 @@ import { toDeferResolve, toProductionEntry } from '../../util/input.js';
 import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Metro';
-const note = `False positives for platform-specific unused files?
-Override the entry patterns as shown below to match platforms and extensions.`;
 const enablers = ['metro', 'react-native'];
 const isEnabled = options => hasDependency(options.dependencies, enablers);
 const config = ['metro.config.{js,cjs,json}', 'package.json'];
@@ -12,7 +10,6 @@ const DEFAULT_PLATFORMS = ['ios', 'android', 'windows', 'web'];
 const PLATFORMS = [...DEFAULT_PLATFORMS, 'native', 'default'];
 const DEFAULT_EXTENSIONS = ['js', 'jsx', 'json', 'ts', 'tsx'];
 const production = [`src/**/*.{${PLATFORMS.join(',')}}.{${DEFAULT_EXTENSIONS.join(',')}}`];
-export const docs = { production };
 const resolveEntryPaths = async (config) => {
     const platformEntryPatterns = compact(PLATFORMS.concat(config.resolver?.platforms ?? []));
     const sourceExts = config.resolver?.sourceExts ?? DEFAULT_EXTENSIONS;
@@ -37,9 +34,11 @@ const resolveConfig = async (config) => {
         inputs.push(transformer.babelTransformerPath);
     return [...inputs].map(toDeferResolve);
 };
+const note = `False positives for platform-specific unused files?
+Override the entry patterns as shown below to match platforms and extensions.`;
+export const docs = { note, production };
 export default {
     title,
-    note,
     enablers,
     isEnabled,
     config,

package/dist/plugins/nest/index.js

@@ -6,7 +6,7 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['nest-cli.json', '.nestcli.json', '.nest-cli.json', 'nest.json'];
 const resolveConfig = async (config) => {
     const inputs = config?.collection ? [config.collection] : [];
-    return [...inputs].map(toDependency);
+    return [...inputs].map(id => toDependency(id));
 };
 export default {
     title,

package/dist/plugins/netlify/index.js

@@ -19,8 +19,8 @@ const resolveEntryPaths = localConfig => {
 };
 const resolveConfig = async (localConfig) => {
     return [
-        ...(localConfig?.plugins?.map(plugin => plugin.package) ?? []).map(toDependency),
-        ...extractFunctionsConfigProperty(localConfig.functions || {}, 'external_node_modules').map(toDependency),
+        ...(localConfig?.plugins?.map(plugin => plugin.package) ?? []).map(id => toDependency(id)),
+        ...extractFunctionsConfigProperty(localConfig.functions || {}, 'external_node_modules').map(id => toDependency(id)),
     ];
 };
 export default {

package/dist/plugins/npm-package-json-lint/index.js

@@ -7,7 +7,7 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const packageJsonPath = 'npmpackagejsonlint';
 const config = ['package.json', ...toCosmiconfig('npmpackagejsonlint')];
 const resolveConfig = localConfig => {
-    return localConfig?.extends ? [localConfig.extends].map(toDependency) : [];
+    return localConfig?.extends ? [localConfig.extends].map(id => toDependency(id)) : [];
 };
 export default {
     title,

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

@@ -1,8 +1,10 @@
 import type { IsPluginEnabled, ResolveEntryPaths } from '../../types/config.js';
 import type { NuxtConfig } from './types.js';
+export declare const docs: {
+    note: string;
+};
 declare const _default: {
     title: string;
-    note: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     entry: string[];

package/dist/plugins/nuxt/index.js

@@ -2,8 +2,6 @@ import { toProductionEntry } from '../../util/input.js';
 import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Nuxt';
-const note = `Knip works best with [explicit imports](https://nuxt.com/docs/guide/concepts/auto-imports#explicit-imports).
-Nuxt allows to [disable auto-imports](https://nuxt.com/docs/guide/concepts/auto-imports#disabling-auto-imports).`;
 const enablers = ['nuxt'];
 const isEnabled = ({ dependencies }) => {
     const isEnabled = hasDependency(dependencies, enablers);
@@ -38,9 +36,11 @@ const resolveEntryPaths = async (localConfig) => {
     ];
     return patterns.map(pattern => toProductionEntry(join(srcDir, pattern)));
 };
+const note = `Knip works best with [explicit imports](https://nuxt.com/docs/guide/concepts/auto-imports#explicit-imports).
+Nuxt allows to [disable auto-imports](https://nuxt.com/docs/guide/concepts/auto-imports#disabling-auto-imports).`;
+export const docs = { note };
 export default {
     title,
-    note,
     enablers,
     isEnabled,
     entry,

package/dist/plugins/nx/index.js

@@ -21,7 +21,7 @@ const findNxDependenciesInNxJson = async (localConfig) => {
             .filter(value => value !== undefined)
             .map(value => value.split(':')[0])
         : [];
-    return compact([...targetsDefault, ...plugins, ...generators]).map(toDependency);
+    return compact([...targetsDefault, ...plugins, ...generators]).map(id => toDependency(id));
 };
 const resolveConfig = async (localConfig, options) => {
     const { configFileName } = options;

package/dist/plugins/oclif/index.js

@@ -7,7 +7,7 @@ const config = ['package.json'];
 const resolveConfig = async (config) => {
     const plugins = config?.plugins ?? [];
     const devPlugins = config?.devPlugins ?? [];
-    return [...plugins, ...devPlugins].map(toDependency);
+    return [...plugins, ...devPlugins].map(id => toDependency(id));
 };
 export default {
     title,

package/dist/plugins/prettier/index.js

@@ -13,7 +13,7 @@ const resolveConfig = config => {
     if (typeof config === 'string')
         return [toDeferResolve(config)];
     return Array.isArray(config.plugins)
-        ? config.plugins.filter((plugin) => typeof plugin === 'string').map(toDependency)
+        ? config.plugins.filter((plugin) => typeof plugin === 'string').map(id => toDependency(id))
         : [];
 };
 export default {

package/dist/plugins/release-it/index.js

@@ -14,7 +14,7 @@ const resolveConfig = (config, options) => {
         scripts.push(config.gitlab.releaseNotes);
     }
     const inputs = options.getInputsFromScripts(scripts);
-    return [...plugins.map(toDependency), ...inputs];
+    return [...plugins.map(id => toDependency(id)), ...inputs];
 };
 export default {
     title,

package/dist/plugins/semantic-release/index.js

@@ -7,9 +7,15 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const isRootOnly = true;
 const packageJsonPath = 'release';
 const config = ['package.json', ...toCosmiconfig('release')];
+const excludePackages = [
+    '@semantic-release/commit-analyzer',
+    '@semantic-release/github',
+    '@semantic-release/npm',
+    '@semantic-release/release-notes-generator',
+];
 const resolveConfig = config => {
     const plugins = (config?.plugins ?? []).map(plugin => (Array.isArray(plugin) ? plugin[0] : plugin));
-    return plugins.map(toDeferResolve);
+    return plugins.filter(plugin => !excludePackages.includes(plugin)).map(toDeferResolve);
 };
 export default {
     title,

package/dist/plugins/storybook/index.js

@@ -30,7 +30,11 @@ const resolveConfig = async (localConfig) => {
             : [builder]
         : [];
     const frameworks = localConfig.framework?.name ? [localConfig.framework.name] : [];
-    return [...addons.map(toDeferResolve), ...builderPackages.map(toDependency), ...frameworks.map(toDependency)];
+    return [
+        ...addons.map(toDeferResolve),
+        ...builderPackages.map(id => toDependency(id)),
+        ...frameworks.map(id => toDependency(id)),
+    ];
 };
 export default {
     title,

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

@@ -1,5 +1,8 @@
 import type { TsConfigJson } from 'type-fest';
 import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
+export declare const docs: {
+    note: string;
+};
 declare const _default: {
     title: string;
     enablers: string[];

package/dist/plugins/typescript/index.js

@@ -30,6 +30,8 @@ const args = {
     alias: { project: ['p'] },
     config: [['project', (p) => (p.endsWith('.json') ? p : join(p, 'tsconfig.json'))]],
 };
+const note = '[What’s up with that configurable tsconfig.json location?](/reference/faq#whats-up-with-that-configurable-tsconfigjson-location)';
+export const docs = { note };
 export default {
     title,
     enablers,

package/dist/plugins/vitest/index.js

@@ -25,7 +25,7 @@ const findConfigDependencies = (localConfig, options) => {
     const dir = join(configFileDir, testConfig.root ?? '.');
     const setupFiles = [testConfig.setupFiles ?? []].flat().map(specifier => ({ ...toDeferResolve(specifier), dir }));
     const globalSetup = [testConfig.globalSetup ?? []].flat().map(specifier => ({ ...toDeferResolve(specifier), dir }));
-    return [...[...environments, ...reporters, ...coverage].map(toDependency), ...setupFiles, ...globalSetup];
+    return [...[...environments, ...reporters, ...coverage].map(id => toDependency(id)), ...setupFiles, ...globalSetup];
 };
 const getConfigs = async (localConfig) => {
     const configs = [];

package/dist/plugins/webdriver-io/index.js

@@ -23,7 +23,7 @@ const resolveConfig = async (config) => {
         })
             .map(reporter => `@wdio/${reporter}-reporter`)
         : [];
-    return [...frameworks, ...runners, ...reporters].map(toDependency);
+    return [...frameworks, ...runners, ...reporters].map(id => toDependency(id));
 };
 export default {
     title,

package/dist/reporters/symbols.js

@@ -8,6 +8,11 @@ const bright = picocolors.whiteBright;
 const TRUNCATE_WIDTH = 40;
 const truncate = (text) => (text.length > TRUNCATE_WIDTH ? `${text.slice(0, TRUNCATE_WIDTH - 3)}...` : text);
 const truncateStart = (text, width) => (text.length > width ? `...${text.slice(-(width - 3))}` : text);
+const sortByPos = (a, b) => {
+    const [f, r, c] = a.filePath.split(':');
+    const [f2, r2, c2] = b.filePath.split(':');
+    return f === f2 ? (Number(r) === Number(r2) ? Number(c) - Number(c2) : Number(r) - Number(r2)) : f.localeCompare(f2);
+};
 const hl = (issue) => {
     if (issue.specifier && issue.specifier !== issue.symbol && issue.specifier.includes(issue.symbol)) {
         const parts = issue.specifier.split(issue.symbol);
@@ -32,7 +37,7 @@ const logIssueRecord = (issues) => {
         issue.isFixed && table.cell('fixed', print('(removed)'));
         table.newRow();
     }
-    console.log(table.sort(['filePath', 'parentSymbol', 'symbol']).print().trim());
+    console.log(table.sort(sortByPos).print().trim());
 };
 export default ({ report, issues, tagHints, configurationHints, noConfigHints, isShowProgress }) => {
     const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;

package/dist/schema/plugins.d.ts

@@ -170,6 +170,19 @@ export declare const pluginsSchema: z.ZodObject<{
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     }>]>;
+    'dependency-cruiser': z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
+        config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        project: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    }, "strip", z.ZodTypeAny, {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    }, {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    }>]>;
     dotenv: z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
         config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
         entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
@@ -1250,6 +1263,11 @@ export declare const pluginsSchema: z.ZodObject<{
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     };
+    'dependency-cruiser': string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    };
     dotenv: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -1701,6 +1719,11 @@ export declare const pluginsSchema: z.ZodObject<{
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     };
+    'dependency-cruiser': string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    };
     dotenv: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;

package/dist/schema/plugins.js

@@ -22,6 +22,7 @@ export const pluginsSchema = z.object({
     cspell: pluginSchema,
     cucumber: pluginSchema,
     cypress: pluginSchema,
+    'dependency-cruiser': pluginSchema,
     dotenv: pluginSchema,
     drizzle: pluginSchema,
     eleventy: pluginSchema,

package/dist/types/PluginNames.d.ts

@@ -1,2 +1,2 @@
-export type PluginName = 'angular' | 'astro' | 'ava' | 'babel' | 'c8' | 'capacitor' | 'changesets' | 'commitizen' | 'commitlint' | 'cspell' | 'cucumber' | 'cypress' | 'dotenv' | 'drizzle' | 'eleventy' | 'eslint' | 'expo' | 'gatsby' | 'github-actions' | 'glob' | 'graphql-codegen' | 'husky' | 'jest' | 'karma' | 'ladle' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lockfile-lint' | 'lost-pixel' | 'markdownlint' | 'metro' | 'mocha' | 'moonrepo' | 'msw' | 'nest' | 'netlify' | 'next' | 'node' | 'node-test-runner' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nx' | 'nyc' | 'oclif' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'postcss' | 'preconstruct' | 'prettier' | 'react-cosmos' | 'release-it' | 'remark' | 'remix' | 'rollup' | 'rsbuild' | 'rspack' | 'semantic-release' | 'sentry' | 'simple-git-hooks' | 'size-limit' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'syncpack' | 'tailwind' | 'travis' | 'ts-node' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'vercel-og' | 'vike' | 'vite' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'xo' | 'yarn' | 'yorkie';
-export declare const pluginNames: readonly ["angular", "astro", "ava", "babel", "c8", "capacitor", "changesets", "commitizen", "commitlint", "cspell", "cucumber", "cypress", "dotenv", "drizzle", "eleventy", "eslint", "expo", "gatsby", "github-actions", "glob", "graphql-codegen", "husky", "jest", "karma", "ladle", "lefthook", "lint-staged", "linthtml", "lockfile-lint", "lost-pixel", "markdownlint", "metro", "mocha", "moonrepo", "msw", "nest", "netlify", "next", "node", "node-test-runner", "nodemon", "npm-package-json-lint", "nuxt", "nx", "nyc", "oclif", "playwright", "playwright-ct", "playwright-test", "plop", "postcss", "preconstruct", "prettier", "react-cosmos", "release-it", "remark", "remix", "rollup", "rsbuild", "rspack", "semantic-release", "sentry", "simple-git-hooks", "size-limit", "storybook", "stryker", "stylelint", "svelte", "syncpack", "tailwind", "travis", "ts-node", "tsup", "tsx", "typedoc", "typescript", "unbuild", "unocss", "vercel-og", "vike", "vite", "vitest", "vue", "webdriver-io", "webpack", "wireit", "wrangler", "xo", "yarn", "yorkie"];
+export type PluginName = 'angular' | 'astro' | 'ava' | 'babel' | 'c8' | 'capacitor' | 'changesets' | 'commitizen' | 'commitlint' | 'cspell' | 'cucumber' | 'cypress' | 'dependency-cruiser' | 'dotenv' | 'drizzle' | 'eleventy' | 'eslint' | 'expo' | 'gatsby' | 'github-actions' | 'glob' | 'graphql-codegen' | 'husky' | 'jest' | 'karma' | 'ladle' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lockfile-lint' | 'lost-pixel' | 'markdownlint' | 'metro' | 'mocha' | 'moonrepo' | 'msw' | 'nest' | 'netlify' | 'next' | 'node' | 'node-test-runner' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nx' | 'nyc' | 'oclif' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'postcss' | 'preconstruct' | 'prettier' | 'react-cosmos' | 'release-it' | 'remark' | 'remix' | 'rollup' | 'rsbuild' | 'rspack' | 'semantic-release' | 'sentry' | 'simple-git-hooks' | 'size-limit' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'syncpack' | 'tailwind' | 'travis' | 'ts-node' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'vercel-og' | 'vike' | 'vite' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'xo' | 'yarn' | 'yorkie';
+export declare const pluginNames: readonly ["angular", "astro", "ava", "babel", "c8", "capacitor", "changesets", "commitizen", "commitlint", "cspell", "cucumber", "cypress", "dependency-cruiser", "dotenv", "drizzle", "eleventy", "eslint", "expo", "gatsby", "github-actions", "glob", "graphql-codegen", "husky", "jest", "karma", "ladle", "lefthook", "lint-staged", "linthtml", "lockfile-lint", "lost-pixel", "markdownlint", "metro", "mocha", "moonrepo", "msw", "nest", "netlify", "next", "node", "node-test-runner", "nodemon", "npm-package-json-lint", "nuxt", "nx", "nyc", "oclif", "playwright", "playwright-ct", "playwright-test", "plop", "postcss", "preconstruct", "prettier", "react-cosmos", "release-it", "remark", "remix", "rollup", "rsbuild", "rspack", "semantic-release", "sentry", "simple-git-hooks", "size-limit", "storybook", "stryker", "stylelint", "svelte", "syncpack", "tailwind", "travis", "ts-node", "tsup", "tsx", "typedoc", "typescript", "unbuild", "unocss", "vercel-og", "vike", "vite", "vitest", "vue", "webdriver-io", "webpack", "wireit", "wrangler", "xo", "yarn", "yorkie"];

package/dist/types/PluginNames.js

@@ -11,6 +11,7 @@ export const pluginNames = [
     'cspell',
     'cucumber',
     'cypress',
+    'dependency-cruiser',
     'dotenv',
     'drizzle',
     'eleventy',

package/dist/types/config.d.ts

@@ -15,7 +15,7 @@ export interface GetInputsFromScriptsOptions extends BaseOptions {
 export type GetInputsFromScripts<T = GetInputsFromScriptsOptions> = (npmScripts: string | string[] | Set<string>, options: T) => Input[];
 export type GetInputsFromScriptsPartial = (npmScripts: string | string[] | Set<string>, options?: Partial<GetInputsFromScriptsOptions>) => Input[];
 type FromArgs = (args: string[]) => Input[];
-interface BinaryResolverOptions extends GetInputsFromScriptsOptions {
+export interface BinaryResolverOptions extends GetInputsFromScriptsOptions {
     fromArgs: FromArgs;
 }
 export type BinaryResolver = (binary: string, args: string[], options: BinaryResolverOptions) => Input[];
@@ -92,7 +92,6 @@ export type ResolveConfig<T = any> = (config: T, options: PluginOptions) => Prom
 export type Resolve = (options: PluginOptions) => Promise<Input[]> | Input[];
 export interface Plugin {
     title: string;
-    note?: string;
     args?: Args;
     packageJsonPath?: string | ((manifest: PackageJson) => string);
     enablers?: IgnorePatterns | string;

package/dist/typescript/visitors/helpers.d.ts

@@ -5,4 +5,4 @@ export declare const isNotJS: (sourceFile: BoundSourceFile) => boolean;
 export declare const isJS: (sourceFile: BoundSourceFile) => boolean;
 export declare const isModule: (sourceFile: BoundSourceFile) => boolean;
 export declare function getImportsFromPragmas(sourceFile: BoundSourceFile): ImportNode[];
-export declare function hasImportSpecifier(node: ts.Statement, name: string): boolean;
+export declare function hasImportSpecifier(node: ts.Statement, name: string, id?: string): boolean;

package/dist/typescript/visitors/helpers.js

@@ -29,11 +29,11 @@ export function getImportsFromPragmas(sourceFile) {
     }
     return importNodes;
 }
-export function hasImportSpecifier(node, name) {
+export function hasImportSpecifier(node, name, id) {
     return (ts.isImportDeclaration(node) &&
         ts.isStringLiteral(node.moduleSpecifier) &&
         node.moduleSpecifier.text === name &&
         !!node.importClause?.namedBindings &&
         ts.isNamedImports(node.importClause.namedBindings) &&
-        node.importClause.namedBindings.elements.some(element => element.name.text === '$'));
+        (!id || node.importClause.namedBindings.elements.some(element => element.name.text === id)));
 }

package/dist/typescript/visitors/scripts/bun.js

@@ -2,7 +2,7 @@ import ts from 'typescript';
 import { stripQuotes } from '../../ast-helpers.js';
 import { hasImportSpecifier } from '../helpers.js';
 import { scriptVisitor as visit } from '../index.js';
-export default visit(sourceFile => sourceFile.statements.some(node => hasImportSpecifier(node, 'bun')), node => {
+export default visit(sourceFile => sourceFile.statements.some(node => hasImportSpecifier(node, 'bun', '$')), node => {
     if (ts.isTaggedTemplateExpression(node) && node.tag.getText() === '$') {
         return stripQuotes(node.template.getText());
     }

package/dist/typescript/visitors/scripts/execa.js

@@ -2,10 +2,33 @@ import ts from 'typescript';
 import { stripQuotes } from '../../ast-helpers.js';
 import { hasImportSpecifier } from '../helpers.js';
 import { scriptVisitor as visit } from '../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 => {
     if (ts.isTaggedTemplateExpression(node)) {
-        if (node.tag.getText() === '$' || (ts.isCallExpression(node.tag) && node.tag.expression.getText() === '$')) {
+        if (tags.has(node.tag.getText()) || (ts.isCallExpression(node.tag) && tags.has(node.tag.expression.getText()))) {
             return stripQuotes(node.template.getText());
         }
     }
+    if (ts.isCallExpression(node)) {
+        const functionName = node.expression.getText();
+        if (methods.has(functionName)) {
+            if (functionName.startsWith('execaCommand')) {
+                if (node.arguments[0] && ts.isStringLiteral(node.arguments[0])) {
+                    return stripQuotes(node.arguments[0].getText());
+                }
+            }
+            else {
+                const [executable, args] = node.arguments;
+                if (executable && ts.isStringLiteral(executable)) {
+                    const executableStr = stripQuotes(executable.getText());
+                    if (args && ts.isArrayLiteralExpression(args)) {
+                        const argStrings = args.elements.filter(ts.isStringLiteral).map(arg => stripQuotes(arg.getText()));
+                        return [executableStr, ...argStrings].join(' ');
+                    }
+                    return executableStr;
+                }
+            }
+        }
+    }
 });

package/dist/util/get-referenced-inputs.js

@@ -16,7 +16,7 @@ export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnore
         const binaryName = fromBinary(input);
         const inputWorkspace = getWorkspaceFor(input, chief, workspace);
         const isHandled = deputy.maybeAddReferencedBinary(inputWorkspace, binaryName);
-        if (isHandled)
+        if (isHandled || input.optional)
             return;
         collector.addIssue({
             type: 'binaries',
@@ -35,7 +35,7 @@ export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnore
             const isHandled = deputy.maybeAddReferencedExternalDependency(inputWorkspace, packageName);
             if (isWorkspace || isDependency(input)) {
                 if (!isHandled) {
-                    if ((deputy.isProduction && input.production) || !deputy.isProduction) {
+                    if (!input.optional && ((deputy.isProduction && input.production) || !deputy.isProduction)) {
                         collector.addIssue({
                             type: 'unlisted',
                             filePath: containingFilePath,
@@ -47,7 +47,7 @@ export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnore
                     return;
                 }
                 const ref = _resolveSync(specifier, dirname(containingFilePath));
-                if (ref && !isGitIgnored(ref))
+                if (ref && isInternal(ref) && !isGitIgnored(ref))
                     return ref;
             }
             if (isHandled)
@@ -63,6 +63,8 @@ export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnore
     if (resolvedFilePath && isInternal(resolvedFilePath)) {
         return isGitIgnored(resolvedFilePath) ? undefined : resolvedFilePath;
     }
+    if (input.optional)
+        return;
     if (!isInternal(filePath)) {
         collector.addIssue({
             type: 'unlisted',