@embroider/core 3.4.9 → 3.4.10-unstable.14b84ff

package/src/module-resolver.d.ts

@@ -8,21 +8,22 @@ 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[];
 }
-interface EngineConfig {
+export interface EngineConfig {
     packageName: string;
     activeAddons: {
         name: string;
         root: string;
+        canResolveFromFile: string;
     }[];
     fastbootFiles: {
         [appName: string]: {
@@ -31,34 +32,42 @@ interface EngineConfig {
         };
     };
     root: string;
+    isLazy: boolean;
 }
-export interface ModuleRequest {
+export interface ModuleRequest<Res extends Resolution = Resolution> {
     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);
-    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): {
+    private beforeResolve;
+    resolve<ResolveResolution extends Resolution>(request: ModuleRequest<ResolveResolution>): Promise<ResolveResolution>;
+    nodeResolve(specifier: string, fromFile: string): Promise<{
         type: 'virtual';
         filename: string;
         content: string;
@@ -68,13 +77,18 @@ 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;
@@ -88,10 +102,12 @@ export declare class Resolver {
     owningEngine(pkg: Package): EngineConfig;
     private handleRewrittenPackages;
     private handleRenaming;
+    private handleVendor;
     private resolveWithinMovedPackage;
     private preHandleExternal;
+    private locateActiveAddon;
     private external;
-    fallbackResolve<R extends ModuleRequest>(request: R): R;
+    private fallbackResolve;
     private getEntryFromMergeMap;
     private withResolvableExtensions;
     private searchAppTree;
@@ -99,4 +115,3 @@ export declare class Resolver {
     reverseComponentLookup(filename: string): string | undefined;
     private tryReverseComponent;
 }
-export {};