nitropack-nightly 2.10.0-28638494.93d002b7 → 3.0.0-beta-28638602.1fe7b893-nitro-nightly-mirror

package/dist/presets/zeabur/preset.mjs

@@ -1,70 +0,0 @@
-import fsp from "node:fs/promises";
-import { dirname, relative, resolve } from "pathe";
-import { writeFile } from "nitropack/kit";
-import { defineNitroPreset } from "nitropack/kit";
-const zeabur = defineNitroPreset(
-  {
-    extends: "node",
-    entry: "./runtime/zeabur",
-    output: {
-      dir: "{{ rootDir }}/.zeabur/output",
-      serverDir: "{{ output.dir }}/functions/__nitro.func",
-      publicDir: "{{ output.dir }}/static"
-    },
-    hooks: {
-      async compiled(nitro) {
-        const buildConfigPath = resolve(
-          nitro.options.output.dir,
-          "config.json"
-        );
-        const cfg = {
-          containerized: false,
-          routes: [{ src: ".*", dest: "/__nitro" }]
-        };
-        await writeFile(buildConfigPath, JSON.stringify(cfg, null, 2));
-        for (const [key, value] of Object.entries(nitro.options.routeRules)) {
-          if (!value.isr) {
-            continue;
-          }
-          const funcPrefix = resolve(
-            nitro.options.output.serverDir,
-            ".." + key
-          );
-          await fsp.mkdir(dirname(funcPrefix), { recursive: true });
-          await fsp.symlink(
-            "./" + relative(dirname(funcPrefix), nitro.options.output.serverDir),
-            funcPrefix + ".func",
-            "junction"
-          );
-          await writeFile(
-            funcPrefix + ".prerender-config.json",
-            JSON.stringify({ type: "Prerender" })
-          );
-        }
-      }
-    }
-  },
-  {
-    name: "zeabur",
-    stdName: "zeabur",
-    url: import.meta.url
-  }
-);
-const zeaburStatic = defineNitroPreset(
-  {
-    extends: "static",
-    output: {
-      dir: "{{ rootDir }}/.zeabur/output",
-      publicDir: "{{ output.dir }}/static"
-    },
-    commands: {
-      preview: "npx serve ./static"
-    }
-  },
-  {
-    name: "zeabur-static",
-    url: import.meta.url,
-    static: true
-  }
-);
-export default [zeabur, zeaburStatic];

package/dist/presets/zeabur/runtime/zeabur.d.ts

@@ -1,4 +0,0 @@
-import "#nitro-internal-pollyfills";
-import { NodeListener } from "h3";
-declare const listener: NodeListener;
-export default listener;

package/dist/presets/zeabur/runtime/zeabur.mjs

@@ -1,8 +0,0 @@
-import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitropack/runtime";
-import { toNodeListener } from "h3";
-const handler = toNodeListener(useNitroApp().h3App);
-const listener = function(req, res) {
-  return handler(req, res);
-};
-export default listener;

package/dist/runtime/app.d.ts

@@ -1,2 +0,0 @@
-export { useNitroApp } from "./internal/app";
-export type { NitroApp } from "nitropack/types";

package/dist/runtime/app.mjs

@@ -1 +0,0 @@
-export { useNitroApp } from "./internal/app.mjs";

package/dist/runtime/cache.d.ts

@@ -1 +0,0 @@
-export { cachedEventHandler, cachedFunction, defineCachedEventHandler, defineCachedFunction, } from "./internal/cache";

package/dist/runtime/cache.mjs

@@ -1,6 +0,0 @@
-export {
-  cachedEventHandler,
-  cachedFunction,
-  defineCachedEventHandler,
-  defineCachedFunction
-} from "./internal/cache.mjs";

package/dist/runtime/config.d.ts

@@ -1 +0,0 @@
-export { useAppConfig, useRuntimeConfig } from "./internal/config";

package/dist/runtime/config.mjs

@@ -1 +0,0 @@
-export { useAppConfig, useRuntimeConfig } from "./internal/config.mjs";

package/dist/runtime/context.d.ts

@@ -1 +0,0 @@
-export { useEvent } from "./internal/context";

package/dist/runtime/context.mjs

@@ -1 +0,0 @@
-export { useEvent } from "./internal/context.mjs";

package/dist/runtime/database.d.ts

@@ -1 +0,0 @@
-export { useDatabase } from "./internal/database";

package/dist/runtime/database.mjs

@@ -1 +0,0 @@
-export { useDatabase } from "./internal/database.mjs";

package/dist/runtime/error.d.ts

@@ -1 +0,0 @@
-export { default } from "./internal/error";

package/dist/runtime/error.mjs

@@ -1 +0,0 @@
-export { default } from "./internal/error.mjs";

package/dist/runtime/internal/app.d.ts

@@ -1,3 +0,0 @@
-import type { NitroApp } from "nitropack/types";
-export declare const nitroApp: NitroApp;
-export declare const useNitroApp: () => NitroApp;

package/dist/runtime/internal/app.mjs

@@ -1,152 +0,0 @@
-import {
-  createApp,
-  createRouter,
-  eventHandler,
-  lazyEventHandler,
-  toNodeListener,
-  fetchWithEvent,
-  isEvent
-} from "h3";
-import { createFetch, Headers } from "ofetch";
-import destr from "destr";
-import {
-  createCall,
-  createFetch as createLocalFetch
-} from "unenv/runtime/fetch/index";
-import { createHooks } from "hookable";
-import { useRuntimeConfig } from "./config.mjs";
-import { cachedEventHandler } from "./cache.mjs";
-import { normalizeFetchResponse } from "./utils.mjs";
-import { createRouteRulesHandler, getRouteRulesForPath } from "./route-rules.mjs";
-import { nitroAsyncContext } from "./context.mjs";
-import { plugins } from "#nitro-internal-virtual/plugins";
-import errorHandler from "#nitro-internal-virtual/error-handler";
-import { handlers } from "#nitro-internal-virtual/server-handlers";
-function createNitroApp() {
-  const config = useRuntimeConfig();
-  const hooks = createHooks();
-  const captureError = (error, context = {}) => {
-    const promise = hooks.callHookParallel("error", error, context).catch((error_) => {
-      console.error("Error while capturing another error", error_);
-    });
-    if (context.event && isEvent(context.event)) {
-      const errors = context.event.context.nitro?.errors;
-      if (errors) {
-        errors.push({ error, context });
-      }
-      if (context.event.waitUntil) {
-        context.event.waitUntil(promise);
-      }
-    }
-  };
-  const h3App = createApp({
-    debug: destr(process.env.DEBUG),
-    onError: (error, event) => {
-      captureError(error, { event, tags: ["request"] });
-      return errorHandler(error, event);
-    },
-    onRequest: async (event) => {
-      await nitroApp.hooks.callHook("request", event).catch((error) => {
-        captureError(error, { event, tags: ["request"] });
-      });
-    },
-    onBeforeResponse: async (event, response) => {
-      await nitroApp.hooks.callHook("beforeResponse", event, response).catch((error) => {
-        captureError(error, { event, tags: ["request", "response"] });
-      });
-    },
-    onAfterResponse: async (event, response) => {
-      await nitroApp.hooks.callHook("afterResponse", event, response).catch((error) => {
-        captureError(error, { event, tags: ["request", "response"] });
-      });
-    }
-  });
-  const router = createRouter({
-    preemptive: true
-  });
-  const localCall = createCall(toNodeListener(h3App));
-  const _localFetch = createLocalFetch(localCall, globalThis.fetch);
-  const localFetch = (input, init) => _localFetch(input, init).then(
-    (response) => normalizeFetchResponse(response)
-  );
-  const $fetch = createFetch({
-    fetch: localFetch,
-    Headers,
-    defaults: { baseURL: config.app.baseURL }
-  });
-  globalThis.$fetch = $fetch;
-  h3App.use(createRouteRulesHandler({ localFetch }));
-  h3App.use(
-    eventHandler((event) => {
-      event.context.nitro = event.context.nitro || { errors: [] };
-      const envContext = event.node.req?.__unenv__;
-      if (envContext) {
-        Object.assign(event.context, envContext);
-      }
-      event.fetch = (req, init) => fetchWithEvent(event, req, init, { fetch: localFetch });
-      event.$fetch = (req, init) => fetchWithEvent(event, req, init, {
-        fetch: $fetch
-      });
-      event.waitUntil = (promise) => {
-        if (!event.context.nitro._waitUntilPromises) {
-          event.context.nitro._waitUntilPromises = [];
-        }
-        event.context.nitro._waitUntilPromises.push(promise);
-        if (envContext?.waitUntil) {
-          envContext.waitUntil(promise);
-        }
-      };
-      event.captureError = (error, context) => {
-        captureError(error, { event, ...context });
-      };
-    })
-  );
-  for (const h of handlers) {
-    let handler = h.lazy ? lazyEventHandler(h.handler) : h.handler;
-    if (h.middleware || !h.route) {
-      const middlewareBase = (config.app.baseURL + (h.route || "/")).replace(
-        /\/+/g,
-        "/"
-      );
-      h3App.use(middlewareBase, handler);
-    } else {
-      const routeRules = getRouteRulesForPath(
-        h.route.replace(/:\w+|\*\*/g, "_")
-      );
-      if (routeRules.cache) {
-        handler = cachedEventHandler(handler, {
-          group: "nitro/routes",
-          ...routeRules.cache
-        });
-      }
-      router.use(h.route, handler, h.method);
-    }
-  }
-  h3App.use(config.app.baseURL, router.handler);
-  if (import.meta._asyncContext) {
-    const _handler = h3App.handler;
-    h3App.handler = (event) => {
-      const ctx = { event };
-      return nitroAsyncContext.callAsync(ctx, () => _handler(event));
-    };
-  }
-  const app = {
-    hooks,
-    h3App,
-    router,
-    localCall,
-    localFetch,
-    captureError
-  };
-  for (const plugin of plugins) {
-    try {
-      plugin(app);
-    } catch (error) {
-      captureError(error, { tags: ["plugin"] });
-      throw error;
-    }
-  }
-  return app;
-}
-export const nitroApp = createNitroApp();
-export const useNitroApp = () => nitroApp;

package/dist/runtime/internal/cache.d.ts

@@ -1,8 +0,0 @@
-import { EventHandler } from "h3";
-import type { EventHandlerRequest, EventHandlerResponse } from "h3";
-import type { CacheOptions, CachedEventHandlerOptions } from "nitropack/types";
-export declare function defineCachedFunction<T, ArgsT extends unknown[] = any[]>(fn: (...args: ArgsT) => T | Promise<T>, opts?: CacheOptions<T>): (...args: ArgsT) => Promise<T | undefined>;
-export declare const cachedFunction: typeof defineCachedFunction;
-export declare function defineCachedEventHandler<Request extends EventHandlerRequest = EventHandlerRequest, Response = EventHandlerResponse>(handler: EventHandler<Request, Response>, opts?: CachedEventHandlerOptions<Response>): EventHandler<Omit<Request, "body">, Response>;
-export declare function defineCachedEventHandler<Request = Omit<EventHandlerRequest, "body">, Response = EventHandlerResponse>(handler: EventHandler<Request extends EventHandlerRequest ? Request : EventHandlerRequest, Request extends EventHandlerRequest ? Response : Request>, opts?: CachedEventHandlerOptions<Request extends EventHandlerRequest ? Response : Request>): EventHandler<Request extends EventHandlerRequest ? Request : EventHandlerRequest, Request extends EventHandlerRequest ? Response : Request>;
-export declare const cachedEventHandler: typeof defineCachedEventHandler;

package/dist/runtime/internal/cache.mjs

@@ -1,329 +0,0 @@
-import { hash } from "ohash";
-import {
-  handleCacheHeaders,
-  defineEventHandler,
-  createEvent,
-  isEvent,
-  splitCookiesString,
-  fetchWithEvent
-} from "h3";
-import { parseURL } from "ufo";
-import { useStorage } from "./storage.mjs";
-import { useNitroApp } from "./app.mjs";
-const defaultCacheOptions = {
-  name: "_",
-  base: "/cache",
-  swr: true,
-  maxAge: 1
-};
-export function defineCachedFunction(fn, opts = {}) {
-  opts = { ...defaultCacheOptions, ...opts };
-  const pending = {};
-  const group = opts.group || "nitro/functions";
-  const name = opts.name || fn.name || "_";
-  const integrity = opts.integrity || hash([fn, opts]);
-  const validate = opts.validate || ((entry) => entry.value !== void 0);
-  async function get(key, resolver, shouldInvalidateCache, event) {
-    const cacheKey = [opts.base, group, name, key + ".json"].filter(Boolean).join(":").replace(/:\/$/, ":index");
-    let entry = await useStorage().getItem(cacheKey) || {};
-    if (typeof entry !== "object") {
-      entry = {};
-      const error = new Error("Malformed data read from cache.");
-      console.error("[nitro] [cache]", error);
-      useNitroApp().captureError(error, { event, tags: ["cache"] });
-    }
-    const ttl = (opts.maxAge ?? opts.maxAge ?? 0) * 1e3;
-    if (ttl) {
-      entry.expires = Date.now() + ttl;
-    }
-    const expired = shouldInvalidateCache || entry.integrity !== integrity || ttl && Date.now() - (entry.mtime || 0) > ttl || validate(entry) === false;
-    const _resolve = async () => {
-      const isPending = pending[key];
-      if (!isPending) {
-        if (entry.value !== void 0 && (opts.staleMaxAge || 0) >= 0 && opts.swr === false) {
-          entry.value = void 0;
-          entry.integrity = void 0;
-          entry.mtime = void 0;
-          entry.expires = void 0;
-        }
-        pending[key] = Promise.resolve(resolver());
-      }
-      try {
-        entry.value = await pending[key];
-      } catch (error) {
-        if (!isPending) {
-          delete pending[key];
-        }
-        throw error;
-      }
-      if (!isPending) {
-        entry.mtime = Date.now();
-        entry.integrity = integrity;
-        delete pending[key];
-        if (validate(entry) !== false) {
-          const promise = useStorage().setItem(cacheKey, entry).catch((error) => {
-            console.error(`[nitro] [cache] Cache write error.`, error);
-            useNitroApp().captureError(error, { event, tags: ["cache"] });
-          });
-          if (event && event.waitUntil) {
-            event.waitUntil(promise);
-          }
-        }
-      }
-    };
-    const _resolvePromise = expired ? _resolve() : Promise.resolve();
-    if (entry.value === void 0) {
-      await _resolvePromise;
-    } else if (expired && event && event.waitUntil) {
-      event.waitUntil(_resolvePromise);
-    }
-    if (opts.swr && validate(entry) !== false) {
-      _resolvePromise.catch((error) => {
-        console.error(`[nitro] [cache] SWR handler error.`, error);
-        useNitroApp().captureError(error, { event, tags: ["cache"] });
-      });
-      return entry;
-    }
-    return _resolvePromise.then(() => entry);
-  }
-  return async (...args) => {
-    const shouldBypassCache = await opts.shouldBypassCache?.(...args);
-    if (shouldBypassCache) {
-      return fn(...args);
-    }
-    const key = await (opts.getKey || getKey)(...args);
-    const shouldInvalidateCache = await opts.shouldInvalidateCache?.(...args);
-    const entry = await get(
-      key,
-      () => fn(...args),
-      shouldInvalidateCache,
-      args[0] && isEvent(args[0]) ? args[0] : void 0
-    );
-    let value = entry.value;
-    if (opts.transform) {
-      value = await opts.transform(entry, ...args) || value;
-    }
-    return value;
-  };
-}
-export const cachedFunction = defineCachedFunction;
-function getKey(...args) {
-  return args.length > 0 ? hash(args, {}) : "";
-}
-function escapeKey(key) {
-  return String(key).replace(/\W/g, "");
-}
-export function defineCachedEventHandler(handler, opts = defaultCacheOptions) {
-  const variableHeaderNames = (opts.varies || []).filter(Boolean).map((h) => h.toLowerCase()).sort();
-  const _opts = {
-    ...opts,
-    getKey: async (event) => {
-      const customKey = await opts.getKey?.(event);
-      if (customKey) {
-        return escapeKey(customKey);
-      }
-      const _path = event.node.req.originalUrl || event.node.req.url || event.path;
-      const _pathname = escapeKey(decodeURI(parseURL(_path).pathname)).slice(0, 16) || "index";
-      const _hashedPath = `${_pathname}.${hash(_path)}`;
-      const _headers = variableHeaderNames.map((header) => [header, event.node.req.headers[header]]).map(([name, value]) => `${escapeKey(name)}.${hash(value)}`);
-      return [_hashedPath, ..._headers].join(":");
-    },
-    validate: (entry) => {
-      if (!entry.value) {
-        return false;
-      }
-      if (entry.value.code >= 400) {
-        return false;
-      }
-      if (entry.value.body === void 0) {
-        return false;
-      }
-      if (entry.value.headers.etag === "undefined" || entry.value.headers["last-modified"] === "undefined") {
-        return false;
-      }
-      return true;
-    },
-    group: opts.group || "nitro/handlers",
-    integrity: opts.integrity || hash([handler, opts])
-  };
-  const _cachedHandler = cachedFunction(
-    async (incomingEvent) => {
-      const variableHeaders = {};
-      for (const header of variableHeaderNames) {
-        const value = incomingEvent.node.req.headers[header];
-        if (value !== void 0) {
-          variableHeaders[header] = value;
-        }
-      }
-      const reqProxy = cloneWithProxy(incomingEvent.node.req, {
-        headers: variableHeaders
-      });
-      const resHeaders = {};
-      let _resSendBody;
-      const resProxy = cloneWithProxy(incomingEvent.node.res, {
-        statusCode: 200,
-        writableEnded: false,
-        writableFinished: false,
-        headersSent: false,
-        closed: false,
-        getHeader(name) {
-          return resHeaders[name];
-        },
-        setHeader(name, value) {
-          resHeaders[name] = value;
-          return this;
-        },
-        getHeaderNames() {
-          return Object.keys(resHeaders);
-        },
-        hasHeader(name) {
-          return name in resHeaders;
-        },
-        removeHeader(name) {
-          delete resHeaders[name];
-        },
-        getHeaders() {
-          return resHeaders;
-        },
-        end(chunk, arg2, arg3) {
-          if (typeof chunk === "string") {
-            _resSendBody = chunk;
-          }
-          if (typeof arg2 === "function") {
-            arg2();
-          }
-          if (typeof arg3 === "function") {
-            arg3();
-          }
-          return this;
-        },
-        write(chunk, arg2, arg3) {
-          if (typeof chunk === "string") {
-            _resSendBody = chunk;
-          }
-          if (typeof arg2 === "function") {
-            arg2(void 0);
-          }
-          if (typeof arg3 === "function") {
-            arg3();
-          }
-          return true;
-        },
-        writeHead(statusCode, headers2) {
-          this.statusCode = statusCode;
-          if (headers2) {
-            if (Array.isArray(headers2) || typeof headers2 === "string") {
-              throw new TypeError("Raw headers  is not supported.");
-            }
-            for (const header in headers2) {
-              const value = headers2[header];
-              if (value !== void 0) {
-                this.setHeader(
-                  header,
-                  value
-                );
-              }
-            }
-          }
-          return this;
-        }
-      });
-      const event = createEvent(reqProxy, resProxy);
-      event.fetch = (url, fetchOptions) => fetchWithEvent(event, url, fetchOptions, {
-        fetch: useNitroApp().localFetch
-      });
-      event.$fetch = (url, fetchOptions) => fetchWithEvent(event, url, fetchOptions, {
-        fetch: globalThis.$fetch
-      });
-      event.context = incomingEvent.context;
-      event.context.cache = {
-        options: _opts
-      };
-      const body = await handler(event) || _resSendBody;
-      const headers = event.node.res.getHeaders();
-      headers.etag = String(
-        headers.Etag || headers.etag || `W/"${hash(body)}"`
-      );
-      headers["last-modified"] = String(
-        headers["Last-Modified"] || headers["last-modified"] || (/* @__PURE__ */ new Date()).toUTCString()
-      );
-      const cacheControl = [];
-      if (opts.swr) {
-        if (opts.maxAge) {
-          cacheControl.push(`s-maxage=${opts.maxAge}`);
-        }
-        if (opts.staleMaxAge) {
-          cacheControl.push(`stale-while-revalidate=${opts.staleMaxAge}`);
-        } else {
-          cacheControl.push("stale-while-revalidate");
-        }
-      } else if (opts.maxAge) {
-        cacheControl.push(`max-age=${opts.maxAge}`);
-      }
-      if (cacheControl.length > 0) {
-        headers["cache-control"] = cacheControl.join(", ");
-      }
-      const cacheEntry = {
-        code: event.node.res.statusCode,
-        headers,
-        body
-      };
-      return cacheEntry;
-    },
-    _opts
-  );
-  return defineEventHandler(async (event) => {
-    if (opts.headersOnly) {
-      if (handleCacheHeaders(event, { maxAge: opts.maxAge })) {
-        return;
-      }
-      return handler(event);
-    }
-    const response = await _cachedHandler(
-      event
-    );
-    if (event.node.res.headersSent || event.node.res.writableEnded) {
-      return response.body;
-    }
-    if (handleCacheHeaders(event, {
-      modifiedTime: new Date(response.headers["last-modified"]),
-      etag: response.headers.etag,
-      maxAge: opts.maxAge
-    })) {
-      return;
-    }
-    event.node.res.statusCode = response.code;
-    for (const name in response.headers) {
-      const value = response.headers[name];
-      if (name === "set-cookie") {
-        event.node.res.appendHeader(
-          name,
-          splitCookiesString(value)
-        );
-      } else {
-        if (value !== void 0) {
-          event.node.res.setHeader(name, value);
-        }
-      }
-    }
-    return response.body;
-  });
-}
-function cloneWithProxy(obj, overrides) {
-  return new Proxy(obj, {
-    get(target, property, receiver) {
-      if (property in overrides) {
-        return overrides[property];
-      }
-      return Reflect.get(target, property, receiver);
-    },
-    set(target, property, value, receiver) {
-      if (property in overrides) {
-        overrides[property] = value;
-        return true;
-      }
-      return Reflect.set(target, property, value, receiver);
-    }
-  });
-}
-export const cachedEventHandler = defineCachedEventHandler;

package/dist/runtime/internal/client.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/runtime/internal/client.mjs

@@ -1,4 +0,0 @@
-import { $fetch } from "ofetch";
-if (!globalThis.$fetch) {
-  globalThis.$fetch = $fetch;
-}

package/dist/runtime/internal/config.d.ts

@@ -1,6 +0,0 @@
-import { H3Event } from "h3";
-import type { NitroRuntimeConfig } from "nitropack/types";
-export declare function useRuntimeConfig<T extends NitroRuntimeConfig = NitroRuntimeConfig>(event?: H3Event): T;
-export declare function useAppConfig(event?: H3Event): any;
-declare const _default: any;
-export default _default;