@embroider/core 3.4.10-unstable.f469b9f → 3.4.10

package/src/module-resolver.d.ts

@@ -8,22 +8,21 @@ export interface Options {
     renameModules: {
         [fromName: string]: string;
     };
+    activeAddons: {
+        [packageName: string]: string;
+    };
     resolvableExtensions: string[];
     appRoot: string;
     engines: EngineConfig[];
     modulePrefix: string;
-    splitAtRoutes?: (RegExp | string)[];
     podModulePrefix?: string;
     amdCompatibility: Required<UserOptions['amdCompatibility']>;
-    autoRun: boolean;
-    staticAppPaths: string[];
 }
-export interface EngineConfig {
+interface EngineConfig {
     packageName: string;
     activeAddons: {
         name: string;
         root: string;
-        canResolveFromFile: string;
     }[];
     fastbootFiles: {
         [appName: string]: {
@@ -32,42 +31,34 @@ export interface EngineConfig {
         };
     };
     root: string;
-    isLazy: boolean;
 }
-export interface ModuleRequest<Res extends Resolution = Resolution> {
+export interface ModuleRequest {
     readonly specifier: string;
     readonly fromFile: string;
     readonly isVirtual: boolean;
     readonly meta: Record<string, unknown> | undefined;
-    readonly debugType: string;
-    readonly isNotFound: boolean;
-    readonly resolvedTo: Res | undefined;
     alias(newSpecifier: string): this;
     rehome(newFromFile: string): this;
     virtualize(virtualFilename: string): this;
     withMeta(meta: Record<string, any> | undefined): this;
-    notFound(): this;
-    defaultResolve(): Promise<Res>;
-    resolveTo(resolution: Res): this;
 }
 export type Resolution<T = unknown, E = unknown> = {
     type: 'found';
-    filename: string;
-    isVirtual: boolean;
-    result: T;
-} | {
-    type: 'ignored';
     result: T;
 } | {
     type: 'not_found';
     err: E;
 };
+export type ResolverFunction<R extends ModuleRequest = ModuleRequest, Res extends Resolution = Resolution> = (request: R) => Promise<Res>;
+export type SyncResolverFunction<R extends ModuleRequest = ModuleRequest, Res extends Resolution = Resolution> = (request: R) => Res;
 export declare class Resolver {
     readonly options: Options;
     constructor(options: Options);
-    private beforeResolve;
-    resolve<ResolveResolution extends Resolution>(request: ModuleRequest<ResolveResolution>): Promise<ResolveResolution>;
-    nodeResolve(specifier: string, fromFile: string): Promise<{
+    beforeResolve<R extends ModuleRequest>(request: R): R;
+    resolve<Req extends ModuleRequest, Res extends Resolution>(request: Req, defaultResolve: ResolverFunction<Req, Res>): Promise<Res>;
+    resolveSync<Req extends ModuleRequest, Res extends Resolution>(request: Req, defaultResolve: SyncResolverFunction<Req, Res>): Res;
+    private internalResolve;
+    nodeResolve(specifier: string, fromFile: string): {
         type: 'virtual';
         filename: string;
         content: string;
@@ -77,18 +68,13 @@ export declare class Resolver {
     } | {
         type: 'not_found';
         err: Error;
-    }>;
+    };
     get packageCache(): RewrittenPackageCache;
     private logicalPackage;
     private generateFastbootSwitch;
     private handleFastbootSwitch;
     private handleImplicitModules;
-    private handleEntrypoint;
-    private handleRouteEntrypoint;
-    private handleImplicitTestScripts;
-    private handleTestSupportStyles;
     private handleGlobalsCompat;
-    private handleVendorStyles;
     private resolveHelper;
     private resolveComponent;
     private resolveHelperOrComponent;
@@ -102,12 +88,10 @@ export declare class Resolver {
     owningEngine(pkg: Package): EngineConfig;
     private handleRewrittenPackages;
     private handleRenaming;
-    private handleVendor;
     private resolveWithinMovedPackage;
     private preHandleExternal;
-    private locateActiveAddon;
     private external;
-    private fallbackResolve;
+    fallbackResolve<R extends ModuleRequest>(request: R): R;
     private getEntryFromMergeMap;
     private withResolvableExtensions;
     private searchAppTree;
@@ -115,3 +99,4 @@ export declare class Resolver {
     reverseComponentLookup(filename: string): string | undefined;
     private tryReverseComponent;
 }
+export {};