@k8ordo/i18n 0.1.0 → 1.1.0

package/dist/locales.mjs

@@ -1,4 +1,7 @@
-import { inBrowser, localeStorage, register } from "./current.mjs";
+import { parseAcceptLanguage } from "./accept-language.mjs";
+import { readCookie } from "./cookie.mjs";
+import { browserPathname, inBrowser, localeStorage, register } from "./current.mjs";
+import { intlFormats } from "./format.mjs";
 //#region src/locales.ts
 /** `Intl.Locale` throws a RangeError on a tag that is not BCP 47; that is the only check a tag needs. */
 const parseTag = (tag) => {
@@ -14,12 +17,33 @@ const localize = (pathname, locale) => {
 	if (rest !== "" && !rest.startsWith("/")) throw new TypeError(`localize: ${JSON.stringify(pathname)} is not a pathname — it does not start with "/"`);
 	return `/${locale}${rest}`;
 };
+/**
+* Where a server keeps the locale. Without one this throws rather than
+* falling back: the locale set would be ignored and the page rendered in the
+* default.
+*/
+const serverStorage = (caller) => {
+	const storage = localeStorage();
+	if (storage === null) throw new Error(`${caller}: this runtime has no AsyncLocalStorage to scope a locale to`);
+	return storage;
+};
 /** Server only: the browser has no request, and its URL already is the locale. */
 const run = (locale, fn) => {
 	if (inBrowser) throw new Error("locales.run: in the browser the URL is the locale — navigate instead");
-	const storage = localeStorage();
-	if (storage === null) throw new Error("locales.run: this runtime has no AsyncLocalStorage to scope a locale to");
-	return storage.run(locale, fn);
+	return serverStorage("locales.run").run(locale, fn);
+};
+/**
+* `Intl.DateTimeFormat` throws a RangeError on a time zone it does not know,
+* and quietly takes the runtime's own for a missing one — the very value
+* that differs between a server and a browser — so both are `null` here.
+*/
+const resolveTimeZone = (value) => {
+	if (typeof value !== "string") return null;
+	try {
+		return new Intl.DateTimeFormat("en", { timeZone: value }).resolvedOptions().timeZone;
+	} catch {
+		return null;
+	}
 };
 /**
 * Declares the locale set once. Everything that needs to know which locales
@@ -28,18 +52,24 @@ const run = (locale, fn) => {
 * every message — reads this value, so the list is spelled in one place.
 *
 * ```ts
-* export const locales = defineLocales(['ja', 'en']);
-* export const locales = defineLocales(['en-US', 'en-GB', 'ja'], { default: 'ja' });
+* export const locales = defineLocales({
+*   ja: { timeZone: 'Asia/Tokyo', dir: 'ltr' },
+*   en: { timeZone: 'America/New_York', dir: 'ltr' },
+* });
 * ```
 */
-const defineLocales = (all, options) => {
-	const list = all;
-	if (new Set(list).size !== list.length) throw new TypeError(`defineLocales: a locale is listed twice in ${JSON.stringify(list)}`);
+const defineLocales = (definitions, options) => {
+	const byTag = definitions;
+	const list = Object.keys(byTag);
+	if (list.length === 0) throw new TypeError("defineLocales: no locale is defined");
 	const fallback = options?.default ?? list[0];
 	if (!list.includes(fallback)) throw new TypeError(`defineLocales: the default ${JSON.stringify(fallback)} is not in ${JSON.stringify(list)}`);
 	const supported = list.map((tag) => {
 		const parsed = parseTag(tag);
 		if (parsed === null) throw new TypeError(`defineLocales: ${JSON.stringify(tag)} is not a BCP 47 language tag`);
+		const { timeZone, dir } = byTag[tag];
+		if (resolveTimeZone(timeZone) === null) throw new TypeError(`defineLocales: the timeZone of ${JSON.stringify(tag)}, ${JSON.stringify(timeZone)}, is not a time zone`);
+		if (dir !== "ltr" && dir !== "rtl") throw new TypeError(`defineLocales: the dir of ${JSON.stringify(tag)}, ${JSON.stringify(dir)}, is neither "ltr" nor "rtl"`);
 		return {
 			tag,
 			language: parsed.language
@@ -58,6 +88,15 @@ const defineLocales = (all, options) => {
 		}
 		return fallback;
 	};
+	const negotiateRequest = (request, { cookie } = {}) => {
+		const chosen = cookie === void 0 ? null : readCookie(request.headers.get("cookie"), cookie);
+		return negotiate([...chosen === null ? [] : [chosen], ...parseAcceptLanguage(request.headers.get("accept-language"))]);
+	};
+	const paths = (patterns) => patterns.flatMap((pattern) => {
+		const segments = pattern.split("/");
+		if (!segments.includes(":locale")) return [pattern];
+		return list.map((locale) => segments.map((segment) => segment === ":locale" ? locale : segment).join("/"));
+	});
 	const delocalize = (pathname) => {
 		const first = pathname.split("/")[1] ?? "";
 		if (!is(first)) return {
@@ -71,7 +110,7 @@ const defineLocales = (all, options) => {
 		};
 	};
 	const getLocale = () => {
-		if (inBrowser) return delocalize(location.pathname).locale ?? fallback;
+		if (inBrowser) return delocalize(browserPathname()).locale ?? fallback;
 		const current = localeStorage()?.getStore();
 		return is(current) ? current : fallback;
 	};
@@ -84,7 +123,7 @@ const defineLocales = (all, options) => {
 				message: `expected one of ${JSON.stringify(list)}, received ${JSON.stringify(locale)}`,
 				path: ["locale"]
 			}] };
-			localeStorage()?.enterWith(locale);
+			if (!inBrowser) serverStorage("locales.paramsSchema").enterWith(locale);
 			return { value: { locale } };
 		}
 	} };
@@ -94,14 +133,18 @@ const defineLocales = (all, options) => {
 	});
 	return {
 		all: list,
+		definitions: byTag,
 		default: fallback,
 		is,
 		negotiate,
+		negotiateRequest,
 		localize,
 		delocalize,
+		paths,
 		paramsSchema,
 		getLocale,
-		run
+		run,
+		...intlFormats(getLocale, byTag)
 	};
 };
 //#endregion

package/dist/message.d.mts

@@ -5,9 +5,9 @@ import { RegisteredLocale } from "./register.mjs";
  * string), returning the text in the current locale. What a component that
  * takes a message as a prop should accept.
  */
-type Message<A extends readonly unknown[] = []> = (...args: A) => string;
+export type Message<A extends readonly unknown[] = []> = (...args: A) => string;
 /** One value per locale — every locale, no locale twice. */
-type Variants<V> = Readonly<Record<RegisteredLocale, V>>;
+export type Variants<V> = Readonly<Record<RegisteredLocale, V>>;
 /**
  * Declares one message with its text in every locale. The result reads the
  * locale where it is called — the request on a server, the URL in the
@@ -25,7 +25,6 @@ type Variants<V> = Readonly<Record<RegisteredLocale, V>>;
  * When nothing names a locale, the text is the default locale's — the one
  * `defineLocales` registered, else the first variant written.
  */
-declare function message(variants: Variants<string>): Message;
-declare function message<A extends readonly unknown[]>(variants: Variants<(...args: A) => string>): Message<A>;
-//#endregion
-export { Message, Variants, message };
+export declare function message(variants: Variants<string>): Message;
+export declare function message<A extends readonly unknown[]>(variants: Variants<(...args: A) => string>): Message<A>;
+//#endregion

package/dist/message.mjs

@@ -1,8 +1,8 @@
-import { currentLocale, registeredDefault, setRegistered } from "./current.mjs";
+import { namedLocale, registeredDefault, setRegistered } from "./current.mjs";
 //#region src/message.ts
 function message(variants) {
 	return (...args) => {
-		const named = currentLocale();
+		const named = namedLocale();
 		const locale = named !== null && (setRegistered() || Object.hasOwn(variants, named)) ? named : registeredDefault();
 		const variant = locale === null ? variants[Object.keys(variants)[0] ?? ""] : variants[locale];
 		if (variant === void 0) throw new TypeError(`message: no text for ${JSON.stringify(locale)} in ${JSON.stringify(Object.keys(variants))}`);

package/dist/register.d.mts

@@ -1,7 +1,8 @@
 //#region src/register.d.ts
 /**
- * Merged by the application once, so `message()` knows which locales every
- * message must carry — without each message naming the set:
+ * Merged once, so `message()` knows which locales every message must carry —
+ * without each message naming the set. `@k8ordo/framework` generates it from
+ * the `locales` export of `src/i18n.ts`; any other application writes it:
  *
  * ```ts
  * declare module '@k8ordo/i18n' {
@@ -14,10 +15,9 @@
  * The one `interface` in this package, kept so because it exists to be
  * merged (see the repository's conventions).
  */
-interface Register {}
+export interface Register {}
 /** The application's locale union once `Register` is merged; `string` before. */
-type RegisteredLocale = Register extends {
+export type RegisteredLocale = Register extends {
   locale: infer L extends string;
 } ? L : string;
-//#endregion
-export { Register, RegisteredLocale };
+//#endregion