knip 0.0.0-angular.0

package/dist/binaries/resolvers/dotenv.js

@@ -0,0 +1,6 @@
+import parseArgs from 'minimist';
+import { toBinary, argsFrom } from '../util.js';
+export const resolve = (binary, args, { fromArgs }) => {
+    const parsed = parseArgs(args);
+    return [toBinary(binary), ...fromArgs(argsFrom(args, parsed._[0]))];
+};

package/dist/binaries/resolvers/fallback.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/binaries/resolvers/fallback.js

@@ -0,0 +1,22 @@
+import parseArgs from 'minimist';
+import { compact } from '../../util/array.js';
+import { toBinary, tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
+const withPositional = parsed => [parsed._[0], parsed.require].flat();
+const withoutPositional = parsed => [parsed.require].flat();
+const argFilters = {
+    'babel-node': withPositional,
+    esbuild: withPositional,
+    execa: withPositional,
+    'ts-node': withPositional,
+    zx: withPositional,
+    tsx: parsed => parsed._.filter(p => p !== 'watch'),
+    default: withoutPositional,
+};
+const spawningBinaries = ['cross-env', 'retry-cli'];
+export const resolve = (binary, args, { cwd, fromArgs }) => {
+    const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader'] }, boolean: ['quiet', 'verbose'] });
+    const bin = binary.startsWith('.') ? tryResolveFilePath(cwd, binary) : toBinary(binary);
+    const filteredArgs = binary in argFilters ? argFilters[binary](parsed) : argFilters.default(parsed);
+    const shiftedArgs = spawningBinaries.includes(binary) ? fromArgs(args) : [];
+    return compact([bin, ...tryResolveSpecifiers(cwd, filteredArgs), ...shiftedArgs]);
+};

package/dist/binaries/resolvers/index.d.ts

@@ -0,0 +1,8 @@
+export * as c8 from './c8.js';
+export * as dotenv from './dotenv.js';
+export * as node from './node.js';
+export * as nodemon from './nodemon.js';
+export * as npx from './npx.js';
+export * as pnpm from './pnpm.js';
+export * as rollup from './rollup.js';
+export * as yarn from './yarn.js';

package/dist/binaries/resolvers/index.js

@@ -0,0 +1,8 @@
+export * as c8 from './c8.js';
+export * as dotenv from './dotenv.js';
+export * as node from './node.js';
+export * as nodemon from './nodemon.js';
+export * as npx from './npx.js';
+export * as pnpm from './pnpm.js';
+export * as rollup from './rollup.js';
+export * as yarn from './yarn.js';

package/dist/binaries/resolvers/node.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/binaries/resolvers/node.js

@@ -0,0 +1,10 @@
+import parseArgs from 'minimist';
+import { compact } from '../../util/array.js';
+import { tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
+export const resolve = (binary, args, { cwd }) => {
+    const parsed = parseArgs(args, {
+        string: ['r'],
+        alias: { require: ['r', 'loader', 'experimental-loader', 'test-reporter'] },
+    });
+    return compact([tryResolveFilePath(cwd, parsed._[0]), ...tryResolveSpecifiers(cwd, [parsed.require].flat())]);
+};

package/dist/binaries/resolvers/nodemon.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/binaries/resolvers/nodemon.js

@@ -0,0 +1,15 @@
+import parseArgs from 'minimist';
+import { compact } from '../../util/array.js';
+import { toBinary, tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
+export const resolve = (binary, args, { cwd, fromArgs }) => {
+    const parsed = parseArgs(args, {
+        string: ['r', 'exec'],
+        alias: { require: ['r', 'loader', 'experimental-loader', 'test-reporter'] },
+    });
+    return compact([
+        toBinary(binary),
+        tryResolveFilePath(cwd, parsed._[0]),
+        ...tryResolveSpecifiers(cwd, [parsed.require].flat()),
+        ...fromArgs([parsed.exec]),
+    ]);
+};

package/dist/binaries/resolvers/npx.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/binaries/resolvers/npx.js

@@ -0,0 +1,20 @@
+import parseArgs from 'minimist';
+import { isInternal } from '../../util/path.js';
+import { getBinariesFromScript } from '../bash-parser.js';
+import { argsFrom, stripVersionFromSpecifier, toBinary } from '../util.js';
+export const resolve = (binary, args, { cwd, fromArgs, manifest }) => {
+    const parsed = parseArgs(args, {
+        boolean: ['yes', 'no'],
+        alias: { yes: 'y', no: 'no-install', package: 'p', call: 'c' },
+    });
+    const packageSpecifier = parsed._[0];
+    const specifier = packageSpecifier ? stripVersionFromSpecifier(packageSpecifier) : '';
+    const packages = parsed.package ? [parsed.package].flat().map(stripVersionFromSpecifier) : [];
+    const command = parsed.call ? getBinariesFromScript(parsed.call, { cwd, manifest }) : [];
+    const restArgs = argsFrom(args, packageSpecifier);
+    const dependencies = manifest ? Object.keys({ ...manifest.dependencies, ...manifest.devDependencies }) : [];
+    const isBinary = specifier && !packageSpecifier.includes('@') && !isInternal(specifier) && !dependencies.includes(specifier);
+    const dependency = isBinary ? toBinary(specifier) : specifier;
+    const specifiers = dependency && !parsed.yes ? [dependency] : [];
+    return [...specifiers, ...packages, ...command, ...fromArgs(restArgs).slice(1)];
+};

package/dist/binaries/resolvers/pnpm.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/binaries/resolvers/pnpm.js

@@ -0,0 +1,63 @@
+import parseArgs from 'minimist';
+import { toBinary } from '../util.js';
+const commands = [
+    'add',
+    'audit',
+    'bin',
+    'config',
+    'dedupe',
+    'deploy',
+    'dlx',
+    'doctor',
+    'env',
+    'fetch',
+    'i',
+    'import',
+    'init',
+    'install-test',
+    'install',
+    'it',
+    'licenses',
+    'link',
+    'list',
+    'ln',
+    'ls',
+    'outdated',
+    'outdated',
+    'pack',
+    'patch-commit',
+    'patch-remove',
+    'patch',
+    'prune',
+    'publish',
+    'rb',
+    'rebuild',
+    'remove',
+    'rm',
+    'root',
+    'run',
+    'server',
+    'setup',
+    'start',
+    'store',
+    't',
+    'test',
+    'tst',
+    'un',
+    'uninstall',
+    'unlink',
+    'up',
+    'update',
+    'upgrade',
+    'why',
+];
+export const resolve = (_binary, args, { manifest }) => {
+    const scripts = manifest.scripts ? Object.keys(manifest.scripts) : [];
+    const parsed = parseArgs(args, { alias: { recursive: 'r' }, boolean: ['recursive'] });
+    const [command, binary] = parsed._;
+    if (scripts.includes(command) || commands.includes(command))
+        return [];
+    if (command === 'exec')
+        return [toBinary(binary)];
+    return command ? [toBinary(command)] : [];
+};

package/dist/binaries/resolvers/rollup.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/binaries/resolvers/rollup.js

@@ -0,0 +1,11 @@
+import parseArgs from 'minimist';
+import { compact } from '../../util/array.js';
+import { toBinary, tryResolveSpecifiers } from '../util.js';
+export const resolve = (binary, args, { cwd, fromArgs }) => {
+    const safeArgs = args.filter(arg => arg !== '--watch');
+    const parsed = parseArgs(safeArgs, { alias: { plugin: 'p' } });
+    const watchers = parsed.watch ? fromArgs(Object.values(parsed.watch)) : [];
+    const plugins = parsed.plugin ? tryResolveSpecifiers(cwd, [parsed.plugin].flat()) : [];
+    const configPlugins = parsed.configPlugin ? tryResolveSpecifiers(cwd, [parsed.configPlugin].flat()) : [];
+    return compact([toBinary(binary), ...watchers, ...plugins, ...configPlugins]);
+};

package/dist/binaries/resolvers/yarn.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/binaries/resolvers/yarn.js

@@ -0,0 +1,48 @@
+import parseArgs from 'minimist';
+import { toBinary } from '../util.js';
+const commands = [
+    'add',
+    'bin',
+    'cache',
+    'config',
+    'constraints',
+    'dedupe',
+    'dlx',
+    'explain',
+    'info',
+    'init',
+    'install',
+    'link',
+    'pack',
+    'patch-commit',
+    'patch',
+    'plugin',
+    'rebuild',
+    'remove',
+    'search',
+    'set',
+    'stage',
+    'unlink',
+    'unplug',
+    'up',
+    'upgrade-interactive',
+    'upgrade',
+    'version',
+    'why',
+    'workspace',
+    'workspaces',
+];
+export const resolve = (_binary, args, { manifest, fromArgs }) => {
+    const scripts = manifest.scripts ? Object.keys(manifest.scripts) : [];
+    const parsed = parseArgs(args, {});
+    const [command, binary] = parsed._;
+    if (scripts.includes(command) || commands.includes(command))
+        return [];
+    if (command === 'run' && scripts.includes(binary))
+        return [];
+    if (command === 'run' || command === 'exec')
+        return [toBinary(binary)];
+    if (command === 'node')
+        return fromArgs(parsed._);
+    return command ? [toBinary(command)] : [];
+};

package/dist/binaries/types.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="npmcli__package-json" />
+import type { PackageJson } from '@npmcli/package-json';
+type Options = {
+    cwd?: string;
+    manifest?: PackageJson;
+    knownGlobalsOnly?: boolean;
+};
+export type GetDependenciesFromScripts = (npmScripts: string | string[] | Set<string>, options?: Options) => string[];
+type FromArgs = (args: string[]) => string[];
+export type Resolver = (binary: string, args: string[], options: {
+    cwd: string;
+    manifest: PackageJson;
+    fromArgs: FromArgs;
+}) => string[];
+export {};

package/dist/binaries/types.js

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

package/dist/binaries/util.d.ts

@@ -0,0 +1,8 @@
+export declare const tryResolveFilePath: (cwd: string, specifier: string, acceptModuleSpecifier?: boolean) => string | undefined;
+export declare const tryResolveSpecifiers: (cwd: string, specifiers: string[]) => (string | undefined)[];
+export declare const toBinary: (specifier: string) => string;
+export declare const fromBinary: (specifier: string) => string;
+export declare const isBinary: (specifier: string) => boolean;
+export declare const stripVersionFromSpecifier: (specifier: string) => string;
+export declare const stripBinaryPath: (command: string) => string;
+export declare const argsFrom: (args: string[], from: string) => string[];

package/dist/binaries/util.js

@@ -0,0 +1,33 @@
+import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from '../util/modules.js';
+import { isInNodeModules, join } from '../util/path.js';
+import { _tryResolve } from '../util/require.js';
+export const tryResolveFilePath = (cwd, specifier, acceptModuleSpecifier) => {
+    if (specifier) {
+        const filePath = join(cwd, specifier);
+        if (!isInNodeModules(filePath)) {
+            const resolvedFilePath = _tryResolve(filePath, cwd);
+            if (resolvedFilePath) {
+                return resolvedFilePath;
+            }
+            else if (acceptModuleSpecifier) {
+                return getPackageNameFromModuleSpecifier(specifier);
+            }
+        }
+        else if (specifier.includes('node_modules/.bin')) {
+            return toBinary(stripBinaryPath(specifier));
+        }
+        else {
+            return getPackageNameFromFilePath(specifier);
+        }
+    }
+};
+export const tryResolveSpecifiers = (cwd, specifiers) => specifiers.map(specifier => tryResolveFilePath(cwd, specifier, true));
+export const toBinary = (specifier) => specifier.replace(/^(bin:)?/, 'bin:');
+export const fromBinary = (specifier) => specifier.replace(/^(bin:)?/, '');
+export const isBinary = (specifier) => specifier.startsWith('bin:');
+export const stripVersionFromSpecifier = (specifier) => specifier.replace(/(\S+)@.*/, '$1');
+const stripNodeModulesFromPath = (command) => command.replace(/^(\.\/)?node_modules\//, '');
+export const stripBinaryPath = (command) => stripVersionFromSpecifier(stripNodeModulesFromPath(command)
+    .replace(/^(\.bin\/)/, '')
+    .replace(/\$\(npm bin\)\/(\w+)/, '$1'));
+export const argsFrom = (args, from) => args.slice(args.indexOf(from));

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import './util/register.js';

package/dist/cli.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import './util/register.js';
+import prettyMilliseconds from 'pretty-ms';
+import parsedArgValues, { helpText } from './util/cli-arguments.js';
+import { isKnownError, getKnownError, isConfigurationError, hasCause } from './util/errors.js';
+import { cwd } from './util/path.js';
+import { Performance } from './util/Performance.js';
+import { runPreprocessors, runReporters } from './util/reporter.js';
+import { version } from './version.js';
+import { main } from './index.js';
+const { debug: isDebug = false, help: isHelp, 'max-issues': maxIssues = '0', 'no-config-hints': noConfigHints = false, 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = false, 'ignore-internal': isIgnoreInternal = false, 'include-entry-exports': isIncludeEntryExports = false, performance: isObservePerf = false, production: isProduction = false, 'reporter-options': reporterOptions = '', strict: isStrict = false, tsConfig, version: isVersion, } = parsedArgValues;
+if (isHelp) {
+    console.log(helpText);
+    process.exit(0);
+}
+if (isVersion) {
+    console.log(version);
+    process.exit(0);
+}
+const isShowProgress = !isDebug && isNoProgress === false && process.stdout.isTTY && typeof process.stdout.cursorTo === 'function';
+const run = async () => {
+    try {
+        const perfObserver = new Performance(isObservePerf);
+        const { report, issues, counters, rules, configurationHints } = await main({
+            cwd,
+            tsConfigFile: tsConfig,
+            gitignore: !isNoGitIgnore,
+            isProduction,
+            isStrict,
+            isIgnoreInternal,
+            isShowProgress,
+            isIncludeEntryExports,
+        });
+        const initialData = {
+            report,
+            issues,
+            configurationHints,
+            noConfigHints,
+            cwd,
+            isProduction,
+            isShowProgress,
+            options: reporterOptions,
+        };
+        const finalData = await runPreprocessors(initialData);
+        await runReporters(finalData);
+        const totalErrorCount = Object.keys(report)
+            .filter(reportGroup => report[reportGroup] && rules[reportGroup] === 'error')
+            .reduce((errorCount, reportGroup) => errorCount + counters[reportGroup], 0);
+        if (isObservePerf) {
+            await perfObserver.finalize();
+            console.log('\n' + perfObserver.getTable());
+            console.log('\nTotal running time:', prettyMilliseconds(perfObserver.getTotalTime()));
+            perfObserver.reset();
+        }
+        if (!noExitCode && totalErrorCount > Number(maxIssues)) {
+            process.exit(totalErrorCount);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && isKnownError(error)) {
+            const knownError = getKnownError(error);
+            console.error(knownError.message);
+            if (hasCause(knownError))
+                console.error('Reason:', knownError.cause.message);
+            if (isConfigurationError(knownError))
+                console.log('\n' + helpText);
+            process.exit(1);
+        }
+        throw error;
+    }
+};
+await run();

package/dist/constants.d.ts

@@ -0,0 +1,12 @@
+import type { IssueType } from './types/issues.js';
+export declare const ROOT_WORKSPACE_NAME = ".";
+export declare const KNIP_CONFIG_LOCATIONS: string[];
+export declare const DEFAULT_EXTENSIONS: string[];
+export declare const TEST_FILE_PATTERNS: string[];
+export declare const GLOBAL_IGNORE_PATTERNS: string[];
+export declare const IGNORED_GLOBAL_BINARIES: string[];
+export declare const IGNORED_DEPENDENCIES: string[];
+export declare const IGNORED_FILE_EXTENSIONS: string[];
+export declare const IGNORE_DEFINITELY_TYPED: string[];
+export declare const ISSUE_TYPES: IssueType[];
+export declare const ISSUE_TYPE_TITLE: Record<IssueType, string>;

package/dist/constants.js

@@ -0,0 +1,90 @@
+export const ROOT_WORKSPACE_NAME = '.';
+export const KNIP_CONFIG_LOCATIONS = ['knip.json', 'knip.jsonc', '.knip.json', '.knip.jsonc', 'knip.ts', 'knip.js'];
+export const DEFAULT_EXTENSIONS = ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx', '.mts', '.cts'];
+export const TEST_FILE_PATTERNS = [
+    '**/*{.,-}{test,spec}.{js,jsx,ts,tsx,mjs,cjs}',
+    '**/{test,__tests__}/**/*.{js,jsx,ts,tsx,mjs,cjs}',
+];
+export const GLOBAL_IGNORE_PATTERNS = ['**/node_modules/**', '.yarn'];
+export const IGNORED_GLOBAL_BINARIES = [
+    'bash',
+    'bun',
+    'cat',
+    'cd',
+    'chmod',
+    'cp',
+    'deno',
+    'dirname',
+    'echo',
+    'exec',
+    'exit',
+    'git',
+    'grep',
+    'mkdir',
+    'mv',
+    'node',
+    'npm',
+    'npx',
+    'pnpm',
+    'pnpx',
+    'rm',
+    'sh',
+    'sudo',
+    'test',
+    'true',
+    'yarn',
+];
+export const IGNORED_DEPENDENCIES = ['knip', 'typescript'];
+export const IGNORED_FILE_EXTENSIONS = [
+    '.avif',
+    '.css',
+    '.eot',
+    '.gif',
+    '.ico',
+    '.jpeg',
+    '.jpg',
+    '.less',
+    '.png',
+    '.sass',
+    '.scss',
+    '.svg',
+    '.ttf',
+    '.webp',
+    '.woff',
+    '.woff2',
+    '.yaml',
+    '.yml',
+];
+export const IGNORE_DEFINITELY_TYPED = ['node'];
+export const ISSUE_TYPES = [
+    'files',
+    'dependencies',
+    'devDependencies',
+    'optionalPeerDependencies',
+    'unlisted',
+    'binaries',
+    'unresolved',
+    'exports',
+    'nsExports',
+    'types',
+    'nsTypes',
+    'enumMembers',
+    'classMembers',
+    'duplicates',
+];
+export const ISSUE_TYPE_TITLE = {
+    files: 'Unused files',
+    dependencies: 'Unused dependencies',
+    devDependencies: 'Unused devDependencies',
+    optionalPeerDependencies: 'Referenced optional peerDependencies',
+    unlisted: 'Unlisted dependencies',
+    binaries: 'Unlisted binaries',
+    unresolved: 'Unresolved imports',
+    exports: 'Unused exports',
+    nsExports: 'Unused exports in namespaces',
+    types: 'Unused exported types',
+    nsTypes: 'Unused exported types in namespaces',
+    enumMembers: 'Unused exported enum members',
+    classMembers: 'Unused exported class members',
+    duplicates: 'Duplicate exports',
+};

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import type { CommandLineOptions } from './types/cli.js';
+export type { RawConfiguration as KnipConfig } from './types/config.js';
+export type { Preprocessor, Reporter, ReporterOptions } from './types/issues.js';
+export declare const main: (unresolvedConfiguration: CommandLineOptions) => Promise<{
+    report: import("./types/issues.js").Report;
+    issues: import("./types/issues.js").Issues;
+    counters: import("./types/issues.js").Counters;
+    rules: import("./types/issues.js").Rules;
+    configurationHints: Set<import("./types/issues.js").ConfigurationHint>;
+}>;