chore: import types from files (#2902)

Co-authored-by: ScriptedAlchemy <[email protected]>

Author: ScriptedAlchemy

webpack/lib/NormalModuleFactory.d.ts

@@ -1,12 +1,12 @@
 export = NormalModuleFactory;
 declare class NormalModuleFactory extends ModuleFactory {
   /**
-   * @param {Object} param params
+   * @param {object} param params
    * @param {string=} param.context context
    * @param {InputFileSystem} param.fs file system
    * @param {ResolverFactory} param.resolverFactory resolverFactory
    * @param {ModuleOptions} param.options options
-   * @param {Object=} param.associatedObjectForCache an object to which the cache will be attached
+   * @param {object=} param.associatedObjectForCache an object to which the cache will be attached
    * @param {boolean=} param.layers enable layers
    */
   constructor({
@@ -21,48 +21,71 @@ declare class NormalModuleFactory extends ModuleFactory {
     fs: InputFileSystem;
     resolverFactory: ResolverFactory;
     options: ModuleOptions;
-    associatedObjectForCache?: any | undefined;
+    associatedObjectForCache?: object | undefined;
     layers?: boolean | undefined;
   });
   hooks: Readonly<{
-    resolve: AsyncSeriesBailHook<[ResolveData], false | void | Module>;
+    /** @type {AsyncSeriesBailHook<[ResolveData], Module | false | void>} */
+    resolve: AsyncSeriesBailHook<[ResolveData], Module | false | void>;
+    /** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
     resolveForScheme: HookMap<
       AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>
     >;
+    /** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
     resolveInScheme: HookMap<
       AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>
     >;
-    factorize: AsyncSeriesBailHook<[ResolveData], undefined | Module>;
+    /** @type {AsyncSeriesBailHook<[ResolveData], Module | undefined>} */
+    factorize: AsyncSeriesBailHook<[ResolveData], Module | undefined>;
+    /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
     beforeResolve: AsyncSeriesBailHook<[ResolveData], false | void>;
+    /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
     afterResolve: AsyncSeriesBailHook<[ResolveData], false | void>;
+    /** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], Module | void>} */
     createModule: AsyncSeriesBailHook<
-      [
-        Partial<NormalModuleCreateData & { settings: ModuleSettings }>,
-        ResolveData,
-      ],
-      void | Module
+      [ResolveData['createData'], ResolveData],
+      Module | void
     >;
+    /** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], Module>} */
     module: SyncWaterfallHook<
-      [
-        Module,
-        Partial<NormalModuleCreateData & { settings: ModuleSettings }>,
-        ResolveData,
-      ],
+      [Module, ResolveData['createData'], ResolveData],
       Module
     >;
+    /** @type {HookMap<SyncBailHook<[ParserOptions], Parser>>} */
     createParser: HookMap<SyncBailHook<[ParserOptions], Parser>>;
-    parser: HookMap<SyncBailHook<[any, ParserOptions], void>>;
+    /** @type {HookMap<SyncBailHook<[TODO, ParserOptions], void>>} */
+    parser: HookMap<SyncBailHook<[TODO, ParserOptions], void>>;
+    /** @type {HookMap<SyncBailHook<[GeneratorOptions], Generator>>} */
     createGenerator: HookMap<SyncBailHook<[GeneratorOptions], Generator>>;
-    generator: HookMap<SyncBailHook<[any, GeneratorOptions], void>>;
-    createModuleClass: HookMap<SyncBailHook<[any, ResolveData], Module>>;
+    /** @type {HookMap<SyncBailHook<[TODO, GeneratorOptions], void>>} */
+    generator: HookMap<SyncBailHook<[TODO, GeneratorOptions], void>>;
+    /** @type {HookMap<SyncBailHook<[TODO, ResolveData], Module>>} */
+    createModuleClass: HookMap<SyncBailHook<[TODO, ResolveData], Module>>;
   }>;
-  resolverFactory: ResolverFactory;
-  ruleSet: RuleSet;
+  resolverFactory: import('./ResolverFactory');
+  ruleSet: RuleSetCompiler.RuleSet;
   context: string;
-  fs: InputFileSystem;
+  fs: import('./util/fs').InputFileSystem;
+  _globalParserOptions: import('../declarations/WebpackOptions').ParserOptionsByModuleType;
+  _globalGeneratorOptions: import('../declarations/WebpackOptions').GeneratorOptionsByModuleType;
+  /** @type {Map<string, WeakMap<object, Parser>>} */
   parserCache: Map<string, WeakMap<object, Parser>>;
+  /** @type {Map<string, WeakMap<object, Generator>>} */
   generatorCache: Map<string, WeakMap<object, Generator>>;
+  /** @type {Set<Module>} */
+  _restoredUnsafeCacheEntries: Set<Module>;
+  _parseResourceWithoutFragment: import('./util/identifier').BindCacheResultFn<
+    import('./util/identifier').ParsedResourceWithoutFragment
+  >;
   cleanupForCache(): void;
+  /**
+   * @param {ModuleFactoryCreateDataContextInfo} contextInfo context info
+   * @param {string} context context
+   * @param {string} unresolvedResource unresolved resource
+   * @param {ResolverWithOptions} resolver resolver
+   * @param {ResolveContext} resolveContext resolver context
+   * @param {(err: null | Error, res?: string | false, req?: ResolveRequest) => void} callback callback
+   */
   resolveResource(
     contextInfo: ModuleFactoryCreateDataContextInfo,
     context: string,
@@ -75,34 +98,85 @@ declare class NormalModuleFactory extends ModuleFactory {
       req?: ResolveRequest,
     ) => void,
   ): void;
+  /**
+   * @param {Error} error error
+   * @param {ModuleFactoryCreateDataContextInfo} contextInfo context info
+   * @param {string} context context
+   * @param {string} unresolvedResource unresolved resource
+   * @param {ResolverWithOptions} resolver resolver
+   * @param {ResolveContext} resolveContext resolver context
+   * @param {Callback<string[]>} callback callback
+   * @private
+   */
+  private _resolveResourceErrorHints;
+  /**
+   * @param {ModuleFactoryCreateDataContextInfo} contextInfo context info
+   * @param {string} context context
+   * @param {LoaderItem[]} array array
+   * @param {ResolverWithOptions} resolver resolver
+   * @param {ResolveContext} resolveContext resolve context
+   * @param {Callback<LoaderItem[]>} callback callback
+   * @returns {void} result
+   */
   resolveRequestArray(
     contextInfo: ModuleFactoryCreateDataContextInfo,
     context: string,
     array: LoaderItem[],
     resolver: ResolverWithOptions,
     resolveContext: ResolveContext,
-    callback: CallbackNormalModuleFactory<LoaderItem[]>,
+    callback: Callback<LoaderItem[]>,
   ): void;
+  /**
+   * @param {string} type type
+   * @param {ParserOptions} parserOptions parser options
+   * @returns {Parser} parser
+   */
   getParser(type: string, parserOptions?: ParserOptions): Parser;
+  /**
+   * @param {string} type type
+   * @param {ParserOptions} parserOptions parser options
+   * @returns {Parser} parser
+   */
   createParser(type: string, parserOptions?: ParserOptions): Parser;
+  /**
+   * @param {string} type type of generator
+   * @param {GeneratorOptions} generatorOptions generator options
+   * @returns {Generator} generator
+   */
   getGenerator(type: string, generatorOptions?: GeneratorOptions): Generator;
+  /**
+   * @param {string} type type of generator
+   * @param {GeneratorOptions} generatorOptions generator options
+   * @returns {Generator} generator
+   */
   createGenerator(type: string, generatorOptions?: GeneratorOptions): Generator;
+  /**
+   * @param {Parameters<ResolverFactory["get"]>[0]} type type of resolver
+   * @param {Parameters<ResolverFactory["get"]>[1]=} resolveOptions options
+   * @returns {ReturnType<ResolverFactory["get"]>} the resolver
+   */
   getResolver(
-    type: string,
-    resolveOptions?: ResolveOptionsWithDependencyType,
-  ): ResolverWithOptions;
+    type: Parameters<ResolverFactory['get']>[0],
+    resolveOptions?: Parameters<ResolverFactory['get']>[1] | undefined,
+  ): ReturnType<ResolverFactory['get']>;
 }
-
 declare namespace NormalModuleFactory {
   export {
     ModuleOptions,
     RuleSetRule,
     Generator,
     ModuleFactoryCreateData,
+    ModuleFactoryCreateDataContextInfo,
     ModuleFactoryResult,
+    GeneratorOptions,
+    LoaderItem,
     NormalModuleCreateData,
+    ParserOptions,
     Parser,
     ResolverFactory,
+    ResolveContext,
+    ResolveRequest,
+    ResolverWithOptions,
     ModuleDependency,
     InputFileSystem,
     ModuleSettings,
@@ -111,65 +185,72 @@ declare namespace NormalModuleFactory {
     ResourceData,
     ResourceDataWithData,
     ParsedLoaderRequest,
+    Callback,
   };
 }
 import ModuleFactory = require('./ModuleFactory');
 import { AsyncSeriesBailHook } from 'tapable';
-type ResolveData = {
-  contextInfo: ModuleFactoryCreateData['contextInfo'];
-  resolveOptions: ModuleFactoryCreateData['resolveOptions'];
-  context: string;
-  request: string;
-  assertions: Record<string, any> | undefined;
-  dependencies: ModuleDependency[];
-  dependencyType: string;
-  createData: CreateData;
-  fileDependencies: LazySet<string>;
-  missingDependencies: LazySet<string>;
-  contextDependencies: LazySet<string>;
-  /**
-   * allow to use the unsafe cache
-   */
-  cacheable: boolean;
-};
 import Module = require('./Module');
 import { HookMap } from 'tapable';
-type ResourceDataWithData = ResourceData & {
-  data: Record<string, any>;
-};
-import NormalModule = require('./NormalModule');
-type ModuleSettings = Pick<
-  RuleSetRule,
-  'type' | 'sideEffects' | 'parser' | 'generator' | 'resolve' | 'layer'
->;
 import { SyncWaterfallHook } from 'tapable';
 import { SyncBailHook } from 'tapable';
-import { SyncHook } from 'tapable';
-import RuleSetCompiler from './rules/RuleSetCompiler';
-type Generator = import('./Generator');
-type Parser = import('./Parser');
-type InputFileSystem = import('./util/fs').InputFileSystem;
-type ResolverFactory = import('./ResolverFactory');
+import RuleSetCompiler = require('./rules/RuleSetCompiler');
 type ModuleOptions =
   import('../declarations/WebpackOptions').ModuleOptionsNormalized;
 type RuleSetRule = import('../declarations/WebpackOptions').RuleSetRule;
+type Generator = import('./Generator');
 type ModuleFactoryCreateData =
   import('./ModuleFactory').ModuleFactoryCreateData;
+type ModuleFactoryCreateDataContextInfo =
+  import('./ModuleFactory').ModuleFactoryCreateDataContextInfo;
 type ModuleFactoryResult = import('./ModuleFactory').ModuleFactoryResult;
+type GeneratorOptions = import('./NormalModule').GeneratorOptions;
+type LoaderItem = import('./NormalModule').LoaderItem;
 type NormalModuleCreateData = import('./NormalModule').NormalModuleCreateData;
+type ParserOptions = import('./NormalModule').ParserOptions;
+type Parser = import('./Parser');
+type ResolverFactory = import('./ResolverFactory');
+type ResolveContext = import('./ResolverFactory').ResolveContext;
+type ResolveRequest = import('./ResolverFactory').ResolveRequest;
+type ResolverWithOptions = import('./ResolverFactory').ResolverWithOptions;
 type ModuleDependency = import('./dependencies/ModuleDependency');
+type InputFileSystem = import('./util/fs').InputFileSystem;
+type ModuleSettings = Pick<
+  RuleSetRule,
+  'type' | 'sideEffects' | 'parser' | 'generator' | 'resolve' | 'layer'
+>;
 type CreateData = Partial<
   NormalModuleCreateData & {
     settings: ModuleSettings;
   }
 >;
+type ResolveData = {
+  contextInfo: ModuleFactoryCreateData['contextInfo'];
+  resolveOptions: ModuleFactoryCreateData['resolveOptions'];
+  context: string;
+  request: string;
+  assertions: Record<string, any> | undefined;
+  dependencies: ModuleDependency[];
+  dependencyType: string;
+  createData: CreateData;
+  fileDependencies: LazySet<string>;
+  missingDependencies: LazySet<string>;
+  contextDependencies: LazySet<string>;
+  /**
+   * allow to use the unsafe cache
+   */
+  cacheable: boolean;
+};
 type ResourceData = {
   resource: string;
-  path: string;
-  query: string;
-  fragment: string;
+  path?: string | undefined;
+  query?: string | undefined;
+  fragment?: string | undefined;
   context?: string | undefined;
 };
+type ResourceDataWithData = ResourceData & {
+  data: Record<string, any>;
+};
 type ParsedLoaderRequest = {
   /**
    * loader
@@ -180,4 +261,8 @@ type ParsedLoaderRequest = {
    */
   options: string | undefined;
 };
+type Callback<T> = (
+  err?: (Error | null) | undefined,
+  stats?: T | undefined,
+) => void;
 import LazySet = require('./util/LazySet');