language.js 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221
  1. var __defProp = Object.defineProperty;
  2. var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  3. var __getOwnPropNames = Object.getOwnPropertyNames;
  4. var __hasOwnProp = Object.prototype.hasOwnProperty;
  5. var __export = (target, all) => {
  6. for (var name in all)
  7. __defProp(target, name, { get: all[name], enumerable: true });
  8. };
  9. var __copyProps = (to, from, except, desc) => {
  10. if (from && typeof from === "object" || typeof from === "function") {
  11. for (let key of __getOwnPropNames(from))
  12. if (!__hasOwnProp.call(to, key) && key !== except)
  13. __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  14. }
  15. return to;
  16. };
  17. var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
  18. var language_exports = {};
  19. __export(language_exports, {
  20. DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
  21. detectFromCookie: () => detectFromCookie,
  22. detectFromHeader: () => detectFromHeader,
  23. detectFromPath: () => detectFromPath,
  24. detectFromQuery: () => detectFromQuery,
  25. detectors: () => detectors,
  26. languageDetector: () => languageDetector,
  27. normalizeLanguage: () => normalizeLanguage,
  28. parseAcceptLanguage: () => parseAcceptLanguage,
  29. validateOptions: () => validateOptions
  30. });
  31. module.exports = __toCommonJS(language_exports);
  32. var import_cookie = require("../../helper/cookie");
  33. var import_accept = require("../../utils/accept");
  34. const DEFAULT_OPTIONS = {
  35. order: ["querystring", "cookie", "header"],
  36. lookupQueryString: "lang",
  37. lookupCookie: "language",
  38. lookupFromHeaderKey: "accept-language",
  39. lookupFromPathIndex: 0,
  40. caches: ["cookie"],
  41. ignoreCase: true,
  42. fallbackLanguage: "en",
  43. supportedLanguages: ["en"],
  44. cookieOptions: {
  45. sameSite: "Strict",
  46. secure: true,
  47. maxAge: 365 * 24 * 60 * 60,
  48. httpOnly: true
  49. },
  50. debug: false
  51. };
  52. function parseAcceptLanguage(header) {
  53. return (0, import_accept.parseAccept)(header).map(({ type, q }) => ({ lang: type, q }));
  54. }
  55. const normalizeLanguage = (lang, options) => {
  56. if (!lang) {
  57. return void 0;
  58. }
  59. try {
  60. let normalizedLang = lang.trim();
  61. if (options.convertDetectedLanguage) {
  62. normalizedLang = options.convertDetectedLanguage(normalizedLang);
  63. }
  64. const compLang = options.ignoreCase ? normalizedLang.toLowerCase() : normalizedLang;
  65. const compSupported = options.supportedLanguages.map(
  66. (l) => options.ignoreCase ? l.toLowerCase() : l
  67. );
  68. const exactIndex = compSupported.indexOf(compLang);
  69. if (exactIndex !== -1) {
  70. return options.supportedLanguages[exactIndex];
  71. }
  72. const parts = compLang.split("-");
  73. for (let i = parts.length - 1; i > 0; i--) {
  74. const candidate = parts.slice(0, i).join("-");
  75. const prefixIndex = compSupported.indexOf(candidate);
  76. if (prefixIndex !== -1) {
  77. return options.supportedLanguages[prefixIndex];
  78. }
  79. }
  80. return void 0;
  81. } catch {
  82. return void 0;
  83. }
  84. };
  85. const detectFromQuery = (c, options) => {
  86. try {
  87. const query = c.req.query(options.lookupQueryString);
  88. return normalizeLanguage(query, options);
  89. } catch {
  90. return void 0;
  91. }
  92. };
  93. const detectFromCookie = (c, options) => {
  94. try {
  95. const cookie = (0, import_cookie.getCookie)(c, options.lookupCookie);
  96. return normalizeLanguage(cookie, options);
  97. } catch {
  98. return void 0;
  99. }
  100. };
  101. function detectFromHeader(c, options) {
  102. try {
  103. const acceptLanguage = c.req.header(options.lookupFromHeaderKey);
  104. if (!acceptLanguage) {
  105. return void 0;
  106. }
  107. const languages = parseAcceptLanguage(acceptLanguage);
  108. for (const { lang } of languages) {
  109. const normalizedLang = normalizeLanguage(lang, options);
  110. if (normalizedLang) {
  111. return normalizedLang;
  112. }
  113. }
  114. return void 0;
  115. } catch {
  116. return void 0;
  117. }
  118. }
  119. function detectFromPath(c, options) {
  120. try {
  121. const url = new URL(c.req.url);
  122. const pathSegments = url.pathname.split("/").filter(Boolean);
  123. const langSegment = pathSegments[options.lookupFromPathIndex];
  124. return normalizeLanguage(langSegment, options);
  125. } catch {
  126. return void 0;
  127. }
  128. }
  129. const detectors = {
  130. querystring: detectFromQuery,
  131. cookie: detectFromCookie,
  132. header: detectFromHeader,
  133. path: detectFromPath
  134. };
  135. function validateOptions(options) {
  136. if (!options.supportedLanguages.includes(options.fallbackLanguage)) {
  137. throw new Error("Fallback language must be included in supported languages");
  138. }
  139. if (options.lookupFromPathIndex < 0) {
  140. throw new Error("Path index must be non-negative");
  141. }
  142. if (!options.order.every((detector) => Object.keys(detectors).includes(detector))) {
  143. throw new Error("Invalid detector type in order array");
  144. }
  145. }
  146. function cacheLanguage(c, language, options) {
  147. if (!Array.isArray(options.caches) || !options.caches.includes("cookie")) {
  148. return;
  149. }
  150. try {
  151. (0, import_cookie.setCookie)(c, options.lookupCookie, language, options.cookieOptions);
  152. } catch (error) {
  153. if (options.debug) {
  154. console.error("Failed to cache language:", error);
  155. }
  156. }
  157. }
  158. const detectLanguage = (c, options) => {
  159. let detectedLang;
  160. for (const detectorName of options.order) {
  161. const detector = detectors[detectorName];
  162. if (!detector) {
  163. continue;
  164. }
  165. try {
  166. detectedLang = detector(c, options);
  167. if (detectedLang) {
  168. if (options.debug) {
  169. console.log(`Language detected from ${detectorName}: ${detectedLang}`);
  170. }
  171. break;
  172. }
  173. } catch (error) {
  174. if (options.debug) {
  175. console.error(`Error in ${detectorName} detector:`, error);
  176. }
  177. continue;
  178. }
  179. }
  180. const finalLang = detectedLang || options.fallbackLanguage;
  181. if (detectedLang && options.caches) {
  182. cacheLanguage(c, finalLang, options);
  183. }
  184. return finalLang;
  185. };
  186. const languageDetector = (userOptions) => {
  187. const options = {
  188. ...DEFAULT_OPTIONS,
  189. ...userOptions,
  190. cookieOptions: {
  191. ...DEFAULT_OPTIONS.cookieOptions,
  192. ...userOptions.cookieOptions
  193. }
  194. };
  195. validateOptions(options);
  196. return async function languageDetector2(ctx, next) {
  197. try {
  198. const lang = detectLanguage(ctx, options);
  199. ctx.set("language", lang);
  200. } catch (error) {
  201. if (options.debug) {
  202. console.error("Language detection failed:", error);
  203. }
  204. ctx.set("language", options.fallbackLanguage);
  205. }
  206. await next();
  207. };
  208. };
  209. // Annotate the CommonJS export names for ESM import in node:
  210. 0 && (module.exports = {
  211. DEFAULT_OPTIONS,
  212. detectFromCookie,
  213. detectFromHeader,
  214. detectFromPath,
  215. detectFromQuery,
  216. detectors,
  217. languageDetector,
  218. normalizeLanguage,
  219. parseAcceptLanguage,
  220. validateOptions
  221. });