@depup/hono 4.12.8-depup.0

package/dist/middleware/language/language.js

@@ -0,0 +1,190 @@
+// src/middleware/language/language.ts
+import { setCookie, getCookie } from "../../helper/cookie/index.js";
+import { parseAccept } from "../../utils/accept.js";
+var DEFAULT_OPTIONS = {
+  order: ["querystring", "cookie", "header"],
+  lookupQueryString: "lang",
+  lookupCookie: "language",
+  lookupFromHeaderKey: "accept-language",
+  lookupFromPathIndex: 0,
+  caches: ["cookie"],
+  ignoreCase: true,
+  fallbackLanguage: "en",
+  supportedLanguages: ["en"],
+  cookieOptions: {
+    sameSite: "Strict",
+    secure: true,
+    maxAge: 365 * 24 * 60 * 60,
+    httpOnly: true
+  },
+  debug: false
+};
+function parseAcceptLanguage(header) {
+  return parseAccept(header).map(({ type, q }) => ({ lang: type, q }));
+}
+var normalizeLanguage = (lang, options) => {
+  if (!lang) {
+    return void 0;
+  }
+  try {
+    let normalizedLang = lang.trim();
+    if (options.convertDetectedLanguage) {
+      normalizedLang = options.convertDetectedLanguage(normalizedLang);
+    }
+    const compLang = options.ignoreCase ? normalizedLang.toLowerCase() : normalizedLang;
+    const compSupported = options.supportedLanguages.map(
+      (l) => options.ignoreCase ? l.toLowerCase() : l
+    );
+    const exactIndex = compSupported.indexOf(compLang);
+    if (exactIndex !== -1) {
+      return options.supportedLanguages[exactIndex];
+    }
+    const parts = compLang.split("-");
+    for (let i = parts.length - 1; i > 0; i--) {
+      const candidate = parts.slice(0, i).join("-");
+      const prefixIndex = compSupported.indexOf(candidate);
+      if (prefixIndex !== -1) {
+        return options.supportedLanguages[prefixIndex];
+      }
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+};
+var detectFromQuery = (c, options) => {
+  try {
+    const query = c.req.query(options.lookupQueryString);
+    return normalizeLanguage(query, options);
+  } catch {
+    return void 0;
+  }
+};
+var detectFromCookie = (c, options) => {
+  try {
+    const cookie = getCookie(c, options.lookupCookie);
+    return normalizeLanguage(cookie, options);
+  } catch {
+    return void 0;
+  }
+};
+function detectFromHeader(c, options) {
+  try {
+    const acceptLanguage = c.req.header(options.lookupFromHeaderKey);
+    if (!acceptLanguage) {
+      return void 0;
+    }
+    const languages = parseAcceptLanguage(acceptLanguage);
+    for (const { lang } of languages) {
+      const normalizedLang = normalizeLanguage(lang, options);
+      if (normalizedLang) {
+        return normalizedLang;
+      }
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function detectFromPath(c, options) {
+  try {
+    const url = new URL(c.req.url);
+    const pathSegments = url.pathname.split("/").filter(Boolean);
+    const langSegment = pathSegments[options.lookupFromPathIndex];
+    return normalizeLanguage(langSegment, options);
+  } catch {
+    return void 0;
+  }
+}
+var detectors = {
+  querystring: detectFromQuery,
+  cookie: detectFromCookie,
+  header: detectFromHeader,
+  path: detectFromPath
+};
+function validateOptions(options) {
+  if (!options.supportedLanguages.includes(options.fallbackLanguage)) {
+    throw new Error("Fallback language must be included in supported languages");
+  }
+  if (options.lookupFromPathIndex < 0) {
+    throw new Error("Path index must be non-negative");
+  }
+  if (!options.order.every((detector) => Object.keys(detectors).includes(detector))) {
+    throw new Error("Invalid detector type in order array");
+  }
+}
+function cacheLanguage(c, language, options) {
+  if (!Array.isArray(options.caches) || !options.caches.includes("cookie")) {
+    return;
+  }
+  try {
+    setCookie(c, options.lookupCookie, language, options.cookieOptions);
+  } catch (error) {
+    if (options.debug) {
+      console.error("Failed to cache language:", error);
+    }
+  }
+}
+var detectLanguage = (c, options) => {
+  let detectedLang;
+  for (const detectorName of options.order) {
+    const detector = detectors[detectorName];
+    if (!detector) {
+      continue;
+    }
+    try {
+      detectedLang = detector(c, options);
+      if (detectedLang) {
+        if (options.debug) {
+          console.log(`Language detected from ${detectorName}: ${detectedLang}`);
+        }
+        break;
+      }
+    } catch (error) {
+      if (options.debug) {
+        console.error(`Error in ${detectorName} detector:`, error);
+      }
+      continue;
+    }
+  }
+  const finalLang = detectedLang || options.fallbackLanguage;
+  if (detectedLang && options.caches) {
+    cacheLanguage(c, finalLang, options);
+  }
+  return finalLang;
+};
+var languageDetector = (userOptions) => {
+  const options = {
+    ...DEFAULT_OPTIONS,
+    ...userOptions,
+    cookieOptions: {
+      ...DEFAULT_OPTIONS.cookieOptions,
+      ...userOptions.cookieOptions
+    }
+  };
+  validateOptions(options);
+  return async function languageDetector2(ctx, next) {
+    try {
+      const lang = detectLanguage(ctx, options);
+      ctx.set("language", lang);
+    } catch (error) {
+      if (options.debug) {
+        console.error("Language detection failed:", error);
+      }
+      ctx.set("language", options.fallbackLanguage);
+    }
+    await next();
+  };
+};
+export {
+  DEFAULT_OPTIONS,
+  detectFromCookie,
+  detectFromHeader,
+  detectFromPath,
+  detectFromQuery,
+  detectors,
+  languageDetector,
+  normalizeLanguage,
+  parseAcceptLanguage,
+  validateOptions
+};

package/dist/middleware/logger/index.js

@@ -0,0 +1,44 @@
+// src/middleware/logger/index.ts
+import { getColorEnabledAsync } from "../../utils/color.js";
+var humanize = (times) => {
+  const [delimiter, separator] = [",", "."];
+  const orderTimes = times.map((v) => v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1" + delimiter));
+  return orderTimes.join(separator);
+};
+var time = (start) => {
+  const delta = Date.now() - start;
+  return humanize([delta < 1e3 ? delta + "ms" : Math.round(delta / 1e3) + "s"]);
+};
+var colorStatus = async (status) => {
+  const colorEnabled = await getColorEnabledAsync();
+  if (colorEnabled) {
+    switch (status / 100 | 0) {
+      case 5:
+        return `\x1B[31m${status}\x1B[0m`;
+      case 4:
+        return `\x1B[33m${status}\x1B[0m`;
+      case 3:
+        return `\x1B[36m${status}\x1B[0m`;
+      case 2:
+        return `\x1B[32m${status}\x1B[0m`;
+    }
+  }
+  return `${status}`;
+};
+async function log(fn, prefix, method, path, status = 0, elapsed) {
+  const out = prefix === "<--" /* Incoming */ ? `${prefix} ${method} ${path}` : `${prefix} ${method} ${path} ${await colorStatus(status)} ${elapsed}`;
+  fn(out);
+}
+var logger = (fn = console.log) => {
+  return async function logger2(c, next) {
+    const { method, url } = c.req;
+    const path = url.slice(url.indexOf("/", 8));
+    await log(fn, "<--" /* Incoming */, method, path);
+    const start = Date.now();
+    await next();
+    await log(fn, "-->" /* Outgoing */, method, path, c.res.status, time(start));
+  };
+};
+export {
+  logger
+};

package/dist/middleware/method-override/index.js

@@ -0,0 +1,82 @@
+// src/middleware/method-override/index.ts
+import { parseBody } from "../../utils/body.js";
+var DEFAULT_METHOD_FORM_NAME = "_method";
+var methodOverride = (options) => async function methodOverride2(c, next) {
+  if (c.req.method === "GET") {
+    return await next();
+  }
+  const app = options.app;
+  if (!(options.header || options.query)) {
+    const contentType = c.req.header("content-type");
+    const methodFormName = options.form || DEFAULT_METHOD_FORM_NAME;
+    const clonedRequest = c.req.raw.clone();
+    const newRequest = clonedRequest.clone();
+    if (contentType?.startsWith("multipart/form-data")) {
+      const form = await clonedRequest.formData();
+      const method = form.get(methodFormName);
+      if (method) {
+        const newForm = await newRequest.formData();
+        newForm.delete(methodFormName);
+        const newHeaders = new Headers(clonedRequest.headers);
+        newHeaders.delete("content-type");
+        newHeaders.delete("content-length");
+        const request = new Request(c.req.url, {
+          body: newForm,
+          headers: newHeaders,
+          method
+        });
+        return app.fetch(request, c.env, getExecutionCtx(c));
+      }
+    }
+    if (contentType === "application/x-www-form-urlencoded") {
+      const params = await parseBody(clonedRequest);
+      const method = params[methodFormName];
+      if (method) {
+        delete params[methodFormName];
+        const newParams = new URLSearchParams(params);
+        const request = new Request(newRequest, {
+          body: newParams,
+          method
+        });
+        return app.fetch(request, c.env, getExecutionCtx(c));
+      }
+    }
+  } else if (options.header) {
+    const headerName = options.header;
+    const method = c.req.header(headerName);
+    if (method) {
+      const newHeaders = new Headers(c.req.raw.headers);
+      newHeaders.delete(headerName);
+      const request = new Request(c.req.raw, {
+        headers: newHeaders,
+        method
+      });
+      return app.fetch(request, c.env, getExecutionCtx(c));
+    }
+  } else if (options.query) {
+    const queryName = options.query;
+    const method = c.req.query(queryName);
+    if (method) {
+      const url = new URL(c.req.url);
+      url.searchParams.delete(queryName);
+      const request = new Request(url.toString(), {
+        body: c.req.raw.body,
+        headers: c.req.raw.headers,
+        method
+      });
+      return app.fetch(request, c.env, getExecutionCtx(c));
+    }
+  }
+  await next();
+};
+var getExecutionCtx = (c) => {
+  let executionCtx;
+  try {
+    executionCtx = c.executionCtx;
+  } catch {
+  }
+  return executionCtx;
+};
+export {
+  methodOverride
+};

package/dist/middleware/powered-by/index.js

@@ -0,0 +1,10 @@
+// src/middleware/powered-by/index.ts
+var poweredBy = (options) => {
+  return async function poweredBy2(c, next) {
+    await next();
+    c.res.headers.set("X-Powered-By", options?.serverName ?? "Hono");
+  };
+};
+export {
+  poweredBy
+};

package/dist/middleware/pretty-json/index.js

@@ -0,0 +1,15 @@
+// src/middleware/pretty-json/index.ts
+var prettyJSON = (options) => {
+  const targetQuery = options?.query ?? "pretty";
+  return async function prettyJSON2(c, next) {
+    const pretty = options?.force || c.req.query(targetQuery) || c.req.query(targetQuery) === "";
+    await next();
+    if (pretty && c.res.headers.get("Content-Type")?.startsWith("application/json")) {
+      const obj = await c.res.json();
+      c.res = new Response(JSON.stringify(obj, null, options?.space ?? 2), c.res);
+    }
+  };
+};
+export {
+  prettyJSON
+};

package/dist/middleware/request-id/index.js

@@ -0,0 +1,5 @@
+// src/middleware/request-id/index.ts
+import { requestId } from "./request-id.js";
+export {
+  requestId
+};

package/dist/middleware/request-id/request-id.js

@@ -0,0 +1,21 @@
+// src/middleware/request-id/request-id.ts
+var requestId = ({
+  limitLength = 255,
+  headerName = "X-Request-Id",
+  generator = () => crypto.randomUUID()
+} = {}) => {
+  return async function requestId2(c, next) {
+    let reqId = headerName ? c.req.header(headerName) : void 0;
+    if (!reqId || reqId.length > limitLength || /[^\w\-=]/.test(reqId)) {
+      reqId = generator(c);
+    }
+    c.set("requestId", reqId);
+    if (headerName) {
+      c.header(headerName, reqId);
+    }
+    await next();
+  };
+};
+export {
+  requestId
+};

package/dist/middleware/secure-headers/index.js

@@ -0,0 +1,6 @@
+// src/middleware/secure-headers/index.ts
+import { NONCE, secureHeaders } from "./secure-headers.js";
+export {
+  NONCE,
+  secureHeaders
+};

package/dist/middleware/secure-headers/secure-headers.js

@@ -0,0 +1,166 @@
+// src/middleware/secure-headers/secure-headers.ts
+import { encodeBase64 } from "../../utils/encode.js";
+var HEADERS_MAP = {
+  crossOriginEmbedderPolicy: ["Cross-Origin-Embedder-Policy", "require-corp"],
+  crossOriginResourcePolicy: ["Cross-Origin-Resource-Policy", "same-origin"],
+  crossOriginOpenerPolicy: ["Cross-Origin-Opener-Policy", "same-origin"],
+  originAgentCluster: ["Origin-Agent-Cluster", "?1"],
+  referrerPolicy: ["Referrer-Policy", "no-referrer"],
+  strictTransportSecurity: ["Strict-Transport-Security", "max-age=15552000; includeSubDomains"],
+  xContentTypeOptions: ["X-Content-Type-Options", "nosniff"],
+  xDnsPrefetchControl: ["X-DNS-Prefetch-Control", "off"],
+  xDownloadOptions: ["X-Download-Options", "noopen"],
+  xFrameOptions: ["X-Frame-Options", "SAMEORIGIN"],
+  xPermittedCrossDomainPolicies: ["X-Permitted-Cross-Domain-Policies", "none"],
+  xXssProtection: ["X-XSS-Protection", "0"]
+};
+var DEFAULT_OPTIONS = {
+  crossOriginEmbedderPolicy: false,
+  crossOriginResourcePolicy: true,
+  crossOriginOpenerPolicy: true,
+  originAgentCluster: true,
+  referrerPolicy: true,
+  strictTransportSecurity: true,
+  xContentTypeOptions: true,
+  xDnsPrefetchControl: true,
+  xDownloadOptions: true,
+  xFrameOptions: true,
+  xPermittedCrossDomainPolicies: true,
+  xXssProtection: true,
+  removePoweredBy: true,
+  permissionsPolicy: {}
+};
+var generateNonce = () => {
+  const arrayBuffer = new Uint8Array(16);
+  crypto.getRandomValues(arrayBuffer);
+  return encodeBase64(arrayBuffer.buffer);
+};
+var NONCE = (ctx) => {
+  const key = "secureHeadersNonce";
+  const init = ctx.get(key);
+  const nonce = init || generateNonce();
+  if (init == null) {
+    ctx.set(key, nonce);
+  }
+  return `'nonce-${nonce}'`;
+};
+var secureHeaders = (customOptions) => {
+  const options = { ...DEFAULT_OPTIONS, ...customOptions };
+  const headersToSet = getFilteredHeaders(options);
+  const callbacks = [];
+  if (options.contentSecurityPolicy) {
+    const [callback, value] = getCSPDirectives(options.contentSecurityPolicy);
+    if (callback) {
+      callbacks.push(callback);
+    }
+    headersToSet.push(["Content-Security-Policy", value]);
+  }
+  if (options.contentSecurityPolicyReportOnly) {
+    const [callback, value] = getCSPDirectives(options.contentSecurityPolicyReportOnly);
+    if (callback) {
+      callbacks.push(callback);
+    }
+    headersToSet.push(["Content-Security-Policy-Report-Only", value]);
+  }
+  if (options.permissionsPolicy && Object.keys(options.permissionsPolicy).length > 0) {
+    headersToSet.push([
+      "Permissions-Policy",
+      getPermissionsPolicyDirectives(options.permissionsPolicy)
+    ]);
+  }
+  if (options.reportingEndpoints) {
+    headersToSet.push(["Reporting-Endpoints", getReportingEndpoints(options.reportingEndpoints)]);
+  }
+  if (options.reportTo) {
+    headersToSet.push(["Report-To", getReportToOptions(options.reportTo)]);
+  }
+  return async function secureHeaders2(ctx, next) {
+    const headersToSetForReq = callbacks.length === 0 ? headersToSet : callbacks.reduce((acc, cb) => cb(ctx, acc), headersToSet);
+    await next();
+    setHeaders(ctx, headersToSetForReq);
+    if (options?.removePoweredBy) {
+      ctx.res.headers.delete("X-Powered-By");
+    }
+  };
+};
+function getFilteredHeaders(options) {
+  return Object.entries(HEADERS_MAP).filter(([key]) => options[key]).map(([key, defaultValue]) => {
+    const overrideValue = options[key];
+    return typeof overrideValue === "string" ? [defaultValue[0], overrideValue] : defaultValue;
+  });
+}
+function getCSPDirectives(contentSecurityPolicy) {
+  const callbacks = [];
+  const resultValues = [];
+  for (const [directive, value] of Object.entries(contentSecurityPolicy)) {
+    const valueArray = Array.isArray(value) ? value : [value];
+    valueArray.forEach((value2, i) => {
+      if (typeof value2 === "function") {
+        const index = i * 2 + 2 + resultValues.length;
+        callbacks.push((ctx, values) => {
+          values[index] = value2(ctx, directive);
+        });
+      }
+    });
+    resultValues.push(
+      directive.replace(
+        /[A-Z]+(?![a-z])|[A-Z]/g,
+        (match, offset) => offset ? "-" + match.toLowerCase() : match.toLowerCase()
+      ),
+      ...valueArray.flatMap((value2) => [" ", value2]),
+      "; "
+    );
+  }
+  resultValues.pop();
+  return callbacks.length === 0 ? [void 0, resultValues.join("")] : [
+    (ctx, headersToSet) => headersToSet.map((values) => {
+      if (values[0] === "Content-Security-Policy" || values[0] === "Content-Security-Policy-Report-Only") {
+        const clone = values[1].slice();
+        callbacks.forEach((cb) => {
+          cb(ctx, clone);
+        });
+        return [values[0], clone.join("")];
+      } else {
+        return values;
+      }
+    }),
+    resultValues
+  ];
+}
+function getPermissionsPolicyDirectives(policy) {
+  return Object.entries(policy).map(([directive, value]) => {
+    const kebabDirective = camelToKebab(directive);
+    if (typeof value === "boolean") {
+      return `${kebabDirective}=${value ? "*" : "none"}`;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        return `${kebabDirective}=()`;
+      }
+      if (value.length === 1 && (value[0] === "*" || value[0] === "none")) {
+        return `${kebabDirective}=${value[0]}`;
+      }
+      const allowlist = value.map((item) => ["self", "src"].includes(item) ? item : `"${item}"`);
+      return `${kebabDirective}=(${allowlist.join(" ")})`;
+    }
+    return "";
+  }).filter(Boolean).join(", ");
+}
+function camelToKebab(str) {
+  return str.replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function getReportingEndpoints(reportingEndpoints = []) {
+  return reportingEndpoints.map((endpoint) => `${endpoint.name}="${endpoint.url}"`).join(", ");
+}
+function getReportToOptions(reportTo = []) {
+  return reportTo.map((option) => JSON.stringify(option)).join(", ");
+}
+function setHeaders(ctx, headersToSet) {
+  headersToSet.forEach(([header, value]) => {
+    ctx.res.headers.set(header, value);
+  });
+}
+export {
+  NONCE,
+  secureHeaders
+};

package/dist/middleware/serve-static/index.js

@@ -0,0 +1,77 @@
+// src/middleware/serve-static/index.ts
+import { COMPRESSIBLE_CONTENT_TYPE_REGEX } from "../../utils/compress.js";
+import { getMimeType } from "../../utils/mime.js";
+import { tryDecodeURI } from "../../utils/url.js";
+import { defaultJoin } from "./path.js";
+var ENCODINGS = {
+  br: ".br",
+  zstd: ".zst",
+  gzip: ".gz"
+};
+var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
+var DEFAULT_DOCUMENT = "index.html";
+var serveStatic = (options) => {
+  const root = options.root ?? "./";
+  const optionPath = options.path;
+  const join = options.join ?? defaultJoin;
+  return async (c, next) => {
+    if (c.finalized) {
+      return next();
+    }
+    let filename;
+    if (options.path) {
+      filename = options.path;
+    } else {
+      try {
+        filename = tryDecodeURI(c.req.path);
+        if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename)) {
+          throw new Error();
+        }
+      } catch {
+        await options.onNotFound?.(c.req.path, c);
+        return next();
+      }
+    }
+    let path = join(
+      root,
+      !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename
+    );
+    if (options.isDir && await options.isDir(path)) {
+      path = join(path, DEFAULT_DOCUMENT);
+    }
+    const getContent = options.getContent;
+    let content = await getContent(path, c);
+    if (content instanceof Response) {
+      return c.newResponse(content.body, content);
+    }
+    if (content) {
+      const mimeType = options.mimes && getMimeType(path, options.mimes) || getMimeType(path);
+      c.header("Content-Type", mimeType || "application/octet-stream");
+      if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
+        const acceptEncodingSet = new Set(
+          c.req.header("Accept-Encoding")?.split(",").map((encoding) => encoding.trim())
+        );
+        for (const encoding of ENCODINGS_ORDERED_KEYS) {
+          if (!acceptEncodingSet.has(encoding)) {
+            continue;
+          }
+          const compressedContent = await getContent(path + ENCODINGS[encoding], c);
+          if (compressedContent) {
+            content = compressedContent;
+            c.header("Content-Encoding", encoding);
+            c.header("Vary", "Accept-Encoding", { append: true });
+            break;
+          }
+        }
+      }
+      await options.onFound?.(path, c);
+      return c.body(content);
+    }
+    await options.onNotFound?.(path, c);
+    await next();
+    return;
+  };
+};
+export {
+  serveStatic
+};

package/dist/middleware/serve-static/path.js

@@ -0,0 +1,18 @@
+// src/middleware/serve-static/path.ts
+var defaultJoin = (...paths) => {
+  let result = paths.filter((p) => p !== "").join("/");
+  result = result.replace(/(?<=\/)\/+/g, "");
+  const segments = result.split("/");
+  const resolved = [];
+  for (const segment of segments) {
+    if (segment === ".." && resolved.length > 0 && resolved.at(-1) !== "..") {
+      resolved.pop();
+    } else if (segment !== ".") {
+      resolved.push(segment);
+    }
+  }
+  return resolved.join("/") || ".";
+};
+export {
+  defaultJoin
+};

package/dist/middleware/timeout/index.js

@@ -0,0 +1,25 @@
+// src/middleware/timeout/index.ts
+import { HTTPException } from "../../http-exception.js";
+var defaultTimeoutException = new HTTPException(504, {
+  message: "Gateway Timeout"
+});
+var timeout = (duration, exception = defaultTimeoutException) => {
+  return async function timeout2(context, next) {
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        reject(typeof exception === "function" ? exception(context) : exception);
+      }, duration);
+    });
+    try {
+      await Promise.race([next(), timeoutPromise]);
+    } finally {
+      if (timer !== void 0) {
+        clearTimeout(timer);
+      }
+    }
+  };
+};
+export {
+  timeout
+};

package/dist/middleware/timing/index.js

@@ -0,0 +1,9 @@
+// src/middleware/timing/index.ts
+import { timing, setMetric, startTime, endTime, wrapTime } from "./timing.js";
+export {
+  endTime,
+  setMetric,
+  startTime,
+  timing,
+  wrapTime
+};