knip 6.24.0 → 6.26.0

package/dist/graph-explorer/operations/find-all-cycles.js

@@ -0,0 +1,43 @@
+import { getRuntimeSuccessors } from '../utils.js';
+const UNVISITED = undefined;
+const ON_STACK = 1;
+const DONE = 2;
+export const findAllCycles = (graph, ignoredFlags) => {
+    const cycles = [];
+    const state = new Map();
+    for (const root of graph.keys()) {
+        if (state.get(root) !== UNVISITED)
+            continue;
+        const path = [];
+        const indexOnPath = new Map();
+        const successorsStack = [];
+        const push = (filePath) => {
+            state.set(filePath, ON_STACK);
+            indexOnPath.set(filePath, path.length);
+            path.push(filePath);
+            const node = graph.get(filePath);
+            successorsStack.push((node ? getRuntimeSuccessors(node, ignoredFlags) : new Set()).values());
+        };
+        push(root);
+        while (path.length > 0) {
+            const current = path[path.length - 1];
+            const next = successorsStack[successorsStack.length - 1].next();
+            if (next.done) {
+                state.set(current, DONE);
+                indexOnPath.delete(current);
+                path.pop();
+                successorsStack.pop();
+                continue;
+            }
+            const successor = next.value;
+            const successorState = state.get(successor);
+            if (successorState === ON_STACK) {
+                cycles.push([...path.slice(indexOnPath.get(successor)), successor]);
+            }
+            else if (successorState === UNVISITED) {
+                push(successor);
+            }
+        }
+    }
+    return cycles;
+};

package/dist/graph-explorer/operations/find-cycles.js

@@ -1,3 +1,4 @@
+import { getRuntimeSuccessors } from '../utils.js';
 export const findCycles = (graph, filePath, maxDepth = 16) => {
     const cycles = [];
     const visited = new Set();
@@ -7,16 +8,9 @@ export const findCycles = (graph, filePath, maxDepth = 16) => {
         if (path.length > maxDepth)
             return;
         const node = graph.get(currentPath);
-        if (!node?.imports?.internal)
+        if (!node)
             return;
-        const nonTypeOnlyImports = new Set();
-        for (const _import of node.imports.imports) {
-            if (_import.filePath && !_import.isTypeOnly)
-                nonTypeOnlyImports.add(_import.filePath);
-        }
-        for (const [importedPath] of node.imports.internal) {
-            if (!nonTypeOnlyImports.has(importedPath))
-                continue;
+        for (const importedPath of getRuntimeSuccessors(node)) {
             if (importedPath === filePath) {
                 cycles.push([...path, importedPath]);
                 continue;

package/dist/graph-explorer/utils.d.ts

@@ -1,5 +1,14 @@
-import type { Import, ImportMaps, ModuleGraph } from '../types/module-graph.ts';
+import type { FileNode, Import, ImportMaps, ModuleGraph } from '../types/module-graph.ts';
+export declare const getIgnoredCycleImportFlags: (includeDynamicImports: boolean) => number;
 export declare const getExportedIdentifiers: (graph: ModuleGraph, filePath: string, visited?: Set<string>) => Map<string, boolean>;
+export declare const getRuntimeSuccessors: (node: FileNode, ignoredFlags?: number) => Set<string>;
+export declare const getRuntimeImport: (node: FileNode, filePath: string, ignoredFlags?: number) => {
+    kind: string;
+    specifier: string;
+    pos: number;
+    line: number;
+    col: number;
+} | undefined;
 export declare const hasStrictlyEnumReferences: (importsForExport: ImportMaps | undefined, identifier: string) => boolean;
 export declare const getIssueType: (hasOnlyNsReference: boolean, isType: boolean) => "exports" | "nsExports" | "nsTypes" | "types";
 export declare const findImportRef: (graph: ModuleGraph, importingFile: string, importedFile: string, identifier: string) => Import | undefined;

package/dist/graph-explorer/utils.js

@@ -1,5 +1,8 @@
+import { IMPORT_FLAGS, IMPORT_STAR, OPAQUE, SIDE_EFFECTS } from '../constants.js';
 import { getCachedExportedIdentifiers, setCachedExportedIdentifiers } from './cache.js';
 import { forEachAliasReExport, forEachNamespaceReExport, forEachPassThroughReExport, getStarReExportSources, } from './visitors.js';
+const IGNORED_CYCLE_IMPORT_FLAGS = IMPORT_FLAGS.ENTRY | IMPORT_FLAGS.DYNAMIC;
+export const getIgnoredCycleImportFlags = (includeDynamicImports) => includeDynamicImports ? IMPORT_FLAGS.ENTRY : IGNORED_CYCLE_IMPORT_FLAGS;
 export const getExportedIdentifiers = (graph, filePath, visited = new Set()) => {
     if (visited.has(filePath))
         return new Map();
@@ -49,6 +52,56 @@ export const getExportedIdentifiers = (graph, filePath, visited = new Set()) =>
     setCachedExportedIdentifiers(graph, filePath, identifiers);
     return identifiers;
 };
+export const getRuntimeSuccessors = (node, ignoredFlags = IGNORED_CYCLE_IMPORT_FLAGS) => {
+    const successors = new Set();
+    for (const _import of node.imports.imports) {
+        if (_import.filePath &&
+            !_import.isTypeOnly &&
+            !(_import.modifiers & ignoredFlags) &&
+            node.imports.internal.has(_import.filePath)) {
+            successors.add(_import.filePath);
+        }
+    }
+    return successors;
+};
+const getImportKind = (importMaps, identifier, modifiers) => {
+    if (modifiers & IMPORT_FLAGS.DYNAMIC)
+        return 'dynamicImport';
+    if (identifier === IMPORT_STAR && importMaps.reExport.has(IMPORT_STAR))
+        return 'reExportStar';
+    if (identifier && importMaps.reExportNs.has(identifier))
+        return 'reExportNS';
+    if (identifier && importMaps.reExportAs.has(identifier))
+        return 'reExportAs';
+    if (identifier && importMaps.reExport.has(identifier))
+        return 'reExport';
+    if (identifier === IMPORT_STAR && importMaps.importNs.size > 0)
+        return 'importNS';
+    if (identifier && importMaps.importAs.has(identifier))
+        return 'importAs';
+    if (identifier === OPAQUE)
+        return 'dynamicImport';
+    if (identifier === SIDE_EFFECTS)
+        return 'sideEffectImport';
+    return 'import';
+};
+export const getRuntimeImport = (node, filePath, ignoredFlags = IGNORED_CYCLE_IMPORT_FLAGS) => {
+    const importMaps = node.imports.internal.get(filePath);
+    if (!importMaps)
+        return;
+    let result;
+    for (const _import of node.imports.imports) {
+        if (_import.filePath !== filePath || _import.isTypeOnly || _import.modifiers & ignoredFlags)
+            continue;
+        if (!result || _import.line < result.line || (_import.line === result.line && _import.col < result.col)) {
+            result = _import;
+        }
+    }
+    if (!result)
+        return;
+    const { specifier, pos, line, col, identifier, modifiers } = result;
+    return { kind: getImportKind(importMaps, identifier, modifiers), specifier, pos, line, col };
+};
 export const hasStrictlyEnumReferences = (importsForExport, identifier) => {
     if (!importsForExport || !importsForExport.refs.has(identifier))
         return false;

package/dist/plugins/_vue/auto-import.d.ts

@@ -0,0 +1,12 @@
+import { type ParseResult } from 'oxc-parser';
+import type { AutoImportMaps } from './types.ts';
+export declare const readAndParseFile: (filePath: string) => ParseResult;
+export declare const collectLocalImportPaths: (filePath: string, result: ParseResult) => Set<string>;
+export declare function buildAutoImportMap(filePath: string, result: ParseResult, maps: AutoImportMaps, isComponents: boolean): void;
+export declare const createAutoImportMaps: () => AutoImportMaps;
+export declare const findGeneratedDts: (cwd: string, signature: string) => string[];
+export declare const createVueCompiler: (maps: AutoImportMaps, cwd: string) => (source: string, path: string) => string;
+export declare const createTsCompiler: (maps: AutoImportMaps) => (source: string, path: string) => string;
+export declare const vueAutoImportCompiler: (source: string, path: string) => string;
+export declare const tsAutoImportCompiler: (source: string, path: string) => string;
+export declare const markdownAutoImportCompiler: (source: string, path: string) => string;

package/dist/plugins/_vue/auto-import.js

@@ -0,0 +1,272 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { Visitor } from 'oxc-parser';
+import { scriptBodies } from '../../compilers/compilers.js';
+import { stylePreprocessorImports } from '../../compilers/style-preprocessors.js';
+import { _parseFile } from '../../typescript/ast-nodes.js';
+import { isFile } from '../../util/fs.js';
+import { _syncGlob } from '../../util/glob.js';
+import { dirname, isInNodeModules, join } from '../../util/path.js';
+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: '' } },
+        }),
+    };
+};
+const readFile = (filePath) => {
+    try {
+        return readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return '';
+    }
+};
+export const readAndParseFile = (filePath) => _parseFile(filePath, readFile(filePath));
+const collectIdentifiers = (source, fileName) => {
+    const identifiers = new Set();
+    const visitor = new Visitor({
+        Identifier(node) {
+            identifiers.add(node.name);
+        },
+    });
+    visitor.visit(_parseFile(fileName, source).program);
+    return identifiers;
+};
+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 };
+};
+const toKebabCase = (s) => s.replace(/[A-Z]/g, (m, i) => (i ? '-' : '') + m.toLowerCase());
+const isLocalSpecifier = (specifier) => specifier.startsWith('.') && !isInNodeModules(specifier);
+export const collectLocalImportPaths = (filePath, result) => {
+    const dir = dirname(filePath);
+    const paths = new Set();
+    const visitor = new Visitor({
+        TSImportType(node) {
+            const specifier = node.source.value;
+            if (isLocalSpecifier(specifier))
+                paths.add(join(dir, specifier));
+        },
+    });
+    visitor.visit(result.program);
+    return paths;
+};
+export function buildAutoImportMap(filePath, result, maps, isComponents) {
+    const dir = dirname(filePath);
+    const importTypes = [];
+    const collectVisitor = new Visitor({
+        TSImportType(node) {
+            importTypes.push({ start: node.start, end: node.end, specifier: node.source.value });
+        },
+    });
+    collectVisitor.visit(result.program);
+    const addEntry = (name, start, end) => {
+        const importType = importTypes.find(it => it.start >= start && it.end <= end);
+        if (!importType || !isLocalSpecifier(importType.specifier))
+            return;
+        const absSpecifier = join(dir, importType.specifier);
+        if (isComponents) {
+            const components = maps.componentMap.get(name);
+            if (components) {
+                if (!components.includes(absSpecifier))
+                    components.push(absSpecifier);
+            }
+            else
+                maps.componentMap.set(name, [absSpecifier]);
+        }
+        else {
+            maps.importMap.set(name, absSpecifier);
+        }
+    };
+    const matchVisitor = new Visitor({
+        VariableDeclarator(node) {
+            if (node.id?.type !== 'Identifier' || node.id.name.startsWith('Lazy'))
+                return;
+            addEntry(node.id.name, node.start, node.end);
+        },
+        TSPropertySignature(node) {
+            if (!isComponents)
+                return;
+            const key = node.key;
+            const name = key?.type === 'Identifier' ? key.name : key?.type === 'Literal' ? String(key.value) : undefined;
+            if (name)
+                addEntry(name, node.start, node.end);
+        },
+        ExportNamedDeclaration(node) {
+            if (!node.source)
+                return;
+            const specifier = node.source.value;
+            if (!isLocalSpecifier(specifier))
+                return;
+            const absSpecifier = join(dir, specifier);
+            for (const s of node.specifiers) {
+                const name = s.exported.type === 'Identifier' ? s.exported.name : s.exported.value;
+                if (name)
+                    maps.importMap.set(name, absSpecifier);
+            }
+        },
+    });
+    matchVisitor.visit(result.program);
+}
+export const createAutoImportMaps = () => ({ importMap: new Map(), componentMap: new Map() });
+export const findGeneratedDts = (cwd, signature) => _syncGlob({ cwd, patterns: ['*.d.ts', 'src/**/*.d.ts'] }).filter(filePath => readFile(filePath).slice(0, 300).includes(signature));
+const generators = [
+    { signature: 'Generated by unplugin-vue-components', isComponents: true },
+    { signature: 'Generated by unplugin-auto-import', isComponents: false },
+];
+const getVueAutoImportMaps = (cwd) => {
+    const maps = createAutoImportMaps();
+    for (const filePath of _syncGlob({ cwd, patterns: ['*.d.ts', 'src/**/*.d.ts'] })) {
+        const source = readFile(filePath);
+        const generator = generators.find(({ signature }) => source.slice(0, 300).includes(signature));
+        if (generator)
+            buildAutoImportMap(filePath, _parseFile(filePath, source), maps, generator.isComponents);
+    }
+    return maps;
+};
+const getSyntheticImports = (maps, identifiers, templateTags) => {
+    const { importMap, componentMap } = maps;
+    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 compileVueSfc = (source, path, maps, root) => {
+    if (maps.importMap.size === 0 && maps.componentMap.size === 0) {
+        return [scriptBodies(source, path), stylePreprocessorImports(source, path)].filter(Boolean).join(';\n');
+    }
+    const { descriptor } = sfcForRoot(root).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);
+    }
+    scripts.push(...getSyntheticImports(maps, identifiers, templateTags));
+    const styles = stylePreprocessorImports(source, path);
+    if (styles)
+        scripts.push(styles);
+    return scripts.join(';\n');
+};
+const compileTs = (source, path, maps) => {
+    if (maps.importMap.size === 0 || path.endsWith('.d.ts') || path.endsWith('.config.ts'))
+        return source;
+    const syntheticImports = getSyntheticImports(maps, collectIdentifiers(source, path));
+    return syntheticImports.length === 0 ? source : `${source}\n${syntheticImports.join('\n')}`;
+};
+const tagMatcher = /<([a-zA-Z][\w.-]*)/g;
+const fencedCodeMatcher = /(`{3,}|~{3,})[\s\S]*?^[ \t]*\1/gm;
+const inlineCodeMatcher = /`[^`\n]*`/g;
+const stripCode = (md) => md.replace(fencedCodeMatcher, '').replace(inlineCodeMatcher, '');
+const compileMarkdown = (source, path, maps) => {
+    const code = stripCode(source);
+    const scripts = scriptBodies(code, path);
+    if (maps.importMap.size === 0 && maps.componentMap.size === 0)
+        return scripts;
+    const tags = new Set();
+    for (const [, tag] of code.matchAll(tagMatcher))
+        tags.add(tag);
+    const identifiers = scripts ? collectIdentifiers(scripts, path) : new Set();
+    return [scripts, ...getSyntheticImports(maps, identifiers, tags)].filter(Boolean).join(';\n');
+};
+export const createVueCompiler = (maps, cwd) => (source, path) => compileVueSfc(source, path, maps, cwd);
+export const createTsCompiler = (maps) => (source, path) => compileTs(source, path, maps);
+const EMPTY_MAPS = createAutoImportMaps();
+const rootByDir = new Map();
+const mapsByRoot = new Map();
+const sfcByRoot = new Map();
+const findRoot = (fromDir) => {
+    const cached = rootByDir.get(fromDir);
+    if (cached !== undefined)
+        return cached;
+    let dir = fromDir;
+    let root = '';
+    for (;;) {
+        if (isFile(join(dir, 'package.json'))) {
+            root = dir;
+            break;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    rootByDir.set(fromDir, root);
+    return root;
+};
+const mapsForFile = (path) => {
+    const root = findRoot(dirname(path));
+    if (!root)
+        return EMPTY_MAPS;
+    let maps = mapsByRoot.get(root);
+    if (!maps) {
+        maps = getVueAutoImportMaps(root);
+        mapsByRoot.set(root, maps);
+    }
+    return maps;
+};
+function sfcForRoot(root) {
+    let sfc = sfcByRoot.get(root);
+    if (!sfc) {
+        sfc = getVueSfc(root);
+        sfcByRoot.set(root, sfc);
+    }
+    return sfc;
+}
+export const vueAutoImportCompiler = (source, path) => compileVueSfc(source, path, mapsForFile(path), findRoot(dirname(path)));
+export const tsAutoImportCompiler = (source, path) => compileTs(source, path, mapsForFile(path));
+export const markdownAutoImportCompiler = (source, path) => compileMarkdown(source, path, mapsForFile(path));

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

@@ -0,0 +1,38 @@
+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 interface AutoImportMaps {
+    importMap: Map<string, string>;
+    componentMap: Map<string, string[]>;
+}
+export {};

package/dist/plugins/_vue/types.js

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

package/dist/plugins/astro/index.js

@@ -1,47 +1,12 @@
-import { findCallArg, getDefaultImportName, getImportMap, getPropertyValues } from '../../typescript/ast-helpers.js';
-import { toConfig, toDependency, toEntry, toProductionEntry } from '../../util/input.js';
+import { toDependency } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
-import { getAliasInputs } from '../vitest/helpers.js';
 import compiler from './compiler.js';
 import mdxCompiler from './compiler-mdx.js';
-import { getSrcDir, getViteAliases, usesPassthroughImageService } from './resolveFromAST.js';
+import { entry, production, resolveFromAST } from './resolveFromAST.js';
 const title = 'Astro';
 const enablers = ['astro'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 export const config = ['astro.config.{js,cjs,mjs,ts,mts}'];
-const entry = ['src/content/config.ts', 'src/content.config.ts'];
-const production = [
-    'src/pages/**/*.{astro,mdx,js,ts}',
-    '!src/pages/**/_*',
-    '!src/pages/**/_*/**',
-    'src/content/**/*.mdx',
-    'src/middleware.{js,ts}',
-    'src/middleware/index.{js,ts}',
-    'src/actions/index.{js,ts}',
-];
-const resolveFromAST = (program, options) => {
-    const srcDir = getSrcDir(program);
-    const setSrcDir = (entry) => entry.replace(/^src\//, `${srcDir}/`);
-    const inputs = [
-        ...entry.map(setSrcDir).map(path => toEntry(path)),
-        ...production.map(setSrcDir).map(path => toProductionEntry(path)),
-        ...getAliasInputs(getViteAliases(program), options.cwd),
-    ];
-    if (!usesPassthroughImageService(program))
-        inputs.push(toDependency('sharp', { optional: true }));
-    const importMap = getImportMap(program);
-    const lunariaImportName = getDefaultImportName(importMap, '@lunariajs/starlight');
-    if (lunariaImportName) {
-        const lunariaConfig = findCallArg(program, lunariaImportName);
-        if (lunariaConfig) {
-            const configPaths = getPropertyValues(lunariaConfig, 'configPath');
-            for (const id of configPaths) {
-                inputs.push(toConfig('lunaria', id));
-            }
-        }
-    }
-    return inputs;
-};
 const registerCompilers = ({ registerCompiler, hasDependency }) => {
     if (hasDependency('astro'))
         registerCompiler({ extension: '.astro', compiler });

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

@@ -1,4 +1,4 @@
-import type { Program } from 'oxc-parser';
-export declare const getSrcDir: (program: Program) => string;
-export declare const usesPassthroughImageService: (program: Program) => boolean;
-export declare const getViteAliases: (program: Program) => Record<string, string>;
+import type { ResolveFromAST } from '../../types/config.ts';
+export declare const entry: string[];
+export declare const production: string[];
+export declare const resolveFromAST: ResolveFromAST;

package/dist/plugins/astro/resolveFromAST.js

@@ -1,10 +1,19 @@
+import { collectFirstPropertyValue, findImportedCallArg, findProperty, getPropertyKey, getPropertyValues, hasImportSpecifier, resolveObjectArg, } from '../../typescript/ast-helpers.js';
 import { getStringValue } from '../../typescript/ast-nodes.js';
-import { collectPropertyValues, findProperty, getPropertyKey, hasImportSpecifier, resolveObjectArg, } from '../../typescript/ast-helpers.js';
-export const getSrcDir = (program) => {
-    const values = collectPropertyValues(program, 'srcDir');
-    return values.size > 0 ? Array.from(values)[0] : 'src';
-};
-export const usesPassthroughImageService = (program) => hasImportSpecifier(program, 'astro/config', 'passthroughImageService');
+import { toConfig, toDependency, toEntry, toProductionEntry } from '../../util/input.js';
+import { getAliasInputs } from '../vitest/helpers.js';
+export const entry = ['src/content/config.ts', 'src/content.config.ts'];
+export const production = [
+    'src/pages/**/*.{astro,mdx,js,ts}',
+    '!src/pages/**/_*',
+    '!src/pages/**/_*/**',
+    'src/content/**/*.mdx',
+    'src/middleware.{js,ts}',
+    'src/middleware/index.{js,ts}',
+    'src/actions/index.{js,ts}',
+];
+const getSrcDir = (program) => collectFirstPropertyValue(program, 'srcDir') ?? 'src';
+const usesPassthroughImageService = (program) => hasImportSpecifier(program, 'astro/config', 'passthroughImageService');
 const findFirstStringArg = (node) => {
     const literal = getStringValue(node);
     if (literal)
@@ -17,7 +26,7 @@ const findFirstStringArg = (node) => {
         }
     }
 };
-export const getViteAliases = (program) => {
+const getViteAliases = (program) => {
     const aliases = {};
     for (const node of program.body ?? []) {
         if (node.type !== 'ExportDefaultDeclaration')
@@ -40,3 +49,21 @@ export const getViteAliases = (program) => {
     }
     return aliases;
 };
+export const resolveFromAST = (program, options) => {
+    const srcDir = getSrcDir(program);
+    const setSrcDir = (entry) => entry.replace(/^src\//, `${srcDir}/`);
+    const inputs = [
+        ...entry.map(setSrcDir).map(path => toEntry(path)),
+        ...production.map(setSrcDir).map(path => toProductionEntry(path)),
+        ...getAliasInputs(getViteAliases(program), options.cwd),
+    ];
+    if (!usesPassthroughImageService(program))
+        inputs.push(toDependency('sharp', { optional: true }));
+    const lunariaConfig = findImportedCallArg(program, '@lunariajs/starlight');
+    if (lunariaConfig) {
+        for (const id of getPropertyValues(lunariaConfig, 'configPath')) {
+            inputs.push(toConfig('lunaria', id));
+        }
+    }
+    return inputs;
+};

package/dist/plugins/bun/index.js

@@ -1,11 +1,22 @@
+import { isFile } from '../../util/fs.js';
+import { toDeferResolve, toEntry, toIgnore } from '../../util/input.js';
 import parseArgs from '../../util/parse-args.js';
-import { toDeferResolve, toEntry } from '../../util/input.js';
+import { getScriptCommands } from '../../util/scripts.js';
 const title = 'Bun';
-const enablers = ['bun'];
-const hasBunTest = (scripts) => scripts && Object.values(scripts).some(script => /(?<=^|\s)bun test/.test(script));
-const isEnabled = ({ manifest }) => !!hasBunTest(manifest.scripts);
-const config = ['bunfig.toml'];
+const enablers = 'This plugin is enabled when a `bun.lock` or `bun.lockb` file is found or a `bun test` script is configured.';
 const patterns = ['**/*.{test,spec}.{js,jsx,ts,tsx}', '**/*_{test,spec}.{js,jsx,ts,tsx}'];
+const getBunTest = (script) => {
+    for (const { binary, args } of getScriptCommands(script)) {
+        if (binary !== 'bun')
+            continue;
+        const parsed = parseArgs(args, { string: ['timeout', 'rerun-each', 'preload'] });
+        if (parsed._[0] === 'test')
+            return parsed;
+    }
+};
+const hasBunTest = (scripts) => scripts && Object.values(scripts).some(script => typeof script === 'string' && getBunTest(script));
+const isEnabled = ({ cwd, manifest }) => isFile(cwd, 'bun.lock') || isFile(cwd, 'bun.lockb') || !!hasBunTest(manifest.scripts);
+const config = ['bunfig.toml'];
 const resolveConfig = localConfig => {
     const preload = localConfig.test?.preload ?? [];
     return preload.map(specifier => toDeferResolve(specifier));
@@ -20,17 +31,20 @@ const toPatterns = (arg) => {
 };
 const resolve = options => {
     const scripts = { ...options.rootManifest?.scripts, ...options.manifest.scripts };
+    const inputs = [toIgnore('bun', 'dependencies')];
     for (const script of Object.values(scripts)) {
-        if (/(?<=^|\s)bun test/.test(script)) {
-            const parsed = parseArgs(script.split(' '), { string: ['timeout', 'rerun-each', 'preload'] });
-            const args = parsed._.filter(id => id !== 'bun' && id !== 'test');
-            const inputs = (args.length === 0 ? patterns : args.flatMap(toPatterns)).map(toEntry);
-            for (const specifier of [parsed.preload ?? []].flat())
-                inputs.push(toDeferResolve(specifier));
-            return inputs;
-        }
+        if (typeof script !== 'string')
+            continue;
+        const parsed = getBunTest(script);
+        if (!parsed)
+            continue;
+        const targets = parsed._.slice(1);
+        for (const pattern of targets.length === 0 ? patterns : targets.flatMap(toPatterns))
+            inputs.push(toEntry(pattern));
+        for (const specifier of [parsed.preload ?? []].flat())
+            inputs.push(toDeferResolve(specifier));
     }
-    return [];
+    return inputs;
 };
 const plugin = {
     title,

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

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