knip 6.25.0 → 6.27.0

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

@@ -0,0 +1,332 @@
+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 {
+        const sfc = createRequire(join(cwd, 'package.json'))('vue/compiler-sfc');
+        if (typeof sfc.parseComponent === 'function') {
+            return {
+                parse: (source, path) => ({
+                    descriptor: sfc.parse({ source, filename: path, sourceMap: false }),
+                }),
+                compileTemplate: (source, path, isTS, preprocessLang) => sfc.compileTemplate({
+                    source,
+                    filename: path,
+                    sourceMap: false,
+                    isProduction: true,
+                    prettify: false,
+                    isTS,
+                    preprocessLang,
+                }),
+            };
+        }
+        return {
+            parse: (source, path) => sfc.parse(source, { filename: path, sourceMap: false }),
+        };
+    }
+    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 visited = new Set();
+    const addExprIdentifiers = (expr) => {
+        for (const id of collectIdentifiers(expr, 'expr.ts'))
+            identifiers.add(id);
+    };
+    const visit = (node) => {
+        if (visited.has(node))
+            return;
+        visited.add(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);
+        if (node.ifConditions)
+            for (const condition of node.ifConditions)
+                visit(condition.block);
+        if (node.scopedSlots)
+            for (const name in node.scopedSlots)
+                visit(node.scopedSlots[name]);
+    };
+    visit(tree);
+    return { tags, identifiers };
+};
+const collectVue2TemplateIdentifiers = (source) => {
+    const identifiers = new Set();
+    const visitor = new Visitor({
+        MemberExpression(node) {
+            if (!node.computed &&
+                node.object.type === 'Identifier' &&
+                node.object.name === '_vm' &&
+                node.property.type === 'Identifier') {
+                const name = node.property.name;
+                if (name !== '_self' && name !== '$set' && name !== '$delete' && !(name.length === 2 && name[0] === '_')) {
+                    identifiers.add(name);
+                }
+            }
+        },
+    });
+    visitor.visit(_parseFile('template.js', source).program);
+    return 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 sfc = sfcForRoot(root);
+    const { descriptor } = sfc.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);
+    const template = descriptor.template;
+    const compiled = template && !template.ast && sfc.compileTemplate
+        ? sfc.compileTemplate(template.content, path, descriptor.script?.lang === 'ts' ||
+            descriptor.script?.lang === 'tsx' ||
+            descriptor.scriptSetup?.lang === 'ts' ||
+            descriptor.scriptSetup?.lang === 'tsx', template.lang)
+        : undefined;
+    let templateTags;
+    const templateAst = template?.ast ?? compiled?.ast;
+    if (templateAst) {
+        const info = collectTemplateInfo(templateAst);
+        templateTags = info.tags;
+        for (const id of info.identifiers)
+            identifiers.add(id);
+    }
+    if (compiled?.code) {
+        for (const id of collectVue2TemplateIdentifiers(compiled.code))
+            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,45 @@
+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[];
+    ifConditions?: {
+        block: TemplateAstNode;
+    }[];
+    scopedSlots?: Record<string, TemplateAstNode>;
+}
+interface DescriptorBlock {
+    content: string;
+    lang?: string;
+}
+interface Descriptor {
+    script: DescriptorBlock | null;
+    scriptSetup: DescriptorBlock | null;
+    template: (DescriptorBlock & {
+        ast?: TemplateAstNode;
+    }) | null;
+}
+export interface VueSfc {
+    parse: (source: string, path: string) => {
+        descriptor: Descriptor;
+    };
+    compileTemplate?: (source: string, path: string, isTS: boolean, preprocessLang?: string) => {
+        ast?: TemplateAstNode;
+        code: string;
+    };
+}
+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/electron-vite/index.d.ts

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

package/dist/plugins/electron-vite/index.js

@@ -0,0 +1,51 @@
+import { toProductionEntry } from '../../util/input.js';
+import { isAbsolute, join } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+import { getHtmlScriptEntries } from '../vite/helpers.js';
+const title = 'electron-vite';
+const enablers = ['electron-vite'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['electron.vite.config.{js,mjs,cjs,ts,mts,cts}'];
+const defaultEntry = {
+    main: 'src/main/index.{js,mjs,cjs,ts,mts,cts}',
+    preload: 'src/preload/index.{js,mjs,cjs,ts,mts,cts}',
+    renderer: 'src/renderer/index.html',
+};
+const production = Object.values(defaultEntry);
+const buildEnv = { command: 'build', mode: 'production' };
+const resolveConfig = async (localConfig, options) => {
+    const { configFileDir } = options;
+    const config = typeof localConfig === 'function' ? await localConfig(buildEnv) : localConfig;
+    const inputs = [];
+    for (const name of ['main', 'preload', 'renderer']) {
+        let section = config?.[name];
+        if (typeof section === 'function')
+            section = await section(buildEnv);
+        const ids = [];
+        for (const input of [section?.build?.rollupOptions?.input, section?.build?.lib?.entry]) {
+            if (typeof input === 'string')
+                ids.push(input);
+            else if (input)
+                ids.push(...Object.values(input));
+        }
+        const patterns = ids.length > 0 ? ids : [defaultEntry[name]];
+        for (const id of patterns) {
+            const resolved = isAbsolute(id) ? id : join(configFileDir, id);
+            inputs.push(toProductionEntry(resolved));
+            if (name === 'renderer' && resolved.endsWith('.html')) {
+                for (const input of await getHtmlScriptEntries(resolved))
+                    inputs.push(input);
+            }
+        }
+    }
+    return inputs;
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    production,
+    resolveConfig,
+};
+export default plugin;

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

@@ -0,0 +1,23 @@
+type EntryInput = string | string[] | Record<string, string>;
+interface ViteBuildConfig {
+    build?: {
+        rollupOptions?: {
+            input?: EntryInput;
+        };
+        lib?: {
+            entry?: EntryInput;
+        };
+    };
+}
+type ConfigEnv = {
+    command: string;
+    mode: string;
+};
+type Section = ViteBuildConfig | ((env: ConfigEnv) => ViteBuildConfig | Promise<ViteBuildConfig>);
+type ElectronViteConfigObject = {
+    main?: Section;
+    preload?: Section;
+    renderer?: Section;
+};
+export type ElectronViteConfig = ElectronViteConfigObject | ((env: ConfigEnv) => ElectronViteConfigObject | Promise<ElectronViteConfigObject>);
+export {};

package/dist/plugins/electron-vite/types.js

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

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

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

package/dist/plugins/esbuild/index.js

@@ -0,0 +1,17 @@
+import { collectPropertyValues } from '../../typescript/ast-helpers.js';
+import { toProductionEntry } from '../../util/input.js';
+import { join } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+const title = 'esbuild';
+const enablers = ['esbuild'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['esbuild.config.{js,mjs,cjs,ts,mts,cts}', 'esbuild.{js,mjs,cjs,ts,mts,cts}'];
+const resolveFromAST = (program, { configFileDir }) => [...collectPropertyValues(program, 'entryPoints')].map(id => toProductionEntry(join(configFileDir, id)));
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    resolveFromAST,
+};
+export default plugin;

package/dist/plugins/eslint/resolveFromAST.js

@@ -1,9 +1,16 @@
 import { Visitor } from 'oxc-parser';
 import { toDeferResolve } from '../../util/input.js';
-import { findProperty } from '../../typescript/ast-helpers.js';
+import { findProperty, getPropertyKey } from '../../typescript/ast-helpers.js';
+import { getStringValue } from '../../typescript/ast-nodes.js';
 import { isInternal } from '../../util/path.js';
 export const getInputsFromFlatConfigAST = (program) => {
     const inputs = [];
+    const addResolver = (key, resolver) => {
+        if (!resolver || resolver === 'node' || isInternal(resolver))
+            return;
+        const dep = key === 'import/resolver' ? `eslint-import-resolver-${resolver}` : resolver;
+        inputs.push(toDeferResolve(dep, { optional: true }));
+    };
     const visitor = new Visitor({
         ObjectExpression(node) {
             const settingsNode = findProperty(node, 'settings');
@@ -12,28 +19,18 @@ export const getInputsFromFlatConfigAST = (program) => {
             for (const prop of settingsNode.properties ?? []) {
                 if (prop.type !== 'Property')
                     continue;
-                const key = prop.key?.name ?? prop.key?.value;
-                if (key === 'import/resolver' || key === 'import/parsers') {
-                    if (prop.value?.type === 'ObjectExpression') {
-                        for (const p of prop.value.properties ?? []) {
-                            if (p.type !== 'Property')
-                                continue;
-                            const resolver = p.key?.name ?? p.key?.value;
-                            if (resolver && resolver !== 'node' && !isInternal(resolver)) {
-                                const dep = key === 'import/resolver' ? `eslint-import-resolver-${resolver}` : resolver;
-                                inputs.push(toDeferResolve(dep, { optional: true }));
-                            }
-                        }
-                    }
-                    else if (prop.value?.type === 'StringLiteral' ||
-                        (prop.value?.type === 'Literal' && typeof prop.value.value === 'string')) {
-                        const resolver = prop.value.value;
-                        if (resolver && resolver !== 'node' && !isInternal(resolver)) {
-                            const dep = key === 'import/resolver' ? `eslint-import-resolver-${resolver}` : resolver;
-                            inputs.push(toDeferResolve(dep, { optional: true }));
-                        }
+                const key = getPropertyKey(prop);
+                if (key !== 'import/resolver' && key !== 'import/parsers')
+                    continue;
+                if (prop.value?.type === 'ObjectExpression') {
+                    for (const p of prop.value.properties ?? []) {
+                        if (p.type === 'Property')
+                            addResolver(key, getPropertyKey(p));
                     }
                 }
+                else {
+                    addResolver(key, getStringValue(prop.value));
+                }
             }
         },
     });