knip 6.43.0 → 6.44.1

package/README.md

@@ -50,8 +50,7 @@ following projects:
 [2]: https://img.shields.io/npm/v/knip?color=f56e0f
 [3]: https://img.shields.io/badge/dynamic/json?url=https://npm-gapless.webpro.nl/downloads/range/last-month/knip&query=$.totalCompact&label=downloads&suffix=/month&color=f56e0f
 [4]: https://github.com/webpro-nl/knip
-[5]:
-  https://img.shields.io/github/stars/webpro-nl/knip?style=flat&color=f56e0f
+[5]: https://img.shields.io/github/stars/webpro-nl/knip?style=flat&color=f56e0f
 [6]: https://knip.dev
 [7]: https://www.npmx.dev/package/@knip/create-config
 [8]: https://www.npmx.dev/package/@knip/language-server
@@ -69,7 +68,6 @@ following projects:
 [20]: https://github.com/pnpm/pnpm/tree/main/deps/graph-sequencer
 [21]: https://github.com/pnpm/pnpm/blob/main/LICENSE
 [22]: https://github.com/jaredwray/cacheable/tree/main/packages/file-entry-cache
-[23]:
-  https://github.com/jaredwray/cacheable/blob/main/packages/file-entry-cache/LICENSE
+[23]: https://github.com/jaredwray/cacheable/blob/main/packages/file-entry-cache/LICENSE
 [24]: https://github.com/npm/json-parse-even-better-errors
 [25]: https://github.com/npm/json-parse-even-better-errors/blob/main/LICENSE.md

package/dist/CacheConsultant.d.ts

@@ -5,6 +5,7 @@ export declare class CacheConsultant<T> {
     getFileDescriptor: (filePath: string) => FileDescriptor<T>;
     reconcile: () => void;
     removeEntry: (filePath: string) => void;
+    setFileData: (filePath: string, data: T) => void;
     constructor(name: string, options: MainOptions);
     getCachedFile(filePath: string): T | undefined;
 }

package/dist/CacheConsultant.js

@@ -7,6 +7,7 @@ export class CacheConsultant {
     getFileDescriptor = () => dummyFileDescriptor;
     reconcile = () => { };
     removeEntry = () => { };
+    setFileData = () => { };
     constructor(name, options) {
         if (!options.isCache)
             return;
@@ -15,6 +16,7 @@ export class CacheConsultant {
         this.getFileDescriptor = timerify(this.cache.getFileDescriptor.bind(this.cache));
         this.reconcile = timerify(this.cache.reconcile.bind(this.cache));
         this.removeEntry = timerify(this.cache.removeEntry.bind(this.cache));
+        this.setFileData = this.cache.setFileData.bind(this.cache);
     }
     getCachedFile(filePath) {
         if (!this.cache)

package/dist/CatalogCounselor.d.ts

@@ -9,12 +9,10 @@ export type CatalogContainer = {
     overrides?: Catalog;
 };
 export declare class CatalogCounselor {
-    private filePath;
+    private sources;
     private entries;
     private referencedEntries;
     private referenceIssues;
-    private overrideReferences;
-    private fileContent?;
     constructor(options: MainOptions);
     private addReferencedCatalogEntry;
     addReference({ catalogName, packageName }: CatalogReference): void;

package/dist/CatalogCounselor.js

@@ -6,18 +6,20 @@ import { extractCatalogReferences, getOverrideCatalogReferences, parseCatalog, }
 import { extname } from './util/path.js';
 import { YamlCatalogPeeker } from './YamlCatalogPeeker.js';
 export class CatalogCounselor {
-    filePath;
+    sources = [];
     entries = new Set();
     referencedEntries = new Set();
     referenceIssues = [];
-    overrideReferences = [];
-    fileContent;
     constructor(options) {
-        this.filePath = options.catalog.filePath;
-        this.entries = parseCatalog(options.catalog);
-        this.overrideReferences = getOverrideCatalogReferences(options.catalog.overrides);
-        for (const reference of this.overrideReferences)
-            this.addReference(reference);
+        for (const container of options.catalog) {
+            const entries = parseCatalog(container);
+            const overrideReferences = getOverrideCatalogReferences(container.overrides);
+            for (const entry of entries)
+                this.entries.add(entry);
+            for (const reference of overrideReferences)
+                this.addReference(reference);
+            this.sources.push({ filePath: container.filePath, entries, overrideReferences });
+        }
     }
     addReferencedCatalogEntry(entryName) {
         this.referencedEntries.add(entryName);
@@ -52,16 +54,17 @@ export class CatalogCounselor {
         }
     }
     async settleCatalogIssues(options) {
-        const filePath = this.filePath;
         const workspace = ROOT_WORKSPACE_NAME;
         const catalogIssues = [];
         const overrideReferenceIssues = [];
-        if (this.entries.size > 0 || this.overrideReferences.length > 0) {
-            this.fileContent = await readFile(filePath, 'utf-8');
+        for (const { filePath, entries, overrideReferences } of this.sources) {
+            if (entries.size === 0 && overrideReferences.length === 0)
+                continue;
+            const fileContent = await readFile(filePath, 'utf-8');
             const isYaml = ['.yml', '.yaml'].includes(extname(filePath));
-            const yamlPeeker = isYaml ? new YamlCatalogPeeker(this.fileContent) : undefined;
-            const peeker = yamlPeeker ?? new JsonCatalogPeeker(this.fileContent);
-            for (const entry of this.entries.keys()) {
+            const yamlPeeker = isYaml ? new YamlCatalogPeeker(fileContent) : undefined;
+            const peeker = yamlPeeker ?? new JsonCatalogPeeker(fileContent);
+            for (const entry of entries) {
                 if (!this.referencedEntries.has(entry)) {
                     const [parentSymbol, symbol] = entry.split(':');
                     const pos = peeker.getLocation(parentSymbol, symbol);
@@ -71,7 +74,7 @@ export class CatalogCounselor {
                     catalogIssues.push({ type: 'catalog', filePath, workspace, symbol, parentSymbol, fixes, ...pos });
                 }
             }
-            for (const { catalogName, packageName, selector } of this.overrideReferences) {
+            for (const { catalogName, packageName, selector } of overrideReferences) {
                 if (this.entries.has(`${catalogName}:${packageName}`))
                     continue;
                 const pos = yamlPeeker?.getOverrideCatalogReferenceLocation(selector);

package/dist/ConfigurationChief.d.ts

@@ -337,6 +337,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'kysely-codegen'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         ladle?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -352,6 +357,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        lingui?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'lint-staged'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -392,6 +402,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        mastra?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         mcp?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -622,6 +637,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        purgecss?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         quasar?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1136,9 +1156,11 @@ export declare class ConfigurationChief {
         jest?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         karma?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         knex?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        "kysely-codegen"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         ladle?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "laravel-vite-plugin"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         lefthook?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        lingui?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "lint-staged"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         linthtml?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         lit?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -1147,6 +1169,7 @@ export declare class ConfigurationChief {
         lunaria?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         markdownlint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         marko?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        mastra?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         mcp?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         mdx?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         mdxlint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -1193,6 +1216,7 @@ export declare class ConfigurationChief {
         preconstruct?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         prettier?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         prisma?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        purgecss?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         quasar?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         qwik?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         railway?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/DependencyDeputy.d.ts

@@ -9,6 +9,7 @@ interface DependencyReferenceOptions {
     isTypeOnly?: boolean;
     isResolved?: boolean;
     isPublishedType?: boolean;
+    isCaught?: boolean;
 }
 export declare class DependencyDeputy {
     isProduction: boolean;
@@ -63,7 +64,7 @@ export declare class DependencyDeputy {
         isPeerOptional: boolean;
     }[];
     getOptionalPeerDependencies(workspaceName: string): DependencySet;
-    maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string, { specifier, isDevOnly, isTypeOnly, isResolved, isPublishedType }: DependencyReferenceOptions): boolean;
+    maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string, { specifier, isDevOnly, isTypeOnly, isResolved, isPublishedType, isCaught }: DependencyReferenceOptions): boolean;
     maybeAddReferencedBinary(workspace: Workspace, binaryName: string): Set<string> | undefined;
     private isInDependencies;
     settleDependencyIssues(): {

package/dist/DependencyDeputy.js

@@ -1,5 +1,5 @@
 import { isBuiltin } from 'node:module';
-import { DT_SCOPE, IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_RUNTIME_DEPENDENCIES, ROOT_WORKSPACE_NAME, } from './constants.js';
+import { DT_SCOPE, IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_RUNTIME_DEPENDENCIES, PROTOCOL_CLOUDFLARE, ROOT_WORKSPACE_NAME, } from './constants.js';
 import { getDependencyMetaData } from './manifest/index.js';
 import { PackagePeeker } from './PackagePeeker.js';
 import { getDefinitelyTypedFor, getPackageFromDefinitelyTyped, getPackageNameFromModuleSpecifier, isDefinitelyTyped, } from './util/modules.js';
@@ -124,18 +124,20 @@ export class DependencyDeputy {
     getOptionalPeerDependencies(workspaceName) {
         return this._manifests.get(workspaceName)?.optionalPeerDependencies ?? new Set();
     }
-    maybeAddReferencedExternalDependency(workspace, packageName, { specifier, isDevOnly, isTypeOnly, isResolved, isPublishedType }) {
+    maybeAddReferencedExternalDependency(workspace, packageName, { specifier, isDevOnly, isTypeOnly, isResolved, isPublishedType, isCaught }) {
         if (!this.isReportDependencies)
             return true;
-        if (specifier.startsWith('node:') || isBuiltin(specifier))
+        if (specifier.startsWith('node:') || specifier.startsWith(PROTOCOL_CLOUDFLARE) || isBuiltin(specifier))
             return true;
         if (IGNORED_RUNTIME_DEPENDENCIES.has(packageName))
             return true;
         if (packageName === workspace.pkgName)
             return true;
+        const optionalPeerDependencies = this.getOptionalPeerDependencies(workspace.name);
         const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...workspace.ancestors.toReversed()];
         const isDevOrTypeOnly = isDevOnly || (isTypeOnly && !isPublishedType);
-        const closestWorkspaceName = workspaceNames.find(name => this.isInDependencies(name, packageName, isDevOrTypeOnly));
+        const isCaughtOptionalPeer = isCaught && optionalPeerDependencies.has(packageName);
+        const closestWorkspaceName = workspaceNames.find(name => this.isInDependencies(name, packageName, isDevOrTypeOnly, isCaughtOptionalPeer));
         const typesPackageName = !isDefinitelyTyped(packageName) && getDefinitelyTypedFor(packageName);
         const closestWorkspaceNameForTypes = typesPackageName && workspaceNames.find(name => this.isInDependencies(name, typesPackageName, isDevOrTypeOnly));
         if (closestWorkspaceNameForTypes && !this.hasTypesIncluded.get(closestWorkspaceNameForTypes)?.has(packageName))
@@ -199,12 +201,15 @@ export class DependencyDeputy {
             return optionalDependencies;
         return;
     }
-    isInDependencies(workspaceName, packageName, isDevOnly) {
+    isInDependencies(workspaceName, packageName, isDevOnly, isCaughtOptionalPeer) {
         const manifest = this._manifests.get(workspaceName);
         if (!manifest)
             return false;
-        if (this.isStrict && !isDevOnly)
+        if (this.isStrict && !isDevOnly) {
+            if (isCaughtOptionalPeer && manifest.optionalPeerDependencies.has(packageName))
+                return true;
             return this.getProductionDependencies(workspaceName).includes(packageName);
+        }
         return manifest.allDependencies.has(packageName);
     }
     settleDependencyIssues() {

package/dist/IssueCollector.js

@@ -172,6 +172,7 @@ export class IssueCollector {
         }
         this.issues = initIssues();
         this.counters = initCounters();
+        this.tagHints.clear();
         return unusedFiles;
     }
     getIssues() {

package/dist/ProjectPrincipal.d.ts

@@ -2,7 +2,8 @@ import type { ParseResult } from 'oxc-parser';
 import { CacheConsultant } from './CacheConsultant.ts';
 import type { Compilers } from './compilers/types.ts';
 import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile, PluginVisitorContext, PluginVisitorObject } from './types/config.ts';
-import type { FileNode, ModuleGraph } from './types/module-graph.ts';
+import type { ConfigurationFiles } from './session/configuration.ts';
+import type { FileNode } from './types/module-graph.ts';
 import type { Paths } from './types/project.ts';
 import type { ResolveGlobPattern } from './typescript/resolve-module-names.ts';
 import { SourceFileManager } from './typescript/SourceFileManager.ts';
@@ -39,6 +40,7 @@ export declare class ProjectPrincipal {
     addCompilers(workspaceName: string, compilers: Compilers): void;
     addPaths(paths: Paths, basePath: string, scope: string): void;
     addRootDirs(rootDirs: string[] | undefined, scope: string): void;
+    collectConfigurationImports(configurationFiles: ConfigurationFiles): void;
     init(): void;
     private hasAcceptedExtension;
     addEntryPath(filePath: string, options?: {
@@ -57,5 +59,5 @@ export declare class ProjectPrincipal {
     private getCachedFile;
     analyzeSourceFile(filePath: string, sourceText: string, options: GetImportsAndExportsOptions, ignoreExportsUsedInFile: IgnoreExportsUsedInFile, parseResult?: ParseResult, cachedFile?: FileNode): FileNode;
     invalidateFile(filePath: string): void;
-    reconcileCache(graph: ModuleGraph): void;
+    reconcileCache(): void;
 }

package/dist/ProjectPrincipal.js

@@ -10,6 +10,14 @@ import { SourceFileManager } from './typescript/SourceFileManager.js';
 import { compact } from './util/array.js';
 import { timerify } from './util/Performance.js';
 import { extname, isInNodeModules, toAbsolute } from './util/path.js';
+const copyFileNode = (file) => ({
+    ...file,
+    imports: {
+        ...file.imports,
+        external: new Set(file.imports.external),
+        externalRefs: new Set(file.imports.externalRefs),
+    },
+});
 export class ProjectPrincipal {
     entryPaths = new Set();
     projectPaths = new Set();
@@ -55,7 +63,7 @@ export class ProjectPrincipal {
         this.pluginVisitorObjects.push(createBunShellVisitor(this.pluginCtx));
         this.fileManager = new SourceFileManager({
             compilers: this.compilers,
-            isSession: options.isSession || options.isWatch,
+            isSession: options.isSession,
         });
         this.walkAndAnalyze = timerify(this.walkAndAnalyze.bind(this), 'walkAndAnalyze');
     }
@@ -92,6 +100,23 @@ export class ProjectPrincipal {
         const scoped = this.rootDirs.get(scope) ?? [];
         this.rootDirs.set(scope, compact([...scoped, ...rootDirs]));
     }
+    collectConfigurationImports(configurationFiles) {
+        for (const filePath of configurationFiles.paths) {
+            if (!DEFAULT_EXTENSIONS.has(extname(filePath)))
+                continue;
+            const source = this.fileManager.readRawFile(filePath);
+            if (source === undefined)
+                continue;
+            try {
+                for (const specifier of extractSpecifiers(_parseFile(filePath, source), source, filePath)) {
+                    const resolved = this.resolveSpecifier(specifier, filePath);
+                    if (resolved && !isInNodeModules(resolved))
+                        configurationFiles.addImport(filePath, resolved);
+                }
+            }
+            catch { }
+        }
+    }
     init() {
         const scopedPaths = this.paths.size > 0 ? Array.from(this.paths, ([scope, paths]) => ({ scope, paths })) : undefined;
         const scopedRootDirs = this.rootDirs.size > 0 ? Array.from(this.rootDirs, ([scope, rootDirs]) => ({ scope, rootDirs })) : undefined;
@@ -225,7 +250,7 @@ export class ProjectPrincipal {
     getCachedFile(filePath) {
         const cachedFile = this.cache.getCachedFile(filePath);
         const skipExports = this.skipExportsAnalysis.has(filePath) || !this.isReportExports;
-        return cachedFile?.skipExports === skipExports ? cachedFile : undefined;
+        return cachedFile?.skipExports === skipExports ? copyFileNode(cachedFile) : undefined;
     }
     analyzeSourceFile(filePath, sourceText, options, ignoreExportsUsedInFile, parseResult, cachedFile) {
         if (cachedFile)
@@ -243,19 +268,16 @@ export class ProjectPrincipal {
         const visitor = ignoreExportsUsedInFile
             ? (this._localRefsVisitor ??= buildVisitor(this.pluginVisitorObjects, true))
             : (this._visitor ??= buildVisitor(this.pluginVisitorObjects, false));
-        return _getImportsAndExports(filePath, sourceText, this.resolveModule, options, ignoreExportsUsedInFile, skipExports, visitor, this.pluginVisitorObjects.length > 0 ? this.pluginCtx : undefined, parseResult);
+        const file = _getImportsAndExports(filePath, sourceText, this.resolveModule, options, ignoreExportsUsedInFile, skipExports, visitor, this.pluginVisitorObjects.length > 0 ? this.pluginCtx : undefined, parseResult);
+        if (this.projectPaths.has(filePath))
+            this.cache.setFileData(filePath, copyFileNode(file));
+        return file;
     }
     invalidateFile(filePath) {
         this.fileManager.invalidate(filePath);
         this.cache.removeEntry(filePath);
     }
-    reconcileCache(graph) {
-        for (const [filePath, file] of graph) {
-            const fd = this.cache.getFileDescriptor(filePath);
-            if (!fd?.meta)
-                continue;
-            fd.meta.data = { ...file, internalImportCache: undefined, importedBy: undefined };
-        }
+    reconcileCache() {
         this.cache.reconcile();
     }
 }

package/dist/WorkspaceWorker.d.ts

@@ -8,6 +8,7 @@ import type { DependencySet } from './types/workspace.ts';
 import { type Manifest } from './util/package-json.ts';
 import type { MainOptions } from './util/create-options.ts';
 import { type Input } from './util/input.ts';
+import type { ConfigurationFiles } from './session/configuration.ts';
 type WorkspaceManagerOptions = {
     name: string;
     dir: string;
@@ -24,6 +25,7 @@ type WorkspaceManagerOptions = {
     ignoredWorkspacePatterns: string[];
     enabledPluginsInAncestors: string[];
     configFilesMap: Map<string, Map<PluginName, Set<string>>>;
+    configurationFiles?: ConfigurationFiles;
     options: MainOptions;
 };
 type CacheItem = {
@@ -51,7 +53,8 @@ export declare class WorkspaceWorker {
     enabledPluginsInAncestors: string[];
     cache: CacheConsultant<Partial<Record<PluginName, CacheItem>>>;
     configFilesMap: Map<string, Map<PluginName, Set<string>>>;
-    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, handleConfigLoadError, findWorkspaceByFilePath, getManifest, readRawFile, configFilesMap, options, }: WorkspaceManagerOptions);
+    configurationFiles: ConfigurationFiles | undefined;
+    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, handleConfigLoadError, findWorkspaceByFilePath, getManifest, readRawFile, configFilesMap, configurationFiles, options, }: WorkspaceManagerOptions);
     init(): Promise<void>;
     private determineEnabledPlugins;
     private getConfigForPlugin;
@@ -60,7 +63,7 @@ export declare class WorkspaceWorker {
     getPluginProjectFilePatterns(patterns?: string[]): string[];
     private getPluginConfig;
     getPluginConfigPatterns(): string[];
-    getPluginEntryFilePatterns(patterns: string[]): string[];
+    getPluginEntryFilePatterns(patterns: string[], base?: string): string[];
     getProductionEntryFilePatterns(): string[];
     getProductionProjectFilePatterns(): string[];
     private getConfigurationFilePatterns;

package/dist/WorkspaceWorker.js

@@ -11,6 +11,7 @@ import { _parseFile } from './typescript/ast-nodes.js';
 import { compact } from './util/array.js';
 import { debugLog, debugLogArray, debugLogObject } from './util/debug.js';
 import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate } from './util/glob.js';
+import { expandIgnorePatterns } from './util/parse-and-convert-gitignores.js';
 import { isCatalog, isConfig, toConfig, toDebugString, toEntry, toProductionEntry, } from './util/input.js';
 import { filterTransitiveDependencies } from './util/filter-transitive-dependencies.js';
 import { timerify } from './util/Performance.js';
@@ -41,7 +42,8 @@ export class WorkspaceWorker {
     enabledPluginsInAncestors;
     cache;
     configFilesMap;
-    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, handleConfigLoadError, findWorkspaceByFilePath, getManifest, readRawFile, configFilesMap, options, }) {
+    configurationFiles;
+    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, handleConfigLoadError, findWorkspaceByFilePath, getManifest, readRawFile, configFilesMap, configurationFiles, options, }) {
         this.name = name;
         this.dir = dir;
         this.config = config;
@@ -52,6 +54,7 @@ export class WorkspaceWorker {
         this.ignoredWorkspacePatterns = ignoredWorkspacePatterns;
         this.enabledPluginsInAncestors = enabledPluginsInAncestors;
         this.configFilesMap = configFilesMap;
+        this.configurationFiles = configurationFiles;
         this.handleInput = handleInput;
         this.handleConfigLoadError = handleConfigLoadError;
         this.findWorkspaceByFilePath = findWorkspaceByFilePath;
@@ -128,9 +131,14 @@ export class WorkspaceWorker {
         }
         return patterns;
     }
-    getPluginEntryFilePatterns(patterns) {
+    getPluginEntryFilePatterns(patterns, base) {
         const negateWorkspaces = patterns.some(pattern => pattern.startsWith('**/')) ? this.negatedWorkspacePatterns : [];
-        return [patterns, negateWorkspaces, this.ignoredWorkspacePatterns.map(negate)].flat();
+        const prefix = `${this.name}/`;
+        const toWorkspaceRelative = (name) => (name.startsWith(prefix) ? name.slice(prefix.length) : name);
+        const ignoredWorkspaces = base
+            ? expandIgnorePatterns(this.ignoredWorkspacePatterns.map(toWorkspaceRelative))
+            : this.ignoredWorkspacePatterns;
+        return [patterns, negateWorkspaces, ignoredWorkspaces.map(negate)].flat();
     }
     getProductionEntryFilePatterns() {
         const entry = this.config.entry.filter(hasProductionSuffix);
@@ -220,7 +228,8 @@ export class WorkspaceWorker {
         const [productionScripts, developmentScripts] = getFilteredScripts(manifest.scripts ?? {});
         const inputsFromManifest = _getInputsFromScripts(Object.values(developmentScripts), baseOptions);
         const productionInputsFromManifest = _getInputsFromScripts(Object.values(productionScripts), baseOptions);
-        const hasProductionInput = (input) => productionInputsFromManifest.find(d => d.specifier === input.specifier && d.type === input.type);
+        for (const input of productionInputsFromManifest)
+            input.production = true;
         const createGetInputsFromScripts = (containingFilePath) => (scripts, options) => _getInputsFromScripts(scripts, { ...baseOptions, ...options, containingFilePath });
         const inputs = [];
         const configFilesMap = this.configFilesMap;
@@ -264,7 +273,7 @@ export class WorkspaceWorker {
             else if (isConfig(input)) {
                 storeConfigFilePath(input.pluginName, { ...input, containingFilePath: inputContainingFilePath });
             }
-            else if (!isProduction || (isProduction && (input.production || hasProductionInput(input)))) {
+            else if (!isProduction || input.production) {
                 inputs.push({ ...input, containingFilePath: inputContainingFilePath });
             }
         }
@@ -324,6 +333,7 @@ export class WorkspaceWorker {
                 if (seenConfigFiles.has(configFilePath))
                     continue;
                 seenConfigFiles.add(configFilePath);
+                this.configurationFiles?.paths.add(configFilePath);
                 const isManifest = basename(configFilePath) === 'package.json';
                 const fd = isManifest ? undefined : this.cache.getFileDescriptor(configFilePath);
                 const data = fd?.changed ? undefined : fd?.meta?.data?.[pluginName];
@@ -419,9 +429,11 @@ export class WorkspaceWorker {
                 for (const id of dependencies)
                     addInput(id, id.containingFilePath ?? containingFilePath);
             }
-            if (inputs.some(input => input.specifier.startsWith('!')))
+            if (inputs.some(input => input.specifier.startsWith('!'))) {
                 for (const input of inputs)
-                    input.group = pluginName;
+                    if (!seenConfigFiles.has(input.specifier))
+                        input.group = pluginName;
+            }
             return inputs;
         };
         const enabledPluginTitles = this.enabledPlugins.map(name => Plugins[name].title);
@@ -429,6 +441,7 @@ export class WorkspaceWorker {
         for (const pluginName of this.enabledPlugins) {
             const configFiles = this.configFilesMap.get(wsName);
             const patterns = [...this.getConfigurationFilePatterns(pluginName), ...(configFiles?.get(pluginName) ?? [])];
+            this.configurationFiles?.addPatterns(this.dir, compact(patterns));
             configFiles?.delete(pluginName);
             for (const input of await runPlugin(pluginName, compact(patterns)))
                 inputs.push(input);

package/dist/binaries/resolvers/bun.js

@@ -56,7 +56,12 @@ const commands = new Set([
 ]);
 export const resolve = (_binary, words, options) => {
     const binary = toCommandBinary(_binary, options);
-    const parsed = parseArgs(words, { string: ['cwd'] });
+    const parsed = parseArgs(words, {
+        string: ['cwd'],
+        boolean: ['bun', 'hot', 'if-present', 'silent', 'smol', 'watch'],
+        alias: { bun: 'b' },
+        isStorePositions: true,
+    });
     const [command, script] = parsed._;
     if (command === 'x') {
         const wordsForX = words.filter(word => word.value !== 'x');
@@ -81,7 +86,7 @@ export const resolve = (_binary, words, options) => {
     const dir = parsed.cwd ? join(cwd, parsed.cwd) : undefined;
     const opts = dir ? { cwd: dir } : {};
     if (command !== 'run')
-        return [binary, ...fromArgs(words, opts)];
+        return [binary, ...fromArgs(dir ? words : words.slice(parsed.positionalIndices[0]), opts)];
     const input = toBinary(filePath, { optional: true });
     if (dir)
         input.dir = dir;

package/dist/binaries/util.js

@@ -48,7 +48,8 @@ export const expandScript = (name, forwardedArgs, scripts, options, opts = {}) =
     if (expandedScripts.has(name))
         return;
     expandedScripts.add(name);
-    return options.fromArgs([source, ...forwardedArgs], { ...opts, expandedScripts });
+    const cwd = options.manifestDir ?? options.cwd;
+    return options.fromArgs([source, ...forwardedArgs], { cwd, manifestDir: undefined, ...opts, expandedScripts });
 };
 export const parseNodeArgs = (args) => parseArgs(args, {
     string: ['r'],

package/dist/cli.js

@@ -9,6 +9,7 @@ import { createPreprocessor, toReporterOptions } from './util/preprocessor.js';
 import { runReporters } from './util/reporter.js';
 import { prettyMilliseconds } from './util/string.js';
 import { version } from './version.js';
+import { watchSession } from './session/watch.js';
 let args = {};
 try {
     args = parseArgs();
@@ -32,6 +33,10 @@ const main = async () => {
             process.exit(0);
         }
         const options = await createOptions({ args });
+        if (options.isWatch) {
+            await watchSession(options);
+            return;
+        }
         const { results } = await run(options);
         if (options.isWatch || options.isTrace)
             return;
@@ -39,7 +44,7 @@ const main = async () => {
         const finalData = await preprocess(toReporterOptions(options, results, args));
         if (options.isFix)
             await fix(finalData.issues, finalData.counters, options);
-        await runReporters(args.reporter ?? ['symbols'], finalData);
+        await runReporters(args.reporter ?? ['symbols'], args['output-file'] ?? [], finalData);
         const totalErrorCount = Object.keys(finalData.report)
             .filter(reportGroup => finalData.report[reportGroup] && options.rules[reportGroup] === 'error')
             .reduce((errorCount, reportGroup) => errorCount + finalData.counters[reportGroup], 0);

package/dist/compilers/index.d.ts

@@ -3,4 +3,9 @@ import type { DependencySet } from '../types/workspace.ts';
 import type { Compilers, RawCompilers } from './types.ts';
 export declare const normalizeCompilerExtension: (ext: string) => string;
 export declare const normalizeCompilers: (rawLocalConfig: RawConfiguration) => RawCompilers;
+export declare const builtInCompilers: {
+    dependencies: string[];
+    compiler: import("./types.ts").CompilerSync;
+    extensions: string[];
+}[];
 export declare const getIncludedCompilers: (rawCompilers: RawCompilers, dependencies: DependencySet, onReferencedDependency?: (packageName: string) => void) => Compilers;

package/dist/compilers/index.js

@@ -18,7 +18,7 @@ export const normalizeCompilers = (rawLocalConfig) => {
     }
     return compilers;
 };
-const builtInCompilers = [
+export const builtInCompilers = [
     { extensions: ['.mdx'], ...MDX },
     { extensions: ['.sass', '.scss'], ...SCSS },
     { extensions: ['.less'], ...LESS },

package/dist/constants.d.ts

@@ -11,6 +11,7 @@ export declare const BETA_TAG = "@beta";
 export declare const ALIAS_TAG = "@alias";
 export declare const DT_SCOPE = "@types";
 export declare const PROTOCOL_VIRTUAL = "virtual:";
+export declare const PROTOCOL_CLOUDFLARE = "cloudflare:";
 export declare const IGNORED_GLOBAL_BINARIES: Set<string>;
 export declare const IGNORED_DEPENDENCIES: Set<string>;
 export declare const IGNORED_RUNTIME_DEPENDENCIES: Set<string>;
@@ -69,4 +70,5 @@ export declare const IMPORT_FLAGS: {
     readonly AUGMENT: number;
     readonly DYNAMIC: number;
     readonly LOADER: number;
+    readonly CAUGHT: number;
 };

package/dist/constants.js

@@ -20,6 +20,7 @@ export const BETA_TAG = '@beta';
 export const ALIAS_TAG = '@alias';
 export const DT_SCOPE = '@types';
 export const PROTOCOL_VIRTUAL = 'virtual:';
+export const PROTOCOL_CLOUDFLARE = 'cloudflare:';
 export const IGNORED_GLOBAL_BINARIES = new Set([
     'amplify',
     'aws',
@@ -278,4 +279,5 @@ export const IMPORT_FLAGS = {
     AUGMENT: 1 << 7,
     DYNAMIC: 1 << 8,
     LOADER: 1 << 9,
+    CAUGHT: 1 << 10,
 };