knip 5.41.0 → 5.42.0

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[];

package/dist/plugins/karma/index.js

@@ -1,43 +1,28 @@
-import { toDeferResolveEntry, toDevDependency, toEntry } from '../../util/input.js';
-import { isInternal, join } from '../../util/path.js';
+import { toEntry } from '../../util/input.js';
+import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
+import { configFiles, inputsFromFrameworks, inputsFromPlugins, loadConfig } from './helpers.js';
 const title = 'Karma';
 const enablers = ['karma'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['karma.conf.js', 'karma.conf.ts', '.config/karma.conf.js', '.config/karma.conf.ts'];
+const config = configFiles;
 const entry = [];
 const resolveConfig = async (localConfig, options) => {
     const inputs = new Set();
     const config = loadConfig(localConfig);
+    if (!config)
+        return [];
     if (config.frameworks) {
-        for (const framework of config.frameworks) {
-            inputs.add(toDevDependency(devDepForFramework(framework)));
-        }
-    }
-    if (config.plugins) {
-        for (const plugin of config.plugins) {
-            if (typeof plugin !== 'string')
-                continue;
-            if (isInternal(plugin)) {
-                inputs.add(toDeferResolveEntry(plugin));
-            }
-            else {
-                inputs.add(toDevDependency(plugin));
-            }
-        }
-    }
-    else {
-        const karmaPluginDevDeps = Object.keys(options.manifest.devDependencies ?? {}).filter(name => name.startsWith('karma-'));
-        for (const karmaPluginDevDep of karmaPluginDevDeps) {
-            inputs.add(toDevDependency(karmaPluginDevDep));
-        }
+        inputsFromFrameworks(config.frameworks).forEach(inputs.add, inputs);
     }
+    inputsFromPlugins(config.plugins, options.manifest.devDependencies).forEach(inputs.add, inputs);
     return Array.from(inputs);
 };
-const devDepForFramework = (framework) => (framework === 'jasmine' ? 'jasmine-core' : framework);
 const resolveEntryPaths = (localConfig, options) => {
     const inputs = new Set();
     const config = loadConfig(localConfig);
+    if (!config)
+        return [];
     const basePath = config.basePath ?? '';
     if (config.files) {
         for (const fileOrPatternObj of config.files) {
@@ -52,17 +37,6 @@ const resolveEntryPaths = (localConfig, options) => {
     }
     return Array.from(inputs);
 };
-const loadConfig = (configFile) => {
-    const inMemoryConfig = new InMemoryConfig();
-    configFile(inMemoryConfig);
-    return inMemoryConfig.config ?? {};
-};
-class InMemoryConfig {
-    config;
-    set(config) {
-        this.config = config;
-    }
-}
 export default {
     title,
     enablers,

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

@@ -1,11 +1,11 @@
 import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
-import type { PluginConfig } from './types.js';
+import type { LintHTMLConfig } from './types.js';
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     packageJsonPath: string;
     config: string[];
-    resolveConfig: ResolveConfig<PluginConfig>;
+    resolveConfig: ResolveConfig<LintHTMLConfig>;
 };
 export default _default;

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

@@ -1,4 +1,4 @@
-export type PluginConfig = {
+export type LintHTMLConfig = {
     extends?: string | string[];
     plugins?: string[];
 };

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

@@ -0,0 +1,15 @@
+import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '../../types/config.js';
+import type { MetroConfig } from './types.js';
+export declare const docs: {
+    production: string[];
+};
+declare const _default: {
+    title: string;
+    note: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    resolveEntryPaths: ResolveEntryPaths<MetroConfig>;
+    resolveConfig: ResolveConfig<MetroConfig>;
+};
+export default _default;

package/dist/plugins/metro/index.js

@@ -0,0 +1,48 @@
+import { compact } from '../../util/array.js';
+import { toDeferResolve, toProductionEntry } from '../../util/input.js';
+import { join } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+const title = 'Metro';
+const note = `False positives for platform-specific unused files?
+Override the entry patterns as shown below to match platforms and extensions.`;
+const enablers = ['metro', 'react-native'];
+const isEnabled = options => hasDependency(options.dependencies, enablers);
+const config = ['metro.config.{js,cjs,json}', 'package.json'];
+const DEFAULT_PLATFORMS = ['ios', 'android', 'windows', 'web'];
+const PLATFORMS = [...DEFAULT_PLATFORMS, 'native', 'default'];
+const DEFAULT_EXTENSIONS = ['js', 'jsx', 'json', 'ts', 'tsx'];
+const production = [`src/**/*.{${PLATFORMS.join(',')}}.{${DEFAULT_EXTENSIONS.join(',')}}`];
+export const docs = { production };
+const resolveEntryPaths = async (config) => {
+    const platformEntryPatterns = compact(PLATFORMS.concat(config.resolver?.platforms ?? []));
+    const sourceExts = config.resolver?.sourceExts ?? DEFAULT_EXTENSIONS;
+    const pattern = `src/**/*.{${platformEntryPatterns.join(',')}}.{${sourceExts.join(',')}}`;
+    if (!config.projectRoot)
+        return [toProductionEntry(pattern)];
+    const entryFilePattern = 'index.{js,jsx,ts,tsx}';
+    const entryFilePath = join(config.projectRoot, entryFilePattern);
+    const entryFilePaths = join(config.projectRoot, pattern);
+    return [toProductionEntry(entryFilePath), toProductionEntry(entryFilePaths)];
+};
+const resolveConfig = async (config) => {
+    const { transformerPath, transformer } = config;
+    const inputs = [];
+    if (transformerPath)
+        inputs.push(transformerPath);
+    if (transformer?.assetPlugins)
+        inputs.push(...transformer.assetPlugins);
+    if (transformer?.minifierPath)
+        inputs.push(transformer.minifierPath);
+    if (transformer?.babelTransformerPath)
+        inputs.push(transformer.babelTransformerPath);
+    return [...inputs].map(toDeferResolve);
+};
+export default {
+    title,
+    note,
+    enablers,
+    isEnabled,
+    config,
+    resolveEntryPaths,
+    resolveConfig,
+};

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

@@ -0,0 +1,13 @@
+export type MetroConfig = {
+    projectRoot?: string;
+    transformerPath?: string;
+    transformer?: {
+        minifierPath?: string;
+        assetPlugins?: string[];
+        babelTransformerPath?: string;
+    };
+    resolver?: {
+        platforms?: string[];
+        sourceExts?: string[];
+    };
+};

package/dist/plugins/metro/types.js

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

package/dist/plugins/nx/index.js

@@ -35,8 +35,16 @@ const resolveConfig = async (localConfig, options) => {
         .filter(executor => executor && !executor.startsWith('.'))
         .map(executor => executor?.split(':')[0]);
     const scripts = targets
-        .filter(target => target.executor === 'nx:run-commands')
-        .flatMap(target => target.options?.commands ?? (target.options?.command ? [target.options.command] : []));
+        .filter(target => target.executor === 'nx:run-commands' || target.command)
+        .flatMap(target => {
+        if (target.command)
+            return [target.command];
+        if (target.options?.command)
+            return [target.options.command];
+        if (target.options?.commands)
+            return target.options.commands;
+        return [];
+    });
     const inputs = options.getInputsFromScripts(scripts);
     return compact([...executors, ...inputs]).map(id => (typeof id === 'string' ? toDependency(id) : id));
 };

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

@@ -1,6 +1,7 @@
 export interface NxProjectConfiguration {
     targets?: {
         [targetName: string]: {
+            command?: string;
             executor?: string;
             options?: {
                 command?: string;

package/dist/plugins/release-it/index.d.ts

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

package/dist/plugins/release-it/index.js

@@ -3,7 +3,6 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Release It!';
 const enablers = ['release-it'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const packageJsonPath = 'release-it';
 const config = ['.release-it.{json,js,cjs,ts,yml,yaml,toml}', 'package.json'];
 const resolveConfig = (config, options) => {
     const plugins = config.plugins ? Object.keys(config.plugins) : [];
@@ -21,7 +20,6 @@ export default {
     title,
     enablers,
     isEnabled,
-    packageJsonPath,
     config,
     resolveConfig,
 };

package/dist/plugins/simple-git-hooks/index.d.ts

@@ -1,11 +1,10 @@
 import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
-import type { PluginConfig } from './types.js';
+import type { SimpleGitHooksConfig } from './types.js';
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
-    packageJsonPath: string;
     config: string[];
-    resolveConfig: ResolveConfig<PluginConfig>;
+    resolveConfig: ResolveConfig<SimpleGitHooksConfig>;
 };
 export default _default;

package/dist/plugins/simple-git-hooks/index.js

@@ -2,14 +2,7 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'simple-git-hooks';
 const enablers = ['simple-git-hooks'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const packageJsonPath = 'simple-git-hooks';
-const config = [
-    '.simple-git-hooks.{js,cjs}',
-    'simple-git-hooks.{js,cjs}',
-    '.simple-git-hooks.json',
-    'simple-git-hooks.json',
-    'package.json',
-];
+const config = ['.simple-git-hooks.{js,cjs,json}', 'simple-git-hooks.{js,cjs,json}', 'package.json'];
 const resolveConfig = async (config, options) => {
     if (typeof config === 'function')
         config = config();
@@ -26,7 +19,6 @@ export default {
     title,
     enablers,
     isEnabled,
-    packageJsonPath,
     config,
     resolveConfig,
 };

package/dist/plugins/simple-git-hooks/types.d.ts

@@ -1,3 +1,3 @@
 type Config = Record<string, string>;
-export type PluginConfig = Config | (() => Config);
+export type SimpleGitHooksConfig = Config | (() => Config);
 export {};

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

@@ -5,7 +5,6 @@ declare const _default: {
     enablers: string[];
     isEnabled: IsPluginEnabled;
     config: string[];
-    production: string[];
     resolveConfig: ResolveConfig<TsConfigJson>;
     args: {
         binaries: string[];

package/dist/plugins/typescript/index.js

@@ -6,7 +6,6 @@ const title = 'TypeScript';
 const enablers = ['typescript'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['tsconfig.json'];
-const production = [];
 const resolveConfig = async (localConfig, options) => {
     const { compilerOptions } = localConfig;
     const extend = localConfig.extends
@@ -36,7 +35,6 @@ export default {
     enablers,
     isEnabled,
     config,
-    production,
     resolveConfig,
     args,
 };

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

@@ -5,7 +5,6 @@ declare const _default: {
     enablers: string[];
     isEnabled: 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>;
 };

package/dist/plugins/vite/index.js

@@ -4,13 +4,11 @@ const title = 'Vite';
 const enablers = ['vite', 'vitest'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 export const config = ['vite.config.{js,mjs,ts,cjs,mts,cts}'];
-const production = [];
 export default {
     title,
     enablers,
     isEnabled,
     config,
-    production,
     resolveEntryPaths,
     resolveConfig,
 };

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

@@ -10,7 +10,10 @@ declare const _default: {
     enablers: string[];
     isEnabled: IsPluginEnabled;
     config: string[];
-    production: string[];
     resolveConfig: ResolveConfig<WebpackConfig>;
+    args: {
+        binaries: string[];
+        config: boolean;
+    };
 };
 export default _default;

package/dist/plugins/webpack/index.js

@@ -7,7 +7,6 @@ const title = 'webpack';
 const enablers = ['webpack', 'webpack-cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['webpack.config.{js,ts,mjs,cjs,mts,cts}'];
-const production = [];
 const hasBabelOptions = (use) => Boolean(use) &&
     typeof use !== 'string' &&
     'loader' in use &&
@@ -100,11 +99,15 @@ const resolveConfig = async (localConfig, options) => {
     const webpackDevServer = scripts.some(script => script?.includes('webpack serve')) ? ['webpack-dev-server'] : [];
     return compact([...inputs, [...webpackCLI, ...webpackDevServer].map(toDevDependency)].flat());
 };
+const args = {
+    binaries: ['webpack', 'webpack-dev-server'],
+    config: true,
+};
 export default {
     title,
     enablers,
     isEnabled,
     config,
-    production,
     resolveConfig,
+    args,
 };

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

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

package/dist/plugins/wireit/index.js

@@ -2,7 +2,6 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Wireit';
 const enablers = ['wireit'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const packageJsonPath = 'wireit';
 const config = ['package.json'];
 const resolveConfig = (localConfig, options) => {
     const scripts = Object.values(localConfig).flatMap(({ command: script }) => (script ? [script] : []));
@@ -13,7 +12,6 @@ export default {
     title,
     enablers,
     isEnabled,
-    packageJsonPath,
     config,
     resolveConfig,
 };

package/dist/reporters/symbols.js

@@ -7,11 +7,15 @@ const dim = picocolors.gray;
 const bright = picocolors.whiteBright;
 const TRUNCATE_WIDTH = 40;
 const truncate = (text) => (text.length > TRUNCATE_WIDTH ? `${text.slice(0, TRUNCATE_WIDTH - 3)}...` : text);
+const truncateStart = (text, width) => (text.length > width ? `...${text.slice(-(width - 3))}` : text);
 const hl = (issue) => {
     if (issue.specifier && issue.specifier !== issue.symbol && issue.specifier.includes(issue.symbol)) {
         const parts = issue.specifier.split(issue.symbol);
-        const rest = parts.slice(1).join('');
-        return [dim(parts[0]), bright(issue.symbol), dim(rest)].join('');
+        const right = parts.slice(1).join('');
+        const max = TRUNCATE_WIDTH - issue.symbol.length - right.length;
+        const part = parts[0];
+        const left = part.length > 3 ? (max <= 3 ? `...${part.slice(-3)}` : truncateStart(part, max)) : part;
+        return [dim(left), bright(issue.symbol), dim(right)].join('');
     }
     return issue.symbol;
 };

package/dist/schema/plugins.d.ts

@@ -417,6 +417,19 @@ export declare const pluginsSchema: z.ZodObject<{
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     }>]>;
+    metro: 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;
+    }>]>;
     mocha: 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">]>>;
@@ -1332,6 +1345,11 @@ export declare const pluginsSchema: z.ZodObject<{
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     };
+    metro: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    };
     mocha: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -1778,6 +1796,11 @@ export declare const pluginsSchema: z.ZodObject<{
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     };
+    metro: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    };
     mocha: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;

package/dist/schema/plugins.js

@@ -41,6 +41,7 @@ export const pluginsSchema = z.object({
     'lockfile-lint': pluginSchema,
     'lost-pixel': pluginSchema,
     markdownlint: pluginSchema,
+    metro: pluginSchema,
     mocha: pluginSchema,
     moonrepo: pluginSchema,
     msw: 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' | 'dotenv' | 'drizzle' | 'eleventy' | 'eslint' | 'expo' | 'gatsby' | 'github-actions' | 'glob' | 'graphql-codegen' | 'husky' | 'jest' | 'karma' | 'ladle' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lockfile-lint' | 'lost-pixel' | 'markdownlint' | 'mocha' | 'moonrepo' | 'msw' | 'nest' | 'netlify' | 'next' | 'node' | 'node-test-runner' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nx' | 'nyc' | 'oclif' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'postcss' | 'preconstruct' | 'prettier' | 'react-cosmos' | '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", "dotenv", "drizzle", "eleventy", "eslint", "expo", "gatsby", "github-actions", "glob", "graphql-codegen", "husky", "jest", "karma", "ladle", "lefthook", "lint-staged", "linthtml", "lockfile-lint", "lost-pixel", "markdownlint", "mocha", "moonrepo", "msw", "nest", "netlify", "next", "node", "node-test-runner", "nodemon", "npm-package-json-lint", "nuxt", "nx", "nyc", "oclif", "playwright", "playwright-ct", "playwright-test", "plop", "postcss", "preconstruct", "prettier", "react-cosmos", "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' | 'dotenv' | 'drizzle' | 'eleventy' | 'eslint' | 'expo' | 'gatsby' | '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' | 'node-test-runner' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nx' | 'nyc' | 'oclif' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'postcss' | 'preconstruct' | 'prettier' | 'react-cosmos' | '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", "dotenv", "drizzle", "eleventy", "eslint", "expo", "gatsby", "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", "node-test-runner", "nodemon", "npm-package-json-lint", "nuxt", "nx", "nyc", "oclif", "playwright", "playwright-ct", "playwright-test", "plop", "postcss", "preconstruct", "prettier", "react-cosmos", "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"];

package/dist/types/PluginNames.js

@@ -30,6 +30,7 @@ export const pluginNames = [
     'lockfile-lint',
     'lost-pixel',
     'markdownlint',
+    'metro',
     'mocha',
     'moonrepo',
     'msw',

package/dist/types/dependency-graph.d.ts

@@ -56,10 +56,8 @@ export type FileNode = {
         external: Set<string>;
         unresolved: Set<UnresolvedImport>;
     };
-    exports: {
-        exported: ExportMap;
-        duplicate: Iterable<Array<IssueSymbol>>;
-    };
+    exports: ExportMap;
+    duplicates: Iterable<Array<IssueSymbol>>;
     scripts: Set<string>;
     imported?: ImportDetails;
     internalImportCache?: ImportMap;

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

@@ -21,6 +21,7 @@ export declare const isDestructuring: (node: ts.Node) => boolean;
 export declare const getDestructuredIds: (name: ts.ObjectBindingPattern) => string[];
 export declare const isConsiderReferencedNS: (node: ts.Identifier) => boolean;
 export declare const isObjectEnumerationCallExpressionArgument: (node: ts.Identifier) => boolean;
+export declare const isInForIteration: (node: ts.Node) => boolean;
 export declare const isTopLevel: (node: ts.Node) => boolean;
 export declare const getTypeName: (node: ts.Identifier) => ts.QualifiedName | undefined;
 export declare const isImportSpecifier: (node: ts.Node) => boolean;

package/dist/typescript/ast-helpers.js

@@ -148,6 +148,7 @@ export const isObjectEnumerationCallExpressionArgument = (node) => ts.isCallExpr
     ts.isIdentifier(node.parent.expression.expression) &&
     node.parent.expression.expression.escapedText === 'Object' &&
     objectEnumerationMethods.has(String(node.parent.expression.name.escapedText));
+export const isInForIteration = (node) => node.parent && (ts.isForInStatement(node.parent) || ts.isForOfStatement(node.parent));
 export const isTopLevel = (node) => ts.isSourceFile(node.parent) || (node.parent && ts.isSourceFile(node.parent.parent));
 export const getTypeName = (node) => {
     if (!node.parent?.parent)

package/dist/typescript/get-imports-and-exports.d.ts

@@ -11,10 +11,8 @@ export declare const _getImportsAndExports: (sourceFile: BoundSourceFile, resolv
         specifiers: Set<[string, string]>;
         unresolved: Set<UnresolvedImport>;
     };
-    exports: {
-        exported: ExportMap;
-        duplicate: IssueSymbol[][];
-    };
+    exports: ExportMap;
+    duplicates: IssueSymbol[][];
     scripts: Set<string>;
     traceRefs: Set<string>;
 };