@universal-middleware/hattip/dist/index.js

Hattip adapter for universal middlewares

// src/common.ts
import { bindUniversal, contextSymbol, getAdapterRuntime, universalSymbol } from "@universal-middleware/core";
function createHandler(handlerFactory) {
  return (...args) => {
    const handler = handlerFactory(...args);
    return bindUniversal(handler, async function universalHandlerHattip(context) {
      const ctx = initContext(context);
      return this[universalSymbol](context.request, ctx, getRuntime(context));
    });
  };
}
function createMiddleware(middlewareFactory) {
  return (...args) => {
    const middleware = middlewareFactory(...args);
    return bindUniversal(middleware, async function universalMiddlewareHattip(context) {
      const ctx = initContext(context);
      const response = await this[universalSymbol](context.request, ctx, getRuntime(context));
      if (typeof response === "function") {
        const res = await context.next();
        const actualRes = await response(res);
        return actualRes ?? res;
      }
      if (response !== null && typeof response === "object") {
        if (response instanceof Response) {
          return response;
        }
        context[contextSymbol] = response;
      }
    });
  };
}
function initContext(context) {
  context[contextSymbol] ??= {};
  return context[contextSymbol];
}
function getContext(context) {
  return context[contextSymbol];
}
function getRuntime(context) {
  return getAdapterRuntime(
    "hattip",
    {
      params: "params" in context ? context.params : void 0,
      hattip: context
    },
    {
      // biome-ignore lint/suspicious/noExplicitAny: ignored
      env: context.platform?.env,
      // biome-ignore lint/suspicious/noExplicitAny: ignored
      ctx: context.platform?.context,
      // biome-ignore lint/suspicious/noExplicitAny: ignored
      req: context.platform?.request,
      // biome-ignore lint/suspicious/noExplicitAny: ignored
      res: context.platform?.response
    }
  );
}

// src/router.ts
import {
  apply as applyCore,
  getUniversal,
  UniversalRouter,
  universalSymbol as universalSymbol2
} from "@universal-middleware/core";
var UniversalHattipRouter = class extends UniversalRouter {
  #app;
  constructor(app) {
    super(false);
    this.#app = app;
  }
  use(middleware) {
    this.#app.use(createMiddleware(() => getUniversal(middleware))());
    return this;
  }
  applyCatchAll() {
    this.#app.use("/*", createHandler(() => this[universalSymbol2])());
    return this;
  }
};
function apply(app, middlewares) {
  const router = new UniversalHattipRouter(app);
  applyCore(router, middlewares);
}
export {
  apply,
  createHandler,
  createMiddleware,
  getContext,
  getRuntime
};