knip 5.85.0 → 5.87.0

package/dist/plugins/nuxt/helpers.js

@@ -0,0 +1,133 @@
+import { createRequire } from 'node:module';
+import ts from 'typescript';
+import { scriptBodies } from "../../compilers/compilers.js";
+import { basename, dirname, isInNodeModules, join } from "../../util/path.js";
+export const getVueSfc = (cwd) => {
+    try {
+        return createRequire(join(cwd, 'package.json'))('vue/compiler-sfc');
+    }
+    catch { }
+    return {
+        parse: (source, path) => ({
+            descriptor: { script: { content: scriptBodies(source, path) }, scriptSetup: null, template: { content: '' } },
+        }),
+    };
+};
+export const createSourceFile = (filePath, contents) => {
+    const c = contents ?? ts.sys.readFile(filePath, 'utf8') ?? '';
+    return ts.createSourceFile(filePath, c, ts.ScriptTarget.Latest);
+};
+export const collectIdentifiers = (source, fileName) => {
+    const identifiers = new Set();
+    const sourceFile = createSourceFile(fileName, source);
+    const visit = (node) => {
+        if (ts.isIdentifier(node))
+            identifiers.add(node.text);
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return identifiers;
+};
+export const collectTemplateInfo = (tree) => {
+    const tags = new Set();
+    const identifiers = new Set();
+    const addExprIdentifiers = (expr) => {
+        for (const id of collectIdentifiers(expr, 'expr.ts'))
+            identifiers.add(id);
+    };
+    const visit = (node) => {
+        if (node.tag)
+            tags.add(node.tag);
+        if (node.type === 5 && node.content && !node.content.isStatic)
+            addExprIdentifiers(node.content.content);
+        if (node.props) {
+            for (const prop of node.props) {
+                if (prop.type === 7) {
+                    if (prop.exp && !prop.exp.isStatic)
+                        addExprIdentifiers(prop.exp.content);
+                    if (prop.arg && !prop.arg.isStatic)
+                        addExprIdentifiers(prop.arg.content);
+                }
+            }
+        }
+        if (node.children)
+            for (const child of node.children)
+                visit(child);
+    };
+    visit(tree);
+    return { tags, identifiers };
+};
+export const toKebabCase = (s) => s.replace(/[A-Z]/g, (m, i) => (i ? '-' : '') + m.toLowerCase());
+const isLocalSpecifier = (specifier) => specifier.startsWith('.') && !isInNodeModules(specifier);
+export const collectLocalImportPaths = (sourceFile) => {
+    const dir = dirname(sourceFile.fileName);
+    const paths = new Set();
+    const visit = (node) => {
+        if (ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument) && ts.isStringLiteral(node.argument.literal)) {
+            const specifier = node.argument.literal.text;
+            if (isLocalSpecifier(specifier))
+                paths.add(join(dir, specifier));
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return paths;
+};
+export function buildAutoImportMap(sourceFile) {
+    const dir = dirname(sourceFile.fileName);
+    const isComponents = basename(sourceFile.fileName) === 'components.d.ts';
+    const importMap = new Map();
+    const componentMap = new Map();
+    function visit(node) {
+        if (ts.isVariableStatement(node)) {
+            if (node.declarationList.declarations.length === 0)
+                return;
+            const decl = node.declarationList.declarations[0];
+            if (!ts.isIdentifier(decl.name))
+                return;
+            const name = decl.name.text;
+            if (name.startsWith('Lazy'))
+                return;
+            if (!decl.type)
+                return;
+            const tNode = ts.isImportTypeNode(decl.type)
+                ? decl.type
+                : ts.isTypeQueryNode(decl.type)
+                    ? ts.isImportTypeNode(decl.type.exprName)
+                        ? decl.type.exprName
+                        : ts.isQualifiedName(decl.type.exprName) &&
+                            ts.isImportTypeNode(decl.type.exprName.left) &&
+                            decl.type.exprName.left
+                    : ts.isIndexedAccessTypeNode(decl.type) && ts.isImportTypeNode(decl.type.objectType) && decl.type.objectType;
+            if (!tNode || !ts.isLiteralTypeNode(tNode.argument) || !ts.isStringLiteral(tNode.argument.literal))
+                return;
+            const specifier = tNode.argument.literal.text;
+            if (!isLocalSpecifier(specifier))
+                return;
+            const absSpecifier = join(dir, specifier);
+            if (isComponents) {
+                const components = componentMap.get(name);
+                if (components)
+                    components.push(absSpecifier);
+                else
+                    componentMap.set(name, [absSpecifier]);
+            }
+            else {
+                importMap.set(name, absSpecifier);
+            }
+        }
+        else if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+            const specifier = node.moduleSpecifier.text;
+            if (!isLocalSpecifier(specifier))
+                return;
+            if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+                for (const element of node.exportClause.elements) {
+                    importMap.set(element.name.text, join(dir, specifier));
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    ts.forEachChild(sourceFile, visit);
+    return { importMap, componentMap };
+}

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

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

package/dist/plugins/nuxt/index.js

@@ -1,20 +1,30 @@
-import { toDependency, toProductionEntry } from '../../util/input.js';
-import { join } from '../../util/path.js';
-import { hasDependency } from '../../util/plugin.js';
+import { isDirectory } from "../../util/fs.js";
+import { _syncGlob } from "../../util/glob.js";
+import { toAlias, toConfig, toDeferResolveProductionEntry, toDependency, toEntry, toIgnore, toProductionEntry, } from "../../util/input.js";
+import { loadTSConfig } from "../../util/load-tsconfig.js";
+import { join } from "../../util/path.js";
+import { hasDependency } from "../../util/plugin.js";
+import { buildAutoImportMap, collectIdentifiers, collectLocalImportPaths, collectTemplateInfo, createSourceFile, getVueSfc, toKebabCase, } from "./helpers.js";
 const title = 'Nuxt';
-const enablers = ['nuxt'];
+const enablers = ['nuxt', 'nuxt-nightly'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['nuxt.config.{js,mjs,ts}'];
+const entry = ['app.config.ts', '**/*.d.vue.ts'];
+const app = ['app.{vue,jsx,tsx}', 'error.{vue,jsx,tsx}', 'router.options.ts'];
+const layout = (dir = 'layouts') => join(dir, '**/*.{vue,jsx,tsx}');
+const middleware = (dir = 'middleware') => join(dir, '**/*.ts');
+const pages = (dir = 'pages') => join(dir, '**/*.{vue,jsx,tsx}');
+const plugins = (dir = 'plugins') => join(dir, '**/*.ts');
+const modules = 'modules/**/*.{ts,vue}';
+const server = ['api/**/*.ts', 'middleware/**/*.ts', 'plugins/**/*.ts', 'routes/**/*.ts', 'tasks/**/*.ts'];
 const production = [
-    'app.{vue,jsx,tsx}',
-    'error.{vue,jsx,tsx}',
-    'pages/**/*.{vue,jsx,tsx}',
-    'layouts/default.{vue,jsx,tsx}',
-    'middleware/**/*.ts',
-    'server/api/**/*.ts',
-    'server/routes/**/*.ts',
-    'server/middleware/**/*.ts',
-    'server/plugins/**/*.ts',
+    ...app,
+    layout(),
+    middleware(),
+    pages(),
+    plugins(),
+    modules,
+    ...server.map(id => join('server', id)),
 ];
 const setup = async () => {
     if (globalThis && !('defineNuxtConfig' in globalThis)) {
@@ -25,38 +35,170 @@ const setup = async () => {
         });
     }
 };
-const resolveConfig = async (localConfig) => {
-    const srcDir = localConfig.srcDir ?? '.';
-    const patterns = [
-        'app.{vue,jsx,tsx}',
-        'error.{vue,jsx,tsx}',
-        join(typeof localConfig.dir?.pages === 'string' ? localConfig.dir.pages : 'pages', '**/*.{vue,jsx,tsx}'),
-        join(typeof localConfig.dir?.layouts === 'string' ? localConfig.dir.layouts : 'layouts', '**/*.{vue,jsx,tsx}'),
-        join(typeof localConfig.dir?.middleware === 'string' ? localConfig.dir.middleware : 'middleware', '**/*.ts'),
-        'server/api/**/*.ts',
-        'server/routes/**/*.ts',
-        'server/middleware/**/*.ts',
-        'server/plugins/**/*.ts',
-    ].map(pattern => toProductionEntry(join(srcDir, pattern)));
-    const deps = localConfig.modules?.reduce((acc, id) => {
+const resolveAlias = (specifier, srcDir, rootDir) => {
+    if (specifier.startsWith('~~/') || specifier.startsWith('@@/'))
+        return join(rootDir, specifier.slice(3));
+    if (specifier.startsWith('~/') || specifier.startsWith('@/'))
+        return join(srcDir, specifier.slice(2));
+    return specifier;
+};
+const addAppEntries = (inputs, srcDir, serverDir, config, dir) => {
+    for (const id of entry)
+        inputs.push(toEntry(join(srcDir, id)));
+    for (const id of app)
+        inputs.push(toProductionEntry(join(srcDir, id)));
+    inputs.push(toProductionEntry(join(srcDir, layout(config.dir?.layouts))));
+    inputs.push(toProductionEntry(join(srcDir, middleware(config.dir?.middleware))));
+    inputs.push(toProductionEntry(join(srcDir, pages(config.dir?.pages))));
+    inputs.push(toProductionEntry(join(srcDir, plugins(config.dir?.plugins))));
+    inputs.push(toProductionEntry(join(srcDir, 'components/global/**/*.{vue,jsx,tsx}')));
+    for (const id of server)
+        inputs.push(toProductionEntry(join(dir, serverDir, id)));
+    inputs.push(toProductionEntry(join(dir, modules)));
+    if (config.css)
+        for (const id of config.css)
+            inputs.push(toDeferResolveProductionEntry(resolveAlias(id, srcDir, dir)));
+};
+const findLayerConfigs = (cwd) => _syncGlob({ cwd, patterns: [`layers/*/${config.at(0)}`] });
+const registerCompilers = async ({ cwd, hasDependency, registerCompiler }) => {
+    if (hasDependency('nuxt') || hasDependency('nuxt-nightly')) {
+        const vueSfc = getVueSfc(cwd);
+        const importMap = new Map();
+        const componentMap = new Map();
+        const definitionFiles = [
+            '.nuxt/imports.d.ts',
+            '.nuxt/components.d.ts',
+            '.nuxt/types/nitro-routes.d.ts',
+            '.nuxt/types/nitro-imports.d.ts',
+        ];
+        for (const file of definitionFiles) {
+            const sourceFile = createSourceFile(join(cwd, file));
+            const maps = buildAutoImportMap(sourceFile);
+            for (const [id, specifier] of maps.importMap)
+                importMap.set(id, specifier);
+            for (const [id, components] of maps.componentMap) {
+                const store = componentMap.get(id);
+                if (store)
+                    store.push(...components);
+                else
+                    componentMap.set(id, [...components]);
+            }
+        }
+        const getSyntheticImports = (identifiers, templateTags) => {
+            const syntheticImports = [];
+            for (const [name, specifier] of importMap) {
+                if (identifiers.has(name))
+                    syntheticImports.push(`import { ${name} } from '${specifier}';`);
+            }
+            if (templateTags) {
+                for (const [name, specifiers] of componentMap) {
+                    const kebab = toKebabCase(name);
+                    if (templateTags.has(name) ||
+                        templateTags.has(kebab) ||
+                        templateTags.has(`Lazy${name}`) ||
+                        templateTags.has(`lazy-${kebab}`)) {
+                        syntheticImports.push(`import { default as ${name} } from '${specifiers[0]}';`);
+                        for (let i = 1; i < specifiers.length; i++)
+                            syntheticImports.push(`import '${specifiers[i]}';`);
+                    }
+                }
+            }
+            return syntheticImports;
+        };
+        const compiler = (source, path) => {
+            const { descriptor } = vueSfc.parse(source, path);
+            const scripts = [];
+            if (descriptor.script?.content)
+                scripts.push(descriptor.script.content);
+            if (descriptor.scriptSetup?.content)
+                scripts.push(descriptor.scriptSetup.content);
+            const identifiers = collectIdentifiers(scripts.join('\n'), path);
+            let templateTags;
+            if (descriptor.template?.ast) {
+                const info = collectTemplateInfo(descriptor.template.ast);
+                templateTags = info.tags;
+                for (const id of info.identifiers)
+                    identifiers.add(id);
+            }
+            const synthetic = getSyntheticImports(identifiers, templateTags);
+            scripts.push(...synthetic);
+            return scripts.join(';\n');
+        };
+        const tsCompiler = (source, path) => {
+            if (path.endsWith('.d.ts') || path.endsWith('.config.ts'))
+                return source;
+            const identifiers = collectIdentifiers(source, path);
+            const syntheticImports = getSyntheticImports(identifiers);
+            if (syntheticImports.length === 0)
+                return source;
+            return `${source}\n${syntheticImports.join('\n')}`;
+        };
+        registerCompiler({ extension: '.vue', compiler });
+        registerCompiler({ extension: '.ts', compiler: tsCompiler });
+    }
+};
+const resolveConfig = async (localConfig, options) => {
+    const { configFileDir: cwd } = options;
+    const hasAppDir = isDirectory(cwd, 'app');
+    const srcDir = localConfig.srcDir ?? (hasAppDir ? join(cwd, 'app') : cwd);
+    const serverDir = localConfig.serverDir ?? 'server';
+    const inputs = [];
+    for (const id of localConfig.modules ?? []) {
         if (Array.isArray(id) && typeof id[0] === 'string')
-            acc.push(toDependency(id[0]));
+            inputs.push(toDependency(id[0]));
         if (typeof id === 'string')
-            acc.push(toDependency(id));
-        return acc;
-    }, []) ?? [];
-    return [...deps, ...patterns];
+            inputs.push(toDependency(id));
+    }
+    addAppEntries(inputs, srcDir, serverDir, localConfig, cwd);
+    const aliases = localConfig.alias;
+    if (aliases) {
+        for (const key in aliases) {
+            const prefix = resolveAlias(aliases[key], srcDir, cwd);
+            inputs.push(toAlias(key, prefix));
+            if (prefix.endsWith('/') || isDirectory(prefix)) {
+                inputs.push(toAlias(join(key, '*'), join(prefix, '*'), { dir: cwd }));
+            }
+        }
+    }
+    for (const ext of localConfig.extends ?? []) {
+        const resolved = resolveAlias(ext, srcDir, cwd);
+        for (const cfg of _syncGlob({ cwd: resolved, patterns: config })) {
+            inputs.push(toConfig('nuxt', join(resolved, cfg)));
+        }
+    }
+    for (const layerConfig of findLayerConfigs(cwd)) {
+        inputs.push(toConfig('nuxt', layerConfig));
+    }
+    if (cwd !== options.cwd)
+        return inputs;
+    for (const file of _syncGlob({ cwd, patterns: ['.nuxt/module/*.d.ts'] })) {
+        const sourceFile = createSourceFile(join(cwd, file));
+        for (const path of collectLocalImportPaths(sourceFile))
+            inputs.push(toProductionEntry(path));
+    }
+    const dir = join(cwd, '.nuxt');
+    const tsConfig = await loadTSConfig(join(dir, 'tsconfig.json'));
+    const paths = tsConfig.compilerOptions?.paths;
+    if (paths) {
+        for (const key in paths) {
+            if (key === '#imports' || key === '#components')
+                continue;
+            inputs.push(toAlias(key, paths[key], { dir }));
+        }
+    }
+    inputs.push(toIgnore('#imports', 'unresolved'));
+    inputs.push(toIgnore('#components', 'unresolved'));
+    return inputs;
 };
-const note = `Knip works best with [explicit imports](https://nuxt.com/docs/guide/concepts/auto-imports#explicit-imports).
-Nuxt allows to [disable auto-imports](https://nuxt.com/docs/guide/concepts/auto-imports#disabling-auto-imports).`;
-export const docs = { note };
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
+    entry,
     production,
     setup,
     resolveConfig,
+    registerCompilers,
 };
 export default plugin;

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

@@ -1,9 +1,59 @@
 export interface NuxtConfig {
     srcDir?: string;
+    buildDir?: string;
+    serverDir?: string;
     dir?: {
         pages?: string;
         layouts?: string;
         middleware?: string;
+        plugins?: string;
     };
     modules?: Array<string | ((inlineOptions: any, nuxt: any) => any) | [string, Record<string, any>]>;
+    imports?: {
+        autoImport?: boolean;
+        dirs?: string[];
+    };
+    extends?: string[];
+    components?: Array<string | {
+        path: string;
+    }> | {
+        dirs?: Array<string | {
+            path: string;
+        }>;
+    };
+    css?: string[];
+    alias?: Record<string, string>;
+}
+export interface TemplateExpressionNode {
+    content: string;
+    isStatic: boolean;
+}
+export interface TemplateAstProp {
+    type: number;
+    exp?: TemplateExpressionNode;
+    arg?: TemplateExpressionNode;
 }
+export interface TemplateAstNode {
+    type?: number;
+    tag?: string;
+    props?: TemplateAstProp[];
+    content?: TemplateExpressionNode;
+    children?: TemplateAstNode[];
+}
+export interface Descriptor {
+    script: {
+        content: string;
+    } | null;
+    scriptSetup: {
+        content: string;
+    } | null;
+    template: {
+        content: string;
+        ast?: TemplateAstNode;
+    } | null;
+}
+export type VueSfc = {
+    parse: (source: string, path: string) => {
+        descriptor: Descriptor;
+    };
+};

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

@@ -1,4 +1,4 @@
-import type { Plugin } from '../../types/config.js';
+import type { Plugin } from '../../types/config.ts';
 export declare const docs: {
     note: string;
 };

package/dist/plugins/nx/index.js

@@ -1,6 +1,7 @@
-import { compact } from '../../util/array.js';
-import { toConfig, toDependency } from '../../util/input.js';
-import { hasDependency } from '../../util/plugin.js';
+import { compact } from "../../util/array.js";
+import { toConfig, toDependency } from "../../util/input.js";
+import { join } from "../../util/path.js";
+import { hasDependency } from "../../util/plugin.js";
 const title = 'Nx';
 const enablers = ['nx', /^@nrwl\//, /^@nx\//];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -34,18 +35,19 @@ const resolveConfig = async (localConfig, options) => {
         .map(target => target?.executor)
         .filter(executor => executor && !executor.startsWith('.'))
         .map(executor => executor?.split(':')[0]);
-    const scripts = targets
+    const inputs = targets
         .filter(target => target.executor === 'nx:run-commands' || target.command)
         .flatMap(target => {
+        let commands = [];
         if (target.command)
-            return [target.command];
-        if (target.options?.command)
-            return [target.options.command];
-        if (target.options?.commands)
-            return target.options.commands.map(commandConfig => typeof commandConfig === 'string' ? commandConfig : commandConfig.command);
-        return [];
+            commands = [target.command];
+        else if (target.options?.command)
+            commands = [target.options.command];
+        else if (target.options?.commands)
+            commands = target.options.commands.map(commandConfig => typeof commandConfig === 'string' ? commandConfig : commandConfig.command);
+        const cwd = target.options?.cwd ? join(options.cwd, target.options.cwd) : undefined;
+        return options.getInputsFromScripts(commands, { cwd });
     });
-    const inputs = options.getInputsFromScripts(scripts);
     const configInputs = targets.flatMap(target => {
         const opts = target.options;
         if (!opts)

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

@@ -8,6 +8,7 @@ export interface NxProjectConfiguration {
                 commands?: Array<string | {
                     command: string;
                 }>;
+                cwd?: string;
                 eslintConfig?: string;
                 jestConfig?: string;
                 tsConfig?: string;

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

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

package/dist/plugins/nyc/index.js

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

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

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

package/dist/plugins/oclif/index.js

@@ -1,5 +1,5 @@
-import { toDependency } from '../../util/input.js';
-import { hasDependency } from '../../util/plugin.js';
+import { toDependency } from "../../util/input.js";
+import { hasDependency } from "../../util/plugin.js";
 const title = 'oclif';
 const enablers = ['oclif'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);

package/dist/plugins/openapi-ts/index.d.ts

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

package/dist/plugins/openapi-ts/index.js

@@ -0,0 +1,13 @@
+import { hasDependency } from "../../util/plugin.js";
+import { toC12config } from "../../util/plugin-config.js";
+const title = 'openapi-ts';
+const enablers = ['@hey-api/openapi-ts'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['package.json', ...toC12config('openapi-ts')];
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+};
+export default plugin;

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

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

package/dist/plugins/oxfmt/index.js

@@ -0,0 +1,16 @@
+import { hasDependency } from "../../util/plugin.js";
+const title = 'Oxfmt';
+const enablers = ['oxfmt'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['.oxfmtrc.json', '.oxfmtrc.jsonc'];
+const args = {
+    config: true,
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    args,
+};
+export default plugin;

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

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

package/dist/plugins/oxlint/index.js

@@ -1,8 +1,8 @@
-import { hasDependency } from '../../util/plugin.js';
+import { hasDependency } from "../../util/plugin.js";
 const title = 'Oxlint';
 const enablers = ['oxlint'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['.oxlintrc.json'];
+const config = ['.oxlintrc.json', 'oxlint.config.ts'];
 const args = {
     config: true,
 };

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

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

package/dist/plugins/parcel/index.js

@@ -1,5 +1,5 @@
-import { toDeferResolve } from '../../util/input.js';
-import { hasDependency } from '../../util/plugin.js';
+import { toDeferResolve } from "../../util/input.js";
+import { hasDependency } from "../../util/plugin.js";
 const title = 'Parcel';
 const enablers = ['parcel', '@parcel/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);

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

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

package/dist/plugins/payload/index.js

@@ -1,5 +1,5 @@
-import { toDeferResolve } from '../../util/input.js';
-import { hasDependency } from '../../util/plugin.js';
+import { toDeferResolve } from "../../util/input.js";
+import { hasDependency } from "../../util/plugin.js";
 const title = 'Payload CMS';
 const enablers = ['payload'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);

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

@@ -1,5 +1,5 @@
-import type { Plugin, ResolveConfig } from '../../types/config.js';
-import type { PlaywrightTestConfig } from './types.js';
+import type { Plugin, ResolveConfig } from '../../types/config.ts';
+import type { PlaywrightTestConfig } from './types.ts';
 export declare const entry: string[];
 export declare const resolveConfig: ResolveConfig<PlaywrightTestConfig>;
 declare const plugin: Plugin;

package/dist/plugins/playwright/index.js

@@ -1,7 +1,7 @@
-import { arrayify } from '../../util/array.js';
-import { toDeferResolve, toEntry } from '../../util/input.js';
-import { join, relative } from '../../util/path.js';
-import { hasDependency } from '../../util/plugin.js';
+import { arrayify } from "../../util/array.js";
+import { toDeferResolve, toEntry } from "../../util/input.js";
+import { join, relative } from "../../util/path.js";
+import { hasDependency } from "../../util/plugin.js";
 const title = 'Playwright';
 const enablers = ['@playwright/test'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -13,7 +13,7 @@ const toEntryPatterns = (testMatch, cwd, configDir, localConfig, rootConfig) =>
     const patterns = [testMatch].flat().filter((p) => typeof p === 'string');
     return patterns.map(pattern => toEntry(join(dir, pattern)));
 };
-const builtinReporters = ['dot', 'line', 'list', 'junit', 'html', 'blob', 'json', 'github'];
+const builtinReporters = ['dot', 'line', 'list', 'junit', 'html', 'blob', 'json', 'github', 'null'];
 export const resolveConfig = async (localConfig, options) => {
     const { cwd, configFileDir } = options;
     const inputs = [];

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

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