repograph/dist/analyzer.worker.cjs

Generate rich, semantic, and interactive codemaps with a functional, composable API for Node.js.

'use strict';

var Parser = require('web-tree-sitter');
var path = require('path');
var fs = require('fs');
var url = require('url');
var repographCore = require('repograph-core');

var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () { return e[k]; }
        });
      }
    });
  }
  n.default = e;
  return Object.freeze(n);
}

var Parser__namespace = /*#__PURE__*/_interopNamespace(Parser);
var path__default = /*#__PURE__*/_interopDefault(path);
var fs__default = /*#__PURE__*/_interopDefault(fs);

// src/tree-sitter/languages.ts
var getDirname = () => path__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('analyzer.worker.cjs', document.baseURI).href))));
var loadedLanguages = /* @__PURE__ */ new Map();
var isInitialized = false;
var initializeParser = async () => {
  if (isInitialized) return;
  await Parser__namespace.Parser.init();
  isInitialized = true;
};
var findWasmFile = async (config) => {
  const wasmFileName = path__default.default.basename(config.wasmPath);
  if (!wasmFileName) {
    throw new repographCore.ParserError(`Invalid wasmPath format for ${config.name}: ${config.wasmPath}.`, config.name);
  }
  const currentDir = getDirname();
  const distWasmPath = path__default.default.resolve(currentDir, "wasm", wasmFileName);
  if (fs__default.default.existsSync(distWasmPath)) return distWasmPath;
  const projectDistWasmPath = path__default.default.resolve(currentDir, "../../dist/wasm", wasmFileName);
  if (fs__default.default.existsSync(projectDistWasmPath)) return projectDistWasmPath;
  try {
    const [pkgName, ...rest] = config.wasmPath.split("/");
    const wasmPathInPkg = rest.join("/");
    const pkgJsonUrl = await undefined(`${pkgName}/package.json`);
    const pkgDir = path__default.default.dirname(url.fileURLToPath(pkgJsonUrl));
    const resolvedWasmPath = path__default.default.join(pkgDir, wasmPathInPkg);
    if (fs__default.default.existsSync(resolvedWasmPath)) {
      return resolvedWasmPath;
    }
  } catch (e) {
  }
  throw new repographCore.ParserError(`WASM file for ${config.name} not found. Looked in ${distWasmPath}, ${projectDistWasmPath}, and tried resolving from node_modules.`, config.name);
};
var loadLanguage = async (config) => {
  if (loadedLanguages.has(config.name)) {
    return loadedLanguages.get(config.name);
  }
  await initializeParser();
  try {
    const wasmPath = await findWasmFile(config);
    repographCore.logger.debug(`Loading WASM for ${config.name} from: ${wasmPath}`);
    const language = await Parser__namespace.Language.load(wasmPath);
    const loadedLanguage = { config, language };
    loadedLanguages.set(config.name, loadedLanguage);
    return loadedLanguage;
  } catch (error) {
    const message = `Failed to load Tree-sitter WASM file for ${config.name}.`;
    repographCore.logger.error(message, error);
    throw new repographCore.ParserError(message, config.name, error);
  }
};
var createParserForLanguage = async (config) => {
  const { language } = await loadLanguage(config);
  const parser = new Parser__namespace.Parser();
  parser.setLanguage(language);
  return parser;
};
async function processFileInWorker({ file, langConfig }) {
  const parser = await createParserForLanguage(langConfig);
  return repographCore.analyzeFileContent({ file, langConfig, parser });
}

module.exports = processFileInWorker;
//# sourceMappingURL=analyzer.worker.cjs.map
//# sourceMappingURL=analyzer.worker.cjs.map