@edgeone/nuxt-pages 1.0.0

package/dist/run/storage/storage.cjs

@@ -0,0 +1,191 @@
+"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/storage.cts
+var storage_exports = {};
+__export(storage_exports, {
+  getMemoizedKeyValueStoreBackedByRegionalBlobStore: () => getMemoizedKeyValueStoreBackedByRegionalBlobStore,
+  setFetchBeforeNuxtPatchedIt: () => setFetchBeforeNuxtPatchedIt,
+  setInMemoryCacheMaxSizeFromNuxtConfig: () => setInMemoryCacheMaxSizeFromNuxtConfig
+});
+module.exports = __toCommonJS(storage_exports);
+
+// node_modules/lru-cache/dist/esm/index.js
+var perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+var PROCESS = typeof process === "object" && !!process ? process : {};
+var emitWarning = (msg, type, code, fn) => {
+  typeof PROCESS.emitWarning === "function" ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
+};
+var AC = globalThis.AbortController;
+var AS = globalThis.AbortSignal;
+if (typeof AC === "undefined") {
+  AS = class AbortSignal {
+    onabort;
+    _onabort = [];
+    reason;
+    aborted = false;
+    addEventListener(_, fn) {
+      this._onabort.push(fn);
+    }
+  };
+  AC = class AbortController {
+    constructor() {
+      warnACPolyfill();
+    }
+    signal = new AS();
+    abort(reason) {
+      if (this.signal.aborted)
+        return;
+      this.signal.reason = reason;
+      this.signal.aborted = true;
+      for (const fn of this.signal._onabort) {
+        fn(reason);
+      }
+      this.signal.onabort?.(reason);
+    }
+  };
+  let printACPolyfillWarning = PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
+  const warnACPolyfill = () => {
+    if (!printACPolyfillWarning)
+      return;
+    printACPolyfillWarning = false;
+    emitWarning("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", warnACPolyfill);
+  };
+}
+var TYPE = Symbol("type");
+
+// node_modules/@netlify/functions/dist/internal.js
+var import_process = require("process");
+var systemLogTag = "__nfSystemLog";
+var serializeError = (error) => {
+  const cause = error?.cause instanceof Error ? serializeError(error.cause) : error.cause;
+  return {
+    error: error.message,
+    error_cause: cause,
+    error_stack: error.stack
+  };
+};
+var SystemLogger = class _SystemLogger {
+  fields;
+  logLevel;
+  constructor(fields = {}, logLevel = 2) {
+    this.fields = fields;
+    this.logLevel = logLevel;
+  }
+  doLog(logger, message) {
+    if (import_process.env.NETLIFY_DEV && !import_process.env.NETLIFY_ENABLE_SYSTEM_LOGGING) {
+      return;
+    }
+    logger(systemLogTag, JSON.stringify({ msg: message, fields: this.fields }));
+  }
+  log(message) {
+    if (this.logLevel > 2) {
+      return;
+    }
+    this.doLog(console.log, message);
+  }
+  debug(message) {
+    if (this.logLevel > 1) {
+      return;
+    }
+    this.doLog(console.debug, message);
+  }
+  error(message) {
+    if (this.logLevel > 3) {
+      return;
+    }
+    this.doLog(console.error, message);
+  }
+  withLogLevel(level) {
+    return new _SystemLogger(this.fields, level);
+  }
+  withFields(fields) {
+    return new _SystemLogger(
+      {
+        ...this.fields,
+        ...fields
+      },
+      this.logLevel
+    );
+  }
+  withError(error) {
+    const fields = error instanceof Error ? serializeError(error) : { error };
+    return this.withFields(fields);
+  }
+};
+var systemLogger = new SystemLogger();
+
+// src/run/handlers/request-context.cts
+var REQUEST_CONTEXT_GLOBAL_KEY = Symbol.for("nf-request-context-async-local-storage");
+var REQUEST_COUNTER_KEY = Symbol.for("nf-request-counter");
+
+// src/run/storage/request-scoped-in-memory-cache.cts
+var NullValue = Symbol.for("null-value");
+var IN_MEMORY_CACHE_MAX_SIZE = Symbol.for("nf-in-memory-cache-max-size");
+var IN_MEMORY_LRU_CACHE = Symbol.for("nf-in-memory-lru-cache");
+var extendedGlobalThis = globalThis;
+var DEFAULT_FALLBACK_MAX_SIZE = 50 * 1024 * 1024;
+function setInMemoryCacheMaxSizeFromNuxtConfig(size) {
+  if (typeof size === "number") {
+    extendedGlobalThis[IN_MEMORY_CACHE_MAX_SIZE] = size;
+  }
+}
+
+// src/run/storage/regional-blob-store.cts
+var FETCH_BEFORE_NUXT_PATCHED_IT = Symbol.for("nf-not-patched-fetch");
+var extendedGlobalThis2 = globalThis;
+function attemptToGetOriginalFetch(fetch) {
+  return fetch._nuxtOriginalFetch ?? 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 setFetchBeforeNuxtPatchedIt = (fetch) => {
+  extendedGlobalThis2[FETCH_BEFORE_NUXT_PATCHED_IT] = forceOptOutOfUsingDataCache(
+    attemptToGetOriginalFetch(fetch)
+  );
+};
+var fetchBeforeNuxtPatchedItFallback = forceOptOutOfUsingDataCache(
+  attemptToGetOriginalFetch(globalThis.fetch)
+);
+
+// src/run/storage/storage.cts
+var getMemoizedKeyValueStoreBackedByRegionalBlobStore = (...args) => {
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMemoizedKeyValueStoreBackedByRegionalBlobStore,
+  setFetchBeforeNuxtPatchedIt,
+  setInMemoryCacheMaxSizeFromNuxtConfig
+});

package/dist/shared/blob-types.cjs

@@ -0,0 +1,37 @@
+"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/shared/blob-types.cts
+var blob_types_exports = {};
+__export(blob_types_exports, {
+  isHtmlBlob: () => isHtmlBlob,
+  isTagManifest: () => isTagManifest
+});
+module.exports = __toCommonJS(blob_types_exports);
+var isTagManifest = (value) => {
+  return typeof value === "object" && value !== null && "revalidatedAt" in value && typeof value.revalidatedAt === "number" && Object.keys(value).length === 1;
+};
+var isHtmlBlob = (value) => {
+  return typeof value === "object" && value !== null && "html" in value && "isFullyStaticPage" in value && typeof value.html === "string" && typeof value.isFullyStaticPage === "boolean" && Object.keys(value).length === 2;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isHtmlBlob,
+  isTagManifest
+});

package/dist/shared/blobkey.js

@@ -0,0 +1,25 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import "../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/shared/blobkey.ts
+import { Buffer } from "node:buffer";
+import { webcrypto as crypto } from "node:crypto";
+var maxLength = 180;
+async function encodeBlobKey(key) {
+  const buffer = Buffer.from(key);
+  const base64 = buffer.toString("base64url");
+  if (base64.length <= maxLength) {
+    return base64;
+  }
+  const digest = await crypto.subtle.digest("SHA-256", buffer);
+  const hash = Buffer.from(digest).toString("base64url");
+  return `${base64.slice(0, maxLength - hash.length - 1)}-${hash}`;
+}
+export {
+  encodeBlobKey
+};

package/dist/shared/cache-types.cjs

@@ -0,0 +1,33 @@
+"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/shared/cache-types.cts
+var cache_types_exports = {};
+__export(cache_types_exports, {
+  isCachedPageValue: () => isCachedPageValue,
+  isCachedRouteValue: () => isCachedRouteValue
+});
+module.exports = __toCommonJS(cache_types_exports);
+var isCachedPageValue = (value) => value.kind === "PAGE" || value.kind === "PAGES";
+var isCachedRouteValue = (value) => value.kind === "ROUTE" || value.kind === "APP_ROUTE";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isCachedPageValue,
+  isCachedRouteValue
+});

package/dist/shared/nuxt-cache-types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/shared/nuxt-cache-types.cts
+var nuxt_cache_types_exports = {};
+module.exports = __toCommonJS(nuxt_cache_types_exports);

package/dist/types/options.js

@@ -0,0 +1,6 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    

package/dist/utils.js

@@ -0,0 +1,25 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  addCodeToGenerateEdgeoneWithAST,
+  getHandlersArrayWithAST,
+  getModulesWithAST,
+  getPrerenderRoutesWithAST,
+  getRouteRulesWithAST,
+  getRoutesArrayWithAST,
+  resetNitroConfigWithAST
+} from "./esm-chunks/chunk-GX4Z7KQX.js";
+import "./esm-chunks/chunk-6BT4RYQJ.js";
+export {
+  addCodeToGenerateEdgeoneWithAST,
+  getHandlersArrayWithAST,
+  getModulesWithAST,
+  getPrerenderRoutesWithAST,
+  getRouteRulesWithAST,
+  getRoutesArrayWithAST,
+  resetNitroConfigWithAST
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@edgeone/nuxt-pages",
+  "version": "1.0.0",
+  "main": "./dist/index.js",
+  "scripts": {
+    "test": "ts-node src/test.ts",
+    "build": "node ./tools/build.js",
+    "build:watch": "node ./tools/build.js --watch",
+    "start": "node dist/index.js",
+    "audit": "npm audit",
+    "audit:fix": "npm audit fix",
+    "security": "npm audit && npm outdated"
+  },
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "nuxt",
+    "deploy",
+    "edgeone"
+  ],
+  "author": "Venzil",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/q153877011/edgeone-nuxt-deploy.git"
+  },
+  "bugs": {
+    "url": "https://github.com/q153877011/edgeone-nuxt-deploy/issues"
+  },
+  "homepage": "https://github.com/q153877011/edgeone-nuxt-deploy#readme",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@babel/parser": "^7.28.4",
+    "@babel/traverse": "^7.28.4",
+    "@babel/types": "^7.28.4",
+    "@netlify/functions": "^3.1.10",
+    "@nuxt/kit": "^3.14.0",
+    "@opentelemetry/api": "^1.9.0",
+    "fast-glob": "^3.3.3",
+    "lru-cache": "^10.4.3",
+    "vitest": "^3.2.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.23",
+    "@types/picomatch": "^3.0.2",
+    "@types/uuid": "^10.0.0",
+    "esbuild": "^0.25.11",
+    "execa": "^8.0.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}