Resolver Factory

/**
 * Creates a custom async resolver with specified options
 * @param options - Configuration options for the resolver
 * @returns Custom async resolver function
 */
function create(options: ResolveOptionsOptionalFS): ResolveFunctionAsync;

const resolve = require("enhanced-resolve");

// Create resolver with custom extensions and aliases
const customResolve = resolve.create({
  extensions: [".js", ".json", ".ts", ".tsx"],
  alias: {
    "@": "/src",
    "components": "/src/components",
    "utils": "/src/utils"
  },
  modules: ["node_modules", "custom_modules"],
  mainFields: ["browser", "module", "main"]
});

// Use the custom resolver
customResolve(__dirname, "@/components/Button", (err, result) => {
  console.log(result); // "/src/components/Button.tsx"
});

// Resolver with modern package.json features
const modernResolve = resolve.create({
  extensions: [".js", ".mjs", ".json"],
  conditionNames: ["import", "require", "node", "default"],
  exportsFields: ["exports"],
  importsFields: ["imports"],
  mainFields: ["module", "main"]
});

modernResolve(__dirname, "modern-package", (err, result) => {
  if (result) console.log("Resolved with exports field:", result);
});

/**
 * Creates a custom sync resolver with specified options
 * @param options - Configuration options for the resolver
 * @returns Custom sync resolver function
 */
create.sync(options: ResolveOptionsOptionalFS): ResolveFunction;

const resolve = require("enhanced-resolve");

// Create sync resolver with TypeScript support
const typeScriptResolve = resolve.create.sync({
  extensions: [".ts", ".tsx", ".js", ".jsx"],
  alias: {
    "@": "/src",
    "~": "/src/components"
  },
  modules: ["node_modules", "@types"]
});

// Use the custom sync resolver
const component = typeScriptResolve(__dirname, "~/Button");
if (component) {
  console.log("Found component:", component);
}

// Resolver with custom file system (for testing)
const testResolve = resolve.create.sync({
  extensions: [".js", ".json"],
  fileSystem: customFileSystem, // Mock or memory filesystem
  modules: ["src", "test"]
});

/**
 * ResolverFactory provides the core factory functionality
 */
class ResolverFactory {
  /**
   * Creates a resolver instance with full configuration options
   * @param options - Complete resolver configuration
   * @returns Configured Resolver instance
   */
  static createResolver(options: ResolveOptions): Resolver;
}

const { ResolverFactory } = require("enhanced-resolve");

// Create resolver with complete options
const resolver = ResolverFactory.createResolver({
  fileSystem: require("fs"),
  extensions: [".js", ".json"],
  modules: ["node_modules"],
  mainFields: ["main"],
  plugins: [
    // Custom plugins can be added here
  ]
});

// Use the resolver directly
resolver.resolve({}, __dirname, "./module", {}, (err, result) => {
  console.log(result);
});

interface ResolveOptions {
  /** List of file extensions to try */
  extensions?: string[];
  
  /** Directories to search for modules */
  modules?: string | string[];
  
  /** Main fields to check in package.json */
  mainFields?: (string | string[] | MainFieldConfig)[];
  
  /** Main files to try in directories */
  mainFiles?: string[];
  
  /** File system implementation to use */
  fileSystem: FileSystem;
}

interface MainFieldConfig {
  name: string | string[];
  forceRelative: boolean;
}

interface ResolveOptions {
  /** Module aliases mapping */
  alias?: AliasOptions | AliasOption[];
  
  /** Fallback aliases applied after modules */
  fallback?: AliasOptions | AliasOption[];
  
  /** Extension aliases mapping */
  extensionAlias?: ExtensionAliasOptions;
  
  /** Alias fields to check in package.json */
  aliasFields?: (string | string[])[];
}

interface AliasOptions {
  [key: string]: string | false | string[];
}

interface AliasOption {
  name: string;
  alias: string | false | string[];
  onlyModule?: boolean;
}

interface ResolveOptions {
  /** Package.json exports fields to process */
  exportsFields?: (string | string[])[];
  
  /** Package.json imports fields to process */
  importsFields?: (string | string[])[];
  
  /** Condition names for conditional exports */
  conditionNames?: string[];
  
  /** Description files to read (usually package.json) */
  descriptionFiles?: string[];
}

interface ResolveOptions {
  /** Custom plugins to add to resolver */
  plugins?: Plugin[];
  
  /** Whether to follow symlinks */
  symlinks?: boolean;
  
  /** Caching configuration */
  unsafeCache?: boolean | Cache;
  
  /** Whether to cache with context */
  cacheWithContext?: boolean;
  
  /** Path restrictions */
  restrictions?: (string | RegExp)[];
  
  /** Root paths for resolution */
  roots?: string[];
  
  /** Require fully specified imports */
  fullySpecified?: boolean;
  
  /** Resolve to context instead of file */
  resolveToContext?: boolean;
  
  /** Prefer relative resolution */
  preferRelative?: boolean;
  
  /** Prefer absolute resolution */
  preferAbsolute?: boolean;
  
  /** Use sync filesystem calls */
  useSyncFileSystemCalls?: boolean;
}

type ResolveFunctionAsync = (
  context: object,
  path: string,
  request: string,
  resolveContext: ResolveContext,
  callback: ResolveCallback
) => void;

type ResolveFunction = (
  context: object,
  path: string,
  request: string
) => string | false;

type ResolveOptionsOptionalFS = Omit<ResolveOptions, "fileSystem"> & 
  Partial<Pick<ResolveOptions, "fileSystem">>;

type Plugin = 
  | undefined
  | null
  | false
  | ""
  | 0
  | { apply: (resolver: Resolver) => void }
  | ((resolver: Resolver) => void);