knip 6.3.0 → 6.4.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License (ISC)
+
+Copyright 2022-2025 Lars Kappert
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/dist/ConfigurationChief.d.ts

@@ -422,6 +422,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'panda-css'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         parcel?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -865,6 +870,7 @@ export declare class ConfigurationChief {
         "openapi-ts"?: (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;
         parcel?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         payload?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         playwright?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/DependencyDeputy.js

@@ -187,12 +187,12 @@ export class DependencyDeputy {
             const referencedDependencies = this.referencedDependencies.get(workspace);
             const hasTypesIncluded = this.getHasTypesIncluded(workspace);
             const peeker = new PackagePeeker(manifestStr);
-            const peerDepCount = {};
-            const isReferencedDependency = (dependency, isPeerDep) => {
+            const isReferencedDependency = (dependency, visited = new Set()) => {
                 if (referencedDependencies?.has(dependency))
                     return true;
-                if (isPeerDep && peerDepCount[dependency])
+                if (visited.has(dependency))
                     return false;
+                visited.add(dependency);
                 const [scope, typedDependency] = dependency.split('/');
                 if (scope === DT_SCOPE) {
                     const typedPackageName = getPackageFromDefinitelyTyped(typedDependency);
@@ -205,21 +205,15 @@ export class DependencyDeputy {
                         ...this.getHostDependenciesFor(workspace, typedPackageName),
                     ];
                     if (hostDependencies.length)
-                        return !!hostDependencies.find(host => isReferencedDependency(host.name, true));
+                        return !!hostDependencies.find(host => isReferencedDependency(host.name, visited));
                     if (!referencedDependencies?.has(dependency))
                         return false;
                     return referencedDependencies.has(typedPackageName);
                 }
                 const hostDependencies = this.getHostDependenciesFor(workspace, dependency);
-                for (const { name } of hostDependencies) {
-                    if (!peerDepCount[name])
-                        peerDepCount[name] = 1;
-                    else
-                        peerDepCount[name]++;
-                }
-                return hostDependencies.some(hostDependency => (isPeerDep === false || !hostDependency.isPeerOptional) && isReferencedDependency(hostDependency.name, true));
+                return hostDependencies.some(hostDependency => isReferencedDependency(hostDependency.name, visited));
             };
-            const isNotReferencedDependency = (dependency) => !isReferencedDependency(dependency, false);
+            const isNotReferencedDependency = (dependency) => !isReferencedDependency(dependency);
             for (const symbol of this.getProductionDependencies(workspace).filter(isNotReferencedDependency)) {
                 const position = peeker.getLocation('dependencies', symbol);
                 dependencyIssues.push({ type: 'dependencies', workspace, filePath, symbol, fixes: [], ...position });

package/dist/ProjectPrincipal.d.ts

@@ -43,11 +43,11 @@ export declare class ProjectPrincipal {
     addProjectPath(filePath: string): void;
     removeProjectPath(filePath: string): void;
     runAsyncCompilers(): Promise<void>;
-    walkAndAnalyze(analyzeFile: (filePath: string, parseResult: ParseResult | undefined, sourceText: string) => Iterable<string> | undefined): void;
+    walkAndAnalyze(analyzeFile: (filePath: string, parseResult: ParseResult | undefined, sourceText: string, cachedFile?: FileNode) => Iterable<string> | undefined): void;
     getUsedResolvedFiles(): string[];
     private resolveSpecifier;
     getUnreferencedFiles(): string[];
-    analyzeSourceFile(filePath: string, options: GetImportsAndExportsOptions, ignoreExportsUsedInFile: IgnoreExportsUsedInFile, parseResult?: ParseResult, sourceText?: string): FileNode;
+    analyzeSourceFile(filePath: string, options: GetImportsAndExportsOptions, ignoreExportsUsedInFile: IgnoreExportsUsedInFile, parseResult?: ParseResult, sourceText?: string, cachedFile?: FileNode): FileNode;
     invalidateFile(filePath: string): void;
     reconcileCache(graph: ModuleGraph): void;
 }

package/dist/ProjectPrincipal.js

@@ -134,22 +134,46 @@ export class ProjectPrincipal {
         const visited = new Set([...this.entryPaths, ...this.programPaths]);
         let lastEntrySize = this.entryPaths.size;
         let lastProgramSize = this.programPaths.size;
+        const rescanFrontier = () => {
+            if (this.entryPaths.size > lastEntrySize || this.programPaths.size > lastProgramSize) {
+                for (const p of this.entryPaths)
+                    visited.add(p);
+                for (const p of this.programPaths)
+                    visited.add(p);
+                lastEntrySize = this.entryPaths.size;
+                lastProgramSize = this.programPaths.size;
+            }
+        };
         for (const filePath of visited) {
+            const isProjectPath = this.projectPaths.has(filePath);
+            let cachedFile;
+            if (isProjectPath) {
+                const fd = this.cache.getFileDescriptor(filePath);
+                if (!fd.changed && fd.meta?.data)
+                    cachedFile = fd.meta.data;
+            }
+            if (cachedFile) {
+                const internalPaths = analyzeFile(filePath, undefined, '', cachedFile);
+                if (internalPaths)
+                    for (const p of internalPaths)
+                        visited.add(p);
+                rescanFrontier();
+                continue;
+            }
             const sourceText = this.fileManager.readFile(filePath);
             if (!sourceText) {
-                if (this.projectPaths.has(filePath))
+                if (isProjectPath)
                     analyzeFile(filePath, undefined, '');
                 continue;
             }
             try {
                 const result = parseFile(filePath, sourceText);
                 this.fileManager.sourceTextCache.delete(filePath);
-                if (this.projectPaths.has(filePath)) {
+                if (isProjectPath) {
                     const internalPaths = analyzeFile(filePath, result, sourceText);
-                    if (internalPaths) {
+                    if (internalPaths)
                         for (const p of internalPaths)
                             visited.add(p);
-                    }
                 }
                 else {
                     for (const specifier of extractSpecifiers(result, sourceText, filePath)) {
@@ -158,14 +182,7 @@ export class ProjectPrincipal {
                             visited.add(resolved);
                     }
                 }
-                if (this.entryPaths.size > lastEntrySize || this.programPaths.size > lastProgramSize) {
-                    for (const p of this.entryPaths)
-                        visited.add(p);
-                    for (const p of this.programPaths)
-                        visited.add(p);
-                    lastEntrySize = this.entryPaths.size;
-                    lastProgramSize = this.programPaths.size;
-                }
+                rescanFrontier();
             }
             catch {
             }
@@ -199,7 +216,9 @@ export class ProjectPrincipal {
     getUnreferencedFiles() {
         return Array.from(this.projectPaths).filter(filePath => !this.resolvedFiles.has(filePath));
     }
-    analyzeSourceFile(filePath, options, ignoreExportsUsedInFile, parseResult, sourceText) {
+    analyzeSourceFile(filePath, options, ignoreExportsUsedInFile, parseResult, sourceText, cachedFile) {
+        if (cachedFile)
+            return cachedFile;
         const fd = this.cache.getFileDescriptor(filePath);
         if (!fd.changed && fd.meta?.data)
             return fd.meta.data;

package/dist/WorkspaceWorker.d.ts

@@ -63,7 +63,7 @@ export declare class WorkspaceWorker {
     registerVisitors(options: RegisterVisitorsOptions): void;
     runPlugins(): Promise<Input[]>;
     private filterTransitiveDependencies;
-    getConfigurationHints(type: 'entry' | 'project', patterns: string[], filePaths: string[], includedPaths: Set<string>): ConfigurationHint[];
+    getConfigurationHints(type: 'entry' | 'project', patterns: string[], filePaths: string[], includedPaths: Set<string>, compilerExtensions?: Set<string>): ConfigurationHint[];
     onDispose(): void;
 }
 export {};

package/dist/WorkspaceWorker.js

@@ -2,7 +2,7 @@ import picomatch from 'picomatch';
 import { _getInputsFromScripts } from "./binaries/index.js";
 import { CacheConsultant } from "./CacheConsultant.js";
 import { isDefaultPattern } from "./ConfigurationChief.js";
-import { ROOT_WORKSPACE_NAME } from "./constants.js";
+import { DEFAULT_EXTENSIONS, ROOT_WORKSPACE_NAME } from "./constants.js";
 import { getFilteredScripts } from "./manifest/helpers.js";
 import { PluginEntries, Plugins } from "./plugins.js";
 import { collectStringLiterals, isExternalReExportsOnly } from "./typescript/ast-helpers.js";
@@ -15,6 +15,7 @@ import { getPackageNameFromSpecifier } from "./util/modules.js";
 import { getKeysByValue } from "./util/object.js";
 import { timerify } from "./util/Performance.js";
 import { basename, dirname, isInternal, join } from "./util/path.js";
+import { extractPatternExtensions } from "./util/pattern-extensions.js";
 import { loadConfigForPlugin } from "./util/plugin.js";
 import { ELLIPSIS } from "./util/string.js";
 const nullConfig = { config: null, entry: null, project: null };
@@ -403,7 +404,7 @@ export class WorkspaceWorker {
             }
         }
     }
-    getConfigurationHints(type, patterns, filePaths, includedPaths) {
+    getConfigurationHints(type, patterns, filePaths, includedPaths, compilerExtensions) {
         const hints = [];
         const entries = this.config[type].filter(pattern => !pattern.startsWith('!'));
         const workspaceName = this.name;
@@ -429,6 +430,22 @@ export class WorkspaceWorker {
                 }
             }
         }
+        if (type === 'project' && compilerExtensions) {
+            const seen = new Set();
+            for (const pattern of userDefinedPatterns) {
+                for (const ext of extractPatternExtensions(pattern)) {
+                    if (seen.has(ext) || DEFAULT_EXTENSIONS.has(ext))
+                        continue;
+                    seen.add(ext);
+                    if (compilerExtensions.has(ext)) {
+                        hints.push({ type: 'project-extension-redundant', identifier: ext, workspaceName });
+                    }
+                    else {
+                        hints.push({ type: 'project-extension-unregistered', identifier: ext, workspaceName });
+                    }
+                }
+            }
+        }
         return hints;
     }
     onDispose() {

package/dist/compilers/index.d.ts

@@ -370,6 +370,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    'panda-css'?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     parcel?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -1086,6 +1091,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'panda-css'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         parcel?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/compilers/scss.js

@@ -1,20 +1,26 @@
-import { existsSync } from 'node:fs';
-import { basename, dirname, join } from "../util/path.js";
+import { basename, dirname } from "../util/path.js";
 const condition = (hasDependency) => hasDependency('sass') || hasDependency('sass-embedded') || hasDependency('node-sass');
 const importMatcher = /@(?:use|import|forward)\s+['"](pkg:)?([^'"]+)['"]/g;
-const resolvePartial = (specifier, containingFile) => {
-    const rel = specifier.startsWith('.') ? specifier : `./${specifier}`;
-    const name = basename(rel);
-    if (name.startsWith('_'))
-        return rel;
-    const dir = dirname(rel);
-    const partial = name.endsWith('.scss') ? `_${name}` : `_${name}.scss`;
-    if (existsSync(join(dirname(containingFile), dir, partial)))
-        return `${dir}/_${name}`;
-    return rel;
+const isAlias = (s) => (s.charCodeAt(0) === 64 && s.charCodeAt(1) === 47) || s.charCodeAt(0) === 126 || s.charCodeAt(0) === 35;
+const candidates = (specifier) => {
+    const spec = specifier.startsWith('.') || isAlias(specifier) ? specifier : `./${specifier}`;
+    const name = basename(spec);
+    const dir = dirname(spec);
+    const base = name.endsWith('.scss') || name.endsWith('.sass') ? name : `${name}.scss`;
+    const plain = `${dir}/${base}`;
+    return name.startsWith('_') ? [plain] : [plain, `${dir}/_${base}`];
+};
+const compiler = text => {
+    const out = [];
+    let i = 0;
+    for (const match of text.matchAll(importMatcher)) {
+        const spec = match[2];
+        if (!spec || spec.startsWith('sass:'))
+            continue;
+        const specs = match[1] ? [spec] : candidates(spec);
+        for (const s of specs)
+            out.push(`import _$${i++} from '${s}';`);
+    }
+    return out.join('\n');
 };
-const compiler = (text, filePath) => [...text.matchAll(importMatcher)]
-    .filter(match => match[2] && !match[2].startsWith('sass:'))
-    .map((match, i) => `import _$${i} from '${match[1] ? match[2] : resolvePartial(match[2], filePath)}';`)
-    .join('\n');
 export default { condition, compiler };

package/dist/graph/analyze.js

@@ -81,6 +81,8 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                     exportedItem.members.length > 0 &&
                                     exportedItem.type !== 'enum';
                                 if ((isEnumMembers || isNsMembers) && exportedItem.members.length > 0) {
+                                    if (importsForExport.enumerated?.has(identifier))
+                                        continue;
                                     if (!options.includedIssueTypes.nsTypes && importsForExport.refs.has(identifier))
                                         continue;
                                     if (isEnumMembers && hasStrictlyEnumReferences(importsForExport, identifier))

package/dist/graph/build.d.ts

@@ -4,7 +4,7 @@ import type { ConsoleStreamer } from '../ConsoleStreamer.ts';
 import type { DependencyDeputy } from '../DependencyDeputy.ts';
 import type { IssueCollector } from '../IssueCollector.ts';
 import type { ProjectPrincipal } from '../ProjectPrincipal.ts';
-import type { ModuleGraph } from '../types/module-graph.ts';
+import type { FileNode, ModuleGraph } from '../types/module-graph.ts';
 import type { MainOptions } from '../util/create-options.ts';
 interface BuildOptions {
     chief: ConfigurationChief;
@@ -22,7 +22,7 @@ export declare function build({ chief, collector, counselor, deputy, principal,
     entryPaths: Set<string>;
     analyzedFiles: Set<string>;
     unreferencedFiles: Set<string>;
-    analyzeSourceFile: (filePath: string, pp: ProjectPrincipal, parseResult?: import("oxc-parser").ParseResult, sourceText?: string) => void;
+    analyzeSourceFile: (filePath: string, pp: ProjectPrincipal, parseResult?: import("oxc-parser").ParseResult, sourceText?: string, cachedFile?: FileNode) => void;
     enabledPluginsStore: Map<string, string[]>;
 }>;
 export {};

package/dist/graph/build.js

@@ -250,7 +250,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 ]);
             const projectPaths = await _glob({ ...sharedGlobOptions, patterns, label: 'project paths' });
             if (!options.isProduction) {
-                const hints = worker.getConfigurationHints('project', config.project, projectPaths, principal.projectPaths);
+                const hints = worker.getConfigurationHints('project', config.project, projectPaths, principal.projectPaths, new Set(extensions));
                 for (const hint of hints)
                     collector.addConfigurationHint(hint);
             }
@@ -273,13 +273,13 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         skipTypeOnly: options.isStrict,
         tags: options.tags,
     };
-    const analyzeSourceFile = (filePath, pp, parseResult, sourceText) => {
+    const analyzeSourceFile = (filePath, pp, parseResult, sourceText, cachedFile) => {
         if (!options.isWatch && !options.isSession && analyzedFiles.has(filePath))
             return;
         analyzedFiles.add(filePath);
         const workspace = chief.findWorkspaceByFilePath(filePath);
         if (workspace) {
-            const file = pp.analyzeSourceFile(filePath, analyzeOpts, chief.config.ignoreExportsUsedInFile, parseResult, sourceText);
+            const file = pp.analyzeSourceFile(filePath, analyzeOpts, chief.config.ignoreExportsUsedInFile, parseResult, sourceText, cachedFile);
             const unresolvedImports = new Set();
             for (const unresolvedImport of file.imports.unresolved) {
                 const { specifier } = unresolvedImport;
@@ -370,8 +370,8 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         await principal.runAsyncCompilers();
     }
     streamer.cast('Analyzing source files');
-    principal.walkAndAnalyze((filePath, parseResult, sourceText) => {
-        analyzeSourceFile(filePath, principal, parseResult, sourceText);
+    principal.walkAndAnalyze((filePath, parseResult, sourceText, cachedFile) => {
+        analyzeSourceFile(filePath, principal, parseResult, sourceText, cachedFile);
         const node = graph.get(filePath);
         if (!node)
             return;

package/dist/plugins/index.d.ts

@@ -77,6 +77,7 @@ export declare const Plugins: {
     'openapi-ts': import("../types/config.ts").Plugin;
     oxfmt: import("../types/config.ts").Plugin;
     oxlint: import("../types/config.ts").Plugin;
+    'panda-css': import("../types/config.ts").Plugin;
     parcel: import("../types/config.ts").Plugin;
     payload: import("../types/config.ts").Plugin;
     playwright: import("../types/config.ts").Plugin;

package/dist/plugins/index.js

@@ -71,6 +71,7 @@ import { default as oclif } from "./oclif/index.js";
 import { default as openapiTs } from "./openapi-ts/index.js";
 import { default as oxfmt } from "./oxfmt/index.js";
 import { default as oxlint } from "./oxlint/index.js";
+import { default as pandaCss } from "./panda-css/index.js";
 import { default as parcel } from "./parcel/index.js";
 import { default as payload } from "./payload/index.js";
 import { default as playwright } from "./playwright/index.js";
@@ -215,6 +216,7 @@ export const Plugins = {
     'openapi-ts': openapiTs,
     oxfmt,
     oxlint,
+    'panda-css': pandaCss,
     parcel,
     payload,
     playwright,

package/dist/plugins/panda-css/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/panda-css/index.js

@@ -0,0 +1,18 @@
+import { toDeferResolve, toDependency } from "../../util/input.js";
+import { hasDependency } from "../../util/plugin.js";
+const title = 'Panda CSS';
+const enablers = ['@pandacss/dev'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['panda.config.{ts,js,mjs,cjs,mts,cts}'];
+const resolveConfig = config => {
+    const presets = (config.presets ?? []).filter((preset) => typeof preset === 'string');
+    return [...presets.map(id => toDeferResolve(id)), toDependency('postcss')];
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    resolveConfig,
+};
+export default plugin;

package/dist/plugins/panda-css/types.d.ts

@@ -0,0 +1,3 @@
+export type PandaCSSConfig = {
+    presets?: (string | Record<string, unknown>)[];
+};

package/dist/plugins/panda-css/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/react-router/index.js

@@ -26,7 +26,7 @@ const resolveConfig = async (localConfig, options) => {
         routeConfig = await load(routesPathJs);
     }
     const mapRoute = (route) => {
-        return [join(appDir, route.file), ...(route.children ? route.children.flatMap(mapRoute) : [])];
+        return [toAbsolute(route.file, appDir), ...(route.children ? route.children.flatMap(mapRoute) : [])];
     };
     const routes = routeConfig
         .flatMap(mapRoute)

package/dist/plugins/tailwind/index.js

@@ -1,11 +1,11 @@
 import { hasDependency } from "../../util/plugin.js";
 import compiler from "./compiler.js";
 const title = 'Tailwind';
-const enablers = ['tailwindcss'];
+const enablers = ['tailwindcss', '@tailwindcss/vite', '@tailwindcss/postcss', '@tailwindcss/cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const entry = ['tailwind.config.{js,cjs,mjs,ts}'];
 const registerCompilers = ({ registerCompiler, hasDependency }) => {
-    if (hasDependency('tailwindcss'))
+    if (enablers.some(enabler => hasDependency(enabler)))
         registerCompiler({ extension: '.css', compiler });
 };
 const plugin = {

package/dist/plugins/webpack/index.js

@@ -13,6 +13,11 @@ const hasBabelOptions = (use) => Boolean(use) &&
     typeof use.loader === 'string' &&
     use.loader === 'babel-loader' &&
     typeof use.options === 'object';
+const hasLoaderOptions = (use) => Boolean(use) &&
+    typeof use !== 'string' &&
+    'loader' in use &&
+    typeof use.loader === 'string' &&
+    typeof use.options === 'object';
 const info = {
     compiler: '',
     issuer: '',
@@ -47,13 +52,28 @@ const resolveRuleSetDependencies = (rule) => {
         return resolveUseItem(item);
     });
 };
+const isSwcLoader = (loader) => loader === 'builtin:swc-loader' || loader.endsWith('/swc-loader') || loader === 'swc-loader';
+const resolveSwcPluginDependencies = (use) => {
+    if (!hasLoaderOptions(use) || !isSwcLoader(use.loader))
+        return [];
+    const plugins = use.options.jsc?.experimental?.plugins;
+    if (!Array.isArray(plugins))
+        return [];
+    return plugins.flatMap(plugin => {
+        if (typeof plugin === 'string')
+            return [plugin];
+        if (Array.isArray(plugin) && typeof plugin[0] === 'string')
+            return [plugin[0]];
+        return [];
+    });
+};
 const resolveUseItem = (use) => {
     if (!use)
         return [];
     if (typeof use === 'string')
         return [use];
     if ('loader' in use && typeof use.loader === 'string')
-        return [use.loader];
+        return [use.loader, ...resolveSwcPluginDependencies(use)];
     return [];
 };
 export const findWebpackDependenciesFromConfig = async (config, options) => {

package/dist/reporters/util/configuration-hints.js

@@ -39,6 +39,8 @@ const addWorkspace = (options) => options.configFilePath
     ? `Add ${bright('entry')} and/or refine ${bright('project')} files in ${bright(`workspaces["${options.workspaceName}"]`)} (${options.size} unused files)`
     : `Create ${bright('knip.json')} configuration file with ${bright(`workspaces["${options.workspaceName}"]`)} object (${options.size} unused files)`;
 const packageEntry = () => 'Package entry file not found';
+const extensionUnregistered = () => `Extension in ${bright('project')} not registered as a compiler — see https://knip.dev/features/compilers#tracking-non-source-files`;
+const extensionRedundant = () => `Extension already registered as a compiler — remove from ${bright('project')} pattern`;
 const hintPrinters = new Map([
     ['ignore', { print: unused }],
     ['ignoreFiles', { print: unused }],
@@ -48,6 +50,8 @@ const hintPrinters = new Map([
     ['ignoreWorkspaces', { print: unused }],
     ['entry-empty', { print: empty }],
     ['project-empty', { print: empty }],
+    ['project-extension-unregistered', { print: extensionUnregistered }],
+    ['project-extension-redundant', { print: extensionRedundant }],
     ['entry-redundant', { print: remove }],
     ['project-redundant', { print: remove }],
     ['top-level-unconfigured', { print: add }],
@@ -66,6 +70,7 @@ const hintTypesOrder = [
     ['ignoreBinaries'],
     ['ignoreUnresolved'],
     ['entry-empty', 'project-empty', 'entry-redundant', 'project-redundant'],
+    ['project-extension-unregistered', 'project-extension-redundant'],
     ['package-entry'],
 ];
 export const finalizeConfigurationHints = (results, options) => {

package/dist/run.js

@@ -9,12 +9,15 @@ import { IssueCollector } from "./IssueCollector.js";
 import { ProjectPrincipal } from "./ProjectPrincipal.js";
 import watchReporter from "./reporters/watch.js";
 import { debugLogObject } from "./util/debug.js";
+import { flushGlobCache, initGlobCache } from "./util/glob-cache.js";
 import { getGitIgnoredHandler } from "./util/glob-core.js";
 import { getModuleSourcePathHandler } from "./util/to-source-path.js";
 import { getSessionHandler } from "./util/watch.js";
 export const run = async (options) => {
     debugLogObject('*', 'Unresolved configuration', options);
     debugLogObject('*', 'Included issue types', options.includedIssueTypes);
+    if (options.isCache)
+        initGlobCache(options.cacheLocation);
     const chief = new ConfigurationChief(options);
     const deputy = new DependencyDeputy(options);
     const streamer = new ConsoleStreamer(options);
@@ -79,6 +82,8 @@ export const run = async (options) => {
     const { issues, counters, tagHints, configurationHints } = collector.getIssues();
     if (!options.isWatch)
         streamer.clear();
+    if (options.isCache)
+        flushGlobCache();
     return {
         results: {
             issues,

package/dist/schema/configuration.d.ts

@@ -367,6 +367,11 @@ export declare const workspaceConfigurationSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>>;
+    'panda-css': z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>>;
     parcel: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -1094,6 +1099,11 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>>;
+    'panda-css': z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>>;
     parcel: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -1810,6 +1820,11 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
             entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
             project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         }, z.core.$strip>]>>;
+        'panda-css': z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+            config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+            entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+            project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        }, z.core.$strip>]>>;
         parcel: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
             config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
             entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;

package/dist/schema/plugins.d.ts

@@ -371,6 +371,11 @@ export declare const pluginsSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>;
+    'panda-css': z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>;
     parcel: z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;

package/dist/schema/plugins.js

@@ -83,6 +83,7 @@ export const pluginsSchema = z.object({
     'openapi-ts': pluginSchema,
     oxfmt: pluginSchema,
     oxlint: pluginSchema,
+    'panda-css': pluginSchema,
     parcel: pluginSchema,
     payload: pluginSchema,
     playwright: pluginSchema,