knip 0.0.0-angular.0

package/dist/util/glob.js

@@ -0,0 +1,59 @@
+import fg from 'fast-glob';
+import { globby } from 'globby';
+import { GLOBAL_IGNORE_PATTERNS, ROOT_WORKSPACE_NAME } from '../constants.js';
+import { compact } from './array.js';
+import { debugLogObject } from './debug.js';
+import { join, relative } from './path.js';
+import { timerify } from './Performance.js';
+export const prependDirToPattern = (workingDir, pattern) => {
+    if (pattern.startsWith('!'))
+        return '!' + join(workingDir, pattern.slice(1));
+    return join(workingDir, pattern);
+};
+export const negate = (pattern) => pattern.replace(/^!?/, '!');
+export const hasProductionSuffix = (pattern) => pattern.endsWith('!');
+export const hasNoProductionSuffix = (pattern) => !pattern.endsWith('!');
+const removeProductionSuffix = (pattern) => pattern.replace(/!$/, '');
+const negatedLast = (pattern) => (pattern.startsWith('!') ? 1 : -1);
+const glob = async ({ cwd, workingDir = cwd, patterns, ignore = [], gitignore = true }) => {
+    if (patterns.length === 0)
+        return [];
+    const relativePath = relative(cwd, workingDir);
+    const prepend = (pattern) => prependDirToPattern(relativePath, pattern);
+    const globPatterns = compact([patterns].flat().map(prepend).map(removeProductionSuffix)).sort(negatedLast);
+    if (globPatterns[0].startsWith('!'))
+        return [];
+    const ignorePatterns = compact([...ignore, ...GLOBAL_IGNORE_PATTERNS]);
+    debugLogObject(`Globbing (${relativePath || ROOT_WORKSPACE_NAME})`, { cwd, globPatterns, ignorePatterns });
+    return globby(globPatterns, {
+        cwd,
+        ignore: ignorePatterns,
+        gitignore,
+        absolute: true,
+        dot: true,
+    });
+};
+const pureGlob = async ({ cwd, patterns, ignore = [], gitignore = true }) => {
+    if (patterns.length === 0)
+        return [];
+    return globby(patterns, {
+        cwd,
+        ignore: [...ignore, ...GLOBAL_IGNORE_PATTERNS],
+        gitignore,
+        absolute: true,
+    });
+};
+const firstGlob = async ({ cwd, patterns }) => {
+    const stream = fg.stream(patterns.map(removeProductionSuffix), { cwd, ignore: GLOBAL_IGNORE_PATTERNS });
+    for await (const entry of stream) {
+        return entry;
+    }
+};
+const dirGlob = async ({ cwd, patterns }) => globby(patterns, {
+    cwd,
+    onlyDirectories: true,
+});
+export const _glob = timerify(glob);
+export const _pureGlob = timerify(pureGlob);
+export const _firstGlob = timerify(firstGlob);
+export const _dirGlob = timerify(dirGlob);

package/dist/util/loader.d.ts

@@ -0,0 +1 @@
+export declare const _load: (filePath: string) => Promise<any>;

package/dist/util/loader.js

@@ -0,0 +1,31 @@
+import { pathToFileURL } from 'node:url';
+import { LoaderError } from './errors.js';
+import { loadJSON, loadYAML, loadFile, parseJSON, parseYAML } from './fs.js';
+import { extname } from './path.js';
+import { timerify } from './Performance.js';
+import { jiti } from './register.js';
+const load = async (filePath) => {
+    try {
+        const ext = extname(filePath);
+        if (/rc$/.test(filePath)) {
+            const contents = await loadFile(filePath);
+            return parseYAML(contents).catch(() => parseJSON(filePath, contents));
+        }
+        if (ext === '.json' || ext === '.jsonc') {
+            return loadJSON(filePath);
+        }
+        if (ext === '.yaml' || ext === '.yml') {
+            return loadYAML(filePath);
+        }
+        if (ext === '.mjs') {
+            const fileUrl = pathToFileURL(filePath);
+            const imported = await import(fileUrl.href);
+            return imported.default ?? imported;
+        }
+        return jiti(filePath);
+    }
+    catch (error) {
+        throw new LoaderError(`Error loading ${filePath}`, { cause: error });
+    }
+};
+export const _load = timerify(load);

package/dist/util/map.d.ts

@@ -0,0 +1 @@
+export declare const getOrSet: <K extends string, V, T extends Map<K, V>>(map: T, key: K, value: V) => NonNullable<V>;

package/dist/util/map.js

@@ -0,0 +1,6 @@
+export const getOrSet = (map, key, value) => {
+    if (!map.has(key)) {
+        map.set(key, value);
+    }
+    return map.get(key);
+};

package/dist/util/modules.d.ts

@@ -0,0 +1,8 @@
+import type { PackageJson } from '@npmcli/package-json';
+export declare const getPackageNameFromModuleSpecifier: (moduleSpecifier: string) => string | undefined;
+export declare const getPackageNameFromFilePath: (value: string) => string;
+export declare const isMaybePackageName: (specifier: string) => boolean;
+export declare const isDefinitelyTyped: (packageName: string) => boolean;
+export declare const getDefinitelyTypedFor: (packageName: string) => string;
+export declare const getPackageFromDefinitelyTyped: (typedDependency: string) => string;
+export declare const getEntryPathFromManifest: (cwd: string, dir: string, manifest: PackageJson) => Promise<string[]>;

package/dist/util/modules.js

@@ -0,0 +1,52 @@
+import { _glob } from './glob.js';
+import { getStringValues } from './object.js';
+import { toPosix } from './path.js';
+export const getPackageNameFromModuleSpecifier = (moduleSpecifier) => {
+    if (!isMaybePackageName(moduleSpecifier))
+        return;
+    const parts = moduleSpecifier.split('/').slice(0, 2);
+    return moduleSpecifier.startsWith('@') ? parts.join('/') : parts[0];
+};
+export const getPackageNameFromFilePath = (value) => {
+    const match = toPosix(value).match(/(?<=node_modules\/)(@[^/]+\/[^/]+|[^/]+)/g);
+    if (match)
+        return match[match.length - 1];
+    return value;
+};
+export const isMaybePackageName = (specifier) => /^@?[a-z0-9]/.test(specifier);
+export const isDefinitelyTyped = (packageName) => packageName.startsWith('@types/');
+export const getDefinitelyTypedFor = (packageName) => {
+    if (isDefinitelyTyped(packageName))
+        return packageName;
+    if (packageName.startsWith('@'))
+        return '@types/' + packageName.slice(1).replace('/', '__');
+    return '@types/' + packageName;
+};
+export const getPackageFromDefinitelyTyped = (typedDependency) => {
+    if (typedDependency.includes('__')) {
+        const [scope, packageName] = typedDependency.split('__');
+        return `@${scope}/${packageName}`;
+    }
+    return typedDependency;
+};
+export const getEntryPathFromManifest = (cwd, dir, manifest) => {
+    const { main, bin, exports } = manifest;
+    const entryPaths = new Set();
+    if (typeof main === 'string')
+        entryPaths.add(main);
+    if (bin) {
+        if (typeof bin === 'string')
+            entryPaths.add(bin);
+        if (typeof bin === 'object')
+            Object.values(bin).forEach(bin => entryPaths.add(bin));
+    }
+    if (exports) {
+        if (typeof exports === 'string') {
+            entryPaths.add(exports);
+        }
+        else {
+            getStringValues(exports).forEach(item => entryPaths.add(item));
+        }
+    }
+    return _glob({ cwd, workingDir: dir, patterns: Array.from(entryPaths) });
+};

package/dist/util/object.d.ts

@@ -0,0 +1,3 @@
+export declare const getValuesByKeyDeep: (obj: any, key: string) => unknown[];
+export declare const getStringValues: (obj: any) => string[];
+export declare const getKeysByValue: <T>(obj: T, value: unknown) => (keyof T)[];

package/dist/util/object.js

@@ -0,0 +1,37 @@
+export const getValuesByKeyDeep = (obj, key) => {
+    const objects = [];
+    if (obj && typeof obj === 'object') {
+        for (const i in obj) {
+            if (obj[i] && typeof obj[i] === 'object') {
+                const values = getValuesByKeyDeep(obj[i], key);
+                objects.push(...values);
+            }
+            else if (i === key) {
+                objects.push(obj[i]);
+            }
+        }
+    }
+    return objects;
+};
+export const getStringValues = (obj) => {
+    let values = [];
+    for (const prop in obj) {
+        if (obj[prop]) {
+            if (typeof obj[prop] === 'string') {
+                values.push(obj[prop]);
+            }
+            else if (typeof obj[prop] === 'object') {
+                values = values.concat(getStringValues(obj[prop]));
+            }
+        }
+    }
+    return values;
+};
+export const getKeysByValue = (obj, value) => {
+    const keys = [];
+    for (const key in obj) {
+        if (obj[key] === value)
+            keys.push(key);
+    }
+    return keys;
+};

package/dist/util/path.d.ts

@@ -0,0 +1,11 @@
+export declare const dirname: (path: string) => string;
+export declare const extname: (path: string) => string;
+export declare const join: (...paths: string[]) => string;
+export declare const toPosix: (value: string) => string;
+export declare const cwd: string;
+export declare const resolve: (...paths: string[]) => string;
+export declare const relative: (from: string, to?: string) => string;
+export declare const isInNodeModules: (filePath: string) => boolean;
+export declare const toAbsolute: (id: string, base: string) => string;
+export declare const toRelative: (id: string) => string;
+export declare const isInternal: (id: string) => boolean;

package/dist/util/path.js

@@ -0,0 +1,13 @@
+import path from 'node:path';
+const isAbsolute = path.isAbsolute;
+export const dirname = path.posix.dirname;
+export const extname = path.posix.extname;
+export const join = path.posix.join;
+export const toPosix = (value) => value.split(path.sep).join(path.posix.sep);
+export const cwd = toPosix(process.cwd());
+export const resolve = (...paths) => paths.length === 1 ? path.posix.join(cwd, paths[0]) : path.posix.resolve(...paths);
+export const relative = (from, to) => path.posix.relative(to ? toPosix(from) : cwd, toPosix(to ?? from));
+export const isInNodeModules = (filePath) => filePath.includes('node_modules');
+export const toAbsolute = (id, base) => (isAbsolute(id) ? id : join(base, id));
+export const toRelative = (id) => (isAbsolute(id) ? relative(id) : id);
+export const isInternal = (id) => (id.startsWith('.') || isAbsolute(id)) && !isInNodeModules(id);

package/dist/util/plugin.d.ts

@@ -0,0 +1,3 @@
+export { _load as load } from './loader.js';
+export declare const toCamelCase: (name: string) => string;
+export declare const hasDependency: (dependencies: Set<string>, values: (string | RegExp)[]) => boolean;

package/dist/util/plugin.js

@@ -0,0 +1,14 @@
+export { _load as load } from './loader.js';
+export const toCamelCase = (name) => name.toLowerCase().replace(/(-[a-z])/g, group => group.toUpperCase().replace('-', ''));
+export const hasDependency = (dependencies, values) => values.some(value => {
+    if (typeof value === 'string') {
+        return dependencies.has(value);
+    }
+    else if (value instanceof RegExp) {
+        for (const dependency of dependencies) {
+            if (value.test(dependency))
+                return true;
+        }
+    }
+    return false;
+});

package/dist/util/register.d.ts

@@ -0,0 +1 @@
+export declare const jiti: any;

package/dist/util/register.js

@@ -0,0 +1,14 @@
+import module from 'node:module';
+import createJITI from 'jiti';
+import { IGNORED_FILE_EXTENSIONS, DEFAULT_EXTENSIONS } from '../constants.js';
+const _extensions = module.Module._extensions;
+export const jiti = createJITI(process.cwd(), { interopDefault: true, extensions: DEFAULT_EXTENSIONS });
+if (!('.ts' in _extensions)) {
+    jiti.register();
+}
+const exportFilePath = (module, filePath) => {
+    module.exports = filePath;
+};
+IGNORED_FILE_EXTENSIONS.forEach(ext => {
+    _extensions[ext] = exportFilePath;
+});

package/dist/util/reporter.d.ts

@@ -0,0 +1,3 @@
+import type { ReporterOptions } from '../types/issues.js';
+export declare const runPreprocessors: (data: ReporterOptions, processors?: any[]) => Promise<ReporterOptions>;
+export declare const runReporters: (options: ReporterOptions) => Promise<void>;

package/dist/util/reporter.js

@@ -0,0 +1,16 @@
+import internalReporters from '../reporters/index.js';
+import parsedArgValues from '../util/cli-arguments.js';
+import { _load } from './loader.js';
+import { isInternal, resolve } from './path.js';
+const { preprocessor = [], reporter = ['symbols'] } = parsedArgValues;
+const preprocessors = await Promise.all(preprocessor.map(proc => _load(isInternal(proc) ? resolve(proc) : proc)));
+export const runPreprocessors = (data, processors = preprocessors) => processors.length === 0 ? Promise.resolve(data) : runPreprocessors(processors[0](data), processors.slice(1));
+const reporters = await Promise.all(reporter.map(async (reporter) => {
+    return reporter in internalReporters
+        ? internalReporters[reporter]
+        : await _load(isInternal(reporter) ? resolve(reporter) : reporter);
+}));
+export const runReporters = async (options) => {
+    for (const reporter of reporters)
+        await reporter(options);
+};

package/dist/util/require.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" resolution-mode="require"/>
+export declare const _require: NodeRequire;
+export declare const _resolve: (specifier: string) => string;
+export declare const _tryResolve: (specifier: string, from: string) => string | undefined;
+export declare const _resolveSpecifier: (dir: string, specifier: string) => string | undefined;

package/dist/util/require.js

@@ -0,0 +1,34 @@
+import { createRequire as nodeCreateRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { debugLog } from './debug.js';
+import { getPackageNameFromModuleSpecifier } from './modules.js';
+import { cwd, toPosix, join } from './path.js';
+import { timerify } from './Performance.js';
+const createRequire = (path) => nodeCreateRequire(pathToFileURL(path ?? cwd));
+const require = createRequire();
+const resolve = (specifier) => toPosix(require.resolve(specifier));
+const tryResolve = (specifier, from) => {
+    try {
+        return resolve(specifier);
+    }
+    catch {
+        debugLog(`Unable to resolve ${specifier} (from ${from})`);
+    }
+};
+const resolveSpecifier = (dir, specifier) => {
+    try {
+        const require = createRequire(join(dir, 'package.json'));
+        return toPosix(require.resolve(specifier));
+    }
+    catch {
+        const packageName = getPackageNameFromModuleSpecifier(specifier);
+        if (packageName) {
+            const relativeSpecifier = specifier.replace(packageName, '.');
+            return tryResolve(join(dir, relativeSpecifier), dir);
+        }
+    }
+};
+export const _require = timerify(require);
+export const _resolve = timerify(resolve);
+export const _tryResolve = timerify(tryResolve);
+export const _resolveSpecifier = timerify(resolveSpecifier);

package/dist/util/tsconfig-loader.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare const loadTSConfig: (tsConfigFilePath: string) => Promise<ts.CompilerOptions>;

package/dist/util/tsconfig-loader.js

@@ -0,0 +1,11 @@
+import ts from 'typescript';
+import { isFile } from './fs.js';
+import { dirname } from './path.js';
+export const loadTSConfig = async (tsConfigFilePath) => {
+    if (isFile(tsConfigFilePath)) {
+        const config = ts.readConfigFile(tsConfigFilePath, ts.sys.readFile);
+        const parsedConfig = ts.parseJsonConfigFileContent(config.config, ts.sys, dirname(tsConfigFilePath));
+        return parsedConfig.options ?? {};
+    }
+    return {};
+};

package/dist/util/workspace.d.ts

@@ -0,0 +1 @@
+export declare const byPathDepth: (a: string, b: string) => number;

package/dist/util/workspace.js

@@ -0,0 +1,11 @@
+export const byPathDepth = (a, b) => {
+    const depthA = a.split('/');
+    const depthB = b.split('/');
+    if (depthA.length !== depthB.length)
+        return depthA.length - depthB.length;
+    if (depthA.includes('*') || depthA.includes('**'))
+        return -1;
+    if (depthB.includes('*') || depthB.includes('**'))
+        return 1;
+    return a.length - b.length;
+};

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "0.0.0-angular.0";

package/dist/version.js

@@ -0,0 +1 @@
+export const version = '0.0.0-angular.0';

package/license

@@ -0,0 +1,12 @@
+ISC License (ISC)
+
+Copyright 2022 Lars Kappert
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted,
+provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/package.json

@@ -0,0 +1,150 @@
+{
+  "name": "knip",
+  "version": "0.0.0-angular.0",
+  "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
+  "homepage": "https://github.com/webpro/knip",
+  "repository": "github:webpro/knip",
+  "bugs": "https://github.com/webpro/knip/issues",
+  "license": "ISC",
+  "author": {
+    "name": "Lars Kappert",
+    "email": "lars@webpro.nl"
+  },
+  "main": "./dist/index.js",
+  "bin": {
+    "knip": "./dist/cli.js"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "knip": "node ./dist/cli.js",
+    "knip:production": "node ./dist/cli.js --production --strict --ignore-internal",
+    "lint": "eslint scripts src tests",
+    "lint:fix": "eslint scripts src tests --fix",
+    "format": "prettier scripts src tests schema.json --with-node-modules --write --config .prettierrc",
+    "pretest": "node rmdir.js tmp && swc src -d tmp/src && swc tests -d tmp/tests",
+    "test": "node --no-warnings --test tmp",
+    "coverage": "c8 --reporter html node --no-warnings --loader tsx --test tests/*.test.ts tests/*/*.test.ts",
+    "watch": "rm $(which knip); npm link && tsc --watch",
+    "prebuild": "node rmdir.js dist",
+    "build": "tsc",
+    "docs": "npm run docs:cli && npm run docs:plugins && npm run docs:format",
+    "docs:cli": "tsx ./scripts/update-cli-usage-in-readme.ts",
+    "docs:plugins": "tsx ./scripts/generate-plugin-docs.ts",
+    "docs:format": "remark README.md docs/*.md .github/*.md src/plugins/*/README.md -o",
+    "qa": "npm run lint && npm run build && npm run knip && npm run knip:production && npm test",
+    "release": "release-it",
+    "create-plugin": "tsx --no-warnings ./scripts/create-new-plugin.ts",
+    "postcreate-plugin": "prettier schema.json src/ConfigurationValidator.ts --write --config .prettierrc --log-level silent"
+  },
+  "files": [
+    "dist",
+    "schema.json"
+  ],
+  "dependencies": {
+    "@ericcornelissen/bash-parser": "^0.5.2",
+    "@npmcli/map-workspaces": "^3.0.4",
+    "@snyk/github-codeowners": "^1.1.0",
+    "chalk": "^5.2.0",
+    "easy-table": "^1.2.0",
+    "fast-glob": "^3.2.12",
+    "globby": "^13.1.3",
+    "jiti": "^1.19.3",
+    "js-yaml": "^4.1.0",
+    "micromatch": "^4.0.5",
+    "minimist": "^1.2.8",
+    "pretty-ms": "^8.0.0",
+    "strip-json-comments": "^5.0.0",
+    "summary": "^2.1.0",
+    "typescript": "^5.0.2",
+    "zod": "^3.22.2",
+    "zod-validation-error": "^1.5.0"
+  },
+  "devDependencies": {
+    "@jest/types": "29.6.3",
+    "@npmcli/package-json": "5.0.0",
+    "@release-it/bumper": "5.1.0",
+    "@swc/cli": "0.1.62",
+    "@swc/core": "1.3.84",
+    "@types/eslint": "8.44.2",
+    "@types/js-yaml": "4.0.5",
+    "@types/micromatch": "4.0.2",
+    "@types/minimist": "1.2.2",
+    "@types/node": "20.6.0",
+    "@types/npmcli__map-workspaces": "3.0.1",
+    "@types/webpack": "5.28.2",
+    "@typescript-eslint/eslint-plugin": "6.7.0",
+    "@typescript-eslint/parser": "6.7.0",
+    "c8": "8.0.1",
+    "eslint": "8.49.0",
+    "eslint-import-resolver-typescript": "3.6.0",
+    "eslint-plugin-import": "2.28.1",
+    "eslint-plugin-n": "16.1.0",
+    "prettier": "3.0.3",
+    "release-it": "16.1.5",
+    "remark-cli": "11.0.0",
+    "remark-preset-webpro": "0.0.3",
+    "tsx": "3.12.8",
+    "type-fest": "4.3.1"
+  },
+  "engines": {
+    "node": ">=16.17.0 <17 || >=18.6.0"
+  },
+  "engineStrict": true,
+  "release-it": {
+    "hooks": {
+      "before:init": [
+        "npm run lint",
+        "npm run build",
+        "npm run knip",
+        "npm run knip:production",
+        "npm run docs",
+        "npm test"
+      ]
+    },
+    "github": {
+      "release": true,
+      "comments": {
+        "submit": true
+      }
+    },
+    "plugins": {
+      "@release-it/bumper": {
+        "out": "{dist,src}/version.*"
+      }
+    }
+  },
+  "remarkConfig": {
+    "plugins": [
+      "preset-webpro"
+    ]
+  },
+  "keywords": [
+    "find",
+    "detect",
+    "analyze",
+    "scan",
+    "lint",
+    "unused",
+    "unreferenced",
+    "unresolved",
+    "missing",
+    "unimported",
+    "files",
+    "dependencies",
+    "devDependencies",
+    "exports",
+    "types",
+    "members",
+    "namespaces",
+    "duplicates",
+    "typescript",
+    "maintenance",
+    "class",
+    "enum",
+    "members",
+    "workspace",
+    "workspaces",
+    "monorepo"
+  ]
+}