@alveole/eslint-config 1.9.0 → 2.0.0-alpha

package/README.md

@@ -10,3 +10,21 @@ Dans un workspace:
 // eslint.config.js
 module.exports = require('@alveole/eslint-config');
 ```
+
+## Seuils de complexité et gel fermé
+
+Les règles de complexité sont posées au niveau visé, pas au niveau constaté. La dette
+existante a été gelée le temps de l'absorber, dans le `eslint-suppressions.json` de chaque
+workspace. **Les quatre workspaces sont désormais à zéro, et le gel est fermé** : la CI
+échoue si un `eslint-suppressions.json` retient la moindre offense.
+
+```sh
+pnpm run check:suppressions
+```
+
+Conséquence pour qui écrit du code ici : une violation se corrige, elle ne se gèle plus.
+`--suppress-all` et `--suppress-rule` ne sont plus une issue, et un `eslint-disable` inline
+est une décision de revue, pas un réflexe.
+
+Si une règle s'avère mal calibrée, c'est la règle qui se discute, dans ce paquet, pour tout
+le monde à la fois. Geler une exception au cas par cas revenait à la discuter nulle part.

package/index.js

@@ -3,14 +3,36 @@ const expoConfig = require('eslint-config-expo/flat');
 const sharedRules = require('./rules/_shared');
 const styleRules = require('./rules/styles');
 const serviceRules = require('./rules/services');
+const accessibilityRules = require('./rules/accessibility');
+const complexityRules = require('./rules/complexity');
+const sonarjsRules = require('./rules/sonarjs');
+const catalogueRules = require('./rules/catalogues');
+const configurationRules = require('./rules/configuration');
+const chargementParesseuxRules = require('./rules/chargement-paresseux');
+const testRules = require('./rules/tests');
+const typageRules = require('./rules/typage');
+const directiveRules = require('./rules/directives');
 
 /** @type {import('eslint').Linter.Config[]} */
 const config = defineConfig([
   expoConfig,
   { ignores: ['dist/**', '**/public/pdf.*.mjs'] },
+  // Une directive qui ne désactive plus rien est un vestige : elle laisse croire qu'une règle
+  // gêne encore à cet endroit, et elle survit au correctif qui l'a rendue inutile. Deux des huit
+  // directives levées ici ont été repérées exactement comme ça.
+  { linterOptions: { reportUnusedDisableDirectives: 'error' } },
   sharedRules,
   styleRules,
   serviceRules,
+  accessibilityRules,
+  complexityRules,
+  sonarjsRules,
+  catalogueRules,
+  configurationRules,
+  chargementParesseuxRules,
+  testRules,
+  typageRules,
+  directiveRules,
 ]);
 
 module.exports = config;

package/package.json

@@ -1,30 +1,30 @@
 {
   "name": "@alveole/eslint-config",
-  "version": "1.9.0",
+  "version": "2.0.0-alpha",
   "description": "ESLint flat config pour les projets Alveole",
   "main": "index.js",
-  "scripts": {
-    "build": "echo \"Nothing to build for @alveole/eslint-config\"",
-    "lint": "eslint .",
-    "typecheck": "echo \"Nothing to typecheck for @alveole/eslint-config\""
-  },
   "files": [
     "index.js",
     "rules",
     "README.md"
   ],
   "peerDependencies": {
-    "eslint": "^9.0.0"
+    "eslint": "^9.0.0 || ^10.0.0"
   },
   "dependencies": {
-    "@uiw/react-signature": "1.3.5",
-    "eslint-config-expo": "57.0.1",
-    "react-native-signature-canvas": "5.1.1"
+    "@eslint-community/eslint-plugin-eslint-comments": "4.8.1",
+    "eslint-config-expo": "57.0.2",
+    "eslint-plugin-sonarjs": "4.2.2"
   },
   "devDependencies": {
-    "eslint": "9.39.5"
+    "eslint": "10.10.0"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "build": "echo \"Nothing to build for @alveole/eslint-config\"",
+    "lint": "eslint .",
+    "typecheck": "echo \"Nothing to typecheck for @alveole/eslint-config\""
   }
-}
+}

package/rules/_shared.js

@@ -129,6 +129,19 @@ const config = {
           'JSXAttribute[name.name=/^(justifyContent|justifyItems|justifySelf|alignItems|alignContent|alignSelf)$/]',
         message: "Cette prop CSS ne fonctionne pas directement sur Box. Passer par style={{ justifyContent: '...' }}.",
       },
+      {
+        // Une double assertion `x as unknown as T` (ou `as any as T`) passe par un type qui
+        // accepte tout, donc TypeScript ne verifie plus rien entre `x` et `T` : on peut lui
+        // faire affirmer n'importe quoi. C'est exactement ce qui a laisse passer un faux
+        // `ResizeObserver` a la signature fausse sans que le typecheck bronche. La regle ne
+        // l'interdit pas absolument - elle le fait remonter en revue : chaque contournement du
+        // typage doit etre un choix visible, jamais un reflexe. Les neuf occurrences du catalogue
+        // venaient toutes d'un meme type menteur (`StoryModule`) : avant de contourner, verifier
+        // que ce n'est pas le type qu'il faut corriger.
+        selector: 'TSAsExpression > TSAsExpression[typeAnnotation.type=/^TS(Unknown|Any)Keyword$/]',
+        message:
+          'Double assertion `as unknown as` / `as any as` : elle desactive la verification de type sur cette expression. Preferer une valeur correctement typee ; si le contournement est indispensable, le justifier en revue.',
+      },
     ],
     'no-redeclare': 'off',
     '@typescript-eslint/no-redeclare': ['error', { ignoreDeclarationMerge: true }],
@@ -141,6 +154,14 @@ const config = {
         message: 'N’utilisez pas window.open. Utilisez Linking.openURL (expo) à la place.',
       },
     ],
+    // Les cycles d'imports cassent silencieusement le runtime (modules partiellement
+    // initialisés, `undefined` au lieu d'un composant) et ne se voient ni au typecheck ni
+    // au build. La règle verrouille le travail de décyclage déjà fait.
+    // disableScc: le graphe de composantes fortement connexes fait tomber la règle en
+    // TypeError quand un chemin n'est pas résolvable (no-cycle.js lit `scc[myPath]` sans
+    // vérifier le null retourné par scc.js), et coûte ici deux fois plus cher qu'il ne
+    // rapporte. Sans lui la détection est identique, mesurée sur un cycle réintroduit.
+    'import/no-cycle': ['error', { maxDepth: 6, ignoreExternal: true, disableScc: true }],
     'no-unused-vars': 'off',
     '@typescript-eslint/no-unused-vars': [
       'error',

package/rules/accessibility.js

@@ -0,0 +1,84 @@
+const TOUCHABLE_ELEMENTS = new Set([
+  'Pressable',
+  'TouchableOpacity',
+  'TouchableHighlight',
+  'TouchableWithoutFeedback',
+  'TouchableNativeFeedback',
+]);
+
+const accessibilityPlugin = {
+  rules: {
+    'touchable-needs-role': {
+      meta: {
+        type: 'problem',
+        docs: {
+          description:
+            'Impose un accessibilityRole sur les zones tactiles, sans quoi les lecteurs d’écran les annoncent comme du texte inerte.',
+        },
+        messages: {
+          missingRole:
+            '<{{name}}> n’expose aucun accessibilityRole : les lecteurs d’écran ne l’annonceront pas comme actionnable. Ajoutez accessibilityRole (« button », « link », « checkbox »…), ou accessible={false} si la zone n’est pas actionnable (fermeture du clavier, voile de modale).',
+        },
+        schema: [],
+      },
+      create(context) {
+        return {
+          JSXOpeningElement(node) {
+            if (node.name.type !== 'JSXIdentifier' || !TOUCHABLE_ELEMENTS.has(node.name.name)) {
+              return;
+            }
+
+            // Un spread peut porter accessibilityRole : le composant relaie alors les props
+            // que son appelant lui passe, et la règle n’a pas de quoi trancher.
+            const hasSpread = node.attributes.some(attribute => attribute.type === 'JSXSpreadAttribute');
+            if (hasSpread) {
+              return;
+            }
+
+            const findAttribute = name =>
+              node.attributes.find(
+                attribute =>
+                  attribute.type === 'JSXAttribute' &&
+                  attribute.name.type === 'JSXIdentifier' &&
+                  attribute.name.name === name,
+              );
+
+            if (findAttribute('accessibilityRole')) {
+              return;
+            }
+
+            // Toutes les zones tactiles ne sont pas actionnables : fermeture du clavier,
+            // voile de modale, blocage de propagation. Les sortir de l'arbre
+            // d'accessibilité est la bonne réponse, pas leur inventer un rôle.
+            const accessible = findAttribute('accessible');
+            const isExcludedFromTree =
+              accessible &&
+              accessible.value &&
+              accessible.value.type === 'JSXExpressionContainer' &&
+              accessible.value.expression.type === 'Literal' &&
+              accessible.value.expression.value === false;
+            if (isExcludedFromTree) {
+              return;
+            }
+
+            context.report({ node, messageId: 'missingRole', data: { name: node.name.name } });
+          },
+        };
+      },
+    },
+  },
+};
+
+/** @type {import('eslint').Linter.Config} */
+const config = {
+  files: ['**/*.{ts,tsx}'],
+  ignores: ['**/*.test.{ts,tsx}', '**/*.stories.tsx'],
+  plugins: {
+    a11y: accessibilityPlugin,
+  },
+  rules: {
+    'a11y/touchable-needs-role': 'error',
+  },
+};
+
+module.exports = config;

package/rules/catalogues.js

@@ -0,0 +1,20 @@
+// `max-lines` repère un fichier qui porte plusieurs responsabilités. Un catalogue de données
+// n'en porte qu'une : il est dense, pas complexe. Le découper pour passer sous la borne
+// gonflerait le nombre de fichiers sans rien découpler, ce qui est proscrit ici.
+//
+// L'exemption est énumérée et non déduite d'un motif large comme `**/constants/**` : une
+// exemption qui ne peut pas s'élargir toute seule est une exemption qu'on peut laisser vivre.
+// Les deux catalogues de tokens sont nommés un par un ; les stories et les jeux de démonstration
+// sont déjà exclus de la même façon par `.jscpd.json` et par les `collectCoverageFrom` de Jest,
+// et cette règle les aligne sur les deux autres dispositifs plutôt que de diverger.
+//
+// Les autres exigences continuent de s'appliquer à ces fichiers : seule la taille est levée.
+/** @type {import('eslint').Linter.Config} */
+const config = {
+  files: ['**/*.stories.tsx', '**/*.demo.*', '**/src/constants/Color.ts', '**/src/constants/Palette.ts'],
+  rules: {
+    'max-lines': 'off',
+  },
+};
+
+module.exports = config;

package/rules/chargement-paresseux.js

@@ -0,0 +1,26 @@
+// `no-require-imports` interdit `require()` parce qu'il échappe au graphe de modules : le
+// bundler ne peut ni le suivre, ni le secouer. Deux endroits en dépendent justement pour cette
+// raison, et l'exemption est énumérée fichier par fichier, comme celle des catalogues : une
+// exemption qui ne peut pas s'élargir toute seule est une exemption qu'on peut laisser vivre.
+//
+// - `useAppUpdateCheck` sonde `expo-in-app-updates`, qui est optionnel. Un `import` statique
+//   lèverait au chargement du module dans les applications qui ne l'installent pas.
+// - `MarkdownDescription` charge `react-markdown` et `remark-gfm` après son early return
+//   `Platform.OS !== 'web'`. Un `import` statique embarquerait toute la chaîne `remark` /
+//   `micromark` dans le bundle natif, qui ne s'en sert jamais.
+//
+// La sortie par le haut serait `import()`, mais elle rend les deux chargements asynchrones et
+// change la signature des composants : c'est une refonte, pas un nettoyage. À rouvrir si l'un
+// des deux appelants devient asynchrone pour une autre raison.
+/** @type {import('eslint').Linter.Config} */
+const config = {
+  files: [
+    '**/src/core/AppUpdateProvider/useAppUpdateCheck.ts',
+    '**/src/core/MarkdownDescription/MarkdownDescription.tsx',
+  ],
+  rules: {
+    '@typescript-eslint/no-require-imports': 'off',
+  },
+};
+
+module.exports = config;

package/rules/complexity.js

@@ -0,0 +1,29 @@
+// Garde-fou de complexité, posé au niveau visé et non au niveau constaté. La dette existante
+// a été gelée le temps de l'absorber, dans le `eslint-suppressions.json` de chaque workspace.
+// Ces quatre fichiers sont maintenant vides et le gel est fermé : `scripts/check-suppressions.mjs`
+// fait échouer la CI dès qu'un d'eux retient une offense. Une violation se corrige donc, elle ne
+// se gèle plus, et un seuil jugé mal calibré se rediscute ici, pour tout le monde a la fois.
+//
+// Les lignes blanches et les commentaires sont exclus des comptages : une fonction ne
+// devient pas complexe parce qu'elle est documentée.
+/** @type {import('eslint').Linter.Config} */
+const config = {
+  files: ['**/*.{ts,tsx}'],
+  rules: {
+    // 10 est le seuil SonarQube par défaut : au-delà, le nombre de chemins d'exécution
+    // d'une fonction dépasse ce qu'un test unitaire couvre raisonnablement.
+    complexity: ['error', { max: 10 }],
+    // Au-delà de trois niveaux d'imbrication, le lecteur ne tient plus les conditions
+    // actives en tête. Le remède est l'early return ou l'extraction, jamais l'accolade.
+    'max-depth': ['error', { max: 2 }],
+    // Quatre paramètres positionnels, c'est déjà un objet qui s'ignore. Le seuil est
+    // atteint aujourd'hui sans dette à geler.
+    'max-params': ['error', { max: 3 }],
+    // Une fonction qui ne tient pas sur un écran fait plusieurs choses.
+    'max-lines-per-function': ['error', { max: 60, skipBlankLines: true, skipComments: true }],
+    // Même logique au niveau du fichier : au-delà, il porte plusieurs responsabilités.
+    'max-lines': ['error', { max: 250, skipBlankLines: true, skipComments: true }],
+  },
+};
+
+module.exports = config;

package/rules/configuration.js

@@ -0,0 +1,22 @@
+// Les fichiers de configuration d'outils (`jest.config.js`, `metro.config.js`…) sont chargés par
+// Node en CommonJS, pas par le bundler. Sans cette déclaration, `no-undef` signale `__dirname`,
+// `module` et `require` comme des variables inconnues, et chaque fichier de configuration doit
+// alors porter un `eslint-disable`. C'était la configuration d'ESLint qui était fausse, pas le
+// code, et ces directives ont disparu d'elles-mêmes une fois la déclaration posée.
+/** @type {import('eslint').Linter.Config} */
+const config = {
+  files: ['**/*.config.js', '**/*.config.cjs'],
+  languageOptions: {
+    sourceType: 'commonjs',
+    globals: {
+      __dirname: 'readonly',
+      __filename: 'readonly',
+      module: 'writable',
+      exports: 'writable',
+      require: 'readonly',
+      process: 'readonly',
+    },
+  },
+};
+
+module.exports = config;

package/rules/directives.js

@@ -0,0 +1,25 @@
+const eslintComments = require('@eslint-community/eslint-plugin-eslint-comments');
+
+// Une règle ne se désactive plus à la ligne : elle se discute dans cette configuration, pour tout
+// le monde à la fois. C'est le pendant de la fermeture du gel - une violation se corrige, ou bien
+// la borne se rediscute ; elle ne se contourne pas en silence dans un coin du code. Sans cette
+// règle, chaque exigence resserrée pouvait être annulée localement par la ligne qu'elle gênait,
+// et l'ensemble du dispositif n'aurait été qu'une suggestion.
+//
+// Les huit directives que portait le dépôt ont été levées avant de poser la règle, et deux
+// d'entre elles masquaient des défauts réels : un gestionnaire figé au premier rendu dans
+// `useDepotFichier`, et deux fichiers de configuration que `no-undef` signalait à tort faute de
+// globales CommonJS déclarées.
+//
+// `eslint-enable` et `eslint-env` restent admis : le premier est sans objet en l'absence de
+// `eslint-disable`, le second ne désactive aucune règle.
+/** @type {import('eslint').Linter.Config} */
+const config = {
+  files: ['**/*.{ts,tsx,js,jsx,mjs,cjs}'],
+  plugins: { 'eslint-comments': eslintComments },
+  rules: {
+    'eslint-comments/no-use': ['error', { allow: ['eslint-enable', 'eslint-env'] }],
+  },
+};
+
+module.exports = config;

package/rules/sonarjs.js

@@ -0,0 +1,28 @@
+const sonarjs = require('eslint-plugin-sonarjs');
+
+// Les règles natives d'ESLint mesurent la complexité cyclomatique et la taille : elles ne
+// voient ni la duplication ni la charge de lecture réelle. Ce sous-ensemble de SonarJS
+// complète les deux angles manquants. Il est volontairement restreint : le preset
+// `recommended` du plugin porte des centaines de règles de style qui recouvrent déjà
+// eslint-config-expo et n'ont rien à voir avec la qualité structurelle.
+//
+// Même régime que les règles natives : seuils au niveau visé, et gel fermé (voir
+// `rules/complexity.js`).
+/** @type {import('eslint').Linter.Config} */
+const config = {
+  files: ['**/*.{ts,tsx}'],
+  plugins: { sonarjs },
+  rules: {
+    // La complexité cognitive compte ce qui coûte au lecteur, pas les chemins d'exécution :
+    // l'imbrication pèse, une suite de ternaires plats ne pèse pas. Sur du JSX elle décrit
+    // mieux la réalité que la complexité cyclomatique, qui punit le rendu conditionnel.
+    'sonarjs/cognitive-complexity': ['error', 10],
+    // L'équivalent du Flay : deux fonctions identiques, deux branches identiques.
+    'sonarjs/no-identical-functions': 'error',
+    'sonarjs/no-duplicated-branches': 'error',
+    'sonarjs/no-all-duplicated-branches': 'error',
+    'sonarjs/no-identical-expressions': 'error',
+  },
+};
+
+module.exports = config;

package/rules/tests.js

@@ -0,0 +1,23 @@
+// Les mocks et les fichiers d'amorçage de Jest s'exécutent dans le harnais de test, qui leur
+// fournit `jest`, `describe`, `expect` et leurs voisins. ESLint ne le sait pas : sans cette
+// déclaration, `no-undef` les signale tous, et chaque fichier doit ouvrir sur un `/* global jest */`
+// - une directive ESLint comme une autre, qui contourne la configuration au lieu de la corriger.
+/** @type {import('eslint').Linter.Config} */
+const config = {
+  files: ['**/__tests__/**/*.{js,ts,tsx}', '**/*.{test,spec}.{js,ts,tsx}', '**/jest.setup.{js,ts}'],
+  languageOptions: {
+    globals: {
+      jest: 'readonly',
+      describe: 'readonly',
+      it: 'readonly',
+      test: 'readonly',
+      expect: 'readonly',
+      beforeAll: 'readonly',
+      beforeEach: 'readonly',
+      afterAll: 'readonly',
+      afterEach: 'readonly',
+    },
+  },
+};
+
+module.exports = config;

package/rules/typage.js

@@ -0,0 +1,41 @@
+// `@ts-ignore` et `@ts-nocheck` éteignent le compilateur sans laisser de trace de ce qui est
+// éteint : l'erreur masquée peut changer de nature sans que rien ne le signale. La règle les
+// interdit et n'admet `@ts-expect-error` qu'accompagné d'une description, parce que celui-ci
+// échoue dès que l'erreur attendue disparaît - il se périme tout seul, contrairement aux deux
+// autres. Le seul `@ts-ignore` du dépôt masquait justement une déclaration devenue morte : React
+// 19 a déplacé le namespace `JSX` vers `React.JSX`, et personne ne l'avait vu.
+//
+// `no-explicit-any` ferme la même porte par un autre côté : un `any` éteint le compilateur sur
+// une valeur au lieu d'une ligne, et il se propage à tout ce qui la touche. Les 39 qu'avait
+// `components` ont été retirés sans exemption ; la règle empêche le premier suivant.
+//
+// `consistent-type-assertions` ferme la dernière porte : un `as` affirme un type que le
+// compilateur n'a pas prouvé. Les casts du dépôt ont été remplacés par des types qui disent vrai ;
+// seuls restent ceux que TypeScript ne sait pas exprimer autrement, chacun isolé dans un fichier
+// qui ne fait que ça et qui explique pourquoi. Ils sont exemptés ici, nommément, et nulle part
+// ailleurs.
+const castsAssumes = [
+  'src/helpers/mapValues.ts',
+  'src/helpers/cssVarTypography.ts',
+  'src/helpers/deepMerge.ts',
+  'src/core/styleNatif/versStyleNatif.ts',
+  'src/core/styleTamagui/versStyleTamagui.ts',
+];
+
+/** @type {import('eslint').Linter.Config[]} */
+const config = [
+  {
+    files: ['**/*.{ts,tsx}'],
+    rules: {
+      '@typescript-eslint/ban-ts-comment': [
+        'error',
+        { 'ts-expect-error': 'allow-with-description', 'ts-ignore': true, 'ts-nocheck': true, 'ts-check': false },
+      ],
+      '@typescript-eslint/no-explicit-any': 'error',
+      '@typescript-eslint/consistent-type-assertions': ['error', { assertionStyle: 'never' }],
+    },
+  },
+  { files: castsAssumes, rules: { '@typescript-eslint/consistent-type-assertions': 'off' } },
+];
+
+module.exports = config;