knip 5.41.1 → 5.42.1

package/dist/index.js

@@ -232,7 +232,7 @@ export const main = async (unresolvedConfiguration) => {
         analyzedFiles.add(filePath);
         const workspace = chief.findWorkspaceByFilePath(filePath);
         if (workspace) {
-            const { imports, exports, scripts, traceRefs } = principal.analyzeSourceFile(filePath, {
+            const { imports, exports, duplicates, scripts, traceRefs } = principal.analyzeSourceFile(filePath, {
                 skipTypeOnly: isStrict,
                 isFixExports: fixer.isEnabled && fixer.isFixUnusedExports,
                 isFixTypes: fixer.isEnabled && fixer.isFixUnusedTypes,
@@ -243,6 +243,7 @@ export const main = async (unresolvedConfiguration) => {
             const file = getOrCreateFileNode(graph, filePath);
             file.imports = imports;
             file.exports = exports;
+            file.duplicates = duplicates;
             file.scripts = scripts;
             file.traceRefs = traceRefs;
             updateImportMap(file, imports.internal, graph);
@@ -250,7 +251,7 @@ export const main = async (unresolvedConfiguration) => {
             graph.set(filePath, file);
             if (scripts && scripts.size > 0) {
                 const dependencies = deputy.getDependencies(workspace.name);
-                const manifestScriptNames = new Set();
+                const manifestScriptNames = new Set(Object.keys(chief.getManifestForWorkspace(workspace.name)?.scripts ?? {}));
                 const rootCwd = cwd;
                 const options = {
                     cwd: dirname(filePath),
@@ -259,18 +260,21 @@ export const main = async (unresolvedConfiguration) => {
                     dependencies,
                     manifestScriptNames,
                 };
-                const specifiers = _getInputsFromScripts(scripts, options);
-                for (const specifier of specifiers) {
-                    specifier.containingFilePath = filePath;
-                    specifier.dir = cwd;
-                    const specifierFilePath = getReferencedInternalFilePath(specifier, workspace);
+                const inputs = _getInputsFromScripts(scripts, options);
+                for (const input of inputs) {
+                    input.containingFilePath = filePath;
+                    input.dir = cwd;
+                    const specifierFilePath = getReferencedInternalFilePath(input, workspace);
                     if (specifierFilePath)
                         analyzeSourceFile(specifierFilePath, principal);
                 }
             }
         }
     };
-    for (const principal of principals) {
+    for (let i = 0; i < principals.length; ++i) {
+        const principal = principals[i];
+        if (!principal)
+            continue;
         principal.init();
         streamer.cast('Running async compilers...');
         await principal.runAsyncCompilers();
@@ -281,7 +285,7 @@ export const main = async (unresolvedConfiguration) => {
             size = principal.entryPaths.size;
             const resolvedFiles = principal.getUsedResolvedFiles();
             const files = resolvedFiles.filter(filePath => !analyzedFiles.has(filePath));
-            debugLogArray('*', `Analyzing used resolved files [P${principals.indexOf(principal) + 1}/${++round}]`, files);
+            debugLogArray('*', `Analyzing used resolved files [P${i + 1}/${++round}]`, files);
             for (const filePath of files)
                 analyzeSourceFile(filePath, principal);
         } while (size !== principal.entryPaths.size);
@@ -290,12 +294,18 @@ export const main = async (unresolvedConfiguration) => {
         for (const filePath of principal.entryPaths)
             entryPaths.add(filePath);
         principal.reconcileCache(graph);
-        if (!isIsolateWorkspaces && isSkipLibs && !isWatch)
+        if (!isIsolateWorkspaces && isSkipLibs && !isWatch) {
             factory.deletePrincipal(principal);
+            principals[i] = undefined;
+        }
+    }
+    if (isIsolateWorkspaces) {
+        for (const principal of principals) {
+            if (principal)
+                factory.deletePrincipal(principal);
+        }
+        principals.length = 0;
     }
-    if (isIsolateWorkspaces)
-        for (const principal of principals)
-            factory.deletePrincipal(principal);
     const ignoreExportsUsedInFile = chief.config.ignoreExportsUsedInFile;
     const isExportedItemReferenced = (exportedItem) => exportedItem.refs[1] ||
         (exportedItem.refs[0] > 0 &&
@@ -306,7 +316,7 @@ export const main = async (unresolvedConfiguration) => {
         if (isReportValues || isReportTypes) {
             streamer.cast('Connecting the dots...');
             for (const [filePath, file] of graph.entries()) {
-                const exportItems = file.exports?.exported;
+                const exportItems = file.exports;
                 if (!exportItems || exportItems.size === 0)
                     continue;
                 const workspace = chief.findWorkspaceByFilePath(filePath);
@@ -341,7 +351,7 @@ export const main = async (unresolvedConfiguration) => {
                                     createAndPrintTrace(filePath, { identifier, isEntry, hasRef: isReferenced });
                                     continue;
                                 }
-                                const reExportedItem = graph.get(reExportingEntryFile)?.exports.exported.get(identifier);
+                                const reExportedItem = graph.get(reExportingEntryFile)?.exports.get(identifier);
                                 if (reExportedItem && shouldIgnore(reExportedItem.jsDocTags))
                                     continue;
                             }
@@ -450,8 +460,8 @@ export const main = async (unresolvedConfiguration) => {
         for (const [filePath, file] of graph.entries()) {
             const ws = chief.findWorkspaceByFilePath(filePath);
             if (ws) {
-                if (file.exports?.duplicate) {
-                    for (const symbols of file.exports.duplicate) {
+                if (file.duplicates) {
+                    for (const symbols of file.duplicates) {
                         if (symbols.length > 1) {
                             const symbol = symbols.map(s => s.symbol).join('|');
                             collector.addIssue({ type: 'duplicates', filePath, workspace: ws.name, symbol, symbols });

package/dist/plugins/_template/index.js

@@ -1,6 +1,6 @@
 import { toDeferResolve } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
-const title = '_template';
+const title = '__PLUGIN_NAME__';
 const enablers = ['__PLUGIN_NAME__'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = [];

package/dist/plugins/angular/index.js

@@ -1,6 +1,7 @@
 import { toConfig, toDependency, toEntry, toProductionEntry } from '../../util/input.js';
 import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
+import * as karma from '../karma/helpers.js';
 const title = 'Angular';
 const enablers = ['@angular/cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -13,50 +14,81 @@ const resolveConfig = async (config, options) => {
     for (const project of Object.values(config.projects)) {
         if (!project.architect)
             return [];
-        for (const target of Object.values(project.architect)) {
+        for (const [targetName, target] of Object.entries(project.architect)) {
             const { options: opts, configurations: configs } = target;
             const [packageName] = typeof target.builder === 'string' ? target.builder.split(':') : [];
             if (typeof packageName === 'string')
                 inputs.add(toDependency(packageName));
             if (opts) {
-                if ('main' in opts && typeof opts.main === 'string') {
-                    inputs.add(toProductionEntry(join(cwd, opts.main)));
-                }
-                if ('browser' in opts && typeof opts.browser === 'string') {
-                    inputs.add(toProductionEntry(join(cwd, opts.browser)));
-                }
-                if ('ssr' in opts && opts.ssr && typeof opts.ssr === 'object') {
-                    if ('entry' in opts.ssr && typeof opts.ssr.entry === 'string') {
-                        inputs.add(toProductionEntry(join(cwd, opts.ssr.entry)));
-                    }
-                }
                 if ('tsConfig' in opts && typeof opts.tsConfig === 'string') {
                     inputs.add(toConfig('typescript', opts.tsConfig, configFilePath));
                 }
-                if ('server' in opts && opts.server && typeof opts.server === 'string') {
-                    inputs.add(toProductionEntry(join(cwd, opts.server)));
-                }
-                if ('fileReplacements' in opts && opts.fileReplacements && Array.isArray(opts.fileReplacements)) {
-                    for (const fileReplacedBy of filesReplacedBy(opts.fileReplacements)) {
-                        inputs.add(toEntry(fileReplacedBy));
+            }
+            const defaultEntriesByOption = opts ? entriesByOption(opts) : new Map();
+            const entriesByOptionByConfig = new Map(configs ? Object.entries(configs).map(([name, opts]) => [name, entriesByOption(opts)]) : []);
+            const productionEntriesByOption = entriesByOptionByConfig.get(PRODUCTION_CONFIG_NAME) ?? new Map();
+            const normalizePath = (path) => join(cwd, path);
+            for (const [configName, entriesByOption] of entriesByOptionByConfig.entries()) {
+                for (const entries of entriesByOption.values()) {
+                    for (const entry of entries) {
+                        inputs.add(targetName === BUILD_TARGET_NAME && configName === PRODUCTION_CONFIG_NAME
+                            ? toProductionEntry(normalizePath(entry))
+                            : toEntry(normalizePath(entry)));
                     }
                 }
             }
-            if (configs) {
-                for (const [configName, config] of Object.entries(configs)) {
-                    const isProductionConfig = configName === 'production';
-                    if ('fileReplacements' in config && config.fileReplacements && Array.isArray(config.fileReplacements)) {
-                        for (const fileReplacedBy of filesReplacedBy(config.fileReplacements)) {
-                            inputs.add(isProductionConfig ? toProductionEntry(fileReplacedBy) : toEntry(fileReplacedBy));
-                        }
-                    }
+            for (const [option, entries] of defaultEntriesByOption.entries()) {
+                for (const entry of entries) {
+                    inputs.add(targetName === BUILD_TARGET_NAME && !productionEntriesByOption.get(option)?.length
+                        ? toProductionEntry(normalizePath(entry))
+                        : toEntry(normalizePath(entry)));
+                }
+            }
+            if (target.builder === '@angular-devkit/build-angular:karma' && opts) {
+                const karmaBuilderOptions = opts;
+                const testFilePatterns = karmaBuilderOptions.include ?? ['**/*.spec.ts'];
+                for (const testFilePattern of testFilePatterns) {
+                    inputs.add(toEntry(testFilePattern));
+                }
+                const excludedTestFilePatterns = karmaBuilderOptions.exclude ?? [];
+                for (const excludedTestFilePattern of excludedTestFilePatterns) {
+                    inputs.add(toEntry(`!${excludedTestFilePattern}`));
+                }
+                const karmaConfig = karmaBuilderOptions.karmaConfig;
+                if (!karmaConfig) {
+                    karma
+                        .inputsFromPlugins(['karma-jasmine', 'karma-chrome-launcher', 'karma-jasmine-html-reporter', 'karma-coverage'], options.manifest.devDependencies)
+                        .forEach(inputs.add, inputs);
+                    karma.inputsFromFrameworks(['jasmine']).forEach(inputs.add, inputs);
+                }
+                if (karmaConfig && !karma.configFiles.includes(karmaConfig)) {
+                    inputs.add(toConfig('karma', karmaConfig, options.configFilePath));
                 }
             }
         }
     }
     return Array.from(inputs);
 };
-const filesReplacedBy = (fileReplacements) => fileReplacements.map(fileReplacement => 'with' in fileReplacement ? fileReplacement.with : fileReplacement.replaceWith);
+const entriesByOption = (opts) => new Map(Object.entries({
+    main: 'main' in opts && opts.main && typeof opts.main === 'string' ? [opts.main] : [],
+    scripts: 'scripts' in opts && opts.scripts && Array.isArray(opts.scripts)
+        ? opts.scripts.map(scriptStringOrObject => typeof scriptStringOrObject === 'string' ? scriptStringOrObject : scriptStringOrObject.input)
+        : [],
+    fileReplacements: 'fileReplacements' in opts && opts.fileReplacements && Array.isArray(opts.fileReplacements)
+        ? opts.fileReplacements.map(fileReplacement => 'with' in fileReplacement ? fileReplacement.with : fileReplacement.replaceWith)
+        : [],
+    browser: 'browser' in opts && opts.browser && typeof opts.browser === 'string' ? [opts.browser] : [],
+    server: 'server' in opts && opts.server && typeof opts.server === 'string' ? [opts.server] : [],
+    ssrEntry: 'ssr' in opts &&
+        opts.ssr &&
+        typeof opts.ssr === 'object' &&
+        'entry' in opts.ssr &&
+        typeof opts.ssr.entry === 'string'
+        ? [opts.ssr.entry]
+        : [],
+}));
+const PRODUCTION_CONFIG_NAME = 'production';
+const BUILD_TARGET_NAME = 'build';
 export default {
     title,
     enablers,

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

@@ -1,5 +1,5 @@
 type FileVersion = number;
-type Project = Project1 & {
+export type Project = Project1 & {
     cli?: {
         [k: string]: unknown;
     };
@@ -869,7 +869,7 @@ interface ExtractI18NTarget1 {
     outputPath?: string;
     outFile?: string;
 }
-interface KarmaTarget {
+export interface KarmaTarget {
     main?: string;
     tsConfig: string;
     karmaConfig?: string;

package/dist/plugins/capacitor/index.js

@@ -11,7 +11,7 @@ const resolveConfig = async (config, { configFileDir }) => {
     const plugins = config.includePlugins ?? [];
     const android = (await exists('android/capacitor.settings.gradle')) ? ['@capacitor/android'] : [];
     const ios = (await exists('ios/App/Podfile')) ? ['@capacitor/ios'] : [];
-    return [...plugins, ...android, ...ios].map(toDependency);
+    return [...plugins, ...android, ...ios].map(id => toDependency(id));
 };
 export default {
     title,

package/dist/plugins/changesets/index.js

@@ -10,7 +10,7 @@ const resolveConfig = config => {
         ? [config.changelog[0]]
         : typeof config.changelog === 'string'
             ? [config.changelog]
-            : []).map(toDependency);
+            : []).map(id => toDependency(id));
 };
 export default {
     title,

package/dist/plugins/commitlint/index.js

@@ -21,7 +21,7 @@ const resolveConfig = async (config) => {
                 ? [parserPreset.path ?? parserPreset]
                 : []
         : [];
-    return [...extendsConfigs, ...plugins, ...formatter, ...parserPresetPaths].map(toDependency);
+    return [...extendsConfigs, ...plugins, ...formatter, ...parserPresetPaths].map(id => toDependency(id));
 };
 export default {
     title,

package/dist/plugins/dependency-cruiser/index.d.ts

@@ -0,0 +1,12 @@
+import type { IsPluginEnabled } from '../../types/config.js';
+declare const _default: {
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    args: {
+        binaries: string[];
+        config: boolean;
+    };
+};
+export default _default;

package/dist/plugins/dependency-cruiser/index.js

@@ -0,0 +1,16 @@
+import { hasDependency } from '../../util/plugin.js';
+const title = 'dependency-cruiser';
+const enablers = ['dependency-cruiser'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['.dependency-cruiser.{js,cjs,mjs,json}'];
+const args = {
+    binaries: ['depcruise', 'dependency-cruise', 'dependency-cruiser', 'depcruise-baseline'],
+    config: true,
+};
+export default {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    args,
+};

package/dist/plugins/expo/helpers.js

@@ -9,7 +9,7 @@ export const getDependencies = async (expoConfig, { manifest }) => {
         return getPackageNameFromModuleSpecifier(pluginName);
     })
         .filter(Boolean) ?? [];
-    const inputs = new Set(pluginPackages.map(toDependency));
+    const inputs = new Set(pluginPackages.map(id => toDependency(id)));
     const allowedPackages = ['expo-atlas', 'expo-dev-client'];
     const allowedProductionPackages = ['expo-insights'];
     const manifestDependencies = Object.keys(manifest.dependencies ?? {});

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

@@ -1,5 +1,8 @@
 import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '../../types/config.js';
 import type { ExpoConfig } from './types.js';
+export declare const docs: {
+    production: string[];
+};
 declare const _default: {
     title: string;
     enablers: string[];

package/dist/plugins/expo/index.js

@@ -6,21 +6,23 @@ const title = 'Expo';
 const enablers = ['expo'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['app.json', 'app.config.{ts,js}'];
+const production = ['app/**/*.{js,jsx,ts,tsx}', 'src/app/**/*.{js,jsx,ts,tsx}'];
+export const docs = { production };
 const resolveEntryPaths = async (expoConfig, { manifest }) => {
     const config = 'expo' in expoConfig ? expoConfig.expo : expoConfig;
-    let production = [];
+    let patterns = [];
     if (manifest.main === 'expo-router/entry') {
-        production = ['app/**/*.{js,jsx,ts,tsx}', 'src/app/**/*.{js,jsx,ts,tsx}'];
+        patterns = [...production];
         const normalizedPlugins = config.plugins?.map(plugin => (Array.isArray(plugin) ? plugin : [plugin])) ?? [];
         const expoRouterPlugin = normalizedPlugins.find(([plugin]) => plugin === 'expo-router');
         if (expoRouterPlugin) {
             const [, options] = expoRouterPlugin;
             if (typeof options?.root === 'string') {
-                production = [join(options.root, '**/*.{js,jsx,ts,tsx}')];
+                patterns = [join(options.root, '**/*.{js,jsx,ts,tsx}')];
             }
         }
     }
-    return production.map(entry => toProductionEntry(entry));
+    return patterns.map(entry => toProductionEntry(entry));
 };
 const resolveConfig = async (expoConfig, options) => getDependencies(expoConfig, options);
 export default {

package/dist/plugins/gatsby/index.js

@@ -26,7 +26,7 @@ const resolveConfig = async (localConfig, options) => {
         if (typeof _config.onCreateBabelConfig === 'function') {
             _config.onCreateBabelConfig({ actions });
         }
-        return Array.from(plugins).map(toDependency);
+        return Array.from(plugins).map(id => toDependency(id));
     }
     return [];
 };

package/dist/plugins/graphql-codegen/index.js

@@ -48,7 +48,7 @@ const resolveConfig = config => {
             return [];
         if (isInternal(plugin))
             return [toEntry(plugin)];
-        return [plugin.includes('codegen-') ? plugin : `@graphql-codegen/${plugin}`].map(toDependency);
+        return [plugin.includes('codegen-') ? plugin : `@graphql-codegen/${plugin}`].map(id => toDependency(id));
     });
     return [...presets, ...flatPlugins, ...nestedPlugins].map(id => (typeof id === 'string' ? toDependency(id) : id));
 };

package/dist/plugins/index.d.ts

@@ -94,6 +94,16 @@ export declare const Plugins: {
         resolveEntryPaths: import("../types/config.js").ResolveEntryPaths;
         resolveConfig: import("../types/config.js").ResolveConfig<import("./cypress/types.js").CypressConfig>;
     };
+    'dependency-cruiser': {
+        title: string;
+        enablers: string[];
+        isEnabled: import("../types/config.js").IsPluginEnabled;
+        config: string[];
+        args: {
+            binaries: string[];
+            config: boolean;
+        };
+    };
     dotenv: {
         title: string;
         args: {
@@ -184,6 +194,9 @@ export declare const Plugins: {
         entry: string[];
         resolveEntryPaths: import("../types/config.js").ResolveEntryPaths<import("./jest/types.js").JestConfig>;
         resolveConfig: import("../types/config.js").ResolveConfig<import("./jest/types.js").JestConfig>;
+        args: {
+            config: boolean;
+        };
     };
     karma: {
         title: string;
@@ -191,8 +204,8 @@ export declare const Plugins: {
         isEnabled: import("../types/config.js").IsPluginEnabled;
         config: string[];
         entry: string[];
-        resolveConfig: import("../types/config.js").ResolveConfig<(config: import("./karma/types.js").Config) => void>;
-        resolveEntryPaths: import("../types/config.js").ResolveEntryPaths<(config: import("./karma/types.js").Config) => void>;
+        resolveConfig: import("../types/config.js").ResolveConfig<import("./karma/helpers.js").ConfigFile>;
+        resolveEntryPaths: import("../types/config.js").ResolveEntryPaths<import("./karma/helpers.js").ConfigFile>;
     };
     ladle: {
         title: string;
@@ -225,7 +238,7 @@ export declare const Plugins: {
         isEnabled: import("../types/config.js").IsPluginEnabled;
         packageJsonPath: string;
         config: string[];
-        resolveConfig: import("../types/config.js").ResolveConfig<import("./linthtml/types.js").PluginConfig>;
+        resolveConfig: import("../types/config.js").ResolveConfig<import("./linthtml/types.js").LintHTMLConfig>;
     };
     'lockfile-lint': {
         title: string;
@@ -246,6 +259,14 @@ export declare const Plugins: {
         config: string[];
         resolveConfig: import("../types/config.js").ResolveConfig<import("./markdownlint/types.js").MarkdownlintConfig>;
     };
+    metro: {
+        title: string;
+        enablers: string[];
+        isEnabled: import("../types/config.js").IsPluginEnabled;
+        config: string[];
+        resolveEntryPaths: import("../types/config.js").ResolveEntryPaths<import("./metro/types.js").MetroConfig>;
+        resolveConfig: import("../types/config.js").ResolveConfig<import("./metro/types.js").MetroConfig>;
+    };
     mocha: {
         title: string;
         enablers: string[];
@@ -329,7 +350,6 @@ export declare const Plugins: {
     };
     nuxt: {
         title: string;
-        note: string;
         enablers: string[];
         isEnabled: import("../types/config.js").IsPluginEnabled;
         entry: string[];
@@ -441,7 +461,6 @@ export declare const Plugins: {
         title: string;
         enablers: string[];
         isEnabled: import("../types/config.js").IsPluginEnabled;
-        packageJsonPath: string;
         config: string[];
         resolveConfig: import("../types/config.js").ResolveConfig<import("./release-it/types.js").ReleaseItConfig>;
     };
@@ -500,9 +519,8 @@ export declare const Plugins: {
         title: string;
         enablers: string[];
         isEnabled: import("../types/config.js").IsPluginEnabled;
-        packageJsonPath: string;
         config: string[];
-        resolveConfig: import("../types/config.js").ResolveConfig<import("./simple-git-hooks/types.js").PluginConfig>;
+        resolveConfig: import("../types/config.js").ResolveConfig<import("./simple-git-hooks/types.js").SimpleGitHooksConfig>;
     };
     'size-limit': {
         title: string;
@@ -611,7 +629,6 @@ export declare const Plugins: {
         enablers: string[];
         isEnabled: import("../types/config.js").IsPluginEnabled;
         config: string[];
-        production: string[];
         resolveConfig: import("../types/config.js").ResolveConfig<import("type-fest").TsConfigJson>;
         args: {
             binaries: string[];
@@ -652,7 +669,6 @@ export declare const Plugins: {
         enablers: string[];
         isEnabled: import("../types/config.js").IsPluginEnabled;
         config: string[];
-        production: string[];
         resolveEntryPaths: import("../types/config.js").ResolveEntryPaths<import("./vitest/types.js").ViteConfigOrFn | import("./vitest/types.js").VitestWorkspaceConfig>;
         resolveConfig: import("../types/config.js").ResolveConfig<import("./vitest/types.js").ViteConfigOrFn | import("./vitest/types.js").VitestWorkspaceConfig>;
     };
@@ -687,14 +703,16 @@ export declare const Plugins: {
         enablers: string[];
         isEnabled: import("../types/config.js").IsPluginEnabled;
         config: string[];
-        production: string[];
         resolveConfig: import("../types/config.js").ResolveConfig<import("./webpack/types.js").WebpackConfig>;
+        args: {
+            binaries: string[];
+            config: boolean;
+        };
     };
     wireit: {
         title: string;
         enablers: string[];
         isEnabled: import("../types/config.js").IsPluginEnabled;
-        packageJsonPath: string;
         config: string[];
         resolveConfig: import("../types/config.js").ResolveConfig<import("./wireit/types.js").WireitConfig>;
     };

package/dist/plugins/index.js

@@ -10,6 +10,7 @@ import { default as commitlint } from './commitlint/index.js';
 import { default as cspell } from './cspell/index.js';
 import { default as cucumber } from './cucumber/index.js';
 import { default as cypress } from './cypress/index.js';
+import { default as dependencyCruiser } from './dependency-cruiser/index.js';
 import { default as dotenv } from './dotenv/index.js';
 import { default as drizzle } from './drizzle/index.js';
 import { default as eleventy } from './eleventy/index.js';
@@ -29,6 +30,7 @@ import { default as linthtml } from './linthtml/index.js';
 import { default as lockfileLint } from './lockfile-lint/index.js';
 import { default as lostPixel } from './lost-pixel/index.js';
 import { default as markdownlint } from './markdownlint/index.js';
+import { default as metro } from './metro/index.js';
 import { default as mocha } from './mocha/index.js';
 import { default as moonrepo } from './moonrepo/index.js';
 import { default as msw } from './msw/index.js';
@@ -100,6 +102,7 @@ export const Plugins = {
     cspell,
     cucumber,
     cypress,
+    'dependency-cruiser': dependencyCruiser,
     dotenv,
     drizzle,
     eleventy,
@@ -119,6 +122,7 @@ export const Plugins = {
     'lockfile-lint': lockfileLint,
     'lost-pixel': lostPixel,
     markdownlint,
+    metro,
     mocha,
     moonrepo,
     msw,

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

@@ -8,5 +8,8 @@ declare const _default: {
     entry: string[];
     resolveEntryPaths: ResolveEntryPaths<JestConfig>;
     resolveConfig: ResolveConfig<JestConfig>;
+    args: {
+        config: boolean;
+    };
 };
 export default _default;

package/dist/plugins/jest/index.js

@@ -95,6 +95,9 @@ const resolveConfig = async (localConfig, options) => {
     });
     return result;
 };
+const args = {
+    config: true,
+};
 export default {
     title,
     enablers,
@@ -103,4 +106,5 @@ export default {
     entry,
     resolveEntryPaths,
     resolveConfig,
+    args,
 };

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

@@ -0,0 +1,7 @@
+import { type Input } from '../../util/input.js';
+import type { Config, ConfigOptions } from './types.js';
+export declare const configFiles: string[];
+export declare const inputsFromFrameworks: (frameworks: readonly string[]) => readonly Input[];
+export declare const inputsFromPlugins: (plugins: ConfigOptions["plugins"], devDependencies: Record<string, string> | undefined) => readonly Input[];
+export type ConfigFile = (config: Config) => void;
+export declare const loadConfig: (configFile: ConfigFile) => ConfigOptions | undefined;

package/dist/plugins/karma/helpers.js

@@ -0,0 +1,32 @@
+import { toDeferResolveEntry, toDevDependency } from '../../util/input.js';
+import { isInternal } from '../../util/path.js';
+export const configFiles = ['karma.conf.js', 'karma.conf.ts', '.config/karma.conf.js', '.config/karma.conf.ts'];
+export const inputsFromFrameworks = (frameworks) => frameworks.map(framework => {
+    return toDevDependency(framework === 'jasmine' ? 'jasmine-core' : framework);
+});
+export const inputsFromPlugins = (plugins, devDependencies) => {
+    if (!plugins) {
+        const karmaPluginDevDeps = Object.keys(devDependencies ?? {}).filter(name => name.startsWith('karma-'));
+        return karmaPluginDevDeps.map(karmaPluginDevDep => toDevDependency(karmaPluginDevDep));
+    }
+    return plugins
+        .map(plugin => {
+        if (typeof plugin !== 'string')
+            return;
+        return isInternal(plugin) ? toDeferResolveEntry(plugin) : toDevDependency(plugin);
+    })
+        .filter(input => !!input);
+};
+export const loadConfig = (configFile) => {
+    if (typeof configFile !== 'function')
+        return;
+    const inMemoryConfig = new InMemoryConfig();
+    configFile(inMemoryConfig);
+    return inMemoryConfig.config ?? {};
+};
+class InMemoryConfig {
+    config;
+    set(config) {
+        this.config = config;
+    }
+}

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

@@ -1,6 +1,5 @@
 import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '../../types/config.js';
-import type { Config } from './types.js';
-type ConfigFile = (config: Config) => void;
+import { type ConfigFile } from './helpers.js';
 declare const _default: {
     title: string;
     enablers: string[];