@dsivd/prestations-ng 19.1.2 → 19.2.0-beta.10

package/src/eslint/configs/__tests__/configs.test.mjs

@@ -1,3 +1,4 @@
+import vitest from '@vitest/eslint-plugin';
 import { builtinRules } from 'eslint/use-at-your-own-risk';
 import { describe, expect, it } from 'vitest';
 
@@ -6,6 +7,10 @@ import prestationsNg, { configs, plugin, rules } from '../../index.mjs';
 const PLUGIN_KEY = '@dsivd/prestations-ng';
 
 const configNames = Object.keys(configs);
+// The configs of this library's plugin (the preset of the Vitest specs only configures @vitest/eslint-plugin)
+const pluginConfigNames = configNames.filter(
+    (name) => name !== 'specTsRecommended',
+);
 
 // Configs that only register this library's rules, and the presets built on top of them.
 const RULE_LAYERS = ['tsRules', 'templateRules'];
@@ -52,6 +57,7 @@ describe('eslint configs', () => {
             'templateRecommended',
             'tsRules',
             'templateRules',
+            'specTsRecommended',
         ]);
     });
 
@@ -88,7 +94,7 @@ describe('eslint configs', () => {
 
     // Two entries declaring the same plugin key from different copies is a hard ESLint
     // failure, so the preset must register ours exactly once.
-    it.each(configNames)('%s should register the plugin once', (name) => {
+    it.each(pluginConfigNames)('%s should register the plugin once', (name) => {
         const declarations = configs[name]
             .map((entry) => entry.plugins?.[PLUGIN_KEY])
             .filter(Boolean);
@@ -101,7 +107,9 @@ describe('eslint configs', () => {
     });
 
     it('should enable every rule in at least one config', () => {
-        const enabled = new Set(configNames.flatMap((n) => ownIdsOf(configs[n])));
+        const enabled = new Set(
+            pluginConfigNames.flatMap((n) => ownIdsOf(configs[n])),
+        );
 
         for (const ruleName of Object.keys(rules)) {
             expect(enabled).toContain(`${PLUGIN_KEY}/${ruleName}`);
@@ -118,6 +126,42 @@ describe('eslint configs', () => {
     );
 });
 
+describe('specTsRecommended', () => {
+    const rulesOf = (config) =>
+        Object.assign({}, ...config.map((entry) => entry.rules ?? {}));
+
+    it('should build on the recommended config of @vitest/eslint-plugin', () => {
+        expect(configs.specTsRecommended[0]).toBe(vitest.configs.recommended);
+        expect(pluginsOf(configs.specTsRecommended)).toEqual({ vitest });
+    });
+
+    it('should count the assertions of the helpers and of the HttpTestingController', () => {
+        const [, options] = rulesOf(configs.specTsRecommended)[
+            'vitest/expect-expect'
+        ];
+
+        expect(options.assertFunctionNames).toEqual(
+            expect.arrayContaining([
+                'expect',
+                'expect*',
+                '*.expectOne',
+                '*.verify',
+            ]),
+        );
+    });
+
+    // An expect which may not run lets a test pass without asserting anything
+    it('should keep vitest/no-conditional-expect enabled', () => {
+        expect(
+            isOff(
+                rulesOf(configs.specTsRecommended)[
+                    'vitest/no-conditional-expect'
+                ],
+            ),
+        ).toBe(false);
+    });
+});
+
 describe('eslint plugin', () => {
     it('should be named after the npm package', () => {
         expect(plugin.meta.name).toBe(PLUGIN_KEY);

package/src/eslint/configs/spec-ts-recommended.mjs

@@ -0,0 +1,34 @@
+/**
+ * The house preset of the Vitest specs: the recommended rules of `@vitest/eslint-plugin`, with the
+ * assertions also made by the helpers of the specs and by the `HttpTestingController`.
+ *
+ * Meant for the `extends` of a `**\/*.spec.ts` block (the Cypress `*.spec.cy.ts` files are not
+ * Vitest specs).
+ *
+ * @param {import('@vitest/eslint-plugin').default} vitest the `@vitest/eslint-plugin` module
+ * @returns {import('typescript-eslint').ConfigArray}
+ */
+const specTsRecommended = (vitest) => [
+    vitest.configs.recommended,
+    {
+        name: 'prestations-ng/spec-ts-recommended',
+        rules: {
+            'vitest/expect-expect': [
+                'error',
+                {
+                    assertFunctionNames: [
+                        'expect',
+                        'expect*',
+                        'assert*',
+                        'test*',
+                        '*.expectOne',
+                        '*.expectNone',
+                        '*.verify',
+                    ],
+                },
+            ],
+        },
+    },
+];
+
+export default specTsRecommended;

package/src/eslint/configs/template-recommended.mjs

@@ -8,6 +8,8 @@ import templateRules from './template-rules.mjs';
  *
  * Meant for the `extends` of a `**\/*.html` block. It brings its own parser and plugins,
  * so do not spread `angular.configs.templateRecommended` alongside it.
+ *
+ * @returns {import('typescript-eslint').ConfigArray}
  */
 const templateRecommended = (plugin) => [
     ...angular.configs.templateRecommended,

package/src/eslint/configs/template-rules.mjs

@@ -1,7 +1,11 @@
 import templateBase from './template-base.mjs';
 
-// Only the rules written by this library. `templateRecommended` includes it, alongside
-// the house style; use this layer directly to opt out of the latter.
+/**
+ * Only the rules written by this library. `templateRecommended` includes it, alongside
+ * the house style; use this layer directly to opt out of the latter.
+ *
+ * @returns {import('typescript-eslint').ConfigArray}
+ */
 const templateRules = (plugin) => [
     templateBase(plugin),
     {

package/src/eslint/configs/ts-recommended.mjs

@@ -14,6 +14,8 @@ import tsRules from './ts-rules.mjs';
  * Meant for the `extends` of a `**\/*.ts` block. It brings its own parser and plugins,
  * so do not spread `angular.configs.tsRecommended` alongside it — declaring the same
  * plugin twice from two different copies makes ESLint fail outright.
+ *
+ * @returns {import('typescript-eslint').ConfigArray}
  */
 const tsRecommended = (plugin) => [
     eslint.configs.recommended,

package/src/eslint/configs/ts-rules.mjs

@@ -1,7 +1,11 @@
 import tsBase from './ts-base.mjs';
 
-// Only the rules written by this library. `tsRecommended` includes it, alongside the
-// house style; use this layer directly to opt out of the latter.
+/**
+ * Only the rules written by this library. `tsRecommended` includes it, alongside the
+ * house style; use this layer directly to opt out of the latter.
+ *
+ * @returns {import('typescript-eslint').ConfigArray}
+ */
 const tsRules = (plugin) => [
     tsBase(plugin),
     {

package/src/eslint/index.mjs

@@ -1,9 +1,17 @@
+import specTsRecommended from './configs/spec-ts-recommended.mjs';
 import templateRecommended from './configs/template-recommended.mjs';
 import templateRules from './configs/template-rules.mjs';
 import tsRecommended from './configs/ts-recommended.mjs';
 import tsRules from './configs/ts-rules.mjs';
 import rules from './rules/index.mjs';
 
+// Only needed by the projects linting Vitest specs: the other configs can be used without it.
+const vitest = await import('@vitest/eslint-plugin').then(
+    (module) => module.default,
+    () => null,
+);
+const specTsRecommendedConfig = vitest ? specTsRecommended(vitest) : null;
+
 const plugin = {
     meta: { name: '@dsivd/prestations-ng' },
     rules,
@@ -16,6 +24,15 @@ const configs = {
     // Only this library's own rules, for a project that supplies its own style.
     tsRules: tsRules(plugin),
     templateRules: templateRules(plugin),
+    // The preset of the Vitest specs (needs @vitest/eslint-plugin)
+    get specTsRecommended() {
+        if (!specTsRecommendedConfig) {
+            throw new Error(
+                'prestationsNg.configs.specTsRecommended needs @vitest/eslint-plugin: npm install --save-dev @vitest/eslint-plugin@1',
+            );
+        }
+        return specTsRecommendedConfig;
+    },
 };
 
 export { configs, plugin, rules };

package/src/eslint/rules/no-direct-signal-mutation.mjs

@@ -241,7 +241,7 @@ function boundNameSignalKind(identifier, scopeContext, seen) {
     scopeContext.sourceCode.getScope(identifier),
     identifier.name,
   );
-  if (!variable || variable.defs.length !== 1 || seen.has(variable)) {
+  if (variable?.defs.length !== 1 || seen.has(variable)) {
     return undefined;
   }
   seen.add(variable);

package/src/eslint/signal-names.mjs

@@ -153,6 +153,67 @@ const reExportedModulesOf = (sourceFile) =>
     .filter((statement) => ts.isExportDeclaration(statement) && statement.moduleSpecifier)
     .map((statement) => statement.moduleSpecifier.text);
 
+const classDeclarationsOf = (sourceFile, className) =>
+  className
+    ? [findClass(sourceFile, className)].filter(Boolean)
+    : sourceFile.statements.filter(ts.isClassDeclaration);
+
+const isBarrelMiss = (className, classDeclarations) =>
+  Boolean(className) && classDeclarations.length === 0;
+
+const collectFromReExports = (sourceFile, path, className, kinds, visited) => {
+  for (const specifier of reExportedModulesOf(sourceFile)) {
+    const target = resolveModule(specifier, path);
+    if (target) {
+      collect(target, className, kinds, visited);
+    }
+  }
+};
+
+const addMemberKindIfEligible = (member, kinds) => {
+  if (!member.name || !ts.isIdentifier(member.name)) {
+    return;
+  }
+  const kind = kindOfMember(member);
+  // A subclass overriding a member wins: it is collected first.
+  if (kind && !kinds.has(member.name.text)) {
+    kinds.set(member.name.text, kind);
+  }
+};
+
+const collectMemberKinds = (classDeclaration, kinds) => {
+  for (const member of classDeclaration.members) {
+    addMemberKindIfEligible(member, kinds);
+  }
+};
+
+const baseTargetOf = (sourceFile, path, classDeclaration) => {
+  const baseName = extendedClassNameOf(classDeclaration);
+  if (!baseName) {
+    return undefined;
+  }
+
+  // Declaration bundles are flattened: the base class often sits in the same file.
+  if (findClass(sourceFile, baseName)) {
+    return { path, className: baseName };
+  }
+
+  const imported = importOf(sourceFile, baseName);
+  if (!imported) {
+    return undefined;
+  }
+
+  const target = resolveModule(imported.specifier, path);
+  return target ? { path: target, className: imported.exportedName } : undefined;
+};
+
+const collectBase = (sourceFile, path, classDeclaration, kinds, visited) => {
+  const target = baseTargetOf(sourceFile, path, classDeclaration);
+  if (target) {
+    collect(target.path, target.className, kinds, visited);
+  }
+};
+
 const collect = (path, className, kinds, visited) => {
   const key = `${path}::${className ?? "*"}`;
   if (visited.has(key)) {
@@ -165,47 +226,17 @@ const collect = (path, className, kinds, visited) => {
     return;
   }
 
-  const classDeclarations = className
-    ? [findClass(sourceFile, className)].filter(Boolean)
-    : sourceFile.statements.filter(ts.isClassDeclaration);
+  const classDeclarations = classDeclarationsOf(sourceFile, className);
 
   // A barrel: the class is only re-exported from here.
-  if (className && classDeclarations.length === 0) {
-    for (const specifier of reExportedModulesOf(sourceFile)) {
-      const target = resolveModule(specifier, path);
-      if (target) {
-        collect(target, className, kinds, visited);
-      }
-    }
+  if (isBarrelMiss(className, classDeclarations)) {
+    collectFromReExports(sourceFile, path, className, kinds, visited);
     return;
   }
 
   for (const classDeclaration of classDeclarations) {
-    for (const member of classDeclaration.members) {
-      if (!member.name || !ts.isIdentifier(member.name)) {
-        continue;
-      }
-      const kind = kindOfMember(member);
-      // A subclass overriding a member wins: it is collected first.
-      if (kind && !kinds.has(member.name.text)) {
-        kinds.set(member.name.text, kind);
-      }
-    }
-
-    const baseName = extendedClassNameOf(classDeclaration);
-    if (!baseName) {
-      continue;
-    }
-    // Declaration bundles are flattened: the base class often sits in the same file.
-    if (findClass(sourceFile, baseName)) {
-      collect(path, baseName, kinds, visited);
-      continue;
-    }
-    const imported = importOf(sourceFile, baseName);
-    const target = imported && resolveModule(imported.specifier, path);
-    if (target) {
-      collect(target, imported.exportedName, kinds, visited);
-    }
+    collectMemberKinds(classDeclaration, kinds);
+    collectBase(sourceFile, path, classDeclaration, kinds, visited);
   }
 };