knip 4.6.0 → 5.0.0

package/dist/constants.js

@@ -94,9 +94,9 @@ export const ISSUE_TYPE_TITLE = {
     binaries: 'Unlisted binaries',
     unresolved: 'Unresolved imports',
     exports: 'Unused exports',
-    nsExports: 'Unused exports in namespaces',
+    nsExports: 'Exports in used namespace',
     types: 'Unused exported types',
-    nsTypes: 'Unused exported types in namespaces',
+    nsTypes: 'Exported types in used namespace',
     enumMembers: 'Unused exported enum members',
     classMembers: 'Unused exported class members',
     duplicates: 'Duplicate exports',

package/dist/index.js

@@ -18,6 +18,7 @@ import { fromBinary, isBinary } from './util/protocols.js';
 import { _resolveSpecifier } from './util/require.js';
 import { shouldIgnore } from './util/tag.js';
 import { loadTSConfig } from './util/tsconfig-loader.js';
+import { getType, getHasStrictlyNsReferences } from './util/type.js';
 import { WorkspaceWorker } from './WorkspaceWorker.js';
 export const main = async (unresolvedConfiguration) => {
     const { cwd, tsConfigFile, gitignore, isStrict, isProduction, isShowProgress, isIncludeEntryExports, isIsolateWorkspaces, tags, isFix, fixTypes, } = unresolvedConfiguration;
@@ -457,17 +458,18 @@ export const main = async (unresolvedConfiguration) => {
                             continue;
                         }
                     }
-                    const hasNsImport = Boolean(importsForExport?.hasStar);
+                    const [hasStrictlyNsReferences, namespace] = getHasStrictlyNsReferences(importsForExport);
                     const isType = ['enum', 'type', 'interface'].includes(exportedItem.type);
-                    if (hasNsImport && ((!report.nsTypes && isType) || (!report.nsExports && !isType)))
+                    if (hasStrictlyNsReferences && ((!report.nsTypes && isType) || (!report.nsExports && !isType)))
                         continue;
                     if (!isExportedItemReferenced(exportedItem)) {
-                        const type = isType ? (hasNsImport ? 'nsTypes' : 'types') : hasNsImport ? 'nsExports' : 'exports';
+                        const type = getType(hasStrictlyNsReferences, isType);
                         collector.addIssue({
                             type,
                             filePath,
                             symbol: identifier,
                             symbolType: exportedItem.type,
+                            parentSymbol: namespace,
                             pos: exportedItem.pos,
                             line: exportedItem.line,
                             col: exportedItem.col,

package/dist/reporters/json.js

@@ -2,7 +2,6 @@ import { OwnershipEngine } from '@snyk/github-codeowners/dist/lib/ownership/inde
 import { isFile } from '../util/fs.js';
 import { relative, resolve } from '../util/path.js';
 import { convert } from './util.js';
-const mergeTypes = (type) => type === 'exports' || type === 'nsExports' ? 'exports' : type === 'types' || type === 'nsTypes' ? 'types' : type;
 export default async ({ report, issues, options }) => {
     let opts = {};
     try {
@@ -26,21 +25,22 @@ export default async ({ report, issues, options }) => {
             ...(report.unlisted && { unlisted: [] }),
             ...(report.binaries && { binaries: [] }),
             ...(report.unresolved && { unresolved: [] }),
-            ...((report.exports || report.nsExports) && { exports: [] }),
-            ...((report.types || report.nsTypes) && { types: [] }),
+            ...(report.exports && { exports: [] }),
+            ...(report.nsExports && { nsExports: [] }),
+            ...(report.types && { types: [] }),
+            ...(report.nsTypes && { nsTypes: [] }),
             ...(report.enumMembers && { enumMembers: {} }),
             ...(report.classMembers && { classMembers: {} }),
             ...(report.duplicates && { duplicates: [] }),
         };
         return row;
     };
-    for (const [reportType, isReportType] of Object.entries(report)) {
+    for (const [type, isReportType] of Object.entries(report)) {
         if (isReportType) {
-            if (reportType === 'files') {
+            if (type === 'files') {
             }
             else {
-                const type = mergeTypes(reportType);
-                flatten(issues[reportType]).forEach(issue => {
+                flatten(issues[type]).forEach(issue => {
                     const { filePath, symbol, symbols, parentSymbol } = issue;
                     json[filePath] = json[filePath] ?? initRow(filePath);
                     if (type === 'duplicates') {
@@ -54,7 +54,7 @@ export default async ({ report, issues, options }) => {
                         }
                     }
                     else {
-                        if (type === 'exports' || type === 'types' || type === 'unresolved') {
+                        if (['exports', 'nsExports', 'types', 'nsTypes', 'unresolved'].includes(type)) {
                             json[filePath][type]?.push(convert(issue));
                         }
                         else {

package/dist/types/issues.d.ts

@@ -44,7 +44,7 @@ export type Issues = {
     classMembers: IssueRecords;
 };
 export type IssueType = keyof Issues;
-export type SymbolIssueType = Exclude<IssueType, 'files'>;
+type SymbolIssueType = Exclude<IssueType, 'files'>;
 export type Report = {
     [key in keyof Issues]: boolean;
 };
@@ -71,3 +71,4 @@ export type ConfigurationHint = {
     identifier: string | RegExp;
     workspaceName?: string;
 };
+export {};

package/dist/typescript/getImportsAndExports.js

@@ -225,20 +225,55 @@ const getImportsAndExports = (sourceFile, getResolvedModule, typeChecker, option
             const result = visitor(node, options);
             result && (Array.isArray(result) ? result.forEach(addScript) : addScript(result));
         }
-        if (ts.isIdentifier(node) && isAccessExpression(node.parent)) {
-            const symbol = sourceFile.locals?.get(String(node.escapedText));
-            if (symbol) {
-                if (importedInternalSymbols.has(symbol)) {
-                    let members = [];
-                    let current = node.parent;
-                    while (current) {
-                        const ms = getMemberStringLiterals(typeChecker, current);
-                        if (!ms)
-                            break;
-                        members = members.concat(ms.flatMap(id => (members.length === 0 ? id : members.map(ns => `${ns}.${id}`))));
-                        current = current.parent;
+        if (ts.isIdentifier(node)) {
+            if (isAccessExpression(node.parent)) {
+                const symbol = sourceFile.locals?.get(String(node.escapedText));
+                if (symbol) {
+                    if (importedInternalSymbols.has(symbol)) {
+                        let members = [];
+                        let current = node.parent;
+                        while (current) {
+                            const ms = getMemberStringLiterals(typeChecker, current);
+                            if (!ms)
+                                break;
+                            members = members.concat(ms.flatMap(id => (members.length === 0 ? id : members.map(ns => `${ns}.${id}`))));
+                            current = current.parent;
+                        }
+                        maybeAddAccessExpressionAsNsImport(String(node.escapedText), members);
+                    }
+                }
+            }
+            else if (ts.isShorthandPropertyAssignment(node.parent) ||
+                (ts.isCallExpression(node.parent) && node.parent.arguments.includes(node)) ||
+                ts.isSpreadAssignment(node.parent) ||
+                ts.isExportAssignment(node.parent)) {
+                const symbol = sourceFile.locals?.get(String(node.escapedText));
+                if (symbol) {
+                    const importedSymbolFilePath = importedInternalSymbols.get(symbol);
+                    if (importedSymbolFilePath) {
+                        internalImports[importedSymbolFilePath].identifiers.add(String(node.escapedText));
+                    }
+                }
+            }
+            else if (ts.isVariableDeclaration(node.parent)) {
+                if (ts.isVariableDeclarationList(node.parent.parent) && ts.isObjectBindingPattern(node.parent.name)) {
+                    const symbol = sourceFile.locals?.get(String(node.escapedText));
+                    if (symbol) {
+                        const importedSymbolFilePath = importedInternalSymbols.get(symbol);
+                        if (importedSymbolFilePath) {
+                            const members = node.parent.name.elements.flatMap(decl => decl.name.getText());
+                            maybeAddAccessExpressionAsNsImport(String(node.escapedText), members);
+                        }
+                    }
+                }
+                else if (node.parent.initializer === node) {
+                    const symbol = sourceFile.locals?.get(String(node.escapedText));
+                    if (symbol) {
+                        const importedSymbolFilePath = importedInternalSymbols.get(symbol);
+                        if (importedSymbolFilePath) {
+                            internalImports[importedSymbolFilePath].identifiers.add(String(node.escapedText));
+                        }
                     }
-                    maybeAddAccessExpressionAsNsImport(String(node.escapedText), members);
                 }
             }
         }

package/dist/util/get-included-issue-types.d.ts

@@ -12,5 +12,6 @@ type Options = {
     dependencies?: boolean;
     exports?: boolean;
 };
+export declare const defaultExcludedIssueTypes: string[];
 export declare const getIncludedIssueTypes: (cliArgs: CLIArguments, { include, exclude, isProduction }?: Options) => Report;
 export {};

package/dist/util/get-included-issue-types.js

@@ -1,6 +1,6 @@
 import { ISSUE_TYPES } from '../constants.js';
 import { ConfigurationError } from './errors.js';
-const defaultExcludedIssueTypes = ['classMembers'];
+export const defaultExcludedIssueTypes = ['classMembers', 'nsExports', 'nsTypes'];
 const defaultIssueTypes = ISSUE_TYPES.filter(type => !defaultExcludedIssueTypes.includes(type));
 const normalize = (values) => values.map(value => value.split(',')).flat();
 export const getIncludedIssueTypes = (cliArgs, { include = [], exclude = [], isProduction = false } = {}) => {

package/dist/util/type.d.ts

@@ -0,0 +1,3 @@
+import type { SerializableImports } from '../types/imports.js';
+export declare const getHasStrictlyNsReferences: (importsForExport: SerializableImports) => [boolean, string?];
+export declare const getType: (hasOnlyNsReference: boolean, isType: boolean) => "exports" | "nsExports" | "types" | "nsTypes";

package/dist/util/type.js

@@ -0,0 +1,16 @@
+export const getHasStrictlyNsReferences = (importsForExport) => {
+    if (!importsForExport || !importsForExport.hasStar || importsForExport.importedNs.size === 0)
+        return [false];
+    let namespace;
+    for (const ns of importsForExport.importedNs) {
+        const hasNs = importsForExport.identifiers.has(ns);
+        if (!hasNs)
+            return [false, ns];
+        for (const id of importsForExport.identifiers)
+            if (id.startsWith(ns + '.'))
+                return [false, ns];
+        namespace = ns;
+    }
+    return [true, namespace];
+};
+export const getType = (hasOnlyNsReference, isType) => hasOnlyNsReference ? (isType ? 'nsTypes' : 'nsExports') : isType ? 'types' : 'exports';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "4.6.0",
+  "version": "5.0.0",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {