knip 5.47.0 → 5.49.0

package/dist/schema/plugins.d.ts

@@ -872,6 +872,32 @@ export declare const pluginsSchema: z.ZodObject<{
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     }>]>;
+    sst: z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
+        config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        project: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    }, "strip", z.ZodTypeAny, {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    }, {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    }>]>;
+    starlight: z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
+        config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        project: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    }, "strip", z.ZodTypeAny, {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    }, {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    }>]>;
     storybook: z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
         config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
         entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
@@ -950,6 +976,19 @@ export declare const pluginsSchema: z.ZodObject<{
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     }>]>;
+    'tanstack-router': z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
+        config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        project: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    }, "strip", z.ZodTypeAny, {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    }, {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    }>]>;
     travis: z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
         config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
         entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
@@ -1541,6 +1580,16 @@ export declare const pluginsSchema: z.ZodObject<{
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     };
+    sst: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    };
+    starlight: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    };
     storybook: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -1571,6 +1620,11 @@ export declare const pluginsSchema: z.ZodObject<{
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     };
+    'tanstack-router': string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    };
     travis: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -2002,6 +2056,16 @@ export declare const pluginsSchema: z.ZodObject<{
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     };
+    sst: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    };
+    starlight: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    };
     storybook: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -2032,6 +2096,11 @@ export declare const pluginsSchema: z.ZodObject<{
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     };
+    'tanstack-router': string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    };
     travis: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;

package/dist/schema/plugins.js

@@ -76,12 +76,15 @@ export const pluginsSchema = z.object({
     sentry: pluginSchema,
     'simple-git-hooks': pluginSchema,
     'size-limit': pluginSchema,
+    sst: pluginSchema,
+    starlight: pluginSchema,
     storybook: pluginSchema,
     stryker: pluginSchema,
     stylelint: pluginSchema,
     svelte: pluginSchema,
     syncpack: pluginSchema,
     tailwind: pluginSchema,
+    'tanstack-router': pluginSchema,
     travis: pluginSchema,
     'ts-node': pluginSchema,
     tsup: pluginSchema,

package/dist/types/PluginNames.d.ts

@@ -1,2 +1,2 @@
-export type PluginName = 'angular' | 'astro' | 'ava' | 'babel' | 'c8' | 'capacitor' | 'changesets' | 'commitizen' | 'commitlint' | 'cspell' | 'cucumber' | 'cypress' | 'dependency-cruiser' | 'dotenv' | 'drizzle' | 'eleventy' | 'eslint' | 'expo' | 'gatsby' | 'github-action' | 'github-actions' | 'glob' | 'graphql-codegen' | 'husky' | 'jest' | 'karma' | 'ladle' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lockfile-lint' | 'lost-pixel' | 'markdownlint' | 'metro' | 'mocha' | 'moonrepo' | 'msw' | 'nest' | 'netlify' | 'next' | 'node' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nx' | 'nyc' | 'oclif' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'postcss' | 'preconstruct' | 'prettier' | 'react-cosmos' | 'react-router' | 'release-it' | 'remark' | 'remix' | 'rollup' | 'rsbuild' | 'rspack' | 'semantic-release' | 'sentry' | 'simple-git-hooks' | 'size-limit' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'syncpack' | 'tailwind' | 'travis' | 'ts-node' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'vercel-og' | 'vike' | 'vite' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'xo' | 'yarn' | 'yorkie';
-export declare const pluginNames: readonly ["angular", "astro", "ava", "babel", "c8", "capacitor", "changesets", "commitizen", "commitlint", "cspell", "cucumber", "cypress", "dependency-cruiser", "dotenv", "drizzle", "eleventy", "eslint", "expo", "gatsby", "github-action", "github-actions", "glob", "graphql-codegen", "husky", "jest", "karma", "ladle", "lefthook", "lint-staged", "linthtml", "lockfile-lint", "lost-pixel", "markdownlint", "metro", "mocha", "moonrepo", "msw", "nest", "netlify", "next", "node", "nodemon", "npm-package-json-lint", "nuxt", "nx", "nyc", "oclif", "playwright", "playwright-ct", "playwright-test", "plop", "postcss", "preconstruct", "prettier", "react-cosmos", "react-router", "release-it", "remark", "remix", "rollup", "rsbuild", "rspack", "semantic-release", "sentry", "simple-git-hooks", "size-limit", "storybook", "stryker", "stylelint", "svelte", "syncpack", "tailwind", "travis", "ts-node", "tsup", "tsx", "typedoc", "typescript", "unbuild", "unocss", "vercel-og", "vike", "vite", "vitest", "vue", "webdriver-io", "webpack", "wireit", "wrangler", "xo", "yarn", "yorkie"];
+export type PluginName = 'angular' | 'astro' | 'ava' | 'babel' | 'c8' | 'capacitor' | 'changesets' | 'commitizen' | 'commitlint' | 'cspell' | 'cucumber' | 'cypress' | 'dependency-cruiser' | 'dotenv' | 'drizzle' | 'eleventy' | 'eslint' | 'expo' | 'gatsby' | 'github-action' | 'github-actions' | 'glob' | 'graphql-codegen' | 'husky' | 'jest' | 'karma' | 'ladle' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lockfile-lint' | 'lost-pixel' | 'markdownlint' | 'metro' | 'mocha' | 'moonrepo' | 'msw' | 'nest' | 'netlify' | 'next' | 'node' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nx' | 'nyc' | 'oclif' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'postcss' | 'preconstruct' | 'prettier' | 'react-cosmos' | 'react-router' | 'release-it' | 'remark' | 'remix' | 'rollup' | 'rsbuild' | 'rspack' | 'semantic-release' | 'sentry' | 'simple-git-hooks' | 'size-limit' | 'sst' | 'starlight' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'syncpack' | 'tailwind' | 'tanstack-router' | 'travis' | 'ts-node' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'vercel-og' | 'vike' | 'vite' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'xo' | 'yarn' | 'yorkie';
+export declare const pluginNames: readonly ["angular", "astro", "ava", "babel", "c8", "capacitor", "changesets", "commitizen", "commitlint", "cspell", "cucumber", "cypress", "dependency-cruiser", "dotenv", "drizzle", "eleventy", "eslint", "expo", "gatsby", "github-action", "github-actions", "glob", "graphql-codegen", "husky", "jest", "karma", "ladle", "lefthook", "lint-staged", "linthtml", "lockfile-lint", "lost-pixel", "markdownlint", "metro", "mocha", "moonrepo", "msw", "nest", "netlify", "next", "node", "nodemon", "npm-package-json-lint", "nuxt", "nx", "nyc", "oclif", "playwright", "playwright-ct", "playwright-test", "plop", "postcss", "preconstruct", "prettier", "react-cosmos", "react-router", "release-it", "remark", "remix", "rollup", "rsbuild", "rspack", "semantic-release", "sentry", "simple-git-hooks", "size-limit", "sst", "starlight", "storybook", "stryker", "stylelint", "svelte", "syncpack", "tailwind", "tanstack-router", "travis", "ts-node", "tsup", "tsx", "typedoc", "typescript", "unbuild", "unocss", "vercel-og", "vike", "vite", "vitest", "vue", "webdriver-io", "webpack", "wireit", "wrangler", "xo", "yarn", "yorkie"];

package/dist/types/PluginNames.js

@@ -65,12 +65,15 @@ export const pluginNames = [
     'sentry',
     'simple-git-hooks',
     'size-limit',
+    'sst',
+    'starlight',
     'storybook',
     'stryker',
     'stylelint',
     'svelte',
     'syncpack',
     'tailwind',
+    'tanstack-router',
     'travis',
     'ts-node',
     'tsup',

package/dist/types/config.d.ts

@@ -1,3 +1,4 @@
+import type ts from 'typescript';
 import type { z } from 'zod';
 import type { AsyncCompilers, SyncCompilers } from '../compilers/types.js';
 import type { knipConfigurationSchema } from '../schema/configuration.js';
@@ -91,6 +92,12 @@ export interface PluginOptions extends BaseOptions {
 export type ResolveEntryPaths<T = any> = (config: T, options: PluginOptions) => Promise<Input[]> | Input[];
 export type ResolveConfig<T = any> = (config: T, options: PluginOptions) => Promise<Input[]> | Input[];
 export type Resolve = (options: PluginOptions) => Promise<Input[]> | Input[];
+export type GetSourceFile = (filePath: string) => ts.SourceFile | undefined;
+export type GetReferencedInternalFilePath = (input: Input) => string | undefined;
+export type ResolveFromAST = (sourceFile: ts.SourceFile, options: PluginOptions & {
+    getSourceFile: GetSourceFile;
+    getReferencedInternalFilePath: GetReferencedInternalFilePath;
+}) => Input[];
 export interface Plugin {
     title: string;
     args?: Args;
@@ -105,6 +112,7 @@ export interface Plugin {
     resolveEntryPaths?: ResolveEntryPaths;
     resolveConfig?: ResolveConfig;
     resolve?: Resolve;
+    resolveFromAST?: ResolveFromAST;
 }
 export type PluginMap = Record<PluginName, Plugin>;
 export type Entries = [PluginName, Plugin][];

package/dist/typescript/ast-helpers.d.ts

@@ -32,3 +32,7 @@ export declare const getExportKeywordNode: (node: ts.Node) => ts.ExportKeyword |
 export declare const getDefaultKeywordNode: (node: ts.Node) => ts.DefaultKeyword | undefined;
 export declare const hasRequireCall: (node: ts.Node) => boolean;
 export declare const isModuleExportsAccess: (node: ts.PropertyAccessExpression) => boolean;
+export declare const getImportMap: (sourceFile: ts.SourceFile) => Map<string, string>;
+export declare const getDefaultImportName: (importMap: ReturnType<typeof getImportMap>, specifier: string) => string | undefined;
+export declare const getPropertyValues: (node: ts.ObjectLiteralExpression, propertyName: string) => Set<string>;
+export declare const getPropertyValueEntries: (node: ts.ObjectLiteralExpression, propertyNames: Set<string>) => [string, string][];

package/dist/typescript/ast-helpers.js

@@ -197,3 +197,65 @@ export const hasRequireCall = (node) => {
     return node.getChildren().some(child => hasRequireCall(child));
 };
 export const isModuleExportsAccess = (node) => ts.isIdentifier(node.expression) && node.expression.escapedText === 'module' && node.name.escapedText === 'exports';
+export const getImportMap = (sourceFile) => {
+    const importMap = new Map();
+    for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement)) {
+            const importClause = statement.importClause;
+            const importPath = stripQuotes(statement.moduleSpecifier.getText());
+            if (importClause?.name)
+                importMap.set(importClause.name.text, importPath);
+            if (importClause?.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
+                for (const element of importClause.namedBindings.elements)
+                    importMap.set(element.name.text, importPath);
+            }
+        }
+    }
+    return importMap;
+};
+export const getDefaultImportName = (importMap, specifier) => {
+    for (const [importName, importSpecifier] of importMap) {
+        if (importSpecifier === specifier)
+            return importName;
+    }
+};
+export const getPropertyValues = (node, propertyName) => {
+    const values = new Set();
+    if (ts.isObjectLiteralExpression(node)) {
+        const props = node.properties.find(prop => ts.isPropertyAssignment(prop) && prop.name.getText() === propertyName);
+        if (props && ts.isPropertyAssignment(props)) {
+            const initializer = props.initializer;
+            if (ts.isStringLiteral(initializer)) {
+                values.add(initializer.text);
+            }
+            else if (ts.isArrayLiteralExpression(initializer)) {
+                for (const element of initializer.elements) {
+                    if (ts.isStringLiteral(element))
+                        values.add(element.text);
+                }
+            }
+            else if (ts.isObjectLiteralExpression(initializer)) {
+                for (const prop of initializer.properties) {
+                    if (ts.isPropertyAssignment(prop)) {
+                        if (ts.isStringLiteral(prop.initializer))
+                            values.add(prop.initializer.text);
+                    }
+                }
+            }
+        }
+    }
+    return values;
+};
+export const getPropertyValueEntries = (node, propertyNames) => {
+    const entries = [];
+    for (const prop of node.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+            if (propertyNames.has(prop.name.text)) {
+                if (ts.isStringLiteral(prop.initializer)) {
+                    entries.push([prop.name.text, prop.initializer.text]);
+                }
+            }
+        }
+    }
+    return entries;
+};

package/dist/typescript/create-hosts.d.ts

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import type { AsyncCompilers, SyncCompilers } from '../compilers/types.js';
 import type { ToSourceFilePath } from '../util/to-source-path.js';
-import { SourceFileManager } from './SourceFileManager.js';
+import type { SourceFileManager } from './SourceFileManager.js';
 type CreateHostsOptions = {
     cwd: string;
     compilerOptions: ts.CompilerOptions;
@@ -10,8 +10,9 @@ type CreateHostsOptions = {
     isSkipLibs: boolean;
     toSourceFilePath: ToSourceFilePath;
     useResolverCache: boolean;
+    fileManager: SourceFileManager;
 };
-export declare const createHosts: ({ cwd, compilerOptions, entryPaths, compilers, isSkipLibs, toSourceFilePath, useResolverCache, }: CreateHostsOptions) => {
+export declare const createHosts: ({ cwd, compilerOptions, fileManager, entryPaths, compilers, isSkipLibs, toSourceFilePath, useResolverCache, }: CreateHostsOptions) => {
     fileManager: SourceFileManager;
     compilerHost: ts.CompilerHost;
     resolveModuleNames: (moduleNames: string[], containingFile: string) => Array<ts.ResolvedModuleFull | undefined>;

package/dist/typescript/create-hosts.js

@@ -2,11 +2,9 @@ import { EOL } from 'node:os';
 import path from 'node:path';
 import ts from 'typescript';
 import { getCompilerExtensions } from '../compilers/index.js';
-import { SourceFileManager } from './SourceFileManager.js';
 import { createCustomModuleResolver } from './resolve-module-names.js';
 const libLocation = path.dirname(ts.getDefaultLibFilePath({}));
-export const createHosts = ({ cwd, compilerOptions, entryPaths, compilers, isSkipLibs, toSourceFilePath, useResolverCache, }) => {
-    const fileManager = new SourceFileManager({ compilers, isSkipLibs });
+export const createHosts = ({ cwd, compilerOptions, fileManager, entryPaths, compilers, isSkipLibs, toSourceFilePath, useResolverCache, }) => {
     const compilerExtensions = getCompilerExtensions(compilers);
     const resolveModuleNames = createCustomModuleResolver(compilerOptions, compilerExtensions, toSourceFilePath, useResolverCache, isSkipLibs);
     const languageServiceHost = {

package/dist/util/Performance.js

@@ -3,9 +3,9 @@ import { constants } from 'node:perf_hooks';
 import { memoryUsage } from 'node:process';
 import EasyTable from 'easy-table';
 import prettyMilliseconds from 'pretty-ms';
-import Summary from 'summary';
 import parsedArgValues from './cli-arguments.js';
 import { debugLog } from './debug.js';
+import { getStats } from './math.js';
 const { performance: isEnabled = false } = parsedArgValues;
 export const timerify = (fn, name = fn.name) => {
     if (!isEnabled)
@@ -71,13 +71,13 @@ class Performance {
         const entriesByName = this.getEntriesByName();
         const table = new EasyTable();
         for (const [name, values] of Object.entries(entriesByName)) {
-            const stats = new Summary(values);
+            const stats = getStats(values);
             table.cell('Name', name);
-            table.cell('size', stats.size(), EasyTable.number(0));
-            table.cell('min', stats.min(), EasyTable.number(2));
-            table.cell('max', stats.max(), EasyTable.number(2));
-            table.cell('median', stats.median(), EasyTable.number(2));
-            table.cell('sum', stats.sum(), EasyTable.number(2));
+            table.cell('size', values.length, EasyTable.number(0));
+            table.cell('min', stats.min, EasyTable.number(2));
+            table.cell('max', stats.max, EasyTable.number(2));
+            table.cell('median', stats.median, EasyTable.number(2));
+            table.cell('sum', stats.sum, EasyTable.number(2));
             table.newRow();
         }
         table.sort(['sum|des']);

package/dist/util/codeowners.d.ts

@@ -0,0 +1,2 @@
+export declare function parseCodeowners(content: string): (filePath: string) => string[];
+export declare function createOwnershipEngine(filePath: string): (filePath: string) => string[];

package/dist/util/codeowners.js

@@ -0,0 +1,32 @@
+import { readFileSync } from 'node:fs';
+import picomatch from 'picomatch';
+import { debugLog } from './debug.js';
+import { convertGitignoreToPicomatchIgnorePatterns } from './glob-core.js';
+export function parseCodeowners(content) {
+    const matchers = content
+        .split(/\r?\n/)
+        .filter(line => line && !line.startsWith('#'))
+        .map(rule => {
+        const [path, ...owners] = rule.split(/\s+/);
+        const { patterns } = convertGitignoreToPicomatchIgnorePatterns(path);
+        return { owners, match: picomatch(patterns) };
+    });
+    return (filePath) => {
+        for (const matcher of [...matchers].reverse()) {
+            if (matcher.match(filePath)) {
+                return matcher.owners;
+            }
+        }
+        return [];
+    };
+}
+export function createOwnershipEngine(filePath) {
+    try {
+        const content = readFileSync(filePath, 'utf8');
+        return parseCodeowners(content);
+    }
+    catch (error) {
+        debugLog('*', `Failed to load codeowners file from ${filePath}`);
+        throw error;
+    }
+}

package/dist/util/errors.d.ts

@@ -7,7 +7,7 @@ export declare class ConfigurationError extends Error {
 export declare class LoaderError extends Error {
 }
 export declare const isKnownError: (error: Error) => error is ConfigurationError | LoaderError | ZodError<any>;
-export declare const hasCause: (error: Error) => error is ErrorWithCause;
+export declare const isDisplayReason: (error: Error) => error is ErrorWithCause;
 export declare const isConfigurationError: (error: Error) => error is ConfigurationError;
 export declare const getKnownError: (error: Error) => Error;
 export {};

package/dist/util/errors.js

@@ -1,11 +1,11 @@
 import { ZodError } from 'zod';
-import { fromZodError } from 'zod-validation-error';
+import { fromZodError, isValidationError } from 'zod-validation-error';
 export class ConfigurationError extends Error {
 }
 export class LoaderError extends Error {
 }
 export const isKnownError = (error) => error instanceof ConfigurationError || error instanceof LoaderError || error instanceof ZodError;
-export const hasCause = (error) => error.cause instanceof Error;
+export const isDisplayReason = (error) => !isValidationError(error) && error.cause instanceof Error;
 export const isConfigurationError = (error) => error instanceof ConfigurationError;
 export const getKnownError = (error) => {
     if (error instanceof ZodError)

package/dist/util/glob-core.js

@@ -187,7 +187,7 @@ export async function glob(patterns, options) {
     const ignore = cachedIgnores || compact(_ignore);
     const { dir, label, ...fgOptions } = { ...options, ignore };
     const paths = await fg.glob(patterns, fgOptions);
-    debugLogObject(relative(options.cwd, dir) || ROOT_WORKSPACE_NAME, label ? `Finding ${label} paths` : 'Finding paths', () => ({ patterns, ...fgOptions, ignore: cachedIgnores ? `// identical to ${dir}` : ignore, paths }));
+    debugLogObject(relative(options.cwd, dir) || ROOT_WORKSPACE_NAME, label ? `Finding ${label}` : 'Finding paths', () => ({ patterns, ...fgOptions, ignore: cachedIgnores ? `// identical to ${dir}` : ignore, paths }));
     if (willCache)
         cachedGlobIgnores.set(options.dir, ignore);
     return paths;

package/dist/util/input.d.ts

@@ -7,6 +7,7 @@ export interface Input {
     optional?: boolean;
     dir?: string;
     containingFilePath?: string;
+    skipExportsAnalysis?: string;
 }
 export interface ConfigInput extends Input {
     type: 'config';

package/dist/util/math.d.ts

@@ -0,0 +1,6 @@
+export declare function getStats(values: number[]): {
+    min: number;
+    max: number;
+    sum: number;
+    median: number;
+};

package/dist/util/math.js

@@ -0,0 +1,11 @@
+export function getStats(values) {
+    if (values.length === 0)
+        return { min: 0, max: 0, sum: 0, median: 0 };
+    const sorted = values.toSorted((a, b) => a - b);
+    const min = sorted[0];
+    const max = sorted[sorted.length - 1];
+    const sum = sorted.reduce((a, b) => a + b, 0);
+    const mid = Math.floor(sorted.length / 2);
+    const median = sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+    return { min, max, sum, median };
+}

package/dist/util/object.d.ts

@@ -1,5 +1,4 @@
 export declare const getValuesByKeyDeep: (obj: any, key: string) => unknown[];
 export declare const findByKeyDeep: <T>(obj: any, key: string) => T[];
-export declare const getStringValues: (obj: any) => string[];
 export declare const getKeysByValue: <T>(obj: T, value: unknown) => (keyof T)[];
 export declare const get: <T>(obj: T, path: string) => any;

package/dist/util/object.js

@@ -32,22 +32,6 @@ export const findByKeyDeep = (obj, key) => {
     }
     return objects;
 };
-export const getStringValues = (obj) => {
-    if (typeof obj === 'string')
-        return [obj];
-    let values = [];
-    for (const prop in obj) {
-        if (obj[prop]) {
-            if (typeof obj[prop] === 'string') {
-                values.push(obj[prop]);
-            }
-            else if (typeof obj[prop] === 'object') {
-                values = values.concat(getStringValues(obj[prop]));
-            }
-        }
-    }
-    return values;
-};
 export const getKeysByValue = (obj, value) => {
     const keys = [];
     for (const key in obj) {

package/dist/util/package-json.d.ts

@@ -7,10 +7,8 @@ interface ExtendedPackageJson extends PackageJson {
 }
 export declare const load: (filePath: string) => Promise<ExtendedPackageJson>;
 export declare const save: (filePath: string, content: ExtendedPackageJson) => Promise<void>;
-export declare const getEntryPathsFromManifest: (manifest: PackageJson, sharedGlobOptions: {
+export declare const getEntryPathsFromManifest: (manifest: PackageJson, options: {
     cwd: string;
-    dir: string;
-    gitignore: boolean;
     ignore: string[];
 }) => Promise<string[]>;
 export {};

package/dist/util/package-json.js

@@ -1,6 +1,5 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import { _glob } from './glob.js';
-import { getStringValues } from './object.js';
 const INDENT = Symbol.for('indent');
 const NEWLINE = Symbol.for('newline');
 const DEFAULT_NEWLINE = '\n';
@@ -19,6 +18,23 @@ const parseJson = (raw) => {
     }
     return result;
 };
+const getEntriesFromExports = (obj) => {
+    if (typeof obj === 'string')
+        return [obj];
+    let values = [];
+    for (const prop in obj) {
+        if (typeof obj[prop] === 'string') {
+            values.push(obj[prop]);
+        }
+        else if (obj[prop] === null) {
+            values.push(`!${prop}`);
+        }
+        else if (typeof obj[prop] === 'object') {
+            values = values.concat(getEntriesFromExports(obj[prop]));
+        }
+    }
+    return values;
+};
 export const load = async (filePath) => {
     const file = await readFile(filePath, 'utf8');
     return parseJson(file);
@@ -30,7 +46,7 @@ export const save = async (filePath, content) => {
     const fileContent = `${JSON.stringify(content, null, space)}\n`.replace(/\n/g, EOL);
     await writeFile(filePath, fileContent);
 };
-export const getEntryPathsFromManifest = (manifest, sharedGlobOptions) => {
+export const getEntryPathsFromManifest = (manifest, options) => {
     const { main, module, browser, bin, exports, types, typings } = manifest;
     const entryPaths = new Set();
     if (typeof main === 'string')
@@ -47,12 +63,19 @@ export const getEntryPathsFromManifest = (manifest, sharedGlobOptions) => {
                 entryPaths.add(id);
     }
     if (exports) {
-        for (const item of getStringValues(exports))
-            entryPaths.add(item);
+        for (const item of getEntriesFromExports(exports)) {
+            if (item === './*')
+                continue;
+            const expanded = item
+                .replace(/\/\*$/, '/**')
+                .replace(/\/\*\./, '/**/*.')
+                .replace(/\/\*\//, '/**/');
+            entryPaths.add(expanded);
+        }
     }
     if (typeof types === 'string')
         entryPaths.add(types);
     if (typeof typings === 'string')
         entryPaths.add(typings);
-    return _glob({ ...sharedGlobOptions, patterns: Array.from(entryPaths), label: 'package.json entry' });
+    return _glob({ patterns: Array.from(entryPaths), ...options, gitignore: false, label: 'package.json entry paths' });
 };

package/dist/util/plugin.d.ts

@@ -1,6 +1,5 @@
 export { _load as load } from './loader.js';
 import type { Plugin, PluginOptions, RawPluginConfiguration } from '../types/config.js';
-import { type Input } from './input.js';
 export declare const hasDependency: (dependencies: Set<string>, values: (string | RegExp)[]) => boolean;
 export declare const normalizePluginConfig: (pluginConfig: RawPluginConfiguration) => boolean | {
     config: string[] | null;
@@ -8,4 +7,3 @@ export declare const normalizePluginConfig: (pluginConfig: RawPluginConfiguratio
     project: string[] | null;
 };
 export declare const loadConfigForPlugin: (configFilePath: string, plugin: Plugin, options: PluginOptions, pluginName: string) => Promise<any>;
-export declare const getFinalEntryPaths: (plugin: Plugin, options: PluginOptions, configEntryPaths: Input[]) => Input[];

package/dist/util/plugin.js

@@ -1,6 +1,5 @@
 export { _load as load } from './loader.js';
 import { arrayify } from './array.js';
-import { toEntry, toProductionEntry } from './input.js';
 import { _load as load } from './loader.js';
 import { get } from './object.js';
 import { basename } from './path.js';
@@ -35,21 +34,9 @@ export const normalizePluginConfig = (pluginConfig) => {
 export const loadConfigForPlugin = async (configFilePath, plugin, options, pluginName) => {
     const { packageJsonPath } = plugin;
     const { manifest } = options;
-    const localConfig = basename(configFilePath) === 'package.json'
+    return basename(configFilePath) === 'package.json'
         ? typeof packageJsonPath === 'function'
             ? packageJsonPath(manifest)
             : get(manifest, packageJsonPath ?? pluginName)
         : await load(configFilePath);
-    return localConfig;
-};
-export const getFinalEntryPaths = (plugin, options, configEntryPaths) => {
-    const { config, isProduction } = options;
-    if (plugin.title === 'Storybook')
-        return [...(config.entry ?? []).map(toEntry), ...configEntryPaths];
-    const toEntryPathProtocol = isProduction && plugin.production && plugin.production.length > 0 ? toProductionEntry : toEntry;
-    if (config.entry)
-        return config.entry.map(id => toEntryPathProtocol(id));
-    if (configEntryPaths.length > 0)
-        return configEntryPaths;
-    return [...(plugin.entry ?? []).map(toEntry), ...(plugin.production ?? []).map(id => toProductionEntry(id))];
 };

package/dist/util/to-source-path.js

@@ -14,25 +14,22 @@ export const augmentWorkspace = (workspace, dir, compilerOptions) => {
 };
 export const getToSourcePathHandler = (chief) => {
     const toSourceMapCache = new Map();
-    const toSourcePath = (filePath) => {
+    return (filePath) => {
         if (!isInternal(filePath) || hasJSExt.test(filePath) || hasTSExt.test(filePath))
             return;
         if (toSourceMapCache.has(filePath))
             return toSourceMapCache.get(filePath);
         const workspace = chief.findWorkspaceByFilePath(filePath);
-        if (workspace) {
-            if (workspace.srcDir && workspace.outDir) {
-                if (filePath.startsWith(workspace.outDir)) {
-                    const pattern = filePath.replace(workspace.outDir, workspace.srcDir).replace(matchExt, defaultExtensions);
-                    const [srcFilePath] = fastGlob.sync(pattern);
-                    toSourceMapCache.set(filePath, srcFilePath);
-                    if (srcFilePath && srcFilePath !== filePath) {
-                        debugLog('*', `Rewiring ${toRelative(filePath)} → ${toRelative(srcFilePath)}`);
-                        return srcFilePath;
-                    }
+        if (workspace?.srcDir && workspace.outDir) {
+            if (filePath.startsWith(workspace.outDir)) {
+                const pattern = filePath.replace(workspace.outDir, workspace.srcDir).replace(matchExt, defaultExtensions);
+                const [srcFilePath] = fastGlob.sync(pattern);
+                toSourceMapCache.set(filePath, srcFilePath);
+                if (srcFilePath && srcFilePath !== filePath) {
+                    debugLog('*', `Source mapping ${toRelative(filePath)} → ${toRelative(srcFilePath)}`);
+                    return srcFilePath;
                 }
             }
         }
     };
-    return toSourcePath;
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.47.0";
+export declare const version = "5.49.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.47.0';
+export const version = '5.49.0';