knip 6.39.0 → 6.41.0

package/dist/ConfigurationChief.d.ts

@@ -237,6 +237,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'expo-router'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'expressive-code'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -247,6 +252,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        flue?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         fumadocs?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -292,6 +302,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        jasmine?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         jest?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -497,6 +512,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        osls?: 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;
@@ -1066,8 +1086,10 @@ export declare class ConfigurationChief {
         eve?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         execa?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         expo?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        "expo-router"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "expressive-code"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         fast?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        flue?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         fumadocs?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         gatsby?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "github-action"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -1077,6 +1099,7 @@ export declare class ConfigurationChief {
         hardhat?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         husky?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "i18next-parser"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        jasmine?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         jest?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         karma?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         knex?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -1118,6 +1141,7 @@ export declare class ConfigurationChief {
         "openapi-ts"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         openclaw?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         orval?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        osls?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         oxfmt?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         oxlint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "panda-css"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/DependencyDeputy.d.ts

@@ -40,6 +40,7 @@ export declare class DependencyDeputy {
         peerDependencies: DependencySet;
         optionalPeerDependencies: DependencySet;
         requiredPeerDependencies: DependencyArray;
+        uninstalledOptionalDependencies: DependencySet;
         allDependencies: DependencySet;
         engines: Record<string, string>;
         isPrivate: boolean;

package/dist/DependencyDeputy.js

@@ -38,15 +38,25 @@ export class DependencyDeputy {
         const requiredPeerDependencies = peerDependencies.filter(dep => !optionalPeerDependencies.has(dep));
         const devDependencies = Object.keys(manifest.devDependencies ?? {});
         const allDependencies = [...dependencies, ...devDependencies, ...peerDependencies, ...optionalDependencies];
-        const packageNames = [...dependencies, ...peerDependencies, ...(this.isProduction ? [] : devDependencies)];
+        const uninstalledOptionalDependencies = new Set();
+        const packageNames = [
+            ...dependencies,
+            ...peerDependencies,
+            ...optionalDependencies,
+            ...(this.isProduction ? [] : devDependencies),
+        ];
         if (this.isReportDependencies) {
-            const { hostDependencies, installedBinaries, hasTypesIncluded } = getDependencyMetaData({
+            const { hostDependencies, installedBinaries, hasTypesIncluded, uninstalledDependencies } = getDependencyMetaData({
                 packageNames,
                 dir,
             });
             this.setHostDependencies(name, hostDependencies);
             this.installedBinaries.set(name, installedBinaries);
             this.hasTypesIncluded.set(name, hasTypesIncluded);
+            for (const dependency of optionalDependencies) {
+                if (uninstalledDependencies.has(dependency))
+                    uninstalledOptionalDependencies.add(dependency);
+            }
         }
         const ignoreDependencies = id.flatMap(id => filterIsProduction(id, this.isProduction)).map(toRegexOrString);
         const ignoreBinaries = ib.flatMap(ib => filterIsProduction(ib, this.isProduction)).map(toRegexOrString);
@@ -66,6 +76,7 @@ export class DependencyDeputy {
             peerDependencies: new Set(peerDependencies),
             optionalPeerDependencies,
             requiredPeerDependencies,
+            uninstalledOptionalDependencies,
             allDependencies: new Set(allDependencies),
             engines: manifest.engines ?? {},
             isPrivate: Boolean(manifest.private),
@@ -171,6 +182,21 @@ export class DependencyDeputy {
                 }
             }
         }
+        const optionalDependencies = new Set();
+        for (const name of workspaceNames) {
+            const manifest = this._manifests.get(name);
+            if (!manifest)
+                continue;
+            for (const dependency of manifest.uninstalledOptionalDependencies) {
+                const defaultBinaryName = dependency.replace(/^@[^/]+\//, '');
+                if (defaultBinaryName === binaryName) {
+                    optionalDependencies.add(dependency);
+                    this.addReferencedDependency(name, dependency);
+                }
+            }
+        }
+        if (optionalDependencies.size)
+            return optionalDependencies;
         return;
     }
     isInDependencies(workspaceName, packageName, isDevOnly) {

package/dist/IssueCollector.js

@@ -1,7 +1,6 @@
 import picomatch from 'picomatch';
 import { ROOT_WORKSPACE_NAME } from './constants.js';
 import { partition } from './util/array.js';
-import { prependDirToPattern } from './util/glob.js';
 import { initCounters, initIssues } from './util/issue-initializers.js';
 import { relative } from './util/path.js';
 const createMatcher = (patterns) => {
@@ -82,23 +81,22 @@ export class IssueCollector {
             return;
         const issueTypePatterns = new Map();
         for (const [pattern, issueTypes] of Object.entries(ignoreIssues)) {
-            const id = prependDirToPattern(this.cwd, pattern);
             for (const issueType of issueTypes) {
                 if (!issueTypePatterns.has(issueType)) {
                     issueTypePatterns.set(issueType, []);
                 }
-                issueTypePatterns.get(issueType)?.push(id);
+                issueTypePatterns.get(issueType)?.push(pattern);
             }
         }
         for (const [issueType, patterns] of issueTypePatterns) {
             this.issueMatchers.set(issueType, picomatch(patterns, { dot: true }));
         }
     }
-    shouldIgnoreIssue(filePath, issueType) {
+    shouldIgnoreIssue(relativePath, issueType) {
         const matcher = this.issueMatchers.get(issueType);
         if (!matcher)
             return false;
-        return matcher(filePath);
+        return matcher(relativePath);
     }
     addFileCounts({ processed, unused }) {
         this.counters.processed += processed;
@@ -110,17 +108,17 @@ export class IssueCollector {
                 continue;
             if (this.referencedFiles.has(filePath))
                 continue;
-            if (this.isMatch(filePath)) {
-                this.markUsedPatterns(filePath, this.unusedIgnorePatterns);
+            const symbol = relative(this.cwd, filePath);
+            if (this.isMatch(symbol)) {
+                this.markUsedPatterns(symbol, this.unusedIgnorePatterns);
                 continue;
             }
-            if (this.isFileMatch(filePath)) {
-                this.markUsedPatterns(filePath, this.unusedIgnoreFilesPatterns);
+            if (this.isFileMatch(symbol)) {
+                this.markUsedPatterns(symbol, this.unusedIgnoreFilesPatterns);
                 continue;
             }
-            if (this.shouldIgnoreIssue(filePath, 'files'))
+            if (this.shouldIgnoreIssue(symbol, 'files'))
                 continue;
-            const symbol = relative(this.cwd, filePath);
             this.issues.files[symbol] = {
                 [symbol]: { type: 'files', filePath, symbol, workspace: '', severity: this.rules.files, fixes: [] },
             };
@@ -131,15 +129,15 @@ export class IssueCollector {
     addIssue(issue) {
         if (!this.workspaceFilter(issue.filePath))
             return;
-        if (this.isMatch(issue.filePath)) {
-            this.markUsedPatterns(issue.filePath, this.unusedIgnorePatterns);
+        const key = relative(this.cwd, issue.filePath);
+        if (this.isMatch(key)) {
+            this.markUsedPatterns(key, this.unusedIgnorePatterns);
             return;
         }
-        if (this.shouldIgnoreIssue(issue.filePath, issue.type))
+        if (this.shouldIgnoreIssue(key, issue.type))
             return;
         if (this.rules[issue.type] === 'off')
             return;
-        const key = relative(this.cwd, issue.filePath);
         issue.severity = this.rules[issue.type];
         const issues = this.issues[issue.type];
         issues[key] = issues[key] ?? {};

package/dist/IssueFixer.js

@@ -21,7 +21,7 @@ export const fix = async (issues, counters, options) => {
     }
     if (options.isFormat) {
         const report = await formatly(Array.from(touchedFiles));
-        if (report.ran && report.result && (report.result.runner === 'virtual' || report.result.code === 0)) {
+        if (report.ran && report.result.runner !== 'dry-run' && report.result.code === 0) {
             debugLogArray('*', `Formatted files using ${report.formatter.name} (${report.formatter.runner})`, touchedFiles);
         }
         else {

package/dist/WorkspaceWorker.d.ts

@@ -49,7 +49,7 @@ export declare class WorkspaceWorker {
     enabledPluginsMap: Partial<Record<PluginName, boolean>>;
     enabledPlugins: PluginName[];
     enabledPluginsInAncestors: string[];
-    cache: CacheConsultant<CacheItem>;
+    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);
     init(): Promise<void>;
@@ -61,14 +61,13 @@ export declare class WorkspaceWorker {
     private getPluginConfig;
     getPluginConfigPatterns(): string[];
     getPluginEntryFilePatterns(patterns: string[]): string[];
-    getProductionEntryFilePatterns(negatedTestFilePatterns: string[]): string[];
-    getProductionProjectFilePatterns(negatedTestFilePatterns: string[]): string[];
+    getProductionEntryFilePatterns(): string[];
+    getProductionProjectFilePatterns(): string[];
     private getConfigurationFilePatterns;
     registerCompilers(registerCompiler: RegisterCompiler): Promise<void>;
     resolveSourceMaps(): Promise<SourceMap[]>;
     registerVisitors(options: RegisterVisitorsOptions): void;
     runPlugins(): Promise<Input[]>;
-    private filterTransitiveDependencies;
     getConfigurationHints(type: 'entry' | 'project', patterns: string[], filePaths: string[], includedPaths: Set<string>, compilerExtensions?: Set<string>): ConfigurationHint[];
     onDispose(): void;
 }

package/dist/WorkspaceWorker.js

@@ -6,15 +6,15 @@ import { DEFAULT_EXTENSIONS, ROOT_WORKSPACE_NAME } from './constants.js';
 import { getFilteredScripts } from './manifest/helpers.js';
 import { PluginEntries, Plugins } from './plugins.js';
 import { createManifest } from './util/package-json.js';
-import { collectStringLiterals, isExternalReExportsOnly } from './typescript/ast-helpers.js';
+import { isExternalReExportsOnly } from './typescript/ast-helpers.js';
 import { _parseFile } from './typescript/ast-nodes.js';
 import { compact } from './util/array.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate } from './util/glob.js';
-import { isCatalog, isConfig, isDeferResolve, isDependency, toConfig, toDebugString, toEntry, toProductionEntry, } from './util/input.js';
-import { getPackageNameFromSpecifier } from './util/modules.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';
-import { basename, dirname, isInternal, join, toRelative } from './util/path.js';
+import { basename, dirname, join, relative, toRelative } from './util/path.js';
 import { extractPatternExtensions } from './util/pattern-extensions.js';
 import { formatCauseMessage } from './util/errors.js';
 import { logError } from './util/log.js';
@@ -132,17 +132,17 @@ export class WorkspaceWorker {
         const negateWorkspaces = patterns.some(pattern => pattern.startsWith('**/')) ? this.negatedWorkspacePatterns : [];
         return [patterns, negateWorkspaces, this.ignoredWorkspacePatterns.map(negate)].flat();
     }
-    getProductionEntryFilePatterns(negatedTestFilePatterns) {
+    getProductionEntryFilePatterns() {
         const entry = this.config.entry.filter(hasProductionSuffix);
         if (entry.length === 0)
             return [];
         const negatedEntryFiles = this.config.entry.filter(hasNoProductionSuffix).map(negate);
-        return [entry, negatedEntryFiles, negatedTestFilePatterns, this.negatedWorkspacePatterns].flat();
+        return [entry, negatedEntryFiles, this.negatedWorkspacePatterns].flat();
     }
-    getProductionProjectFilePatterns(negatedTestFilePatterns) {
+    getProductionProjectFilePatterns() {
         const project = this.config.project;
         if (project.length === 0)
-            return this.getProductionEntryFilePatterns(negatedTestFilePatterns);
+            return this.getProductionEntryFilePatterns();
         const _project = this.config.project.map(pattern => {
             if (!(pattern.endsWith('!') || pattern.startsWith('!')))
                 return negate(pattern);
@@ -156,7 +156,6 @@ export class WorkspaceWorker {
             negatedEntryFiles,
             negatedPluginConfigPatterns,
             negatedPluginProjectFilePatterns,
-            negatedTestFilePatterns,
             this.negatedWorkspacePatterns,
         ].flat();
     }
@@ -326,8 +325,8 @@ export class WorkspaceWorker {
                 seenConfigFiles.add(configFilePath);
                 const isManifest = basename(configFilePath) === 'package.json';
                 const fd = isManifest ? undefined : this.cache.getFileDescriptor(configFilePath);
-                if (fd?.meta?.data && !fd.changed) {
-                    const data = fd.meta.data;
+                const data = fd?.changed ? undefined : fd?.meta?.data?.[pluginName];
+                if (data) {
                     if (data.resolveConfig)
                         for (const id of data.resolveConfig)
                             addInput(id, configFilePath);
@@ -370,7 +369,7 @@ export class WorkspaceWorker {
                                 if (localConfig) {
                                     const inputs = await plugin.resolveConfig(localConfig, resolveOpts);
                                     if (plugin.isFilterTransitiveDependencies && !isManifest) {
-                                        this.filterTransitiveDependencies(inputs, configFilePath);
+                                        filterTransitiveDependencies(inputs, configFilePath, this.readRawFile);
                                     }
                                     for (const input of inputs)
                                         addInput(input, configFilePath);
@@ -405,7 +404,7 @@ export class WorkspaceWorker {
                         this.cache.removeEntry(configFilePath);
                     }
                     else if (fd?.meta) {
-                        fd.meta.data = cache;
+                        fd.meta.data = { ...fd.meta.data, [pluginName]: cache };
                     }
                 }
             }
@@ -458,31 +457,6 @@ export class WorkspaceWorker {
         debugLogArray(wsName, 'Plugin dependencies', () => compact(inputs.map(input => toDebugString(input, rootCwd))));
         return inputs;
     }
-    filterTransitiveDependencies(inputs, configFilePath) {
-        const literals = new Set();
-        const visited = new Set();
-        const collect = (filePath) => {
-            if (visited.has(filePath))
-                return;
-            visited.add(filePath);
-            const sourceText = this.readRawFile(filePath);
-            if (!sourceText)
-                return;
-            for (const literal of collectStringLiterals(sourceText, filePath)) {
-                literals.add(literal);
-                if (isInternal(literal))
-                    collect(join(dirname(filePath), literal));
-            }
-        };
-        collect(configFilePath);
-        for (const input of inputs) {
-            if (!input.optional && (isDeferResolve(input) || isDependency(input))) {
-                const name = getPackageNameFromSpecifier(input.specifier);
-                if (name && !literals.has(name))
-                    input.optional = true;
-            }
-        }
-    }
     getConfigurationHints(type, patterns, filePaths, includedPaths, compilerExtensions) {
         const hints = [];
         const entries = this.config[type].filter(pattern => !pattern.startsWith('!'));
@@ -495,18 +469,24 @@ export class WorkspaceWorker {
             hints.push({ type: `${type}-empty`, identifier, workspaceName });
             return hints;
         }
+        const dir = this.dir;
+        const relativePaths = [];
+        const hasMatch = (isMatch) => {
+            for (let i = 0; i < filePaths.length; i++) {
+                if (isMatch((relativePaths[i] ??= relative(dir, filePaths[i]))))
+                    return true;
+            }
+            return false;
+        };
         for (const pattern of patterns) {
             if (pattern.startsWith('!'))
                 continue;
-            const filePathOrPattern = join(this.dir, pattern.replace(/!$/, ''));
-            if (includedPaths.has(filePathOrPattern)) {
+            const id = pattern.replace(/!$/, '');
+            if (includedPaths.has(join(dir, id))) {
                 hints.push({ type: `${type}-redundant`, identifier: pattern, workspaceName });
             }
-            else {
-                const matcher = picomatch(filePathOrPattern);
-                if (!filePaths.some(filePath => matcher(filePath))) {
-                    hints.push({ type: `${type}-empty`, identifier: pattern, workspaceName });
-                }
+            else if (!hasMatch(picomatch(id))) {
+                hints.push({ type: `${type}-empty`, identifier: pattern, workspaceName });
             }
         }
         if (type === 'project' && compilerExtensions) {

package/dist/binaries/bash-parser.js

@@ -7,6 +7,11 @@ import { walkCommands } from '../util/scripts.js';
 import { getDependenciesFromCommand } from './command.js';
 import { toScript } from './util.js';
 const collectExpansionScripts = (word, out) => {
+    if (word.type === 'ArrayValue') {
+        for (const element of word.elements)
+            collectExpansionScripts(element, out);
+        return;
+    }
     if (!word.parts)
         return;
     for (const part of word.parts) {
@@ -63,11 +68,12 @@ export const getDependenciesFromScript = (script, options) => {
     const processCommand = (node, pending) => {
         if (node.name)
             collectExpansionScripts(node.name, pending);
-        for (const prefix of node.prefix)
-            if (prefix.value)
+        for (const prefix of node.prefix) {
+            if (prefix.type === 'Assignment')
                 collectExpansionScripts(prefix.value, pending);
-        for (const suffix of node.suffix)
-            collectExpansionScripts(suffix, pending);
+        }
+        for (const arg of node.args)
+            collectExpansionScripts(arg.type === 'Assignment' ? arg.value : arg, pending);
         if (definedFunctions.size && node.name && definedFunctions.has(extractBinary(node.name.value)))
             return [];
         return getDependenciesFromCommand(node, { ...options, fromArgs }, fromWords);

package/dist/binaries/command.d.ts

@@ -2,4 +2,4 @@ import type { Command, Word } from 'unbash';
 import type { BinaryResolverOptions, GetInputsFromScriptsOptions } from '../types/config.ts';
 import { type Input } from '../util/input.ts';
 export declare const getInputsFromNodeOptions: (prefix: Command['prefix']) => Input[];
-export declare const getDependenciesFromCommand: (node: Command, options: BinaryResolverOptions, fromWords?: (words: Word[], options: GetInputsFromScriptsOptions) => Input[]) => Input[];
+export declare const getDependenciesFromCommand: (node: Pick<Command, 'name' | 'prefix' | 'args'>, options: BinaryResolverOptions, fromWords?: (words: Word[], options: GetInputsFromScriptsOptions) => Input[]) => Input[];

package/dist/binaries/command.js

@@ -1,17 +1,23 @@
 import { Plugins, pluginArgsMap } from '../plugins.js';
 import { toDeferResolve } from '../util/input.js';
 import { extractBinary, isInNodeModulesBin, isRelativeNodeModulesBin } from '../util/modules.js';
+import { getCommandWords } from '../util/scripts.js';
 import { resolve as fallbackResolve, spawningBinaries } from './fallback.js';
 import KnownResolvers, { isPackageManager } from './resolvers/index.js';
 import { resolve as resolverFromPlugins } from './plugins.js';
 import { parseNodeArgs, toCommandBinary } from './util.js';
-export const getInputsFromNodeOptions = (prefix) => prefix
-    .filter(a => a.name === 'NODE_OPTIONS' && a.value)
-    .map(a => a.value.value)
-    .map(arg => parseNodeArgs(arg.split(' ')))
-    .filter(args => args.require)
-    .flatMap(arg => arg.require)
-    .map(id => toDeferResolve(id));
+export const getInputsFromNodeOptions = (prefix) => {
+    const inputs = [];
+    for (const item of prefix) {
+        if (item.type !== 'Assignment' || item.name !== 'NODE_OPTIONS' || item.value.type !== 'Word')
+            continue;
+        const args = parseNodeArgs(item.value.value.split(' '));
+        if (args.require)
+            for (const id of [args.require].flat())
+                inputs.push(toDeferResolve(id));
+    }
+    return inputs;
+};
 export const getDependenciesFromCommand = (node, options, fromWords = options.fromArgs) => {
     const text = node.name?.value;
     if (!text)
@@ -31,7 +37,7 @@ export const getDependenciesFromCommand = (node, options, fromWords = options.fr
         };
     }
     const { fromArgs } = options;
-    const words = node.suffix;
+    const words = getCommandWords(node);
     if (binary === '!' || binary === 'test')
         return fromArgs(words);
     const fromNodeOptions = getInputsFromNodeOptions(node.prefix);

package/dist/compilers/compilers.js

@@ -1,6 +1,6 @@
 export const fencedCodeBlockMatcher = /```[\s\S]*?```/g;
 export const inlineCodeMatcher = /`[^`]+`/g;
-export const scriptExtractor = /<script\b((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<\/script>/gi;
+export const scriptExtractor = /<script\b((?:[^>"']|"[^"]*"|'[^']*')*)(?<!\/)>([\s\S]*?)<\/script>/gi;
 export const styleExtractor = /<style\b((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<\/style>/gi;
 const langAttrMatcher = /\blang\s*=\s*["']([^"']+)["']/i;
 export const blockCommentMatcher = /\/\*[\s\S]*?\*\//g;

package/dist/graph/build.js

@@ -9,7 +9,7 @@ import { existsSync } from 'node:fs';
 import picomatch from 'picomatch';
 import { tryRealpath } from '../util/fs.js';
 import { createManifest } from '../util/package-json.js';
-import { _glob, _syncGlob, negate, prependDirToPattern as prependDir } from '../util/glob.js';
+import { _glob, _syncGlob, prependDirToPattern as prependDir, removeProductionSuffix } from '../util/glob.js';
 import { isAlias, isCatalog, isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isIgnore, isProductionEntry, isProject, toDeferResolveEntry, toDependency, toProductionEntry, } from '../util/input.js';
 import { isAmbientDeclarationFile } from '../typescript/ast-nodes.js';
 import { resolveImportGlobs } from '../typescript/glob-imports.js';
@@ -19,6 +19,7 @@ import { createFileNode, updateImportMap } from '../util/module-graph.js';
 import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
 import { perfObserver } from '../util/Performance.js';
 import { getEntrySpecifiersFromManifest, getManifestImportDependencies } from '../util/package-json.js';
+import { expandIgnorePatterns } from '../util/parse-and-convert-gitignores.js';
 import { dirname, extname, isAbsolute, isInNodeModules, isInternal, join, relative } from '../util/path.js';
 import { extensionAlias } from '../util/resolve.js';
 import { augmentWorkspace, getToSourcePathsHandler, toSourceMappedSpecifiers } from '../util/to-source-path.js';
@@ -50,8 +51,8 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         });
     }
     deputy.setWorkspacePkgNames(chief.availableWorkspacePkgNames);
-    collector.addIgnorePatterns(chief.config.ignore.map(id => ({ pattern: prependDir(options.cwd, id), id })));
-    collector.addIgnoreFilesPatterns(chief.config.ignoreFiles.map(id => ({ pattern: prependDir(options.cwd, id), id })));
+    collector.addIgnorePatterns(chief.config.ignore.map(id => ({ pattern: id, id })));
+    collector.addIgnoreFilesPatterns(chief.config.ignoreFiles.map(id => ({ pattern: id, id })));
     if (options.configFilePath) {
         principal.addEntryPath(options.configFilePath, { skipExportsAnalysis: true });
     }
@@ -78,7 +79,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             continue;
         const dependencies = deputy.getDependencies(name);
         const tsConfigFilePath = join(dir, options.tsConfigFile ?? 'tsconfig.json');
-        const { isFile, compilerOptions, fileNames, include, exclude, sourceMapPairs, paths: tsConfigPaths, } = await loadTSConfig(tsConfigFilePath);
+        const { isFile, compilerOptions, fileNames, include, exclude, sourceMapPairs, paths: tsConfigPaths, } = await loadTSConfig(tsConfigFilePath, options.isUseTscFiles);
         const [definitionPaths, tscSourcePaths] = partition(fileNames, filePath => IS_DTS.test(filePath));
         const worker = new WorkspaceWorker({
             name,
@@ -121,7 +122,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 inputs.add(toProductionEntry(tryRealpath(id), { containingFilePath: tsConfigFilePath }));
         }
         const sharedGlobOptions = { cwd: options.cwd, dir, gitignore: options.gitignore };
-        const fn = (id) => ({ pattern: prependDir(options.cwd, prependDir(name, id)), id, workspaceName: name });
+        const fn = (id) => ({ pattern: prependDir(name, id), id, workspaceName: name });
         collector.addIgnorePatterns(config.ignore.map(fn));
         collector.addIgnoreFilesPatterns(config.ignoreFiles.map(fn));
         const entrySpecifiersFromManifest = getEntrySpecifiersFromManifest(manifest);
@@ -246,16 +247,30 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 }
             }
         }
-        const negatedEntryPatterns = [];
+        const developmentMatchers = [];
         if (options.isProduction) {
+            const toPattern = (pattern) => {
+                const id = removeProductionSuffix(pattern);
+                return isAbsolute(id) ? relative(options.cwd, id) : join(name, id);
+            };
             for (const map of [entryPatterns, entryPatternsSkipExports]) {
-                for (const patterns of map.values())
-                    for (const pattern of patterns)
-                        negatedEntryPatterns.push(negate(pattern));
+                for (const patterns of map.values()) {
+                    const [excluded, included] = partition(patterns, pattern => pattern.startsWith('!'));
+                    if (included.length === 0)
+                        continue;
+                    const ignore = expandIgnorePatterns(excluded.map(pattern => removeProductionSuffix(pattern.slice(1))));
+                    developmentMatchers.push(picomatch(included.map(toPattern), { ignore: ignore.map(toPattern), dot: true }));
+                }
             }
         }
+        const productionPaths = (paths) => developmentMatchers.length
+            ? paths.filter(path => {
+                const relativePath = relative(options.cwd, path);
+                return !developmentMatchers.some(match => match(relativePath));
+            })
+            : paths;
         const userEntryPatterns = options.isProduction
-            ? worker.getProductionEntryFilePatterns(negatedEntryPatterns)
+            ? worker.getProductionEntryFilePatterns()
             : worker.getEntryFilePatterns();
         const userEntryPaths = await _glob({
             ...sharedGlobOptions,
@@ -272,7 +287,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 ]);
                 const label = `entry paths from plugins${group !== DEFAULT_GROUP ? ` - ${group}` : ''}`;
                 const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
-                principal.addEntryPaths(pluginWorkspaceEntryPaths);
+                principal.addEntryPaths(productionPaths(pluginWorkspaceEntryPaths));
             }
             {
                 const patterns = worker.getPluginEntryFilePatterns([
@@ -293,7 +308,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 collector.addConfigurationHint(hint);
         }
         const hasExplicitEntries = config.entry.some(pattern => !isDefaultPattern('entry', pattern));
-        principal.addEntryPaths(userEntryPaths, hasExplicitEntries ? { skipExportsAnalysis: false } : undefined);
+        principal.addEntryPaths(productionPaths(userEntryPaths), hasExplicitEntries ? { skipExportsAnalysis: false } : undefined);
         if (options.isUseTscFiles && isFile) {
             const isIgnoredWorkspace = chief.createIgnoredWorkspaceMatcher(name, dir);
             debugLogArray(name, 'Using tsconfig files as project files', tscSourcePaths);
@@ -306,10 +321,11 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             }
             if (extensions.length > 0) {
                 const extPart = extensions.length === 1 ? extensions[0] : `.{${extensions.map(ext => ext.slice(1)).join(',')}}`;
-                const bases = include ? new Set(include.map(p => picomatch.scan(p).base || dir)) : new Set([dir]);
+                const tsConfigDir = relative(dir, dirname(tsConfigFilePath));
+                const bases = include ? new Set(include.map(p => join(tsConfigDir, picomatch.scan(p).base))) : new Set(['']);
                 const patterns = [
-                    ...Array.from(bases, base => `${base}/**/*${extPart}`),
-                    ...(exclude?.map(p => `!${p}`) ?? []),
+                    ...Array.from(bases, base => join(base, `**/*${extPart}`)),
+                    ...(exclude?.map(p => `!${join(tsConfigDir, p)}`) ?? []),
                 ];
                 const compilerPaths = await _glob({ ...sharedGlobOptions, patterns, label: 'compiler extension paths' });
                 for (const compilerPath of compilerPaths) {
@@ -320,7 +336,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         }
         else {
             const patterns = options.isProduction
-                ? worker.getProductionProjectFilePatterns(negatedEntryPatterns)
+                ? worker.getProductionProjectFilePatterns()
                 : worker.getProjectFilePatterns([
                     ...(productionPatternsSkipExports.get(DEFAULT_GROUP) ?? []),
                     ...projectFilePatterns,
@@ -332,7 +348,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 for (const hint of hints)
                     collector.addConfigurationHint(hint);
             }
-            for (const projectPath of projectPaths)
+            for (const projectPath of productionPaths(projectPaths))
                 principal.addProjectPath(projectPath);
         }
         worker.onDispose();

package/dist/manifest/index.d.ts

@@ -7,6 +7,7 @@ declare const getMetaDataFromPackageJson: ({ dir, packageNames }: Options) => {
     hostDependencies: HostDependencies;
     installedBinaries: InstalledBinaries;
     hasTypesIncluded: Set<string>;
+    uninstalledDependencies: Set<string>;
 };
 export declare const getDependencyMetaData: typeof getMetaDataFromPackageJson;
 export {};