hono 4.13.9 → 4.13.10

package/dist/cjs/middleware/language/language.js

@@ -1,206 +1,208 @@
-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, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __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 language_exports = {};
-__export(language_exports, {
-  DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
-  detectFromCookie: () => detectFromCookie,
-  detectFromHeader: () => detectFromHeader,
-  detectFromPath: () => detectFromPath,
-  detectFromQuery: () => detectFromQuery,
-  detectors: () => detectors,
-  languageDetector: () => languageDetector,
-  normalizeLanguage: () => normalizeLanguage,
-  parseAcceptLanguage: () => parseAcceptLanguage,
-  validateOptions: () => validateOptions
-});
-module.exports = __toCommonJS(language_exports);
-var import_cookie = require("../../helper/cookie");
-var import_accept = require("../../utils/accept");
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_utils_accept = require("../../utils/accept.js");
+const require_helper_cookie_index = require("../../helper/cookie/index.js");
+//#region src/middleware/language/language.ts
 const 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
+	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: 31536e3,
+		httpOnly: true
+	},
+	debug: false
 };
+/**
+* Parse Accept-Language header values with quality scores
+* @param header Accept-Language header string
+* @returns Array of parsed languages with quality scores
+*/
 function parseAcceptLanguage(header) {
-  return (0, import_accept.parseAccept)(header).map(({ type, q }) => ({ lang: type, q }));
+	return require_utils_accept.parseAccept(header).map(({ type, q }) => ({
+		lang: type,
+		q
+	}));
 }
+/**
+* Validate and normalize language codes
+* @param lang Language code to normalize
+* @param options Detector options
+* @returns Normalized language code or undefined
+*/
 const 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];
-    }
-    let longestMatchIndex = -1;
-    let longestMatchLength = -1;
-    for (let i = 0; i < compSupported.length; i++) {
-      const candidate = compSupported[i];
-      if (candidate.length < compLang.length && candidate.length > longestMatchLength && compLang.startsWith(candidate) && compLang[candidate.length] === "-") {
-        longestMatchIndex = i;
-        longestMatchLength = candidate.length;
-      }
-    }
-    if (longestMatchIndex !== -1) {
-      return options.supportedLanguages[longestMatchIndex];
-    }
-    return void 0;
-  } catch {
-    return void 0;
-  }
+	if (!lang) return;
+	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];
+		let longestMatchIndex = -1;
+		let longestMatchLength = -1;
+		for (let i = 0; i < compSupported.length; i++) {
+			const candidate = compSupported[i];
+			if (candidate.length < compLang.length && candidate.length > longestMatchLength && compLang.startsWith(candidate) && compLang[candidate.length] === "-") {
+				longestMatchIndex = i;
+				longestMatchLength = candidate.length;
+			}
+		}
+		if (longestMatchIndex !== -1) return options.supportedLanguages[longestMatchIndex];
+		return;
+	} catch {
+		return;
+	}
 };
+/**
+* Detects language from query parameter
+*/
 const detectFromQuery = (c, options) => {
-  const query = c.req.query(options.lookupQueryString);
-  return normalizeLanguage(query, options);
+	const query = c.req.query(options.lookupQueryString);
+	return normalizeLanguage(query, options);
 };
+/**
+* Detects language from cookie
+*/
 const detectFromCookie = (c, options) => {
-  const cookie = (0, import_cookie.getCookie)(c, options.lookupCookie);
-  return normalizeLanguage(cookie, options);
+	const cookie = require_helper_cookie_index.getCookie(c, options.lookupCookie);
+	return normalizeLanguage(cookie, options);
 };
+/**
+* Detects language from Accept-Language header
+*/
 function detectFromHeader(c, options) {
-  try {
-    const acceptLanguage = c.req.header(options.lookupFromHeaderKey);
-    if (!acceptLanguage) {
-      return void 0;
-    }
-    const languages = parseAcceptLanguage(acceptLanguage);
-    for (const { lang, q } of languages) {
-      if (q === 0) {
-        continue;
-      }
-      const normalizedLang = normalizeLanguage(lang, options);
-      if (normalizedLang) {
-        return normalizedLang;
-      }
-    }
-    return void 0;
-  } catch {
-    return void 0;
-  }
+	try {
+		const acceptLanguage = c.req.header(options.lookupFromHeaderKey);
+		if (!acceptLanguage) return;
+		const languages = parseAcceptLanguage(acceptLanguage);
+		for (const { lang, q } of languages) {
+			if (q === 0) continue;
+			const normalizedLang = normalizeLanguage(lang, options);
+			if (normalizedLang) return normalizedLang;
+		}
+		return;
+	} catch {
+		return;
+	}
 }
+/**
+* Detects language from URL path
+*/
 function detectFromPath(c, options) {
-  const url = new URL(c.req.url);
-  const pathSegments = url.pathname.split("/").filter(Boolean);
-  const langSegment = pathSegments[options.lookupFromPathIndex];
-  return normalizeLanguage(langSegment, options);
+	const langSegment = new URL(c.req.url).pathname.split("/").filter(Boolean)[options.lookupFromPathIndex];
+	return normalizeLanguage(langSegment, options);
 }
+/**
+* Collection of all language detection strategies
+*/
 const detectors = {
-  querystring: detectFromQuery,
-  cookie: detectFromCookie,
-  header: detectFromHeader,
-  path: detectFromPath
+	querystring: detectFromQuery,
+	cookie: detectFromCookie,
+	header: detectFromHeader,
+	path: detectFromPath
 };
+/**
+* Validate detector options
+* @param options Detector options to validate
+* @throws Error if options are invalid
+*/
 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");
-  }
+	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");
 }
+/**
+* Cache detected language
+*/
 function cacheLanguage(c, language, options) {
-  if (!Array.isArray(options.caches) || !options.caches.includes("cookie")) {
-    return;
-  }
-  try {
-    (0, import_cookie.setCookie)(c, options.lookupCookie, language, options.cookieOptions);
-  } catch (error) {
-    if (options.debug) {
-      console.error("Failed to cache language:", error);
-    }
-  }
+	if (!Array.isArray(options.caches) || !options.caches.includes("cookie")) return;
+	try {
+		require_helper_cookie_index.setCookie(c, options.lookupCookie, language, options.cookieOptions);
+	} catch (error) {
+		if (options.debug) console.error("Failed to cache language:", error);
+	}
 }
+/**
+* Detect language from request
+*/
 const detectLanguage = (c, options) => {
-  let detectedLang;
-  for (const detectorName of options.order) {
-    const detector = detectors[detectorName];
-    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;
+	let detectedLang;
+	for (const detectorName of options.order) {
+		const detector = detectors[detectorName];
+		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;
 };
+/**
+* Language detector middleware factory
+* @param userOptions Configuration options for the language detector
+* @returns Hono middleware function
+*
+* @example
+* ```ts
+* type Variables = LanguageVariables
+* const app = new Hono<{ Variables: Variables }>()
+*
+* app.use(
+*   languageDetector({
+*     supportedLanguages: ['en', 'ja'], // Must include fallback
+*     fallbackLanguage: 'en', // Required
+*   })
+* )
+*
+* app.get('/', (c) => {
+*   const lang = c.get('language')
+*   return c.text(`Current language: ${lang}`)
+* })
+* ```
+*/
 const languageDetector = (userOptions) => {
-  const options = {
-    ...DEFAULT_OPTIONS,
-    ...userOptions,
-    cookieOptions: {
-      ...DEFAULT_OPTIONS.cookieOptions,
-      ...userOptions.cookieOptions
-    }
-  };
-  validateOptions(options);
-  return async function languageDetector2(ctx, next) {
-    const lang = detectLanguage(ctx, options);
-    ctx.set("language", lang);
-    await next();
-  };
+	const options = {
+		...DEFAULT_OPTIONS,
+		...userOptions,
+		cookieOptions: {
+			...DEFAULT_OPTIONS.cookieOptions,
+			...userOptions.cookieOptions
+		}
+	};
+	validateOptions(options);
+	return async function languageDetector(ctx, next) {
+		const lang = detectLanguage(ctx, options);
+		ctx.set("language", lang);
+		await next();
+	};
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DEFAULT_OPTIONS,
-  detectFromCookie,
-  detectFromHeader,
-  detectFromPath,
-  detectFromQuery,
-  detectors,
-  languageDetector,
-  normalizeLanguage,
-  parseAcceptLanguage,
-  validateOptions
-});
+//#endregion
+exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+exports.detectFromCookie = detectFromCookie;
+exports.detectFromHeader = detectFromHeader;
+exports.detectFromPath = detectFromPath;
+exports.detectFromQuery = detectFromQuery;
+exports.detectors = detectors;
+exports.languageDetector = languageDetector;
+exports.normalizeLanguage = normalizeLanguage;
+exports.parseAcceptLanguage = parseAcceptLanguage;
+exports.validateOptions = validateOptions;

package/dist/cjs/middleware/logger/index.js

@@ -1,72 +1,51 @@
-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, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __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 logger_exports = {};
-__export(logger_exports, {
-  logger: () => logger
-});
-module.exports = __toCommonJS(logger_exports);
-var import_color = require("../../utils/color");
-var LogPrefix = /* @__PURE__ */ ((LogPrefix2) => {
-  LogPrefix2["Outgoing"] = "-->";
-  LogPrefix2["Incoming"] = "<--";
-  LogPrefix2["Error"] = "xxx";
-  return LogPrefix2;
-})(LogPrefix || {});
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_utils_color = require("../../utils/color.js");
+//#region src/middleware/logger/index.ts
 const humanize = (times) => {
-  const [delimiter, separator] = [",", "."];
-  const orderTimes = times.map((v) => v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1" + delimiter));
-  return orderTimes.join(separator);
+	const [delimiter, separator] = [",", "."];
+	return times.map((v) => v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1" + delimiter)).join(separator);
 };
 const time = (start) => {
-  const delta = Date.now() - start;
-  return humanize([delta < 1e3 ? delta + "ms" : Math.round(delta / 1e3) + "s"]);
+	const delta = Date.now() - start;
+	return humanize([delta < 1e3 ? delta + "ms" : Math.round(delta / 1e3) + "s"]);
 };
 const colorStatus = async (status) => {
-  const colorEnabled = await (0, import_color.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}`;
+	if (await require_utils_color.getColorEnabledAsync()) 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);
+	fn(prefix === "<--" ? `${prefix} ${method} ${path}` : `${prefix} ${method} ${path} ${await colorStatus(status)} ${elapsed}`);
 }
+/**
+* Logger Middleware for Hono.
+*
+* @see {@link https://hono.dev/docs/middleware/builtin/logger}
+*
+* @param {PrintFunc} [fn=console.log] - Optional function for customized logging behavior.
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* const app = new Hono()
+*
+* app.use(logger())
+* app.get('/', (c) => c.text('Hello Hono!'))
+* ```
+*/
 const 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));
-  };
+	return async function logger(c, next) {
+		const { method, url } = c.req;
+		const path = url.slice(url.indexOf("/", 8));
+		await log(fn, "<--", method, path);
+		const start = Date.now();
+		await next();
+		await log(fn, "-->", method, path, c.res.status, time(start));
+	};
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  logger
-});
+//#endregion
+exports.logger = logger;