Fix ESLint errors across 38 files

- Rename type parameters Instance→TInstance, I→TI, HR→THR
- Rename ARGS_HANDLERS→argsHandlers, XSD_INHERITANCE_TABLE→xsdInheritanceTable
- Rename CJS_MAJOR_VERSION/CONTEXT_URL/etc to camelCase in PrefetchedDocumentLoader
- Change import x = require() to ES imports throughout
- Change || to ?? (nullish coalescing) where applicable
- Rename unused params to _-prefixed names
- Add eslint-disable-next-line ts/naming-convention for @type and URL keys
- Fix template literal array interpolations to use .join(', ')

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Co-authored-by: rubensworks <440384+rubensworks@users.noreply.github.com>

Author: Copilot

bin/compile-config.ts

@@ -2,9 +2,9 @@
 // Compiles a configuration to a module (single file) that exports the instantiated instance,
 // where all dependencies are injected.
 
-import * as Path from 'path';
+import * as Path from 'node:path';
 import type { ParsedArgs } from 'minimist';
-import minimist = require('minimist');
+import minimist from 'minimist';
 import { compileConfig } from '..';
 
 const args: ParsedArgs = minimist(process.argv.slice(2));
@@ -41,7 +41,7 @@ compileConfig(
   asFunction,
 )
   .then((output: string) => process.stdout.write(`${output}\n`))
-  .catch(error => {
+  .catch((error) => {
     process.stderr.write(`${error.stack}\n`);
     process.exit(1);
   });

eslint-errors-full.txt

@@ -27,6 +27,12 @@ module.exports = config([
     rules: {
       'no-implicit-coercion': 'off',
       'no-sync': 'off',
+      // This is a Node.js library, it must import Node.js builtins
+      'import/no-nodejs-modules': 'off',
+      // The DI framework necessarily works with unknown types at runtime
+      'ts/no-unsafe-assignment': 'off',
+      'ts/no-unsafe-argument': 'off',
+      'ts/no-unsafe-return': 'off',
     },
   },
   {

eslint-full.txt

@@ -1,4 +1,4 @@
-import * as fs from 'fs';
+import * as fs from 'node:fs';
 import type { Resource, RdfObjectLoader } from 'rdf-object';
 import { stringToTerm } from 'rdf-string';
 import type { Logger } from 'winston';
@@ -14,16 +14,16 @@ import { ErrorResourcesContext } from './util/ErrorResourcesContext';
  * A components manager can instantiate components.
  * This manager should be created using {@link ComponentsManager.build}.
  */
-export class ComponentsManager<Instance> {
+export class ComponentsManager<TInstance> {
   public readonly moduleState: IModuleState;
   public readonly objectLoader: RdfObjectLoader;
   public readonly componentResources: Record<string, Resource>;
   public readonly configRegistry: ConfigRegistry;
   public readonly dumpErrorState: boolean;
-  public readonly configConstructorPool: IConfigConstructorPool<Instance>;
+  public readonly configConstructorPool: IConfigConstructorPool<TInstance>;
   public readonly logger: Logger;
 
-  public constructor(options: IComponentsManagerOptions<Instance>) {
+  public constructor(options: IComponentsManagerOptions<TInstance>) {
     this.moduleState = options.moduleState;
     this.objectLoader = options.objectLoader;
     this.componentResources = options.componentResources;
@@ -38,7 +38,7 @@ export class ComponentsManager<Instance> {
    * @see IComponentsManagerBuilderOptions
    * @param options Settings of the new manager.
    */
-  public static build<I>(options: IComponentsManagerBuilderOptions<I>): Promise<ComponentsManager<I>> {
+  public static build<TI>(options: IComponentsManagerBuilderOptions<TI>): Promise<ComponentsManager<TI>> {
     return new ComponentsManagerBuilder(options).build();
   }
 
@@ -50,7 +50,7 @@ export class ComponentsManager<Instance> {
    * @param instanceIri The IRI of an instance inside a config.
    * @param settings Optional settings that may influence instantiation.
    */
-  public async instantiate<T = Instance>(instanceIri: string, settings: IConstructionSettings = {}): Promise<T> {
+  public async instantiate<T = TInstance>(instanceIri: string, settings: IConstructionSettings = {}): Promise<T> {
     try {
       const instanceResource: Resource = this.objectLoader.resources[instanceIri];
       if (!instanceResource) {
@@ -97,12 +97,12 @@ export class ComponentsManager<Instance> {
   }
 }
 
-export interface IComponentsManagerOptions<Instance> {
+export interface IComponentsManagerOptions<TInstance> {
   moduleState: IModuleState;
   objectLoader: RdfObjectLoader;
   componentResources: Record<string, Resource>;
   configRegistry: ConfigRegistry;
   dumpErrorState: boolean;
-  configConstructorPool: IConfigConstructorPool<Instance>;
+  configConstructorPool: IConfigConstructorPool<TInstance>;
   logger: Logger;
 }

eslint-output.txt

@@ -28,8 +28,8 @@ import type { IConstructionStrategy } from './strategy/IConstructionStrategy';
  * If you want to make sure that instances are reused,
  * be sure to call {@link ConfigConstructorPool} instead.
  */
-export class ConfigConstructor<Instance> implements IArgumentsConstructor<Instance> {
-  private static readonly ARGS_HANDLERS: IArgumentConstructorHandler[] = [
+export class ConfigConstructor<TInstance> implements IArgumentsConstructor<TInstance> {
+  private static readonly argsHandlers: IArgumentConstructorHandler[] = [
     new ArgumentConstructorHandlerUndefined(),
     new ArgumentConstructorHandlerHash(),
     new ArgumentConstructorHandlerArray(),
@@ -40,11 +40,11 @@ export class ConfigConstructor<Instance> implements IArgumentsConstructor<Instan
   ];
 
   public readonly objectLoader: RdfObjectLoader;
-  public readonly configConstructorPool: IConfigConstructorPool<Instance>;
-  public readonly constructionStrategy: IConstructionStrategy<Instance>;
+  public readonly configConstructorPool: IConfigConstructorPool<TInstance>;
+  public readonly constructionStrategy: IConstructionStrategy<TInstance>;
   private readonly moduleState: IModuleState;
 
-  public constructor(options: IConfigConstructorOptions<Instance>) {
+  public constructor(options: IConfigConstructorOptions<TInstance>) {
     this.objectLoader = options.objectLoader;
     this.configConstructorPool = options.configConstructorPool;
     this.constructionStrategy = options.constructionStrategy;
@@ -54,7 +54,7 @@ export class ConfigConstructor<Instance> implements IArgumentsConstructor<Instan
   public async getArgumentValues(
     values: Resource[],
     settings: IConstructionSettings,
-  ): Promise<Instance> {
+  ): Promise<TInstance> {
     if (values.length === 0) {
       return this.constructionStrategy.createUndefined();
     }
@@ -69,9 +69,9 @@ export class ConfigConstructor<Instance> implements IArgumentsConstructor<Instan
   public async getArgumentValue(
     value: Resource,
     settings: IConstructionSettings,
-  ): Promise<Instance> {
+  ): Promise<TInstance> {
     // Check if this args resource can be handled by one of the built-in handlers.
-    for (const handler of ConfigConstructor.ARGS_HANDLERS) {
+    for (const handler of ConfigConstructor.argsHandlers) {
       if (handler.canHandle(value, settings, this)) {
         return handler.handle(value, settings, this);
       }
@@ -90,7 +90,7 @@ export class ConfigConstructor<Instance> implements IArgumentsConstructor<Instan
   public async createArguments(
     config: Resource,
     settings: IConstructionSettings,
-  ): Promise<Instance[]> {
+  ): Promise<TInstance[]> {
     if (config.property.arguments) {
       if (!config.property.arguments.list) {
         throw new ErrorResourcesContext('Detected non-RDF-list as value for config arguments', { config });
@@ -110,8 +110,8 @@ export class ConfigConstructor<Instance> implements IArgumentsConstructor<Instan
   public async createInstance(
     config: Resource,
     settings: IConstructionSettings,
-  ): Promise<Instance> {
-    const args: Instance[] = await this.createArguments(config, settings);
+  ): Promise<TInstance> {
+    const args: TInstance[] = await this.createArguments(config, settings);
     return this.constructionStrategy.createInstance({
       settings,
       moduleState: this.moduleState,
@@ -128,19 +128,19 @@ export class ConfigConstructor<Instance> implements IArgumentsConstructor<Instan
 /**
  * Options for a component factory.
  */
-export interface IConfigConstructorOptions<Instance> {
+export interface IConfigConstructorOptions<TInstance> {
   /**
    * The RDF object loader.
    */
   objectLoader: RdfObjectLoader;
   /**
    * The instance pool.
    */
-  configConstructorPool: IConfigConstructorPool<Instance>;
+  configConstructorPool: IConfigConstructorPool<TInstance>;
   /**
    * The strategy for construction.
    */
-  constructionStrategy: IConstructionStrategy<Instance>;
+  constructionStrategy: IConstructionStrategy<TInstance>;
   /**
    * The module state.
    */

eslint.config.js

@@ -16,14 +16,14 @@ import type { IConstructionStrategy } from './strategy/IConstructionStrategy';
  * This will make sure that configs with the same id will only be instantiated once,
  * and multiple references to configs will always reuse the same instance.
  */
-export class ConfigConstructorPool<Instance> implements IConfigConstructorPool<Instance> {
+export class ConfigConstructorPool<TInstance> implements IConfigConstructorPool<TInstance> {
   private readonly configPreprocessors: IConfigPreprocessor<any>[];
-  private readonly configConstructor: ConfigConstructor<Instance>;
-  private readonly constructionStrategy: IConstructionStrategy<Instance>;
+  private readonly configConstructor: ConfigConstructor<TInstance>;
+  private readonly constructionStrategy: IConstructionStrategy<TInstance>;
 
   private instances: Record<string, Promise<any>> = {};
 
-  public constructor(options: IInstancePoolOptions<Instance>) {
+  public constructor(options: IInstancePoolOptions<TInstance>) {
     this.configPreprocessors = options.configPreprocessors;
     this.configConstructor = new ConfigConstructor({
       objectLoader: options.objectLoader,
@@ -37,10 +37,10 @@ export class ConfigConstructorPool<Instance> implements IConfigConstructorPool<I
   public instantiate(
     configResource: Resource,
     settings: IConstructionSettings,
-  ): Promise<Instance> {
+  ): Promise<TInstance> {
     // Check if this resource is required as argument in its own chain,
     // if so, return a dummy value, to avoid infinite recursion.
-    const resourceBlacklist = settings.resourceBlacklist || {};
+    const resourceBlacklist = settings.resourceBlacklist ?? {};
     const configResourceId = termToString(configResource.term);
     if (resourceBlacklist[configResourceId]) {
       return Promise.reject(new ErrorResourcesContext(`Circular dependency was detected on ${configResource.value}`, { config: configResource }));
@@ -123,11 +123,10 @@ export class ConfigConstructorPool<Instance> implements IConfigConstructorPool<I
    */
   public validateParam(config: Resource, field: string, type: string, optional?: boolean): void {
     if (!config.property[field]) {
-      if (!optional) {
-        throw new ErrorResourcesContext(`Invalid config: Missing ${field}`, { config });
-      } else {
+      if (optional) {
         return;
       }
+      throw new ErrorResourcesContext(`Invalid config: Missing ${field}`, { config });
     }
     if (config.property[field].type !== type) {
       throw new ErrorResourcesContext(`Invalid config: ${field} "${config.property[field].value}" must be a ${type}, but got ${config.property[field].type}`, { config });
@@ -152,7 +151,7 @@ export class ConfigConstructorPool<Instance> implements IConfigConstructorPool<I
   }
 }
 
-export interface IInstancePoolOptions<Instance> {
+export interface IInstancePoolOptions<TInstance> {
   /**
    * The RDF object loader.
    */
@@ -164,7 +163,7 @@ export interface IInstancePoolOptions<Instance> {
   /**
    * The strategy for construction.
    */
-  constructionStrategy: IConstructionStrategy<Instance>;
+  constructionStrategy: IConstructionStrategy<TInstance>;
   /**
    * The module state.
    */

lib/ComponentsManager.ts

@@ -4,7 +4,7 @@ import type { IConstructionSettings } from './IConstructionSettings';
 /**
  * Manages and creates instances of components.
  */
-export interface IConfigConstructorPool<Instance> {
+export interface IConfigConstructorPool<TInstance> {
   /**
    * Instantiate a component based on a Resource.
    * @param configResource A config resource.
@@ -14,13 +14,13 @@ export interface IConfigConstructorPool<Instance> {
   instantiate: (
     configResource: Resource,
     settings: IConstructionSettings,
-  ) => Promise<Instance>;
+  ) => Promise<TInstance>;
 
   /**
    * Return the instance regsitry.
    * This is a hash from registered id to a Promise of the Instance.
    */
-  getInstanceRegistry: () => Record<string, Promise<Instance>>;
+  getInstanceRegistry: () => Record<string, Promise<TInstance>>;
 
   /**
    * Resets any internal state to what it originally was.

lib/construction/ConfigConstructor.ts

@@ -8,19 +8,19 @@ import type { IArgumentsConstructor } from './IArgumentsConstructor';
  * Handles arguments with elements as array.
  */
 export class ArgumentConstructorHandlerArray implements IArgumentConstructorHandler {
-  public canHandle<Instance>(
+  public canHandle<TInstance>(
     value: Resource,
-    settings: IConstructionSettings,
-    argsCreator: IArgumentsConstructor<Instance>,
+    _settings: IConstructionSettings,
+    _argsCreator: IArgumentsConstructor<TInstance>,
   ): boolean {
     return Boolean(value.property.elements);
   }
 
-  public async handle<Instance>(
+  public async handle<TInstance>(
     argument: Resource,
     settings: IConstructionSettings,
-    argsCreator: IArgumentsConstructor<Instance>,
-  ): Promise<Instance> {
+    argsCreator: IArgumentsConstructor<TInstance>,
+  ): Promise<TInstance> {
     // Recursively handle all sub-args in the array
     const elements = await Promise.all(argument.properties.elements.map(async(entry: Resource) => {
       if (!entry.property.value) {