@oxlint/migrate/dist/src/env_globals.mjs

Generates a `.oxlintrc.json` from a existing eslint flat config

import globals from "globals";
const ES_VERSIONS = [
  6,
  2016,
  2017,
  2018,
  2019,
  2020,
  2021,
  2022,
  2023,
  2024,
  2025,
  2026
];
const OTHER_SUPPORTED_ENVS = [
  "browser",
  "node",
  "shared-node-browser",
  "worker",
  "serviceworker",
  "amd",
  "applescript",
  "atomtest",
  "commonjs",
  "embertest",
  "greasemonkey",
  "jasmine",
  "jest",
  "jquery",
  "meteor",
  "mocha",
  "mongo",
  "nashorn",
  "protractor",
  "prototypejs",
  "phantomjs",
  "shelljs",
  "webextensions",
  "qunit",
  "vitest"
];
const SUPPORTED_ESLINT_PARSERS = ["typescript-eslint/parser"];
const normalizeGlobValue = (value) => {
  if (value === "readable" || value === "readonly" || value === false) {
    return false;
  }
  if (value === "off") {
    return void 0;
  }
  return true;
};
const removeGlobalsWithAreCoveredByEnv = (config) => {
  if (config.globals === void 0 || config.env === void 0) {
    return;
  }
  for (const [env, entries] of Object.entries(globals)) {
    if (config.env[env] === true) {
      for (const entry of Object.keys(entries)) {
        if (normalizeGlobValue(config.globals[entry]) === entries[entry]) {
          delete config.globals[entry];
        }
      }
    }
  }
  if (Object.keys(config.globals).length === 0) {
    delete config.globals;
  }
};
const transformBoolGlobalToString = (config) => {
  if (config.globals === void 0) {
    return;
  }
  for (const [entry, value] of Object.entries(config.globals)) {
    if (value === false || value === "readable") {
      config.globals[entry] = "readonly";
    } else if (value === true || value === "writable") {
      config.globals[entry] = "writeable";
    }
  }
};
const detectEnvironmentByGlobals = (config) => {
  if (config.globals === void 0) {
    return;
  }
  for (const [env, entries] of Object.entries(globals)) {
    if (!env.startsWith("es") && !OTHER_SUPPORTED_ENVS.includes(env)) {
      continue;
    }
    if (env.startsWith("es") && !ES_VERSIONS.includes(parseInt(env.replace(/^es/, "")))) {
      continue;
    }
    let search = Object.keys(entries);
    let matches = search.filter(
      (entry) => (
        // @ts-ignore -- we already checked for undefined
        entry in config.globals && // @ts-ignore -- filtering makes the key to any
        normalizeGlobValue(config.globals[entry]) === entries[entry]
      )
    );
    if (search.length === matches.length) {
      if (config.env === void 0) {
        config.env = {};
      }
      config.env[env] = true;
    }
  }
};
const transformEnvAndGlobals = (eslintConfig, targetConfig, options) => {
  if (eslintConfig.languageOptions?.parser !== void 0 && !SUPPORTED_ESLINT_PARSERS.includes(
    eslintConfig.languageOptions.parser.meta?.name
  )) {
    options?.reporter !== void 0 && options.reporter(
      "special parser detected: " + eslintConfig.languageOptions.parser.meta?.name
    );
  }
  if (eslintConfig.languageOptions?.globals !== void 0) {
    if (targetConfig.globals === void 0) {
      targetConfig.globals = {};
    }
    if (options?.merge) {
      for (const [global, globalSetting] of Object.entries(
        eslintConfig.languageOptions.globals
      )) {
        if (!(global in targetConfig.globals)) {
          targetConfig.globals[global] = globalSetting;
        }
      }
    } else {
      Object.assign(targetConfig.globals, eslintConfig.languageOptions.globals);
    }
  }
  if (eslintConfig.languageOptions?.ecmaVersion !== void 0) {
    if (eslintConfig.languageOptions?.ecmaVersion === "latest") {
      if (targetConfig.env === void 0) {
        targetConfig.env = {};
      }
      const latestVersion = `es${ES_VERSIONS[ES_VERSIONS.length - 1]}`;
      if (!(latestVersion in targetConfig.env)) {
        targetConfig.env[latestVersion] = true;
      }
    } else if (ES_VERSIONS.includes(eslintConfig.languageOptions?.ecmaVersion)) {
      if (targetConfig.env === void 0) {
        targetConfig.env = {};
      }
      const targetVersion = `es${eslintConfig.languageOptions?.ecmaVersion}`;
      if (!(targetVersion in targetConfig.env)) {
        targetConfig.env[targetVersion] = true;
      }
    }
  }
};
const cleanUpUselessOverridesEnv = (config) => {
  if (config.env === void 0 || config.overrides === void 0) {
    return;
  }
  for (const override of config.overrides) {
    if (override.env === void 0) {
      continue;
    }
    for (const [overrideEnv, overrideEnvConfig] of Object.entries(
      override.env
    )) {
      if (overrideEnv in config.env && config.env[overrideEnv] === overrideEnvConfig) {
        delete override.env[overrideEnv];
      }
    }
    if (Object.keys(override.env).length === 0) {
      delete override.env;
    }
  }
};
export {
  ES_VERSIONS,
  cleanUpUselessOverridesEnv,
  detectEnvironmentByGlobals,
  removeGlobalsWithAreCoveredByEnv,
  transformBoolGlobalToString,
  transformEnvAndGlobals
};