@streetui/i18n 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 StreetUI contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,129 @@
+# @streetui/i18n
+
+Minimal, framework-native internationalization for StreetUI. Built **entirely**
+on `@streetui/state` signals — the active locale is a writable signal and `t()`
+returns a derived signal, so translations plug straight into the DSL's reactive
+text bindings. There is no second reactive system, no ICU parser, and no
+third-party dependency.
+
+```bash
+# part of the StreetUI monorepo — no separate install
+```
+
+---
+
+## Creating an instance
+
+```ts
+import { createI18n } from '@streetui/i18n';
+
+const messages = {
+  en: { 'app.title': 'Accounts', 'hello': 'Hello, {name}!', 'items.one': '{count} item', 'items.other': '{count} items' },
+  fr: { 'app.title': 'Comptes', 'hello': 'Bonjour, {name} !', 'items.one': '{count} article', 'items.other': '{count} articles' },
+} as const;
+
+// A typed message shape keeps keys checked at compile time.
+type MessageKey = keyof (typeof messages)['en'];
+type Messages = Record<MessageKey, string>;
+
+const i18n = createI18n<Messages>({
+  locale: 'en',
+  messages,
+  fallbackLocale: 'en',   // consulted when a key is missing in the active locale
+});
+```
+
+---
+
+## Reactive vs. one-shot translation
+
+There are two lookups, and the distinction matters:
+
+- **`t(key, params?)` → `ReadonlySignal<string>`** — reactive. It recomputes when
+  the locale changes, so it belongs in DSL bindings that should re-render on a
+  locale switch.
+- **`translate(key, params?)` → `string`** — a non-reactive one-shot read of the
+  current locale. Use it for values captured once at build time (e.g. a
+  validator message or a static `aria-label`) that should not re-render.
+
+```ts
+page.heading(i18n.t('app.title'));                 // reactive — flips on setLocale
+page.button('Save', { ariaLabel: i18n.translate('actions.save') });   // one-shot
+```
+
+`key` is typed as `keyof M & string`, so unknown keys are a compile error:
+
+```ts
+i18n.t('app.title');   // ok
+// @ts-expect-error — 'nope' is not a message key
+i18n.t('nope');
+```
+
+---
+
+## Reactive locale switching
+
+`i18n.locale` is a read-only signal and `setLocale()` writes it. Every `t()` /
+`plural()` signal created from the instance recomputes, so a single toggle
+re-renders every bound string in place:
+
+```ts
+shell.button(derived(() => i18n.locale.get().toUpperCase()), {
+  onClick: () => i18n.setLocale(i18n.locale.get() === 'en' ? 'fr' : 'en'),
+});
+```
+
+`i18n.locales` lists the locales that have a message map, in declaration order.
+
+---
+
+## Interpolation
+
+Placeholders use `{name}` syntax. Provide values via `params`; unknown
+placeholders are left intact (never replaced with `undefined`).
+
+```ts
+i18n.t('hello', { name: 'Ada' }).get();   // "Hello, Ada!"
+```
+
+The bundled `interpolate(template, params?)` helper is exported for direct use.
+
+---
+
+## Pluralization
+
+`plural(key, count, params?)` selects a message using the platform
+`Intl.PluralRules` for the active locale. It looks up `${key}.${category}`
+(e.g. `items.one`, `items.many`) and falls back to `${key}.other`. `count` is
+automatically available to interpolation as `{count}`.
+
+```ts
+i18n.plural('items', 1).get();    // "1 item"    (en → 'one')
+i18n.plural('items', 5).get();    // "5 items"   (en → 'other')
+```
+
+Because category selection is delegated to `Intl`, locale-specific plural rules
+(e.g. French, Russian, Arabic) work without any custom tables.
+
+---
+
+## Determinism, SSR & hydration
+
+Translation is deterministic by design:
+
+- a **missing key resolves to the key itself** (a stable, visible marker — never
+  a thrown error or a random placeholder), and
+- the same `(locale, key, params)` always produces the same string.
+
+That determinism is exactly what keeps `renderToString()` and `hydrate()` in
+agreement — **provided the client boots with the same initial locale the server
+rendered with.** Pass the server's locale into `createI18n({ locale })` on the
+client and the hydrated markup matches byte-for-byte before any `setLocale()`.
+`i18n` coexists cleanly with the router, forms, and context — see
+`examples/streetui-account` for all of them in one universal app.
+
+## Use with `has()`
+
+`has(key)` reports whether the active (or fallback) locale defines a key —
+useful for optional/feature-flagged copy without triggering the missing-key
+echo.

package/dist/index.cjs

@@ -0,0 +1,91 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createI18n: () => createI18n,
+  interpolate: () => interpolate
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/i18n.ts
+var import_state = require("@streetui/state");
+var INTERPOLATION = /\{(\w+)\}/g;
+function interpolate(template, params) {
+  if (params === void 0) return template;
+  return template.replace(INTERPOLATION, (whole, name) => {
+    const value = params[name];
+    return value === void 0 ? whole : String(value);
+  });
+}
+function createI18n(config) {
+  const messages = config.messages;
+  const fallback = config.fallbackLocale;
+  const localeSignal = (0, import_state.signal)(config.locale);
+  const locales = Object.keys(messages);
+  function lookup(loc, key) {
+    const active = messages[loc];
+    const hit = active === void 0 ? void 0 : active[key];
+    if (hit !== void 0) return hit;
+    if (fallback !== void 0 && fallback !== loc) {
+      const fb = messages[fallback];
+      if (fb !== void 0) return fb[key];
+    }
+    return void 0;
+  }
+  function resolve(loc, key, params) {
+    const template = lookup(loc, key);
+    return template === void 0 ? key : interpolate(template, params);
+  }
+  function pluralKey(loc, key, count) {
+    const category = new Intl.PluralRules(loc).select(count);
+    if (lookup(loc, `${key}.${category}`) !== void 0) return `${key}.${category}`;
+    return `${key}.other`;
+  }
+  return {
+    locale: localeSignal,
+    locales,
+    setLocale(loc) {
+      localeSignal.set(loc);
+    },
+    t(key, params) {
+      return (0, import_state.derived)(() => resolve(localeSignal.get(), key, params));
+    },
+    translate(key, params) {
+      return resolve(localeSignal.peek(), key, params);
+    },
+    plural(key, count, params) {
+      const merged = { count, ...params ?? {} };
+      return (0, import_state.derived)(() => {
+        const loc = localeSignal.get();
+        return resolve(loc, pluralKey(loc, key, count), merged);
+      });
+    },
+    has(key) {
+      return lookup(localeSignal.peek(), key) !== void 0;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createI18n,
+  interpolate
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/i18n.ts"],"sourcesContent":["export * from './i18n.js';\n","/**\n * Minimal, framework-native internationalization for StreetUI.\n *\n * Built entirely on `@streetui/state` signals — there is no second reactive\n * system. The active locale is a writable signal; `t()` returns a derived\n * signal that recomputes when the locale changes, so translations plug\n * straight into the DSL's reactive text bindings (`text(() => i18n.t(...).get())`\n * or `text(i18n.t(...))`).\n *\n * Translation is deterministic: a missing key resolves to the key itself, and\n * the same (locale, key, params) always produces the same string on the server\n * and the client. That determinism is what keeps `renderToString()` and\n * `hydrate()` in agreement — provided the app boots the client with the same\n * initial locale it rendered with on the server.\n */\n\nimport {\n  signal,\n  derived,\n  type ReadonlySignal,\n  type DerivedSignal,\n} from '@streetui/state';\n\n/** A flat dictionary of message templates for a single locale. */\nexport type MessageMap = Record<string, string>;\n\n/** Values allowed in interpolation params. */\nexport type InterpolationParams = Record<string, string | number>;\n\nexport interface I18nConfig<M extends MessageMap> {\n  /** The initial (and server-rendered) locale. */\n  readonly locale: string;\n  /** Messages keyed by locale, e.g. `{ en: {...}, fr: {...} }`. */\n  readonly messages: Readonly<Record<string, M>>;\n  /** Locale consulted when a key is absent from the active locale. */\n  readonly fallbackLocale?: string;\n}\n\nexport interface I18n<M extends MessageMap> {\n  /** The active locale as a reactive, read-only signal. */\n  readonly locale: ReadonlySignal<string>;\n  /** Switch the active locale; all `t()`/`plural()` signals recompute. */\n  setLocale(locale: string): void;\n  /** The locales that have a message map, in declaration order. */\n  readonly locales: ReadonlyArray<string>;\n  /** Reactive translation. Returns a derived signal — call `.get()` to read. */\n  t(key: keyof M & string, params?: InterpolationParams): ReadonlySignal<string>;\n  /** Non-reactive translation for the current locale (a one-shot read). */\n  translate(key: keyof M & string, params?: InterpolationParams): string;\n  /**\n   * Reactive pluralization via `Intl.PluralRules`. Selects the message whose\n   * key is `${key}.${category}` (e.g. `items.one`), falling back to\n   * `${key}.other`. `count` is available to interpolation as `{count}`.\n   */\n  plural(key: string, count: number, params?: InterpolationParams): ReadonlySignal<string>;\n  /** True when the active (or fallback) locale defines `key`. */\n  has(key: string): boolean;\n}\n\nconst INTERPOLATION = /\\{(\\w+)\\}/g;\n\n/** Replace `{name}` placeholders using `params`; unknown names are left intact. */\nexport function interpolate(template: string, params?: InterpolationParams): string {\n  if (params === undefined) return template;\n  return template.replace(INTERPOLATION, (whole, name: string) => {\n    const value = params[name];\n    return value === undefined ? whole : String(value);\n  });\n}\n\nexport function createI18n<M extends MessageMap>(config: I18nConfig<M>): I18n<M> {\n  const messages = config.messages;\n  const fallback = config.fallbackLocale;\n  const localeSignal = signal<string>(config.locale);\n  const locales = Object.keys(messages);\n\n  /** Resolve a raw template for `key` in `loc`, then the fallback locale. */\n  function lookup(loc: string, key: string): string | undefined {\n    const active = messages[loc];\n    const hit = active === undefined ? undefined : active[key];\n    if (hit !== undefined) return hit;\n    if (fallback !== undefined && fallback !== loc) {\n      const fb = messages[fallback];\n      if (fb !== undefined) return fb[key];\n    }\n    return undefined;\n  }\n\n  function resolve(loc: string, key: string, params?: InterpolationParams): string {\n    const template = lookup(loc, key);\n    // Deterministic miss: echo the key so output is stable server/client.\n    return template === undefined ? key : interpolate(template, params);\n  }\n\n  function pluralKey(loc: string, key: string, count: number): string {\n    const category = new Intl.PluralRules(loc).select(count);\n    if (lookup(loc, `${key}.${category}`) !== undefined) return `${key}.${category}`;\n    return `${key}.other`;\n  }\n\n  return {\n    locale: localeSignal,\n    locales,\n    setLocale(loc: string): void {\n      localeSignal.set(loc);\n    },\n    t(key, params): DerivedSignal<string> {\n      return derived<string>(() => resolve(localeSignal.get(), key, params));\n    },\n    translate(key, params): string {\n      return resolve(localeSignal.peek(), key, params);\n    },\n    plural(key, count, params): DerivedSignal<string> {\n      const merged: InterpolationParams = { count, ...(params ?? {}) };\n      return derived<string>(() => {\n        const loc = localeSignal.get();\n        return resolve(loc, pluralKey(loc, key, count), merged);\n      });\n    },\n    has(key: string): boolean {\n      return lookup(localeSignal.peek(), key) !== undefined;\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACgBA,mBAKO;AAsCP,IAAM,gBAAgB;AAGf,SAAS,YAAY,UAAkB,QAAsC;AAClF,MAAI,WAAW,OAAW,QAAO;AACjC,SAAO,SAAS,QAAQ,eAAe,CAAC,OAAO,SAAiB;AAC9D,UAAM,QAAQ,OAAO,IAAI;AACzB,WAAO,UAAU,SAAY,QAAQ,OAAO,KAAK;AAAA,EACnD,CAAC;AACH;AAEO,SAAS,WAAiC,QAAgC;AAC/E,QAAM,WAAW,OAAO;AACxB,QAAM,WAAW,OAAO;AACxB,QAAM,mBAAe,qBAAe,OAAO,MAAM;AACjD,QAAM,UAAU,OAAO,KAAK,QAAQ;AAGpC,WAAS,OAAO,KAAa,KAAiC;AAC5D,UAAM,SAAS,SAAS,GAAG;AAC3B,UAAM,MAAM,WAAW,SAAY,SAAY,OAAO,GAAG;AACzD,QAAI,QAAQ,OAAW,QAAO;AAC9B,QAAI,aAAa,UAAa,aAAa,KAAK;AAC9C,YAAM,KAAK,SAAS,QAAQ;AAC5B,UAAI,OAAO,OAAW,QAAO,GAAG,GAAG;AAAA,IACrC;AACA,WAAO;AAAA,EACT;AAEA,WAAS,QAAQ,KAAa,KAAa,QAAsC;AAC/E,UAAM,WAAW,OAAO,KAAK,GAAG;AAEhC,WAAO,aAAa,SAAY,MAAM,YAAY,UAAU,MAAM;AAAA,EACpE;AAEA,WAAS,UAAU,KAAa,KAAa,OAAuB;AAClE,UAAM,WAAW,IAAI,KAAK,YAAY,GAAG,EAAE,OAAO,KAAK;AACvD,QAAI,OAAO,KAAK,GAAG,GAAG,IAAI,QAAQ,EAAE,MAAM,OAAW,QAAO,GAAG,GAAG,IAAI,QAAQ;AAC9E,WAAO,GAAG,GAAG;AAAA,EACf;AAEA,SAAO;AAAA,IACL,QAAQ;AAAA,IACR;AAAA,IACA,UAAU,KAAmB;AAC3B,mBAAa,IAAI,GAAG;AAAA,IACtB;AAAA,IACA,EAAE,KAAK,QAA+B;AACpC,iBAAO,sBAAgB,MAAM,QAAQ,aAAa,IAAI,GAAG,KAAK,MAAM,CAAC;AAAA,IACvE;AAAA,IACA,UAAU,KAAK,QAAgB;AAC7B,aAAO,QAAQ,aAAa,KAAK,GAAG,KAAK,MAAM;AAAA,IACjD;AAAA,IACA,OAAO,KAAK,OAAO,QAA+B;AAChD,YAAM,SAA8B,EAAE,OAAO,GAAI,UAAU,CAAC,EAAG;AAC/D,iBAAO,sBAAgB,MAAM;AAC3B,cAAM,MAAM,aAAa,IAAI;AAC7B,eAAO,QAAQ,KAAK,UAAU,KAAK,KAAK,KAAK,GAAG,MAAM;AAAA,MACxD,CAAC;AAAA,IACH;AAAA,IACA,IAAI,KAAsB;AACxB,aAAO,OAAO,aAAa,KAAK,GAAG,GAAG,MAAM;AAAA,IAC9C;AAAA,EACF;AACF;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,55 @@
+import { ReadonlySignal } from '@streetui/state';
+
+/**
+ * Minimal, framework-native internationalization for StreetUI.
+ *
+ * Built entirely on `@streetui/state` signals — there is no second reactive
+ * system. The active locale is a writable signal; `t()` returns a derived
+ * signal that recomputes when the locale changes, so translations plug
+ * straight into the DSL's reactive text bindings (`text(() => i18n.t(...).get())`
+ * or `text(i18n.t(...))`).
+ *
+ * Translation is deterministic: a missing key resolves to the key itself, and
+ * the same (locale, key, params) always produces the same string on the server
+ * and the client. That determinism is what keeps `renderToString()` and
+ * `hydrate()` in agreement — provided the app boots the client with the same
+ * initial locale it rendered with on the server.
+ */
+
+/** A flat dictionary of message templates for a single locale. */
+type MessageMap = Record<string, string>;
+/** Values allowed in interpolation params. */
+type InterpolationParams = Record<string, string | number>;
+interface I18nConfig<M extends MessageMap> {
+    /** The initial (and server-rendered) locale. */
+    readonly locale: string;
+    /** Messages keyed by locale, e.g. `{ en: {...}, fr: {...} }`. */
+    readonly messages: Readonly<Record<string, M>>;
+    /** Locale consulted when a key is absent from the active locale. */
+    readonly fallbackLocale?: string;
+}
+interface I18n<M extends MessageMap> {
+    /** The active locale as a reactive, read-only signal. */
+    readonly locale: ReadonlySignal<string>;
+    /** Switch the active locale; all `t()`/`plural()` signals recompute. */
+    setLocale(locale: string): void;
+    /** The locales that have a message map, in declaration order. */
+    readonly locales: ReadonlyArray<string>;
+    /** Reactive translation. Returns a derived signal — call `.get()` to read. */
+    t(key: keyof M & string, params?: InterpolationParams): ReadonlySignal<string>;
+    /** Non-reactive translation for the current locale (a one-shot read). */
+    translate(key: keyof M & string, params?: InterpolationParams): string;
+    /**
+     * Reactive pluralization via `Intl.PluralRules`. Selects the message whose
+     * key is `${key}.${category}` (e.g. `items.one`), falling back to
+     * `${key}.other`. `count` is available to interpolation as `{count}`.
+     */
+    plural(key: string, count: number, params?: InterpolationParams): ReadonlySignal<string>;
+    /** True when the active (or fallback) locale defines `key`. */
+    has(key: string): boolean;
+}
+/** Replace `{name}` placeholders using `params`; unknown names are left intact. */
+declare function interpolate(template: string, params?: InterpolationParams): string;
+declare function createI18n<M extends MessageMap>(config: I18nConfig<M>): I18n<M>;
+
+export { type I18n, type I18nConfig, type InterpolationParams, type MessageMap, createI18n, interpolate };

package/dist/index.d.ts

@@ -0,0 +1,55 @@
+import { ReadonlySignal } from '@streetui/state';
+
+/**
+ * Minimal, framework-native internationalization for StreetUI.
+ *
+ * Built entirely on `@streetui/state` signals — there is no second reactive
+ * system. The active locale is a writable signal; `t()` returns a derived
+ * signal that recomputes when the locale changes, so translations plug
+ * straight into the DSL's reactive text bindings (`text(() => i18n.t(...).get())`
+ * or `text(i18n.t(...))`).
+ *
+ * Translation is deterministic: a missing key resolves to the key itself, and
+ * the same (locale, key, params) always produces the same string on the server
+ * and the client. That determinism is what keeps `renderToString()` and
+ * `hydrate()` in agreement — provided the app boots the client with the same
+ * initial locale it rendered with on the server.
+ */
+
+/** A flat dictionary of message templates for a single locale. */
+type MessageMap = Record<string, string>;
+/** Values allowed in interpolation params. */
+type InterpolationParams = Record<string, string | number>;
+interface I18nConfig<M extends MessageMap> {
+    /** The initial (and server-rendered) locale. */
+    readonly locale: string;
+    /** Messages keyed by locale, e.g. `{ en: {...}, fr: {...} }`. */
+    readonly messages: Readonly<Record<string, M>>;
+    /** Locale consulted when a key is absent from the active locale. */
+    readonly fallbackLocale?: string;
+}
+interface I18n<M extends MessageMap> {
+    /** The active locale as a reactive, read-only signal. */
+    readonly locale: ReadonlySignal<string>;
+    /** Switch the active locale; all `t()`/`plural()` signals recompute. */
+    setLocale(locale: string): void;
+    /** The locales that have a message map, in declaration order. */
+    readonly locales: ReadonlyArray<string>;
+    /** Reactive translation. Returns a derived signal — call `.get()` to read. */
+    t(key: keyof M & string, params?: InterpolationParams): ReadonlySignal<string>;
+    /** Non-reactive translation for the current locale (a one-shot read). */
+    translate(key: keyof M & string, params?: InterpolationParams): string;
+    /**
+     * Reactive pluralization via `Intl.PluralRules`. Selects the message whose
+     * key is `${key}.${category}` (e.g. `items.one`), falling back to
+     * `${key}.other`. `count` is available to interpolation as `{count}`.
+     */
+    plural(key: string, count: number, params?: InterpolationParams): ReadonlySignal<string>;
+    /** True when the active (or fallback) locale defines `key`. */
+    has(key: string): boolean;
+}
+/** Replace `{name}` placeholders using `params`; unknown names are left intact. */
+declare function interpolate(template: string, params?: InterpolationParams): string;
+declare function createI18n<M extends MessageMap>(config: I18nConfig<M>): I18n<M>;
+
+export { type I18n, type I18nConfig, type InterpolationParams, type MessageMap, createI18n, interpolate };

package/dist/index.js

@@ -0,0 +1,66 @@
+// src/i18n.ts
+import {
+  signal,
+  derived
+} from "@streetui/state";
+var INTERPOLATION = /\{(\w+)\}/g;
+function interpolate(template, params) {
+  if (params === void 0) return template;
+  return template.replace(INTERPOLATION, (whole, name) => {
+    const value = params[name];
+    return value === void 0 ? whole : String(value);
+  });
+}
+function createI18n(config) {
+  const messages = config.messages;
+  const fallback = config.fallbackLocale;
+  const localeSignal = signal(config.locale);
+  const locales = Object.keys(messages);
+  function lookup(loc, key) {
+    const active = messages[loc];
+    const hit = active === void 0 ? void 0 : active[key];
+    if (hit !== void 0) return hit;
+    if (fallback !== void 0 && fallback !== loc) {
+      const fb = messages[fallback];
+      if (fb !== void 0) return fb[key];
+    }
+    return void 0;
+  }
+  function resolve(loc, key, params) {
+    const template = lookup(loc, key);
+    return template === void 0 ? key : interpolate(template, params);
+  }
+  function pluralKey(loc, key, count) {
+    const category = new Intl.PluralRules(loc).select(count);
+    if (lookup(loc, `${key}.${category}`) !== void 0) return `${key}.${category}`;
+    return `${key}.other`;
+  }
+  return {
+    locale: localeSignal,
+    locales,
+    setLocale(loc) {
+      localeSignal.set(loc);
+    },
+    t(key, params) {
+      return derived(() => resolve(localeSignal.get(), key, params));
+    },
+    translate(key, params) {
+      return resolve(localeSignal.peek(), key, params);
+    },
+    plural(key, count, params) {
+      const merged = { count, ...params ?? {} };
+      return derived(() => {
+        const loc = localeSignal.get();
+        return resolve(loc, pluralKey(loc, key, count), merged);
+      });
+    },
+    has(key) {
+      return lookup(localeSignal.peek(), key) !== void 0;
+    }
+  };
+}
+export {
+  createI18n,
+  interpolate
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/i18n.ts"],"sourcesContent":["/**\n * Minimal, framework-native internationalization for StreetUI.\n *\n * Built entirely on `@streetui/state` signals — there is no second reactive\n * system. The active locale is a writable signal; `t()` returns a derived\n * signal that recomputes when the locale changes, so translations plug\n * straight into the DSL's reactive text bindings (`text(() => i18n.t(...).get())`\n * or `text(i18n.t(...))`).\n *\n * Translation is deterministic: a missing key resolves to the key itself, and\n * the same (locale, key, params) always produces the same string on the server\n * and the client. That determinism is what keeps `renderToString()` and\n * `hydrate()` in agreement — provided the app boots the client with the same\n * initial locale it rendered with on the server.\n */\n\nimport {\n  signal,\n  derived,\n  type ReadonlySignal,\n  type DerivedSignal,\n} from '@streetui/state';\n\n/** A flat dictionary of message templates for a single locale. */\nexport type MessageMap = Record<string, string>;\n\n/** Values allowed in interpolation params. */\nexport type InterpolationParams = Record<string, string | number>;\n\nexport interface I18nConfig<M extends MessageMap> {\n  /** The initial (and server-rendered) locale. */\n  readonly locale: string;\n  /** Messages keyed by locale, e.g. `{ en: {...}, fr: {...} }`. */\n  readonly messages: Readonly<Record<string, M>>;\n  /** Locale consulted when a key is absent from the active locale. */\n  readonly fallbackLocale?: string;\n}\n\nexport interface I18n<M extends MessageMap> {\n  /** The active locale as a reactive, read-only signal. */\n  readonly locale: ReadonlySignal<string>;\n  /** Switch the active locale; all `t()`/`plural()` signals recompute. */\n  setLocale(locale: string): void;\n  /** The locales that have a message map, in declaration order. */\n  readonly locales: ReadonlyArray<string>;\n  /** Reactive translation. Returns a derived signal — call `.get()` to read. */\n  t(key: keyof M & string, params?: InterpolationParams): ReadonlySignal<string>;\n  /** Non-reactive translation for the current locale (a one-shot read). */\n  translate(key: keyof M & string, params?: InterpolationParams): string;\n  /**\n   * Reactive pluralization via `Intl.PluralRules`. Selects the message whose\n   * key is `${key}.${category}` (e.g. `items.one`), falling back to\n   * `${key}.other`. `count` is available to interpolation as `{count}`.\n   */\n  plural(key: string, count: number, params?: InterpolationParams): ReadonlySignal<string>;\n  /** True when the active (or fallback) locale defines `key`. */\n  has(key: string): boolean;\n}\n\nconst INTERPOLATION = /\\{(\\w+)\\}/g;\n\n/** Replace `{name}` placeholders using `params`; unknown names are left intact. */\nexport function interpolate(template: string, params?: InterpolationParams): string {\n  if (params === undefined) return template;\n  return template.replace(INTERPOLATION, (whole, name: string) => {\n    const value = params[name];\n    return value === undefined ? whole : String(value);\n  });\n}\n\nexport function createI18n<M extends MessageMap>(config: I18nConfig<M>): I18n<M> {\n  const messages = config.messages;\n  const fallback = config.fallbackLocale;\n  const localeSignal = signal<string>(config.locale);\n  const locales = Object.keys(messages);\n\n  /** Resolve a raw template for `key` in `loc`, then the fallback locale. */\n  function lookup(loc: string, key: string): string | undefined {\n    const active = messages[loc];\n    const hit = active === undefined ? undefined : active[key];\n    if (hit !== undefined) return hit;\n    if (fallback !== undefined && fallback !== loc) {\n      const fb = messages[fallback];\n      if (fb !== undefined) return fb[key];\n    }\n    return undefined;\n  }\n\n  function resolve(loc: string, key: string, params?: InterpolationParams): string {\n    const template = lookup(loc, key);\n    // Deterministic miss: echo the key so output is stable server/client.\n    return template === undefined ? key : interpolate(template, params);\n  }\n\n  function pluralKey(loc: string, key: string, count: number): string {\n    const category = new Intl.PluralRules(loc).select(count);\n    if (lookup(loc, `${key}.${category}`) !== undefined) return `${key}.${category}`;\n    return `${key}.other`;\n  }\n\n  return {\n    locale: localeSignal,\n    locales,\n    setLocale(loc: string): void {\n      localeSignal.set(loc);\n    },\n    t(key, params): DerivedSignal<string> {\n      return derived<string>(() => resolve(localeSignal.get(), key, params));\n    },\n    translate(key, params): string {\n      return resolve(localeSignal.peek(), key, params);\n    },\n    plural(key, count, params): DerivedSignal<string> {\n      const merged: InterpolationParams = { count, ...(params ?? {}) };\n      return derived<string>(() => {\n        const loc = localeSignal.get();\n        return resolve(loc, pluralKey(loc, key, count), merged);\n      });\n    },\n    has(key: string): boolean {\n      return lookup(localeSignal.peek(), key) !== undefined;\n    },\n  };\n}\n"],"mappings":";AAgBA;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AAsCP,IAAM,gBAAgB;AAGf,SAAS,YAAY,UAAkB,QAAsC;AAClF,MAAI,WAAW,OAAW,QAAO;AACjC,SAAO,SAAS,QAAQ,eAAe,CAAC,OAAO,SAAiB;AAC9D,UAAM,QAAQ,OAAO,IAAI;AACzB,WAAO,UAAU,SAAY,QAAQ,OAAO,KAAK;AAAA,EACnD,CAAC;AACH;AAEO,SAAS,WAAiC,QAAgC;AAC/E,QAAM,WAAW,OAAO;AACxB,QAAM,WAAW,OAAO;AACxB,QAAM,eAAe,OAAe,OAAO,MAAM;AACjD,QAAM,UAAU,OAAO,KAAK,QAAQ;AAGpC,WAAS,OAAO,KAAa,KAAiC;AAC5D,UAAM,SAAS,SAAS,GAAG;AAC3B,UAAM,MAAM,WAAW,SAAY,SAAY,OAAO,GAAG;AACzD,QAAI,QAAQ,OAAW,QAAO;AAC9B,QAAI,aAAa,UAAa,aAAa,KAAK;AAC9C,YAAM,KAAK,SAAS,QAAQ;AAC5B,UAAI,OAAO,OAAW,QAAO,GAAG,GAAG;AAAA,IACrC;AACA,WAAO;AAAA,EACT;AAEA,WAAS,QAAQ,KAAa,KAAa,QAAsC;AAC/E,UAAM,WAAW,OAAO,KAAK,GAAG;AAEhC,WAAO,aAAa,SAAY,MAAM,YAAY,UAAU,MAAM;AAAA,EACpE;AAEA,WAAS,UAAU,KAAa,KAAa,OAAuB;AAClE,UAAM,WAAW,IAAI,KAAK,YAAY,GAAG,EAAE,OAAO,KAAK;AACvD,QAAI,OAAO,KAAK,GAAG,GAAG,IAAI,QAAQ,EAAE,MAAM,OAAW,QAAO,GAAG,GAAG,IAAI,QAAQ;AAC9E,WAAO,GAAG,GAAG;AAAA,EACf;AAEA,SAAO;AAAA,IACL,QAAQ;AAAA,IACR;AAAA,IACA,UAAU,KAAmB;AAC3B,mBAAa,IAAI,GAAG;AAAA,IACtB;AAAA,IACA,EAAE,KAAK,QAA+B;AACpC,aAAO,QAAgB,MAAM,QAAQ,aAAa,IAAI,GAAG,KAAK,MAAM,CAAC;AAAA,IACvE;AAAA,IACA,UAAU,KAAK,QAAgB;AAC7B,aAAO,QAAQ,aAAa,KAAK,GAAG,KAAK,MAAM;AAAA,IACjD;AAAA,IACA,OAAO,KAAK,OAAO,QAA+B;AAChD,YAAM,SAA8B,EAAE,OAAO,GAAI,UAAU,CAAC,EAAG;AAC/D,aAAO,QAAgB,MAAM;AAC3B,cAAM,MAAM,aAAa,IAAI;AAC7B,eAAO,QAAQ,KAAK,UAAU,KAAK,KAAK,KAAK,GAAG,MAAM;AAAA,MACxD,CAAC;AAAA,IACH;AAAA,IACA,IAAI,KAAsB;AACxB,aAAO,OAAO,aAAa,KAAK,GAAG,GAAG,MAAM;AAAA,IAC9C;AAAA,EACF;AACF;","names":[]}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@streetui/i18n",
+  "version": "1.0.0",
+  "description": "StreetUI internationalization — reactive locale, typed translation, interpolation and pluralization",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@streetui/state": "1.0.0"
+  },
+  "devDependencies": {
+    "typescript": "*",
+    "tsup": "*",
+    "vitest": "*"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
+}