0.0.4

règles/javascript.ts

@@ -0,0 +1,65 @@
+import type { Linter } from "eslint";
+
+import javascript from "@eslint/js";
+
+export const règlesJavaScript: Readonly<Linter.Config> = {
+  name: "JavaScript",
+  rules: {
+    ...javascript.configs.recommended.rules,
+    /**
+     * Impose la présence de déclarations `return` dans les _callbacks_ des méthodes `Array`. Il est autorisé ici
+     * l'usage de valeurs de retour en `void` et la vérification de valeurs de retour superflues pour `forEach()`.
+     *
+     * @link [ESLint](https://eslint.org/docs/latest/rules/array-callback-return)
+     */
+    "array-callback-return": ["error", { allowVoid: true, checkForEach: true }],
+    /**
+     * Interdit la définition de fonctions avec plus de 3 paramètres.
+     *
+     * @link [ESLint](https://eslint.org/docs/latest/rules/max-params#max)
+     */
+    "max-params": ["error", { max: 3 }],
+    /** Surchargé par une meilleur version présente dans le plugin _Unicorn_. */
+    "no-nested-ternary": "off",
+    /**
+     * Interdit l'usage de variables lues sans être préalablement assignées.
+     *
+     * @link [ESLint](https://eslint.org/docs/latest/rules/no-unassigned-vars)
+     */
+    "no-unassigned-vars": "error",
+    /**
+     * Interdit l'usage d'opérateurs ternaires quand des opérations plus simples existent. Cela inclut ici l'usage de
+     * ternaires comme opération d'assignation par défaut d'une valeur.
+     *
+     * @link [ESLint](https://eslint.org/docs/latest/rules/no-unneeded-ternary)
+     */
+    "no-unneeded-ternary": ["error", { defaultAssignment: false }],
+    /**
+     * Interdit l'usage de boucles ne permettant qu'une seule itération. Par la nature de l'analyse statique de code,
+     * certains cas peuvent ne pas être détectées.
+     *
+     * @link [ESLint](https://eslint.org/docs/latest/rules/no-unreachable-loop)
+     */
+    "no-unreachable-loop": "error",
+    /**
+     * Interdit l'usage de variables non définies.
+     *
+     * @link [ESLint](https://eslint.org/docs/latest/rules/no-use-before-define)
+     */
+    "no-use-before-define": "error",
+    /**
+     * Interdit l'assignation de variables non utilisées. Par la nature de l'analyse statique de code, certains cas
+     * peuvent ne pas être détectées.
+     *
+     * @link [ESLint](https://eslint.org/docs/latest/rules/no-useless-assignment)
+     */
+    "no-useless-assignment": "error",
+    /**
+     * Interdit ici l'usage de conditions « [Yoda](https://en.wikipedia.org/wiki/Yoda_conditions) » pour des soucis de
+     * lisibilité du code.
+     *
+     * @link [ESLint](https://eslint.org/docs/latest/rules/yoda)
+     */
+    yoda: ["error", "never"],
+  },
+};

règles/programmation-fonctionnelle.ts

@@ -0,0 +1,39 @@
+import type { Linter } from "eslint";
+
+import functional from "eslint-plugin-functional";
+import typescriptEslint from "typescript-eslint";
+
+export const règlesProgrammationFonctionnelle: Readonly<Linter.Config> = {
+  name: "Programmation fonctionnelle",
+  plugins: { functional: functional as typeof typescriptEslint.plugin },
+  rules: {
+    ...functional.configs.noExceptions.rules,
+    ...functional.configs.noMutations.rules,
+    ...functional.configs.externalTypeScriptRecommended.rules,
+    ...functional.configs.stylistic.rules,
+    // Choix stylistique.
+    "@typescript-eslint/array-type": ["error", { default: "generic", readonly: "generic" }],
+    // L'imposition d'une immutabilité plus importante est extrêmement contraignante.
+    "functional/prefer-immutable-types": ["error", { enforcement: "ReadonlyShallow" }],
+    // Le style tacite complique la lecture du code.
+    "functional/prefer-tacit": "off",
+    // Choix stylistique.
+    "functional/readonly-type": ["error", "generic"],
+    // L'imposition d'une immutabilité plus importante est extrêmement contraignante.
+    "functional/type-declaration-immutability": [
+      "error",
+      {
+        ignoreInterfaces: false,
+        rules: [
+          {
+            comparator: "AtLeast",
+            fixer: false,
+            identifiers: "^(?!I?Mutable).+",
+            immutability: "ReadonlyShallow",
+            suggestions: false,
+          },
+        ],
+      },
+    ],
+  },
+};

règles/tri.ts

@@ -0,0 +1,8 @@
+import type { Linter } from "eslint";
+
+import perfectionist from "eslint-plugin-perfectionist";
+
+export const règlesTri: Readonly<Linter.Config> = {
+  plugins: perfectionist.configs["recommended-natural"].plugins ?? {},
+  rules: perfectionist.configs["recommended-natural"].rules ?? {},
+};

règles/typescript.ts

@@ -0,0 +1,33 @@
+import type { Linter } from "eslint";
+
+import typescriptEslint from "typescript-eslint";
+
+type EsLintConfig = Readonly<Linter.Config>;
+
+const trouveConfiguration = (configuration: ReadonlyArray<Linter.Config>, nom: string): EsLintConfig =>
+  configuration.find((v: EsLintConfig) => v.name === nom) ?? {};
+
+const base = trouveConfiguration(typescriptEslint.configs.strictTypeChecked, "typescript-eslint/base");
+const desactivationsJavaScript = trouveConfiguration(
+  typescriptEslint.configs.strictTypeChecked,
+  "typescript-eslint/eslint-recommended",
+);
+const strictTypeChecked = trouveConfiguration(
+  typescriptEslint.configs.strictTypeChecked,
+  "typescript-eslint/strict-type-checked",
+);
+const stylisticTypeChecked = trouveConfiguration(
+  typescriptEslint.configs.stylisticTypeChecked,
+  "typescript-eslint/stylistic-type-checked",
+);
+
+export const règlesTypeScript: Readonly<Linter.Config> = {
+  languageOptions: base.languageOptions ?? {},
+  name: "TypeScript",
+  plugins: base.plugins ?? {},
+  rules: {
+    ...desactivationsJavaScript.rules,
+    ...strictTypeChecked.rules,
+    ...stylisticTypeChecked.rules,
+  },
+};

règles/unicorn.ts

@@ -0,0 +1,43 @@
+import type { Linter } from "eslint";
+
+import unicorn from "eslint-plugin-unicorn";
+
+export const règlesUnicorn: Readonly<Linter.Config> = {
+  name: "Unicorn",
+  plugins: { unicorn: unicorn },
+  rules: {
+    ...unicorn.configs.unopinionated.rules,
+    /**
+     * Impose un nom de paramètre spécifique dans les clauses de capture des Erreurs.
+     *
+     * @link [GitHub](https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/catch-error-name.md)
+     */
+    "unicorn/catch-error-name": ["error"],
+    /**
+     * Préfère des types consistants lors de l'étalage d'un tableau de littéraux au sein d'une condition ternaire.
+     *
+     * @link [GitHub](https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-empty-array-spread.md)
+     */
+    "unicorn/consistent-empty-array-spread": ["error"],
+    /**
+     * Impose l'unique manière valide d'étendre la classe `Error`.
+     *
+     * @link [GitHub](https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/custom-error-definition.md)
+     */
+    "unicorn/custom-error-definition": ["error"],
+    /**
+     * Impose la comparaison explicite de propriétés `length` ou `size`. Cela inclut ici l'obligation de vérifier
+     * qu'elles ne correspondent pas à `0` avec `!==`.
+     *
+     * @link [GitHub](https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/explicit-length-check.md)
+     */
+    "unicorn/explicit-length-check": ["error", { "non-zero": "not-equal" }],
+    /**
+     * Interdit l'usage d'opérateurs ternaires imbriqués. Cette règle remplace celle présente par défaut dans _ESLint_
+     * avec le même nom.
+     *
+     * @link [GitHub](https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-nested-ternary.md)
+     */
+    "unicorn/no-nested-ternary": ["error"],
+  },
+};