@ramadan04/eslint-plugin-baseline

Plugin ESLint para detectar el uso de features de JavaScript según la base de compatibilidad "Baseline" (integrado con TypeScript para comprobaciones con información de tipos).

Este plugin expone reglas centradas en identificar APIs y métodos que no están ampliamente soportados en determinados años de Baseline y reportarlos en tiempo de lint.

Características

• Regla principal: no-unsupported — Detecta llamadas a métodos y accesos a propiedades de prototipos que Baseline marca como no suficientemente soportados para un año objetivo.
• Funciona con TypeScript y aprovecha la información de tipos (typed linting) para resolver el tipo del objeto y mapearlo correctamente a la entrada de Baseline (por ejemplo: String.prototype.replaceAll()).

Instalación

Instala el paquete desde npm y las dependencias recomendadas para TypeScript linting:

# Desde la carpeta de tu proyecto que consume el plugin
npm install --save-dev @ramadan04/eslint-plugin-baseline
npm install --save-dev typescript @typescript-eslint/parser @typescript-eslint/eslint-plugin

Si usas pnpm o yarn, usa el gestor equivalente.

Uso

En un archivo de configuración de ESLint (ej: .eslintrc.js, eslint.config.mjs o eslint.config.mts) registra el plugin y activa la regla:

Ejemplo minimal con la configuración "flat" (eslint.config.mjs / eslint.config.mts):

import globals from "globals";
import tsplugin from "@typescript-eslint/eslint-plugin";
const baseline = require("@ramadan04/eslint-plugin-baseline");

export default [
  {
    files: ["**/*.{ts,tsx,js,jsx,mjs,cjs,mts,cts}"],
    languageOptions: {
      parser: require.resolve("@typescript-eslint/parser"),
      parserOptions: {
        project: "./tsconfig.json",
        tsconfigRootDir: __dirname,
        sourceType: "module"
      },
      globals: globals.browser
    },
    plugins: {
      "@ramadan04/baseline": baseline
    },
    rules: {
      "@ramadan04/baseline/no-unsupported": ["error", { year: 2024 }]
    }
  }
];

Si usas la configuración tradicional (.eslintrc.js) registra el plugin normalmente:

module.exports = {
  parser: "@typescript-eslint/parser",
  parserOptions: {
    project: "./tsconfig.json",
  },
  plugins: ["@ramadan04/baseline"],
  rules: {
    "@ramadan04/baseline/no-unsupported": ["error", { year: 2024 }]
  }
};

Configuración de TypeScript (typed linting)

La regla no-unsupported necesita información de tipos para resolver correctamente el tipo del objeto. Para habilitarlo debes:

1. Tener un tsconfig.json en el proyecto consumidor.
2. En la configuración de ESLint setear parserOptions.project apuntando a ese tsconfig.json.

Ejemplo:

// tsconfig.json
{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "strict": true
  },
  "include": ["src/**/*", "test/**/*"]
}

Y en ESLint:

parserOptions: { project: "./tsconfig.json" }

Si no proporcionas parserOptions.project, la regla no reportará nada que dependa de información de tipos y ESLint mostrará un mensaje indicando que habilites typed linting.

Ejemplos

Código que será reportado como no soportado si year es 2023 (pero no en 2024):

const s = "hello";
// String.prototype.replaceAll fue añadido ampliamente en Baseline 2024
s.replaceAll("l", "L");

Código soportado en Baseline 2024:

const arr = [1,2,3];
arr.at(0); // Array.prototype.at también está en Baseline 2024

API / Reglas

• @ramadan04/baseline/no-unsupported — regla que detecta features no soportadas.
  • Opciones: objeto { year: number } (por defecto el año actual)

Publicación en npm

Antes de publicar, asegúrate de que package.json tenga los campos name = @ramadan04/eslint-plugin-baseline, version, main (apunta al index.js) y types si incluyes declaraciones. Un ejemplo mínimo:

{
  "name": "@ramadan04/eslint-plugin-baseline",
  "version": "0.0.0",
  "main": "index.js",
  "types": "index.d.ts",
  "files": ["lib/**/*", "index.js", "index.d.ts"]
}

Si no incluyes index.d.ts, los consumidores TypeScript verán un warning; puedes crear un archivo index.d.ts que declare el módulo con any como tipo para evitar ese mensaje.

Notas internas y limitaciones

• La regla utiliza la librería web-features para mapear nombres de features. La cobertura depende de los datos de esa librería.
• Para detectar correctamente prototipos (String.prototype.replaceAll) la regla resuelve el tipo del objeto y construye el nombre desde la combinación tipo + propiedad.
• Actualmente la regla solo informa sobre MemberExpression y llamadas de métodos; podrías extenderla para NewExpression u otros patrones.

Contribuciones

Pull requests y issues bienvenidos. Asegúrate de incluir tests y ejemplos reproducibles.

Licencia

MIT