@vercel/next 4.1.3 → 4.1.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/dist/index.js +159 -79
  2. package/package.json +2 -2
package/dist/index.js CHANGED
@@ -9677,7 +9677,19 @@ async function getRoutesManifest(entryPath, outputDirectory, nextVersion) {
9677
9677
  }
9678
9678
  return routesManifest;
9679
9679
  }
9680
- async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev, routesManifest, omittedRoutes, canUsePreviewMode, bypassToken, isServerMode, dynamicMiddlewareRouteMap, experimentalPPR) {
9680
+ async function getDynamicRoutes({
9681
+ entryPath,
9682
+ entryDirectory,
9683
+ dynamicPages,
9684
+ isDev,
9685
+ routesManifest,
9686
+ omittedRoutes,
9687
+ canUsePreviewMode,
9688
+ bypassToken,
9689
+ isServerMode,
9690
+ dynamicMiddlewareRouteMap,
9691
+ experimentalPPRRoutes
9692
+ }) {
9681
9693
  if (routesManifest) {
9682
9694
  switch (routesManifest.version) {
9683
9695
  case 1:
@@ -9730,7 +9742,7 @@ async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev,
9730
9742
  }
9731
9743
  ];
9732
9744
  }
9733
- if (experimentalPPR) {
9745
+ if (experimentalPPRRoutes.has(page)) {
9734
9746
  let dest = route.dest?.replace(/($|\?)/, ".prefetch.rsc$1");
9735
9747
  if (page === "/" || page === "/index") {
9736
9748
  dest = dest?.replace(/([^/]+\.prefetch\.rsc(\?.*|$))/, "__$1");
@@ -10628,7 +10640,8 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
10628
10640
  pageLambdaMap,
10629
10641
  routesManifest,
10630
10642
  isCorrectNotFoundRoutes,
10631
- isEmptyAllowQueryForPrendered
10643
+ isEmptyAllowQueryForPrendered,
10644
+ omittedPrerenderRoutes
10632
10645
  } = prerenderRouteArgs;
10633
10646
  if (isBlocking && isFallback) {
10634
10647
  throw new import_build_utils.NowBuildError({
@@ -10910,17 +10923,23 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
10910
10923
  if (`/${outputPathPage}` !== srcRoute && srcRoute) {
10911
10924
  sourcePath = srcRoute;
10912
10925
  }
10913
- let key = srcRoute || routeKey;
10914
- if (key === "/") {
10915
- key = "index";
10916
- } else {
10917
- if (!key.startsWith("/")) {
10918
- throw new Error("Invariant: key doesn't start with /");
10926
+ let experimentalStreamingLambdaPath;
10927
+ if (experimentalPPR) {
10928
+ if (!experimentalStreamingLambdaPaths) {
10929
+ throw new Error(
10930
+ "Invariant: experimentalStreamingLambdaPaths doesn't exist"
10931
+ );
10932
+ }
10933
+ if (srcRoute && !omittedPrerenderRoutes.has(srcRoute)) {
10934
+ experimentalStreamingLambdaPath = experimentalStreamingLambdaPaths.get(
10935
+ pathnameToOutputName(entryDirectory, srcRoute)
10936
+ );
10937
+ } else {
10938
+ experimentalStreamingLambdaPath = experimentalStreamingLambdaPaths.get(
10939
+ pathnameToOutputName(entryDirectory, routeKey)
10940
+ );
10919
10941
  }
10920
- key = key.substring(1);
10921
10942
  }
10922
- key = import_path2.default.posix.join(entryDirectory, key);
10923
- const experimentalStreamingLambdaPath = experimentalStreamingLambdaPaths?.get(key);
10924
10943
  prerenders[outputPathPage] = new import_build_utils.Prerender({
10925
10944
  expiration: initialRevalidate,
10926
10945
  lambda,
@@ -11076,6 +11095,16 @@ function normalizeIndexOutput(outputName, isServerMode) {
11076
11095
  function getNextServerPath(nextVersion) {
11077
11096
  return import_semver.default.gte(nextVersion, "v11.0.2-canary.4") ? "next/dist/server" : "next/dist/next-server/server";
11078
11097
  }
11098
+ function pathnameToOutputName(entryDirectory, pathname) {
11099
+ if (pathname === "/")
11100
+ pathname = "/index";
11101
+ return import_path2.default.posix.join(entryDirectory, pathname);
11102
+ }
11103
+ function getPostponeResumePathname(entryDirectory, pathname) {
11104
+ if (pathname === "/")
11105
+ pathname = "/index";
11106
+ return import_path2.default.posix.join(entryDirectory, "_next/postponed/resume", pathname);
11107
+ }
11079
11108
  function updateRouteSrc(route, index, manifestItems) {
11080
11109
  if (route.src) {
11081
11110
  route.src = manifestItems[index].regex;
@@ -12017,7 +12046,8 @@ async function serverBuild({
12017
12046
  isCorrectLocaleAPIRoutes,
12018
12047
  lambdaCompressedByteLimit,
12019
12048
  requiredServerFilesManifest,
12020
- variantsManifest
12049
+ variantsManifest,
12050
+ experimentalPPRRoutes
12021
12051
  }) {
12022
12052
  lambdaPages = Object.assign({}, lambdaPages, lambdaAppPaths);
12023
12053
  const experimentalAllowBundling = Boolean(
@@ -12127,16 +12157,6 @@ async function serverBuild({
12127
12157
  if (lambdaPages["404.js"]) {
12128
12158
  internalPages.push("404.js");
12129
12159
  }
12130
- const experimentalPPRRoutes = /* @__PURE__ */ new Set();
12131
- for (const [route, { experimentalPPR }] of [
12132
- ...Object.entries(prerenderManifest.staticRoutes),
12133
- ...Object.entries(prerenderManifest.blockingFallbackRoutes),
12134
- ...Object.entries(prerenderManifest.fallbackRoutes)
12135
- ]) {
12136
- if (!experimentalPPR)
12137
- continue;
12138
- experimentalPPRRoutes.add(route);
12139
- }
12140
12160
  const prerenderRoutes = /* @__PURE__ */ new Set([
12141
12161
  ...canUsePreviewMode ? omittedPrerenderRoutes : [],
12142
12162
  ...Object.keys(prerenderManifest.blockingFallbackRoutes),
@@ -12778,7 +12798,7 @@ async function serverBuild({
12778
12798
  const isPPR = experimental.ppr && group.isAppRouter && !group.isAppRouteHandler;
12779
12799
  let revalidate;
12780
12800
  if (isPPR) {
12781
- if (isPPR && !options.isStreaming) {
12801
+ if (!options.isStreaming) {
12782
12802
  throw new Error("Invariant: PPR lambda isn't streaming");
12783
12803
  }
12784
12804
  revalidate = await createLambdaFromPseudoLayers({
@@ -12786,44 +12806,58 @@ async function serverBuild({
12786
12806
  isStreaming: false
12787
12807
  });
12788
12808
  }
12789
- for (const page of group.pages) {
12790
- const pageNoExt = page.replace(/\.js$/, "");
12791
- let isPrerender = prerenderRoutes.has(
12792
- import_path4.default.join("/", pageNoExt === "index" ? "" : pageNoExt)
12793
- );
12809
+ for (const pageFilename of group.pages) {
12810
+ const pageName = pageFilename.replace(/\.js$/, "");
12811
+ const pagePath = import_path4.default.posix.join("/", pageName);
12812
+ const pagePathname = pagePath === "/index" ? "/" : pagePath;
12813
+ let isPrerender = prerenderRoutes.has(pagePathname);
12794
12814
  if (!isPrerender && routesManifest?.i18n) {
12795
12815
  isPrerender = routesManifest.i18n.locales.some((locale) => {
12796
12816
  return prerenderRoutes.has(
12797
- import_path4.default.join("/", locale, pageNoExt === "index" ? "" : pageNoExt)
12817
+ import_path4.default.join("/", locale, pageName === "index" ? "" : pageName)
12798
12818
  );
12799
12819
  });
12800
12820
  }
12801
- let outputName = import_path4.default.posix.join(entryDirectory, pageNoExt);
12802
- if (!group.isAppRouter && !group.isAppRouteHandler) {
12803
- outputName = normalizeIndexOutput(outputName, true);
12804
- }
12821
+ let outputName = import_path4.default.posix.join(entryDirectory, pageName);
12805
12822
  if (isPPR) {
12806
12823
  if (!revalidate) {
12807
12824
  throw new Error("Invariant: PPR lambda isn't set");
12808
12825
  }
12809
- outputName = import_path4.default.posix.join(entryDirectory, pageNoExt);
12810
12826
  lambdas[outputName] = revalidate;
12811
- const pprOutputName = import_path4.default.posix.join(
12812
- entryDirectory,
12813
- "/_next/postponed/resume",
12814
- pageNoExt
12815
- );
12816
- lambdas[pprOutputName] = lambda;
12817
- experimentalStreamingLambdaPaths.set(outputName, pprOutputName);
12827
+ if (!omittedPrerenderRoutes.has(pagePathname)) {
12828
+ const key = getPostponeResumePathname(entryDirectory, pageName);
12829
+ lambdas[key] = lambda;
12830
+ experimentalStreamingLambdaPaths.set(outputName, key);
12831
+ } else {
12832
+ for (const [
12833
+ routePathname,
12834
+ { srcRoute, experimentalPPR }
12835
+ ] of Object.entries(prerenderManifest.staticRoutes)) {
12836
+ if (srcRoute !== pagePathname || !experimentalPPR)
12837
+ continue;
12838
+ if (routePathname === pagePathname)
12839
+ continue;
12840
+ const key = getPostponeResumePathname(
12841
+ entryDirectory,
12842
+ routePathname
12843
+ );
12844
+ lambdas[key] = lambda;
12845
+ outputName = import_path4.default.posix.join(entryDirectory, routePathname);
12846
+ experimentalStreamingLambdaPaths.set(outputName, key);
12847
+ }
12848
+ }
12818
12849
  continue;
12819
12850
  }
12820
- if (i18n && !isPrerender && !group.isAppRouter && (!isCorrectLocaleAPIRoutes || !(pageNoExt === "api" || pageNoExt.startsWith("api/")))) {
12851
+ if (!group.isAppRouter && !group.isAppRouteHandler) {
12852
+ outputName = normalizeIndexOutput(outputName, true);
12853
+ }
12854
+ if (i18n && !isPrerender && !group.isAppRouter && (!isCorrectLocaleAPIRoutes || !(pageName === "api" || pageName.startsWith("api/")))) {
12821
12855
  for (const locale of i18n.locales) {
12822
12856
  lambdas[normalizeIndexOutput(
12823
12857
  import_path4.default.posix.join(
12824
12858
  entryDirectory,
12825
12859
  locale,
12826
- pageNoExt === "index" ? "" : pageNoExt
12860
+ pageName === "index" ? "" : pageName
12827
12861
  ),
12828
12862
  true
12829
12863
  )] = lambda;
@@ -12853,7 +12887,8 @@ async function serverBuild({
12853
12887
  localePrefixed404,
12854
12888
  hasPages404: routesManifest.pages404,
12855
12889
  isCorrectNotFoundRoutes,
12856
- isEmptyAllowQueryForPrendered
12890
+ isEmptyAllowQueryForPrendered,
12891
+ omittedPrerenderRoutes
12857
12892
  });
12858
12893
  await Promise.all(
12859
12894
  Object.keys(prerenderManifest.staticRoutes).map(
@@ -12872,9 +12907,9 @@ async function serverBuild({
12872
12907
  );
12873
12908
  if (static404Page && canUsePreviewMode) {
12874
12909
  await Promise.all(
12875
- [...omittedPrerenderRoutes].map((route) => {
12876
- return prerenderRoute(route, { isOmitted: true });
12877
- })
12910
+ Array.from(omittedPrerenderRoutes).map(
12911
+ (route) => prerenderRoute(route, { isOmitted: true })
12912
+ )
12878
12913
  );
12879
12914
  }
12880
12915
  prerenderRoutes.forEach((route) => {
@@ -12899,19 +12934,19 @@ async function serverBuild({
12899
12934
  appPathRoutesManifest: appPathRoutesManifest || {}
12900
12935
  });
12901
12936
  const isNextDataServerResolving = middleware.staticRoutes.length > 0 && import_semver3.default.gte(nextVersion, NEXT_DATA_MIDDLEWARE_RESOLVING_VERSION);
12902
- const dynamicRoutes = await getDynamicRoutes(
12937
+ const dynamicRoutes = await getDynamicRoutes({
12903
12938
  entryPath,
12904
12939
  entryDirectory,
12905
12940
  dynamicPages,
12906
- false,
12941
+ isDev: false,
12907
12942
  routesManifest,
12908
- omittedPrerenderRoutes,
12943
+ omittedRoutes: omittedPrerenderRoutes,
12909
12944
  canUsePreviewMode,
12910
- prerenderManifest.bypassToken || "",
12911
- true,
12912
- middleware.dynamicRouteMap,
12913
- experimental.ppr
12914
- ).then(
12945
+ bypassToken: prerenderManifest.bypassToken || "",
12946
+ isServerMode: true,
12947
+ dynamicMiddlewareRouteMap: middleware.dynamicRouteMap,
12948
+ experimentalPPRRoutes
12949
+ }).then(
12915
12950
  (arr) => localizeDynamicRoutes(
12916
12951
  arr,
12917
12952
  dynamicPrefix,
@@ -13080,6 +13115,28 @@ async function serverBuild({
13080
13115
  if (experimental.ppr && !rscPrefetchHeader) {
13081
13116
  throw new Error("Invariant: cannot use PPR without 'rsc.prefetchHeader'");
13082
13117
  }
13118
+ if (experimental.ppr) {
13119
+ for (const { srcRoute, dataRoute, experimentalPPR } of Object.values(
13120
+ prerenderManifest.staticRoutes
13121
+ )) {
13122
+ if (!experimentalPPR || !dataRoute || !srcRoute)
13123
+ continue;
13124
+ if (!omittedPrerenderRoutes.has(srcRoute))
13125
+ continue;
13126
+ const srcPathname = srcRoute.substring(1);
13127
+ const dataPathname = dataRoute.substring(1);
13128
+ const dataPathnameExists = dataPathname in lambdas;
13129
+ if (dataPathnameExists)
13130
+ continue;
13131
+ const srcPathnameExists = srcPathname in lambdas;
13132
+ if (!srcPathnameExists) {
13133
+ throw new Error(
13134
+ `Invariant: Expected to have a lambda for the source route: ${srcPathname}`
13135
+ );
13136
+ }
13137
+ lambdas[dataPathname] = lambdas[srcPathname];
13138
+ }
13139
+ }
13083
13140
  return {
13084
13141
  wildcard: wildcardConfig,
13085
13142
  images: getImagesConfig(imagesManifest),
@@ -14546,6 +14603,17 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
14546
14603
  }
14547
14604
  }
14548
14605
  }
14606
+ const experimentalPPRRoutes = /* @__PURE__ */ new Set();
14607
+ for (const [route, { experimentalPPR }] of [
14608
+ ...Object.entries(prerenderManifest.staticRoutes),
14609
+ ...Object.entries(prerenderManifest.blockingFallbackRoutes),
14610
+ ...Object.entries(prerenderManifest.fallbackRoutes),
14611
+ ...Object.entries(prerenderManifest.omittedRoutes)
14612
+ ]) {
14613
+ if (!experimentalPPR)
14614
+ continue;
14615
+ experimentalPPRRoutes.add(route);
14616
+ }
14549
14617
  if (requiredServerFilesManifest) {
14550
14618
  if (!routesManifest) {
14551
14619
  throw new Error(
@@ -14593,7 +14661,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
14593
14661
  privateOutputs,
14594
14662
  hasIsr404Page,
14595
14663
  hasIsr500Page,
14596
- variantsManifest
14664
+ variantsManifest,
14665
+ experimentalPPRRoutes
14597
14666
  });
14598
14667
  }
14599
14668
  const pageKeys = Object.keys(pages);
@@ -14982,17 +15051,18 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
14982
15051
  })
14983
15052
  );
14984
15053
  }
14985
- dynamicRoutes = await getDynamicRoutes(
15054
+ dynamicRoutes = await getDynamicRoutes({
14986
15055
  entryPath,
14987
15056
  entryDirectory,
14988
15057
  dynamicPages,
14989
- false,
15058
+ isDev: false,
14990
15059
  routesManifest,
14991
- omittedPrerenderRoutes,
15060
+ omittedRoutes: omittedPrerenderRoutes,
14992
15061
  canUsePreviewMode,
14993
- prerenderManifest.bypassToken || "",
14994
- isServerMode
14995
- ).then(
15062
+ bypassToken: prerenderManifest.bypassToken || "",
15063
+ isServerMode,
15064
+ experimentalPPRRoutes
15065
+ }).then(
14996
15066
  (arr) => localizeDynamicRoutes(
14997
15067
  arr,
14998
15068
  dynamicPrefix,
@@ -15007,17 +15077,18 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
15007
15077
  if (isSharedLambdas) {
15008
15078
  const launcherPath2 = import_path5.default.join(__dirname, "templated-launcher-shared.js");
15009
15079
  const launcherData2 = await (0, import_fs_extra6.readFile)(launcherPath2, "utf8");
15010
- const completeDynamicRoutes = await getDynamicRoutes(
15080
+ const completeDynamicRoutes = await getDynamicRoutes({
15011
15081
  entryPath,
15012
15082
  entryDirectory,
15013
15083
  dynamicPages,
15014
- false,
15084
+ isDev: false,
15015
15085
  routesManifest,
15016
- void 0,
15086
+ omittedRoutes: void 0,
15017
15087
  canUsePreviewMode,
15018
- prerenderManifest.bypassToken || "",
15019
- isServerMode
15020
- ).then(
15088
+ bypassToken: prerenderManifest.bypassToken || "",
15089
+ isServerMode,
15090
+ experimentalPPRRoutes
15091
+ }).then(
15021
15092
  (arr) => arr.map((route) => {
15022
15093
  route.src = route.src.replace("^", `^${dynamicPrefix}`);
15023
15094
  return route;
@@ -15194,21 +15265,30 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
15194
15265
  prerenderManifest,
15195
15266
  appPathRoutesManifest,
15196
15267
  isSharedLambdas,
15197
- canUsePreviewMode
15268
+ canUsePreviewMode,
15269
+ omittedPrerenderRoutes
15198
15270
  });
15199
- Object.keys(prerenderManifest.staticRoutes).forEach(
15200
- (route) => prerenderRoute(route, { isBlocking: false, isFallback: false })
15271
+ await Promise.all(
15272
+ Object.keys(prerenderManifest.staticRoutes).map(
15273
+ (route) => prerenderRoute(route, {})
15274
+ )
15201
15275
  );
15202
- Object.keys(prerenderManifest.fallbackRoutes).forEach(
15203
- (route) => prerenderRoute(route, { isBlocking: false, isFallback: true })
15276
+ await Promise.all(
15277
+ Object.keys(prerenderManifest.fallbackRoutes).map(
15278
+ (route) => prerenderRoute(route, { isFallback: true })
15279
+ )
15204
15280
  );
15205
- Object.keys(prerenderManifest.blockingFallbackRoutes).forEach(
15206
- (route) => prerenderRoute(route, { isBlocking: true, isFallback: false })
15281
+ await Promise.all(
15282
+ Object.keys(prerenderManifest.blockingFallbackRoutes).map(
15283
+ (route) => prerenderRoute(route, { isBlocking: true })
15284
+ )
15207
15285
  );
15208
15286
  if (static404Page && canUsePreviewMode) {
15209
- omittedPrerenderRoutes.forEach((route) => {
15210
- prerenderRoute(route, { isOmitted: true });
15211
- });
15287
+ await Promise.all(
15288
+ Array.from(omittedPrerenderRoutes).map(
15289
+ (route) => prerenderRoute(route, { isOmitted: true })
15290
+ )
15291
+ );
15212
15292
  }
15213
15293
  if (!(routesManifest && routesManifest.dataRoutes)) {
15214
15294
  [
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@vercel/next",
3
- "version": "4.1.3",
3
+ "version": "4.1.4",
4
4
  "license": "Apache-2.0",
5
5
  "main": "./dist/index",
6
6
  "homepage": "https://vercel.com/docs/runtimes#official-runtimes/next-js",
@@ -30,7 +30,7 @@
30
30
  "@types/semver": "6.0.0",
31
31
  "@types/text-table": "0.2.1",
32
32
  "@types/webpack-sources": "3.2.0",
33
- "@vercel/build-utils": "7.7.0",
33
+ "@vercel/build-utils": "7.7.1",
34
34
  "@vercel/routing-utils": "3.1.0",
35
35
  "async-sema": "3.0.1",
36
36
  "buffer-crc32": "0.2.13",