knip 6.35.1 → 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/WorkspaceWorker.js

@@ -259,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) => {
@@ -299,6 +300,7 @@ export class WorkspaceWorker {
                 configFilePath: containingFilePath,
                 configFileDir: cwd,
                 configFileName: '',
+                isResolvedConfigFile: isResolvedConfigFiles,
                 getInputsFromScripts: createGetInputsFromScripts(containingFilePath),
             };
             if (config.entry) {
@@ -411,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/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-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 };
+};