fix(readme):updated

Author: shadil-rayyan

.open-next/.build/cache.cjs

@@ -0,0 +1,178 @@
+globalThis.disableIncrementalCache = false;globalThis.disableDynamoDBCache = false;globalThis.isNextAfter15 = true;globalThis.openNextDebug = false;globalThis.openNextVersion = "3.7.4";
+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);
+
+// node_modules/@opennextjs/aws/dist/adapters/composable-cache.js
+var composable_cache_exports = {};
+__export(composable_cache_exports, {
+  default: () => composable_cache_default
+});
+module.exports = __toCommonJS(composable_cache_exports);
+
+// node_modules/@opennextjs/aws/dist/adapters/logger.js
+function debug(...args) {
+  if (globalThis.openNextDebug) {
+    console.log(...args);
+  }
+}
+
+// node_modules/@opennextjs/aws/dist/utils/cache.js
+function getTagKey(tag) {
+  if (typeof tag === "string") {
+    return tag;
+  }
+  return JSON.stringify({
+    tag: tag.tag,
+    path: tag.path
+  });
+}
+async function writeTags(tags) {
+  const store = globalThis.__openNextAls.getStore();
+  debug("Writing tags", tags, store);
+  if (!store || globalThis.openNextConfig.dangerous?.disableTagCache) {
+    return;
+  }
+  const tagsToWrite = tags.filter((t) => {
+    const tagKey = getTagKey(t);
+    const shouldWrite = !store.writtenTags.has(tagKey);
+    if (shouldWrite) {
+      store.writtenTags.add(tagKey);
+    }
+    return shouldWrite;
+  });
+  if (tagsToWrite.length === 0) {
+    return;
+  }
+  await globalThis.tagCache.writeTags(tagsToWrite);
+}
+
+// node_modules/@opennextjs/aws/dist/utils/stream.js
+var import_node_stream = require("node:stream");
+function fromReadableStream(stream, base64) {
+  const reader = stream.getReader();
+  const chunks = [];
+  return new Promise((resolve, reject) => {
+    function pump() {
+      reader.read().then(({ done, value }) => {
+        if (done) {
+          resolve(Buffer.concat(chunks).toString(base64 ? "base64" : "utf8"));
+          return;
+        }
+        chunks.push(value);
+        pump();
+      }).catch(reject);
+    }
+    pump();
+  });
+}
+function toReadableStream(value, isBase64) {
+  return import_node_stream.Readable.toWeb(import_node_stream.Readable.from(Buffer.from(value, isBase64 ? "base64" : "utf8")));
+}
+
+// node_modules/@opennextjs/aws/dist/adapters/composable-cache.js
+var pendingWritePromiseMap = /* @__PURE__ */ new Map();
+var composable_cache_default = {
+  async get(cacheKey) {
+    try {
+      if (pendingWritePromiseMap.has(cacheKey)) {
+        const stored = pendingWritePromiseMap.get(cacheKey);
+        if (stored) {
+          return stored.then((entry) => ({
+            ...entry,
+            value: toReadableStream(entry.value)
+          }));
+        }
+      }
+      const result = await globalThis.incrementalCache.get(cacheKey, "composable");
+      if (!result?.value?.value) {
+        return void 0;
+      }
+      debug("composable cache result", result);
+      if (globalThis.tagCache.mode === "nextMode" && result.value.tags.length > 0) {
+        const hasBeenRevalidated = result.shouldBypassTagCache ? false : await globalThis.tagCache.hasBeenRevalidated(result.value.tags, result.lastModified);
+        if (hasBeenRevalidated)
+          return void 0;
+      } else if (globalThis.tagCache.mode === "original" || globalThis.tagCache.mode === void 0) {
+        const hasBeenRevalidated = result.shouldBypassTagCache ? false : await globalThis.tagCache.getLastModified(cacheKey, result.lastModified) === -1;
+        if (hasBeenRevalidated)
+          return void 0;
+      }
+      return {
+        ...result.value,
+        value: toReadableStream(result.value.value)
+      };
+    } catch (e) {
+      debug("Cannot read composable cache entry");
+      return void 0;
+    }
+  },
+  async set(cacheKey, pendingEntry) {
+    const promiseEntry = pendingEntry.then(async (entry2) => ({
+      ...entry2,
+      value: await fromReadableStream(entry2.value)
+    }));
+    pendingWritePromiseMap.set(cacheKey, promiseEntry);
+    const entry = await promiseEntry.finally(() => {
+      pendingWritePromiseMap.delete(cacheKey);
+    });
+    await globalThis.incrementalCache.set(cacheKey, {
+      ...entry,
+      value: entry.value
+    }, "composable");
+    if (globalThis.tagCache.mode === "original") {
+      const storedTags = await globalThis.tagCache.getByPath(cacheKey);
+      const tagsToWrite = entry.tags.filter((tag) => !storedTags.includes(tag));
+      if (tagsToWrite.length > 0) {
+        await writeTags(tagsToWrite.map((tag) => ({ tag, path: cacheKey })));
+      }
+    }
+  },
+  async refreshTags() {
+    return;
+  },
+  async getExpiration(...tags) {
+    if (globalThis.tagCache.mode === "nextMode") {
+      return globalThis.tagCache.getLastRevalidated(tags);
+    }
+    return 0;
+  },
+  async expireTags(...tags) {
+    if (globalThis.tagCache.mode === "nextMode") {
+      return writeTags(tags);
+    }
+    const tagCache = globalThis.tagCache;
+    const revalidatedAt = Date.now();
+    const pathsToUpdate = await Promise.all(tags.map(async (tag) => {
+      const paths = await tagCache.getByTag(tag);
+      return paths.map((path) => ({
+        path,
+        tag,
+        revalidatedAt
+      }));
+    }));
+    const setToWrite = /* @__PURE__ */ new Set();
+    for (const entry of pathsToUpdate.flat()) {
+      setToWrite.add(entry);
+    }
+    await writeTags(Array.from(setToWrite));
+  },
+  // This one is necessary for older versions of next
+  async receiveExpiredTags(...tags) {
+    return;
+  }
+};

.open-next/.build/composable-cache.cjs

@@ -0,0 +1,206 @@
+// node_modules/@opennextjs/cloudflare/dist/api/cloudflare-context.js
+var cloudflareContextSymbol = Symbol.for("__cloudflare-context__");
+function getCloudflareContext(options = { async: false }) {
+  return options.async ? getCloudflareContextAsync() : getCloudflareContextSync();
+}
+function getCloudflareContextFromGlobalScope() {
+  const global = globalThis;
+  return global[cloudflareContextSymbol];
+}
+function inSSG() {
+  const global = globalThis;
+  return global.__NEXT_DATA__?.nextExport === true;
+}
+function getCloudflareContextSync() {
+  const cloudflareContext = getCloudflareContextFromGlobalScope();
+  if (cloudflareContext) {
+    return cloudflareContext;
+  }
+  if (inSSG()) {
+    throw new Error(`
+
+ERROR: \`getCloudflareContext\` has been called in sync mode in either a static route or at the top level of a non-static one, both cases are not allowed but can be solved by either:
+  - make sure that the call is not at the top level and that the route is not static
+  - call \`getCloudflareContext({async: true})\` to use the \`async\` mode
+  - avoid calling \`getCloudflareContext\` in the route
+`);
+  }
+  throw new Error(initOpenNextCloudflareForDevErrorMsg);
+}
+async function getCloudflareContextAsync() {
+  const cloudflareContext = getCloudflareContextFromGlobalScope();
+  if (cloudflareContext) {
+    return cloudflareContext;
+  }
+  const inNodejsRuntime = process.env.NEXT_RUNTIME === "nodejs";
+  if (inNodejsRuntime || inSSG()) {
+    const cloudflareContext2 = await getCloudflareContextFromWrangler();
+    addCloudflareContextToNodejsGlobal(cloudflareContext2);
+    return cloudflareContext2;
+  }
+  throw new Error(initOpenNextCloudflareForDevErrorMsg);
+}
+function addCloudflareContextToNodejsGlobal(cloudflareContext) {
+  const global = globalThis;
+  global[cloudflareContextSymbol] = cloudflareContext;
+}
+async function getCloudflareContextFromWrangler(options) {
+  const { getPlatformProxy } = await import(
+    /* webpackIgnore: true */
+    `${"__wrangler".replaceAll("_", "")}`
+  );
+  const environment = options?.environment ?? process.env.NEXT_DEV_WRANGLER_ENV;
+  const { env, cf, ctx } = await getPlatformProxy({
+    ...options,
+    environment
+  });
+  return {
+    env,
+    cf,
+    ctx
+  };
+}
+var initOpenNextCloudflareForDevErrorMsg = `
+
+ERROR: \`getCloudflareContext\` has been called without having called \`initOpenNextCloudflareForDev\` from the Next.js config file.
+You should update your Next.js config file as shown below:
+
+   \`\`\`
+   // next.config.mjs
+
+   import { initOpenNextCloudflareForDev } from "@opennextjs/cloudflare";
+
+   initOpenNextCloudflareForDev();
+
+   const nextConfig = { ... };
+   export default nextConfig;
+   \`\`\`
+
+`;
+
+// node_modules/@opennextjs/cloudflare/dist/api/overrides/asset-resolver/index.js
+var resolver = {
+  name: "cloudflare-asset-resolver",
+  async maybeGetAssetResult(event) {
+    const { ASSETS } = getCloudflareContext().env;
+    if (!ASSETS || !isUserWorkerFirst(globalThis.__ASSETS_RUN_WORKER_FIRST__, event.rawPath)) {
+      return void 0;
+    }
+    const { method, headers } = event;
+    if (method !== "GET" && method != "HEAD") {
+      return void 0;
+    }
+    const url = new URL(event.rawPath, "https://assets.local");
+    const response = await ASSETS.fetch(url, {
+      headers,
+      method
+    });
+    if (response.status === 404) {
+      await response.body?.cancel();
+      return void 0;
+    }
+    return {
+      type: "core",
+      statusCode: response.status,
+      headers: Object.fromEntries(response.headers.entries()),
+      // Workers and Node types differ.
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      body: response.body || new ReadableStream(),
+      isBase64Encoded: false
+    };
+  }
+};
+function isUserWorkerFirst(runWorkerFirst, pathname) {
+  if (!Array.isArray(runWorkerFirst)) {
+    return runWorkerFirst ?? false;
+  }
+  let hasPositiveMatch = false;
+  for (let rule of runWorkerFirst) {
+    let isPositiveRule = true;
+    if (rule.startsWith("!")) {
+      rule = rule.slice(1);
+      isPositiveRule = false;
+    } else if (hasPositiveMatch) {
+      continue;
+    }
+    const match = new RegExp(`^${rule.replace(/([[\]().*+?^$|{}\\])/g, "\\$1").replace("\\*", ".*")}$`).test(pathname);
+    if (match) {
+      if (isPositiveRule) {
+        hasPositiveMatch = true;
+      } else {
+        return false;
+      }
+    }
+  }
+  return hasPositiveMatch;
+}
+var asset_resolver_default = resolver;
+
+// node_modules/@opennextjs/cloudflare/dist/api/config.js
+function defineCloudflareConfig(config = {}) {
+  const { incrementalCache, tagCache, queue, cachePurge, enableCacheInterception = false, routePreloadingBehavior = "none" } = config;
+  return {
+    default: {
+      override: {
+        wrapper: "cloudflare-node",
+        converter: "edge",
+        proxyExternalRequest: "fetch",
+        incrementalCache: resolveIncrementalCache(incrementalCache),
+        tagCache: resolveTagCache(tagCache),
+        queue: resolveQueue(queue),
+        cdnInvalidation: resolveCdnInvalidation(cachePurge)
+      },
+      routePreloadingBehavior
+    },
+    // node:crypto is used to compute cache keys
+    edgeExternals: ["node:crypto"],
+    cloudflare: {
+      useWorkerdCondition: true
+    },
+    dangerous: {
+      enableCacheInterception
+    },
+    middleware: {
+      external: true,
+      override: {
+        wrapper: "cloudflare-edge",
+        converter: "edge",
+        proxyExternalRequest: "fetch",
+        incrementalCache: resolveIncrementalCache(incrementalCache),
+        tagCache: resolveTagCache(tagCache),
+        queue: resolveQueue(queue)
+      },
+      assetResolver: () => asset_resolver_default
+    }
+  };
+}
+function resolveIncrementalCache(value = "dummy") {
+  if (typeof value === "string") {
+    return value;
+  }
+  return typeof value === "function" ? value : () => value;
+}
+function resolveTagCache(value = "dummy") {
+  if (typeof value === "string") {
+    return value;
+  }
+  return typeof value === "function" ? value : () => value;
+}
+function resolveQueue(value = "dummy") {
+  if (typeof value === "string") {
+    return value;
+  }
+  return typeof value === "function" ? value : () => value;
+}
+function resolveCdnInvalidation(value = "dummy") {
+  if (typeof value === "string") {
+    return value;
+  }
+  return typeof value === "function" ? value : () => value;
+}
+
+// open-next.config.ts
+var open_next_config_default = defineCloudflareConfig();
+export {
+  open_next_config_default as default
+};