@ubean/i18n 0.1.1 → 0.1.3

package/dist/index.d.ts

@@ -0,0 +1,96 @@
+//#region src/index.d.ts
+type I18nRoutingStrategy = 'prefix' | 'prefix_except_default' | 'prefix_and_default' | 'no_prefix';
+type DateTimeFormatStyle = 'short' | 'medium' | 'long' | 'full';
+type NumberFormatStyle = 'decimal' | 'percent' | 'currency';
+type ListFormatStyle = 'conjunction' | 'disjunction' | 'unit';
+type RelativeTimeUnit = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year';
+interface I18nConfig {
+  defaultLocale: string;
+  strategy: I18nRoutingStrategy;
+  locales: string[];
+}
+interface LocaleMessages {
+  [key: string]: string | LocaleMessages;
+}
+interface LocaleDefinition {
+  code: string;
+  messages: LocaleMessages;
+  name?: string;
+  dir?: 'ltr' | 'rtl';
+  isDefault?: boolean;
+}
+type LocaleChangeCallback = (locale: string) => void;
+type MissingKeyHandler = (locale: string, key: string) => void;
+interface NumberFormatOptions extends Intl.NumberFormatOptions {
+  style?: NumberFormatStyle;
+}
+interface I18nInstance {
+  locale: string;
+  fallbackLocale: string;
+  availableLocales: string[];
+  t(key: string, params?: Record<string, string | number>): string;
+  d(value: Date | number, style?: DateTimeFormatStyle, options?: Intl.DateTimeFormatOptions): string;
+  n(value: number, style?: NumberFormatStyle, options?: NumberFormatOptions): string;
+  c(value: number, currency: string, options?: Intl.NumberFormatOptions): string;
+  relativeTime(value: number, unit: RelativeTimeUnit, options?: Intl.RelativeTimeFormatOptions): string;
+  list(items: string[], style?: ListFormatStyle, options?: Intl.ListFormatOptions): string;
+  setLocale(locale: string): void;
+  getLocale(): string;
+  addLocale(code: string, messages: LocaleMessages, options?: {
+    name?: string;
+    dir?: 'ltr' | 'rtl';
+  }): void;
+  mergeLocale(code: string, messages: LocaleMessages): void;
+  detectLocale(acceptLanguage?: string): string;
+  onLocaleChange(callback: LocaleChangeCallback): () => void;
+  getLocaleDir(locale?: string): 'ltr' | 'rtl';
+  getLocaleName(locale?: string): string | undefined;
+  onMissingKey(handler: MissingKeyHandler): () => void;
+}
+declare function defineLocale(definition: LocaleDefinition): LocaleDefinition;
+declare function setI18nConfig(config: Partial<I18nConfig>): void;
+declare function getI18nConfig(): I18nConfig;
+declare function getDefaultLocale(): string;
+declare function localizePath(path: string, locale?: string): string;
+declare function switchLocalePath(newLocale: string, currentPath?: string): string;
+declare function extractLocaleFromPath(path: string): {
+  locale: string | null;
+  pathWithoutLocale: string;
+};
+declare function useI18n(): I18nInstance;
+declare function t(key: string, params?: Record<string, string | number>): string;
+declare function setLocale(locale: string): void;
+declare function getLocale(): string;
+declare function getRegisteredLocales(): string[];
+interface LocaleMeta {
+  code: string;
+  name?: string;
+  dir: 'ltr' | 'rtl';
+  isDefault?: boolean;
+}
+/**
+ * Returns metadata for all registered locales (without messages).
+ * Used by SSR to serialize the full locale list so the client can
+ * register all available locales during hydration — preventing
+ * `availableLocales` hydration mismatches.
+ */
+declare function getRegisteredLocalesMeta(): LocaleMeta[];
+declare function getLocaleMessages(locale?: string): LocaleMessages | undefined;
+declare function clearLocales(): void;
+declare function onLocaleChange(callback: LocaleChangeCallback): () => void;
+declare function getLocaleDir(locale?: string): 'ltr' | 'rtl';
+declare function getLocaleName(locale?: string): string | undefined;
+declare function detectLocale(acceptLanguage?: string): string;
+declare function addLocale(code: string, messages: LocaleMessages, options?: {
+  name?: string;
+  dir?: 'ltr' | 'rtl';
+}): void;
+declare function mergeLocale(code: string, messages: LocaleMessages): void;
+declare function detectBrowserLocale(): string;
+declare function formatDate(value: Date | number, style?: DateTimeFormatStyle, options?: Intl.DateTimeFormatOptions): string;
+declare function formatNumber(value: number, style?: NumberFormatStyle, options?: NumberFormatOptions): string;
+declare function formatCurrency(value: number, currency: string, options?: Intl.NumberFormatOptions): string;
+declare function formatRelativeTime(value: number, unit: RelativeTimeUnit, options?: Intl.RelativeTimeFormatOptions): string;
+declare function formatList(items: string[], style?: ListFormatStyle, options?: Intl.ListFormatOptions): string;
+//#endregion
+export { DateTimeFormatStyle, I18nConfig, I18nInstance, I18nRoutingStrategy, ListFormatStyle, LocaleChangeCallback, LocaleDefinition, LocaleMessages, LocaleMeta, MissingKeyHandler, NumberFormatOptions, NumberFormatStyle, RelativeTimeUnit, addLocale, clearLocales, defineLocale, detectBrowserLocale, detectLocale, extractLocaleFromPath, formatCurrency, formatDate, formatList, formatNumber, formatRelativeTime, getDefaultLocale, getI18nConfig, getLocale, getLocaleDir, getLocaleMessages, getLocaleName, getRegisteredLocales, getRegisteredLocalesMeta, localizePath, mergeLocale, onLocaleChange, setI18nConfig, setLocale, switchLocalePath, t, useI18n };

package/dist/index.js

@@ -0,0 +1,447 @@
+//#region src/index.ts
+const I18N_STATE_KEY = "__ubean_i18n_state__";
+function getI18nState() {
+	const g = globalThis;
+	if (!g[I18N_STATE_KEY]) g[I18N_STATE_KEY] = {
+		registeredLocales: /* @__PURE__ */ new Map(),
+		messageCache: /* @__PURE__ */ new Map(),
+		currentLocale: "en",
+		fallbackLocale: "en",
+		localeListeners: /* @__PURE__ */ new Set(),
+		missingKeyHandlers: /* @__PURE__ */ new Set(),
+		missingKeyWarned: /* @__PURE__ */ new Set(),
+		i18nConfig: {
+			defaultLocale: "en",
+			strategy: "prefix_except_default",
+			locales: []
+		}
+	};
+	return g[I18N_STATE_KEY];
+}
+function notifyLocaleChange(locale) {
+	for (const fn of getI18nState().localeListeners) fn(locale);
+}
+function addLocaleListener(callback) {
+	getI18nState().localeListeners.add(callback);
+	return () => getI18nState().localeListeners.delete(callback);
+}
+function addMissingKeyHandler(handler) {
+	getI18nState().missingKeyHandlers.add(handler);
+	return () => getI18nState().missingKeyHandlers.delete(handler);
+}
+function notifyMissingKey(locale, key) {
+	const state = getI18nState();
+	const cacheKey = `${locale}:${key}`;
+	if (!state.missingKeyWarned.has(cacheKey)) {
+		state.missingKeyWarned.add(cacheKey);
+		for (const fn of state.missingKeyHandlers) fn(locale, key);
+		if (typeof process !== "undefined" && process.env && process.env.NODE_ENV === "development") console.warn(`[i18n] Missing key "${key}" for locale "${locale}"`);
+	}
+}
+function invalidateCache(locale) {
+	getI18nState().messageCache.delete(locale);
+}
+function deepMerge(target, source) {
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		const sourceVal = source[key];
+		const targetVal = result[key];
+		if (sourceVal && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal && typeof targetVal === "object" && !Array.isArray(targetVal)) result[key] = deepMerge(targetVal, sourceVal);
+		else result[key] = sourceVal;
+	}
+	return result;
+}
+function flattenMessages(messages, prefix = "") {
+	const result = {};
+	for (const [key, value] of Object.entries(messages)) {
+		const fullKey = prefix ? `${prefix}.${key}` : key;
+		if (typeof value === "string") result[fullKey] = value;
+		else if (value && typeof value === "object") Object.assign(result, flattenMessages(value, fullKey));
+	}
+	return result;
+}
+function getFlatMessages(locale) {
+	const state = getI18nState();
+	const cached = state.messageCache.get(locale);
+	if (cached) return cached;
+	const localeData = state.registeredLocales.get(locale);
+	if (!localeData) return {};
+	const flat = flattenMessages(localeData.messages);
+	state.messageCache.set(locale, flat);
+	return flat;
+}
+function getPluralCategory(count, locale) {
+	try {
+		return new Intl.PluralRules(locale).select(count);
+	} catch {
+		return count === 0 ? "zero" : count === 1 ? "one" : "other";
+	}
+}
+function selectPlural(template, count, locale) {
+	const parts = template.split("|").map((p) => p.trim());
+	if (parts.length === 1) return template;
+	for (const part of parts) {
+		const eqMatch = part.match(/^=(\d+)\s*/);
+		if (eqMatch) {
+			if (parseInt(eqMatch[1], 10) === count) return part.replace(/^=\d+\s*/, "");
+		}
+	}
+	const explicitCategories = [];
+	const plainParts = [];
+	for (const part of parts) {
+		if (/^=\d+\s*/.test(part)) continue;
+		const catMatch = part.match(/^(\w+):\s*/);
+		if (catMatch) explicitCategories.push({
+			cat: catMatch[1],
+			text: part.replace(/^\w+:\s*/, "")
+		});
+		else plainParts.push(part);
+	}
+	for (const { cat, text } of explicitCategories) {
+		if (cat === "zero" && count === 0) return text;
+		if (cat === "one" && count === 1) return text;
+		if (cat === getPluralCategory(count, locale)) return text;
+	}
+	if (plainParts.length === 2) return count === 1 ? plainParts[0] : plainParts[1];
+	if (plainParts.length >= 3) {
+		if (count === 0) return plainParts[0];
+		if (count === 1) return plainParts[1];
+		return plainParts[plainParts.length - 1];
+	}
+	if (plainParts.length === 1) return plainParts[0];
+	const category = getPluralCategory(count, locale);
+	const categoryIndex = [
+		"zero",
+		"one",
+		"two",
+		"few",
+		"many",
+		"other"
+	].indexOf(category);
+	if (categoryIndex >= 0 && categoryIndex < parts.length) return parts[categoryIndex];
+	return parts[parts.length - 1];
+}
+function resolveLinkedMessages(template, flat, visited = /* @__PURE__ */ new Set()) {
+	return template.replace(/@(?::([\w.]+)|{([\w.]+)})/g, (_match, colonKey, braceKey) => {
+		const key = colonKey || braceKey;
+		if (!key || visited.has(key)) return _match;
+		visited.add(key);
+		const linked = flat[key];
+		if (linked === void 0) return _match;
+		const resolved = resolveLinkedMessages(linked, flat, visited);
+		visited.delete(key);
+		return resolved;
+	});
+}
+function interpolate(template, params, locale, flat) {
+	let result = template;
+	if (flat) result = resolveLinkedMessages(result, flat);
+	if (params && typeof params.count === "number") result = selectPlural(result, params.count, locale || "en");
+	if (params) result = result.replace(/\{(\w+)\}/g, (_, key) => {
+		const val = params[key];
+		return val !== void 0 ? String(val) : `{${key}}`;
+	});
+	return result;
+}
+function getMessage(locale, key, params) {
+	const flat = getFlatMessages(locale);
+	const msg = flat[key];
+	if (msg === void 0) return void 0;
+	return interpolate(msg, params, locale, flat);
+}
+function defineLocale(definition) {
+	const state = getI18nState();
+	const locale = {
+		code: definition.code,
+		messages: definition.messages,
+		name: definition.name,
+		dir: definition.dir || "ltr",
+		isDefault: definition.isDefault
+	};
+	state.registeredLocales.set(definition.code, locale);
+	invalidateCache(definition.code);
+	if (definition.isDefault || state.registeredLocales.size === 1) {
+		state.fallbackLocale = definition.code;
+		if (!state.currentLocale || state.currentLocale === "en") state.currentLocale = definition.code;
+	}
+	return definition;
+}
+function setI18nConfig(config) {
+	const state = getI18nState();
+	state.i18nConfig = {
+		...state.i18nConfig,
+		...config
+	};
+	if (config.defaultLocale) state.fallbackLocale = config.defaultLocale;
+}
+function getI18nConfig() {
+	const state = getI18nState();
+	return {
+		...state.i18nConfig,
+		locales: Array.from(state.registeredLocales.keys())
+	};
+}
+function getDefaultLocale() {
+	const state = getI18nState();
+	for (const [code, loc] of state.registeredLocales) if (loc.isDefault) return code;
+	return state.i18nConfig.defaultLocale;
+}
+function localizePath(path, locale) {
+	const state = getI18nState();
+	const targetLocale = locale || state.currentLocale;
+	const defaultLocale = getDefaultLocale();
+	const strategy = state.i18nConfig.strategy;
+	const cleanPath = path.replace(/^\/+/, "/").replace(/\/+$/, "") || "/";
+	if (strategy === "no_prefix") return cleanPath;
+	const pathParts = cleanPath.split("/").filter(Boolean);
+	const firstSegment = pathParts[0] || "";
+	const isLocalePrefix = state.registeredLocales.has(firstSegment);
+	let pathWithoutPrefix = cleanPath;
+	if (isLocalePrefix) {
+		const rest = pathParts.slice(1).join("/");
+		pathWithoutPrefix = rest ? `/${rest}` : "/";
+	}
+	if ((strategy === "prefix_except_default" || strategy === "prefix_and_default") && targetLocale === defaultLocale) return pathWithoutPrefix;
+	return `/${targetLocale}${pathWithoutPrefix === "/" ? "" : pathWithoutPrefix}`;
+}
+function switchLocalePath(newLocale, currentPath) {
+	const _global = globalThis;
+	return localizePath(currentPath || (typeof _global.window !== "undefined" ? _global.window.location.pathname : "/"), newLocale);
+}
+function extractLocaleFromPath(path) {
+	const state = getI18nState();
+	const pathParts = path.split("/").filter(Boolean);
+	const firstSegment = pathParts[0] || "";
+	if (state.registeredLocales.has(firstSegment)) {
+		const rest = pathParts.slice(1).join("/");
+		return {
+			locale: firstSegment,
+			pathWithoutLocale: rest ? `/${rest}` : "/"
+		};
+	}
+	return {
+		locale: null,
+		pathWithoutLocale: path
+	};
+}
+function useI18n() {
+	return {
+		get locale() {
+			return getI18nState().currentLocale;
+		},
+		get fallbackLocale() {
+			return getI18nState().fallbackLocale;
+		},
+		get availableLocales() {
+			return Array.from(getI18nState().registeredLocales.keys());
+		},
+		t(key, params) {
+			const state = getI18nState();
+			let message = getMessage(state.currentLocale, key, params);
+			if (message === void 0 && state.currentLocale !== state.fallbackLocale) message = getMessage(state.fallbackLocale, key, params);
+			if (message === void 0) {
+				notifyMissingKey(state.currentLocale, key);
+				return key;
+			}
+			return message;
+		},
+		d(value, style = "short", options) {
+			try {
+				const date = value instanceof Date ? value : new Date(value);
+				if (isNaN(date.getTime())) throw new Error("Invalid date");
+				return new Intl.DateTimeFormat(getI18nState().currentLocale, {
+					dateStyle: style,
+					...options
+				}).format(date);
+			} catch {
+				const date = value instanceof Date ? value : new Date(value);
+				if (isNaN(date.getTime())) return String(value);
+				return date.toISOString().split("T")[0];
+			}
+		},
+		n(value, style = "decimal", options) {
+			try {
+				return new Intl.NumberFormat(getI18nState().currentLocale, {
+					style,
+					...options
+				}).format(value);
+			} catch {
+				return String(value);
+			}
+		},
+		c(value, currency, options) {
+			try {
+				return new Intl.NumberFormat(getI18nState().currentLocale, {
+					style: "currency",
+					currency,
+					...options
+				}).format(value);
+			} catch {
+				return `${currency} ${value}`;
+			}
+		},
+		relativeTime(value, unit, options) {
+			try {
+				return new Intl.RelativeTimeFormat(getI18nState().currentLocale, options).format(value, unit);
+			} catch {
+				return `${value >= 0 ? "in " : ""}${Math.abs(value)} ${unit}${value === 1 ? "" : "s"}${value < 0 ? " ago" : ""}`;
+			}
+		},
+		list(items, style = "conjunction", options) {
+			try {
+				return new Intl.ListFormat(getI18nState().currentLocale, {
+					type: style,
+					...options
+				}).format(items);
+			} catch {
+				return items.join(", ");
+			}
+		},
+		setLocale(locale) {
+			const state = getI18nState();
+			if (state.registeredLocales.has(locale) && locale !== state.currentLocale) {
+				state.currentLocale = locale;
+				notifyLocaleChange(locale);
+			}
+		},
+		getLocale() {
+			return getI18nState().currentLocale;
+		},
+		addLocale(code, messages, options) {
+			const state = getI18nState();
+			const existing = state.registeredLocales.get(code);
+			if (existing) {
+				existing.messages = deepMerge(existing.messages, messages);
+				if (options?.name) existing.name = options.name;
+				if (options?.dir) existing.dir = options.dir;
+			} else state.registeredLocales.set(code, {
+				code,
+				messages,
+				name: options?.name,
+				dir: options?.dir || "ltr"
+			});
+			invalidateCache(code);
+			state.missingKeyWarned = /* @__PURE__ */ new Set();
+		},
+		mergeLocale(code, messages) {
+			const state = getI18nState();
+			const existing = state.registeredLocales.get(code);
+			if (existing) existing.messages = deepMerge(existing.messages, messages);
+			else state.registeredLocales.set(code, {
+				code,
+				messages,
+				dir: "ltr"
+			});
+			invalidateCache(code);
+			state.missingKeyWarned = /* @__PURE__ */ new Set();
+		},
+		detectLocale(acceptLanguage) {
+			const state = getI18nState();
+			if (!acceptLanguage) return state.fallbackLocale;
+			const requested = acceptLanguage.split(",").map((lang) => {
+				const [code, q = "q=1.0"] = lang.trim().split(";");
+				const quality = parseFloat(q.replace("q=", "")) || 0;
+				return {
+					code: code.trim().toLowerCase(),
+					quality
+				};
+			}).sort((a, b) => b.quality - a.quality);
+			for (const { code } of requested) for (const registered of state.registeredLocales.keys()) if (code === registered.toLowerCase() || code.startsWith(`${registered.toLowerCase()}-`)) return registered;
+			return state.fallbackLocale;
+		},
+		onLocaleChange: addLocaleListener,
+		onMissingKey: addMissingKeyHandler,
+		getLocaleDir(locale) {
+			const state = getI18nState();
+			const code = locale || state.currentLocale;
+			return state.registeredLocales.get(code)?.dir || "ltr";
+		},
+		getLocaleName(locale) {
+			const state = getI18nState();
+			const code = locale || state.currentLocale;
+			return state.registeredLocales.get(code)?.name;
+		}
+	};
+}
+function t(key, params) {
+	return useI18n().t(key, params);
+}
+function setLocale(locale) {
+	useI18n().setLocale(locale);
+}
+function getLocale() {
+	return useI18n().getLocale();
+}
+function getRegisteredLocales() {
+	return Array.from(getI18nState().registeredLocales.keys());
+}
+/**
+* Returns metadata for all registered locales (without messages).
+* Used by SSR to serialize the full locale list so the client can
+* register all available locales during hydration — preventing
+* `availableLocales` hydration mismatches.
+*/
+function getRegisteredLocalesMeta() {
+	const state = getI18nState();
+	return Array.from(state.registeredLocales.values()).map((loc) => ({
+		code: loc.code,
+		name: loc.name,
+		dir: loc.dir,
+		isDefault: loc.isDefault
+	}));
+}
+function getLocaleMessages(locale) {
+	const state = getI18nState();
+	const code = locale || state.currentLocale;
+	return state.registeredLocales.get(code)?.messages;
+}
+function clearLocales() {
+	const state = getI18nState();
+	state.registeredLocales.clear();
+	state.localeListeners.clear();
+	state.missingKeyHandlers.clear();
+	state.messageCache.clear();
+	state.missingKeyWarned = /* @__PURE__ */ new Set();
+	state.currentLocale = "en";
+	state.fallbackLocale = "en";
+}
+function onLocaleChange(callback) {
+	return useI18n().onLocaleChange(callback);
+}
+function getLocaleDir(locale) {
+	return useI18n().getLocaleDir(locale);
+}
+function getLocaleName(locale) {
+	return useI18n().getLocaleName(locale);
+}
+function detectLocale(acceptLanguage) {
+	return useI18n().detectLocale(acceptLanguage);
+}
+function addLocale(code, messages, options) {
+	useI18n().addLocale(code, messages, options);
+}
+function mergeLocale(code, messages) {
+	useI18n().mergeLocale(code, messages);
+}
+function detectBrowserLocale() {
+	const i18n = useI18n();
+	if (typeof navigator !== "undefined" && navigator.language) return i18n.detectLocale(navigator.language);
+	return getI18nState().fallbackLocale;
+}
+function formatDate(value, style, options) {
+	return useI18n().d(value, style, options);
+}
+function formatNumber(value, style, options) {
+	return useI18n().n(value, style, options);
+}
+function formatCurrency(value, currency, options) {
+	return useI18n().c(value, currency, options);
+}
+function formatRelativeTime(value, unit, options) {
+	return useI18n().relativeTime(value, unit, options);
+}
+function formatList(items, style, options) {
+	return useI18n().list(items, style, options);
+}
+//#endregion
+export { addLocale, clearLocales, defineLocale, detectBrowserLocale, detectLocale, extractLocaleFromPath, formatCurrency, formatDate, formatList, formatNumber, formatRelativeTime, getDefaultLocale, getI18nConfig, getLocale, getLocaleDir, getLocaleMessages, getLocaleName, getRegisteredLocales, getRegisteredLocalesMeta, localizePath, mergeLocale, onLocaleChange, setI18nConfig, setLocale, switchLocalePath, t, useI18n };

package/dist/routing.d.ts

@@ -0,0 +1,27 @@
+import { I18nRoutingStrategy } from "./index.js";
+import { Context, MiddlewareHandler } from "hono";
+import { UbeanEnv } from "@ubean/types";
+//#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 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 };

package/dist/routing.js

@@ -0,0 +1,129 @@
+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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ubean/i18n",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Zero-dependency i18n for ubean (defineLocale, t, formatDate, routing)",
   "files": [
     "dist"
@@ -21,7 +21,7 @@
   },
   "dependencies": {
     "hono": "4.12.32",
-    "@ubean/types": "0.1.1"
+    "@ubean/types": "0.1.3"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",