@dsivd/prestations-ng 19.0.6 → 19.0.8-beta.1

package/package.json

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

package/src/eslint/component-path.mjs

@@ -0,0 +1,15 @@
+// Path of the component a linted template belongs to, `undefined` when the file is not a
+// template.
+//
+// An inline template is a virtual block whose path is derived from the `.ts`, and whose
+// name ends with `.html` too: `foo.component.ts/1_inline-template-….component.html`.
+// It has to be matched BEFORE the external template, otherwise it resolves to garbage.
+export function resolveComponentPath(filename) {
+  const inlineMatch = filename.match(/^(.*\.ts)(?:[/\\]|$)/);
+  if (inlineMatch) {
+    return inlineMatch[1];
+  }
+  return filename.endsWith(".html")
+    ? `${filename.slice(0, -".html".length)}.ts`
+    : undefined;
+}

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

@@ -1,3 +1,4 @@
+import { builtinRules } from 'eslint/use-at-your-own-risk';
 import { describe, expect, it } from 'vitest';
 
 import prestationsNg, { configs, plugin, rules } from '../../index.mjs';
@@ -6,65 +7,129 @@ const PLUGIN_KEY = '@dsivd/prestations-ng';
 
 const configNames = Object.keys(configs);
 
-// Rule ids enabled by a config, whatever its severity.
+// 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.keys(entry.rules ?? {}));
+    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 one config per lint target', () => {
-    expect(configNames).toEqual(['tsRecommended', 'templateRecommended']);
-  });
+    it('should expose a rule layer and a preset per lint target', () => {
+        expect(configNames).toEqual([
+            'tsRecommended',
+            'templateRecommended',
+            'tsRules',
+            'templateRules',
+        ]);
+    });
 
-  it.each(configNames)('%s should register the plugin first', (name) => {
-    const [base, ...rest] = configs[name];
+    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);
-  });
+        expect(base.plugins).toEqual({ [PLUGIN_KEY]: plugin });
+        expect(base.rules).toBeUndefined();
+        expect(rest.every((entry) => entry.plugins === undefined)).toBe(true);
+    });
 
-  it.each(configNames)('%s should name every entry', (name) => {
-    for (const entry of configs[name]) {
-      expect(entry.name).toMatch(/^prestations-ng\//);
-    }
-  });
-
-  // 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.
-  it.each(configNames)('%s should only enable existing rules', (name) => {
-    for (const id of enabledIdsOf(configs[name])) {
-      expect(id.startsWith(`${PLUGIN_KEY}/`)).toBe(true);
-      expect(rules).toHaveProperty(id.slice(PLUGIN_KEY.length + 1));
-    }
-  });
+    it.each(RULE_LAYERS)('%s should carry no third-party rule', (name) => {
+        expect(enabledIdsOf(configs[name])).toEqual(ownIdsOf(configs[name]));
+    });
 
-  it('should enable every rule in at least one config', () => {
-    const enabled = new Set(configNames.flatMap((n) => enabledIdsOf(configs[n])));
+    it.each(configNames)('%s should name its own entries', (name) => {
+        const own = configs[name].filter((entry) =>
+            entry.name?.startsWith('prestations-ng/'),
+        );
 
-    for (const ruleName of Object.keys(rules)) {
-      expect(enabled).toContain(`${PLUGIN_KEY}/${ruleName}`);
-    }
-  });
+        expect(own.length).toBeGreaterThan(0);
+    });
 
-  it('should keep the template-only rule out of the TypeScript config', () => {
-    expect(enabledIdsOf(configs.tsRecommended)).not.toContain(
-      `${PLUGIN_KEY}/no-uninvoked-signal-in-template`,
+    // 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');
-  });
+    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

@@ -1,6 +1,6 @@
 // Registers the plugin without enabling any rule. Meant to be used through
-// `templateRecommended`, inside the `extends` of a block that already targets
-// `**/*.html` and sets the Angular template parser.
+// `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: {

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

@@ -1,14 +1,23 @@
-import templateBase from './template-base.mjs';
+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) => [
-    templateBase(plugin),
+    ...angular.configs.templateRecommended,
+    ...angular.configs.templateAccessibility,
+    ...templateRules(plugin),
     {
         name: 'prestations-ng/template-recommended',
         rules: {
-            // Also in `tsRecommended`: 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',
+            '@angular-eslint/template/no-negated-async': 'off',
+            '@angular-eslint/template/button-has-type': 'error',
         },
     },
 ];

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

@@ -1,6 +1,6 @@
 // Registers the plugin without enabling any rule. Meant to be used through
-// `tsRecommended`, inside the `extends` of a block that already targets `**/*.ts`
-// and sets the TypeScript parser.
+// `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: {

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

@@ -1,11 +1,141 @@
-import tsBase from './ts-base.mjs';
+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) => [
-    tsBase(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: {
-            '@dsivd/prestations-ng/no-direct-signal-mutation': 'error',
+            // ── @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',
         },
     },
 ];

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,15 +1,21 @@
 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';
 
 const plugin = {
-  meta: { name: '@dsivd/prestations-ng' },
-  rules,
+    meta: { name: '@dsivd/prestations-ng' },
+    rules,
 };
 
 const configs = {
-  tsRecommended: tsRecommended(plugin),
-  templateRecommended: templateRecommended(plugin),
+    // 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 };