@krizaka/i18n 0.0.0-stage → 0.1.0-beta.1

package/dist/index.d.ts

@@ -0,0 +1,100 @@
+import { PluralForms } from '@krizaka/intl/plural';
+
+/**
+ * The types of a message catalogue. `en.json` (the reference) gives the shape; every other locale has the same one.
+ * A key is the dotted path to a leaf (`"auction.phase.SOLD"`); a leaf is a message string or a set of plural forms.
+ */
+
+/** A value a message may hold: a string, a plural set, a nested branch, or a list (long structured content). */
+type MessageValue = string | Dictionary | readonly MessageValue[];
+/** A message catalogue, as `import en from "./messages/en.json"` types it. */
+interface Dictionary {
+    readonly [key: string]: MessageValue;
+}
+/** A value a placeholder accepts. */
+type PlaceholderValue = string | number;
+/** The values handed to `format` / `t`: `{ count: 3, name: "Ada" }`. */
+type Values = Readonly<Record<string, PlaceholderValue | null | undefined>>;
+/** The plural categories a plural set may carry (`zero` is the explicit "exactly 0" form). */
+type PluralCategory = keyof PluralForms;
+/** A plural set as it sits in a catalogue: `{ "one": "{count} bid", "other": "{count} bids" }`. */
+type PluralMessage = PluralForms<string>;
+type Join<P extends string, K extends string> = P extends "" ? K : `${P}.${K}`;
+/** True when T is a plural set: an object whose keys are plural categories, `other` included. */
+type IsPlural<T> = T extends {
+    other: string;
+} ? Exclude<keyof T, PluralCategory> extends never ? true : false : false;
+/**
+ * Every key of a catalogue: the dotted path to each string and each plural set. Lists are not keys (read them as a
+ * branch with `getDictionary`). `MessageKey<typeof en>` → `"home.title" | "auction.bids" | …`.
+ */
+type MessageKey<D, P extends string = ""> = D extends readonly unknown[] ? never : {
+    [K in keyof D & string]: D[K] extends string ? Join<P, K> : IsPlural<D[K]> extends true ? Join<P, K> : D[K] extends readonly unknown[] ? never : D[K] extends object ? MessageKey<D[K], Join<P, K>> : never;
+}[keyof D & string];
+/** The message at a key: `MessageAt<typeof en, "home.title">`. */
+type MessageAt<D, K extends string> = K extends `${infer H}.${infer R}` ? H extends keyof D ? MessageAt<D[H], R> : never : K extends keyof D ? D[K] : never;
+/** The `{placeholders}` of a literal message type: `Placeholders<"{count} of {total}">` → `"count" | "total"`. */
+type Placeholders<S extends string> = S extends `${string}{${infer N}}${infer R}` ? N extends `${string}${" " | "{"}${string}` ? Placeholders<R> : N | Placeholders<R> : never;
+/**
+ * The arguments `t` takes after the key. A message typed as a literal (a catalogue written `as const`) requires its
+ * placeholders; a plural set requires `count`; a message typed `string` (a JSON import widens literals) takes any values.
+ */
+type ValuesArgs<M> = IsPlural<M> extends true ? [values: Values & {
+    readonly count: number;
+}] : M extends string ? string extends M ? [values?: Values] : [Placeholders<M>] extends [never] ? [values?: Values] : [values: Values & {
+    readonly [N in Placeholders<M>]: PlaceholderValue;
+}] : [values?: Values];
+/** A translator bound to one locale: `t("auction.bids", { count: 3 })`. */
+type Translate<D> = <K extends MessageKey<D>>(key: K, ...values: ValuesArgs<MessageAt<D, K>>) => string;
+
+/** The plural categories, in CLDR order (`zero` first: the explicit "exactly 0" form). */
+declare const PLURAL_CATEGORIES: readonly ["zero", "one", "two", "few", "many", "other"];
+/**
+ * Replaces the `{name}` placeholders of a message: `format("{count} repositories", { count: 23 })` → `"23 repositories"`.
+ * A placeholder without a value (missing, `null` or `undefined`) stays as written, so a gap is visible, never silent.
+ */
+declare function format(message: string, values?: Values): string;
+/** The placeholder names of a message, sorted and without duplicates: `"{b} {a} {b}"` → `["a", "b"]`. */
+declare function placeholdersOf(message: string): string[];
+/** True when a catalogue value is a plural set: an object of plural categories with an `other` string. */
+declare function isPluralMessage(value: unknown): value is PluralMessage;
+
+interface CreateI18nOptions<L extends string> {
+    /** The reference locale: its catalogue gives the shape, and anything unknown falls back to it. */
+    defaultLocale: L;
+}
+interface I18n<D extends Dictionary, L extends string = string> {
+    /** The supported locales, in the order the catalogues were given. */
+    readonly locales: readonly L[];
+    readonly defaultLocale: L;
+    /** True when the value is a supported locale. */
+    isLocale(value: unknown): value is L;
+    /** Narrows any value (a route segment, a cookie) to a supported locale: the default one for anything else. */
+    asLocale(value: unknown): L;
+    /** The whole catalogue of a locale (the default one for an unknown locale) — for Server Components and branches. */
+    getDictionary(locale: unknown): D;
+    /** The translator bound to a locale: `translator("fr")("auction.bids", { count: 3 })`. */
+    translator(locale: unknown): Translate<D>;
+    /** The translator of the default locale. */
+    t: Translate<D>;
+    /** `{placeholder}` replacement, the same function as the package's `format`. */
+    format: typeof format;
+}
+/**
+ * The i18n engine of a Krizaka app, bound to its catalogues:
+ *
+ * ```ts
+ * import en from "@/messages/en.json";
+ * import fr from "@/messages/fr.json";
+ * export const i18n = createI18n<typeof en, "en" | "fr">({ en, fr }, { defaultLocale: "en" });
+ * i18n.t("auction.phase.SOLD");                  // typed key
+ * i18n.translator("fr")("auction.bids", { count: 2 }); // plural set → @krizaka/intl's plural rules
+ * ```
+ *
+ * Giving the type arguments makes every catalogue type-check against the reference: a key missing from `fr.json`
+ * fails to compile. A key missing at run time falls back to the default locale, then to the key itself (visible,
+ * never an empty string).
+ */
+declare function createI18n<D extends Dictionary, L extends string = string>(dictionaries: Readonly<Record<L, D>>, options: CreateI18nOptions<NoInfer<L>>): I18n<D, L>;
+
+export { type CreateI18nOptions, type Dictionary, type I18n, type MessageAt, type MessageKey, type MessageValue, PLURAL_CATEGORIES, type PlaceholderValue, type Placeholders, type PluralCategory, type PluralMessage, type Translate, type Values, type ValuesArgs, createI18n, format, isPluralMessage, placeholdersOf };

package/dist/index.js

@@ -0,0 +1,59 @@
+import {
+  PLURAL_CATEGORIES,
+  format,
+  isPluralMessage,
+  placeholdersOf
+} from "./chunk-62MK7X4K.js";
+
+// src/create.ts
+import { plural } from "@krizaka/intl/plural";
+function lookup(dictionary, key) {
+  let node = dictionary;
+  for (const part of key.split(".")) {
+    if (!node || typeof node !== "object" || Array.isArray(node) || !Object.hasOwn(node, part)) return void 0;
+    node = node[part];
+  }
+  return node;
+}
+function createI18n(dictionaries, options) {
+  const { defaultLocale } = options;
+  const locales = Object.keys(dictionaries);
+  if (!locales.includes(defaultLocale)) {
+    throw new RangeError(`createI18n: no catalogue for the default locale "${defaultLocale}".`);
+  }
+  const isLocale = (value) => typeof value === "string" && locales.includes(value);
+  const asLocale = (value) => isLocale(value) ? value : defaultLocale;
+  const getDictionary = (locale) => dictionaries[asLocale(locale)];
+  const translator = (locale) => {
+    const current = asLocale(locale);
+    const translate = (key, values) => {
+      let message = lookup(dictionaries[current], key);
+      if (message === void 0 && current !== defaultLocale) message = lookup(dictionaries[defaultLocale], key);
+      if (typeof message === "string") return format(message, values);
+      if (isPluralMessage(message)) {
+        const count = Number(values?.count);
+        return format(Number.isFinite(count) ? plural(count, current, message) : message.other, values);
+      }
+      return key;
+    };
+    return translate;
+  };
+  return {
+    locales,
+    defaultLocale,
+    isLocale,
+    asLocale,
+    getDictionary,
+    translator,
+    t: translator(defaultLocale),
+    format
+  };
+}
+export {
+  PLURAL_CATEGORIES,
+  createI18n,
+  format,
+  isPluralMessage,
+  placeholdersOf
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/create.ts"],"sourcesContent":["import { plural } from \"@krizaka/intl/plural\";\n\nimport { format, isPluralMessage } from \"./format\";\nimport type { Dictionary, Translate, Values } from \"./types\";\n\nexport interface CreateI18nOptions<L extends string> {\n  /** The reference locale: its catalogue gives the shape, and anything unknown falls back to it. */\n  defaultLocale: L;\n}\n\nexport interface I18n<D extends Dictionary, L extends string = string> {\n  /** The supported locales, in the order the catalogues were given. */\n  readonly locales: readonly L[];\n  readonly defaultLocale: L;\n  /** True when the value is a supported locale. */\n  isLocale(value: unknown): value is L;\n  /** Narrows any value (a route segment, a cookie) to a supported locale: the default one for anything else. */\n  asLocale(value: unknown): L;\n  /** The whole catalogue of a locale (the default one for an unknown locale) — for Server Components and branches. */\n  getDictionary(locale: unknown): D;\n  /** The translator bound to a locale: `translator(\"fr\")(\"auction.bids\", { count: 3 })`. */\n  translator(locale: unknown): Translate<D>;\n  /** The translator of the default locale. */\n  t: Translate<D>;\n  /** `{placeholder}` replacement, the same function as the package's `format`. */\n  format: typeof format;\n}\n\nfunction lookup(dictionary: Dictionary, key: string): unknown {\n  let node: unknown = dictionary;\n  for (const part of key.split(\".\")) {\n    if (!node || typeof node !== \"object\" || Array.isArray(node) || !Object.hasOwn(node, part)) return undefined;\n    node = (node as Record<string, unknown>)[part];\n  }\n  return node;\n}\n\n/**\n * The i18n engine of a Krizaka app, bound to its catalogues:\n *\n * ```ts\n * import en from \"@/messages/en.json\";\n * import fr from \"@/messages/fr.json\";\n * export const i18n = createI18n<typeof en, \"en\" | \"fr\">({ en, fr }, { defaultLocale: \"en\" });\n * i18n.t(\"auction.phase.SOLD\");                  // typed key\n * i18n.translator(\"fr\")(\"auction.bids\", { count: 2 }); // plural set → @krizaka/intl's plural rules\n * ```\n *\n * Giving the type arguments makes every catalogue type-check against the reference: a key missing from `fr.json`\n * fails to compile. A key missing at run time falls back to the default locale, then to the key itself (visible,\n * never an empty string).\n */\nexport function createI18n<D extends Dictionary, L extends string = string>(\n  dictionaries: Readonly<Record<L, D>>,\n  options: CreateI18nOptions<NoInfer<L>>,\n): I18n<D, L> {\n  const { defaultLocale } = options;\n  const locales = Object.keys(dictionaries) as L[];\n  if (!locales.includes(defaultLocale)) {\n    throw new RangeError(`createI18n: no catalogue for the default locale \"${defaultLocale}\".`);\n  }\n\n  const isLocale = (value: unknown): value is L => typeof value === \"string\" && locales.includes(value as L);\n  const asLocale = (value: unknown): L => (isLocale(value) ? value : defaultLocale);\n  const getDictionary = (locale: unknown): D => dictionaries[asLocale(locale)];\n\n  const translator = (locale: unknown): Translate<D> => {\n    const current = asLocale(locale);\n    const translate = (key: string, values?: Values): string => {\n      let message = lookup(dictionaries[current], key);\n      if (message === undefined && current !== defaultLocale) message = lookup(dictionaries[defaultLocale], key);\n      if (typeof message === \"string\") return format(message, values);\n      if (isPluralMessage(message)) {\n        const count = Number(values?.count);\n        return format(Number.isFinite(count) ? plural(count, current, message) : message.other, values);\n      }\n      return key;\n    };\n    return translate as Translate<D>;\n  };\n\n  return {\n    locales,\n    defaultLocale,\n    isLocale,\n    asLocale,\n    getDictionary,\n    translator,\n    t: translator(defaultLocale),\n    format,\n  };\n}\n"],"mappings":";;;;;;;;AAAA,SAAS,cAAc;AA4BvB,SAAS,OAAO,YAAwB,KAAsB;AAC5D,MAAI,OAAgB;AACpB,aAAW,QAAQ,IAAI,MAAM,GAAG,GAAG;AACjC,QAAI,CAAC,QAAQ,OAAO,SAAS,YAAY,MAAM,QAAQ,IAAI,KAAK,CAAC,OAAO,OAAO,MAAM,IAAI,EAAG,QAAO;AACnG,WAAQ,KAAiC,IAAI;AAAA,EAC/C;AACA,SAAO;AACT;AAiBO,SAAS,WACd,cACA,SACY;AACZ,QAAM,EAAE,cAAc,IAAI;AAC1B,QAAM,UAAU,OAAO,KAAK,YAAY;AACxC,MAAI,CAAC,QAAQ,SAAS,aAAa,GAAG;AACpC,UAAM,IAAI,WAAW,oDAAoD,aAAa,IAAI;AAAA,EAC5F;AAEA,QAAM,WAAW,CAAC,UAA+B,OAAO,UAAU,YAAY,QAAQ,SAAS,KAAU;AACzG,QAAM,WAAW,CAAC,UAAuB,SAAS,KAAK,IAAI,QAAQ;AACnE,QAAM,gBAAgB,CAAC,WAAuB,aAAa,SAAS,MAAM,CAAC;AAE3E,QAAM,aAAa,CAAC,WAAkC;AACpD,UAAM,UAAU,SAAS,MAAM;AAC/B,UAAM,YAAY,CAAC,KAAa,WAA4B;AAC1D,UAAI,UAAU,OAAO,aAAa,OAAO,GAAG,GAAG;AAC/C,UAAI,YAAY,UAAa,YAAY,cAAe,WAAU,OAAO,aAAa,aAAa,GAAG,GAAG;AACzG,UAAI,OAAO,YAAY,SAAU,QAAO,OAAO,SAAS,MAAM;AAC9D,UAAI,gBAAgB,OAAO,GAAG;AAC5B,cAAM,QAAQ,OAAO,QAAQ,KAAK;AAClC,eAAO,OAAO,OAAO,SAAS,KAAK,IAAI,OAAO,OAAO,SAAS,OAAO,IAAI,QAAQ,OAAO,MAAM;AAAA,MAChG;AACA,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAG,WAAW,aAAa;AAAA,IAC3B;AAAA,EACF;AACF;","names":[]}

package/dist/react.d.ts

@@ -0,0 +1,43 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { Dictionary, Translate, format, I18n } from './index.js';
+import '@krizaka/intl/plural';
+
+/** What `useI18n()` returns. */
+interface I18nContextValue<D extends Dictionary, L extends string> {
+    /** The active locale. */
+    locale: L;
+    /** The whole catalogue of the active locale: `messages.home.title`. */
+    messages: D;
+    /** The translator of the active locale: `t("auction.bids", { count: 3 })`. */
+    t: Translate<D>;
+    /** `{placeholder}` replacement. */
+    format: typeof format;
+    /** Asks the app to switch locale (what it does — a route, a cookie — is the app's): a no-op unless given. */
+    setLocale: (locale: L) => void;
+}
+interface I18nProviderProps<L extends string> {
+    locale: L;
+    /** How the app switches locale (push a route, write a cookie). */
+    setLocale?: (locale: L) => void;
+    children?: ReactNode;
+}
+/**
+ * The React side of an i18n engine, bound to it once in the app:
+ *
+ * ```tsx
+ * "use client";
+ * export const { I18nProvider, useI18n } = createI18nReact(i18n);
+ * ```
+ *
+ * `I18nProvider` takes the locale the server resolved (and how to switch it); `useI18n()` gives the active locale, its
+ * catalogue, its translator and `format`. Outside a provider, `useI18n()` reads the default locale. Server Components
+ * do not use the context: they call `i18n.getDictionary(locale)` / `i18n.translator(locale)`.
+ */
+declare function createI18nReact<D extends Dictionary, L extends string>(i18n: I18n<D, L>): {
+    I18nProvider: ({ locale, setLocale, children }: I18nProviderProps<L>) => react.JSX.Element;
+    useI18n: () => I18nContextValue<D, L>;
+    I18nContext: react.Context<I18nContextValue<D, L>>;
+};
+
+export { type I18nContextValue, type I18nProviderProps, createI18nReact };

package/dist/react.js

@@ -0,0 +1,42 @@
+"use client";
+
+// src/react.tsx
+import { createContext, useContext, useMemo } from "react";
+
+// src/format.ts
+var PLACEHOLDER = /\{(\w+)\}/g;
+function format(message, values = {}) {
+  return message.replace(PLACEHOLDER, (match, name) => {
+    const value = Object.hasOwn(values, name) ? values[name] : void 0;
+    return value === void 0 || value === null ? match : String(value);
+  });
+}
+
+// src/react.tsx
+import { jsx } from "react/jsx-runtime";
+var noop = () => {
+};
+function createI18nReact(i18n) {
+  const valueOf = (locale, setLocale) => ({
+    locale,
+    messages: i18n.getDictionary(locale),
+    t: i18n.translator(locale),
+    format,
+    setLocale
+  });
+  const Context = createContext(valueOf(i18n.defaultLocale, noop));
+  Context.displayName = "I18nContext";
+  function I18nProvider({ locale, setLocale = noop, children }) {
+    const current = i18n.asLocale(locale);
+    const value = useMemo(() => valueOf(current, setLocale), [current, setLocale]);
+    return /* @__PURE__ */ jsx(Context.Provider, { value, children });
+  }
+  function useI18n() {
+    return useContext(Context);
+  }
+  return { I18nProvider, useI18n, I18nContext: Context };
+}
+export {
+  createI18nReact
+};
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/react.tsx","../src/format.ts"],"sourcesContent":["import { createContext, type ReactNode, useContext, useMemo } from \"react\";\n\nimport type { I18n } from \"./create\";\nimport { format } from \"./format\";\nimport type { Dictionary, Translate } from \"./types\";\n\n/** What `useI18n()` returns. */\nexport interface I18nContextValue<D extends Dictionary, L extends string> {\n  /** The active locale. */\n  locale: L;\n  /** The whole catalogue of the active locale: `messages.home.title`. */\n  messages: D;\n  /** The translator of the active locale: `t(\"auction.bids\", { count: 3 })`. */\n  t: Translate<D>;\n  /** `{placeholder}` replacement. */\n  format: typeof format;\n  /** Asks the app to switch locale (what it does — a route, a cookie — is the app's): a no-op unless given. */\n  setLocale: (locale: L) => void;\n}\n\nexport interface I18nProviderProps<L extends string> {\n  locale: L;\n  /** How the app switches locale (push a route, write a cookie). */\n  setLocale?: (locale: L) => void;\n  children?: ReactNode;\n}\n\nconst noop = (): void => {};\n\n/**\n * The React side of an i18n engine, bound to it once in the app:\n *\n * ```tsx\n * \"use client\";\n * export const { I18nProvider, useI18n } = createI18nReact(i18n);\n * ```\n *\n * `I18nProvider` takes the locale the server resolved (and how to switch it); `useI18n()` gives the active locale, its\n * catalogue, its translator and `format`. Outside a provider, `useI18n()` reads the default locale. Server Components\n * do not use the context: they call `i18n.getDictionary(locale)` / `i18n.translator(locale)`.\n */\nexport function createI18nReact<D extends Dictionary, L extends string>(i18n: I18n<D, L>) {\n  const valueOf = (locale: L, setLocale: (locale: L) => void): I18nContextValue<D, L> => ({\n    locale,\n    messages: i18n.getDictionary(locale),\n    t: i18n.translator(locale),\n    format,\n    setLocale,\n  });\n\n  const Context = createContext<I18nContextValue<D, L>>(valueOf(i18n.defaultLocale, noop));\n  Context.displayName = \"I18nContext\";\n\n  function I18nProvider({ locale, setLocale = noop, children }: I18nProviderProps<L>) {\n    const current = i18n.asLocale(locale);\n    const value = useMemo(() => valueOf(current, setLocale), [current, setLocale]);\n    return <Context.Provider value={value}>{children}</Context.Provider>;\n  }\n\n  function useI18n(): I18nContextValue<D, L> {\n    return useContext(Context);\n  }\n\n  return { I18nProvider, useI18n, I18nContext: Context };\n}\n","import type { PluralMessage, Values } from \"./types\";\n\n/** A `{name}` placeholder: letters, digits and `_`. */\nexport const PLACEHOLDER = /\\{(\\w+)\\}/g;\n\n/** The plural categories, in CLDR order (`zero` first: the explicit \"exactly 0\" form). */\nexport const PLURAL_CATEGORIES = [\"zero\", \"one\", \"two\", \"few\", \"many\", \"other\"] as const;\n\n/**\n * Replaces the `{name}` placeholders of a message: `format(\"{count} repositories\", { count: 23 })` → `\"23 repositories\"`.\n * A placeholder without a value (missing, `null` or `undefined`) stays as written, so a gap is visible, never silent.\n */\nexport function format(message: string, values: Values = {}): string {\n  return message.replace(PLACEHOLDER, (match, name: string) => {\n    const value = Object.hasOwn(values, name) ? values[name] : undefined;\n    return value === undefined || value === null ? match : String(value);\n  });\n}\n\n/** The placeholder names of a message, sorted and without duplicates: `\"{b} {a} {b}\"` → `[\"a\", \"b\"]`. */\nexport function placeholdersOf(message: string): string[] {\n  return [...new Set([...message.matchAll(PLACEHOLDER)].map((m) => m[1] as string))].sort();\n}\n\n/** True when a catalogue value is a plural set: an object of plural categories with an `other` string. */\nexport function isPluralMessage(value: unknown): value is PluralMessage {\n  if (!value || typeof value !== \"object\" || Array.isArray(value)) return false;\n  const keys = Object.keys(value);\n  return (\n    typeof (value as { other?: unknown }).other === \"string\" &&\n    keys.every((k) => (PLURAL_CATEGORIES as readonly string[]).includes(k) && typeof (value as Record<string, unknown>)[k] === \"string\")\n  );\n}\n"],"mappings":";;;AAAA,SAAS,eAA+B,YAAY,eAAe;;;ACG5D,IAAM,cAAc;AASpB,SAAS,OAAO,SAAiB,SAAiB,CAAC,GAAW;AACnE,SAAO,QAAQ,QAAQ,aAAa,CAAC,OAAO,SAAiB;AAC3D,UAAM,QAAQ,OAAO,OAAO,QAAQ,IAAI,IAAI,OAAO,IAAI,IAAI;AAC3D,WAAO,UAAU,UAAa,UAAU,OAAO,QAAQ,OAAO,KAAK;AAAA,EACrE,CAAC;AACH;;;ADuCW;AA7BX,IAAM,OAAO,MAAY;AAAC;AAcnB,SAAS,gBAAwD,MAAkB;AACxF,QAAM,UAAU,CAAC,QAAW,eAA4D;AAAA,IACtF;AAAA,IACA,UAAU,KAAK,cAAc,MAAM;AAAA,IACnC,GAAG,KAAK,WAAW,MAAM;AAAA,IACzB;AAAA,IACA;AAAA,EACF;AAEA,QAAM,UAAU,cAAsC,QAAQ,KAAK,eAAe,IAAI,CAAC;AACvF,UAAQ,cAAc;AAEtB,WAAS,aAAa,EAAE,QAAQ,YAAY,MAAM,SAAS,GAAyB;AAClF,UAAM,UAAU,KAAK,SAAS,MAAM;AACpC,UAAM,QAAQ,QAAQ,MAAM,QAAQ,SAAS,SAAS,GAAG,CAAC,SAAS,SAAS,CAAC;AAC7E,WAAO,oBAAC,QAAQ,UAAR,EAAiB,OAAe,UAAS;AAAA,EACnD;AAEA,WAAS,UAAkC;AACzC,WAAO,WAAW,OAAO;AAAA,EAC3B;AAEA,SAAO,EAAE,cAAc,SAAS,aAAa,QAAQ;AACvD;","names":[]}

package/dist/rich.d.ts

@@ -0,0 +1,31 @@
+import { ReactNode } from 'react';
+
+/** What `renderLink` receives for each `<a>…</a>` of a message, in order of appearance. */
+interface RichLink {
+    /** The href given for this link (`href[index]`, or `href` itself when it is a string), if any. */
+    href: string | undefined;
+    /** The position of the link in the message: 0 for the first `<a>`. */
+    index: number;
+    children: ReactNode;
+}
+interface RichProps {
+    /** The message: plain text with `<b>…</b>` emphasis and `<a>…</a>` links, the only markup messages may carry. */
+    text: string;
+    /** The target of each `<a>`, in order (a string for a single link). The words stay in the message, the URL in code. */
+    href?: string | readonly string[];
+    /** Renders a link (e.g. with `next/link`). Default: `<a href>`, or the plain words when the link has no href. */
+    renderLink?: (link: RichLink) => ReactNode;
+}
+/**
+ * Renders a message with its markup — `<b>` → `<strong>`, `<a>` → a link — and everything else as text (never HTML:
+ * no `dangerouslySetInnerHTML`, an unknown or unbalanced tag is shown as written). `<b>` and `<a>` may hold each other.
+ * No hook, no context: usable in a Server Component.
+ *
+ * ```tsx
+ * <Rich text={t.home.lead} />
+ * <Rich text="Read <a>the docs</a>, <b>now</b>." href="/docs" renderLink={({ href, children }) => <Link href={href!}>{children}</Link>} />
+ * ```
+ */
+declare function Rich({ text, href, renderLink }: RichProps): ReactNode;
+
+export { Rich, type RichLink, type RichProps, Rich as default };

package/dist/rich.js

@@ -0,0 +1,39 @@
+// src/rich.tsx
+import { Fragment } from "react";
+import { Fragment as Fragment2, jsx } from "react/jsx-runtime";
+var TAG = /<(b|a)>([\s\S]*?)<\/\1>/g;
+function defaultLink({ href, children }) {
+  return href === void 0 ? children : /* @__PURE__ */ jsx("a", { href, children });
+}
+function Rich({ text, href, renderLink = defaultLink }) {
+  const hrefs = typeof href === "string" ? [href] : href ?? [];
+  let links = 0;
+  const render = (source, prefix) => {
+    const out = [];
+    let last = 0;
+    for (const match of source.matchAll(TAG)) {
+      const [whole, tag, inner] = match;
+      const at = match.index;
+      const key = `${prefix}${out.length}`;
+      if (at > last) out.push(/* @__PURE__ */ jsx(Fragment, { children: source.slice(last, at) }, `${key}t`));
+      if (tag === "b") {
+        out.push(/* @__PURE__ */ jsx("strong", { children: render(inner, `${key}.`) }, key));
+      } else {
+        const index = links++;
+        out.push(
+          /* @__PURE__ */ jsx(Fragment, { children: renderLink({ href: hrefs[index], index, children: render(inner, `${key}.`) }) }, key)
+        );
+      }
+      last = at + whole.length;
+    }
+    if (last < source.length) out.push(/* @__PURE__ */ jsx(Fragment, { children: source.slice(last) }, `${prefix}end`));
+    return out;
+  };
+  return /* @__PURE__ */ jsx(Fragment2, { children: render(text, "") });
+}
+var rich_default = Rich;
+export {
+  Rich,
+  rich_default as default
+};
+//# sourceMappingURL=rich.js.map

package/dist/rich.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/rich.tsx"],"sourcesContent":["import { Fragment, type ReactNode } from \"react\";\n\n/** What `renderLink` receives for each `<a>…</a>` of a message, in order of appearance. */\nexport interface RichLink {\n  /** The href given for this link (`href[index]`, or `href` itself when it is a string), if any. */\n  href: string | undefined;\n  /** The position of the link in the message: 0 for the first `<a>`. */\n  index: number;\n  children: ReactNode;\n}\n\nexport interface RichProps {\n  /** The message: plain text with `<b>…</b>` emphasis and `<a>…</a>` links, the only markup messages may carry. */\n  text: string;\n  /** The target of each `<a>`, in order (a string for a single link). The words stay in the message, the URL in code. */\n  href?: string | readonly string[];\n  /** Renders a link (e.g. with `next/link`). Default: `<a href>`, or the plain words when the link has no href. */\n  renderLink?: (link: RichLink) => ReactNode;\n}\n\nconst TAG = /<(b|a)>([\\s\\S]*?)<\\/\\1>/g;\n\nfunction defaultLink({ href, children }: RichLink): ReactNode {\n  return href === undefined ? children : <a href={href}>{children}</a>;\n}\n\n/**\n * Renders a message with its markup — `<b>` → `<strong>`, `<a>` → a link — and everything else as text (never HTML:\n * no `dangerouslySetInnerHTML`, an unknown or unbalanced tag is shown as written). `<b>` and `<a>` may hold each other.\n * No hook, no context: usable in a Server Component.\n *\n * ```tsx\n * <Rich text={t.home.lead} />\n * <Rich text=\"Read <a>the docs</a>, <b>now</b>.\" href=\"/docs\" renderLink={({ href, children }) => <Link href={href!}>{children}</Link>} />\n * ```\n */\nexport function Rich({ text, href, renderLink = defaultLink }: RichProps): ReactNode {\n  const hrefs = typeof href === \"string\" ? [href] : (href ?? []);\n  let links = 0;\n\n  // The match is lazy: inside <b>…</b> there is no </b>, so only an <a> can match there (and the other way round).\n  const render = (source: string, prefix: string): ReactNode[] => {\n    const out: ReactNode[] = [];\n    let last = 0;\n    for (const match of source.matchAll(TAG)) {\n      const [whole, tag, inner] = match as unknown as [string, \"a\" | \"b\", string];\n      const at = match.index as number;\n      const key = `${prefix}${out.length}`;\n      if (at > last) out.push(<Fragment key={`${key}t`}>{source.slice(last, at)}</Fragment>);\n      if (tag === \"b\") {\n        out.push(<strong key={key}>{render(inner, `${key}.`)}</strong>);\n      } else {\n        const index = links++;\n        out.push(\n          <Fragment key={key}>{renderLink({ href: hrefs[index], index, children: render(inner, `${key}.`) })}</Fragment>,\n        );\n      }\n      last = at + whole.length;\n    }\n    if (last < source.length) out.push(<Fragment key={`${prefix}end`}>{source.slice(last)}</Fragment>);\n    return out;\n  };\n\n  return <>{render(text, \"\")}</>;\n}\n\nexport default Rich;\n"],"mappings":";AAAA,SAAS,gBAAgC;AAuBA,SAwChC,YAAAA,WAxCgC;AAHzC,IAAM,MAAM;AAEZ,SAAS,YAAY,EAAE,MAAM,SAAS,GAAwB;AAC5D,SAAO,SAAS,SAAY,WAAW,oBAAC,OAAE,MAAa,UAAS;AAClE;AAYO,SAAS,KAAK,EAAE,MAAM,MAAM,aAAa,YAAY,GAAyB;AACnF,QAAM,QAAQ,OAAO,SAAS,WAAW,CAAC,IAAI,IAAK,QAAQ,CAAC;AAC5D,MAAI,QAAQ;AAGZ,QAAM,SAAS,CAAC,QAAgB,WAAgC;AAC9D,UAAM,MAAmB,CAAC;AAC1B,QAAI,OAAO;AACX,eAAW,SAAS,OAAO,SAAS,GAAG,GAAG;AACxC,YAAM,CAAC,OAAO,KAAK,KAAK,IAAI;AAC5B,YAAM,KAAK,MAAM;AACjB,YAAM,MAAM,GAAG,MAAM,GAAG,IAAI,MAAM;AAClC,UAAI,KAAK,KAAM,KAAI,KAAK,oBAAC,YAA0B,iBAAO,MAAM,MAAM,EAAE,KAAjC,GAAG,GAAG,GAA6B,CAAW;AACrF,UAAI,QAAQ,KAAK;AACf,YAAI,KAAK,oBAAC,YAAkB,iBAAO,OAAO,GAAG,GAAG,GAAG,KAA7B,GAA+B,CAAS;AAAA,MAChE,OAAO;AACL,cAAM,QAAQ;AACd,YAAI;AAAA,UACF,oBAAC,YAAoB,qBAAW,EAAE,MAAM,MAAM,KAAK,GAAG,OAAO,UAAU,OAAO,OAAO,GAAG,GAAG,GAAG,EAAE,CAAC,KAAlF,GAAoF;AAAA,QACrG;AAAA,MACF;AACA,aAAO,KAAK,MAAM;AAAA,IACpB;AACA,QAAI,OAAO,OAAO,OAAQ,KAAI,KAAK,oBAAC,YAA+B,iBAAO,MAAM,IAAI,KAAlC,GAAG,MAAM,KAA2B,CAAW;AACjG,WAAO;AAAA,EACT;AAEA,SAAO,oBAAAA,WAAA,EAAG,iBAAO,MAAM,EAAE,GAAE;AAC7B;AAEA,IAAO,eAAQ;","names":["Fragment"]}

package/package.json

@@ -1,6 +1,128 @@
 {
   "name": "@krizaka/i18n",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0-beta.1",
+  "description": "The i18n engine of every Krizaka app: typed message keys and placeholders from en.json, format(), plurals through @krizaka/intl, <Rich> (<b>, <a>), a React provider, and the krizaka-i18n CLI that checks catalogues and finds hard-coded strings.",
+  "keywords": [
+    "krizaka",
+    "i18n",
+    "translation",
+    "messages",
+    "typed-keys",
+    "plural",
+    "react",
+    "cli"
+  ],
+  "homepage": "https://github.com/krizaka/krizaka-ui/tree/main/packages/i18n#readme",
+  "bugs": "https://github.com/krizaka/krizaka-ui/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/krizaka/krizaka-ui.git",
+    "directory": "packages/i18n"
+  },
+  "license": "Apache-2.0",
+  "author": "Krizaka (https://www.krizaka.com)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./rich": {
+      "types": "./dist/rich.d.ts",
+      "import": "./dist/rich.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js"
+    },
+    "./check": {
+      "types": "./dist/check.d.ts",
+      "import": "./dist/check.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "krizaka-i18n": "./dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@krizaka/intl": "^0.1.0-beta.0"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "typescript": "^5"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@size-limit/preset-small-lib": "^14.2.0",
+    "@types/node": "^22.15.0",
+    "@types/react": "^19.2.0",
+    "@types/react-dom": "^19.2.0",
+    "@vitest/coverage-v8": "4.1.11",
+    "eslint": "^9.39.0",
+    "publint": "^0.3.25",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "size-limit": "^14.2.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.0",
+    "vitest": "^4.1.11",
+    "@krizaka/config": "0.1.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "size-limit": [
+    {
+      "name": ".",
+      "path": "dist/index.js",
+      "limit": "1.5 kB",
+      "gzip": true
+    },
+    {
+      "name": "./rich",
+      "path": "dist/rich.js",
+      "limit": "1 kB",
+      "gzip": true,
+      "ignore": [
+        "react"
+      ]
+    },
+    {
+      "name": "./react",
+      "path": "dist/react.js",
+      "limit": "2 kB",
+      "gzip": true,
+      "ignore": [
+        "react"
+      ]
+    }
+  ],
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsup",
+    "lint": "eslint . --max-warnings 0 && tsc --noEmit --noUnusedLocals --noUnusedParameters --noFallthroughCasesInSwitch --noImplicitReturns",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --coverage",
+    "size": "size-limit",
+    "publint": "publint && attw --pack . --profile esm-only && tsc -p test/consumer/tsconfig.json"
+  }
 }