knip 6.35.0 → 6.36.0

package/dist/ConfigurationChief.d.ts

@@ -787,6 +787,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        textlint?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         travis?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -867,6 +872,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        varlock?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         vercel?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1145,6 +1155,7 @@ export declare class ConfigurationChief {
         taskfile?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tauri?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         temporal?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        textlint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         travis?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "ts-node"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tsd?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -1161,6 +1172,7 @@ export declare class ConfigurationChief {
         "unplugin-vue-i18n"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "unplugin-vue-markdown"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "unplugin-vue-router"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        varlock?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         vercel?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "vercel-og"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         vike?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/IssueCollector.d.ts

@@ -12,6 +12,7 @@ export declare class IssueCollector {
     private referencedFiles;
     private configurationHints;
     private tagHints;
+    private hasConfigLoadErrors;
     private ignorePatterns;
     private ignoreFilesPatterns;
     private isMatch;
@@ -46,12 +47,14 @@ export declare class IssueCollector {
     addIssue(issue: Issue): true | undefined;
     addConfigurationHint(issue: ConfigurationHint): void;
     addTagHint(issue: TagHint): void;
+    addConfigLoadError(): void;
     purge(): Set<string>;
     getIssues(): {
         issues: import("./types/issues.ts").Issues;
         counters: import("./types/issues.ts").Counters;
         tagHints: Set<TagHint>;
         configurationHints: ConfigurationHint[];
+        hasConfigLoadErrors: boolean;
     };
     getUnusedIgnorePatternHints(options: MainOptions): ConfigurationHint[];
     private retainedIssues;

package/dist/IssueCollector.js

@@ -22,6 +22,7 @@ export class IssueCollector {
     referencedFiles = new Set();
     configurationHints = new Map();
     tagHints = new Set();
+    hasConfigLoadErrors = false;
     ignorePatterns = new Set();
     ignoreFilesPatterns = new Set();
     isMatch;
@@ -162,6 +163,9 @@ export class IssueCollector {
     addTagHint(issue) {
         this.tagHints.add(issue);
     }
+    addConfigLoadError() {
+        this.hasConfigLoadErrors = true;
+    }
     purge() {
         const unusedFiles = new Set();
         for (const issues of Object.values(this.issues.files)) {
@@ -178,6 +182,7 @@ export class IssueCollector {
             counters: this.counters,
             tagHints: this.tagHints,
             configurationHints: Array.from(this.configurationHints.values()),
+            hasConfigLoadErrors: this.hasConfigLoadErrors,
         };
     }
     getUnusedIgnorePatternHints(options) {

package/dist/WorkspaceWorker.d.ts

@@ -16,6 +16,7 @@ type WorkspaceManagerOptions = {
     dependencies: DependencySet;
     rootManifest: Manifest | undefined;
     handleInput: HandleInput;
+    handleConfigLoadError: () => void;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
     getManifest: (dir: string) => Manifest | undefined;
     readRawFile: (filePath: string) => string;
@@ -38,6 +39,7 @@ export declare class WorkspaceWorker {
     rootManifest: Manifest | undefined;
     dependencies: DependencySet;
     handleInput: HandleInput;
+    handleConfigLoadError: () => void;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
     getManifest: (dir: string) => Manifest | undefined;
     readRawFile: (filePath: string) => string;
@@ -49,7 +51,7 @@ export declare class WorkspaceWorker {
     enabledPluginsInAncestors: string[];
     cache: CacheConsultant<CacheItem>;
     configFilesMap: Map<string, Map<PluginName, Set<string>>>;
-    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getManifest, readRawFile, configFilesMap, options, }: WorkspaceManagerOptions);
+    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, handleConfigLoadError, findWorkspaceByFilePath, getManifest, readRawFile, configFilesMap, options, }: WorkspaceManagerOptions);
     init(): Promise<void>;
     private determineEnabledPlugins;
     private getConfigForPlugin;

package/dist/WorkspaceWorker.js

@@ -29,6 +29,7 @@ export class WorkspaceWorker {
     rootManifest;
     dependencies;
     handleInput;
+    handleConfigLoadError;
     findWorkspaceByFilePath;
     getManifest;
     readRawFile;
@@ -40,7 +41,7 @@ export class WorkspaceWorker {
     enabledPluginsInAncestors;
     cache;
     configFilesMap;
-    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getManifest, readRawFile, configFilesMap, options, }) {
+    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, handleConfigLoadError, findWorkspaceByFilePath, getManifest, readRawFile, configFilesMap, options, }) {
         this.name = name;
         this.dir = dir;
         this.config = config;
@@ -52,6 +53,7 @@ export class WorkspaceWorker {
         this.enabledPluginsInAncestors = enabledPluginsInAncestors;
         this.configFilesMap = configFilesMap;
         this.handleInput = handleInput;
+        this.handleConfigLoadError = handleConfigLoadError;
         this.findWorkspaceByFilePath = findWorkspaceByFilePath;
         this.getManifest = getManifest;
         this.readRawFile = readRawFile;
@@ -257,14 +259,15 @@ export class WorkspaceWorker {
             }
         };
         for (const input of [...inputsFromManifest, ...productionInputsFromManifest]) {
+            const inputContainingFilePath = input.containingFilePath ?? containingFilePath;
             if (isCatalog(input)) {
-                inputs.push({ ...input, containingFilePath });
+                inputs.push({ ...input, containingFilePath: inputContainingFilePath });
             }
             else if (isConfig(input)) {
-                storeConfigFilePath(input.pluginName, { ...input, containingFilePath });
+                storeConfigFilePath(input.pluginName, { ...input, containingFilePath: inputContainingFilePath });
             }
             else if (!isProduction || (isProduction && (input.production || hasProductionInput(input)))) {
-                inputs.push({ ...input, containingFilePath });
+                inputs.push({ ...input, containingFilePath: inputContainingFilePath });
             }
         }
         const runPlugin = async (pluginName, patterns, isResolvedConfigFiles = false) => {
@@ -297,6 +300,7 @@ export class WorkspaceWorker {
                 configFilePath: containingFilePath,
                 configFileDir: cwd,
                 configFileName: '',
+                isResolvedConfigFile: isResolvedConfigFiles,
                 getInputsFromScripts: createGetInputsFromScripts(containingFilePath),
             };
             if (config.entry) {
@@ -378,6 +382,7 @@ export class WorkspaceWorker {
                                 if (!(error instanceof Error))
                                     throw error;
                                 hasLoadConfigError = true;
+                                this.handleConfigLoadError();
                                 const relPath = toRelative(configFilePath, this.options.cwd);
                                 const cause = formatCauseMessage(error, this.options.cwd);
                                 logError(`Error loading ${relPath} (${cause})`);
@@ -408,7 +413,7 @@ export class WorkspaceWorker {
             if (plugin.resolve) {
                 const dependencies = (await plugin.resolve(options)) ?? [];
                 for (const id of dependencies)
-                    addInput(id, containingFilePath);
+                    addInput(id, id.containingFilePath ?? containingFilePath);
             }
             if (inputs.some(input => input.specifier.startsWith('!')))
                 for (const input of inputs)

package/dist/binaries/command.js

@@ -26,13 +26,13 @@ export const getDependenciesFromCommand = (node, options, fromWords = options.fr
     const fromNodeOptions = getInputsFromNodeOptions(node.prefix);
     if (binary in KnownResolvers) {
         const resolver = KnownResolvers[binary];
-        return resolver(binary, words, options);
+        return [...resolver(binary, words, options), ...fromNodeOptions];
     }
     if (pluginArgsMap.has(binary)) {
         return [...resolverFromPlugins(binary, words, options), ...fromNodeOptions];
     }
     if (spawningBinaries.includes(binary)) {
-        return [toBinary(binary), ...fromWords(words, options)];
+        return [toBinary(binary), ...fromWords(words, options), ...fromNodeOptions];
     }
     if (binary in Plugins) {
         const inputs = fallbackResolve(binary, words, options);

package/dist/cli.js

@@ -54,6 +54,10 @@ const main = async () => {
             console.log('\nTotal running time:', prettyMilliseconds(duration));
             perfObserver.reset();
         }
+        if (results.hasConfigLoadErrors) {
+            process.exitCode = 2;
+            return;
+        }
         if (!args['no-exit-code'] &&
             (totalErrorCount > options.maxIssues ||
                 (!options.isDisableConfigHints &&

package/dist/compilers/compilers.js

@@ -5,7 +5,7 @@ export const styleExtractor = /<style\b((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<
 const langAttrMatcher = /\blang\s*=\s*["']([^"']+)["']/i;
 export const blockCommentMatcher = /\/\*[\s\S]*?\*\//g;
 export const lineCommentMatcher = /^[ \t]*\/\/.*$/gm;
-export const importMatcher = /import(?:\s*\(\s*['"][^'"]+['"][^)]*\)|(?!\s*\()[^'"]+['"][^'"]+['"])/g;
+export const importMatcher = /(?<![.\w$#])import\b(?:\s*\(\s*['"][^'"]+['"][^)]*\)|(?!\s*\()[^'"]+['"][^'"]+['"])/g;
 export const collectImports = text => {
     if (!text.includes('import'))
         return '';

package/dist/compilers/scss.js

@@ -1,13 +1,13 @@
 import { ensureRelative, isScopedPackage, isTildePackage, splitSpec } from './shared.js';
+import { hasUrlScheme } from '../util/url.js';
 const dependencies = ['sass', 'sass-embedded', 'node-sass'];
 const dependencyMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|\/\/[^\r\n]*(?:[\r\n]|$)|@(?:use|import|forward)\s+['"](pkg:)?([^'"]+)['"]|url\(\s*(?:["']([^"']*)["']|([^'")\s]+))\s*\)/g;
-const urlSchemeMatcher = /^[a-z][a-z\d+.-]*:/i;
 const getUrlSpecifier = (url) => {
     if (!url ||
         url.startsWith('//') ||
         url.startsWith('/') ||
         url.startsWith('#') ||
-        urlSchemeMatcher.test(url) ||
+        hasUrlScheme(url) ||
         url.includes('$') ||
         url.includes('#{'))
         return;

package/dist/graph/build.js

@@ -88,6 +88,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             dependencies,
             rootManifest,
             handleInput: (input) => handleInput(input, workspace),
+            handleConfigLoadError: () => collector.addConfigLoadError(),
             findWorkspaceByFilePath: chief.findWorkspaceByFilePath.bind(chief),
             getManifest,
             negatedWorkspacePatterns: chief.getNegatedWorkspacePatterns(name),

package/dist/graph-explorer/cache.d.ts

@@ -1,6 +1,7 @@
 import type { ModuleGraph } from '../types/module-graph.ts';
 import type { UsageResult } from './operations/get-usage.ts';
 import type { DefinitionResult } from './operations/resolve-definition.ts';
+import type { ExportTableCache } from './operations/resolve-export-origins.ts';
 export declare const invalidateCache: (graph: ModuleGraph) => void;
 export declare const getCachedDefinition: (graph: ModuleGraph, filePath: string, identifier: string) => DefinitionResult | null | undefined;
 export declare const setCachedDefinition: (graph: ModuleGraph, filePath: string, identifier: string, result: DefinitionResult | null) => void;
@@ -8,3 +9,5 @@ export declare const getCachedUsage: (graph: ModuleGraph, filePath: string, iden
 export declare const setCachedUsage: (graph: ModuleGraph, filePath: string, identifier: string, result: UsageResult) => void;
 export declare const getCachedExportedIdentifiers: (graph: ModuleGraph, filePath: string) => Map<string, boolean> | undefined;
 export declare const setCachedExportedIdentifiers: (graph: ModuleGraph, filePath: string, result: Map<string, boolean>) => void;
+export declare const getCachedExportTable: (graph: ModuleGraph, filePath: string) => ExportTableCache | undefined;
+export declare const setCachedExportTable: (graph: ModuleGraph, filePath: string, table: ExportTableCache) => void;

package/dist/graph-explorer/cache.js

@@ -4,6 +4,7 @@ const createEmptyCache = () => ({
     usage: new Map(),
     importLookup: new Map(),
     exportedIdentifiers: new Map(),
+    exportTables: new Map(),
     generation: 0,
 });
 const getCache = (graph) => {
@@ -21,6 +22,7 @@ export const invalidateCache = (graph) => {
         cache.usage.clear();
         cache.importLookup.clear();
         cache.exportedIdentifiers.clear();
+        cache.exportTables.clear();
         cache.generation++;
     }
 };
@@ -70,3 +72,7 @@ export const setCachedExportedIdentifiers = (graph, filePath, result) => {
     const cache = getCache(graph);
     cache.exportedIdentifiers.set(filePath, result);
 };
+export const getCachedExportTable = (graph, filePath) => caches.get(graph)?.exportTables.get(filePath);
+export const setCachedExportTable = (graph, filePath, table) => {
+    getCache(graph).exportTables.set(filePath, table);
+};

package/dist/graph-explorer/explorer.d.ts

@@ -10,6 +10,7 @@ export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<s
         filePath?: string;
         identifier?: string;
     }) => import("./operations/build-exports-tree.ts").ExportsTreeNode[];
+    resolveExportOrigins: (filePath: string, identifier: string) => import("./operations/resolve-export-origins.ts").ExportOriginResolution;
     getDependencyUsage: (pattern?: string | RegExp) => Map<string, import("./operations/get-dependency-usage.ts").DependencyNodes>;
     resolveDefinition: (filePath: string, identifier: string) => import("./operations/resolve-definition.ts").DefinitionResult | null;
     getUsage: (filePath: string, identifier: string) => import("./operations/get-usage.ts").UsageResult;

package/dist/graph-explorer/explorer.js

@@ -9,12 +9,14 @@ import { hasStrictlyNsReferences } from './operations/has-strictly-ns-references
 import { isEnumerated } from './operations/is-enumerated.js';
 import { isReferenced } from './operations/is-referenced.js';
 import { resolveDefinition } from './operations/resolve-definition.js';
+import { resolveExportOrigins } from './operations/resolve-export-origins.js';
 export const createGraphExplorer = (graph, entryPaths) => {
     return {
         isReferenced: (filePath, identifier, options) => isReferenced(graph, entryPaths, filePath, identifier, options),
         hasStrictlyNsReferences: (filePath, identifier) => hasStrictlyNsReferences(graph, filePath, graph.get(filePath)?.importedBy, identifier),
         isEnumerated: (filePath, identifier) => isEnumerated(graph, filePath, graph.get(filePath)?.importedBy, identifier),
         buildExportsTree: (options) => buildExportsTree(graph, entryPaths, options),
+        resolveExportOrigins: (filePath, identifier) => resolveExportOrigins(graph, filePath, identifier),
         getDependencyUsage: (pattern) => getDependencyUsage(graph, pattern),
         resolveDefinition: (filePath, identifier) => resolveDefinition(graph, filePath, identifier),
         getUsage: (filePath, identifier) => getUsage(graph, entryPaths, filePath, identifier),

package/dist/graph-explorer/operations/build-exports-tree.js

@@ -45,7 +45,8 @@ const buildExportTree = (graph, entryPaths, filePath, identifier) => {
         const key = `${importingFile}:${id}`;
         const isRenamed = via.endsWith('As') && sourceId !== ns;
         const refs = filterRefs(importRefs, id);
-        const childNode = nodeMap.get(key) ?? {
+        const existingNode = nodeMap.get(key);
+        const childNode = existingNode ?? {
             filePath: importingFile,
             identifier: id,
             originalId: isRenamed ? sourceId : undefined,
@@ -64,12 +65,23 @@ const buildExportTree = (graph, entryPaths, filePath, identifier) => {
                 }
             }
         }
-        (parentNode ?? rootNode).children.push(childNode);
+        const parent = parentNode ?? rootNode;
+        if (existingNode && reaches(existingNode, parent))
+            return CONTINUE;
+        parent.children.push(childNode);
         return CONTINUE;
     }, entryPaths);
     pruneReExportStarOnlyBranches(rootNode);
     return rootNode;
 };
+const reaches = (node, target) => {
+    if (node === target)
+        return true;
+    for (const child of node.children)
+        if (reaches(child, target))
+            return true;
+    return false;
+};
 const filterRefs = (refs, id) => {
     if (!refs)
         return [];

package/dist/graph-explorer/operations/get-ambiguous-star-export.d.ts

@@ -0,0 +1,8 @@
+import type { ExportOriginResolution } from './resolve-export-origins.ts';
+export interface AmbiguousStarExport {
+    origins: {
+        filePath: string;
+        identifier: string;
+    }[];
+}
+export declare const getAmbiguousStarExport: (resolution: ExportOriginResolution, identifier: string) => AmbiguousStarExport | undefined;

package/dist/graph-explorer/operations/get-ambiguous-star-export.js

@@ -0,0 +1,11 @@
+export const getAmbiguousStarExport = (resolution, identifier) => {
+    if (identifier === 'default')
+        return;
+    if (resolution.hasExplicitExport || resolution.origins.length < 2)
+        return;
+    const origins = [];
+    for (const origin of resolution.origins) {
+        origins.push({ filePath: origin.filePath, identifier: origin.identifier });
+    }
+    return { origins };
+};