@ubean/i18n 0.2.2 → 0.3.1

package/dist/browser.d.ts

@@ -0,0 +1,3 @@
+import { a as switchLocalePath, c as HonoLocalePath, d as I18nRoutingStrategy, f as LocaleRoutingConfig, i as localizePath, l as I18nLocaleMeta, n as extractLocaleFromPath, o as toVueRouterLocalePath, r as getVueLocaleParam, s as CompiledLocalePath, t as compileLocalePaths } from "./paths-CJVBLGJS.js";
+import { a as parseLocaleCookie, i as detectLocaleFromAcceptLanguage, n as LocaleHeadTags, o as serializeLocaleCookie, r as buildLocaleHead, t as LocaleHeadInput } from "./head-CT8nH37d.js";
+export { type CompiledLocalePath, type HonoLocalePath, type I18nLocaleMeta, type I18nRoutingStrategy, type LocaleHeadInput, type LocaleHeadTags, type LocaleRoutingConfig, buildLocaleHead, compileLocalePaths, detectLocaleFromAcceptLanguage, extractLocaleFromPath, getVueLocaleParam, localizePath, parseLocaleCookie, serializeLocaleCookie, switchLocalePath, toVueRouterLocalePath };

package/dist/browser.js

@@ -0,0 +1,3 @@
+import { a as extractLocaleFromPath, c as switchLocalePath, i as compileLocalePaths, l as toVueRouterLocalePath, n as parseLocaleCookie, o as getVueLocaleParam, r as serializeLocaleCookie, s as localizePath, t as detectLocaleFromAcceptLanguage } from "./detect-BIURd4aL.js";
+import { t as buildLocaleHead } from "./head-BzEFwnlD.js";
+export { buildLocaleHead, compileLocalePaths, detectLocaleFromAcceptLanguage, extractLocaleFromPath, getVueLocaleParam, localizePath, parseLocaleCookie, serializeLocaleCookie, switchLocalePath, toVueRouterLocalePath };

package/dist/detect-BIURd4aL.js

@@ -0,0 +1,145 @@
+//#region src/paths.ts
+function escapeRegex(code) {
+	return code.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function joinCodes(codes) {
+	return codes.map(escapeRegex).join("|");
+}
+function normalizePath(path) {
+	if (!path || path === "") return "/";
+	const withSlash = path.startsWith("/") ? path : `/${path}`;
+	if (withSlash.length > 1 && withSlash.endsWith("/")) return withSlash.slice(0, -1);
+	return withSlash;
+}
+/**
+* vue-router locale param segment for the given strategy.
+*
+* - `prefix_except_default`: `:locale(zh)?` (default unprefixed; `/en/about` 不匹配)
+* - `prefix`: `:locale(en|zh)` (required)
+* - `prefix_and_default`: `:locale(en|zh)?` (`/about` 与 `/en/about` 都匹配)
+* - `no_prefix`: empty
+*/
+function getVueLocaleParam(cfg) {
+	const { strategy, defaultLocale, locales } = cfg;
+	const others = locales.filter((c) => c !== defaultLocale);
+	switch (strategy) {
+		case "no_prefix": return "";
+		case "prefix": return locales.length === 0 ? "" : `:locale(${joinCodes(locales)})`;
+		case "prefix_except_default":
+			if (others.length === 0) return "";
+			return `:locale(${joinCodes(others)})?`;
+		case "prefix_and_default":
+			if (locales.length === 0) return "";
+			return `:locale(${joinCodes(locales)})?`;
+		default: return "";
+	}
+}
+/** Apply a vue-router locale param to a page path (`/` / `/about` / catch-all). */
+function toVueRouterLocalePath(pagePath, localeParam) {
+	if (!localeParam) return pagePath;
+	const path = normalizePath(pagePath);
+	if (path === "/") return `/${localeParam}`;
+	return `/${localeParam}${path}`;
+}
+function extractLocaleFromPath(path, localeCodes) {
+	const normalized = normalizePath(path);
+	const segments = normalized.split("/").filter(Boolean);
+	const first = segments[0];
+	if (first && localeCodes.includes(first)) {
+		const rest = segments.slice(1).join("/");
+		return {
+			locale: first,
+			pathWithoutLocale: rest ? `/${rest}` : "/"
+		};
+	}
+	return {
+		locale: null,
+		pathWithoutLocale: normalized
+	};
+}
+function localizePath(path, locale, cfg) {
+	const { pathWithoutLocale } = extractLocaleFromPath(path, cfg.locales);
+	const clean = pathWithoutLocale;
+	const suffix = clean === "/" ? "" : clean;
+	switch (cfg.strategy) {
+		case "no_prefix": return clean;
+		case "prefix": return `/${locale}${suffix}`;
+		case "prefix_except_default":
+		case "prefix_and_default":
+			if (locale === cfg.defaultLocale) return clean;
+			return `/${locale}${suffix}`;
+		default: return clean;
+	}
+}
+function switchLocalePath(locale, currentPath, cfg) {
+	return localizePath(currentPath, locale, cfg);
+}
+function honoPathsFor(pagePath, cfg) {
+	const path = normalizePath(pagePath);
+	const suffix = path === "/" ? "" : path;
+	const { defaultLocale, locales, strategy } = cfg;
+	const result = [];
+	const push = (mounted, locale, isDefault) => {
+		result.push({
+			path: mounted || "/",
+			locale,
+			isDefault
+		});
+	};
+	switch (strategy) {
+		case "no_prefix":
+			push(path, defaultLocale, true);
+			break;
+		case "prefix":
+			for (const locale of locales) push(`/${locale}${suffix}`, locale, locale === defaultLocale);
+			break;
+		case "prefix_except_default":
+			push(path, defaultLocale, true);
+			for (const locale of locales) {
+				if (locale === defaultLocale) continue;
+				push(`/${locale}${suffix}`, locale, false);
+			}
+			break;
+		case "prefix_and_default":
+			push(path, defaultLocale, true);
+			for (const locale of locales) push(`/${locale}${suffix}`, locale, locale === defaultLocale);
+			break;
+		default: push(path, defaultLocale, true);
+	}
+	return result;
+}
+function compileLocalePaths(pagePath, cfg) {
+	return {
+		vuePath: toVueRouterLocalePath(pagePath, getVueLocaleParam(cfg)),
+		hono: honoPathsFor(pagePath, cfg)
+	};
+}
+//#endregion
+//#region src/detect.ts
+function detectLocaleFromAcceptLanguage(header, locales, fallback) {
+	if (!header) return fallback;
+	const requested = header.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);
+	const lower = locales.map((l) => ({
+		orig: l,
+		lower: l.toLowerCase()
+	}));
+	for (const { code } of requested) for (const loc of lower) if (code === loc.lower || code.startsWith(`${loc.lower}-`)) return loc.orig;
+	return fallback;
+}
+function parseLocaleCookie(cookieHeader, cookieName) {
+	if (!cookieHeader) return null;
+	const match = cookieHeader.match(new RegExp(`(?:^|;\\s*)${cookieName}=([^;]+)`));
+	return match ? decodeURIComponent(match[1]) : null;
+}
+function serializeLocaleCookie(cookieName, locale) {
+	return `${cookieName}=${encodeURIComponent(locale)}; Path=/; SameSite=Lax`;
+}
+//#endregion
+export { extractLocaleFromPath as a, switchLocalePath as c, compileLocalePaths as i, toVueRouterLocalePath as l, parseLocaleCookie as n, getVueLocaleParam as o, serializeLocaleCookie as r, localizePath as s, detectLocaleFromAcceptLanguage as t };

package/dist/head-BzEFwnlD.js

@@ -0,0 +1,84 @@
+import { a as extractLocaleFromPath, s as localizePath } from "./detect-BIURd4aL.js";
+//#region src/head.ts
+function abs(baseUrl, path) {
+	if (!baseUrl) return path;
+	return `${baseUrl.replace(/\/+$/, "")}${path}`;
+}
+function ogLocale(languageOrCode) {
+	return languageOrCode.replace(/-/g, "_");
+}
+function pagePathWithoutLocale(path, locales) {
+	return extractLocaleFromPath(path, locales).pathWithoutLocale;
+}
+/**
+* Build hreflang / canonical / og:locale tags.
+* `prefix_and_default` 下默认语言的 canonical 指向无前缀 URL，避免双 URL 重复收录。
+*/
+function buildLocaleHead(input) {
+	const current = input.locales.find((l) => l.code === input.locale);
+	const lang = current?.language || input.locale;
+	const dir = current?.dir || "ltr";
+	const clean = pagePathWithoutLocale(input.path, input.routing.locales);
+	const codes = input.routing.locales;
+	const link = [];
+	const meta = [];
+	const languageGroups = /* @__PURE__ */ new Map();
+	for (const loc of input.locales) {
+		const href = abs(input.baseUrl || "", localizePath(clean, loc.code, input.routing));
+		const hreflang = loc.language || loc.code;
+		link.push({
+			rel: "alternate",
+			href,
+			hreflang
+		});
+		const group = hreflang.split("-")[0];
+		if (!languageGroups.has(group)) languageGroups.set(group, loc);
+	}
+	for (const [group, loc] of languageGroups) {
+		if (link.some((l) => l.hreflang === group)) continue;
+		link.push({
+			rel: "alternate",
+			href: abs(input.baseUrl || "", localizePath(clean, loc.code, input.routing)),
+			hreflang: group
+		});
+	}
+	const defaultLoc = input.locales.find((l) => l.isDefault) || input.locales.find((l) => l.code === input.routing.defaultLocale);
+	if (defaultLoc) {
+		const defaultUnprefixed = abs(input.baseUrl || "", localizePath(clean, defaultLoc.code, {
+			...input.routing,
+			locales: codes,
+			strategy: "prefix_except_default"
+		}));
+		link.push({
+			rel: "alternate",
+			href: defaultUnprefixed,
+			hreflang: "x-default"
+		});
+		const canonicalPath = input.locale === defaultLoc.code && input.routing.strategy === "prefix_and_default" ? defaultUnprefixed : abs(input.baseUrl || "", localizePath(clean, input.locale, input.routing));
+		link.push({
+			rel: "canonical",
+			href: canonicalPath
+		});
+	}
+	meta.push({
+		property: "og:locale",
+		content: ogLocale(lang)
+	});
+	for (const loc of input.locales) {
+		if (loc.code === input.locale) continue;
+		meta.push({
+			property: "og:locale:alternate",
+			content: ogLocale(loc.language || loc.code)
+		});
+	}
+	return {
+		htmlAttrs: {
+			lang,
+			dir
+		},
+		link,
+		meta
+	};
+}
+//#endregion
+export { buildLocaleHead as t };

package/dist/head-CT8nH37d.d.ts

@@ -0,0 +1,36 @@
+import { f as LocaleRoutingConfig, l as I18nLocaleMeta } from "./paths-CJVBLGJS.js";
+//#region src/detect.d.ts
+declare function detectLocaleFromAcceptLanguage(header: string | undefined, locales: string[], fallback: string): string;
+declare function parseLocaleCookie(cookieHeader: string | undefined, cookieName: string): string | null;
+declare function serializeLocaleCookie(cookieName: string, locale: string): string;
+//#endregion
+//#region src/head.d.ts
+interface LocaleHeadInput {
+  path: string;
+  locale: string;
+  locales: I18nLocaleMeta[];
+  routing: LocaleRoutingConfig;
+  baseUrl?: string;
+}
+interface LocaleHeadTags {
+  htmlAttrs: {
+    lang: string;
+    dir: 'ltr' | 'rtl';
+  };
+  link: Array<{
+    rel: string;
+    href: string;
+    hreflang?: string;
+  }>;
+  meta: Array<{
+    property: string;
+    content: string;
+  }>;
+}
+/**
+ * Build hreflang / canonical / og:locale tags.
+ * `prefix_and_default` 下默认语言的 canonical 指向无前缀 URL，避免双 URL 重复收录。
+ */
+declare function buildLocaleHead(input: LocaleHeadInput): LocaleHeadTags;
+//#endregion
+export { parseLocaleCookie as a, detectLocaleFromAcceptLanguage as i, LocaleHeadTags as n, serializeLocaleCookie as o, buildLocaleHead as r, LocaleHeadInput as t };

package/dist/index.d.ts

@@ -1,96 +1,59 @@
-//#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;
+import { a as switchLocalePath, c as HonoLocalePath, d as I18nRoutingStrategy, f as LocaleRoutingConfig, i as localizePath, l as I18nLocaleMeta, n as extractLocaleFromPath, o as toVueRouterLocalePath, r as getVueLocaleParam, s as CompiledLocalePath, t as compileLocalePaths, u as I18nMiddlewareOptions } from "./paths-CJVBLGJS.js";
+import { a as parseLocaleCookie, i as detectLocaleFromAcceptLanguage, n as LocaleHeadTags, o as serializeLocaleCookie, r as buildLocaleHead, t as LocaleHeadInput } from "./head-CT8nH37d.js";
+import { createI18nMiddleware, getPathWithoutLocale, getRequestLocale as getRequestLocale$1 } from "./routing.js";
+import { LocaleMessage } from "@intlify/core";
+//#region src/context.d.ts
+type LocaleMessages = LocaleMessage;
+declare function createI18nCoreContext(locale: string, fallback: string, messages: Record<string, LocaleMessages>): import("@intlify/core").CoreContext<string, Record<string, LocaleMessages>, {}, {}, string | import("@intlify/core").LocaleDetector<any[]>, string, string>;
+type I18nCoreContext = ReturnType<typeof createI18nCoreContext>;
+interface I18nRequestScope {
+  locale: string;
+  fallbackLocale: string;
+  ctx: I18nCoreContext;
+  t?: (key: string, ...args: unknown[]) => string;
+  d?: (value: Date | number | string, ...args: unknown[]) => string;
+  n?: (value: number, ...args: unknown[]) => string;
 }
-interface LocaleDefinition {
-  code: string;
-  messages: LocaleMessages;
+type LocaleLoader = (code: string) => Promise<unknown>;
+declare function setFallbackLocale(code: string): void;
+declare function getFallbackLocale(): string;
+declare function setLocaleMessages(code: string, messages: LocaleMessages): void;
+declare function getLocaleMessages(code: string): LocaleMessages | undefined;
+declare function mergeLocaleMessages(code: string, messages: LocaleMessages): LocaleMessages;
+declare function setLocaleMeta(code: string, meta: {
   name?: string;
   dir?: 'ltr' | 'rtl';
+  language?: string;
   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 {
+}): void;
+declare function getLocaleMeta(code: string): {
+  name?: string;
+  dir: "ltr" | "rtl";
+  language?: string;
+  isDefault?: boolean;
+} | undefined;
+declare function listLocaleCodes(): string[];
+declare function getRegisteredLocalesMeta(): Array<{
   code: string;
   name?: string;
   dir: 'ltr' | 'rtl';
+  language?: string;
   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;
+/**
+ * Vite 图里的 `ubean:locales` 在求值时注册；Node 侧中间件通过
+ * `ensureLocaleMessages` 调用，避免 `import('ubean:locales')` 在 CLI 进程里 404。
+ */
+declare function registerLocaleLoader(loader?: LocaleLoader): void;
+declare function ensureLocaleMessages(locale: string, fallback?: string): Promise<void>;
+declare function createRequestContext(locale: string, fallback?: string): I18nCoreContext;
+declare function runWithI18n<T>(scope: I18nRequestScope, fn: () => T): T;
+declare function getI18nScope(): I18nRequestScope | undefined;
+declare function getRequestLocale(): string;
+declare function t(key: string, ...args: unknown[]): string;
+declare function d(value: Date | number | string, ...args: unknown[]): string;
+declare function n(value: number, ...args: unknown[]): 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 };
+export { type CompiledLocalePath, type HonoLocalePath, type I18nCoreContext, type I18nLocaleMeta, type I18nMiddlewareOptions, type I18nRequestScope, type I18nRoutingStrategy, type LocaleHeadInput, type LocaleHeadTags, type LocaleMessages, type LocaleRoutingConfig, buildLocaleHead, compileLocalePaths, createI18nMiddleware, createRequestContext, d, detectLocaleFromAcceptLanguage, ensureLocaleMessages, extractLocaleFromPath, getRequestLocale as getAlsLocale, getFallbackLocale, getI18nScope, getLocaleDir, getLocaleMessages, getLocaleMeta, getLocaleName, getPathWithoutLocale, getRegisteredLocalesMeta, getRequestLocale$1 as getRequestLocale, getVueLocaleParam, listLocaleCodes, localizePath, mergeLocaleMessages, n, parseLocaleCookie, registerLocaleLoader, runWithI18n, serializeLocaleCookie, setFallbackLocale, setLocaleMessages, setLocaleMeta, switchLocalePath, t, toVueRouterLocalePath };