knip 5.26.0 → 5.27.1

package/dist/index.js

@@ -1,5 +1,4 @@
 import { watch } from 'node:fs';
-import { CacheConsultant } from './CacheConsultant.js';
 import { ConfigurationChief } from './ConfigurationChief.js';
 import { ConsoleStreamer } from './ConsoleStreamer.js';
 import { DependencyDeputy } from './DependencyDeputy.js';
@@ -10,35 +9,38 @@ import { WorkspaceWorker } from './WorkspaceWorker.js';
 import { _getDependenciesFromScripts } from './binaries/index.js';
 import { getCompilerExtensions, getIncludedCompilers } from './compilers/index.js';
 import { getFilteredScripts } from './manifest/helpers.js';
-import watchReporter from './reporters/watch.js';
 import { debugLog, debugLogArray, debugLogObject } from './util/debug.js';
-import { addNsValues, addValues, createFileNode } from './util/dependency-graph.js';
-import { isFile } from './util/fs.js';
+import { getOrCreateFileNode, updateImportMap } from './util/dependency-graph.js';
 import { _glob, negate } from './util/glob.js';
 import { getGitIgnoredHandler } from './util/globby.js';
-import { getHandler } from './util/handle-dependency.js';
+import { getReferencedDependencyHandler } from './util/handle-dependency.js';
 import { getHasStrictlyNsReferences, getType } from './util/has-strictly-ns-references.js';
 import { getIsIdentifierReferencedHandler } from './util/is-identifier-referenced.js';
 import { getEntryPathFromManifest, getPackageNameFromModuleSpecifier } from './util/modules.js';
-import { dirname, join, toPosix } from './util/path.js';
+import { dirname, join } from './util/path.js';
 import { findMatch } from './util/regex.js';
 import { getShouldIgnoreHandler, getShouldIgnoreTagHandler } from './util/tag.js';
 import { augmentWorkspace, getToSourcePathHandler } from './util/to-source-path.js';
 import { createAndPrintTrace, printTrace } from './util/trace.js';
 import { loadTSConfig } from './util/tsconfig-loader.js';
+import { getWatchHandler } from './util/watch.js';
 export const main = async (unresolvedConfiguration) => {
-    const { cwd, tsConfigFile, gitignore, isStrict, isProduction, isShowProgress, isIncludeEntryExports, isIncludeLibs, isIsolateWorkspaces, isDebug, isWatch, tags, isFix, fixTypes, isRemoveFiles, } = unresolvedConfiguration;
+    const { cacheLocation, cwd, excludedIssueTypes, fixTypes, gitignore, includedIssueTypes, isCache, isDebug, isDependenciesShorthand, isExportsShorthand, isFilesShorthand, isFix, isHideConfigHints, isIncludeEntryExports, isIncludeLibs, isIsolateWorkspaces, isProduction, isRemoveFiles, isShowProgress, isStrict, isWatch, tags, tsConfigFile, workspace, } = unresolvedConfiguration;
     debugLogObject('*', 'Unresolved configuration (from CLI arguments)', unresolvedConfiguration);
-    const chief = new ConfigurationChief({ cwd, isProduction, isStrict, isIncludeEntryExports });
+    const chief = new ConfigurationChief({ cwd, isProduction, isStrict, isIncludeEntryExports, workspace });
     const deputy = new DependencyDeputy({ isProduction, isStrict });
     const factory = new PrincipalFactory();
     const streamer = new ConsoleStreamer({ isEnabled: isShowProgress });
-    const isGitIgnored = await getGitIgnoredHandler({ cwd, gitignore });
-    const toSourceFilePath = getToSourcePathHandler(chief);
     streamer.cast('Reading workspace configuration(s)...');
     await chief.init();
     const workspaces = chief.getIncludedWorkspaces();
-    const report = chief.getIncludedIssueTypes();
+    const report = chief.getIncludedIssueTypes({
+        includedIssueTypes,
+        excludedIssueTypes,
+        isDependenciesShorthand,
+        isExportsShorthand,
+        isFilesShorthand,
+    });
     const rules = chief.getRules();
     const filters = chief.getFilters();
     const fixer = new IssueFixer({ isEnabled: isFix, cwd, fixTypes, isRemoveFiles });
@@ -53,6 +55,11 @@ export const main = async (unresolvedConfiguration) => {
     const o = () => workspaces.map(w => ({ pkgName: w.pkgName, name: w.name, config: w.config, ancestors: w.ancestors }));
     debugLogObject('*', 'Included workspaces', () => workspaces.map(w => w.pkgName));
     debugLogObject('*', 'Included workspace configs', o);
+    const isGitIgnored = await getGitIgnoredHandler({ cwd, gitignore });
+    const toSourceFilePath = getToSourcePathHandler(chief);
+    const handleReferencedDependency = getReferencedDependencyHandler(collector, deputy, chief);
+    const shouldIgnore = getShouldIgnoreHandler(isProduction);
+    const shouldIgnoreTags = getShouldIgnoreTagHandler(tags);
     for (const workspace of workspaces) {
         const { name, dir, ancestors, pkgName, manifestPath } = workspace;
         streamer.cast(`Analyzing workspace ${name}...`);
@@ -81,6 +88,9 @@ export const main = async (unresolvedConfiguration) => {
             isIsolateWorkspaces,
             isSkipLibs,
             isWatch,
+            toSourceFilePath,
+            isCache,
+            cacheLocation,
         });
         const worker = new WorkspaceWorker({
             name,
@@ -94,6 +104,8 @@ export const main = async (unresolvedConfiguration) => {
             rootIgnore: chief.config.ignore,
             negatedWorkspacePatterns: chief.getNegatedWorkspacePatterns(name),
             enabledPluginsInAncestors: ancestors.flatMap(ancestor => enabledPluginsStore.get(ancestor) ?? []),
+            isCache,
+            cacheLocation,
         });
         await worker.init();
         principal.addEntryPaths(definitionPaths);
@@ -177,39 +189,7 @@ export const main = async (unresolvedConfiguration) => {
     const analyzedFiles = new Set();
     const unreferencedFiles = new Set();
     const entryPaths = new Set();
-    const getFileNode = (filePath) => graph.get(filePath) ?? createFileNode();
-    const handleReferencedDependency = getHandler(collector, deputy, chief);
-    const updateImportDetails = (importedModule, importItems) => {
-        for (const id of importItems.refs)
-            importedModule.refs.add(id);
-        for (const [id, v] of importItems.imported.entries())
-            addValues(importedModule.imported, id, v);
-        for (const [id, v] of importItems.importedAs.entries())
-            addNsValues(importedModule.importedAs, id, v);
-        for (const [id, v] of importItems.importedNs.entries())
-            addValues(importedModule.importedNs, id, v);
-        for (const [id, v] of importItems.reExported.entries())
-            addValues(importedModule.reExported, id, v);
-        for (const [id, v] of importItems.reExportedAs.entries())
-            addNsValues(importedModule.reExportedAs, id, v);
-        for (const [id, v] of importItems.reExportedNs.entries())
-            addValues(importedModule.reExportedNs, id, v);
-    };
-    const updateImportMap = (file, importMap) => {
-        for (const [importedFilePath, importDetails] of importMap.entries()) {
-            const importedFileImports = file.imports.internal.get(importedFilePath);
-            if (!importedFileImports)
-                file.imports.internal.set(importedFilePath, importDetails);
-            else
-                updateImportDetails(importedFileImports, importDetails);
-            const importedFile = getFileNode(importedFilePath);
-            if (!importedFile.imported)
-                importedFile.imported = importDetails;
-            else
-                updateImportDetails(importedFile.imported, importDetails);
-            graph.set(importedFilePath, importedFile);
-        }
-    };
+    const isIdentifierReferenced = getIsIdentifierReferencedHandler(graph, entryPaths);
     const isPackageNameInternalWorkspace = (packageName) => chief.availableWorkspacePkgNames.has(packageName);
     const getPrincipalByFilePath = (filePath) => {
         const workspace = chief.findWorkspaceByFilePath(filePath);
@@ -230,12 +210,12 @@ export const main = async (unresolvedConfiguration) => {
                 isReportClassMembers,
                 tags,
             }, isGitIgnored, isPackageNameInternalWorkspace, getPrincipalByFilePath);
-            const file = getFileNode(filePath);
+            const file = getOrCreateFileNode(graph, filePath);
             file.imports = imports;
             file.exports = exports;
             file.scripts = scripts;
             file.traceRefs = traceRefs;
-            updateImportMap(file, imports.internal);
+            updateImportMap(file, imports.internal, graph);
             file.internalImportCache = imports.internal;
             graph.set(filePath, file);
             if (scripts && scripts.size > 0) {
@@ -252,12 +232,12 @@ export const main = async (unresolvedConfiguration) => {
         }
     };
     for (const principal of principals) {
-        principal.init(toSourceFilePath);
+        principal.init();
         for (const [containingFilePath, specifier, workspaceName] of principal.referencedDependencies) {
             const workspace = chief.findWorkspaceByName(workspaceName);
             if (workspace) {
                 const specifierFilePath = handleReferencedDependency(specifier, containingFilePath, workspace);
-                if (specifierFilePath)
+                if (specifierFilePath && !isGitIgnored(specifierFilePath))
                     principal.addEntryPath(specifierFilePath);
             }
         }
@@ -285,16 +265,13 @@ export const main = async (unresolvedConfiguration) => {
     if (isIsolateWorkspaces)
         for (const principal of principals)
             factory.deletePrincipal(principal);
-    const shouldIgnore = getShouldIgnoreHandler(isProduction);
-    const shouldIgnoreTags = getShouldIgnoreTagHandler(tags);
-    const isIdentifierReferenced = getIsIdentifierReferencedHandler(graph, entryPaths);
     const ignoreExportsUsedInFile = chief.config.ignoreExportsUsedInFile;
     const isExportedItemReferenced = (exportedItem) => exportedItem.refs[1] ||
         (exportedItem.refs[0] > 0 &&
             (typeof ignoreExportsUsedInFile === 'object'
                 ? exportedItem.type !== 'unknown' && !!ignoreExportsUsedInFile[exportedItem.type]
                 : ignoreExportsUsedInFile));
-    const findUnusedExports = async () => {
+    const collectUnusedExports = async () => {
         if (isReportValues || isReportTypes) {
             streamer.cast('Connecting the dots...');
             for (const [filePath, file] of graph.entries()) {
@@ -472,98 +449,42 @@ export const main = async (unresolvedConfiguration) => {
                     collector.addIssue(issue);
             for (const issue of optionalPeerDependencyIssues)
                 collector.addIssue(issue);
-            const configurationHints = deputy.getConfigurationHints(collector.getIssues());
-            for (const hint of configurationHints)
-                collector.addConfigurationHint(hint);
+            deputy.removeIgnoredIssues(collector.getIssues());
+            if (!workspace && !isProduction && !isHideConfigHints) {
+                const configurationHints = deputy.getConfigurationHints();
+                for (const hint of configurationHints)
+                    collector.addConfigurationHint(hint);
+            }
         }
         const unusedIgnoredWorkspaces = chief.getUnusedIgnoredWorkspaces();
         for (const identifier of unusedIgnoredWorkspaces) {
             collector.addConfigurationHint({ type: 'ignoreWorkspaces', identifier });
         }
     };
+    await collectUnusedExports();
+    const { issues, counters, tagHints, configurationHints } = collector.getIssues();
     if (isWatch) {
-        const cacheLocation = CacheConsultant.getCacheLocation();
-        watch('.', { recursive: true }, async (eventType, filename) => {
-            debugLog('*', `(raw) ${eventType} ${filename}`);
-            if (filename) {
-                const startTime = performance.now();
-                const filePath = join(cwd, toPosix(filename));
-                if (filename.startsWith(cacheLocation) || filename.startsWith('.git/') || isGitIgnored(filePath)) {
-                    debugLog('*', `ignoring ${eventType} ${filename}`);
-                    return;
-                }
-                const workspace = chief.findWorkspaceByFilePath(filePath);
-                if (workspace) {
-                    const principal = factory.getPrincipalByPackageName(workspace.pkgName);
-                    if (principal) {
-                        const event = eventType === 'rename' ? (isFile(filePath) ? 'added' : 'deleted') : 'modified';
-                        principal.invalidateFile(filePath);
-                        unreferencedFiles.clear();
-                        const cachedUnusedFiles = collector.purge();
-                        switch (event) {
-                            case 'added':
-                                principal.addProjectPath(filePath);
-                                principal.deletedFiles.delete(filePath);
-                                cachedUnusedFiles.add(filePath);
-                                debugLog(workspace.name, `Watcher: + ${filename}`);
-                                break;
-                            case 'deleted':
-                                analyzedFiles.delete(filePath);
-                                principal.removeProjectPath(filePath);
-                                cachedUnusedFiles.delete(filePath);
-                                debugLog(workspace.name, `Watcher: - ${filename}`);
-                                break;
-                            case 'modified':
-                                debugLog(workspace.name, `Watcher: ± ${filename}`);
-                                break;
-                        }
-                        const filePaths = principal.getUsedResolvedFiles();
-                        if (event === 'added' || event === 'deleted') {
-                            graph.clear();
-                            for (const filePath of filePaths)
-                                analyzeSourceFile(filePath, principal);
-                        }
-                        else {
-                            for (const [filePath, file] of graph) {
-                                if (filePaths.includes(filePath)) {
-                                    file.imported = undefined;
-                                }
-                                else {
-                                    graph.delete(filePath);
-                                    analyzedFiles.delete(filePath);
-                                    cachedUnusedFiles.add(filePath);
-                                }
-                            }
-                            for (const filePath of filePaths)
-                                if (!graph.has(filePath))
-                                    analyzeSourceFile(filePath, principal);
-                            if (!cachedUnusedFiles.has(filePath))
-                                analyzeSourceFile(filePath, principal);
-                            for (const filePath of filePaths) {
-                                const file = graph.get(filePath);
-                                if (file?.internalImportCache)
-                                    updateImportMap(file, file.internalImportCache);
-                            }
-                        }
-                        await findUnusedExports();
-                        const unusedFiles = [...cachedUnusedFiles].filter(filePath => !analyzedFiles.has(filePath));
-                        collector.addFilesIssues(unusedFiles);
-                        collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
-                        const { issues } = collector.getIssues();
-                        watchReporter({ report, issues, streamer, startTime, size: analyzedFiles.size, isDebug });
-                    }
-                }
-            }
+        const isIgnored = (filePath) => filePath.startsWith(cacheLocation) || filePath.includes('/.git/') || isGitIgnored(filePath);
+        const watchHandler = await getWatchHandler({
+            analyzedFiles,
+            analyzeSourceFile,
+            chief,
+            collector,
+            collectUnusedExports,
+            cwd,
+            factory,
+            graph,
+            isDebug,
+            isIgnored,
+            report,
+            streamer,
+            unreferencedFiles,
         });
+        watch('.', { recursive: true }, watchHandler);
     }
-    await findUnusedExports();
-    const { issues, counters, tagHints, configurationHints } = collector.getIssues();
-    if (isFix) {
+    if (isFix)
         await fixer.fixIssues(issues);
-    }
-    if (isWatch)
-        watchReporter({ report, issues, streamer, size: analyzedFiles.size, isDebug });
-    else
+    if (!isWatch)
         streamer.clear();
     return { report, issues, counters, rules, tagHints, configurationHints };
 };

package/dist/plugins/babel/index.js

@@ -10,7 +10,8 @@ export const getDependenciesFromConfig = (config) => {
     const presets = config.presets?.flatMap(getName).map(name => resolveName(name, 'preset')) ?? [];
     const plugins = config.plugins?.flatMap(getName).map(name => resolveName(name, 'plugin')) ?? [];
     const nested = config.env ? Object.values(config.env).flatMap(getDependenciesFromConfig) : [];
-    return compact([...presets, ...plugins, ...nested]);
+    const overrides = config.overrides ? [config.overrides].flat().flatMap(getDependenciesFromConfig) : [];
+    return compact([...presets, ...plugins, ...nested, ...overrides]);
 };
 const resolveConfig = async (config) => {
     if (typeof config === 'function')

package/dist/plugins/babel/types.d.ts

@@ -4,6 +4,7 @@ export type BabelConfigObj = {
     plugins?: (string | [string, unknown])[];
     presets?: (string | [string, unknown])[];
     env?: Record<string, BabelConfigObj>;
+    overrides?: BabelConfigObj[];
 };
 export type BabelConfig = BabelConfigObj | BabelConfigFn;
 export {};

package/dist/plugins/cypress/helpers.d.ts

@@ -0,0 +1,3 @@
+import type { PluginOptions } from '#p/types/plugins.js';
+import type { CypressConfig } from './types.js';
+export declare const resolveDependencies: (config: CypressConfig, options: PluginOptions) => Promise<string[]>;

package/dist/plugins/cypress/helpers.js

@@ -0,0 +1,23 @@
+import { isInternal, toAbsolute } from '#p/util/path.js';
+import { load, resolveEntry } from '#p/util/plugin.js';
+export const resolveDependencies = async (config, options) => {
+    const { reporter } = config;
+    const { configFileDir } = options;
+    const resolve = (specifier) => resolveEntry(options, specifier);
+    const reporters = reporter ? new Set([reporter]) : new Set();
+    if (reporter === 'cypress-multi-reporters' && config.reporterOptions?.configFile) {
+        const { configFile } = config.reporterOptions;
+        const configFilePath = toAbsolute(configFile, configFileDir);
+        if (isInternal(configFilePath)) {
+            const reporterConfig = await load(configFilePath);
+            if (typeof reporterConfig === 'object' && reporterConfig.reporterEnabled) {
+                const { reporterEnabled: reporterConcatenatedNames } = reporterConfig;
+                const reporterNames = reporterConcatenatedNames.split(',');
+                for (const reporterName of reporterNames) {
+                    reporters.add(resolve(reporterName.trim()));
+                }
+            }
+        }
+    }
+    return [...reporters];
+};

package/dist/plugins/cypress/index.d.ts

@@ -1,4 +1,5 @@
-import type { IsPluginEnabled, ResolveEntryPaths } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types/plugins.js';
+import type { CypressConfig } from './types.js';
 declare const _default: {
     title: string;
     enablers: string[];
@@ -6,5 +7,6 @@ declare const _default: {
     config: string[];
     entry: string[];
     resolveEntryPaths: ResolveEntryPaths;
+    resolveConfig: ResolveConfig<CypressConfig>;
 };
 export default _default;

package/dist/plugins/cypress/index.js

@@ -1,5 +1,6 @@
 import { hasDependency } from '#p/util/plugin.js';
 import { toEntryPattern } from '../../util/protocols.js';
+import { resolveDependencies } from './helpers.js';
 const title = 'Cypress';
 const enablers = ['cypress'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -19,6 +20,9 @@ const resolveEntryPaths = async (localConfig) => {
         ...(supportFiles.length > 0 ? supportFiles : SUPPORT_FILE_PATTERNS),
     ].map(toEntryPattern);
 };
+const resolveConfig = (config, options) => {
+    return resolveDependencies(config, options);
+};
 export default {
     title,
     enablers,
@@ -26,4 +30,5 @@ export default {
     config,
     entry,
     resolveEntryPaths,
+    resolveConfig,
 };

package/dist/plugins/cypress/types.d.ts

@@ -0,0 +1,6 @@
+export interface CypressConfig {
+    reporter: string;
+    reporterOptions?: {
+        configFile?: string;
+    };
+}

package/dist/plugins/cypress/types.js

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

package/dist/plugins/eslint/helpers.js

@@ -1,8 +1,7 @@
 import { compact } from '#p/util/array.js';
 import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from '#p/util/modules.js';
 import { basename, dirname, isAbsolute, isInternal, toAbsolute } from '#p/util/path.js';
-import { load } from '#p/util/plugin.js';
-import { _resolve } from '#p/util/require.js';
+import { load, resolve } from '#p/util/plugin.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
 const getDependencies = (config) => {
     const extendsSpecifiers = config.extends ? [config.extends].flat().map(resolveExtendSpecifier) : [];
@@ -27,11 +26,13 @@ export const getDependenciesDeep = async (localConfig, options, dependencies = n
         if (localConfig.extends) {
             for (const extend of [localConfig.extends].flat()) {
                 if (isInternal(extend)) {
-                    const filePath = _resolve(toAbsolute(extend, configFileDir));
-                    dependencies.add(filePath);
-                    const localConfig = await load(filePath);
-                    const opts = { ...options, configFileDir: dirname(filePath), configFileName: basename(filePath) };
-                    addAll(await getDependenciesDeep(localConfig, opts, dependencies));
+                    const filePath = resolve(toAbsolute(extend, configFileDir), configFileDir);
+                    if (filePath) {
+                        dependencies.add(filePath);
+                        const localConfig = await load(filePath);
+                        const opts = { ...options, configFileDir: dirname(filePath), configFileName: basename(filePath) };
+                        addAll(await getDependenciesDeep(localConfig, opts, dependencies));
+                    }
                 }
             }
         }

package/dist/plugins/husky/index.d.ts

@@ -4,6 +4,6 @@ declare const _default: {
     enablers: string[];
     isEnabled: IsPluginEnabled;
     config: string[];
-    resolveConfig: ResolveConfig<string>;
+    resolveConfig: ResolveConfig;
 };
 export default _default;

package/dist/plugins/husky/index.js

@@ -4,10 +4,17 @@ const title = 'husky';
 const enablers = ['husky'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const gitHookPaths = getGitHookPaths('.husky', false);
-const config = [...gitHookPaths];
-const resolveConfig = async (script, options) => {
+const config = [...gitHookPaths, 'package.json'];
+const resolveConfig = (script, options) => {
     if (!script)
         return [];
+    if (options.configFileName === 'package.json') {
+        const hooks = script.hooks;
+        if (hooks) {
+            const scripts = Object.values(hooks);
+            return ['husky', ...getDependenciesFromScripts(scripts, { ...options })];
+        }
+    }
     return getDependenciesFromScripts(String(script), { ...options, knownGlobalsOnly: true });
 };
 export default {

package/dist/plugins/index.d.ts

@@ -17,6 +17,7 @@ export { default as githubActions } from './github-actions/index.js';
 export { default as graphqlCodegen } from './graphql-codegen/index.js';
 export { default as husky } from './husky/index.js';
 export { default as jest } from './jest/index.js';
+export { default as ladle } from './ladle/index.js';
 export { default as lefthook } from './lefthook/index.js';
 export { default as linthtml } from './linthtml/index.js';
 export { default as lintStaged } from './lint-staged/index.js';
@@ -37,10 +38,13 @@ export { default as playwright } from './playwright/index.js';
 export { default as playwrightCt } from './playwright-ct/index.js';
 export { default as postcss } from './postcss/index.js';
 export { default as prettier } from './prettier/index.js';
+export { default as reactCosmos } from './react-cosmos/index.js';
 export { default as releaseIt } from './release-it/index.js';
 export { default as remark } from './remark/index.js';
 export { default as remix } from './remix/index.js';
 export { default as rollup } from './rollup/index.js';
+export { default as rsbuild } from './rsbuild/index.js';
+export { default as rspack } from './rspack/index.js';
 export { default as semanticRelease } from './semantic-release/index.js';
 export { default as sentry } from './sentry/index.js';
 export { default as simpleGitHooks } from './simple-git-hooks/index.js';

package/dist/plugins/index.js

@@ -17,6 +17,7 @@ export { default as githubActions } from './github-actions/index.js';
 export { default as graphqlCodegen } from './graphql-codegen/index.js';
 export { default as husky } from './husky/index.js';
 export { default as jest } from './jest/index.js';
+export { default as ladle } from './ladle/index.js';
 export { default as lefthook } from './lefthook/index.js';
 export { default as linthtml } from './linthtml/index.js';
 export { default as lintStaged } from './lint-staged/index.js';
@@ -37,10 +38,13 @@ export { default as playwright } from './playwright/index.js';
 export { default as playwrightCt } from './playwright-ct/index.js';
 export { default as postcss } from './postcss/index.js';
 export { default as prettier } from './prettier/index.js';
+export { default as reactCosmos } from './react-cosmos/index.js';
 export { default as releaseIt } from './release-it/index.js';
 export { default as remark } from './remark/index.js';
 export { default as remix } from './remix/index.js';
 export { default as rollup } from './rollup/index.js';
+export { default as rsbuild } from './rsbuild/index.js';
+export { default as rspack } from './rspack/index.js';
 export { default as semanticRelease } from './semantic-release/index.js';
 export { default as sentry } from './sentry/index.js';
 export { default as simpleGitHooks } from './simple-git-hooks/index.js';

package/dist/plugins/ladle/index.d.ts

@@ -0,0 +1,13 @@
+import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types/plugins.js';
+import type { LadleConfig } from './types.js';
+declare const _default: {
+    title: string;
+    enablers: import("#p/types/config.js").IgnorePatterns;
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    entry: string[];
+    project: string[];
+    resolveEntryPaths: ResolveEntryPaths<LadleConfig>;
+    resolveConfig: ResolveConfig<LadleConfig>;
+};
+export default _default;

package/dist/plugins/ladle/index.js

@@ -0,0 +1,36 @@
+import { toAbsolute } from '#p/util/path.js';
+import { hasDependency, load } from '#p/util/plugin.js';
+import { toEntryPattern } from '../../util/protocols.js';
+import { resolveConfig as resolveVitestConfig } from '../vitest/index.js';
+const title = 'Ladle';
+const enablers = ['@ladle/react'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['.ladle/config.{mjs,js,ts}'];
+const stories = ['src/**/*.stories.{js,jsx,ts,tsx,mdx}'];
+const restEntry = ['.ladle/components.{js,jsx,ts,tsx}'];
+const entry = [...restEntry, ...stories];
+const project = ['.ladle/**/*.{js,jsx,ts,tsx}'];
+const resolveEntryPaths = (localConfig, options) => {
+    const localStories = typeof localConfig.stories === 'string' ? [localConfig.stories] : localConfig.stories;
+    const viteConfig = localConfig.viteConfig ? [toAbsolute(localConfig.viteConfig, options.cwd)] : [];
+    const patterns = [...restEntry, ...(localStories ?? stories), ...viteConfig];
+    return patterns.map(toEntryPattern);
+};
+const resolveConfig = async (localConfig, options) => {
+    if (localConfig.viteConfig) {
+        const viteConfigPath = toAbsolute(localConfig.viteConfig, options.cwd);
+        const viteConfig = await load(viteConfigPath);
+        return resolveVitestConfig(viteConfig, options);
+    }
+    return [];
+};
+export default {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    entry,
+    project,
+    resolveEntryPaths,
+    resolveConfig,
+};

package/dist/plugins/ladle/types.d.ts

@@ -0,0 +1,4 @@
+export type LadleConfig = {
+    stories?: string | string[];
+    viteConfig?: string;
+};

package/dist/plugins/ladle/types.js

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

package/dist/plugins/playwright/index.d.ts

@@ -1,5 +1,5 @@
-import type { PlaywrightTestConfig } from 'playwright/test';
 import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types/plugins.js';
+import type { PlaywrightTestConfig } from './types.js';
 export declare const entry: string[];
 export declare const resolveEntryPaths: ResolveEntryPaths<PlaywrightTestConfig>;
 export declare const resolveConfig: ResolveConfig<PlaywrightTestConfig>;

package/dist/plugins/playwright/types.d.ts

@@ -0,0 +1,36 @@
+type LiteralUnion<T extends U, U = string> = T | (U & {
+    zz_IGNORE_ME?: never;
+});
+type ReporterDescription = Readonly<['blob'] | ['blob', {
+    outputDir?: string;
+    fileName?: string;
+}] | ['dot'] | ['line'] | ['list'] | ['list', {
+    printSteps?: boolean;
+}] | ['github'] | ['junit'] | ['junit', {
+    outputFile?: string;
+    stripANSIControlSequences?: boolean;
+    includeProjectInTestName?: boolean;
+}] | ['json'] | ['json', {
+    outputFile?: string;
+}] | ['html'] | [
+    'html',
+    {
+        outputFolder?: string;
+        open?: 'always' | 'never' | 'on-failure';
+        host?: string;
+        port?: number;
+        attachmentsBaseURL?: string;
+    }
+] | ['null'] | [string] | [string, any]>;
+type Project = {
+    name: string;
+    use: string;
+    testMatch?: string | RegExp | (string | RegExp)[];
+};
+export type PlaywrightTestConfig = {
+    projects?: Project[];
+    testMatch?: string | RegExp | (string | RegExp)[];
+    testDir?: string;
+    reporter?: LiteralUnion<'dot' | 'line' | 'list' | 'junit' | 'html' | 'json' | 'github' | 'null', string> | ReporterDescription[];
+};
+export {};

package/dist/plugins/playwright/types.js

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

package/dist/plugins/playwright-ct/index.d.ts

@@ -5,7 +5,7 @@ declare const _default: {
     isEnabled: IsPluginEnabled;
     config: string[];
     entry: string[];
-    resolveEntryPaths: import("#p/types/plugins.js").ResolveEntryPaths<import("playwright/test").PlaywrightTestConfig>;
-    resolveConfig: import("#p/types/plugins.js").ResolveConfig<import("playwright/test").PlaywrightTestConfig>;
+    resolveEntryPaths: import("#p/types/plugins.js").ResolveEntryPaths<import("../playwright/types.js").PlaywrightTestConfig>;
+    resolveConfig: import("#p/types/plugins.js").ResolveConfig<import("../playwright/types.js").PlaywrightTestConfig>;
 };
 export default _default;

package/dist/plugins/react-cosmos/index.d.ts

@@ -0,0 +1,12 @@
+import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types/plugins.js';
+import type { ReactCosmosConfig } from './types.js';
+declare const _default: {
+    title: string;
+    enablers: import("#p/types/config.js").IgnorePatterns;
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    entry: string[];
+    resolveConfig: ResolveConfig<ReactCosmosConfig>;
+    resolveEntryPaths: ResolveEntryPaths<ReactCosmosConfig>;
+};
+export default _default;