knip 2.1.1 → 2.1.2

package/README.md

@@ -72,14 +72,15 @@ file. Let's say you are using `.ts` files excusively and have all source files o
 The `entry` files target the starting point(s) to resolve the rest of the imported code. The `project` files should
 contain all files to match against the files resolved from the entry files, including potentially unused files.
 
-Places where Knip looks for configuration:
+Places where Knip looks for configuration (ordered by priority):
 
 - `knip.json`
 - `knip.jsonc`
 - `.knip.json`
 - `.knip.jsonc`
-- `knip.js`
 - `knip.ts`
+- `knip.js`
+- `package.json#knip`
 
 So you can use a dynamic `knip.ts` with TypeScript if you prefer:
 
@@ -510,6 +511,9 @@ Such variables and types can be marked with the JSDoc `@public` tag:
  */
 
 export const merge = function () {};
+
+/** @public */
+export const split = function () {};
 ```
 
 Knip does not report public exports and types as unused.

package/dist/binaries/bash-parser.js

@@ -1,5 +1,6 @@
 import parse from 'bash-parser';
 import parseArgs from 'minimist';
+import { debugLogObject } from '../util/debug.js';
 import * as FallbackResolver from './resolvers/fallback.js';
 import * as KnownResolvers from './resolvers/index.js';
 const spawningBinaries = ['cross-env', 'dotenv'];
@@ -52,6 +53,12 @@ export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly
                 return [];
         }
     });
-    const parsed = parse(script);
-    return parsed?.commands ? getBinariesFromNodes(parsed.commands) : [];
+    try {
+        const parsed = parse(script);
+        return parsed?.commands ? getBinariesFromNodes(parsed.commands) : [];
+    }
+    catch (error) {
+        debugLogObject('Bash parser error', error);
+        return [];
+    }
 };

package/dist/cli.js

@@ -3,7 +3,7 @@ import './util/register.js';
 import prettyMilliseconds from 'pretty-ms';
 import reporters from './reporters/index.js';
 import parsedArgs, { helpText } from './util/cli-arguments.js';
-import { ConfigurationError, LoaderError } from './util/errors.js';
+import { isKnownError, ConfigurationError } from './util/errors.js';
 import { _load } from './util/loader.js';
 import { cwd, resolve } from './util/path.js';
 import { Performance } from './util/performance.js';
@@ -46,15 +46,12 @@ const run = async () => {
         }
     }
     catch (error) {
-        if (error instanceof ConfigurationError) {
-            console.error(error.message + '\n');
-            console.log(helpText);
-            process.exit(1);
-        }
-        else if (error instanceof LoaderError) {
+        if (error instanceof Error && isKnownError(error)) {
             console.error(error.message);
             if (error.cause instanceof Error)
                 console.error('Reason:', error.cause.message);
+            if (error instanceof ConfigurationError)
+                console.log('\n' + helpText);
             process.exit(1);
         }
         throw error;

package/dist/index.js

@@ -6,7 +6,7 @@ import { IssueCollector } from './issue-collector.js';
 import { PrincipalFactory } from './principal-factory.js';
 import { compact } from './util/array.js';
 import { debugLogObject, debugLogArray, debugLog } from './util/debug.js';
-import { ConfigurationError } from './util/errors.js';
+import { LoaderError } from './util/errors.js';
 import { findFile } from './util/fs.js';
 import { _glob } from './util/glob.js';
 import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from './util/modules.js';
@@ -38,7 +38,7 @@ export const main = async (unresolvedConfiguration) => {
         const manifestPath = isRoot ? chief.manifestPath : findFile(dir, 'package.json');
         const manifest = isRoot ? chief.manifest : manifestPath && _require(manifestPath);
         if (!manifestPath || !manifest)
-            throw new ConfigurationError(`Unable to load package.json for ${name}`);
+            throw new LoaderError(`Unable to load package.json for ${name}`);
         deputy.addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies });
         const compilerOptions = await loadCompilerOptions(join(dir, tsConfigFile ?? 'tsconfig.json'));
         const principal = factory.getPrincipal({ cwd: dir, report: report, paths, compilerOptions, compilers });

package/dist/principal-factory.d.ts

@@ -6,7 +6,7 @@ type Paths = ts.CompilerOptions['paths'];
 type Principal = {
     principal: ProjectPrincipal;
     cwds: Set<string>;
-    paths: Set<string>;
+    pathKeys: Set<string>;
 };
 type Principals = Set<Principal>;
 type Options = {

package/dist/principal-factory.js

@@ -1,12 +1,11 @@
 import { ProjectPrincipal } from './project-principal.js';
 import { join, isAbsolute } from './util/path.js';
-const mergePaths = (cwd, compilerOptions = {}, paths = {}) => {
-    const mergedPaths = { ...compilerOptions.paths, ...paths };
-    const baseUrl = compilerOptions.baseUrl ?? '.';
-    compilerOptions.paths = Object.keys(mergedPaths).reduce((paths, key) => {
-        paths[key] = mergedPaths[key].map(entry => isAbsolute(entry) ? entry : isAbsolute(baseUrl) ? join(baseUrl, entry) : join(cwd, baseUrl, entry));
-        return paths;
+const mergePaths = (cwd, compilerOptions, paths = {}) => {
+    const overridePaths = Object.keys(paths).reduce((overridePaths, key) => {
+        overridePaths[key] = paths[key].map(entry => (isAbsolute(entry) ? entry : join(cwd, entry)));
+        return overridePaths;
     }, {});
+    compilerOptions.paths = { ...compilerOptions.paths, ...overridePaths };
     return compilerOptions;
 };
 export class PrincipalFactory {
@@ -26,22 +25,22 @@ export class PrincipalFactory {
         const workspacePaths = compilerOptions?.paths ? Object.keys(compilerOptions.paths) : [];
         const principal = Array.from(this.principals).find(principal => {
             if (compilerOptions.baseUrl === principal.principal.compilerOptions.baseUrl) {
-                return workspacePaths.every(p => !principal.paths.has(p));
+                return workspacePaths.every(p => !principal.pathKeys.has(p));
             }
             return !compilerOptions.baseUrl;
         });
         return principal;
     }
     linkPrincipal(principal, cwd, paths) {
-        Object.keys(paths ?? {}).forEach(p => principal.paths.add(p));
+        Object.keys(paths ?? {}).forEach(p => principal.pathKeys.add(p));
         principal.principal.compilerOptions.paths = { ...principal.principal.compilerOptions.paths, ...paths };
         principal.cwds.add(cwd);
     }
     addNewPrincipal({ cwd, compilerOptions, report, compilers }) {
         const principal = new ProjectPrincipal({ cwd, compilerOptions, report, compilers });
-        const paths = new Set(Object.keys(compilerOptions?.paths ?? {}));
+        const pathKeys = new Set(Object.keys(compilerOptions?.paths ?? {}));
         compilerOptions.baseUrl = join(cwd, compilerOptions.baseUrl ?? '.');
-        this.principals.add({ principal, cwds: new Set([cwd]), paths });
+        this.principals.add({ principal, cwds: new Set([cwd]), pathKeys });
         return principal;
     }
     getPrincipals() {

package/dist/util/errors.d.ts

@@ -2,3 +2,4 @@ export declare class ConfigurationError extends Error {
 }
 export declare class LoaderError extends Error {
 }
+export declare const isKnownError: (error: Error) => boolean;

package/dist/util/errors.js

@@ -2,3 +2,4 @@ export class ConfigurationError extends Error {
 }
 export class LoaderError extends Error {
 }
+export const isKnownError = (error) => error instanceof ConfigurationError || error instanceof LoaderError;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.1.1";
+export declare const version = "2.1.2";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.1.1';
+export const version = '2.1.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",