knip 5.85.0 → 5.87.0

package/dist/util/Performance.js

@@ -1,9 +1,8 @@
-import os from 'node:os';
 import { PerformanceObserver, performance } from 'node:perf_hooks';
 import { memoryUsage } from 'node:process';
 import { parseArgs } from 'node:util';
-import { getStats } from './math.js';
-import { Table } from './table.js';
+import { getStats } from "./math.js";
+import { Table } from "./table.js";
 const { values } = parseArgs({
     strict: false,
     options: {
@@ -24,12 +23,15 @@ export const timerify = (fn, name = fn.name) => {
         return fn;
     return performance.timerify(Object.defineProperty(fn, 'name', { get: () => name }));
 };
-const getMemInfo = () => Object.assign({ freemem: os.freemem() }, memoryUsage());
+const getMemInfo = (label) => {
+    const usage = memoryUsage();
+    return { label, heapUsed: usage.heapUsed, heapTotal: usage.heapTotal, rss: usage.rss };
+};
 const twoFixed = (value) => (typeof value === 'number' ? value.toFixed(2) : value);
 const inMB = (bytes) => bytes / 1024 / 1024;
-const keys = ['heapUsed', 'heapTotal', 'freemem'];
-const logHead = () => console.log(keys.map(key => key.padStart(10)).join('  '));
-const log = (memInfo) => console.log(keys.map(key => twoFixed(inMB(memInfo[key])).padStart(10)).join('  '));
+const keys = ['heapUsed', 'heapTotal', 'rss'];
+const logHead = () => console.log(['phase', ...keys].map(key => key.padStart(10)).join('  '));
+const log = (memInfo) => console.log([memInfo.label.padStart(10), ...keys.map(key => twoFixed(inMB(memInfo[key])).padStart(10))].join('  '));
 class Performance {
     isEnabled;
     isTimerifyFunctions;
@@ -42,8 +44,6 @@ class Performance {
     memId;
     fnObserver;
     memObserver;
-    memoryUsageStart;
-    freeMemoryStart;
     constructor({ isTimerifyFunctions = false, isMemoryUsageEnabled = false }) {
         this.isEnabled = isTimerifyFunctions || isMemoryUsageEnabled;
         this.isTimerifyFunctions = isTimerifyFunctions;
@@ -69,7 +69,7 @@ class Performance {
             this.memObserver.observe({ type: 'mark' });
             if (isMemoryRealtime)
                 logHead();
-            this.addMemoryMark(0);
+            this.addMemoryMark('start');
         }
     }
     setMark(name) {
@@ -98,6 +98,7 @@ class Performance {
     }
     getTimerifiedFunctionsTable() {
         const entriesByName = this.getPerfEntriesByName();
+        const totalDuration = this.getCurrentDurationInMs();
         const table = new Table({ header: true });
         for (const [name, values] of Object.entries(entriesByName)) {
             const stats = getStats(values);
@@ -108,38 +109,53 @@ class Performance {
             table.cell('max', stats.max, twoFixed);
             table.cell('median', stats.median, twoFixed);
             table.cell('sum', stats.sum, twoFixed);
+            table.cell('%', (stats.sum / totalDuration) * 100, v => (typeof v === 'number' ? `${v.toFixed(0)}%` : ''));
         }
         table.sort('sum|desc');
         return table.toString();
     }
-    addMemoryMark(index) {
+    addMemoryMark(label) {
         if (!this.isMemoryUsageEnabled)
             return;
-        const id = `${this.memId}:${index}`;
-        const detail = getMemInfo();
+        const id = `${this.memId}:${label}`;
+        const detail = getMemInfo(label);
         performance.mark(id, { detail });
-        if (isMemoryRealtime && detail)
+        if (isMemoryRealtime)
             log(detail);
     }
     getMemoryUsageTable() {
         const table = new Table({ header: true });
-        let i = 0;
+        let prevHeapUsed = 0;
+        let peakHeapUsed = 0;
+        let peakRss = 0;
         for (const entry of this.memEntries) {
             if (!entry.detail)
                 continue;
+            const { label, heapUsed, rss } = entry.detail;
+            const delta = heapUsed - prevHeapUsed;
+            if (heapUsed > peakHeapUsed)
+                peakHeapUsed = heapUsed;
+            if (rss > peakRss)
+                peakRss = rss;
             table.row();
-            table.cell('#', String(i++));
-            table.cell('heapUsed', inMB(entry.detail.heapUsed), twoFixed);
-            table.cell('heapTotal', inMB(entry.detail.heapTotal), twoFixed);
-            table.cell('freemem', inMB(entry.detail.freemem), twoFixed);
+            table.cell('Phase', label);
+            table.cell('heapUsed', inMB(heapUsed), twoFixed);
+            table.cell('rss', inMB(rss), twoFixed);
+            table.cell('Δheap', prevHeapUsed === 0 ? '' : `${delta > 0 ? '+' : ''}${twoFixed(inMB(delta))}`, String);
+            prevHeapUsed = heapUsed;
         }
+        table.row();
+        table.cell('Phase', 'peak');
+        table.cell('heapUsed', inMB(peakHeapUsed), twoFixed);
+        table.cell('rss', inMB(peakRss), twoFixed);
+        table.cell('Δheap', '');
         return table.toString();
     }
     getCurrentDurationInMs() {
         return performance.now() - this.startTime;
     }
     getMemHeapUsage() {
-        return (memoryUsage().heapUsed ?? 0) - (this.memoryUsageStart?.heapUsed ?? 0);
+        return memoryUsage().heapUsed;
     }
     getCurrentMemUsageInMb() {
         return twoFixed(inMB(this.getMemHeapUsage()));
@@ -147,6 +163,7 @@ class Performance {
     async finalize() {
         if (!this.isEnabled)
             return;
+        this.addMemoryMark('end');
         await this.flush();
     }
     reset() {

package/dist/util/catalog.d.ts

@@ -1,5 +1,5 @@
-import type { CatalogContainer } from '../CatalogCounselor.js';
-import type { PackageJson } from '../types/package-json.js';
+import type { CatalogContainer } from '../CatalogCounselor.ts';
+import type { PackageJson } from '../types/package-json.ts';
 export declare const DEFAULT_CATALOG = "default";
 export declare const getCatalogContainer: (cwd: string, manifest: PackageJson, manifestPath: string, pnpmWorkspacePath?: string, pnpmWorkspace?: any) => Promise<CatalogContainer>;
 export declare const parseCatalog: (container: CatalogContainer) => Set<string>;

package/dist/util/catalog.js

@@ -1,6 +1,6 @@
-import { isFile } from './fs.js';
-import { _load } from './loader.js';
-import { basename, join } from './path.js';
+import { isFile } from "./fs.js";
+import { _load } from "./loader.js";
+import { basename, join } from "./path.js";
 export const DEFAULT_CATALOG = 'default';
 export const getCatalogContainer = async (cwd, manifest, manifestPath, pnpmWorkspacePath, pnpmWorkspace) => {
     const filePath = pnpmWorkspacePath ?? (isFile(cwd, '.yarnrc.yml') ? join(cwd, '.yarnrc.yml') : manifestPath);

package/dist/util/codeowners.js

@@ -1,7 +1,7 @@
 import { readFileSync } from 'node:fs';
 import picomatch from 'picomatch';
-import { debugLog } from './debug.js';
-import { convertGitignoreToPicomatchIgnorePatterns } from './parse-and-convert-gitignores.js';
+import { debugLog } from "./debug.js";
+import { convertGitignoreToPicomatchIgnorePatterns } from "./parse-and-convert-gitignores.js";
 export function parseCodeowners(content) {
     const matchers = content
         .split(/\r?\n/)

package/dist/util/create-input-handler.d.ts

@@ -1,8 +1,8 @@
-import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
-import type { DependencyDeputy } from '../DependencyDeputy.js';
-import type { Issue } from '../types/issues.js';
-import type { ExternalRef } from '../types/module-graph.js';
-import type { MainOptions } from './create-options.js';
-import { type Input } from './input.js';
+import type { ConfigurationChief, Workspace } from '../ConfigurationChief.ts';
+import type { DependencyDeputy } from '../DependencyDeputy.ts';
+import type { Issue } from '../types/issues.ts';
+import type { ExternalRef } from '../types/module-graph.ts';
+import type { MainOptions } from './create-options.ts';
+import { type Input } from './input.ts';
 export type ExternalRefsFromInputs = Map<string, Set<ExternalRef>>;
 export declare const createInputHandler: (deputy: DependencyDeputy, chief: ConfigurationChief, isGitIgnored: (filePath: string) => boolean, addIssue: (issue: Issue) => void, externalRefs: ExternalRefsFromInputs | undefined, options: MainOptions) => (input: Input, workspace: Workspace) => string | undefined;

package/dist/util/create-input-handler.js

@@ -1,9 +1,9 @@
-import { IGNORED_RUNTIME_DEPENDENCIES } from '../constants.js';
-import { debugLog } from './debug.js';
-import { fromBinary, isBinary, isConfig, isDeferResolve, isDeferResolveEntry, isDependency, toDebugString, } from './input.js';
-import { getPackageNameFromSpecifier } from './modules.js';
-import { dirname, isAbsolute, isInNodeModules, isInternal, join } from './path.js';
-import { _resolveModuleSync, _resolveSync } from './resolve.js';
+import { IGNORED_RUNTIME_DEPENDENCIES } from "../constants.js";
+import { debugLog } from "./debug.js";
+import { fromBinary, isBinary, isConfig, isDeferResolve, isDeferResolveEntry, isDependency, toDebugString, } from "./input.js";
+import { getPackageNameFromSpecifier } from "./modules.js";
+import { dirname, isAbsolute, isInNodeModules, isInternal, join } from "./path.js";
+import { resolveModuleSync, _resolveSync } from "./resolve.js";
 const isJoinable = (specifier) => {
     const char = specifier.charCodeAt(0);
     return char !== 35 && char !== 126 && char !== 64 && !isAbsolute(specifier);
@@ -53,7 +53,7 @@ export const createInputHandler = (deputy, chief, isGitIgnored, addIssue, extern
         const isWorkspace = chief.workspacesByPkgName.has(packageName);
         const inputWorkspace = getWorkspaceFor(input, chief, workspace);
         if (inputWorkspace) {
-            const isHandled = deputy.maybeAddReferencedExternalDependency(inputWorkspace, packageName);
+            const isHandled = deputy.maybeAddReferencedExternalDependency(inputWorkspace, packageName, isConfig(input));
             if (externalRefs && !isWorkspace) {
                 addExternalRef(externalRefs, containingFilePath, { specifier: packageName, identifier: undefined });
             }
@@ -84,7 +84,7 @@ export const createInputHandler = (deputy, chief, isGitIgnored, addIssue, extern
     }
     const filePath = isJoinable(specifier) ? join(input.dir ?? dirname(containingFilePath), specifier) : specifier;
     const basePath = input.dir ? join(input.dir, 'file.ts') : containingFilePath;
-    const resolvedFilePath = _resolveModuleSync(filePath, basePath);
+    const resolvedFilePath = resolveModuleSync(filePath, basePath);
     if (resolvedFilePath && isInternal(resolvedFilePath)) {
         return isGitIgnored(resolvedFilePath) ? undefined : resolvedFilePath;
     }

package/dist/util/create-options.d.ts

@@ -1,21 +1,21 @@
-import type { Options } from '../types/options.js';
-import type { ParsedCLIArgs } from './cli-arguments.js';
+import type { Options } from '../types/options.ts';
+import type { ParsedCLIArgs } from './cli-arguments.ts';
 interface CreateOptions extends Partial<Options> {
     args?: ParsedCLIArgs;
 }
 export declare const createOptions: (options: CreateOptions) => Promise<{
     cacheLocation: string;
-    catalog: import("../CatalogCounselor.js").CatalogContainer;
+    catalog: import("../CatalogCounselor.ts").CatalogContainer;
     config: string | undefined;
     configFilePath: string | undefined;
     cwd: string;
     dependencies: boolean;
-    experimentalTags: import("../types/options.js").Tags;
+    experimentalTags: import("../types/options.ts").Tags;
     exports: boolean;
     files: boolean;
     fixTypes: string[];
     gitignore: boolean;
-    includedIssueTypes: import("../types/issues.js").Report;
+    includedIssueTypes: import("../types/issues.ts").Report;
     isCache: boolean;
     isDebug: boolean;
     isDisableConfigHints: boolean;
@@ -395,6 +395,16 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'openapi-ts'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
+        oxfmt?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         oxlint?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -460,6 +470,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        qwik?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'react-cosmos'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1076,6 +1091,16 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            'openapi-ts'?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
+            oxfmt?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             oxlint?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;
@@ -1141,6 +1166,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            qwik?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             'react-cosmos'?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;
@@ -1441,24 +1471,24 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
         treatConfigHintsAsErrors?: boolean | undefined;
     };
     rules: {
-        files: import("../types/issues.js").IssueSeverity;
-        dependencies: import("../types/issues.js").IssueSeverity;
-        devDependencies: import("../types/issues.js").IssueSeverity;
-        optionalPeerDependencies: import("../types/issues.js").IssueSeverity;
-        unlisted: import("../types/issues.js").IssueSeverity;
-        binaries: import("../types/issues.js").IssueSeverity;
-        unresolved: import("../types/issues.js").IssueSeverity;
-        exports: import("../types/issues.js").IssueSeverity;
-        nsExports: import("../types/issues.js").IssueSeverity;
-        types: import("../types/issues.js").IssueSeverity;
-        nsTypes: import("../types/issues.js").IssueSeverity;
-        enumMembers: import("../types/issues.js").IssueSeverity;
-        classMembers: import("../types/issues.js").IssueSeverity;
-        duplicates: import("../types/issues.js").IssueSeverity;
-        catalog: import("../types/issues.js").IssueSeverity;
-        _files: import("../types/issues.js").IssueSeverity;
+        files: import("../types/issues.ts").IssueSeverity;
+        dependencies: import("../types/issues.ts").IssueSeverity;
+        devDependencies: import("../types/issues.ts").IssueSeverity;
+        optionalPeerDependencies: import("../types/issues.ts").IssueSeverity;
+        unlisted: import("../types/issues.ts").IssueSeverity;
+        binaries: import("../types/issues.ts").IssueSeverity;
+        unresolved: import("../types/issues.ts").IssueSeverity;
+        exports: import("../types/issues.ts").IssueSeverity;
+        nsExports: import("../types/issues.ts").IssueSeverity;
+        types: import("../types/issues.ts").IssueSeverity;
+        nsTypes: import("../types/issues.ts").IssueSeverity;
+        enumMembers: import("../types/issues.ts").IssueSeverity;
+        classMembers: import("../types/issues.ts").IssueSeverity;
+        duplicates: import("../types/issues.ts").IssueSeverity;
+        catalog: import("../types/issues.ts").IssueSeverity;
+        _files: import("../types/issues.ts").IssueSeverity;
     };
-    tags: import("../types/options.js").Tags;
+    tags: import("../types/options.ts").Tags;
     traceDependency: string | undefined;
     traceExport: string | undefined;
     traceFile: string | undefined;

package/dist/util/create-options.js

@@ -1,16 +1,16 @@
-import { partitionCompilers } from '../compilers/index.js';
-import { KNIP_CONFIG_LOCATIONS } from '../constants.js';
-import { knipConfigurationSchema } from '../schema/configuration.js';
-import { getCatalogContainer } from './catalog.js';
-import { ConfigurationError } from './errors.js';
-import { findFile, loadJSON } from './fs.js';
-import { getIncludedIssueTypes, shorthandDeps, shorthandExports, shorthandFiles } from './get-included-issue-types.js';
-import { defaultRules } from './issue-initializers.js';
-import { loadResolvedConfigFile } from './load-config.js';
-import { _load } from './loader.js';
-import { getKeysByValue } from './object.js';
-import { isAbsolute, join, normalize, toAbsolute, toPosix } from './path.js';
-import { splitTags } from './tag.js';
+import { partitionCompilers } from "../compilers/index.js";
+import { KNIP_CONFIG_LOCATIONS } from "../constants.js";
+import { knipConfigurationSchema } from "../schema/configuration.js";
+import { getCatalogContainer } from "./catalog.js";
+import { ConfigurationError } from "./errors.js";
+import { findFile, loadJSON } from "./fs.js";
+import { getIncludedIssueTypes, shorthandDeps, shorthandExports, shorthandFiles } from "./get-included-issue-types.js";
+import { defaultRules } from "./issue-initializers.js";
+import { loadResolvedConfigFile } from "./load-config.js";
+import { _load } from "./loader.js";
+import { getKeysByValue } from "./object.js";
+import { isAbsolute, join, normalize, toAbsolute, toPosix } from "./path.js";
+import { splitTags } from "./tag.js";
 export const createOptions = async (options) => {
     const { args = {} } = options;
     const pcwd = process.cwd();

package/dist/util/create-workspace-graph.d.ts

@@ -1,3 +1,3 @@
-import type { WorkspacePackage } from '../types/package-json.js';
+import type { WorkspacePackage } from '../types/package-json.ts';
 export type WorkspaceGraph = Map<string, Set<string>>;
 export declare function createWorkspaceGraph(cwd: string, wsNames: string[], wsPkgNames: Set<string>, wsPackages: Map<string, WorkspacePackage>): WorkspaceGraph;

package/dist/util/create-workspace-graph.js

@@ -1,4 +1,4 @@
-import { join } from './path.js';
+import { join } from "./path.js";
 const types = ['peerDependencies', 'devDependencies', 'optionalDependencies', 'dependencies'];
 export function createWorkspaceGraph(cwd, wsNames, wsPkgNames, wsPackages) {
     const graph = new Map();

package/dist/util/file-entry-cache.js

@@ -1,10 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { deserialize, serialize } from 'node:v8';
-import { debugLog } from './debug.js';
-import { isDirectory, isFile } from './fs.js';
-import { timerify } from './Performance.js';
-import { dirname, isAbsolute, resolve } from './path.js';
+import { debugLog } from "./debug.js";
+import { isDirectory, isFile } from "./fs.js";
+import { timerify } from "./Performance.js";
+import { dirname, isAbsolute, resolve } from "./path.js";
 const createCache = (filePath) => {
     try {
         return deserialize(fs.readFileSync(filePath));

package/dist/util/fs.d.ts

@@ -5,7 +5,7 @@ export declare const loadFile: (filePath: string) => Promise<string>;
 export declare const hasFileWithExtension: (cwd: string, dirName: string, extensions: string[]) => boolean;
 export declare const loadJSON: (filePath: string) => Promise<any>;
 export declare const loadJSONC: (filePath: string) => Promise<any>;
-export declare const loadYAML: (filePath: string) => Promise<unknown>;
+export declare const loadYAML: (filePath: string) => Promise<any>;
 export declare const loadTOML: (filePath: string) => Promise<import("smol-toml").TomlTable>;
 export declare const parseJSONC: (filePath: string, contents: string) => Promise<any>;
-export declare const parseYAML: (contents: string) => unknown;
+export declare const parseYAML: (contents: string) => any;

package/dist/util/fs.js

@@ -1,10 +1,10 @@
 import { readdirSync, statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
-import yaml from 'js-yaml';
+import { parse as parseYAMLContents } from 'yaml';
 import { parse as parseTOML } from 'smol-toml';
 import stripJsonComments from 'strip-json-comments';
-import { LoaderError } from './errors.js';
-import { extname, join } from './path.js';
+import { LoaderError } from "./errors.js";
+import { extname, join } from "./path.js";
 export const isDirectory = (cwdOrPath, name) => {
     try {
         return statSync(name ? join(cwdOrPath, name) : cwdOrPath).isDirectory();
@@ -77,5 +77,5 @@ export const parseJSONC = async (filePath, contents) => {
     }
 };
 export const parseYAML = (contents) => {
-    return yaml.load(contents);
+    return parseYAMLContents(contents, { logLevel: 'error' });
 };

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

@@ -1,4 +1,4 @@
-import type { Report } from '../types/issues.js';
+import type { Report } from '../types/issues.ts';
 type GetIncludedIssueTypesOptions = {
     isProduction?: boolean;
     include: string[];

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

@@ -1,5 +1,5 @@
-import { ISSUE_TYPES } from '../constants.js';
-import { ConfigurationError } from './errors.js';
+import { ISSUE_TYPES } from "../constants.js";
+import { ConfigurationError } from "./errors.js";
 export const defaultExcludedIssueTypes = ['classMembers', 'nsExports', 'nsTypes'];
 const defaultIssueTypes = ISSUE_TYPES.filter(type => !defaultExcludedIssueTypes.includes(type));
 const normalize = (values) => values.flatMap(value => value.split(','));

package/dist/util/git.js

@@ -1,5 +1,5 @@
 import { execSync } from 'node:child_process';
-import { join } from './path.js';
+import { join } from "./path.js";
 const hookFileNames = [
     'prepare-commit-msg',
     'commit-msg',

package/dist/util/glob-core.js

@@ -3,15 +3,14 @@ import { promisify } from 'node:util';
 import { walk as _walk } from '@nodelib/fs.walk';
 import fg, {} from 'fast-glob';
 import picomatch from 'picomatch';
-import { GLOBAL_IGNORE_PATTERNS } from '../constants.js';
-import { compact, partition } from './array.js';
-import { debugLogObject } from './debug.js';
-import { isDirectory, isFile } from './fs.js';
-import { timerify } from './Performance.js';
-import { parseAndConvertGitignorePatterns } from './parse-and-convert-gitignores.js';
-import { dirname, join, relative, toPosix } from './path.js';
+import { GLOBAL_IGNORE_PATTERNS } from "../constants.js";
+import { compact, partition } from "./array.js";
+import { debugLogObject } from "./debug.js";
+import { isDirectory, isFile } from "./fs.js";
+import { timerify } from "./Performance.js";
+import { parseAndConvertGitignorePatterns } from "./parse-and-convert-gitignores.js";
+import { dirname, join, relative, toPosix } from "./path.js";
 const walk = promisify(_walk);
-const _picomatch = timerify(picomatch);
 const cachedGitIgnores = new Map();
 const cachedGlobIgnores = new Map();
 const isGitRoot = (dir) => isDirectory(dir, '.git') || isFile(dir, '.git');
@@ -46,15 +45,23 @@ const findAncestorGitignoreFiles = (cwd) => {
     return gitignorePaths;
 };
 export const findAndParseGitignores = async (cwd, workspaceDirs) => {
-    const init = ['.git', ...GLOBAL_IGNORE_PATTERNS];
-    const ignores = new Set(init);
+    const ignores = new Set(GLOBAL_IGNORE_PATTERNS);
     const unignores = [];
     const gitignoreFiles = [];
     const pmOptions = { ignore: unignores };
     let deepFilterMatcher;
+    let prevUnignoreLength = unignores.length;
+    const pendingIgnores = [];
     const getMatcher = () => {
-        if (!deepFilterMatcher)
-            deepFilterMatcher = _picomatch(Array.from(ignores), pmOptions);
+        if (!deepFilterMatcher) {
+            deepFilterMatcher = picomatch(Array.from(ignores), pmOptions);
+            pendingIgnores.length = 0;
+        }
+        else if (pendingIgnores.length > 0) {
+            const prev = deepFilterMatcher;
+            const incr = picomatch(pendingIgnores.splice(0), pmOptions);
+            deepFilterMatcher = (path) => prev(path) || incr(path);
+        }
         return deepFilterMatcher;
     };
     const addFile = (filePath, baseDir) => {
@@ -62,8 +69,9 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
         const dir = baseDir ?? dirname(toPosix(filePath));
         const base = relative(cwd, dir);
         const ancestor = base.startsWith('..') ? `${relative(dir, cwd)}/` : undefined;
-        const ignoresForDir = new Set(base === '' ? init : []);
+        const ignoresForDir = new Set(base === '' ? GLOBAL_IGNORE_PATTERNS : []);
         const unignoresForDir = new Set();
+        const prevIgnoreSize = ignores.size;
         const patterns = readFileSync(filePath, 'utf8');
         for (const rule of parseAndConvertGitignorePatterns(patterns, ancestor)) {
             const [pattern, extraPattern] = rule.patterns;
@@ -113,7 +121,15 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
         else {
             cachedGitIgnores.set(cacheDir, { ignores: ignoresForDir, unignores: unignoresForDir });
         }
-        deepFilterMatcher = undefined;
+        if (unignores.length !== prevUnignoreLength) {
+            deepFilterMatcher = undefined;
+            prevUnignoreLength = unignores.length;
+        }
+        else if (ignores.size !== prevIgnoreSize) {
+            for (const p of ignoresForDir)
+                if (!GLOBAL_IGNORE_PATTERNS.includes(p))
+                    pendingIgnores.push(p);
+        }
     };
     for (const filePath of findAncestorGitignoreFiles(cwd))
         addFile(filePath);
@@ -144,7 +160,7 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
                 if (relevantAncestors.has(absPath))
                     return true;
                 for (const wsDir of nonRootDirs)
-                    if (absPath.startsWith(wsDir + '/'))
+                    if (absPath.startsWith(`${wsDir}/`))
                         return true;
                 return false;
             };
@@ -160,8 +176,8 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
     const deepFilter = (entry) => (!isRelevantDir || isRelevantDir(toPosix(entry.path))) && !getMatcher()(relative(cwd, entry.path));
     await walk(cwd, {
         concurrency: 16,
-        entryFilter: timerify(entryFilter),
-        deepFilter: timerify(deepFilter),
+        entryFilter,
+        deepFilter,
     });
     debugLogObject('*', 'Parsed gitignore files', { gitignoreFiles });
     return { gitignoreFiles, ignores, unignores };
@@ -173,26 +189,21 @@ export async function glob(_patterns, options) {
     const hasCache = cachedGlobIgnores.has(options.dir);
     const willCache = !hasCache && options.gitignore && options.label;
     const cachedIgnores = options.gitignore ? cachedGlobIgnores.get(options.dir) : undefined;
-    const _ignore = [];
+    const _ignore = [...GLOBAL_IGNORE_PATTERNS];
     const [negatedPatterns, patterns] = partition(_patterns, pattern => pattern.startsWith('!'));
-    if (options.gitignore) {
-        if (willCache) {
-            let dir = options.dir;
-            let prev;
-            while (dir) {
-                const cacheForDir = cachedGitIgnores.get(dir);
-                if (cacheForDir) {
-                    _ignore.push(...cacheForDir.ignores);
-                }
-                dir = dirname((prev = dir));
-                if (prev === dir || dir === '.')
-                    break;
+    if (options.gitignore && willCache) {
+        let dir = options.dir;
+        let prev;
+        while (dir) {
+            const cacheForDir = cachedGitIgnores.get(dir);
+            if (cacheForDir) {
+                _ignore.push(...cacheForDir.ignores);
             }
+            dir = dirname((prev = dir));
+            if (prev === dir || dir === '.')
+                break;
         }
     }
-    else {
-        _ignore.push(...GLOBAL_IGNORE_PATTERNS);
-    }
     if (willCache)
         cachedGlobIgnores.set(options.dir, compact(_ignore));
     const ignorePatterns = (cachedIgnores || _ignore).concat(negatedPatterns.map(pattern => pattern.slice(1)));
@@ -213,7 +224,15 @@ export async function getGitIgnoredHandler(options, workspaceDirs) {
     if (options.gitignore === false)
         return () => false;
     const { ignores, unignores } = await _parseFindGitignores(options.cwd, workspaceDirs);
-    const matcher = _picomatch(Array.from(ignores), { ignore: unignores });
-    const isGitIgnored = (filePath) => matcher(relative(options.cwd, filePath));
-    return timerify(isGitIgnored);
+    const matcher = picomatch(Array.from(ignores), { ignore: unignores });
+    const cache = new Map();
+    const isGitIgnored = (filePath) => {
+        let result = cache.get(filePath);
+        if (result === undefined) {
+            result = matcher(relative(options.cwd, filePath));
+            cache.set(filePath, result);
+        }
+        return result;
+    };
+    return isGitIgnored;
 }

package/dist/util/glob.js

@@ -1,8 +1,8 @@
 import fg from 'fast-glob';
-import { compact } from './array.js';
-import { glob } from './glob-core.js';
-import { timerify } from './Performance.js';
-import { isAbsolute, join, relative } from './path.js';
+import { compact } from "./array.js";
+import { glob } from "./glob-core.js";
+import { timerify } from "./Performance.js";
+import { isAbsolute, join, relative } from "./path.js";
 const prepend = (pattern, relativePath) => isAbsolute(pattern.replace(/^!/, '')) ? pattern : prependDirToPattern(relativePath, pattern);
 const prependDirToPatterns = (cwd, dir, patterns) => {
     const relativePath = relative(cwd, dir);

package/dist/util/input.d.ts

@@ -1,5 +1,5 @@
-import type { IssueType } from '../types/issues.js';
-import type { PluginName } from '../types/PluginNames.js';
+import type { IssueType } from '../types/issues.ts';
+import type { PluginName } from '../types/PluginNames.ts';
 type InputType = 'binary' | 'entry' | 'project' | 'config' | 'dependency' | 'deferResolve' | 'deferResolveEntry' | 'alias' | 'ignore';
 export interface Input {
     type: InputType;