@vercel/next 4.1.2 → 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 +160 -83
  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(
@@ -12078,10 +12108,7 @@ async function serverBuild({
12078
12108
  nextVersion,
12079
12109
  CORRECT_MIDDLEWARE_ORDER_VERSION
12080
12110
  );
12081
- const isCorrectManifests = import_semver3.default.gte(
12082
- nextVersion,
12083
- CORRECTED_MANIFESTS_VERSION
12084
- );
12111
+ const isCorrectManifests = !experimentalAllowBundling && import_semver3.default.gte(nextVersion, CORRECTED_MANIFESTS_VERSION);
12085
12112
  let hasStatic500 = !!staticPages[import_path4.default.posix.join(entryDirectory, "500")];
12086
12113
  if (lambdaPageKeys.length === 0) {
12087
12114
  throw new import_build_utils2.NowBuildError({
@@ -12130,16 +12157,6 @@ async function serverBuild({
12130
12157
  if (lambdaPages["404.js"]) {
12131
12158
  internalPages.push("404.js");
12132
12159
  }
12133
- const experimentalPPRRoutes = /* @__PURE__ */ new Set();
12134
- for (const [route, { experimentalPPR }] of [
12135
- ...Object.entries(prerenderManifest.staticRoutes),
12136
- ...Object.entries(prerenderManifest.blockingFallbackRoutes),
12137
- ...Object.entries(prerenderManifest.fallbackRoutes)
12138
- ]) {
12139
- if (!experimentalPPR)
12140
- continue;
12141
- experimentalPPRRoutes.add(route);
12142
- }
12143
12160
  const prerenderRoutes = /* @__PURE__ */ new Set([
12144
12161
  ...canUsePreviewMode ? omittedPrerenderRoutes : [],
12145
12162
  ...Object.keys(prerenderManifest.blockingFallbackRoutes),
@@ -12781,7 +12798,7 @@ async function serverBuild({
12781
12798
  const isPPR = experimental.ppr && group.isAppRouter && !group.isAppRouteHandler;
12782
12799
  let revalidate;
12783
12800
  if (isPPR) {
12784
- if (isPPR && !options.isStreaming) {
12801
+ if (!options.isStreaming) {
12785
12802
  throw new Error("Invariant: PPR lambda isn't streaming");
12786
12803
  }
12787
12804
  revalidate = await createLambdaFromPseudoLayers({
@@ -12789,44 +12806,58 @@ async function serverBuild({
12789
12806
  isStreaming: false
12790
12807
  });
12791
12808
  }
12792
- for (const page of group.pages) {
12793
- const pageNoExt = page.replace(/\.js$/, "");
12794
- let isPrerender = prerenderRoutes.has(
12795
- import_path4.default.join("/", pageNoExt === "index" ? "" : pageNoExt)
12796
- );
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);
12797
12814
  if (!isPrerender && routesManifest?.i18n) {
12798
12815
  isPrerender = routesManifest.i18n.locales.some((locale) => {
12799
12816
  return prerenderRoutes.has(
12800
- import_path4.default.join("/", locale, pageNoExt === "index" ? "" : pageNoExt)
12817
+ import_path4.default.join("/", locale, pageName === "index" ? "" : pageName)
12801
12818
  );
12802
12819
  });
12803
12820
  }
12804
- let outputName = import_path4.default.posix.join(entryDirectory, pageNoExt);
12805
- if (!group.isAppRouter && !group.isAppRouteHandler) {
12806
- outputName = normalizeIndexOutput(outputName, true);
12807
- }
12821
+ let outputName = import_path4.default.posix.join(entryDirectory, pageName);
12808
12822
  if (isPPR) {
12809
12823
  if (!revalidate) {
12810
12824
  throw new Error("Invariant: PPR lambda isn't set");
12811
12825
  }
12812
- outputName = import_path4.default.posix.join(entryDirectory, pageNoExt);
12813
12826
  lambdas[outputName] = revalidate;
12814
- const pprOutputName = import_path4.default.posix.join(
12815
- entryDirectory,
12816
- "/_next/postponed/resume",
12817
- pageNoExt
12818
- );
12819
- lambdas[pprOutputName] = lambda;
12820
- 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
+ }
12821
12849
  continue;
12822
12850
  }
12823
- 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/")))) {
12824
12855
  for (const locale of i18n.locales) {
12825
12856
  lambdas[normalizeIndexOutput(
12826
12857
  import_path4.default.posix.join(
12827
12858
  entryDirectory,
12828
12859
  locale,
12829
- pageNoExt === "index" ? "" : pageNoExt
12860
+ pageName === "index" ? "" : pageName
12830
12861
  ),
12831
12862
  true
12832
12863
  )] = lambda;
@@ -12856,7 +12887,8 @@ async function serverBuild({
12856
12887
  localePrefixed404,
12857
12888
  hasPages404: routesManifest.pages404,
12858
12889
  isCorrectNotFoundRoutes,
12859
- isEmptyAllowQueryForPrendered
12890
+ isEmptyAllowQueryForPrendered,
12891
+ omittedPrerenderRoutes
12860
12892
  });
12861
12893
  await Promise.all(
12862
12894
  Object.keys(prerenderManifest.staticRoutes).map(
@@ -12875,9 +12907,9 @@ async function serverBuild({
12875
12907
  );
12876
12908
  if (static404Page && canUsePreviewMode) {
12877
12909
  await Promise.all(
12878
- [...omittedPrerenderRoutes].map((route) => {
12879
- return prerenderRoute(route, { isOmitted: true });
12880
- })
12910
+ Array.from(omittedPrerenderRoutes).map(
12911
+ (route) => prerenderRoute(route, { isOmitted: true })
12912
+ )
12881
12913
  );
12882
12914
  }
12883
12915
  prerenderRoutes.forEach((route) => {
@@ -12902,19 +12934,19 @@ async function serverBuild({
12902
12934
  appPathRoutesManifest: appPathRoutesManifest || {}
12903
12935
  });
12904
12936
  const isNextDataServerResolving = middleware.staticRoutes.length > 0 && import_semver3.default.gte(nextVersion, NEXT_DATA_MIDDLEWARE_RESOLVING_VERSION);
12905
- const dynamicRoutes = await getDynamicRoutes(
12937
+ const dynamicRoutes = await getDynamicRoutes({
12906
12938
  entryPath,
12907
12939
  entryDirectory,
12908
12940
  dynamicPages,
12909
- false,
12941
+ isDev: false,
12910
12942
  routesManifest,
12911
- omittedPrerenderRoutes,
12943
+ omittedRoutes: omittedPrerenderRoutes,
12912
12944
  canUsePreviewMode,
12913
- prerenderManifest.bypassToken || "",
12914
- true,
12915
- middleware.dynamicRouteMap,
12916
- experimental.ppr
12917
- ).then(
12945
+ bypassToken: prerenderManifest.bypassToken || "",
12946
+ isServerMode: true,
12947
+ dynamicMiddlewareRouteMap: middleware.dynamicRouteMap,
12948
+ experimentalPPRRoutes
12949
+ }).then(
12918
12950
  (arr) => localizeDynamicRoutes(
12919
12951
  arr,
12920
12952
  dynamicPrefix,
@@ -13083,6 +13115,28 @@ async function serverBuild({
13083
13115
  if (experimental.ppr && !rscPrefetchHeader) {
13084
13116
  throw new Error("Invariant: cannot use PPR without 'rsc.prefetchHeader'");
13085
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
+ }
13086
13140
  return {
13087
13141
  wildcard: wildcardConfig,
13088
13142
  images: getImagesConfig(imagesManifest),
@@ -14549,6 +14603,17 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
14549
14603
  }
14550
14604
  }
14551
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
+ }
14552
14617
  if (requiredServerFilesManifest) {
14553
14618
  if (!routesManifest) {
14554
14619
  throw new Error(
@@ -14596,7 +14661,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
14596
14661
  privateOutputs,
14597
14662
  hasIsr404Page,
14598
14663
  hasIsr500Page,
14599
- variantsManifest
14664
+ variantsManifest,
14665
+ experimentalPPRRoutes
14600
14666
  });
14601
14667
  }
14602
14668
  const pageKeys = Object.keys(pages);
@@ -14985,17 +15051,18 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
14985
15051
  })
14986
15052
  );
14987
15053
  }
14988
- dynamicRoutes = await getDynamicRoutes(
15054
+ dynamicRoutes = await getDynamicRoutes({
14989
15055
  entryPath,
14990
15056
  entryDirectory,
14991
15057
  dynamicPages,
14992
- false,
15058
+ isDev: false,
14993
15059
  routesManifest,
14994
- omittedPrerenderRoutes,
15060
+ omittedRoutes: omittedPrerenderRoutes,
14995
15061
  canUsePreviewMode,
14996
- prerenderManifest.bypassToken || "",
14997
- isServerMode
14998
- ).then(
15062
+ bypassToken: prerenderManifest.bypassToken || "",
15063
+ isServerMode,
15064
+ experimentalPPRRoutes
15065
+ }).then(
14999
15066
  (arr) => localizeDynamicRoutes(
15000
15067
  arr,
15001
15068
  dynamicPrefix,
@@ -15010,17 +15077,18 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
15010
15077
  if (isSharedLambdas) {
15011
15078
  const launcherPath2 = import_path5.default.join(__dirname, "templated-launcher-shared.js");
15012
15079
  const launcherData2 = await (0, import_fs_extra6.readFile)(launcherPath2, "utf8");
15013
- const completeDynamicRoutes = await getDynamicRoutes(
15080
+ const completeDynamicRoutes = await getDynamicRoutes({
15014
15081
  entryPath,
15015
15082
  entryDirectory,
15016
15083
  dynamicPages,
15017
- false,
15084
+ isDev: false,
15018
15085
  routesManifest,
15019
- void 0,
15086
+ omittedRoutes: void 0,
15020
15087
  canUsePreviewMode,
15021
- prerenderManifest.bypassToken || "",
15022
- isServerMode
15023
- ).then(
15088
+ bypassToken: prerenderManifest.bypassToken || "",
15089
+ isServerMode,
15090
+ experimentalPPRRoutes
15091
+ }).then(
15024
15092
  (arr) => arr.map((route) => {
15025
15093
  route.src = route.src.replace("^", `^${dynamicPrefix}`);
15026
15094
  return route;
@@ -15197,21 +15265,30 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
15197
15265
  prerenderManifest,
15198
15266
  appPathRoutesManifest,
15199
15267
  isSharedLambdas,
15200
- canUsePreviewMode
15268
+ canUsePreviewMode,
15269
+ omittedPrerenderRoutes
15201
15270
  });
15202
- Object.keys(prerenderManifest.staticRoutes).forEach(
15203
- (route) => prerenderRoute(route, { isBlocking: false, isFallback: false })
15271
+ await Promise.all(
15272
+ Object.keys(prerenderManifest.staticRoutes).map(
15273
+ (route) => prerenderRoute(route, {})
15274
+ )
15204
15275
  );
15205
- Object.keys(prerenderManifest.fallbackRoutes).forEach(
15206
- (route) => prerenderRoute(route, { isBlocking: false, isFallback: true })
15276
+ await Promise.all(
15277
+ Object.keys(prerenderManifest.fallbackRoutes).map(
15278
+ (route) => prerenderRoute(route, { isFallback: true })
15279
+ )
15207
15280
  );
15208
- Object.keys(prerenderManifest.blockingFallbackRoutes).forEach(
15209
- (route) => prerenderRoute(route, { isBlocking: true, isFallback: false })
15281
+ await Promise.all(
15282
+ Object.keys(prerenderManifest.blockingFallbackRoutes).map(
15283
+ (route) => prerenderRoute(route, { isBlocking: true })
15284
+ )
15210
15285
  );
15211
15286
  if (static404Page && canUsePreviewMode) {
15212
- omittedPrerenderRoutes.forEach((route) => {
15213
- prerenderRoute(route, { isOmitted: true });
15214
- });
15287
+ await Promise.all(
15288
+ Array.from(omittedPrerenderRoutes).map(
15289
+ (route) => prerenderRoute(route, { isOmitted: true })
15290
+ )
15291
+ );
15215
15292
  }
15216
15293
  if (!(routesManifest && routesManifest.dataRoutes)) {
15217
15294
  [
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@vercel/next",
3
- "version": "4.1.2",
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",