hono/dist/cjs/middleware/combine/index.js

Web framework built on Web Standards

"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, except2, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except2)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var combine_exports = {};
__export(combine_exports, {
  every: () => every,
  except: () => except,
  some: () => some
});
module.exports = __toCommonJS(combine_exports);
var import_compose = require("../../compose");
var import_router = require("../../router");
var import_trie_router = require("../../router/trie-router");
const some = (...middleware) => {
  return async function some2(c, next) {
    let lastError;
    for (const handler of middleware) {
      try {
        const result = await handler(c, next);
        if (result === true && !c.finalized) {
          await next();
        } else if (result === false) {
          lastError = new Error("No successful middleware found");
          continue;
        }
        lastError = void 0;
        break;
      } catch (error) {
        lastError = error;
        continue;
      }
    }
    if (lastError) {
      throw lastError;
    }
  };
};
const every = (...middleware) => {
  const wrappedMiddleware = middleware.map((m) => async (c, next) => {
    const res = await m(c, next);
    if (res === false) {
      throw new Error("Unmet condition");
    }
    return res;
  });
  const handler = async (c, next) => (0, import_compose.compose)(wrappedMiddleware.map((m) => [[m, void 0], c.req.param()]))(c, next);
  return async function every2(c, next) {
    await handler(c, next);
  };
};
const except = (condition, ...middleware) => {
  let router = void 0;
  const conditions = (Array.isArray(condition) ? condition : [condition]).map((condition2) => {
    if (typeof condition2 === "string") {
      router ||= new import_trie_router.TrieRouter();
      router.add(import_router.METHOD_NAME_ALL, condition2, true);
    } else {
      return condition2;
    }
  }).filter(Boolean);
  if (router) {
    conditions.unshift((c) => !!router?.match(import_router.METHOD_NAME_ALL, c.req.path)?.[0]?.[0]?.[0]);
  }
  const handler = some((c) => conditions.some((cond) => cond(c)), every(...middleware));
  return async function except2(c, next) {
    await handler(c, next);
  };
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  every,
  except,
  some
});