@edgeone/opennextjs-pages 0.0.1

package/dist/run/handlers/wait-until.cjs

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/run/handlers/wait-until.cts
+var wait_until_exports = {};
+__export(wait_until_exports, {
+  setupWaitUntil: () => setupWaitUntil
+});
+module.exports = __toCommonJS(wait_until_exports);
+var import_request_context = require("./request-context.cjs");
+var NEXT_REQUEST_CONTEXT_SYMBOL = Symbol.for("@next/request-context");
+function setupWaitUntil() {
+  ;
+  globalThis[NEXT_REQUEST_CONTEXT_SYMBOL] = {
+    get() {
+      return { waitUntil: (0, import_request_context.getRequestContext)()?.trackBackgroundWork };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupWaitUntil
+});

package/dist/run/headers.js

@@ -0,0 +1,81 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import "../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/run/headers.ts
+var getHeaderValueArray = (header) => {
+  return header.split(",").map((value) => value.trim()).filter(Boolean);
+};
+var omitHeaderValues = (header, values) => {
+  const headerValues = getHeaderValueArray(header);
+  const filteredValues = headerValues.filter(
+    (value) => !values.some((val) => value.startsWith(val))
+  );
+  return filteredValues.join(", ");
+};
+function setCacheControlFromRequestContext(headers, revalidate) {
+  const cdnCacheControl = (
+    // if we are serving already stale response, instruct edge to not attempt to cache that response
+    headers.get("x-nextjs-cache") === "STALE" ? "public, max-age=0, must-revalidate, durable" : `s-maxage=${revalidate || 31536e3}, stale-while-revalidate=31536000, durable`
+  );
+  headers.set("eo-cdn-cache-control", cdnCacheControl);
+}
+var setCacheControlHeaders = ({ headers, status }, request, requestContext) => {
+  if (typeof requestContext.routeHandlerRevalidate !== "undefined" && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("eo-cdn-cache-control")) {
+    setCacheControlFromRequestContext(headers, requestContext.routeHandlerRevalidate);
+    return;
+  }
+  if (status === 404) {
+    if (request.url.endsWith(".php")) {
+      headers.set("cache-control", "public, max-age=0, must-revalidate");
+      headers.set("eo-cdn-cache-control", `max-age=31536000, durable`);
+      return;
+    }
+    if (process.env.CACHE_404_PAGE && request.url.endsWith("/404") && ["GET", "HEAD"].includes(request.method)) {
+      setCacheControlFromRequestContext(headers, requestContext.pageHandlerRevalidate);
+      return;
+    }
+  }
+  const cacheControl = headers.get("cache-control");
+  if (cacheControl !== null && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("eo-cdn-cache-control")) {
+    const browserCacheControl = omitHeaderValues(cacheControl, [
+      "s-maxage",
+      "stale-while-revalidate"
+    ]);
+    const cdnCacheControl = (
+      // if we are serving already stale response, instruct edge to not attempt to cache that response
+      headers.get("x-nextjs-cache") === "STALE" ? "public, max-age=0, must-revalidate, durable" : [
+        ...getHeaderValueArray(cacheControl).map(
+          (value) => value === "stale-while-revalidate" ? "stale-while-revalidate=31536000" : value
+        ),
+        "durable"
+      ].join(", ")
+    );
+    headers.set("cache-control", browserCacheControl || "public, max-age=0, must-revalidate");
+    headers.set("eo-cdn-cache-control", cdnCacheControl);
+    return;
+  }
+  if (cacheControl === null && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("eo-cdn-cache-control") && requestContext.usedFsReadForNonFallback && !requestContext.didPagesRouterOnDemandRevalidate) {
+    headers.set("cache-control", "public, max-age=0, must-revalidate");
+    headers.set("eo-cdn-cache-control", `max-age=31536000, durable`);
+  }
+};
+var setCacheTagsHeaders = (headers, requestContext) => {
+  if (!headers.has("cache-control")) {
+    return;
+  }
+};
+var setCacheStatusHeader = (headers, nextCache) => {
+  if (headers.has("x-nextjs-cache")) {
+    headers.delete("x-nextjs-cache");
+  }
+};
+export {
+  setCacheControlHeaders,
+  setCacheStatusHeader,
+  setCacheTagsHeaders
+};

package/dist/run/next.cjs

@@ -0,0 +1,100 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/run/next.cts
+var next_exports = {};
+__export(next_exports, {
+  getMockedRequestHandler: () => getMockedRequestHandler
+});
+module.exports = __toCommonJS(next_exports);
+var import_node_async_hooks = require("node:async_hooks");
+var import_promises = __toESM(require("node:fs/promises"));
+var import_request_context = require("./handlers/request-context.cjs");
+var import_tracer = require("./handlers/tracer.cjs");
+process.env.NODE_ENV = "production";
+var { getRequestHandlers } = require("next/dist/server/lib/start-server.js");
+var ResponseCache = require("next/dist/server/response-cache/index.js").default;
+var originalGet = ResponseCache.prototype.get;
+ResponseCache.prototype.get = function get(...getArgs) {
+  if (!this.didAddBackgroundWorkTracking) {
+    if (typeof this.batcher !== "undefined") {
+      const originalBatcherBatch = this.batcher.batch;
+      this.batcher.batch = async (key, fn) => {
+        const trackedFn = async (...workFnArgs) => {
+          const workPromise = fn(...workFnArgs);
+          const requestContext = (0, import_request_context.getRequestContext)();
+          if (requestContext && workPromise instanceof Promise) {
+            requestContext.trackBackgroundWork(workPromise);
+          }
+          return await workPromise;
+        };
+        return originalBatcherBatch.call(this.batcher, key, trackedFn);
+      };
+    } else if (typeof this.pendingResponses !== "undefined") {
+      const backgroundWork = /* @__PURE__ */ new Map();
+      const originalPendingResponsesSet = this.pendingResponses.set;
+      this.pendingResponses.set = async (key, value) => {
+        const requestContext = (0, import_request_context.getRequestContext)();
+        if (requestContext && !this.pendingResponses.has(key)) {
+          const workPromise = new Promise((_resolve) => {
+            backgroundWork.set(key, _resolve);
+          });
+          requestContext.trackBackgroundWork(workPromise);
+        }
+        return originalPendingResponsesSet.call(this.pendingResponses, key, value);
+      };
+      const originalPendingResponsesDelete = this.pendingResponses.delete;
+      this.pendingResponses.delete = async (key) => {
+        const _resolve = backgroundWork.get(key);
+        if (_resolve) {
+          _resolve();
+        }
+        return originalPendingResponsesDelete.call(this.pendingResponses, key);
+      };
+    }
+    this.didAddBackgroundWorkTracking = true;
+  }
+  return originalGet.apply(this, getArgs);
+};
+async function getMockedRequestHandler(...args) {
+  const initContext = { initializingServer: true };
+  const initAsyncLocalStorage = new import_node_async_hooks.AsyncLocalStorage();
+  const tracer = (0, import_tracer.getTracer)();
+  return tracer.withActiveSpan("mocked request handler", async () => {
+    const ofs = { ...import_promises.default };
+    const requestHandlers = await initAsyncLocalStorage.run(initContext, async () => {
+      return await getRequestHandlers(...args);
+    });
+    return Array.isArray(requestHandlers) ? requestHandlers[0] : requestHandlers.requestHandler;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMockedRequestHandler
+});

package/dist/run/revalidate.js

@@ -0,0 +1,34 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import "../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/run/revalidate.ts
+import { isPromise } from "node:util/types";
+function isRevalidateMethod(key, nextResponseField) {
+  return key === "revalidate" && typeof nextResponseField === "function";
+}
+var nextResponseProxy = (response, requestContext) => {
+  return new Proxy(response, {
+    get(target, key) {
+      const originalValue = Reflect.get(target, key);
+      if (isRevalidateMethod(key, originalValue)) {
+        return function newRevalidate(...args) {
+          requestContext.didPagesRouterOnDemandRevalidate = true;
+          const result = originalValue.apply(target, args);
+          if (result && isPromise(result)) {
+            requestContext.trackBackgroundWork(result);
+          }
+          return result;
+        };
+      }
+      return originalValue;
+    }
+  });
+};
+export {
+  nextResponseProxy
+};

package/dist/run/storage/regional-blob-store.cjs

@@ -0,0 +1,64 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/run/storage/regional-blob-store.cts
+var regional_blob_store_exports = {};
+__export(regional_blob_store_exports, {
+  getRegionalBlobStore: () => getRegionalBlobStore,
+  setFetchBeforeNextPatchedIt: () => setFetchBeforeNextPatchedIt
+});
+module.exports = __toCommonJS(regional_blob_store_exports);
+var FETCH_BEFORE_NEXT_PATCHED_IT = Symbol.for("nf-not-patched-fetch");
+var extendedGlobalThis = globalThis;
+function attemptToGetOriginalFetch(fetch) {
+  return fetch._nextOriginalFetch ?? fetch;
+}
+function forceOptOutOfUsingDataCache(fetch) {
+  return (input, init) => {
+    return fetch(input, {
+      ...init,
+      next: {
+        ...init?.next,
+        // setting next.internal = true should prevent from trying to use data cache
+        // https://github.com/vercel/next.js/blob/fa214c74c1d8023098c0e94e57f917ef9f1afd1a/packages/next/src/server/lib/patch-fetch.ts#L174
+        // https://github.com/vercel/next.js/blob/fa214c74c1d8023098c0e94e57f917ef9f1afd1a/packages/next/src/server/lib/patch-fetch.ts#L210-L213
+        // this is last line of defense in case we didn't manage to get unpatched fetch that will not affect
+        // fetch if it's unpatched so it should be safe to apply always if we aren't sure if we use patched fetch
+        // @ts-expect-error - this is an internal field that Next.js doesn't add to its global
+        // type overrides for RequestInit type (like `next.revalidate` or `next.tags`)
+        internal: true
+      }
+    });
+  };
+}
+var setFetchBeforeNextPatchedIt = (fetch) => {
+  extendedGlobalThis[FETCH_BEFORE_NEXT_PATCHED_IT] = forceOptOutOfUsingDataCache(
+    attemptToGetOriginalFetch(fetch)
+  );
+};
+var fetchBeforeNextPatchedItFallback = forceOptOutOfUsingDataCache(
+  attemptToGetOriginalFetch(globalThis.fetch)
+);
+var getRegionalBlobStore = (args = {}) => {
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRegionalBlobStore,
+  setFetchBeforeNextPatchedIt
+});