Merge branch 'next' into refactor/catalog-edge-resolve

Author: elrrrrrrr

biome.json

@@ -18,6 +18,7 @@
       "!packages/utoo-web/src/webpackLoaders/loaders/**",
       "!packages/utoo-web/src/utoo/**",
       "crates/pack-core/js/**/*.ts",
+      "!crates/pack-core/js/src/umd/**",
       "!**/examples/multi-entries-heavy/*",
       "!**/packages/**/binding.*",
       "!next.js/**",

crates/pack-core/js/src/umd/base-externals-utils.ts

@@ -1,7 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 
-/// <reference path="./runtime-utils.ts" />
-
 /// A 'base' utilities to support runtime can have externals.
 /// Currently this is for node.js / edge runtime both.
 /// If a fn requires node.js specific behavior, it should be placed in `node-external-utils` instead.

crates/pack-core/js/src/umd/build-base.ts

@@ -58,10 +58,9 @@ const chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map();
      */
     loadChunkCached(
       sourceType: SourceType,
-      sourceData: SourceData,
       chunkUrl: ChunkUrl,
     ) {
-      return doLoadChunk(sourceType, sourceData, chunkUrl);
+      return doLoadChunk(sourceType, chunkUrl);
     },
   };
   function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {
@@ -94,7 +93,6 @@ const chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map();
    */
   function doLoadChunk(
     sourceType: SourceType,
-    _sourceData: SourceData,
     chunkUrl: ChunkUrl,
   ) {
     const resolver = getOrCreateResolver(chunkUrl);

crates/pack-core/js/src/umd/runtime-backend-dom.ts

@@ -37,7 +37,6 @@ let BACKEND: RuntimeBackend;
      */
     loadChunkCached(
       _sourceType: SourceType,
-      _sourceData: SourceData,
       _chunkUrl: ChunkUrl,
     ) {
       return Promise.resolve();

crates/pack-core/js/src/umd/runtime-backend-node.ts

@@ -9,7 +9,8 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 
 /// <reference path="./globals.d.ts" />
-/// <reference path="./runtime-utils.ts" />
+/// <reference path="../../../../../next.js/turbopack/crates/turbopack-ecmascript-runtime/js/src/shared/runtime/runtime-utils.ts" />
+
 
 // Used in WebWorkers to tell the runtime about the chunk base path
 declare var TURBOPACK_WORKER_LOCATION: string;
@@ -40,47 +41,30 @@ type RuntimeParams = {
   runtimeModuleIds: ModuleId[];
 };
 
+type ChunkRegistrationChunk =
+  | ChunkPath
+  | { getAttribute: (name: string) => string | null }
+  | undefined;
+
 type ChunkRegistration = [
-  chunkPath: ChunkScript,
-  chunkModules: CompressedModuleFactories,
-  params: RuntimeParams | undefined,
+  chunkPath: ChunkRegistrationChunk,
+  ...([RuntimeParams] | CompressedModuleFactories),
 ];
 
 type ChunkList = {
-  script: ChunkListScript;
+  script: ChunkRegistrationChunk;
   chunks: ChunkData[];
   source: "entry" | "dynamic";
 };
 
-enum SourceType {
-  /**
-   * The module was instantiated because it was included in an evaluated chunk's
-   * runtime.
-   * SourceData is a ChunkPath.
-   */
-  Runtime = 0,
-  /**
-   * The module was instantiated because a parent module imported it.
-   * SourceData is a ModuleId.
-   */
-  Parent = 1,
-  /**
-   * The module was instantiated because it was included in a chunk's hot module
-   * update.
-   * SourceData is an array of ModuleIds or undefined.
-   */
-  Update = 2,
-}
-
-type SourceData = ChunkPath | ModuleId | ModuleId[] | undefined;
+// SourceType and SourceData are provided by shared/runtime/runtime-utils.ts
 interface RuntimeBackend {
-  registerChunk: (chunkPath: ChunkPath, params?: RuntimeParams) => void;
+  registerChunk: (chunkPath: ChunkPath | ChunkScript, params?: RuntimeParams) => void;
   /**
    * Returns the same Promise for the same chunk URL.
    */
   loadChunkCached: (
     sourceType: SourceType,
-    sourceData: SourceData,
     chunkUrl: ChunkUrl,
   ) => Promise<void>;
 }
@@ -92,33 +76,6 @@ const availableModules: Map<ModuleId, Promise<any> | true> = new Map();
 
 const availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map();
 
-function factoryNotAvailable(
-  moduleId: ModuleId,
-  sourceType: SourceType,
-  sourceData: SourceData,
-) {
-  let instantiationReason;
-  switch (sourceType) {
-    case SourceType.Runtime:
-      instantiationReason = `as a runtime entry of chunk ${sourceData}`;
-      break;
-    case SourceType.Parent:
-      instantiationReason = `because it was required from module ${sourceData}`;
-      break;
-    case SourceType.Update:
-      instantiationReason = "because of an HMR update";
-      break;
-    default:
-      invariant(
-        sourceType,
-        (sourceType) => `Unknown source type: ${sourceType}`,
-      );
-  }
-  throw new Error(
-    `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available. It might have been deleted in an HMR update.`,
-  );
-}
-
 const loadedChunk = Promise.resolve(undefined);
 const instrumentedBackendLoadChunks = new WeakMap<
   Promise<any>,
@@ -169,7 +126,7 @@ function loadChunkByUrlInternal(
   sourceData: SourceData,
   chunkUrl: ChunkUrl,
 ): Promise<any> {
-  const thenable = BACKEND.loadChunkCached(sourceType, sourceData, chunkUrl);
+  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl);
   let entry = instrumentedBackendLoadChunks.get(thenable);
   if (entry === undefined) {
     const resolve = instrumentedBackendLoadChunks.set.bind(
@@ -278,7 +235,7 @@ function getPathFromScript(
   const chunkUrl =
     typeof TURBOPACK_NEXT_CHUNK_URLS !== "undefined"
       ? TURBOPACK_NEXT_CHUNK_URLS.pop()!
-      : chunkScript.getAttribute("src")!;
+      : chunkScript.src!;
   const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ""));
   let path = src.startsWith(CHUNK_BASE_PATH)
     ? src.slice(CHUNK_BASE_PATH.length)
@@ -289,22 +246,6 @@ function getPathFromScript(
   return path as ChunkPath | ChunkListPath;
 }
 
-function registerCompressedModuleFactory(
-  moduleId: ModuleId,
-  moduleFactory: Function | [Function, ModuleId[]],
-) {
-  if (!moduleFactories.has(moduleId)) {
-    if (Array.isArray(moduleFactory)) {
-      let [moduleFactoryFn, otherIds] = moduleFactory;
-      moduleFactories.set(moduleId, moduleFactoryFn);
-      for (const otherModuleId of otherIds) {
-        moduleFactories.set(otherModuleId, moduleFactoryFn);
-      }
-    } else {
-      moduleFactories.set(moduleId, moduleFactory);
-    }
-  }
-}
 
 const regexJsUrl = /\.js(?:\?[^#]*)?(?:#.*)?$/;
 /**
@@ -313,3 +254,22 @@ const regexJsUrl = /\.js(?:\?[^#]*)?(?:#.*)?$/;
 function isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {
   return regexJsUrl.test(chunkUrlOrPath);
 }
+
+/**
+ * Determine the chunk to register. Note that this function has side-effects!
+ */
+function getChunkFromRegistration(
+  chunk: ChunkRegistrationChunk,
+): ChunkPath | CurrentScript {
+  if (typeof chunk === "string") {
+    return chunk;
+  } else if (!chunk) {
+    if (typeof TURBOPACK_NEXT_CHUNK_URLS !== "undefined") {
+      return { src: TURBOPACK_NEXT_CHUNK_URLS.pop()! } as CurrentScript;
+    } else {
+      throw new Error("chunk path empty but not in a worker");
+    }
+  } else {
+    return { src: chunk.getAttribute("src")! } as CurrentScript;
+  }
+}