knip 6.24.0 → 6.26.0

package/dist/plugins/next/index.js

@@ -1,33 +1,46 @@
+import { collectPropertyValues } from '../../typescript/ast-helpers.js';
+import { isDirectory } from '../../util/fs.js';
 import { toConfig, toProductionEntry } from '../../util/input.js';
 import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
-import { getPageExtensions } from './resolveFromAST.js';
 const title = 'Next.js';
 const enablers = ['next'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['next.config.{js,ts,cjs,mjs}'];
+const config = ['next.config.{js,ts,cjs,mjs,mts}'];
 const defaultPageExtensions = ['{js,jsx,ts,tsx}'];
 const productionEntryFilePatterns = [
     'app/{,[(]*[)]/}{manifest,robots}.{js,ts}',
     'app/**/sitemap.{js,ts}',
     'app/**/{icon,apple-icon,opengraph-image,twitter-image}.{js,jsx,ts,tsx}',
 ];
-const getEntryFilePatterns = (pageExtensions = defaultPageExtensions) => {
+const rootOrSrc = '{,src/}';
+const getRouterDirPrefix = (cwd, name) => {
+    if (!cwd)
+        return rootOrSrc;
+    if (isDirectory(cwd, name))
+        return '';
+    if (isDirectory(cwd, `src/${name}`))
+        return 'src/';
+    return rootOrSrc;
+};
+const getEntryFilePatterns = (pageExtensions = defaultPageExtensions, cwd) => {
     const ext = pageExtensions.length === 1 ? pageExtensions[0] : `{${pageExtensions.join(',')}}`;
+    const appDirPrefix = getRouterDirPrefix(cwd, 'app');
+    const pagesDirPrefix = getRouterDirPrefix(cwd, 'pages');
     return [
-        ...productionEntryFilePatterns,
-        `{instrumentation,instrumentation-client,middleware,proxy}.${ext}`,
-        `app/global-{error,not-found}.${ext}`,
-        `app/**/{default,error,forbidden,loading,not-found,unauthorized}.${ext}`,
-        `app/**/{layout,page,route,template}.${ext}`,
-        `pages/**/*.${ext}`,
-    ].flatMap(pattern => [pattern, `src/${pattern}`]);
+        ...productionEntryFilePatterns.map(pattern => `${appDirPrefix}${pattern}`),
+        `${rootOrSrc}{instrumentation,instrumentation-client,middleware,proxy}.${ext}`,
+        `${appDirPrefix}app/global-{error,not-found}.${ext}`,
+        `${appDirPrefix}app/**/{default,error,forbidden,loading,not-found,unauthorized}.${ext}`,
+        `${appDirPrefix}app/**/{layout,page,route,template}.${ext}`,
+        `${pagesDirPrefix}pages/**/*.${ext}`,
+    ];
 };
 const production = getEntryFilePatterns();
 const resolveFromAST = (program, { configFileDir }) => {
-    const pageExtensions = getPageExtensions(program);
+    const pageExtensions = [...collectPropertyValues(program, 'pageExtensions')];
     const extensions = pageExtensions.length > 0 ? pageExtensions : defaultPageExtensions;
-    const patterns = [...getEntryFilePatterns(extensions), 'next-env.d.ts'];
+    const patterns = [...getEntryFilePatterns(extensions, configFileDir), 'next-env.d.ts'];
     return patterns.map(id => toProductionEntry(join(configFileDir, id)));
 };
 const commands = new Set(['dev', 'build', 'start']);

package/dist/plugins/next-mdx/index.js

@@ -1,15 +1,9 @@
-import { toDependency, toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
-import { getMdxPlugins } from './resolveFromAST.js';
+import { production, resolveFromAST } from './resolveFromAST.js';
 const title = 'Next.js MDX';
 const enablers = ['@next/mdx'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['next.config.{js,ts,cjs,mjs}'];
-const production = ['{src/,}mdx-components.{js,jsx,ts,tsx}'];
-const resolveFromAST = program => {
-    const mdxPlugins = getMdxPlugins(program);
-    return [...production.map(id => toProductionEntry(id)), ...Array.from(mdxPlugins).map(id => toDependency(id))];
-};
+const config = ['next.config.{js,ts,cjs,mjs,mts}'];
 const plugin = {
     title,
     enablers,

package/dist/plugins/next-mdx/resolveFromAST.d.ts

@@ -1,2 +1,3 @@
-import type { Program } from 'oxc-parser';
-export declare const getMdxPlugins: (program: Program) => Set<string>;
+import type { ResolveFromAST } from '../../types/config.ts';
+export declare const production: string[];
+export declare const resolveFromAST: ResolveFromAST;

package/dist/plugins/next-mdx/resolveFromAST.js

@@ -1,24 +1,20 @@
-import { Visitor } from 'oxc-parser';
-import { findProperty, getDefaultImportName, getImportMap, getStringValues } from '../../typescript/ast-helpers.js';
-export const getMdxPlugins = (program) => {
+import { findImportedCalls, findProperty, getStringValues } from '../../typescript/ast-helpers.js';
+import { toDependency, toProductionEntry } from '../../util/input.js';
+export const production = ['{src/,}mdx-components.{js,jsx,ts,tsx}'];
+const getMdxPlugins = (program) => {
     const plugins = new Set();
-    const importMap = getImportMap(program);
-    const mdxImportName = getDefaultImportName(importMap, '@next/mdx');
-    if (!mdxImportName)
-        return plugins;
-    const visitor = new Visitor({
-        CallExpression(node) {
-            if (node.callee?.type !== 'Identifier' || node.callee.name !== mdxImportName)
-                return;
-            const options = findProperty(node.arguments?.[0], 'options');
-            if (options?.type !== 'ObjectExpression')
-                return;
-            for (const pluginType of ['remarkPlugins', 'rehypePlugins', 'recmaPlugins']) {
-                for (const v of getStringValues(findProperty(options, pluginType)))
-                    plugins.add(v);
-            }
-        },
-    });
-    visitor.visit(program);
+    for (const call of findImportedCalls(program, '@next/mdx')) {
+        const options = findProperty(call.arguments?.[0], 'options');
+        if (options?.type !== 'ObjectExpression')
+            continue;
+        for (const pluginType of ['remarkPlugins', 'rehypePlugins', 'recmaPlugins']) {
+            for (const v of getStringValues(findProperty(options, pluginType)))
+                plugins.add(v);
+        }
+    }
     return plugins;
 };
+export const resolveFromAST = program => [
+    ...production.map(id => toProductionEntry(id)),
+    ...Array.from(getMdxPlugins(program)).map(id => toDependency(id)),
+];

package/dist/plugins/node/index.js

@@ -1,4 +1,5 @@
 import { toEntry, toProductionEntry } from '../../util/input.js';
+import { getScriptCommands } from '../../util/scripts.js';
 const title = 'Node.js';
 const isEnabled = () => true;
 const patterns = [
@@ -7,7 +8,9 @@ const patterns = [
     '**/test.{cjs,mjs,js,cts,mts,ts}',
     '**/test/**/*.{cjs,mjs,js,cts,mts,ts}',
 ];
-const hasNodeTest = (scripts) => scripts && Object.values(scripts).some(script => /(?<=^|\s)(node|nub)\s(.*)--test/.test(script));
+const hasNodeTest = (scripts) => scripts &&
+    Object.values(scripts).some(script => typeof script === 'string' &&
+        getScriptCommands(script).some(({ binary, args }) => (binary === 'node' || binary === 'nub') && args.includes('--test')));
 const entry = ['server.js'];
 const resolve = options => {
     const entries = entry.map(id => toProductionEntry(id));

package/dist/plugins/nuxt/index.js

@@ -4,7 +4,7 @@ import { toAlias, toConfig, toDeferResolveProductionEntry, toDependency, toEntry
 import { loadTSConfig } from '../../util/load-tsconfig.js';
 import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
-import { buildAutoImportMap, collectIdentifiers, collectLocalImportPaths, collectTemplateInfo, getVueSfc, readAndParseFile, toKebabCase, } from './helpers.js';
+import { buildAutoImportMap, collectLocalImportPaths, createAutoImportMaps, createTsCompiler, createVueCompiler, readAndParseFile, } from '../_vue/auto-import.js';
 const title = 'Nuxt';
 const enablers = ['nuxt', 'nuxt-nightly'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -62,9 +62,7 @@ const addAppEntries = (inputs, srcDir, serverDir, config, 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 maps = createAutoImportMaps();
         const definitionFiles = [
             '.nuxt/imports.d.ts',
             '.nuxt/components.d.ts',
@@ -73,71 +71,10 @@ const registerCompilers = async ({ cwd, hasDependency, registerCompiler }) => {
         ];
         for (const file of definitionFiles) {
             const path = join(cwd, file);
-            const result = readAndParseFile(path);
-            const maps = buildAutoImportMap(path, result);
-            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);
-            }
+            buildAutoImportMap(path, readAndParseFile(path), maps, file.endsWith('components.d.ts'));
         }
-        const getSyntheticImports = (identifiers, templateTags) => {
-            if (importMap.size === 0 && (!templateTags || componentMap.size === 0))
-                return [];
-            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 = scripts.length === 0 ? new Set() : 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 });
+        registerCompiler({ extension: '.vue', compiler: createVueCompiler(maps, cwd) });
+        registerCompiler({ extension: '.ts', compiler: createTsCompiler(maps) });
     }
 };
 const resolveConfig = async (localConfig, options) => {

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

@@ -25,37 +25,3 @@ export interface NuxtConfig {
     css?: string[];
     alias?: Record<string, string>;
 }
-interface TemplateExpressionNode {
-    content: string;
-    isStatic: boolean;
-}
-interface TemplateAstProp {
-    type: number;
-    exp?: TemplateExpressionNode;
-    arg?: TemplateExpressionNode;
-}
-export interface TemplateAstNode {
-    type?: number;
-    tag?: string;
-    props?: TemplateAstProp[];
-    content?: TemplateExpressionNode;
-    children?: TemplateAstNode[];
-}
-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;
-    };
-};
-export {};

package/dist/plugins/nuxtjs-i18n/index.d.ts

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

package/dist/plugins/nuxtjs-i18n/index.js

@@ -0,0 +1,12 @@
+import { hasDependency } from '../../util/plugin.js';
+const title = '@nuxtjs/i18n';
+const enablers = ['@nuxtjs/i18n'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const entry = ['i18n.config.{js,mjs,ts}', 'i18n/i18n.config.{js,mjs,ts}'];
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    entry,
+};
+export default plugin;

package/dist/plugins/oclif/index.js

@@ -1,19 +1,24 @@
-import { toDependency } from '../../util/input.js';
+import { toDependency, toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'oclif';
-const enablers = ['oclif'];
+const enablers = ['oclif', '@oclif/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['package.json'];
+const production = ['{,src/}commands/**/*.{js,mjs,cjs,jsx,ts,tsx,mts,cts}'];
 const resolveConfig = async (config) => {
-    const plugins = config?.plugins ?? [];
-    const devPlugins = config?.devPlugins ?? [];
-    return [...plugins, ...devPlugins].map(id => toDependency(id));
+    if (!config)
+        return [];
+    const inputs = production.map(id => toProductionEntry(id));
+    for (const id of [...(config.plugins ?? []), ...(config.devPlugins ?? [])])
+        inputs.push(toDependency(id));
+    return inputs;
 };
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
+    production,
     resolveConfig,
 };
 export default plugin;

package/dist/plugins/orval/index.js

@@ -1,11 +1,9 @@
-import { toEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
-import { getInputsFromAST } from './resolveFromAST.js';
+import { resolveFromAST } from './resolveFromAST.js';
 const title = 'orval';
 const enablers = ['orval'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['orval.config.{js,mjs,ts,mts}'];
-const resolveFromAST = program => [...getInputsFromAST(program)].map(id => toEntry(id));
 const plugin = {
     title,
     enablers,

package/dist/plugins/orval/resolveFromAST.d.ts

@@ -1,2 +1,2 @@
-import type { Program } from 'oxc-parser';
-export declare const getInputsFromAST: (program: Program) => Set<string>;
+import type { ResolveFromAST } from '../../types/config.ts';
+export declare const resolveFromAST: ResolveFromAST;

package/dist/plugins/orval/resolveFromAST.js

@@ -1,11 +1,8 @@
 import { collectPropertyValues } from '../../typescript/ast-helpers.js';
+import { toEntry } from '../../util/input.js';
 const PATH_KEY = 'path';
 const TRANSFORMER_KEY = 'transformer';
-export const getInputsFromAST = (program) => {
-    const values = new Set();
-    for (const v of collectPropertyValues(program, PATH_KEY))
-        values.add(v);
-    for (const v of collectPropertyValues(program, TRANSFORMER_KEY))
-        values.add(v);
-    return values;
+export const resolveFromAST = program => {
+    const values = [...collectPropertyValues(program, PATH_KEY), ...collectPropertyValues(program, TRANSFORMER_KEY)];
+    return values.map(id => toEntry(id));
 };

package/dist/plugins/oxlint/index.js

@@ -1,10 +1,13 @@
+import { Visitor } from 'oxc-parser';
+import { findProperty, getPropertyValues } from '../../typescript/ast-helpers.js';
 import { toDependency, toEntry } from '../../util/input.js';
 import { isInternal } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Oxlint';
-const enablers = ['oxlint'];
+const enablers = ['oxlint', 'vite-plus'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['.oxlintrc.json', 'oxlint.config.ts'];
+const config = ['.oxlintrc.json', 'oxlint.config.ts', 'vite.config.{js,mjs,ts,cjs,mts,cts}'];
+const isViteConfig = (configFileName) => configFileName.startsWith('vite.config.');
 const args = {
     config: true,
 };
@@ -19,6 +22,7 @@ const resolveJsPlugins = (jsPlugins) => {
     }
     return inputs;
 };
+const isLoadConfig = ({ configFileName }) => !isViteConfig(configFileName);
 const resolveConfig = config => {
     const inputs = resolveJsPlugins(config.jsPlugins);
     for (const override of config.overrides ?? []) {
@@ -27,12 +31,29 @@ const resolveConfig = config => {
     }
     return inputs;
 };
+const resolveFromAST = (program, options) => {
+    if (!isViteConfig(options.configFileName))
+        return [];
+    const jsPlugins = new Set();
+    const visitor = new Visitor({
+        ObjectExpression(node) {
+            const lint = findProperty(node, 'lint');
+            if (lint?.type === 'ObjectExpression')
+                for (const specifier of getPropertyValues(lint, 'jsPlugins'))
+                    jsPlugins.add(specifier);
+        },
+    });
+    visitor.visit(program);
+    return resolveJsPlugins([...jsPlugins]);
+};
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
+    isLoadConfig,
     resolveConfig,
+    resolveFromAST,
     args,
 };
 export default plugin;

package/dist/plugins/pnpm/index.js

@@ -1,12 +1,33 @@
 import { isFile } from '../../util/fs.js';
+import { toDependency, toEntry } from '../../util/input.js';
 const title = 'pnpm';
+const enablers = 'This plugin is enabled when a `pnpm-lock.yaml` or `pnpm-workspace.yaml` file is found in the root directory, or when `pnpm@` is specified in the `packageManager` field of `package.json`.';
 const isEnabled = async ({ cwd, manifest }) => manifest.packageManager?.startsWith('pnpm@') || isFile(cwd, 'pnpm-lock.yaml') || isFile(cwd, 'pnpm-workspace.yaml');
 const isRootOnly = true;
-const config = ['.pnpmfile.cjs'];
+const entry = ['.pnpmfile.{cjs,mjs}'];
+const config = ['package.json', 'pnpm-workspace.yaml'];
+const resolveConfig = config => {
+    const inputs = entry.map(toEntry);
+    const packageExtensions = config?.pnpm?.packageExtensions || config?.packageExtensions;
+    if (packageExtensions) {
+        for (const extension of Object.values(packageExtensions)) {
+            if (extension.peerDependencies) {
+                for (const dep of Object.keys(extension.peerDependencies)) {
+                    const optional = extension.peerDependenciesMeta?.[dep]?.optional === true;
+                    inputs.push(optional ? toDependency(dep, { optional: true }) : toDependency(dep));
+                }
+            }
+        }
+    }
+    return inputs;
+};
 const plugin = {
     title,
+    enablers,
     isEnabled,
     isRootOnly,
+    entry,
     config,
+    resolveConfig,
 };
 export default plugin;

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

@@ -0,0 +1,4 @@
+import type { PackageExtensions, PackageJson } from '../../types/package-json.ts';
+export type PnpmConfig = PackageJson & {
+    packageExtensions?: PackageExtensions;
+};

package/dist/plugins/pnpm/types.js

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

package/dist/plugins/prettier/index.js

@@ -12,9 +12,25 @@ const config = [
 const resolveConfig = config => {
     if (typeof config === 'string')
         return [toDeferResolve(config)];
-    return Array.isArray(config.plugins)
-        ? config.plugins.filter((plugin) => typeof plugin === 'string').map(id => toDependency(id))
-        : [];
+    const result = new Set();
+    const processOptions = (options) => {
+        if (Array.isArray(options.plugins)) {
+            for (const plugin of options.plugins) {
+                if (typeof plugin === 'string') {
+                    result.add(toDependency(plugin));
+                }
+            }
+        }
+    };
+    processOptions(config);
+    if (config.overrides) {
+        for (const override of config.overrides) {
+            if (override.options) {
+                processOptions(override.options);
+            }
+        }
+    }
+    return Array.from(result);
 };
 const args = {
     config: true,

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

@@ -1,4 +1,4 @@
-export type PrettierConfig = {
+export type PrettierOptions = {
     plugins?: (string | {
         parsers?: Record<string, unknown>;
         printers?: Record<string, unknown>;
@@ -6,3 +6,8 @@ export type PrettierConfig = {
         options?: Record<string, unknown>;
     })[];
 };
+export type PrettierConfig = PrettierOptions & {
+    overrides?: {
+        options?: PrettierOptions;
+    }[];
+};

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

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

package/dist/plugins/quasar/index.js

@@ -0,0 +1,15 @@
+import { hasDependency } from '../../util/plugin.js';
+import { production, resolveFromAST } from './resolveFromAST.js';
+const title = 'Quasar';
+const enablers = ['@quasar/app', '@quasar/app-vite', '@quasar/app-webpack'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['quasar.config.{js,cjs,mjs,ts}', 'quasar.conf.js'];
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    production,
+    resolveFromAST,
+};
+export default plugin;

package/dist/plugins/quasar/resolveFromAST.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveFromAST } from '../../types/config.ts';
+export declare const production: string[];
+export declare const resolveFromAST: ResolveFromAST;

package/dist/plugins/quasar/resolveFromAST.js

@@ -0,0 +1,63 @@
+import { findProperty, getFirstPropertyValue, getStringValues, resolveObjectArg, } from '../../typescript/ast-helpers.js';
+import { getStringValue } from '../../typescript/ast-nodes.js';
+import { toDeferResolve, toProductionEntry } from '../../util/input.js';
+import { join } from '../../util/path.js';
+const sourceFilesEntries = [
+    ['rootComponent', ['src/App.vue']],
+    ['router', ['src/router/index.{js,ts}']],
+    ['store', ['src/stores/index.{js,ts}', 'src/store/index.{js,ts}']],
+    ['pwaRegisterServiceWorker', ['src-pwa/register-service-worker.{js,ts}', 'src-pwa/register-sw.{js,ts}']],
+    ['pwaServiceWorker', ['src-pwa/custom-service-worker.{js,ts}', 'src-pwa/sw/custom-sw.{js,ts}']],
+    ['electronMain', ['src-electron/electron-main.{js,ts}']],
+];
+const staticEntries = [
+    'src-electron/electron-preload.{js,ts}',
+    'src-ssr/server.{js,ts}',
+    'src-ssr/middlewares/*.{js,ts}',
+    'src-bex/**/*.{js,ts}',
+];
+export const production = [...sourceFilesEntries.flatMap(([, defaults]) => defaults), ...staticEntries];
+const getConfigObject = (program) => {
+    for (const node of program.body ?? []) {
+        if (node.type === 'ExportDefaultDeclaration') {
+            const decl = node.declaration;
+            return decl?.type === 'CallExpression' ? resolveObjectArg(decl.arguments?.[0]) : resolveObjectArg(decl);
+        }
+        if (node.type === 'ExpressionStatement' && node.expression?.type === 'AssignmentExpression') {
+            const { left, right } = node.expression;
+            if (left?.type === 'MemberExpression' && left.object?.name === 'module' && left.property?.name === 'exports') {
+                return right?.type === 'CallExpression' ? resolveObjectArg(right.arguments?.[0]) : resolveObjectArg(right);
+            }
+        }
+    }
+};
+const withExtensions = (id) => (id.includes('.') ? id : `${id}.{js,ts}`);
+export const resolveFromAST = (program, options) => {
+    const { configFileDir } = options;
+    const inputs = [];
+    const config = getConfigObject(program);
+    const sourceFiles = findProperty(config, 'sourceFiles');
+    for (const [key, defaults] of sourceFilesEntries) {
+        const override = getFirstPropertyValue(sourceFiles, key);
+        for (const id of override ? [withExtensions(override)] : defaults) {
+            inputs.push(toProductionEntry(join(configFileDir, id)));
+        }
+    }
+    for (const id of staticEntries)
+        inputs.push(toProductionEntry(join(configFileDir, id)));
+    const boot = findProperty(config, 'boot');
+    if (boot?.type === 'ArrayExpression') {
+        for (const element of boot.elements ?? []) {
+            const id = getStringValue(element) ?? getFirstPropertyValue(element, 'path');
+            if (id)
+                inputs.push(toProductionEntry(join(configFileDir, 'src/boot', withExtensions(id))));
+        }
+    }
+    for (const id of getStringValues(findProperty(config, 'css'))) {
+        if (id.startsWith('~'))
+            inputs.push(toDeferResolve(id.slice(1)));
+        else
+            inputs.push(toProductionEntry(join(configFileDir, 'src/css', id)));
+    }
+    return inputs;
+};

package/dist/plugins/qwik/index.js

@@ -1,34 +1,10 @@
 import MDX from '../../compilers/mdx.js';
-import { toEntry, toIgnore, toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
 import { config } from '../vite/index.js';
-import { getRoutesDirs, getSrcDir } from './resolveFromAST.js';
+import { entry, production, resolveFromAST, routeProduction } from './resolveFromAST.js';
 const title = 'Qwik';
 const enablers = ['@builder.io/qwik'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const entry = ['src/entry.dev.tsx'];
-const production = ['src/root.tsx', 'src/entry.*.tsx'];
-const routeProduction = ['src/routes/**/*.{tsx,ts,md,mdx}'];
-const resolveFromAST = program => {
-    const srcDir = getSrcDir(program);
-    const routesDirs = getRoutesDirs(program, srcDir);
-    const setSrcDir = (pattern) => pattern.replace(/^src\//, `${srcDir}/`);
-    const setRoutesDir = (pattern, routesDir) => pattern.replace(/^src\/routes\//, `${routesDir}/`);
-    const routeEntries = [];
-    for (const routesDir of routesDirs) {
-        for (const pattern of routeProduction) {
-            routeEntries.push(toProductionEntry(setRoutesDir(pattern, routesDir)));
-        }
-    }
-    return [
-        ...entry.map(setSrcDir).map(path => toEntry(path)),
-        ...production.map(setSrcDir).map(path => toProductionEntry(path)),
-        ...routeEntries,
-        toIgnore('@qwik-city-plan', 'unlisted'),
-        toIgnore('@qwik-city-sw-register', 'unlisted'),
-        toIgnore('@qwik-client-manifest', 'unlisted'),
-    ];
-};
 const registerCompilers = ({ registerCompiler, hasDependency }) => {
     if (hasDependency('@builder.io/qwik-city')) {
         registerCompiler({ extension: '.mdx', compiler: MDX.compiler });

package/dist/plugins/qwik/resolveFromAST.d.ts

@@ -1,3 +1,5 @@
-import type { Program } from 'oxc-parser';
-export declare const getSrcDir: (program: Program) => string;
-export declare const getRoutesDirs: (program: Program, srcDir: string) => string[];
+import type { ResolveFromAST } from '../../types/config.ts';
+export declare const entry: string[];
+export declare const production: string[];
+export declare const routeProduction: string[];
+export declare const resolveFromAST: ResolveFromAST;