knip 6.14.2 → 6.16.0

package/dist/typescript/get-imports-and-exports.js

@@ -9,6 +9,8 @@ import { extractImportsFromComments } from './comments.js';
 import { _parseFile, buildLineStarts, getLineAndCol, shouldCountRefs, } from './ast-nodes.js';
 import { buildJSDocTagLookup } from './visitors/jsdoc.js';
 import { _walkAST } from './visitors/walk.js';
+const EMPTY_CHILD_PROCESS_NAMES = new Set();
+const EMPTY_CHILD_PROCESS_METHODS = new Map();
 const getImportsAndExports = (filePath, sourceText, resolveModule, options, ignoreExportsUsedInFile, skipExportsForFile, visitor, pluginCtx, cachedParseResult) => {
     const skipExports = skipExportsForFile || !options.isReportExports;
     const isDts = filePath.endsWith('.d.ts') || filePath.endsWith('.d.cts') || filePath.endsWith('.d.mts');
@@ -34,6 +36,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
     const localDeclarationTypes = new Map();
     const referencedInExport = new Map();
     const destructuredExports = new Set();
+    const registeredCustomElements = new Set();
     const addNsMemberRefs = (internalImport, namespace, member) => {
         if (typeof member === 'string') {
             internalImport.refs.add(`${namespace}.${member}`);
@@ -167,15 +170,18 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
     let hasChildProcessImport = false;
     let hasPathJoinImport = false;
     let hasPathResolveImport = false;
+    let childProcessNamespaces;
+    let childProcessMethods;
     for (const _imports of result.module.staticImports) {
         const specifier = _imports.moduleRequest.value;
+        const isPathImport = specifier === 'node:path' || specifier === 'path';
+        const isChildProcessImport = specifier === 'node:child_process' || specifier === 'child_process';
         if (specifier === 'node:module' || specifier === 'module')
             hasNodeModuleImport = true;
         else if (specifier === 'node:worker_threads' || specifier === 'worker_threads')
             hasWorkerThreadsImport = true;
-        else if (specifier === 'node:child_process' || specifier === 'child_process')
+        else if (isChildProcessImport)
             hasChildProcessImport = true;
-        const isPathImport = specifier === 'node:path' || specifier === 'path';
         const pos = _imports.moduleRequest.start;
         const jsdocTags = getJSDocTags(_imports.start);
         if (_imports.entries.length === 0) {
@@ -190,12 +196,16 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
             const modifiers = entry.isType ? IMPORT_FLAGS.TYPE_ONLY : IMPORT_FLAGS.NONE;
             if (entry.importName.kind === 'NamespaceObject') {
                 const localName = entry.localName.value;
+                if (isChildProcessImport)
+                    (childProcessNamespaces ??= new Set()).add(localName);
                 addImport(specifier, IMPORT_STAR, localName, undefined, entry.localName.start, modifiers, pos, jsdocTags, resolved);
                 if (internalPath)
                     localImportMap.set(localName, { importedName: IMPORT_STAR, filePath: internalPath, isNamespace: true });
             }
             else if (entry.importName.kind === 'Default') {
                 const localName = entry.localName.value;
+                if (isChildProcessImport)
+                    (childProcessNamespaces ??= new Set()).add(localName);
                 const alias = localName !== 'default' ? localName : undefined;
                 addImport(specifier, 'default', alias, undefined, entry.localName.start, modifiers, pos, jsdocTags, resolved);
                 if (internalPath)
@@ -205,6 +215,8 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
                 const importedName = entry.importName.name;
                 const localName = entry.localName.value;
                 const alias = localName !== importedName ? localName : undefined;
+                if (isChildProcessImport)
+                    (childProcessMethods ??= new Map()).set(localName, importedName);
                 if (isPathImport && !alias) {
                     if (importedName === 'join')
                         hasPathJoinImport = true;
@@ -254,6 +266,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         pluginCtx.sourceText = sourceText;
         pluginCtx.addScript = (s) => scripts.add(s);
         pluginCtx.addImport = (spec, pos, mod) => addImport(spec, undefined, undefined, undefined, pos, mod);
+        pluginCtx.markExportRegistered = (name) => registeredCustomElements.add(name);
     }
     const localRefs = _walkAST(result.program, sourceText, filePath, {
         lineStarts,
@@ -277,6 +290,9 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         hasNodeModuleImport,
         hasWorkerThreadsImport,
         hasChildProcessImport,
+        childProcessNamespaces: childProcessNamespaces ?? EMPTY_CHILD_PROCESS_NAMES,
+        childProcessMethods: childProcessMethods ?? EMPTY_CHILD_PROCESS_METHODS,
+        registeredCustomElements,
         hasPathJoinImport,
         hasPathResolveImport,
         resolveModule,

package/dist/typescript/resolve-module-names.d.ts

@@ -1,7 +1,11 @@
 import type { ToSourceFilePath, WorkspaceManifestHandler } from '../util/to-source-path.ts';
 import type { ResolveModule } from './ast-nodes.ts';
+type ScopedPaths = Array<{
+    scope: string;
+    paths: Record<string, string[]>;
+}>;
 export declare function clearModuleResolutionCaches(): void;
 export declare function createCustomModuleResolver(compilerOptions: {
-    paths?: Record<string, string[]>;
-    rootDirs?: string[];
+    scopedPaths?: ScopedPaths;
 }, customCompilerExtensions: string[], toSourceFilePath: ToSourceFilePath, findWorkspaceManifestImports?: WorkspaceManifestHandler): ResolveModule;
+export {};

package/dist/typescript/resolve-module-names.js

@@ -27,28 +27,32 @@ export function clearModuleResolutionCaches() {
     for (const cache of moduleResolutionCaches)
         cache.clear();
 }
-function compilePathMappings(paths) {
-    if (!paths)
+function compilePathMappings(scopedPaths) {
+    if (!scopedPaths)
         return undefined;
     const mappings = [];
-    for (const key in paths) {
-        const starIdx = key.indexOf('*');
-        if (starIdx >= 0) {
-            mappings.push({ prefix: key.slice(0, starIdx), wildcard: true, values: paths[key] });
-        }
-        else {
-            mappings.push({ prefix: key, wildcard: false, values: paths[key] });
+    for (const { scope, paths } of scopedPaths) {
+        for (const key in paths) {
+            const starIndex = key.indexOf('*');
+            if (starIndex >= 0) {
+                mappings.push({ prefix: key.slice(0, starIndex), wildcard: true, values: paths[key], scope });
+            }
+            else {
+                mappings.push({ prefix: key, wildcard: false, values: paths[key], scope });
+            }
         }
     }
-    return mappings.length > 0 ? mappings : undefined;
+    if (mappings.length === 0)
+        return undefined;
+    mappings.sort((a, b) => b.scope.length - a.scope.length);
+    return mappings;
 }
 export function createCustomModuleResolver(compilerOptions, customCompilerExtensions, toSourceFilePath, findWorkspaceManifestImports) {
     const customCompilerExtensionsSet = new Set(customCompilerExtensions);
     const hasCustomExts = customCompilerExtensionsSet.size > 0;
     const extensions = [...DEFAULT_EXTENSIONS, ...customCompilerExtensions, ...DTS_EXTENSIONS];
     const resolveSync = hasCustomExts ? _createSyncModuleResolver(extensions) : _resolveModuleSync;
-    const pathMappings = compilePathMappings(compilerOptions.paths);
-    const rootDirs = compilerOptions.rootDirs;
+    const pathMappings = compilePathMappings(compilerOptions.scopedPaths);
     function toSourcePath(resolvedFileName) {
         if (!hasCustomExts || !customCompilerExtensionsSet.has(extname(resolvedFileName))) {
             return toSourceFilePath(resolvedFileName) || resolvedFileName;
@@ -87,7 +91,10 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
         if (resolvedFileName)
             return toResult(resolvedFileName);
         if (pathMappings) {
-            for (const { prefix, wildcard, values } of pathMappings) {
+            const dir = dirname(containingFile);
+            for (const { prefix, wildcard, values, scope } of pathMappings) {
+                if (dir !== scope && !dir.startsWith(`${scope}/`))
+                    continue;
                 if (wildcard ? specifier.startsWith(prefix) : specifier === prefix) {
                     const captured = wildcard ? specifier.slice(prefix.length) : '';
                     for (const value of values) {
@@ -111,22 +118,6 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
                 }
             }
         }
-        if (rootDirs && !isAbsolute(specifier)) {
-            const containingDir = dirname(containingFile);
-            for (const srcRoot of rootDirs) {
-                if (!containingDir.startsWith(srcRoot))
-                    continue;
-                const relPath = containingDir.slice(srcRoot.length);
-                for (const targetRoot of rootDirs) {
-                    if (targetRoot === srcRoot)
-                        continue;
-                    const mapped = join(targetRoot, relPath, specifier);
-                    const resolved = resolveSync(mapped, containingFile);
-                    if (resolved)
-                        return toResult(resolved);
-                }
-            }
-        }
         const candidate = isAbsolute(specifier) ? specifier : join(dirname(containingFile), specifier);
         if (existsSync(candidate)) {
             return { resolvedFileName: candidate, isExternalLibraryImport: false };

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

@@ -1,4 +1,5 @@
-import type { CallExpression, NewExpression } from 'oxc-parser';
-import type { WalkState } from './walk.ts';
+import type { CallExpression, NewExpression, VariableDeclarator } from 'oxc-parser';
+import { type WalkState } from './walk.ts';
+export declare function trackCustomElementRegistry(node: VariableDeclarator, s: WalkState): void;
 export declare function handleCallExpression(node: CallExpression, s: WalkState): void;
 export declare function handleNewExpression(node: NewExpression, s: WalkState): void;

package/dist/typescript/visitors/calls.js

@@ -1,6 +1,49 @@
 import { IMPORT_FLAGS, OPAQUE } from '../../constants.js';
 import { addValue } from '../../util/module-graph.js';
-import { getStringValue, isStringLiteral } from '../ast-nodes.js';
+import { getSafeScriptFromArgs, getStringValue, isStringLiteral } from '../ast-nodes.js';
+import { isShadowed } from './walk.js';
+function getRegisteredCustomElement(node, s) {
+    const callee = node.callee;
+    if (callee.type !== 'MemberExpression' || callee.computed)
+        return undefined;
+    if (callee.property.type !== 'Identifier' || callee.property.name !== 'define')
+        return undefined;
+    const object = callee.object;
+    let isRegistry;
+    if (object.type === 'Identifier') {
+        isRegistry =
+            (object.name === 'customElements' || s.customElementRegistries.has(object.name)) &&
+                !isShadowed(object.name, object.start);
+    }
+    else {
+        isRegistry =
+            object.type === 'MemberExpression' &&
+                !object.computed &&
+                object.property.type === 'Identifier' &&
+                object.property.name === 'customElements';
+    }
+    if (!isRegistry)
+        return undefined;
+    const arg = node.arguments[1];
+    if (arg?.type === 'Identifier')
+        return isShadowed(arg.name, arg.start) ? undefined : arg.name;
+    if (arg?.type === 'ThisExpression' && s.staticBlockDepth > 0)
+        return s.classNameStack[s.classNameStack.length - 1] || undefined;
+    return undefined;
+}
+export function trackCustomElementRegistry(node, s) {
+    if (node.id.type !== 'Identifier' || !node.init)
+        return;
+    const init = node.init;
+    if ((init.type === 'Identifier' && init.name === 'customElements' && !isShadowed('customElements', init.start)) ||
+        (init.type === 'MemberExpression' &&
+            !init.computed &&
+            init.property.type === 'Identifier' &&
+            init.property.name === 'customElements') ||
+        (init.type === 'NewExpression' && init.callee.type === 'Identifier' && init.callee.name === 'CustomElementRegistry')) {
+        s.customElementRegistries.add(node.id.name);
+    }
+}
 function extractInlineDirnamePath(node, s) {
     if (node?.type !== 'CallExpression')
         return undefined;
@@ -41,8 +84,28 @@ function extractInlineDirnamePath(node, s) {
     const joined = parts.join('/').replace(/\/+/g, '/');
     return joined.startsWith('.') || joined.startsWith('/') ? joined : `./${joined}`;
 }
-const CHILD_PROCESS_ENTRY_METHODS = new Set(['fork', 'spawn', 'execFile']);
+const CHILD_PROCESS_FILE_METHODS = new Set(['fork', 'spawn', 'spawnSync', 'execFile', 'execFileSync']);
+const CHILD_PROCESS_COMMAND_METHODS = new Set(['exec', 'execSync']);
+function getChildProcessMethod(node, s) {
+    const callee = node.callee;
+    if (callee.type === 'Identifier')
+        return s.childProcessMethods.get(callee.name);
+    if (callee.type === 'MemberExpression' &&
+        !callee.computed &&
+        callee.object.type === 'Identifier' &&
+        callee.property.type === 'Identifier' &&
+        s.childProcessNamespaces.has(callee.object.name))
+        return callee.property.name;
+    return undefined;
+}
 export function handleCallExpression(node, s) {
+    if (node.arguments.length >= 2) {
+        const registered = getRegisteredCustomElement(node, s);
+        if (registered) {
+            s.registeredCustomElements.add(registered);
+            return;
+        }
+    }
     if (node.callee.type === 'Identifier' &&
         node.callee.name === 'require' &&
         node.arguments.length === 1 &&
@@ -95,22 +158,31 @@ export function handleCallExpression(node, s) {
         }
     }
     if (s.hasChildProcessImport && node.arguments.length >= 1) {
-        let isChildProcessEntry = false;
-        if (node.callee.type === 'Identifier' && CHILD_PROCESS_ENTRY_METHODS.has(node.callee.name)) {
-            isChildProcessEntry = true;
-        }
-        else if (node.callee.type === 'MemberExpression' &&
-            !node.callee.computed &&
-            node.callee.property.type === 'Identifier' &&
-            CHILD_PROCESS_ENTRY_METHODS.has(node.callee.property.name)) {
-            isChildProcessEntry = true;
-        }
-        if (isChildProcessEntry) {
-            const specifier = extractInlineDirnamePath(node.arguments[0], s);
-            if (specifier) {
-                s.addImport(specifier, undefined, undefined, undefined, node.arguments[0].start, IMPORT_FLAGS.ENTRY);
+        const method = getChildProcessMethod(node, s);
+        if (method) {
+            const arg = node.arguments[0];
+            if (CHILD_PROCESS_COMMAND_METHODS.has(method)) {
+                if (isStringLiteral(arg)) {
+                    const command = getStringValue(arg);
+                    if (command)
+                        s.scripts.add(command);
+                }
                 return;
             }
+            if (CHILD_PROCESS_FILE_METHODS.has(method)) {
+                const specifier = extractInlineDirnamePath(arg, s);
+                if (specifier) {
+                    s.addImport(specifier, undefined, undefined, undefined, arg.start, IMPORT_FLAGS.ENTRY);
+                    return;
+                }
+                if (method !== 'fork') {
+                    const script = getSafeScriptFromArgs(arg, node.arguments[1]);
+                    if (script) {
+                        s.scripts.add(script);
+                        return;
+                    }
+                }
+            }
         }
     }
     if (node.callee.type === 'MemberExpression' &&

package/dist/typescript/visitors/exports.js

@@ -3,6 +3,13 @@ import { addNsValue, addValue } from '../../util/module-graph.js';
 import { extractEnumMembers, extractNamespaceMembers, getLineAndCol, getStringValue, isStringLiteral, } from '../ast-nodes.js';
 import { EMPTY_TAGS } from './jsdoc.js';
 const getName = (n) => (n?.type === 'Identifier' ? n.name : undefined);
+const addLocalToExport = (s, local, exported) => {
+    const set = s.localToExports.get(local);
+    if (set)
+        set.add(exported);
+    else
+        s.localToExports.set(local, new Set([exported]));
+};
 const hasExplicitFunctionReturnType = (node) => !!node &&
     (node.type === 'ArrowFunctionExpression' ||
         node.type === 'FunctionExpression' ||
@@ -214,6 +221,8 @@ export function handleExportNamed(node, s) {
             s.addExport(exportedName, type, spec.exported?.start ?? spec.start, [], fix, isReExport, s.getJSDocTags(node.start));
             if (exportedName)
                 s.specifierExportNames.add(exportedName);
+            if (localName && exportedName)
+                addLocalToExport(s, localName, exportedName);
         }
     }
 }
@@ -240,6 +249,8 @@ export function handleExportDefault(node, s) {
         pos = decl.id?.start ?? decl.start;
         members = [];
         s.collectRefsInType(decl, 'default', true);
+        if (decl.id)
+            addLocalToExport(s, decl.id.name, 'default');
     }
     else if (decl.type === 'TSInterfaceDeclaration') {
         type = SYMBOL_TYPE.INTERFACE;
@@ -249,6 +260,7 @@ export function handleExportDefault(node, s) {
     else if (decl.type === 'Identifier') {
         type = s.localDeclarationTypes.get(decl.name) ?? SYMBOL_TYPE.UNKNOWN;
         pos = decl.start;
+        addLocalToExport(s, decl.name, 'default');
         const _import = s.localImportMap.get(decl.name);
         if (_import) {
             const internalImport = s.internal.get(_import.filePath);

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

@@ -35,6 +35,9 @@ interface WalkContext {
     hasNodeModuleImport: boolean;
     hasWorkerThreadsImport: boolean;
     hasChildProcessImport: boolean;
+    childProcessNamespaces: ReadonlySet<string>;
+    childProcessMethods: ReadonlyMap<string, string>;
+    registeredCustomElements: Set<string>;
     hasPathJoinImport: boolean;
     hasPathResolveImport: boolean;
     resolveModule: ResolveModule;
@@ -72,6 +75,10 @@ export interface WalkState extends WalkContext {
         exportName: string;
         seen: Set<string>;
     }>;
+    localToExports: Map<string, Set<string>>;
+    customElementRegistries: Set<string>;
+    classNameStack: string[];
+    staticBlockDepth: number;
     addExport: (identifier: string, type: SymbolType, pos: number, members: ExportMember[], fix: Fix, isReExport: boolean, jsDocTags: Set<string>) => void;
     getFix: (start: number, end: number, flags?: number) => Fix;
     getTypeFix: (start: number, end: number) => Fix;

package/dist/typescript/visitors/walk.js

@@ -5,7 +5,7 @@ import { isInNodeModules } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
 import { getLineAndCol, getStringValue, isStringLiteral } from '../ast-nodes.js';
 import { EMPTY_TAGS } from './jsdoc.js';
-import { handleCallExpression, handleNewExpression } from './calls.js';
+import { handleCallExpression, handleNewExpression, trackCustomElementRegistry } from './calls.js';
 import { handleExportAssignment, handleExportDefault, handleExportNamed, handleExpressionStatement, } from './exports.js';
 import { handleImportExpression, handleVariableDeclarator } from './imports.js';
 import { handleJSXMemberExpression, handleMemberExpression } from './members.js';
@@ -42,6 +42,7 @@ const _addExport = (identifier, type, pos, members, fix, isReExport, jsDocTags)
             line,
             col,
             hasRefsInFile: false,
+            isRegistered: false,
             referencedIn: undefined,
             fixes: fix ? [fix] : [],
             isReExport,
@@ -104,6 +105,13 @@ const _collectRefsInType = (node, exportName, signatureOnly, seen = new Set(), i
                 return;
             }
             break;
+        case 'VariableDeclarator':
+            if (inBody) {
+                if (node.init)
+                    _collectRefsInType(node.init, exportName, signatureOnly, seen, inBody);
+                return;
+            }
+            break;
     }
     const keys = visitorKeys[type];
     if (!keys)
@@ -205,11 +213,27 @@ const coreVisitorObject = {
         state.nsRanges.push([node.start, node.end]);
     },
     ClassDeclaration(node) {
+        state.classNameStack.push(node.id?.name ?? '');
         if (node.id?.name) {
             state.localDeclarationTypes.set(node.id.name, SYMBOL_TYPE.CLASS);
             state.localDeclarations.set(node.id.name, node);
         }
     },
+    'ClassDeclaration:exit'() {
+        state.classNameStack.pop();
+    },
+    ClassExpression(node) {
+        state.classNameStack.push(node.id?.name ?? '');
+    },
+    'ClassExpression:exit'() {
+        state.classNameStack.pop();
+    },
+    StaticBlock() {
+        state.staticBlockDepth++;
+    },
+    'StaticBlock:exit'() {
+        state.staticBlockDepth--;
+    },
     FunctionDeclaration(node) {
         if (node.id?.name) {
             state.localDeclarationTypes.set(node.id.name, SYMBOL_TYPE.FUNCTION);
@@ -267,6 +291,7 @@ const coreVisitorObject = {
     },
     VariableDeclarator(node) {
         handleVariableDeclarator(node, state);
+        trackCustomElementRegistry(node, state);
     },
     ImportExpression(node) {
         handleImportExpression(node, state);
@@ -697,6 +722,10 @@ function walkAST(program, sourceText, filePath, ctx) {
         localDeclarations: new Map(),
         pendingCallRefs: [],
         pendingMemberCallRefs: [],
+        localToExports: new Map(),
+        customElementRegistries: new Set(),
+        classNameStack: [],
+        staticBlockDepth: 0,
         addExport: _addExport,
         getFix: _getFix,
         getTypeFix: _getTypeFix,
@@ -777,6 +806,19 @@ function walkAST(program, sourceText, filePath, ctx) {
                 item.hasRefsInFile = true;
         }
     }
+    for (const name of state.registeredCustomElements) {
+        const item = state.exports.get(name);
+        if (item)
+            item.isRegistered = true;
+        const aliases = state.localToExports.get(name);
+        if (aliases) {
+            for (const exportName of aliases) {
+                const aliased = state.exports.get(exportName);
+                if (aliased)
+                    aliased.isRegistered = true;
+            }
+        }
+    }
     const localRefs = state.localRefs;
     state = undefined;
     return localRefs;

package/dist/util/Performance.d.ts

@@ -1,38 +1,22 @@
-import { type PerformanceEntry, PerformanceObserver } from 'node:perf_hooks';
-export declare const timerify: <T extends (...params: any[]) => any>(fn: T, name?: string) => T;
-type MemInfo = {
-    label: string;
-    heapUsed: number;
-    heapTotal: number;
-    rss: number;
-};
-interface MemoryEntry extends PerformanceEntry {
-    detail: MemInfo;
-}
+import { type RecordableHistogram } from 'node:perf_hooks';
 declare class Performance {
-    isEnabled: boolean;
-    isTimerifyFunctions: boolean;
-    isMemoryUsageEnabled: boolean;
-    isDurationEnabled: boolean;
-    startTime: number;
-    endTime: number;
-    perfEntries: PerformanceEntry[];
-    memEntries: MemoryEntry[];
-    perfId?: string;
-    memId?: string;
-    fnObserver?: PerformanceObserver;
-    memObserver?: PerformanceObserver;
+    readonly isEnabled: boolean;
+    readonly isTimerifyFunctions: boolean;
+    readonly isMemoryUsageEnabled: boolean;
+    readonly isDurationEnabled: boolean;
+    private readonly startTime;
+    private readonly memId;
+    private readonly histograms;
+    private readonly memEntries;
+    private readonly memObserver?;
     constructor({ isTimerifyFunctions, isMemoryUsageEnabled, isDurationEnabled }: {
         isDurationEnabled?: boolean | undefined;
         isMemoryUsageEnabled?: boolean | undefined;
         isTimerifyFunctions?: boolean | undefined;
     });
-    private setMark;
-    private clearMark;
-    private flush;
-    private getPerfEntriesByName;
-    getTimerifiedFunctionsTable(): string;
+    registerHistogram(name: string): RecordableHistogram;
     addMemoryMark(label: string): void;
+    getTimerifiedFunctionsTable(): string;
     getMemoryUsageTable(): string;
     getCurrentDurationInMs(): number;
     getMemHeapUsage(): number;
@@ -41,4 +25,5 @@ declare class Performance {
     reset(): void;
 }
 export declare const perfObserver: Performance;
+export declare const timerify: <T extends (...params: any[]) => any>(fn: T, name?: string) => T;
 export {};