@ubean/i18n 0.2.2 → 0.3.0

package/dist/routing-D4Y0l8jV.js

@@ -0,0 +1,330 @@
+import { a as extractLocaleFromPath, n as parseLocaleCookie, r as serializeLocaleCookie, s as localizePath, t as detectLocaleFromAcceptLanguage } from "./detect-BIURd4aL.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { compile, createCoreContext, datetime, number, registerMessageCompiler, translate } from "@intlify/core";
+//#region src/context.ts
+/**
+* Request-scoped i18n engine (@intlify/core).
+*
+* `t()` / `d()` / `n()` 必须在 `runWithI18n()`（由 createI18nMiddleware 包住）
+* 内调用。没有 ALS store 时抛错，禁止回落进程全局 locale。
+*
+* Cloudflare Workers：依赖 `nodejs_compat` 的 `AsyncLocalStorage`。不可用时
+* 同样抛错；handler 应改读 `c.get('locale')` 再 `translate(createRequestContext(...))`。
+*
+* Dev 下 CLI 从 Node 加载 `@ubean/app`（进而 `@ubean/i18n`），路由经 Vite
+* `ssrLoadModule` 再打一份 `@ubean/i18n`。ALS / catalogs / locale loader
+* 挂在 `globalThis` 上，保证两份模块读写同一份状态；`t()` 委托 scope 上
+* 绑定的 translate（与创建 ctx 的那份 `@intlify/core` 一致）。
+*/
+registerMessageCompiler(compile);
+function createI18nCoreContext(locale, fallback, messages) {
+	return createCoreContext({
+		locale,
+		fallbackLocale: fallback,
+		messages,
+		missingWarn: false,
+		fallbackWarn: false,
+		messageCompiler: compile
+	});
+}
+const ENGINE_KEY = "__UBEAN_I18N_ENGINE__";
+function getState() {
+	const g = globalThis;
+	if (!g[ENGINE_KEY]) g[ENGINE_KEY] = {
+		storage: new AsyncLocalStorage(),
+		catalogs: /* @__PURE__ */ new Map(),
+		catalogMeta: /* @__PURE__ */ new Map(),
+		fallbackLocaleCode: "en",
+		compiled: /* @__PURE__ */ new Map()
+	};
+	if (!g[ENGINE_KEY].compiled) g[ENGINE_KEY].compiled = /* @__PURE__ */ new Map();
+	return g[ENGINE_KEY];
+}
+function setFallbackLocale(code) {
+	getState().fallbackLocaleCode = code;
+}
+function getFallbackLocale() {
+	return getState().fallbackLocaleCode;
+}
+function setLocaleMessages(code, messages) {
+	const state = getState();
+	state.catalogs.set(code, messages);
+	state.compiled.delete(code);
+}
+function getLocaleMessages(code) {
+	return getState().catalogs.get(code);
+}
+function mergeLocaleMessages(code, messages) {
+	const state = getState();
+	const catalogs = state.catalogs;
+	const merged = deepMerge(catalogs.get(code) || {}, messages);
+	catalogs.set(code, merged);
+	state.compiled.delete(code);
+	return merged;
+}
+function setLocaleMeta(code, meta) {
+	const catalogMeta = getState().catalogMeta;
+	const prev = catalogMeta.get(code);
+	catalogMeta.set(code, {
+		name: meta.name ?? prev?.name,
+		dir: meta.dir ?? prev?.dir ?? "ltr",
+		language: meta.language ?? prev?.language,
+		isDefault: meta.isDefault ?? prev?.isDefault
+	});
+}
+function getLocaleMeta(code) {
+	return getState().catalogMeta.get(code);
+}
+function listLocaleCodes() {
+	const { catalogs, catalogMeta } = getState();
+	return Array.from(/* @__PURE__ */ new Set([...catalogs.keys(), ...catalogMeta.keys()]));
+}
+function getRegisteredLocalesMeta() {
+	const { catalogMeta } = getState();
+	return listLocaleCodes().map((code) => {
+		const meta = catalogMeta.get(code);
+		return {
+			code,
+			name: meta?.name,
+			dir: meta?.dir || "ltr",
+			language: meta?.language,
+			isDefault: meta?.isDefault
+		};
+	});
+}
+function getLocaleDir(locale) {
+	const { storage, catalogMeta } = getState();
+	const code = locale || storage.getStore()?.locale;
+	if (!code) return "ltr";
+	return catalogMeta.get(code)?.dir || "ltr";
+}
+function getLocaleName(locale) {
+	const { storage, catalogMeta } = getState();
+	const code = locale || storage.getStore()?.locale;
+	if (!code) return void 0;
+	return catalogMeta.get(code)?.name;
+}
+/**
+* Vite 图里的 `ubean:locales` 在求值时注册；Node 侧中间件通过
+* `ensureLocaleMessages` 调用，避免 `import('ubean:locales')` 在 CLI 进程里 404。
+*/
+function registerLocaleLoader(loader) {
+	getState().loadLocale = loader;
+}
+async function ensureLocaleMessages(locale, fallback) {
+	const loader = getState().loadLocale;
+	if (loader) {
+		await loader(locale);
+		if (fallback && fallback !== locale) await loader(fallback);
+		return;
+	}
+	try {
+		const mod = await import("ubean:locales");
+		if (mod.loadLocale) {
+			getState().loadLocale = mod.loadLocale;
+			await mod.loadLocale(locale);
+			if (fallback && fallback !== locale) await mod.loadLocale(fallback);
+		}
+	} catch {}
+}
+function catalogFingerprint(locale, fallback, catalogs) {
+	const loc = catalogs.get(locale);
+	const fb = locale === fallback ? void 0 : catalogs.get(fallback);
+	return `${locale}:${fallback}:${loc ? Object.keys(loc).join(",") : ""}:${fb ? Object.keys(fb).join(",") : ""}`;
+}
+function createRequestContext(locale, fallback) {
+	const { catalogs, fallbackLocaleCode, compiled } = getState();
+	const fb = fallback ?? fallbackLocaleCode;
+	const fingerprint = catalogFingerprint(locale, fb, catalogs);
+	const cached = compiled.get(locale);
+	if (cached && cached.key === fingerprint) return cached.ctx;
+	const messages = {};
+	const locMsgs = catalogs.get(locale);
+	if (locMsgs) messages[locale] = locMsgs;
+	if (fb !== locale) {
+		const fbMsgs = catalogs.get(fb);
+		if (fbMsgs) messages[fb] = fbMsgs;
+	}
+	const ctx = createI18nCoreContext(locale, fb, messages);
+	compiled.set(locale, {
+		key: fingerprint,
+		ctx
+	});
+	return ctx;
+}
+function bindScope(scope) {
+	if (scope.t && scope.d && scope.n) return scope;
+	const { ctx } = scope;
+	return {
+		...scope,
+		t: (key, ...args) => {
+			try {
+				const result = translate(ctx, key, ...args);
+				return typeof result === "string" ? result : key;
+			} catch {
+				return key;
+			}
+		},
+		d: (value, ...args) => String(datetime(ctx, value, ...args)),
+		n: (value, ...args) => String(number(ctx, value, ...args))
+	};
+}
+function runWithI18n(scope, fn) {
+	return getState().storage.run(bindScope(scope), fn);
+}
+function getI18nScope() {
+	return getState().storage.getStore();
+}
+function getRequestLocale$1() {
+	const scope = getState().storage.getStore();
+	if (!scope) throw new Error("[ubean/i18n] t()/getRequestLocale() called outside request scope (no AsyncLocalStorage store)");
+	return scope.locale;
+}
+function t(key, ...args) {
+	const scope = getState().storage.getStore();
+	if (!scope) throw new Error("[ubean/i18n] t() called outside request scope. Use createI18nMiddleware or runWithI18n().");
+	return (scope.t ?? bindScope(scope).t)(key, ...args);
+}
+function d(value, ...args) {
+	const scope = getState().storage.getStore();
+	if (!scope) throw new Error("[ubean/i18n] d() called outside request scope");
+	return (scope.d ?? bindScope(scope).d)(value, ...args);
+}
+function n(value, ...args) {
+	const scope = getState().storage.getStore();
+	if (!scope) throw new Error("[ubean/i18n] n() called outside request scope");
+	return (scope.n ?? bindScope(scope).n)(value, ...args);
+}
+function isMessageDict(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function deepMerge(target, source) {
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		const srcVal = source[key];
+		const tgtVal = result[key];
+		if (isMessageDict(srcVal) && isMessageDict(tgtVal)) result[key] = deepMerge(tgtVal, srcVal);
+		else result[key] = srcVal;
+	}
+	return result;
+}
+//#endregion
+//#region src/routing.ts
+const DETECT_DEFAULTS = {
+	cookieName: "ubean_locale",
+	redirectOn: "root",
+	alwaysRedirect: false
+};
+function routingFrom(options) {
+	return {
+		defaultLocale: options.defaultLocale,
+		locales: options.locales,
+		strategy: options.strategy
+	};
+}
+function isRootPath(path) {
+	return path === "/" || path === "";
+}
+function shouldSkipDetect(path) {
+	return path.startsWith("/api/") || path.startsWith("/_") || path.startsWith("/__");
+}
+function resolvePreferredFromRequest(c, detect, cookieName, locales, defaultLocale) {
+	if (!detect) return defaultLocale;
+	const cookieLocale = parseLocaleCookie(c.req.header("cookie"), cookieName);
+	if (cookieLocale && locales.includes(cookieLocale)) return cookieLocale;
+	return detectLocaleFromAcceptLanguage(c.req.header("accept-language"), locales, defaultLocale);
+}
+function createI18nMiddleware(options) {
+	const { strategy, defaultLocale, locales } = options;
+	const detect = options.detectBrowserLanguage === false ? false : {
+		...DETECT_DEFAULTS,
+		...options.detectBrowserLanguage
+	};
+	const cookieName = detect ? detect.cookieName : DETECT_DEFAULTS.cookieName;
+	const routing = routingFrom(options);
+	setFallbackLocale(defaultLocale);
+	return async function i18nMiddleware(c, next) {
+		const url = new URL(c.req.url);
+		const path = url.pathname;
+		if (shouldSkipDetect(path)) {
+			const preferred = resolvePreferredFromRequest(c, detect, cookieName, locales, defaultLocale);
+			c.set("locale", preferred);
+			const fallback = getFallbackLocale();
+			if (options.loadMessages) await options.loadMessages(preferred, fallback);
+			else await ensureLocaleMessages(preferred, fallback);
+			await runWithI18n({
+				locale: preferred,
+				fallbackLocale: fallback,
+				ctx: createRequestContext(preferred, fallback)
+			}, () => next());
+			return;
+		}
+		const extracted = extractLocaleFromPath(path, locales);
+		let detectedLocale = defaultLocale;
+		if (extracted.locale && locales.includes(extracted.locale)) {
+			if (strategy === "prefix_except_default" && extracted.locale === defaultLocale) {
+				writeCookie(c, defaultLocale);
+				return c.redirect(extracted.pathWithoutLocale + url.search, 302);
+			}
+			detectedLocale = extracted.locale;
+			c.set("pathWithoutLocale", extracted.pathWithoutLocale);
+		} else if (strategy === "prefix") {
+			const preferred = resolvePreferred();
+			const redirectUrl = localizePath(path, preferred, routing);
+			if (redirectUrl !== path) {
+				writeCookie(c, preferred);
+				return c.redirect(redirectUrl + url.search, 302);
+			}
+			detectedLocale = preferred;
+		} else if (strategy === "prefix_and_default") {
+			detectedLocale = defaultLocale;
+			c.set("pathWithoutLocale", path);
+		} else if (strategy === "prefix_except_default") {
+			if (detect && (detect.redirectOn === "all" || detect.redirectOn === "root" && isRootPath(path))) {
+				const preferred = resolvePreferred();
+				if (preferred !== defaultLocale) {
+					const redirectUrl = localizePath(path, preferred, routing);
+					writeCookie(c, preferred);
+					return c.redirect(redirectUrl + url.search, 302);
+				}
+			}
+			detectedLocale = defaultLocale;
+			c.set("pathWithoutLocale", path);
+		} else if (strategy === "no_prefix") {
+			detectedLocale = resolvePreferred();
+			c.set("pathWithoutLocale", path);
+		}
+		function resolvePreferred() {
+			if (detect) {
+				const cookieLocale = parseLocaleCookie(c.req.header("cookie"), cookieName);
+				if (cookieLocale && locales.includes(cookieLocale)) return cookieLocale;
+				const header = c.req.header("accept-language");
+				return detectLocaleFromAcceptLanguage(header, locales, defaultLocale);
+			}
+			return defaultLocale;
+		}
+		writeCookie(c, detectedLocale);
+		c.set("locale", detectedLocale);
+		c.header("Content-Language", detectedLocale);
+		const fallback = getFallbackLocale();
+		if (options.loadMessages) await options.loadMessages(detectedLocale, fallback);
+		else await ensureLocaleMessages(detectedLocale, fallback);
+		const ctx = createRequestContext(detectedLocale, fallback);
+		await runWithI18n({
+			locale: detectedLocale,
+			fallbackLocale: fallback,
+			ctx
+		}, () => next());
+	};
+	function writeCookie(c, locale) {
+		c.header("Set-Cookie", serializeLocaleCookie(cookieName, locale), { append: true });
+	}
+}
+function getRequestLocale(c) {
+	return c.get("locale") || "en";
+}
+function getPathWithoutLocale(c) {
+	return c.get("pathWithoutLocale") || new URL(c.req.url).pathname;
+}
+//#endregion
+export { t as C, setLocaleMeta as S, n as _, d as a, setFallbackLocale as b, getI18nScope as c, getLocaleMeta as d, getLocaleName as f, mergeLocaleMessages as g, listLocaleCodes as h, createRequestContext as i, getLocaleDir as l, getRequestLocale$1 as m, getPathWithoutLocale as n, ensureLocaleMessages as o, getRegisteredLocalesMeta as p, getRequestLocale as r, getFallbackLocale as s, createI18nMiddleware as t, getLocaleMessages as u, registerLocaleLoader as v, setLocaleMessages as x, runWithI18n as y };

package/dist/routing.d.ts

@@ -1,27 +1,9 @@
-import { I18nRoutingStrategy } from "./index.js";
+import { a as switchLocalePath, d as I18nRoutingStrategy, i as localizePath, n as extractLocaleFromPath, t as compileLocalePaths, u as I18nMiddlewareOptions } from "./paths-CJVBLGJS.js";
 import { Context, MiddlewareHandler } from "hono";
 import { UbeanEnv } from "@ubean/shared";
 //#region src/routing.d.ts
-interface I18nRoutingOptions {
-  strategy?: I18nRoutingStrategy;
-  defaultLocale?: string;
-  locales?: string[];
-  detectFromHeader?: boolean;
-  detectFromCookie?: boolean | string;
-  redirectOnLocaleMismatch?: boolean;
-  cookieName?: string;
-}
-declare function createI18nMiddleware(options?: I18nRoutingOptions): MiddlewareHandler<UbeanEnv>;
-declare function switchLocalePath(c: Context, locale: string, strategy?: I18nRoutingStrategy, defaultLocale?: string): string;
-declare function getLocalePath(c: Context): string;
+declare function createI18nMiddleware(options: I18nMiddlewareOptions): MiddlewareHandler<UbeanEnv>;
+declare function getRequestLocale(c: Context): string;
 declare function getPathWithoutLocale(c: Context): string;
-declare function localeRoutes(locales: string[], defaultLocale: string, strategy?: I18nRoutingStrategy): {
-  localizePath: (path: string, locale?: string) => string;
-  getLocaleFromUrl: (url: string) => string | null;
-  getLocalizedPaths: (path: string) => Array<{
-    locale: string;
-    path: string;
-  }>;
-};
 //#endregion
-export { I18nRoutingOptions, type I18nRoutingStrategy, createI18nMiddleware, getLocalePath, getPathWithoutLocale, localeRoutes, switchLocalePath };
+export { type I18nMiddlewareOptions, type I18nRoutingStrategy, compileLocalePaths, createI18nMiddleware, extractLocaleFromPath, getPathWithoutLocale, getRequestLocale, localizePath, switchLocalePath };

package/dist/routing.js

@@ -1,129 +1,3 @@
-import { useI18n } from "./index.js";
-//#region src/routing.ts
-function getLocaleFromPath(path, locales) {
-	const segments = path.split("/");
-	if (segments.length >= 2 && locales.includes(segments[1])) {
-		const remainingPath = segments.slice(2).join("/");
-		return {
-			locale: segments[1],
-			pathWithoutLocale: remainingPath ? `/${remainingPath}` : "/"
-		};
-	}
-	return {
-		locale: null,
-		pathWithoutLocale: path
-	};
-}
-function createI18nMiddleware(options = {}) {
-	const { strategy = "prefix_except_default", defaultLocale: explicitDefault, locales: explicitLocales, detectFromHeader = true, detectFromCookie = true, redirectOnLocaleMismatch = true, cookieName = "ubean_locale" } = options;
-	return async function i18nMiddleware(c, next) {
-		const i18n = useI18n();
-		const resolvedDefaultLocale = explicitDefault || i18n.fallbackLocale;
-		const resolvedLocales = explicitLocales || i18n.availableLocales;
-		const path = new URL(c.req.url).pathname;
-		let detectedLocale = resolvedDefaultLocale;
-		if (strategy === "prefix" || strategy === "prefix_except_default" || strategy === "prefix_and_default") {
-			const { locale: pathLocale, pathWithoutLocale } = getLocaleFromPath(path, resolvedLocales);
-			if (pathLocale) {
-				detectedLocale = pathLocale;
-				c.set("locale", pathLocale);
-				c.set("pathWithoutLocale", pathWithoutLocale);
-			} else if (strategy === "prefix_and_default") {
-				detectedLocale = resolvedDefaultLocale;
-				c.set("pathWithoutLocale", path);
-			} else if (strategy === "prefix") {
-				const preferredLocale = resolvePreferredLocale();
-				if (redirectOnLocaleMismatch && preferredLocale !== resolvedDefaultLocale) {
-					const redirectUrl = `/${preferredLocale}${path === "/" ? "" : path}`;
-					return c.redirect(redirectUrl, 302);
-				}
-				if (redirectOnLocaleMismatch) return c.redirect(`/${resolvedDefaultLocale}${path === "/" ? "" : path}`, 302);
-			} else if (strategy === "prefix_except_default") {
-				const preferredLocale = resolvePreferredLocale();
-				if (preferredLocale !== resolvedDefaultLocale && redirectOnLocaleMismatch) return c.redirect(`/${preferredLocale}${path === "/" ? "" : path}`, 302);
-				detectedLocale = resolvedDefaultLocale;
-			}
-		} else if (strategy === "no_prefix") detectedLocale = resolvePreferredLocale();
-		function resolvePreferredLocale() {
-			if (detectFromCookie) {
-				const cookieLocale = c.req.header("cookie");
-				if (cookieLocale) {
-					const match = cookieLocale.match(new RegExp(`${cookieName}=([^;]+)`));
-					if (match && resolvedLocales.includes(match[1])) return match[1];
-				}
-			}
-			if (detectFromHeader) {
-				const acceptLang = c.req.header("accept-language");
-				if (acceptLang) {
-					const detected = i18n.detectLocale(acceptLang);
-					if (resolvedLocales.includes(detected)) return detected;
-				}
-			}
-			return resolvedDefaultLocale;
-		}
-		if (resolvedLocales.includes(detectedLocale)) i18n.setLocale(detectedLocale);
-		c.set("locale", detectedLocale);
-		c.header("Content-Language", detectedLocale);
-		await next();
-	};
-}
-function switchLocalePath(c, locale, strategy = "prefix_except_default", defaultLocale) {
-	const path = new URL(c.req.url).pathname;
-	const i18n = useI18n();
-	const resolvedDefault = defaultLocale || i18n.fallbackLocale;
-	const resolvedLocales = i18n.availableLocales;
-	const { pathWithoutLocale } = getLocaleFromPath(path, resolvedLocales);
-	const cleanPath = pathWithoutLocale === "/" ? "" : pathWithoutLocale;
-	switch (strategy) {
-		case "no_prefix": return path;
-		case "prefix": return `/${locale}${cleanPath}`;
-		case "prefix_except_default":
-		case "prefix_and_default":
-			if (locale === resolvedDefault) return cleanPath || "/";
-			return `/${locale}${cleanPath}`;
-		default: return path;
-	}
-}
-function getLocalePath(c) {
-	return c.get("locale") || "en";
-}
-function getPathWithoutLocale(c) {
-	return c.get("pathWithoutLocale") || new URL(c.req.url).pathname;
-}
-function localeRoutes(locales, defaultLocale, strategy = "prefix_except_default") {
-	function localizePath(path, locale) {
-		const targetLocale = locale || defaultLocale;
-		const cleanPath = path.startsWith("/") ? path : `/${path}`;
-		switch (strategy) {
-			case "no_prefix": return cleanPath;
-			case "prefix": return `/${targetLocale}${cleanPath === "/" ? "" : cleanPath}`;
-			case "prefix_except_default":
-			case "prefix_and_default":
-				if (targetLocale === defaultLocale) return cleanPath;
-				return `/${targetLocale}${cleanPath === "/" ? "" : cleanPath}`;
-		}
-	}
-	function getLocaleFromUrl(url) {
-		try {
-			const pathname = new URL(url).pathname;
-			const { locale } = getLocaleFromPath(pathname, locales);
-			return locale;
-		} catch {
-			const { locale } = getLocaleFromPath(url, locales);
-			return locale;
-		}
-	}
-	function getLocalizedPaths(path) {
-		return locales.map((locale) => ({
-			locale,
-			path: localizePath(path, locale)
-		}));
-	}
-	return {
-		localizePath,
-		getLocaleFromUrl,
-		getLocalizedPaths
-	};
-}
-//#endregion
-export { createI18nMiddleware, getLocalePath, getPathWithoutLocale, localeRoutes, switchLocalePath };
+import { a as extractLocaleFromPath, c as switchLocalePath, i as compileLocalePaths, s as localizePath } from "./detect-BIURd4aL.js";
+import { n as getPathWithoutLocale, r as getRequestLocale, t as createI18nMiddleware } from "./routing-D4Y0l8jV.js";
+export { compileLocalePaths, createI18nMiddleware, extractLocaleFromPath, getPathWithoutLocale, getRequestLocale, localizePath, switchLocalePath };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ubean/i18n",
-  "version": "0.2.2",
-  "description": "Zero-dependency i18n for ubean (defineLocale, t, formatDate, routing)",
+  "version": "0.3.0",
+  "description": "i18n for ubean (vue-i18n / @intlify/core, compact locale routing, ALS)",
   "files": [
     "dist"
   ],
@@ -17,17 +17,25 @@
     "./routing": {
       "types": "./dist/routing.d.ts",
       "import": "./dist/routing.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js"
     }
   },
   "dependencies": {
+    "@intlify/core": "11.4.8",
     "hono": "4.13.3",
-    "@ubean/shared": "0.2.2"
+    "@ubean/shared": "0.3.0"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",
     "typescript": "7.0.2",
     "vite-plus": "0.2.9"
   },
+  "engines": {
+    "node": ">=22"
+  },
   "scripts": {
     "build": "vp pack",
     "dev": "vp pack --watch",