@dsivd/prestations-ng 19.0.6-beta.2 → 19.0.7

package/package.json

@@ -40,7 +40,7 @@
   "ng-update": {
     "migrations": "./schematics/migration-collection.json"
   },
-  "version": "19.0.6-beta.2",
+  "version": "19.0.7",
   "module": "fesm2022/dsivd-prestations-ng.mjs",
   "typings": "types/dsivd-prestations-ng.d.ts",
   "exports": {

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

@@ -0,0 +1,135 @@
+import { builtinRules } from 'eslint/use-at-your-own-risk';
+import { describe, expect, it } from 'vitest';
+
+import prestationsNg, { configs, plugin, rules } from '../../index.mjs';
+
+const PLUGIN_KEY = '@dsivd/prestations-ng';
+
+const configNames = Object.keys(configs);
+
+// Configs that only register this library's rules, and the presets built on top of them.
+const RULE_LAYERS = ['tsRules', 'templateRules'];
+const PRESETS = [
+    ['tsRecommended', 'tsRules'],
+    ['templateRecommended', 'templateRules'],
+];
+
+const isOff = (severity) =>
+    severity === 'off' ||
+    severity === 0 ||
+    (Array.isArray(severity) && (severity[0] === 'off' || severity[0] === 0));
+
+// Rule ids a config turns on. Ids set to 'off' are excluded: ESLint accepts those even
+// when the rule does not exist, which is precisely the escape hatch consumers rely on.
+const enabledIdsOf = (config) =>
+    config.flatMap((entry) =>
+        Object.entries(entry.rules ?? {})
+            .filter(([, severity]) => !isOff(severity))
+            .map(([id]) => id),
+    );
+
+const ownIdsOf = (config) =>
+    enabledIdsOf(config).filter((id) => id.startsWith(`${PLUGIN_KEY}/`));
+
+const pluginsOf = (config) =>
+    Object.assign({}, ...config.map((entry) => entry.plugins ?? {}));
+
+// An id is either `plugin-key/rule` (possibly nested, as in `@angular-eslint/template/x`)
+// or a bare core rule.
+const ruleExists = (id, plugins) => {
+    for (const [key, declared] of Object.entries(plugins)) {
+        if (id.startsWith(`${key}/`)) {
+            return Boolean(declared.rules?.[id.slice(key.length + 1)]);
+        }
+    }
+    return builtinRules.has(id);
+};
+
+describe('eslint configs', () => {
+    it('should expose a rule layer and a preset per lint target', () => {
+        expect(configNames).toEqual([
+            'tsRecommended',
+            'templateRecommended',
+            'tsRules',
+            'templateRules',
+        ]);
+    });
+
+    it.each(RULE_LAYERS)('%s should register the plugin first', (name) => {
+        const [base, ...rest] = configs[name];
+
+        expect(base.plugins).toEqual({ [PLUGIN_KEY]: plugin });
+        expect(base.rules).toBeUndefined();
+        expect(rest.every((entry) => entry.plugins === undefined)).toBe(true);
+    });
+
+    it.each(RULE_LAYERS)('%s should carry no third-party rule', (name) => {
+        expect(enabledIdsOf(configs[name])).toEqual(ownIdsOf(configs[name]));
+    });
+
+    it.each(configNames)('%s should name its own entries', (name) => {
+        const own = configs[name].filter((entry) =>
+            entry.name?.startsWith('prestations-ng/'),
+        );
+
+        expect(own.length).toBeGreaterThan(0);
+    });
+
+    // A config referencing a rule that does not exist breaks the lint of every consuming
+    // project at once, so it must never reach a release. `builtinRules` is an unstable
+    // ESLint export, but it is the only way to check core rule ids.
+    it.each(configNames)('%s should only enable existing rules', (name) => {
+        const plugins = pluginsOf(configs[name]);
+
+        for (const id of enabledIdsOf(configs[name])) {
+            expect(ruleExists(id, plugins), `unknown rule ${id}`).toBe(true);
+        }
+    });
+
+    // 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) => {
+        const declarations = configs[name]
+            .map((entry) => entry.plugins?.[PLUGIN_KEY])
+            .filter(Boolean);
+
+        expect(declarations).toEqual([plugin]);
+    });
+
+    it.each(PRESETS)('%s should build on %s', (preset, layer) => {
+        expect(ownIdsOf(configs[preset])).toEqual(ownIdsOf(configs[layer]));
+    });
+
+    it('should enable every rule in at least one config', () => {
+        const enabled = new Set(configNames.flatMap((n) => ownIdsOf(configs[n])));
+
+        for (const ruleName of Object.keys(rules)) {
+            expect(enabled).toContain(`${PLUGIN_KEY}/${ruleName}`);
+        }
+    });
+
+    it.each(['tsRecommended', 'tsRules'])(
+        '%s should keep the template-only rule out',
+        (name) => {
+            expect(enabledIdsOf(configs[name])).not.toContain(
+                `${PLUGIN_KEY}/no-uninvoked-signal-in-template`,
+            );
+        },
+    );
+});
+
+describe('eslint plugin', () => {
+    it('should be named after the npm package', () => {
+        expect(plugin.meta.name).toBe(PLUGIN_KEY);
+    });
+
+    it('should mirror the named exports on the default export', () => {
+        expect(prestationsNg).toEqual({ configs, plugin, rules });
+    });
+
+    it.each(Object.entries(rules))('%s should be a usable rule', (_, rule) => {
+        expect(typeof rule.create).toBe('function');
+        expect(Object.keys(rule.meta.messages).length).toBeGreaterThan(0);
+        expect(rule.meta.type).toBe('problem');
+    });
+});

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

@@ -0,0 +1,10 @@
+// Registers the plugin without enabling any rule. Meant to be used through
+// `templateRules` or `templateRecommended`, inside the `extends` of a block that
+// already targets `**/*.html` and sets the Angular template parser.
+const templateBase = (plugin) => ({
+    name: 'prestations-ng/template-base',
+    plugins: {
+        '@dsivd/prestations-ng': plugin,
+    },
+});
+export default templateBase;

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

@@ -0,0 +1,24 @@
+import angular from 'angular-eslint';
+
+import templateRules from './template-rules.mjs';
+
+/**
+ * The house Angular template preset: the recommended and accessibility baselines, this
+ * library's own rules, and the conventions every prestations-ng project follows.
+ *
+ * Meant for the `extends` of a `**\/*.html` block. It brings its own parser and plugins,
+ * so do not spread `angular.configs.templateRecommended` alongside it.
+ */
+const templateRecommended = (plugin) => [
+    ...angular.configs.templateRecommended,
+    ...angular.configs.templateAccessibility,
+    ...templateRules(plugin),
+    {
+        name: 'prestations-ng/template-recommended',
+        rules: {
+            '@angular-eslint/template/no-negated-async': 'off',
+            '@angular-eslint/template/button-has-type': 'error',
+        },
+    },
+];
+export default templateRecommended;

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

@@ -0,0 +1,17 @@
+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.
+const templateRules = (plugin) => [
+    templateBase(plugin),
+    {
+        name: 'prestations-ng/template-rules',
+        rules: {
+            // Also in `tsRules`: the rule carries both an ESTree and an Angular
+            // template visitor, and each fires on its own kind of file.
+            '@dsivd/prestations-ng/no-direct-signal-mutation': 'error',
+            '@dsivd/prestations-ng/no-uninvoked-signal-in-template': 'error',
+        },
+    },
+];
+export default templateRules;

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

@@ -0,0 +1,10 @@
+// Registers the plugin without enabling any rule. Meant to be used through
+// `tsRules` or `tsRecommended`, inside the `extends` of a block that already
+// targets `**/*.ts` and sets the TypeScript parser.
+const tsBase = (plugin) => ({
+    name: 'prestations-ng/ts-base',
+    plugins: {
+        '@dsivd/prestations-ng': plugin,
+    },
+});
+export default tsBase;

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

@@ -0,0 +1,142 @@
+import eslint from '@eslint/js';
+import rxjs from '@smarttools/eslint-plugin-rxjs';
+import angular from 'angular-eslint';
+import importX from 'eslint-plugin-import-x';
+import simpleImportSort from 'eslint-plugin-simple-import-sort';
+import tseslint from 'typescript-eslint';
+
+import tsRules from './ts-rules.mjs';
+
+/**
+ * The house TypeScript preset: the shared baselines, this library's own rules, and the
+ * conventions every prestations-ng project follows.
+ *
+ * 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.
+ */
+const tsRecommended = (plugin) => [
+    eslint.configs.recommended,
+    ...tseslint.configs.recommended, // covers: no-explicit-any, ban-ts-comment,
+    //   no-unused-expressions, no-var, no-unused-vars…
+    ...tseslint.configs.stylistic, // covers: array-type, consistent-type-assertions,
+    //   dot-notation, no-inferrable-types (default options),
+    //   no-empty-function (error), prefer-for-of,
+    //   prefer-function-type…
+    ...angular.configs.tsRecommended, // covers: prefer-inject, no-empty-lifecycle-method,
+    //   use-lifecycle-interface…
+    ...tsRules(plugin),
+    {
+        name: 'prestations-ng/ts-recommended',
+        plugins: {
+            rxjs,
+            'simple-import-sort': simpleImportSort,
+            'import-x': importX,
+        },
+        rules: {
+            // ── @angular-eslint ──────────────────────────────────────────────
+            '@angular-eslint/component-selector': [
+                'error',
+                {
+                    type: 'element',
+                    prefix: 'app',
+                    style: 'kebab-case',
+                },
+            ],
+            '@angular-eslint/directive-selector': [
+                'error',
+                {
+                    type: 'attribute',
+                    prefix: 'app',
+                    style: 'camelCase',
+                },
+            ],
+            '@angular-eslint/no-uncalled-signals': ['error'],
+            '@angular-eslint/prefer-signal-model': ['error'],
+            '@angular-eslint/prefer-signals': ['error'],
+
+            // ── @typescript-eslint ───────────────────────────────────────────
+            '@typescript-eslint/explicit-function-return-type': [
+                'error',
+                {
+                    allowExpressions: true,
+                    allowTypedFunctionExpressions: true,
+                    allowHigherOrderFunctions: true,
+                    allowDirectConstAssertionInArrowFunctions: true,
+                },
+            ],
+            '@typescript-eslint/explicit-member-accessibility': [
+                'error',
+                { accessibility: 'no-public' },
+            ],
+            '@typescript-eslint/member-ordering': 'error',
+            '@typescript-eslint/no-base-to-string': 'warn',
+            // stylistic enables no-inferrable-types with default options (ignoreParameters: false);
+            // override here to allow typed parameters explicitly
+            '@typescript-eslint/no-inferrable-types': [
+                'error',
+                { ignoreParameters: true },
+            ],
+            // stylistic sets no-empty-function to error; downgrade to warn
+            '@typescript-eslint/no-empty-function': 'warn',
+            '@typescript-eslint/prefer-includes': 'warn',
+            '@typescript-eslint/return-await': ['error', 'never'],
+            '@typescript-eslint/typedef': ['error', { parameter: true }],
+            '@typescript-eslint/unified-signatures': 'error',
+            // off here — @typescript-eslint/no-shadow handles it correctly for TS
+            'no-shadow': 'off',
+            '@typescript-eslint/no-shadow': ['error', { hoist: 'all' }],
+            '@typescript-eslint/no-unused-vars': [
+                'error',
+                {
+                    varsIgnorePattern: '^_',
+                    argsIgnorePattern: '^_',
+                    caughtErrorsIgnorePattern: '^_',
+                },
+            ],
+
+            // ── eslint core ──────────────────────────────────────────────────
+            'arrow-body-style': 'error',
+            'arrow-parens': ['error', 'as-needed'],
+            curly: 'error',
+            eqeqeq: ['error', 'always'],
+            'guard-for-in': 'error',
+            'no-bitwise': 'error',
+            'no-caller': 'error',
+            'no-console': ['error', { allow: ['log', 'warn', 'error'] }],
+            'no-eval': 'error',
+            'no-extra-boolean-cast': 'off',
+            'no-multiple-empty-lines': 'error',
+            'no-new-wrappers': 'error',
+            'no-restricted-imports': [
+                'error',
+                { paths: ['rxjs/Rx', 'primeng/primeng', 'primeng'] },
+            ],
+            'no-return-assign': 'error',
+            'no-throw-literal': 'error',
+            'no-undef-init': 'error',
+            'no-useless-concat': 'error',
+            'object-shorthand': ['error', 'always', { avoidQuotes: true }],
+            'one-var': ['error', 'never'],
+            'prefer-arrow-callback': 'error',
+            'prefer-template': 'error',
+            radix: 'error',
+
+            // ── rxjs ─────────────────────────────────────────────────────────
+            'rxjs/no-implicit-any-catch': ['error', { allowExplicitAny: true }],
+            'rxjs/no-sharereplay': 'off',
+
+            // ── import-x ─────────────────────────────────────────────────────
+            'import-x/no-cycle': ['warn', { maxDepth: 3, ignoreExternal: true }],
+            'import-x/no-deprecated': 'warn',
+            'import-x/first': 'error',
+            'import-x/newline-after-import': 'error',
+            'import-x/no-duplicates': 'error',
+
+            // ── simple-import-sort ───────────────────────────────────────────
+            'simple-import-sort/imports': 'error',
+            'simple-import-sort/exports': 'error',
+        },
+    },
+];
+export default tsRecommended;

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

@@ -0,0 +1,14 @@
+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.
+const tsRules = (plugin) => [
+    tsBase(plugin),
+    {
+        name: 'prestations-ng/ts-rules',
+        rules: {
+            '@dsivd/prestations-ng/no-direct-signal-mutation': 'error',
+        },
+    },
+];
+export default tsRules;

package/src/eslint/index.mjs

@@ -1,7 +1,22 @@
-import { noDirectSignalMutation } from './rules/index.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';
 
-export default {
-  rules: {
-    'no-direct-signal-mutation': noDirectSignalMutation,
-  },
+const plugin = {
+    meta: { name: '@dsivd/prestations-ng' },
+    rules,
 };
+
+const configs = {
+    // The house presets: baselines, this library's rules, and the shared conventions.
+    tsRecommended: tsRecommended(plugin),
+    templateRecommended: templateRecommended(plugin),
+    // Only this library's own rules, for a project that supplies its own style.
+    tsRules: tsRules(plugin),
+    templateRules: templateRules(plugin),
+};
+
+export { configs, plugin, rules };
+export default { configs, plugin, rules };

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

@@ -1,3 +1,4 @@
+import * as templateParser from '@angular-eslint/template-parser';
 import { describe, it } from 'vitest';
 import { RuleTester } from 'eslint';
 import rule from '../no-direct-signal-mutation.mjs';
@@ -46,13 +47,13 @@ describe('no-direct-signal-mutation', () => {
         'this.pendingFilesByFormKey.get(formKey).url = baseUrl',
         'const autocompleteComponent = viewChild("auto"); autocompleteComponent().inputElement().nativeElement.hidden = true',
         'component.inputElement().nativeElement.value = ""',
+        // A view query signal is read-only: there is no `.set()`/`.update()` to suggest,
+        // so `viewChild.required(…)` has to be excluded like `viewChild(…)`.
+        'const requiredChild = viewChild.required("req"); requiredChild().nativeElement.hidden = true',
+        'const requiredRows = contentChildren.required("row"); requiredRows()[0].hidden = true',
 
         // Method chaining without assignment
         'model().update((v) => v).subscribe()',
-
-        // One-way bindings are OK
-        '[model]="model().property"',
-        '[ngModel]="model().comment"',
       ],
 
       invalid: [
@@ -95,4 +96,85 @@ describe('no-direct-signal-mutation', () => {
       ],
     });
   });
+
+  const templateRuleTester = new RuleTester({
+    languageOptions: { parser: templateParser },
+  });
+
+  it('should validate signal mutation rule in templates', () => {
+    templateRuleTester.run('no-direct-signal-mutation', rule, {
+      valid: [
+        // Reads only
+        '{{ model().property }}',
+        '<div [value]="model().property"></div>',
+        '<div [value]="model().deeply.nested.property"></div>',
+        '<div [value]="model().array[0]"></div>',
+
+        // Going through the signal API
+        '<button (click)="model.set({ property: value })"></button>',
+        '<button (click)="model.update((v) => ({ ...v, property: value }))"></button>',
+
+        // Assignments that do not target a call result
+        '<button (click)="property = value"></button>',
+        '<button (click)="obj.property = value"></button>',
+        '<button (click)="this.obj.property = value"></button>',
+
+        // Two-way binding on the signal itself: Angular calls `.set()`
+        '<input [(ngModel)]="model" />',
+        '<app-child [(value)]="comment"></app-child>',
+
+        // Same exclusions as the TypeScript side: a call taking arguments, or reached
+        // through a foreign receiver, is not assumed to be a signal read.
+        '<button (click)="pendingFilesByFormKey.get(formKey).files = []"></button>',
+        '<button (click)="this.pendingFilesByFormKey.get(formKey).url = baseUrl"></button>',
+        '<button (click)="component.inputElement().nativeElement.value = &quot;&quot;"></button>',
+        '<button (click)="obj.getter().property = value"></button>',
+        // An output named `…Change` that carries no assignment
+        '<app-child (valueChange)="model.set($event)"></app-child>',
+      ],
+
+      invalid: [
+        {
+          code: '<button (click)="model().property = value"></button>',
+          errors: [{ messageId: 'directMutation' }],
+        },
+        {
+          code: '<button (click)="this.model().property = value"></button>',
+          errors: [{ messageId: 'directMutation' }],
+        },
+        {
+          code: '<button (click)="model().deeply.nested.property = value"></button>',
+          errors: [{ messageId: 'directMutation' }],
+        },
+        {
+          code: '<button (click)="model().array[0] = value"></button>',
+          errors: [{ messageId: 'directMutation' }],
+        },
+        // Every compound assignment accepted by the Angular parser
+        {
+          code: '<button (click)="model().property += value"></button>',
+          errors: [{ messageId: 'directMutation' }],
+        },
+        {
+          code: '<button (click)="model().property ??= value"></button>',
+          errors: [{ messageId: 'directMutation' }],
+        },
+        // The mutation hidden in a two-way binding, reported once and not twice
+        {
+          code: '<input [(ngModel)]="model().comment" />',
+          errors: [{ messageId: 'directMutation' }],
+        },
+        {
+          code: '<app-child [(value)]="model().nested.property"></app-child>',
+          errors: [{ messageId: 'directMutation' }],
+        },
+        // An explicit `…Change` handler carrying the assignment: the Binary reports it,
+        // the BoundEvent must not report it a second time.
+        {
+          code: '<app-child (valueChange)="model().property = $event"></app-child>',
+          errors: [{ messageId: 'directMutation' }],
+        },
+      ],
+    });
+  });
 });