@universal-middleware/sirv/dist/universal-elysia-middleware-middleware.js

Universal static file serving middleware

import { attachUniversal, bindUniversal, universalSymbol, getAdapterRuntime, serveStatic, isBodyInit, cloneRequest } from './chunk-ZWGVEH2Z.js';
import { Elysia } from 'elysia';

var contextSymbol = Symbol.for("unContext");
var pendingSymbol = Symbol.for("unPending");
var pendingHandledSymbol = Symbol.for("unPendingHandled");
function cloneRequestWithBody(request, body) {
  let bodyInit = void 0;
  if (isBodyInit(body)) {
    bodyInit = body;
  } else if (typeof body === "object" && body !== null) {
    bodyInit = JSON.stringify(body);
  }
  return cloneRequest(request, { body: bodyInit });
}
function createMiddleware(middlewareFactory) {
  return (...args) => {
    const middleware = middlewareFactory(...args);
    return attachUniversal(
      middleware,
      new Elysia().use(initPlugin()).onBeforeHandle((elysiaContext1) => {
        return bindUniversal(
          middleware,
          async function universalMiddlewareElysia(elysiaContext) {
            const response = await this[universalSymbol](
              cloneRequestWithBody(elysiaContext.request, elysiaContext.body),
              elysiaContext.getContext(),
              getRuntime(elysiaContext)
            );
            if (typeof response === "function") {
              elysiaContext[pendingSymbol].push(response);
            } else if (response !== null && typeof response === "object") {
              if (response instanceof Response) {
                return response;
              }
              elysiaContext.setContext(response);
            }
          }
        )(elysiaContext1);
      }).onAfterHandle(async (elysiaContext) => {
        if (elysiaContext[pendingHandledSymbol]) return;
        Object.defineProperty(elysiaContext, pendingHandledSymbol, {
          value: true
        });
        let currentResponse = elysiaContext.response;
        for (const p of elysiaContext[pendingSymbol]) {
          const res = await p(currentResponse);
          if (res) {
            currentResponse = res;
          }
        }
        return currentResponse;
      }).as("plugin")
    );
  };
}
function initPlugin() {
  return new Elysia({ name: "universal-middleware-context" }).derive(() => {
    return {
      [contextSymbol]: {},
      [pendingSymbol]: [],
      [pendingHandledSymbol]: false
    };
  }).derive((elysiaContext) => {
    return {
      getContext() {
        return elysiaContext[contextSymbol];
      },
      setContext(value) {
        Object.defineProperty(elysiaContext, contextSymbol, {
          value
        });
      }
    };
  }).as("plugin");
}
function getRuntime(elysiaContext) {
  let params = elysiaContext.params;
  const elysiaContextAny = elysiaContext;
  const cloudflareContext = elysiaContextAny.env && elysiaContextAny.ctx ? {
    env: elysiaContextAny.env,
    ctx: elysiaContextAny.ctx
  } : {};
  if (cloudflareContext.ctx) {
    params = cloudflareContext.ctx.params ?? params;
  }
  return getAdapterRuntime(
    "elysia",
    {
      params,
      elysia: elysiaContext
    },
    cloudflareContext
  );
}

// virtual:universal-middleware:virtual:universal-middleware:elysia:middleware:src/middleware.ts
var middleware_default = createMiddleware(serveStatic);

export { middleware_default as default };