wip

Author: szymonrybczak

apps/tester-app/index.js

@@ -69,12 +69,18 @@ ScriptManager.shared.hooks.beforeResolve.tapAsync(
 
 ScriptManager.shared.hooks.resolve.tapAsync(
   'test-during',
-  ({ scriptId, caller, error }, callback) => {
-    if (!error) {
-      console.log('During resolving:', scriptId, caller);
+  async ({ scriptId, caller, referenceUrl, resolvers, error }, callback) => {
+    console.log('Resolving:', scriptId, caller);
+    for (const [, , resolve] of resolvers) {
+      const resolvedLocator = await resolve(scriptId, caller, referenceUrl);
+      if (resolvedLocator) {
+        console.log('Resolved locator:', resolvedLocator);
+        callback({ result: resolvedLocator });
+        return;
+      }
     }
-    console.log('ScriptManager.shared.hooks.resolve', scriptId, caller, error);
-    callback();
+
+    callback(new Error('No locator found'));
   }
 );
 

packages/repack/src/modules/ScriptManager/ScriptManager.ts

@@ -55,6 +55,14 @@ export interface ResolverOptions {
   key?: string;
 }
 
+interface ResolveHookParams {
+  scriptId: string;
+  caller?: string;
+  referenceUrl?: string;
+  resolvers: Array<[string, string | number, ScriptLocatorResolver]>;
+  result?: ScriptLocator;
+}
+
 /**
  * A manager to ease resolution, downloading and executing additional code from:
  * - arbitrary JavaScript scripts
@@ -118,9 +126,7 @@ export class ScriptManager extends EventEmitter {
       scriptId: string;
       caller?: string;
     }>(['params']),
-    resolve: new AsyncSeriesHook<{ scriptId: string; caller?: string }, void>([
-      'params',
-    ]),
+    resolve: new AsyncSeriesWaterfallHook<ResolveHookParams>(['params']),
     afterResolve: new AsyncSeriesHook<
       { scriptId: string; caller?: string },
       void
@@ -328,28 +334,36 @@ export class ScriptManager extends EventEmitter {
       this.emit('resolving', { scriptId: finalScriptId, caller: finalCaller });
 
       // Check if there are any taps in the resolve hook
-      const _hasResolveHooks = this.hooks.resolve.taps.length > 0;
+      const hasResolveHooks = this.hooks.resolve.taps.length > 0;
 
       let locator: ScriptLocator | undefined;
 
-      // if (hasResolveHooks) {
-      await this.hooks.resolve.promise({
-        scriptId: finalScriptId,
-        caller: finalCaller,
-      });
+      // // if (hasResolveHooks) {
+      //   const { result } = await this.hooks.resolve.promise({
+      //     scriptId: finalScriptId,
+      //     caller: finalCaller,
+      //     referenceUrl,
+      //     resolvers: this.resolvers,
+      //   });
+
+      // //   if (result) {
+      //     locator = result;
+      //     console.log('Resolved locator1:', locator);
+      // //   }
       // } else {
       for (const [, , resolve] of this.resolvers) {
         const resolvedLocator = await resolve(
           finalScriptId,
           finalCaller,
           referenceUrl
         );
+
         if (resolvedLocator) {
           locator = resolvedLocator;
           break;
         }
-        // }
       }
+      // }
 
       if (!locator) {
         const error = new Error(

packages/repack/src/modules/ScriptManager/__tests__/ScriptManager.test.ts

@@ -3,6 +3,7 @@ import NativeScriptManager, {
 } from '../NativeScriptManager.js';
 import { Script } from '../Script.js';
 import { ScriptManager } from '../ScriptManager.js';
+import { getWebpackContext } from '../getWebpackContext.js';
 
 jest.mock('../NativeScriptManager.js', () => ({
   loadScript: jest.fn(),
@@ -1192,6 +1193,95 @@ describe('ScriptManagerAPI', () => {
         expect.any(Error)
       );
     });
+
+    it('should allow resolve hook to handle resolution with custom logic', async () => {
+      const hookOrder: string[] = [];
+      const customScriptId = 'custom-script';
+      const customCaller = 'custom-caller';
+      const customReferenceUrl = 'http://reference.url';
+
+      ScriptManager.shared.hooks.beforeResolve.tap(
+        'test-before',
+        ({ scriptId, caller }) => {
+          hookOrder.push('beforeResolve');
+          return { scriptId, caller };
+        }
+      );
+
+      ScriptManager.shared.hooks.resolve.tapAsync(
+        'test-resolve',
+        async (params, callback) => {
+          expect(params.scriptId).toBe(customScriptId);
+          expect(params.caller).toBe(customCaller);
+          expect(params.referenceUrl).toBe(customReferenceUrl);
+          expect(params.resolvers).toBeDefined();
+          expect(Array.isArray(params.resolvers)).toBe(true);
+
+          hookOrder.push('resolve');
+          for (const [, , resolve] of params.resolvers) {
+            try {
+              const resolvedLocator = await resolve(
+                params.scriptId,
+                params.caller,
+                params.referenceUrl
+              );
+
+              if (resolvedLocator) {
+                callback(null, {
+                  ...params,
+                  result: resolvedLocator,
+                });
+                return;
+              }
+            } catch (error) {
+              if (error instanceof Error) {
+                callback(error);
+              } else {
+                callback(new Error('Unknown error occurred'));
+              }
+              return;
+            }
+          }
+          callback(new Error('No locator found'));
+        }
+      );
+
+      ScriptManager.shared.hooks.afterResolve.tap(
+        'test-after',
+        ({ scriptId, caller }) => {
+          expect(scriptId).toBe(customScriptId);
+          expect(caller).toBe(customCaller);
+          hookOrder.push('afterResolve');
+        }
+      );
+
+      // Add a resolver that should be called by the hook
+      ScriptManager.shared.addResolver(async () => {
+        hookOrder.push('resolver');
+        return {
+          url: Script.getRemoteURL('http://domain.ext/script.js'),
+          cache: true,
+        };
+      });
+
+      const script = await ScriptManager.shared.resolveScript(
+        customScriptId,
+        customCaller,
+        getWebpackContext(),
+        customReferenceUrl
+      );
+      expect(script.locator.url).toBe(
+        'http://domain.ext/script.js.chunk.bundle'
+      );
+      expect(hookOrder).toEqual([
+        'beforeResolve',
+        'resolve',
+        'resolver',
+        'afterResolve',
+      ]);
+
+      ScriptManager.shared.removeAllResolvers();
+    });
   });
 
   describe('loading script hooks lifecycle', () => {