@vercel/next 4.1.3 → 4.1.5

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 -85
  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,
@@ -13072,14 +13107,31 @@ async function serverBuild({
13072
13107
  const rscPrefetchHeader = routesManifest.rsc?.prefetchHeader?.toLowerCase();
13073
13108
  const rscVaryHeader = routesManifest?.rsc?.varyHeader || "RSC, Next-Router-State-Tree, Next-Router-Prefetch";
13074
13109
  const appNotFoundPath = import_path4.default.posix.join(".", entryDirectory, "_not-found");
13075
- const flags = variantsManifest ? Object.entries(variantsManifest).map(([key, value]) => ({
13076
- key,
13077
- ...value,
13078
- metadata: value.metadata ?? {}
13079
- })) : [];
13080
13110
  if (experimental.ppr && !rscPrefetchHeader) {
13081
13111
  throw new Error("Invariant: cannot use PPR without 'rsc.prefetchHeader'");
13082
13112
  }
13113
+ if (experimental.ppr) {
13114
+ for (const { srcRoute, dataRoute, experimentalPPR } of Object.values(
13115
+ prerenderManifest.staticRoutes
13116
+ )) {
13117
+ if (!experimentalPPR || !dataRoute || !srcRoute)
13118
+ continue;
13119
+ if (!omittedPrerenderRoutes.has(srcRoute))
13120
+ continue;
13121
+ const srcPathname = srcRoute.substring(1);
13122
+ const dataPathname = dataRoute.substring(1);
13123
+ const dataPathnameExists = dataPathname in lambdas;
13124
+ if (dataPathnameExists)
13125
+ continue;
13126
+ const srcPathnameExists = srcPathname in lambdas;
13127
+ if (!srcPathnameExists) {
13128
+ throw new Error(
13129
+ `Invariant: Expected to have a lambda for the source route: ${srcPathname}`
13130
+ );
13131
+ }
13132
+ lambdas[dataPathname] = lambdas[srcPathname];
13133
+ }
13134
+ }
13083
13135
  return {
13084
13136
  wildcard: wildcardConfig,
13085
13137
  images: getImagesConfig(imagesManifest),
@@ -13661,7 +13713,7 @@ async function serverBuild({
13661
13713
  ]
13662
13714
  ],
13663
13715
  framework: { version: nextVersion },
13664
- flags
13716
+ flags: variantsManifest || void 0
13665
13717
  };
13666
13718
  }
13667
13719
 
@@ -14546,6 +14598,17 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
14546
14598
  }
14547
14599
  }
14548
14600
  }
14601
+ const experimentalPPRRoutes = /* @__PURE__ */ new Set();
14602
+ for (const [route, { experimentalPPR }] of [
14603
+ ...Object.entries(prerenderManifest.staticRoutes),
14604
+ ...Object.entries(prerenderManifest.blockingFallbackRoutes),
14605
+ ...Object.entries(prerenderManifest.fallbackRoutes),
14606
+ ...Object.entries(prerenderManifest.omittedRoutes)
14607
+ ]) {
14608
+ if (!experimentalPPR)
14609
+ continue;
14610
+ experimentalPPRRoutes.add(route);
14611
+ }
14549
14612
  if (requiredServerFilesManifest) {
14550
14613
  if (!routesManifest) {
14551
14614
  throw new Error(
@@ -14593,7 +14656,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
14593
14656
  privateOutputs,
14594
14657
  hasIsr404Page,
14595
14658
  hasIsr500Page,
14596
- variantsManifest
14659
+ variantsManifest,
14660
+ experimentalPPRRoutes
14597
14661
  });
14598
14662
  }
14599
14663
  const pageKeys = Object.keys(pages);
@@ -14982,17 +15046,18 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
14982
15046
  })
14983
15047
  );
14984
15048
  }
14985
- dynamicRoutes = await getDynamicRoutes(
15049
+ dynamicRoutes = await getDynamicRoutes({
14986
15050
  entryPath,
14987
15051
  entryDirectory,
14988
15052
  dynamicPages,
14989
- false,
15053
+ isDev: false,
14990
15054
  routesManifest,
14991
- omittedPrerenderRoutes,
15055
+ omittedRoutes: omittedPrerenderRoutes,
14992
15056
  canUsePreviewMode,
14993
- prerenderManifest.bypassToken || "",
14994
- isServerMode
14995
- ).then(
15057
+ bypassToken: prerenderManifest.bypassToken || "",
15058
+ isServerMode,
15059
+ experimentalPPRRoutes
15060
+ }).then(
14996
15061
  (arr) => localizeDynamicRoutes(
14997
15062
  arr,
14998
15063
  dynamicPrefix,
@@ -15007,17 +15072,18 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
15007
15072
  if (isSharedLambdas) {
15008
15073
  const launcherPath2 = import_path5.default.join(__dirname, "templated-launcher-shared.js");
15009
15074
  const launcherData2 = await (0, import_fs_extra6.readFile)(launcherPath2, "utf8");
15010
- const completeDynamicRoutes = await getDynamicRoutes(
15075
+ const completeDynamicRoutes = await getDynamicRoutes({
15011
15076
  entryPath,
15012
15077
  entryDirectory,
15013
15078
  dynamicPages,
15014
- false,
15079
+ isDev: false,
15015
15080
  routesManifest,
15016
- void 0,
15081
+ omittedRoutes: void 0,
15017
15082
  canUsePreviewMode,
15018
- prerenderManifest.bypassToken || "",
15019
- isServerMode
15020
- ).then(
15083
+ bypassToken: prerenderManifest.bypassToken || "",
15084
+ isServerMode,
15085
+ experimentalPPRRoutes
15086
+ }).then(
15021
15087
  (arr) => arr.map((route) => {
15022
15088
  route.src = route.src.replace("^", `^${dynamicPrefix}`);
15023
15089
  return route;
@@ -15194,21 +15260,30 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
15194
15260
  prerenderManifest,
15195
15261
  appPathRoutesManifest,
15196
15262
  isSharedLambdas,
15197
- canUsePreviewMode
15263
+ canUsePreviewMode,
15264
+ omittedPrerenderRoutes
15198
15265
  });
15199
- Object.keys(prerenderManifest.staticRoutes).forEach(
15200
- (route) => prerenderRoute(route, { isBlocking: false, isFallback: false })
15266
+ await Promise.all(
15267
+ Object.keys(prerenderManifest.staticRoutes).map(
15268
+ (route) => prerenderRoute(route, {})
15269
+ )
15201
15270
  );
15202
- Object.keys(prerenderManifest.fallbackRoutes).forEach(
15203
- (route) => prerenderRoute(route, { isBlocking: false, isFallback: true })
15271
+ await Promise.all(
15272
+ Object.keys(prerenderManifest.fallbackRoutes).map(
15273
+ (route) => prerenderRoute(route, { isFallback: true })
15274
+ )
15204
15275
  );
15205
- Object.keys(prerenderManifest.blockingFallbackRoutes).forEach(
15206
- (route) => prerenderRoute(route, { isBlocking: true, isFallback: false })
15276
+ await Promise.all(
15277
+ Object.keys(prerenderManifest.blockingFallbackRoutes).map(
15278
+ (route) => prerenderRoute(route, { isBlocking: true })
15279
+ )
15207
15280
  );
15208
15281
  if (static404Page && canUsePreviewMode) {
15209
- omittedPrerenderRoutes.forEach((route) => {
15210
- prerenderRoute(route, { isOmitted: true });
15211
- });
15282
+ await Promise.all(
15283
+ Array.from(omittedPrerenderRoutes).map(
15284
+ (route) => prerenderRoute(route, { isOmitted: true })
15285
+ )
15286
+ );
15212
15287
  }
15213
15288
  if (!(routesManifest && routesManifest.dataRoutes)) {
15214
15289
  [
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@vercel/next",
3
- "version": "4.1.3",
3
+ "version": "4.1.5",
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.8.0",
34
34
  "@vercel/routing-utils": "3.1.0",
35
35
  "async-sema": "3.0.1",
36
36
  "buffer-crc32": "0.2.13",