Bump @typescript-eslint/typescript-estree to v7

Author: rubensworks

.eslintrc.js

@@ -125,8 +125,8 @@ The following shows an example of the possible options:
   "source": "lib",
   "destination": "components",
   "extension": "jsonld",
-  "ignorePackagePaths": [ "path/to/package-ignored1", "path/to/package-ignored2" ],
-  "ignoreComponents": [ "Class1", "Class2" ],
+  "ignorePackagePaths": ["path/to/package-ignored1", "path/to/package-ignored2"],
+  "ignoreComponents": ["Class1", "Class2"],
   "logLevel": "info",
   "modulePrefix": "myprefix",
   "debugState": "true",
@@ -170,7 +170,7 @@ export class MyClass extends OtherClass {
    * @param paramA - My parameter
    */
   constructor(paramA: boolean, paramB: number, paramC: string[]) {
-  
+
   }
 }
 ```
@@ -221,13 +221,13 @@ Component file:
 
 Each argument in the constructor of the class must be one of the following:
 
-* A primitive type such as `boolean, number, string`, which will be mapped to an [XSD type](https://componentsjs.readthedocs.io/en/latest/configuration/components/parameters/) 
+* A primitive type such as `boolean, number, string`, which will be mapped to an [XSD type](https://componentsjs.readthedocs.io/en/latest/configuration/components/parameters/)
 * Another class, which will be mapped to the component `@id`.
 * A record or interface containing key-value pairs where each value matches one of the possible options. Nesting is allowed.
 * Reference to a generic type that is defined on the class.
 * An array, `keyof`, tuple, union, or intersection over any of the allowed types.
-  
-Here is an example that showcases all of these options:  
+
+Here is an example that showcases all of these options:
    ```typescript
   import {Logger} from "@comunica/core";
   export class SampleActor {
@@ -252,7 +252,7 @@ Here is an example that showcases all of these options:
   export interface ExtendsTest {
       string: string;
   }
-``` 
+```
 
 ### Argument tags
 
@@ -286,7 +286,7 @@ export class MyActor {
     /**
      * @param myByte - This is an array of bytes @range {byte}
      * @param ignoredArg - @ignored
-     */ 
+     */
     constructor(myByte: number[], ignoredArg: string) {
 
     }
@@ -326,7 +326,7 @@ export class MyActor {
     /**
      * @param myValue - Values will be passed as parsed JSON @range {json}
      * @param ignoredArg - @ignored
-     */ 
+     */
     constructor(myValue: any, ignoredArg: string) {
 
     }
@@ -364,7 +364,7 @@ When instantiating TestClass as follows, its JSON value will be passed directly
     "someKey": {
       "someOtherKey1": 1,
       "someOtherKey2": "abc"
-    }  
+    }
   }
 }
 ```

README.md

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import * as fs from 'fs';
+import * as fs from 'node:fs';
 import * as minimist from 'minimist';
 import { GeneratorFactory } from '../lib/config/GeneratorFactory';
 import { ResolutionContext } from '../lib/resolution/ResolutionContext';
@@ -38,7 +38,7 @@ if (args.help) {
 } else {
   const packageRootDirectories = (args._.length > 0 ? args._ : [ '' ])
     .map(path => joinFilePath(normalizeFilePath(process.cwd()), path))
-    .flatMap(path => {
+    .flatMap((path) => {
       // Since path expansion does not work on Windows, we may receive wildcard paths, so let's expand those here
       if (path.endsWith('*')) {
         path = path.slice(0, -1);
@@ -56,4 +56,3 @@ if (args.help) {
       process.exit(1);
     });
 }
-

bin/componentsjs-generator.ts

@@ -0,0 +1,56 @@
+const config = require('@rubensworks/eslint-config');
+
+module.exports = config([
+  {
+    files: [ '**/*.ts' ],
+    languageOptions: {
+      parserOptions: {
+        tsconfigRootDir: __dirname,
+        project: [ './tsconfig.eslint.json' ],
+      },
+    },
+  },
+  {
+    files: [ '**/*.ts' ],
+    rules: {
+      'import/no-nodejs-modules': 'off',
+      'ts/naming-convention': [
+        'error',
+        {
+          selector: 'interface',
+          format: [ 'PascalCase' ],
+          custom: {
+            regex: '^[A-Z]',
+            match: true,
+          },
+        },
+      ],
+      // TODO: check if we can enable the following
+      'ts/no-require-imports': 'off',
+      'ts/no-unsafe-assignment': 'off',
+      'ts/no-unsafe-argument': 'off',
+      'ts/no-unsafe-return': 'off',
+    },
+  },
+  {
+    // Specific rules for NodeJS-specific files
+    files: [
+      '**/test/**/*.ts',
+    ],
+    rules: {
+      'import/no-nodejs-modules': 'off',
+      'unused-imports/no-unused-vars': 'off',
+      'ts/no-require-imports': 'off',
+      'ts/no-var-requires': 'off',
+      'ts/no-extraneous-class': 'off',
+      // TODO: check if we can enable the following
+      'node/no-path-concat': 'off',
+    },
+  },
+  {
+    // Files that do not require linting
+    ignores: [
+      '**/file-invalid.d.ts',
+    ],
+  },
+]);

eslint.config.js

@@ -3,12 +3,14 @@
  */
 import type { Logger } from 'winston';
 import type { ClassFinder } from './ClassFinder';
-import type { ClassIndex,
+import type {
+  ClassIndex,
   ClassReference,
   ClassReferenceLoaded,
   ClassReferenceLoadedClassOrInterface,
   InterfaceLoaded,
-  GenericallyTyped } from './ClassIndex';
+  GenericallyTyped,
+} from './ClassIndex';
 
 import type { ClassLoader } from './ClassLoader';
 
@@ -55,8 +57,8 @@ export class ClassIndexer {
 
     if (classReferenceLoaded.type === 'class') {
       // If the class has a super class, load it recursively
-      const superClassName = this.classLoader.getSuperClassName(classReferenceLoaded.declaration,
-        classReferenceLoaded.fileName);
+      const superClassName = this.classLoader
+        .getSuperClassName(classReferenceLoaded.declaration, classReferenceLoaded.fileName);
       if (superClassName && !(superClassName.value in this.ignoreClasses)) {
         let superClassLoaded;
         try {
@@ -80,13 +82,13 @@ export class ClassIndexer {
       }
 
       // If the class implements interfaces, load them
-      const interfaceNames = this.classLoader.getClassInterfaceNames(classReferenceLoaded.declaration,
-        classReferenceLoaded.fileName);
+      const interfaceNames = this.classLoader
+        .getClassInterfaceNames(classReferenceLoaded.declaration, classReferenceLoaded.fileName);
       classReferenceLoaded.implementsInterfaces = <GenericallyTyped<ClassReferenceLoadedClassOrInterface>[]> (
         await Promise
           .all(interfaceNames
             .filter(interfaceName => !(interfaceName.value in this.ignoreClasses))
-            .map(async interfaceName => {
+            .map(async(interfaceName) => {
               let interfaceOrClassLoaded;
               try {
                 interfaceOrClassLoaded = await this.classLoader.loadClassDeclaration({
@@ -106,14 +108,14 @@ export class ClassIndexer {
                 genericTypeInstantiations: interfaceName.genericTypeInstantiations,
               };
             })))
-        .filter(iface => Boolean(iface));
+        .filter(Boolean);
     } else {
       const superInterfaceNames = this.classLoader
         .getSuperInterfaceNames(classReferenceLoaded.declaration, classReferenceLoaded.fileName);
       classReferenceLoaded.superInterfaces = <GenericallyTyped<InterfaceLoaded>[]> (await Promise
         .all(superInterfaceNames
           .filter(interfaceName => !(interfaceName.value in this.ignoreClasses))
-          .map(async interfaceName => {
+          .map(async(interfaceName) => {
             let superInterface;
             try {
               superInterface = await this.loadClassChain({
@@ -136,7 +138,7 @@ export class ClassIndexer {
               genericTypeInstantiations: interfaceName.genericTypeInstantiations,
             };
           })))
-        .filter(iface => Boolean(iface));
+        .filter(Boolean);
     }
 
     return classReferenceLoaded;

lib/parse/ClassIndexer.ts

@@ -46,7 +46,7 @@ export class ClassLoader {
       // Extensions in the form of `class A extends B`
       return {
         value: declaration.superClass.name,
-        genericTypeInstantiations: declaration.superTypeParameters,
+        genericTypeInstantiations: declaration.superTypeArguments,
       };
     }
     if (declaration.superClass.type === AST_NODE_TYPES.MemberExpression &&
@@ -62,27 +62,27 @@ export class ClassLoader {
    * Find the super interfaces of the given interface.
    * Throws an error for interface definitions that could not be interpreted.
    * @param declaration An interface declaration.
-   * @param fileName The file name of the current class.
+   * @param _fileName The file name of the current class.
    */
   public getSuperInterfaceNames(
     declaration: TSESTree.TSInterfaceDeclaration,
-    fileName: string,
+    _fileName: string,
   ): GenericallyTyped<string>[] {
-    return <GenericallyTyped<string>[]> (declaration.extends || [])
+    return <GenericallyTyped<string>[]> declaration.extends
       // eslint-disable-next-line array-callback-return
-      .map(extendsExpression => {
+      .map((extendsExpression) => {
         if (extendsExpression.type === AST_NODE_TYPES.TSInterfaceHeritage &&
           extendsExpression.expression.type === AST_NODE_TYPES.Identifier) {
           // Extensions in the form of `interface A extends B`
           return {
             value: extendsExpression.expression.name,
-            genericTypeInstantiations: extendsExpression.typeParameters,
+            genericTypeInstantiations: extendsExpression.typeArguments,
           };
         }
         // Ignore interfaces that we don't understand
         this.logger.debug(`Ignored an interface expression of unknown type ${extendsExpression.expression.type} on ${declaration.id.name}`);
       })
-      .filter(iface => Boolean(iface));
+      .filter(Boolean);
   }
 
   /**
@@ -102,7 +102,7 @@ export class ClassLoader {
         }
         interfaceNames.push({
           value: implement.expression.name,
-          genericTypeInstantiations: implement.typeParameters,
+          genericTypeInstantiations: implement.typeArguments,
         });
       }
     }
@@ -375,15 +375,23 @@ export class ClassLoader {
                 name: enumKey,
                 loc: <any> undefined,
                 range: <any> undefined,
+                parent: <any> undefined,
+                typeAnnotation: <any> undefined,
+                optional: <any> undefined,
+                decorators: <any> undefined,
               },
               typeAnnotation: {
                 type: AST_NODE_TYPES.TSLiteralType,
                 literal: enumMember.initializer,
                 loc: <any> undefined,
                 range: <any> undefined,
+                parent: <any> undefined,
               },
               loc: <any> undefined,
               range: <any> undefined,
+              parent: <any> undefined,
+              declare: <any> undefined,
+              typeParameters: <any> undefined,
             };
             return <any> <TypeLoaded> {
               type: 'type',