repomix/lib/core/treeSitter/languageConfig.js

A tool to pack repository contents to single file for AI consumption

import { CssParseStrategy } from './parseStrategies/CssParseStrategy.js';
import { DefaultParseStrategy } from './parseStrategies/DefaultParseStrategy.js';
import { GoParseStrategy } from './parseStrategies/GoParseStrategy.js';
import { PythonParseStrategy } from './parseStrategies/PythonParseStrategy.js';
import { TypeScriptParseStrategy } from './parseStrategies/TypeScriptParseStrategy.js';
import { VueParseStrategy } from './parseStrategies/VueParseStrategy.js';
import { queryC } from './queries/queryC.js';
import { queryCpp } from './queries/queryCpp.js';
import { queryCSharp } from './queries/queryCSharp.js';
import { queryCss } from './queries/queryCss.js';
import { queryDart } from './queries/queryDart.js';
import { queryGo } from './queries/queryGo.js';
import { queryJava } from './queries/queryJava.js';
import { queryJavascript } from './queries/queryJavascript.js';
import { queryPhp } from './queries/queryPhp.js';
import { queryPython } from './queries/queryPython.js';
import { queryRuby } from './queries/queryRuby.js';
import { queryRust } from './queries/queryRust.js';
import { querySolidity } from './queries/querySolidity.js';
import { querySwift } from './queries/querySwift.js';
import { queryTypescript } from './queries/queryTypescript.js';
import { queryVue } from './queries/queryVue.js';
export const LANGUAGE_CONFIGS = [
    {
        name: 'javascript',
        extensions: ['js', 'jsx', 'cjs', 'mjs', 'mjsx'],
        query: queryJavascript,
        createStrategy: () => new TypeScriptParseStrategy(),
    },
    {
        name: 'typescript',
        extensions: ['ts', 'tsx', 'mts', 'mtsx', 'cts'],
        query: queryTypescript,
        createStrategy: () => new TypeScriptParseStrategy(),
    },
    {
        name: 'python',
        extensions: ['py'],
        query: queryPython,
        createStrategy: () => new PythonParseStrategy(),
    },
    {
        name: 'go',
        extensions: ['go'],
        query: queryGo,
        createStrategy: () => new GoParseStrategy(),
    },
    {
        name: 'rust',
        extensions: ['rs'],
        query: queryRust,
        createStrategy: () => new DefaultParseStrategy(),
    },
    {
        name: 'java',
        extensions: ['java'],
        query: queryJava,
        createStrategy: () => new DefaultParseStrategy(),
    },
    {
        name: 'c_sharp',
        extensions: ['cs'],
        query: queryCSharp,
        createStrategy: () => new DefaultParseStrategy(),
    },
    {
        name: 'ruby',
        extensions: ['rb'],
        query: queryRuby,
        createStrategy: () => new DefaultParseStrategy(),
    },
    {
        name: 'php',
        extensions: ['php'],
        query: queryPhp,
        createStrategy: () => new DefaultParseStrategy(),
    },
    {
        name: 'swift',
        extensions: ['swift'],
        query: querySwift,
        createStrategy: () => new DefaultParseStrategy(),
    },
    {
        name: 'c',
        extensions: ['c', 'h'],
        query: queryC,
        createStrategy: () => new DefaultParseStrategy(),
    },
    {
        name: 'cpp',
        extensions: ['cpp', 'hpp'],
        query: queryCpp,
        createStrategy: () => new DefaultParseStrategy(),
    },
    {
        name: 'css',
        extensions: ['css'],
        query: queryCss,
        createStrategy: () => new CssParseStrategy(),
    },
    {
        name: 'solidity',
        extensions: ['sol'],
        query: querySolidity,
        createStrategy: () => new DefaultParseStrategy(),
    },
    {
        name: 'vue',
        extensions: ['vue'],
        query: queryVue,
        createStrategy: () => new VueParseStrategy(),
    },
    {
        name: 'dart',
        extensions: ['dart'],
        query: queryDart,
        createStrategy: () => new DefaultParseStrategy(),
    },
];
let extensionToLanguageMap = null;
let languageNameToConfigMap = null;
function buildLookupMaps() {
    const extensionMap = new Map();
    const nameMap = new Map();
    for (const config of LANGUAGE_CONFIGS) {
        for (const ext of config.extensions) {
            const existing = extensionMap.get(ext);
            if (existing) {
                throw new Error(`Duplicate extension '${ext}' found: claimed by both '${existing.name}' and '${config.name}'`);
            }
            extensionMap.set(ext, config);
        }
        nameMap.set(config.name, config);
    }
    return { extensionMap, nameMap };
}
function getLookupMaps() {
    if (!extensionToLanguageMap || !languageNameToConfigMap) {
        const maps = buildLookupMaps();
        extensionToLanguageMap = maps.extensionMap;
        languageNameToConfigMap = maps.nameMap;
    }
    return {
        extensionMap: extensionToLanguageMap,
        nameMap: languageNameToConfigMap,
    };
}
export function getLanguageConfigByExtension(extension) {
    const { extensionMap } = getLookupMaps();
    return extensionMap.get(extension);
}
export function getLanguageConfigByName(languageName) {
    const { nameMap } = getLookupMaps();
    return nameMap.get(languageName);
}
export function getSupportedLanguages() {
    return LANGUAGE_CONFIGS.map((config) => config.name);
}