eslint-config-angular-strict 2.3.82 → 2.3.84

package/README.md

@@ -24,6 +24,7 @@ A production-ready, opinionated ESLint configuration that enforces best practice
 📘 **TypeScript**: Promise-async, type imports, strict typing, type safety, extraneous classes,...<br>
 ✨ **Code Quality**: Complexity max, file length control, import cycles detection, 100+ Unicorn best practices,...<br>
 🎨 **Style**: Airbnb extended, max line length, object/class newlines, sorted classes/imports/objects/types,...<br>
+📁 **Naming**: File/folder/class suffix conventions enforced (components, services, pipes, interfaces,...)<br>
 🔍 **Templates**: 30+ rules with alphabetical attrs, complexity max, control flow, trackBy, a11y, no-any,...
 
 ## What's Included

package/index.js

@@ -9,6 +9,8 @@ import tsEslintParser from '@typescript-eslint/parser';
 import tsEslintPlugin from '@typescript-eslint/eslint-plugin';
 import unicornPlugin from 'eslint-plugin-unicorn';
 
+import { namingConventionOverrides, noRestrictedSyntaxRule } from './naming-conventions.js';
+
 export default [
   {
     ignores: ['dist/**', 'node_modules/**'],
@@ -47,12 +49,7 @@ export default [
       'no-fallthrough': 'off',
       'no-param-reassign': ['error', { props: false }],
       'no-plusplus': 'off',
-      'no-restricted-syntax': [
-        'error',
-        { selector: 'TSEnumDeclaration:not(TSModuleBlock > TSEnumDeclaration)', message: 'Enums must live in enums.ts or *.enum.ts files' },
-        { selector: 'TSInterfaceDeclaration:not(TSModuleBlock > TSInterfaceDeclaration)', message: 'Interfaces must live in *.interface.ts files' },
-        { selector: 'TSTypeAliasDeclaration:not(TSModuleBlock > TSTypeAliasDeclaration)', message: 'Types must live in types.ts or *.type.ts files' },
-      ],
+      'no-restricted-syntax': noRestrictedSyntaxRule,
       'no-return-assign': 'off',
       'no-underscore-dangle': ['error', { allowAfterThis: true }],
       'radix': ['error', 'as-needed'],
@@ -301,45 +298,5 @@ export default [
     },
   },
 
-  // *.interface.ts: only interfaces allowed
-  {
-    files: ['**/*.interface.ts'],
-    rules: {
-      'no-restricted-syntax': [
-        'error',
-        {
-          selector: 'Program > :not(ImportDeclaration, TSInterfaceDeclaration, ExportNamedDeclaration:has(> TSInterfaceDeclaration))',
-          message: 'Only interfaces allowed in *.interface.ts',
-        },
-      ],
-    },
-  },
-
-  // enums.ts / *.enum.ts: only enums allowed
-  {
-    files: ['**/enums.ts', '**/*.enum.ts'],
-    rules: {
-      'no-restricted-syntax': [
-        'error',
-        {
-          selector: 'Program > :not(ImportDeclaration, TSEnumDeclaration, ExportNamedDeclaration:has(> TSEnumDeclaration))',
-          message: 'Only enums allowed in enums.ts / *.enum.ts',
-        },
-      ],
-    },
-  },
-
-  // types.ts / *.type.ts: only type aliases allowed
-  {
-    files: ['**/types.ts', '**/*.type.ts'],
-    rules: {
-      'no-restricted-syntax': [
-        'error',
-        {
-          selector: 'Program > :not(ImportDeclaration, TSTypeAliasDeclaration, ExportNamedDeclaration:has(> TSTypeAliasDeclaration))',
-          message: 'Only type aliases allowed in types.ts / *.type.ts',
-        },
-      ],
-    },
-  },
+  ...namingConventionOverrides,
 ];

package/naming-conventions.js

@@ -0,0 +1,245 @@
+// Class suffix enforcement (regex matched against class name)
+const classSuffixRestriction = (suffix, location) => ({
+  selector: `ClassDeclaration[id.name!=/${suffix}$/]`,
+  message: `Classes in ${location} must end with "${suffix}"`,
+});
+
+// Files containing only imports + export const (literal values, not functions) should be named *.constant.ts
+const constantsFileRestriction = {
+  selector:
+    'Program:has(ExportNamedDeclaration VariableDeclaration[kind="const"]):not(:has(:matches(ClassDeclaration, FunctionDeclaration, TSInterfaceDeclaration, TSEnumDeclaration, TSTypeAliasDeclaration))):not(:has(VariableDeclarator > :matches(ArrowFunctionExpression, FunctionExpression, CallExpression)))',
+  message: 'Files containing only constants must be named constants/*.constant.ts',
+};
+
+// Restrictions for interface/enum/type declarations (skipped inside `declare module` blocks)
+const declarationFileRestrictions = [
+  { selector: 'TSEnumDeclaration:not(TSModuleBlock > TSEnumDeclaration)', message: 'Enums must live in interfaces/enums.ts or interfaces/*.enum.ts files' },
+  { selector: 'TSInterfaceDeclaration:not(TSModuleBlock > TSInterfaceDeclaration)', message: 'Interfaces must live in interfaces/*.interface.ts files' },
+  {
+    selector: 'TSTypeAliasDeclaration:not(TSModuleBlock > TSTypeAliasDeclaration)',
+    message: 'Types must live in interfaces/types.ts or interfaces/*.type.ts files',
+  },
+];
+
+// Restrictions for Angular class decorators (one decorator type per file)
+const decoratorFileRestrictions = {
+  Component: {
+    selector: 'Decorator[expression.callee.name="Component"]',
+    message:
+      '@Component classes must live in app.ts / components/**/*.component.ts / components/drawers/*.drawer.ts / components/modals/*.modal.ts / pages/**/*.page.ts',
+  },
+  Directive: { selector: 'Decorator[expression.callee.name="Directive"]', message: '@Directive classes must live in directives/*.directive.ts' },
+  Injectable: { selector: 'Decorator[expression.callee.name="Injectable"]', message: '@Injectable classes must live in services/*.service.ts' },
+  Pipe: { selector: 'Decorator[expression.callee.name="Pipe"]', message: '@Pipe classes must live in pipes/*.pipe.ts' },
+};
+
+// Undecorated classes must live in helpers/*.helpers.ts
+const helperFileRestriction = {
+  selector: 'ClassDeclaration:not(:has(Decorator))',
+  message: 'Undecorated classes must live in helpers/*.helpers.ts',
+};
+
+// Global no-restricted-syntax rule (used in the main TypeScript files block)
+export const noRestrictedSyntaxRule = [
+  'error',
+  constantsFileRestriction,
+  decoratorFileRestrictions.Component,
+  decoratorFileRestrictions.Directive,
+  decoratorFileRestrictions.Injectable,
+  decoratorFileRestrictions.Pipe,
+  helperFileRestriction,
+  ...declarationFileRestrictions,
+];
+
+// Per-file overrides relaxing no-restricted-syntax to allow the relevant decorator/declaration
+export const namingConventionOverrides = [
+  // app.ts / components/**/*.component.ts / components/drawers/*.drawer.ts / components/modals/*.modal.ts / pages/**/*.page.ts: @Component allowed
+  {
+    files: ['**/app.ts', '**/components/**/*.component.ts', '**/components/drawers/**/*.drawer.ts', '**/components/modals/**/*.modal.ts', '**/pages/**/*.page.ts'],
+    rules: {
+      'no-restricted-syntax': [
+        'error',
+        decoratorFileRestrictions.Directive,
+        decoratorFileRestrictions.Injectable,
+        decoratorFileRestrictions.Pipe,
+        helperFileRestriction,
+        ...declarationFileRestrictions,
+      ],
+    },
+  },
+
+  // directives/*.directive.ts: @Directive allowed
+  {
+    files: ['**/directives/**/*.directive.ts'],
+    rules: {
+      'no-restricted-syntax': [
+        'error',
+        decoratorFileRestrictions.Component,
+        decoratorFileRestrictions.Injectable,
+        decoratorFileRestrictions.Pipe,
+        helperFileRestriction,
+        ...declarationFileRestrictions,
+      ],
+    },
+  },
+
+  // pipes/*.pipe.ts: @Pipe allowed, class must end with "Pipe"
+  {
+    files: ['**/pipes/**/*.pipe.ts'],
+    rules: {
+      'no-restricted-syntax': [
+        'error',
+        classSuffixRestriction('Pipe', '*.pipe.ts'),
+        decoratorFileRestrictions.Component,
+        decoratorFileRestrictions.Directive,
+        decoratorFileRestrictions.Injectable,
+        helperFileRestriction,
+        ...declarationFileRestrictions,
+      ],
+    },
+  },
+
+  // services/*.service.ts: @Injectable allowed, class must end with "Service"
+  {
+    files: ['**/services/**/*.service.ts'],
+    rules: {
+      'no-restricted-syntax': [
+        'error',
+        classSuffixRestriction('Service', '*.service.ts'),
+        decoratorFileRestrictions.Component,
+        decoratorFileRestrictions.Directive,
+        decoratorFileRestrictions.Pipe,
+        helperFileRestriction,
+        ...declarationFileRestrictions,
+      ],
+    },
+  },
+
+  // helpers/*.helpers.ts: undecorated classes allowed, class must end with "Helpers"
+  {
+    files: ['**/helpers/**/*.helpers.ts'],
+    rules: {
+      'no-restricted-syntax': [
+        'error',
+        classSuffixRestriction('Helpers', '*.helpers.ts'),
+        decoratorFileRestrictions.Component,
+        decoratorFileRestrictions.Directive,
+        decoratorFileRestrictions.Injectable,
+        decoratorFileRestrictions.Pipe,
+        ...declarationFileRestrictions,
+      ],
+    },
+  },
+
+  // interfaces/*.interface.ts: only interfaces allowed
+  {
+    files: ['**/interfaces/**/*.interface.ts'],
+    rules: {
+      'no-restricted-syntax': [
+        'error',
+        {
+          selector: 'Program > :not(ImportDeclaration, TSInterfaceDeclaration, ExportNamedDeclaration:has(> TSInterfaceDeclaration))',
+          message: 'Only interfaces allowed in interfaces/*.interface.ts',
+        },
+      ],
+    },
+  },
+
+  // interfaces/enums.ts / interfaces/*.enum.ts: only enums allowed
+  {
+    files: ['**/interfaces/enums.ts', '**/interfaces/**/*.enum.ts'],
+    rules: {
+      'no-restricted-syntax': [
+        'error',
+        {
+          selector: 'Program > :not(ImportDeclaration, TSEnumDeclaration, ExportNamedDeclaration:has(> TSEnumDeclaration))',
+          message: 'Only enums allowed in interfaces/enums.ts / interfaces/*.enum.ts',
+        },
+      ],
+    },
+  },
+
+  // interfaces/types.ts / interfaces/*.type.ts: only type aliases allowed
+  {
+    files: ['**/interfaces/types.ts', '**/interfaces/**/*.type.ts'],
+    rules: {
+      'no-restricted-syntax': [
+        'error',
+        {
+          selector: 'Program > :not(ImportDeclaration, TSTypeAliasDeclaration, ExportNamedDeclaration:has(> TSTypeAliasDeclaration))',
+          message: 'Only type aliases allowed in interfaces/types.ts / interfaces/*.type.ts',
+        },
+      ],
+    },
+  },
+
+  // constants/*.constant.ts: only imports + export const allowed
+  {
+    files: ['**/constants/**/*.constant.ts'],
+    rules: {
+      'no-restricted-syntax': [
+        'error',
+        {
+          selector: 'Program > :not(ImportDeclaration, ExportNamedDeclaration:has(> VariableDeclaration[kind="const"]))',
+          message: 'Only imports and export const allowed in constants/*.constant.ts',
+        },
+      ],
+    },
+  },
+
+  // guards/*.guard.ts: only imports + export const allowed (functional guards)
+  {
+    files: ['**/guards/**/*.guard.ts'],
+    rules: {
+      'no-restricted-syntax': [
+        'error',
+        {
+          selector: 'Program > :not(ImportDeclaration, ExportNamedDeclaration:has(> VariableDeclaration[kind="const"]))',
+          message: 'Only imports and export const allowed in guards/*.guard.ts',
+        },
+      ],
+    },
+  },
+
+  // interceptors/*.interceptor.ts: only imports + export const allowed (functional interceptors)
+  {
+    files: ['**/interceptors/**/*.interceptor.ts'],
+    rules: {
+      'no-restricted-syntax': [
+        'error',
+        {
+          selector: 'Program > :not(ImportDeclaration, ExportNamedDeclaration:has(> VariableDeclaration[kind="const"]))',
+          message: 'Only imports and export const allowed in interceptors/*.interceptor.ts',
+        },
+      ],
+    },
+  },
+
+  // resolvers/*.resolver.ts: only imports + export const allowed (functional resolvers)
+  {
+    files: ['**/resolvers/**/*.resolver.ts'],
+    rules: {
+      'no-restricted-syntax': [
+        'error',
+        {
+          selector: 'Program > :not(ImportDeclaration, ExportNamedDeclaration:has(> VariableDeclaration[kind="const"]))',
+          message: 'Only imports and export const allowed in resolvers/*.resolver.ts',
+        },
+      ],
+    },
+  },
+
+  // *.routes.ts: only imports + export const allowed (route definitions, any folder)
+  {
+    files: ['**/*.routes.ts'],
+    rules: {
+      'no-restricted-syntax': [
+        'error',
+        {
+          selector: 'Program > :not(ImportDeclaration, ExportNamedDeclaration:has(> VariableDeclaration[kind="const"]))',
+          message: 'Only imports and export const allowed in *.routes.ts',
+        },
+      ],
+    },
+  },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-angular-strict",
-  "version": "2.3.82",
+  "version": "2.3.84",
   "description": "Modern ESLint configuration with strict rules for Angular development.",
   "keywords": [
     "angular",
@@ -40,10 +40,10 @@
     "@angular-eslint/eslint-plugin-template": "21.3.1",
     "@angular-eslint/template-parser": "21.3.1",
     "@stylistic/eslint-plugin": "5.10.0",
-    "@typescript-eslint/eslint-plugin": "8.59.2",
-    "@typescript-eslint/parser": "8.59.2",
-    "@typescript-eslint/types": "8.59.2",
-    "@typescript-eslint/utils": "8.59.2",
+    "@typescript-eslint/eslint-plugin": "8.59.3",
+    "@typescript-eslint/parser": "8.59.3",
+    "@typescript-eslint/types": "8.59.3",
+    "@typescript-eslint/utils": "8.59.3",
     "eslint": "9.39.4",
     "eslint-config-airbnb-extended": "3.1.0",
     "eslint-plugin-import-x": "4.16.2",