@embroider/core 3.5.1-unstable.fc482ba → 3.5.1

package/src/module-resolver.d.ts

@@ -1,14 +1,64 @@
 import type { Package } from '@embroider/shared-internals';
 import { RewrittenPackageCache } from '@embroider/shared-internals';
-import { type NodeResolveOpts } from './node-resolve';
-import type { Options, EngineConfig } from './module-resolver-options';
-import { type ModuleRequest, type Resolution } from './module-request';
+import type UserOptions from './options';
+export interface Options {
+    renamePackages: {
+        [fromName: string]: string;
+    };
+    renameModules: {
+        [fromName: string]: string;
+    };
+    activeAddons: {
+        [packageName: string]: string;
+    };
+    resolvableExtensions: string[];
+    appRoot: string;
+    engines: EngineConfig[];
+    modulePrefix: string;
+    podModulePrefix?: string;
+    amdCompatibility: Required<UserOptions['amdCompatibility']>;
+}
+interface EngineConfig {
+    packageName: string;
+    activeAddons: {
+        name: string;
+        root: string;
+    }[];
+    fastbootFiles: {
+        [appName: string]: {
+            localFilename: string;
+            shadowedFilename: string | undefined;
+        };
+    };
+    root: string;
+}
+export interface ModuleRequest {
+    readonly specifier: string;
+    readonly fromFile: string;
+    readonly isVirtual: boolean;
+    readonly meta: Record<string, unknown> | undefined;
+    alias(newSpecifier: string): this;
+    rehome(newFromFile: string): this;
+    virtualize(virtualFilename: string): this;
+    withMeta(meta: Record<string, any> | undefined): this;
+}
+export type Resolution<T = unknown, E = unknown> = {
+    type: 'found';
+    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, opts?: NodeResolveOpts): 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;
@@ -18,20 +68,13 @@ export declare class Resolver {
     } | {
         type: 'not_found';
         err: Error;
-    }>;
+    };
     get packageCache(): RewrittenPackageCache;
-    private afterResolve;
-    private handleSyntheticComponents;
     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;
@@ -47,21 +90,15 @@ export declare class Resolver {
     get emberVersionSupportsSeparateTemplates(): boolean;
     private handleRewrittenPackages;
     private handleRenaming;
-    private handleVendor;
     private resolveWithinMovedPackage;
     private preHandleExternal;
-    private locateActiveAddon;
-    private fallbackResolve;
-    private restoreRehomedRequest;
-    private relativeFallbackResolve;
-    private maybeFallbackToActiveAddon;
+    private external;
+    fallbackResolve<R extends ModuleRequest>(request: R): R;
     private getEntryFromMergeMap;
     private withResolvableExtensions;
     private searchAppTree;
-    reverseSearchAppTree(owningPackage: Package, fromFile: string): {
-        owningEngine: EngineConfig;
-        inAppName: string;
-    } | undefined;
+    private reverseSearchAppTree;
     reverseComponentLookup(filename: string): string | undefined;
     private tryReverseComponent;
 }
+export {};