@kiwa-test/nextjs 1.2.0 → 1.3.0

package/dist/index.cjs

@@ -28,18 +28,25 @@ __export(index_exports, {
   REDIRECT_SYMBOL: () => REDIRECT_SYMBOL,
   RSC_ERROR_BOUNDARY_SYMBOL: () => RSC_ERROR_BOUNDARY_SYMBOL,
   RSC_REDIRECT_SYMBOL: () => RSC_REDIRECT_SYMBOL,
+  applyHmrPatch: () => applyHmrPatch,
   assertMode: () => assertMode,
   captureParallelError: () => captureParallelError,
   collectFidelityCoverage: () => collectFidelityCoverage,
+  commitTransition: () => commitTransition,
+  completeFastRefresh: () => completeFastRefresh,
   completePartialPrerendering: () => completePartialPrerendering,
   findAll: () => findAll,
+  findHmrBoundary: () => findHmrBoundary,
   flushStreamingBoundary: () => flushStreamingBoundary,
   interceptCurrentSegment: () => interceptCurrentSegment,
   interceptParentSegment: () => interceptParentSegment,
   interceptRootCatchall: () => interceptRootCatchall,
+  interruptTransition: () => interruptTransition,
   invokeMiddleware: () => invokeMiddleware,
   invokeParallelRoutes: () => invokeParallelRoutes,
   invokeServerAction: () => invokeServerAction,
+  markModuleUpdated: () => markModuleUpdated,
+  markTransitionPending: () => markTransitionPending,
   middlewareActions: () => middlewareActions,
   navigateSlot: () => navigateSlot,
   openDynamicHole: () => openDynamicHole,
@@ -55,10 +62,12 @@ __export(index_exports, {
   revalidateActionPath: () => revalidateActionPath,
   revalidateActionTag: () => revalidateActionTag,
   setupNextRscEnv: () => setupNextRscEnv,
+  startConcurrentTransition: () => startConcurrentTransition,
   startInterceptionRoutes: () => startInterceptionRoutes,
   startParallelRoutesAdvanced: () => startParallelRoutesAdvanced,
   startPartialPrerendering: () => startPartialPrerendering,
   startServerActionAdvanced: () => startServerActionAdvanced,
+  startTurbopackHmr: () => startTurbopackHmr,
   submitFormAction: () => submitFormAction,
   textContent: () => textContent
 });
@@ -427,7 +436,15 @@ var dialect = {
     "parallel.default_rendered": "app.parallel.default",
     "parallel.loading_rendered": "app.parallel.loading",
     "parallel.error_boundary_captured": "app.parallel.error",
-    "parallel.slot_navigated": "app.parallel.navigate"
+    "parallel.slot_navigated": "app.parallel.navigate",
+    "turbopack.module_updated": "app.turbopack.module.update",
+    "turbopack.hmr_boundary_found": "app.turbopack.hmr.boundary",
+    "turbopack.hmr_applied": "app.turbopack.hmr.apply",
+    "turbopack.fast_refresh_completed": "app.turbopack.fast-refresh",
+    "transition.started": "app.transition.start",
+    "transition.pending": "app.transition.pending",
+    "transition.interrupted": "app.transition.interrupt",
+    "transition.committed": "app.transition.commit"
   },
   "pages-router": {
     "action.form_submitted": "pages.api.form.submit",
@@ -445,7 +462,15 @@ var dialect = {
     "parallel.default_rendered": "pages.slot.default",
     "parallel.loading_rendered": "pages.slot.loading",
     "parallel.error_boundary_captured": "pages.slot.error",
-    "parallel.slot_navigated": "pages.slot.navigate"
+    "parallel.slot_navigated": "pages.slot.navigate",
+    "turbopack.module_updated": "pages.webpack.module.update",
+    "turbopack.hmr_boundary_found": "pages.webpack.hmr.boundary",
+    "turbopack.hmr_applied": "pages.webpack.hmr.apply",
+    "turbopack.fast_refresh_completed": "pages.webpack.fast-refresh",
+    "transition.started": "pages.transition.start",
+    "transition.pending": "pages.transition.pending",
+    "transition.interrupted": "pages.transition.interrupt",
+    "transition.committed": "pages.transition.commit"
   },
   "edge-runtime": {
     "action.form_submitted": "edge.action.form.submit",
@@ -463,7 +488,15 @@ var dialect = {
     "parallel.default_rendered": "edge.parallel.default",
     "parallel.loading_rendered": "edge.parallel.loading",
     "parallel.error_boundary_captured": "edge.parallel.error",
-    "parallel.slot_navigated": "edge.parallel.navigate"
+    "parallel.slot_navigated": "edge.parallel.navigate",
+    "turbopack.module_updated": "edge.esbuild.module.update",
+    "turbopack.hmr_boundary_found": "edge.esbuild.hmr.boundary",
+    "turbopack.hmr_applied": "edge.esbuild.hmr.apply",
+    "turbopack.fast_refresh_completed": "edge.esbuild.fast-refresh",
+    "transition.started": "edge.transition.start",
+    "transition.pending": "edge.transition.pending",
+    "transition.interrupted": "edge.transition.interrupt",
+    "transition.committed": "edge.transition.commit"
   }
 };
 function providerEventName(target, neutral) {
@@ -769,6 +802,19 @@ var NEXT_AXIS_TO_EVENTS = {
     "parallel.loading_rendered",
     "parallel.error_boundary_captured",
     "parallel.slot_navigated"
+  ],
+  // v1.49 advanced III
+  "turbopack-hmr": [
+    "turbopack.module_updated",
+    "turbopack.hmr_boundary_found",
+    "turbopack.hmr_applied",
+    "turbopack.fast_refresh_completed"
+  ],
+  "concurrent-transitions": [
+    "transition.started",
+    "transition.pending",
+    "transition.interrupted",
+    "transition.committed"
   ]
 };
 function collectFidelityCoverage(providers = ["app-router", "pages-router", "edge-runtime"]) {
@@ -788,6 +834,127 @@ function collectFidelityCoverage(providers = ["app-router", "pages-router", "edg
   return { providers, axes, rows };
 }
 
+// src/semantics/turbopack-hmr.ts
+function emit5(session, neutralEvent, metadata) {
+  const step = {
+    neutralEvent,
+    providerEvent: providerEventName(session.target, neutralEvent),
+    state: session.state,
+    amountCents: 0,
+    metadata: { sessionId: session.sessionId, ...metadata }
+  };
+  session.history.push(step);
+  return step;
+}
+function startTurbopackHmr(input) {
+  if (input.sessionId.length === 0) {
+    throw new Error("startTurbopackHmr: sessionId must not be empty");
+  }
+  return {
+    target: input.target,
+    sessionId: input.sessionId,
+    updatedModuleIds: [],
+    boundaryModuleId: null,
+    state: "idle",
+    history: []
+  };
+}
+function markModuleUpdated(session, moduleId) {
+  session.updatedModuleIds.push(moduleId);
+  session.state = "updating";
+  return emit5(session, "turbopack.module_updated", {
+    moduleId,
+    updateCount: session.updatedModuleIds.length
+  });
+}
+function findHmrBoundary(session, boundaryModuleId) {
+  if (session.state !== "updating") {
+    throw new Error(`findHmrBoundary: session is ${session.state}`);
+  }
+  session.boundaryModuleId = boundaryModuleId;
+  session.state = "boundary-found";
+  return emit5(session, "turbopack.hmr_boundary_found", { boundaryModuleId });
+}
+function applyHmrPatch(session) {
+  if (session.state !== "boundary-found") {
+    throw new Error(`applyHmrPatch: session is ${session.state}`);
+  }
+  session.state = "applied";
+  return emit5(session, "turbopack.hmr_applied", {
+    updatedModuleCount: session.updatedModuleIds.length
+  });
+}
+function completeFastRefresh(session) {
+  if (session.state !== "applied") {
+    throw new Error(`completeFastRefresh: session is ${session.state}`);
+  }
+  session.state = "refresh-completed";
+  return emit5(session, "turbopack.fast_refresh_completed", {
+    updatedModuleCount: session.updatedModuleIds.length
+  });
+}
+
+// src/semantics/concurrent-transitions.ts
+function emit6(session, neutralEvent, metadata) {
+  const step = {
+    neutralEvent,
+    providerEvent: providerEventName(session.target, neutralEvent),
+    state: session.state,
+    amountCents: 0,
+    metadata: { transitionId: session.transitionId, ...metadata }
+  };
+  session.history.push(step);
+  return step;
+}
+function startConcurrentTransition(input) {
+  if (input.transitionId.length === 0) {
+    throw new Error("startConcurrentTransition: transitionId must not be empty");
+  }
+  const session = {
+    target: input.target,
+    transitionId: input.transitionId,
+    interruptions: 0,
+    pendingCount: 0,
+    state: "started",
+    committedValue: null,
+    history: []
+  };
+  emit6(session, "transition.started", { interruptions: 0 });
+  return session;
+}
+function markTransitionPending(session) {
+  if (session.state !== "started" && session.state !== "interrupted") {
+    throw new Error(`markTransitionPending: session is ${session.state}`);
+  }
+  session.state = "pending";
+  session.pendingCount += 1;
+  return emit6(session, "transition.pending", {
+    pendingCount: session.pendingCount
+  });
+}
+function interruptTransition(session) {
+  if (session.state !== "pending") {
+    throw new Error(`interruptTransition: session is ${session.state}`);
+  }
+  session.state = "interrupted";
+  session.interruptions += 1;
+  return emit6(session, "transition.interrupted", {
+    interruptions: session.interruptions
+  });
+}
+function commitTransition(session, committedValue) {
+  if (session.state !== "pending" && session.state !== "started") {
+    throw new Error(`commitTransition: session is ${session.state}`);
+  }
+  session.state = "committed";
+  session.committedValue = committedValue;
+  return emit6(session, "transition.committed", {
+    committedValue,
+    totalInterruptions: session.interruptions,
+    totalPending: session.pendingCount
+  });
+}
+
 // src/real-driver.ts
 var TARGET_KEY_ENV = {
   "app-router": "NEXT_APP_URL",
@@ -830,18 +997,25 @@ function assertMode(provider, expected, env = process.env) {
   REDIRECT_SYMBOL,
   RSC_ERROR_BOUNDARY_SYMBOL,
   RSC_REDIRECT_SYMBOL,
+  applyHmrPatch,
   assertMode,
   captureParallelError,
   collectFidelityCoverage,
+  commitTransition,
+  completeFastRefresh,
   completePartialPrerendering,
   findAll,
+  findHmrBoundary,
   flushStreamingBoundary,
   interceptCurrentSegment,
   interceptParentSegment,
   interceptRootCatchall,
+  interruptTransition,
   invokeMiddleware,
   invokeParallelRoutes,
   invokeServerAction,
+  markModuleUpdated,
+  markTransitionPending,
   middlewareActions,
   navigateSlot,
   openDynamicHole,
@@ -857,10 +1031,12 @@ function assertMode(provider, expected, env = process.env) {
   revalidateActionPath,
   revalidateActionTag,
   setupNextRscEnv,
+  startConcurrentTransition,
   startInterceptionRoutes,
   startParallelRoutesAdvanced,
   startPartialPrerendering,
   startServerActionAdvanced,
+  startTurbopackHmr,
   submitFormAction,
   textContent
 });