@futdevpro/dynamo-eslint 1.12.1 → 1.14.3

package/samples/package.json.example

@@ -0,0 +1,26 @@
+{
+  "name": "example-project",
+  "version": "1.0.0",
+  "scripts": {
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "lint:fix-all": "eslint src --ext .ts --fix && dynamo-fix-return-types",
+    "validate:imports": "dynamo-validate-imports",
+    "validate:naming": "dynamo-validate-naming",
+    "audit:eslintrc": "dynamo-eslintrc-audit",
+    "fix": "dynamo-fix",
+    "fix:return-types": "dynamo-fix-return-types",
+    "test": "npm run lint && npm run validate:imports && npm run validate:naming"
+  },
+  "devDependencies": {
+    "@futdevpro/dynamo-eslint": "^01.14.2",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "eslint": "^9.0.0",
+    "eslint-plugin-import": "^2.29.0",
+    "eslint-plugin-jsdoc": "^48.0.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "prettier": "^3.3.0",
+    "typescript": "^5.5.4"
+  }
+}

package/samples/poc-violations.ts

@@ -4,6 +4,16 @@
 // ❌ VIOLATIONS: This file contains multiple import ordering violations
 
 // Wrong order: FutDevPro packages before non-FutDevPro packages
+
+
+
+
+
+
+
+
+
+
 import { DyFM_Error } from '@futdevpro/fsm-dynamo';
 import { Component } from '@angular/core';
 
@@ -12,13 +22,32 @@ import { Router } from '@angular/router';
 import { FDP_User } from '@futdevpro/fdp-templates';
 
 // Wrong order: same module before other modules
+
+
+
+
+
+
+
+
+
+
 import { LocalService } from './local.service';
+
+
+
+
+
+
+
+
+
 import { SomeService } from '../../../services/some.service';
 
 // ❌ Forbidden patterns:
-import { Something } from '../../../NPM-packages/some-package'; // Forbidden NPM-packages import
-import { AnotherThing } from './some-file.js'; // Forbidden .js extension
-import type { SomeType } from './some-file'; // Forbidden import type
+import { Something } from '@futdevpro/some-package'; // Forbidden NPM-packages import
+import { AnotherThing } from './some-file'; // Forbidden .js extension
+import { SomeType } from './some-file'; // Forbidden import type
 
 export class PocViolationsComponent {
   // This class demonstrates various import violations

package/src/configs/base.ts

@@ -1,51 +1,96 @@
-export = {
-  env: { browser: true, es2021: true },
-  parser: '@typescript-eslint/parser',
-  parserOptions: { ecmaVersion: 'latest' },
-  plugins: [
-    '@typescript-eslint',
-    'unused-imports',
-    'max-params-no-constructor',
-  ],
-  extends: [
-    'eslint:recommended',
-    'plugin:@typescript-eslint/recommended',
-  ],
-  rules: {
-    'no-warning-comments': ['warn', { terms: ['todo', 'fixme', 'removable', '??'], location: 'anywhere' }],
-    indent: ['warn', 2, { SwitchCase: 1 }],
-    'max-len': ['warn', { code: 100, comments: 120 }],
-    'max-lines': ['warn', 1000],
-    'linebreak-style': 'off',
-    semi: ['warn', 'always'],
-    'no-unused-vars': 'off',
-    'no-prototype-builtins': 'off',
-    'no-empty': 'warn',
-    'comma-dangle': ['warn', { arrays: 'always-multiline', objects: 'always-multiline', functions: 'only-multiline', imports: 'never', exports: 'never' }],
-    'brace-style': ['warn', '1tbs', { allowSingleLine: false }],
-    'object-curly-spacing': ['warn', 'always'],
-    'array-bracket-spacing': ['warn', 'always', { objectsInArrays: false, arraysInArrays: false }],
-    'padding-line-between-statements': [
-      'warn',
-      { blankLine: 'always', prev: '*', next: ['return','throw','if','for','while','switch','default'] },
-      { blankLine: 'always', prev: ['const','let','var','break'], next: '*' },
-      { blankLine: 'any', prev: ['const','let','var'], next: ['const','let','var'] },
-    ],
-    'prefer-const': 'warn',
-    'no-case-declarations': 'off',
-    'no-fallthrough': 'off',
-    'keyword-spacing': 'warn',
-    'no-else-return': 'warn',
-    'no-duplicate-imports': 'warn',
-    'max-params': ['warn', 4],
-    'max-params-no-constructor/max-params-no-constructor': ['warn', 5],
-    quotes: ['warn', 'single', { allowTemplateLiterals: true }],
-    '@typescript-eslint/quotes': ['warn', 'single', { allowTemplateLiterals: true }],
-    '@typescript-eslint/no-unused-vars': 'warn',
-    '@typescript-eslint/explicit-function-return-type': ['warn', { allowTypedFunctionExpressions: false }],
-    '@typescript-eslint/no-explicit-any': 'warn',
-    '@typescript-eslint/typedef': 'warn',
+
+/**
+ * Base Rulesets For Dynamo Based Systems
+ * ESLint v9 Flat Config Format
+ */
+const tsParser = require('@typescript-eslint/parser');
+const tsPlugin = require('@typescript-eslint/eslint-plugin');
+const unusedImportsPlugin = require('eslint-plugin-unused-imports');
+const maxParamsNoConstructorPlugin = require('eslint-plugin-max-params-no-constructor');
+const dynamoPlugin = require('../plugin');
+
+module.exports = [
+  {
+    ignores: [
+      'node_modules/**',
+      'dist/**',
+      'build/**',
+      '*.d.ts'
+    ]
+  },
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: { 
+        ecmaVersion: 'latest',
+        sourceType: 'module'
+      },
+      globals: {
+        // Browser globals
+        window: 'readonly',
+        document: 'readonly',
+        console: 'readonly',
+        process: 'readonly',
+        Buffer: 'readonly',
+        global: 'readonly',
+        __dirname: 'readonly',
+        __filename: 'readonly',
+        module: 'readonly',
+        require: 'readonly',
+        exports: 'readonly'
+      }
+    },
+    plugins: {
+      '@typescript-eslint': tsPlugin,
+      'unused-imports': unusedImportsPlugin,
+      'max-params-no-constructor': maxParamsNoConstructorPlugin,
+      '@futdevpro/dynamo': dynamoPlugin,
+    },
+    rules: {
+      // ESLint recommended rules
+      'no-warning-comments': ['warn', { terms: ['todo', 'fixme', 'removable', '??'], location: 'anywhere' }],
+      'indent': ['warn', 2, { SwitchCase: 1 }],
+      'max-len': ['warn', { code: 100, comments: 120 }],
+      'max-lines': ['warn', 1000],
+      'linebreak-style': 'off',
+      'semi': ['warn', 'always'],
+      'no-unused-vars': 'off',
+      'no-prototype-builtins': 'off',
+      'no-empty': 'warn',
+      'comma-dangle': ['warn', { arrays: 'always-multiline', objects: 'always-multiline', functions: 'only-multiline', imports: 'never', exports: 'never' }],
+      'brace-style': ['warn', '1tbs', { allowSingleLine: false }],
+      'object-curly-spacing': ['warn', 'always'],
+      'array-bracket-spacing': ['warn', 'always', { objectsInArrays: false, arraysInArrays: false }],
+      'padding-line-between-statements': [
+        'warn',
+        { blankLine: 'always', prev: '*', next: ['return','throw','if','for','while','switch','default'] },
+        { blankLine: 'always', prev: ['const','let','var','break'], next: '*' },
+        { blankLine: 'any', prev: ['const','let','var'], next: ['const','let','var'] },
+      ],
+      'prefer-const': 'warn',
+      'no-case-declarations': 'off',
+      'no-fallthrough': 'off',
+      'keyword-spacing': 'warn',
+      'no-else-return': 'warn',
+      'no-duplicate-imports': 'warn',
+      'max-params': ['warn', 4],
+      'max-params-no-constructor/max-params-no-constructor': ['warn', 5],
+      'quotes': ['warn', 'single', { allowTemplateLiterals: true }],
+      
+      // TypeScript rules
+      '@typescript-eslint/no-unused-vars': 'warn',
+      '@typescript-eslint/explicit-function-return-type': ['warn', { allowTypedFunctionExpressions: false }],
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/typedef': 'warn',
+      
+      // Dynamo custom rules
+      '@futdevpro/dynamo/import-order': 'warn',
+      '@futdevpro/dynamo/naming-patterns': 'warn',
+      '@futdevpro/dynamo/no-import-type': 'warn',
+      '@futdevpro/dynamo/no-js-import': 'warn',
+    },
   },
-};
+];
 
 

package/src/configs/fsm.ts

@@ -1,9 +1,10 @@
-import nts = require('./nts');
-
-const config = {
-  ...nts,
-};
-
-export = config;
+const fsmBaseConfig = require('./base');
+
+/**
+ * Rulesets For Dynamo Based Systems
+ * FSM: Full Stack Module
+ * ESLint v9 Flat Config Format
+ */
+module.exports = fsmBaseConfig;
 
 

package/src/configs/ngx-package.ts

@@ -1,9 +1,10 @@
-import ngx = require('./ngx');
-
-const config = {
-  ...ngx,
-};
-
-export = config;
+const ngxConfig = require('./ngx');
+
+/**
+ * Rulesets For Dynamo Based Systems
+ * NGX-PACKAGE: Angular Package
+ * ESLint v9 Flat Config Format
+ */
+module.exports = ngxConfig;
 
 

package/src/configs/ngx.ts

@@ -1,14 +1,74 @@
-import base = require('./base');
+const ngxBaseConfig = require('./base');
+const angularPlugin = require('@angular-eslint/eslint-plugin');
+const angularTemplatePlugin = require('@angular-eslint/eslint-plugin-template');
+const angularTemplateParser = require('@angular-eslint/template-parser');
 
-const config = {
-  ...base,
-  env: { browser: true, es2021: true },
-  extends: [
-    ...base.extends,
-    'plugin:@angular-eslint/recommended',
-  ],
-};
-
-export = config;
+/**
+ * Rulesets For Dynamo Based Systems
+ * NGX: Angular Projects
+ * ESLint v9 Flat Config Format
+ */
+module.exports = [
+  ...ngxBaseConfig,
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+    languageOptions: {
+      ...ngxBaseConfig[1].languageOptions,
+      globals: {
+        // Angular globals
+        window: 'readonly',
+        document: 'readonly',
+        console: 'readonly',
+        process: 'readonly',
+        Buffer: 'readonly',
+        global: 'readonly',
+        __dirname: 'readonly',
+        __filename: 'readonly',
+        module: 'readonly',
+        require: 'readonly',
+        exports: 'readonly'
+      }
+    },
+    plugins: {
+      ...ngxBaseConfig[1].plugins,
+      '@angular-eslint': angularPlugin,
+    },
+    rules: {
+      ...ngxBaseConfig[1].rules,
+      // Angular-specific rules
+      '@angular-eslint/directive-selector': 'error',
+      '@angular-eslint/component-selector': 'error',
+      '@angular-eslint/no-conflicting-lifecycle': 'error',
+      '@angular-eslint/no-host-metadata-property': 'error',
+      '@angular-eslint/no-input-rename': 'error',
+      '@angular-eslint/no-output-rename': 'error',
+      '@angular-eslint/no-outputs-metadata-property': 'error',
+      '@angular-eslint/use-lifecycle-interface': 'error',
+      '@angular-eslint/use-pipe-transform-interface': 'error',
+    },
+  },
+  {
+    files: ['**/*.html'],
+    languageOptions: {
+      parser: angularTemplateParser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        sourceType: 'module',
+      },
+    },
+    plugins: {
+      '@angular-eslint/template': angularTemplatePlugin,
+    },
+    rules: {
+      '@angular-eslint/template/banana-in-box': 'error',
+      '@angular-eslint/template/cyclomatic-complexity': 'error',
+      '@angular-eslint/template/eqeqeq': 'error',
+      '@angular-eslint/template/no-call-expression': 'error',
+      '@angular-eslint/template/no-duplicate-attributes': 'error',
+      '@angular-eslint/template/no-negated-async': 'error',
+      '@angular-eslint/template/use-track-by-function': 'error',
+    },
+  },
+];
 
 

package/src/configs/nts-package.ts

@@ -1,14 +1,20 @@
-import nts = require('./nts');
+const ntsConfig = require('./nts');
 
-const config = {
-  ...nts,
-  rules: {
-    ...nts.rules,
-    '@typescript-eslint/ban-types': 'off',
-    '@typescript-eslint/no-explicit-any': 'off',
+/**
+ * Rulesets For Dynamo Based Systems
+ * NTS-PACKAGE: Node TypeScript Package
+ * ESLint v9 Flat Config Format
+ */
+module.exports = [
+  ...ntsConfig,
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+    rules: {
+      ...ntsConfig[1].rules,
+      '@typescript-eslint/ban-types': 'off',
+      '@typescript-eslint/no-explicit-any': 'off',
+    },
   },
-};
-
-export = config;
+];
 
 

package/src/configs/nts.ts

@@ -1,15 +1,34 @@
-import base = require('./base');
+const ntsBaseConfig = require('./base');
 
-const config = {
-  ...base,
-  env: { node: true, es2021: true },
-  parserOptions: { ...base.parserOptions, sourceType: 'module' },
-  rules: {
-    ...base.rules,
-    'max-lines': ['warn', 1500],
+/**
+ * Rulesets For Dynamo Based Systems
+ * NTS: Node TypeScript
+ * ESLint v9 Flat Config Format
+ */
+module.exports = [
+  ...ntsBaseConfig,
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+    languageOptions: {
+      ...ntsBaseConfig[1].languageOptions,
+      globals: {
+        // Node.js globals
+        process: 'readonly',
+        Buffer: 'readonly',
+        global: 'readonly',
+        __dirname: 'readonly',
+        __filename: 'readonly',
+        module: 'readonly',
+        require: 'readonly',
+        exports: 'readonly',
+        console: 'readonly'
+      }
+    },
+    rules: {
+      ...ntsBaseConfig[1].rules,
+      'max-lines': ['warn', 1500],
+    },
   },
-};
-
-export = config;
+];
 
 

package/src/plugin/index.ts

@@ -1,15 +1,23 @@
-import importOrderRule from './rules/import-order';
+import importOrderRule from './rules/import/import-order';
 import namingPatternsRule from './rules/naming-patterns';
+import noImportTypeRule from './rules/import/no-import-type';
+import noJsExtensionRule from './rules/import/no-js-import';
 
 export = {
   rules: {
     'import-order': importOrderRule,
+    'no-import-type': noImportTypeRule,
+    'no-js-import': noJsExtensionRule,
+
     'naming-patterns': namingPatternsRule,
   },
   configs: {
     recommended: {
       rules: {
         '@futdevpro/dynamo/import-order': 'warn',
+        '@futdevpro/dynamo/no-import-type': 'warn',
+        '@futdevpro/dynamo/no-js-import': 'warn',
+        
         '@futdevpro/dynamo/naming-patterns': 'warn',
       },
     },

package/src/plugin/rules/{import-order.spec.ts → import/import-order.spec.ts}

@@ -11,24 +11,25 @@ describe('| import-order', () => {
     const mockContext = {
       getSourceCode: () => ({ 
         ast: {},
-        getLines: () => ['line1', 'line2', 'line3']
+        getLines: () => [ 'line1', 'line2', 'line3' ],
       }),
       getFilename: () => 'test.ts',
       report: () => {},
     } as any;
 
     const result = importOrderRule.create(mockContext);
+
     expect(typeof result).toBe('object');
     expect(typeof result.Program).toBe('function');
   });
 
   it('| should detect forbidden NPM-packages imports', () => {
     const mockContext = {
-      getSourceCode: () => ({ 
+      sourceCode: { 
         ast: {},
-        getLines: () => ['import { Something } from \'../../../NPM-packages/some-package\';']
-      }),
-      getFilename: () => 'test.ts',
+        getLines: () => [ 'import { Something } from \'../../../NPM-packages/some-package\';' ],
+      },
+      filename: 'test.ts',
       report: (options: any) => {
         expect(options.messageId).toBe('forbiddenNpmPackages');
       },
@@ -42,22 +43,23 @@ describe('| import-order', () => {
           type: 'ImportDeclaration',
           source: { value: '../../../NPM-packages/some-package' },
           importKind: 'value',
-          loc: { start: { line: 1 }, end: { line: 1 } }
-        }
-      ]
+          loc: { start: { line: 1 }, end: { line: 1 } },
+        },
+      ],
     } as any;
 
     const rule = importOrderRule.create(mockContext);
+
     rule.Program(mockNode);
   });
 
   it('| should detect forbidden .js extension imports', () => {
     const mockContext = {
-      getSourceCode: () => ({ 
+      sourceCode: { 
         ast: {},
-        getLines: () => ['import { Something } from \'./some-file.js\';']
-      }),
-      getFilename: () => 'test.ts',
+        getLines: () => [ 'import { Something } from \'./some-file.js\';' ],
+      },
+      filename: 'test.ts',
       report: (options: any) => {
         expect(options.messageId).toBe('forbiddenJsExtension');
       },
@@ -71,22 +73,23 @@ describe('| import-order', () => {
           type: 'ImportDeclaration',
           source: { value: './some-file.js' },
           importKind: 'value',
-          loc: { start: { line: 1 }, end: { line: 1 } }
-        }
-      ]
+          loc: { start: { line: 1 }, end: { line: 1 } },
+        },
+      ],
     } as any;
 
     const rule = importOrderRule.create(mockContext);
+
     rule.Program(mockNode);
   });
 
   it('| should detect forbidden import type usage', () => {
     const mockContext = {
-      getSourceCode: () => ({ 
+      sourceCode: { 
         ast: {},
-        getLines: () => ['import type { SomeType } from \'./some-file\';']
-      }),
-      getFilename: () => 'test.ts',
+        getLines: () => [ 'import type { SomeType } from \'./some-file\';' ],
+      },
+      filename: 'test.ts',
       report: (options: any) => {
         expect(options.messageId).toBe('forbiddenImportType');
       },
@@ -100,26 +103,27 @@ describe('| import-order', () => {
           type: 'ImportDeclaration',
           source: { value: './some-file' },
           importKind: 'type',
-          loc: { start: { line: 1 }, end: { line: 1 } }
-        }
-      ]
+          loc: { start: { line: 1 }, end: { line: 1 } },
+        },
+      ],
     } as any;
 
     const rule = importOrderRule.create(mockContext);
+
     rule.Program(mockNode);
   });
 
   it('| should detect misordered imports', () => {
     let reportCount = 0;
     const mockContext = {
-      getSourceCode: () => ({ 
+      sourceCode: { 
         ast: {},
         getLines: () => [
           'import { DyFM_Error } from \'@futdevpro/fsm-dynamo\';',
-          'import { Component } from \'@angular/core\';'
-        ]
-      }),
-      getFilename: () => 'test.ts',
+          'import { Component } from \'@angular/core\';',
+        ],
+      },
+      filename: 'test.ts',
       report: (options: any) => {
         if (options.messageId === 'misordered') {
           reportCount++;
@@ -135,18 +139,19 @@ describe('| import-order', () => {
           type: 'ImportDeclaration',
           source: { value: '@futdevpro/fsm-dynamo' },
           importKind: 'value',
-          loc: { start: { line: 1 }, end: { line: 1 } }
+          loc: { start: { line: 1 }, end: { line: 1 } },
         },
         {
           type: 'ImportDeclaration',
           source: { value: '@angular/core' },
           importKind: 'value',
-          loc: { start: { line: 2 }, end: { line: 2 } }
-        }
-      ]
+          loc: { start: { line: 2 }, end: { line: 2 } },
+        },
+      ],
     } as any;
 
     const rule = importOrderRule.create(mockContext);
+
     rule.Program(mockNode);
     
     expect(reportCount).toBeGreaterThan(0);
@@ -155,14 +160,14 @@ describe('| import-order', () => {
   it('| should detect missing empty line between groups', () => {
     let reportCount = 0;
     const mockContext = {
-      getSourceCode: () => ({ 
+      sourceCode: { 
         ast: {},
         getLines: () => [
           'import { Component } from \'@angular/core\';',
-          'import { DyFM_Error } from \'@futdevpro/fsm-dynamo\';'
-        ]
-      }),
-      getFilename: () => 'test.ts',
+          'import { DyFM_Error } from \'@futdevpro/fsm-dynamo\';',
+        ],
+      },
+      filename: 'test.ts',
       report: (options: any) => {
         if (options.messageId === 'missingEmptyLine') {
           reportCount++;
@@ -178,18 +183,19 @@ describe('| import-order', () => {
           type: 'ImportDeclaration',
           source: { value: '@angular/core' },
           importKind: 'value',
-          loc: { start: { line: 1 }, end: { line: 1 } }
+          loc: { start: { line: 1 }, end: { line: 1 } },
         },
         {
           type: 'ImportDeclaration',
           source: { value: '@futdevpro/fsm-dynamo' },
           importKind: 'value',
-          loc: { start: { line: 2 }, end: { line: 2 } }
-        }
-      ]
+          loc: { start: { line: 2 }, end: { line: 2 } },
+        },
+      ],
     } as any;
 
     const rule = importOrderRule.create(mockContext);
+
     rule.Program(mockNode);
     
     expect(reportCount).toBeGreaterThan(0);