@nibapp/ui 0.0.0-stage → 0.1.0

package/dist/components/truncated-text.js

@@ -0,0 +1,19 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Tooltip as BaseTooltip } from "@base-ui/react/tooltip";
+import { useRef, useState } from "react";
+import { cn } from "../lib/cn.js";
+import { TooltipContent } from "./tooltip.js";
+/**
+ * One line of text that truncates with an ellipsis when its box is too narrow, and then shows the
+ * whole of it in a tooltip on hover. Text that fits has no tooltip. Screen readers always get the
+ * full text (the cut is visual). Use it for names and titles that must stay on one line.
+ */
+export function TruncatedText({ children, full, side, className, ...props }) {
+    const ref = useRef(null);
+    const [open, setOpen] = useState(false);
+    return (_jsxs(BaseTooltip.Root, { open: open, onOpenChange: (next) => {
+            const el = ref.current;
+            setOpen(next && el !== null && el.scrollWidth > el.clientWidth + 1);
+        }, children: [_jsx(BaseTooltip.Trigger, { render: _jsx("span", { ref: ref, "data-slot": "truncated-text", className: cn("block min-w-0 truncate", className), ...props }), children: children }), _jsx(TooltipContent, { ...(side === undefined ? {} : { side }), children: _jsx("span", { className: "break-words", children: full ?? children }) })] }));
+}

package/dist/i18n/defaults.d.ts

@@ -0,0 +1,7 @@
+/** The language the kit speaks without a provider, and whose table every other one matches. */
+export declare const DEFAULT_LOCALE = "en";
+/**
+ * The tag English is formatted with when no provider names one: day before month and a 24-hour clock
+ * ("1 Nov", "14:05"), the kit's own choice. A provider's `locale` always wins.
+ */
+export declare const ENGLISH_FORMAT_LOCALE = "en-GB";

package/dist/i18n/defaults.js

@@ -0,0 +1,7 @@
+/** The language the kit speaks without a provider, and whose table every other one matches. */
+export const DEFAULT_LOCALE = "en";
+/**
+ * The tag English is formatted with when no provider names one: day before month and a 24-hour clock
+ * ("1 Nov", "14:05"), the kit's own choice. A provider's `locale` always wins.
+ */
+export const ENGLISH_FORMAT_LOCALE = "en-GB";

package/dist/i18n/format.d.ts

@@ -0,0 +1,84 @@
+import { type Amount } from "../lib/number-format.js";
+import { type UiStrings } from "./strings/index.js";
+/** A unit of a spoken time phrase (`Intl.RelativeTimeFormat` unit names). */
+export type TimeUnit = "second" | "minute" | "hour" | "day";
+/** Whole minutes as the largest sensible unit, like `span`: 12 → 12 minutes, 180 → 3 hours, 2880 → 2 days. */
+export declare function spanValue(minutes: number): {
+    readonly value: number;
+    readonly unit: "minute" | "hour" | "day";
+};
+/** Locale-aware formatters. Get them from `useFormatters()`; English output is the house style. */
+export interface UiFormatters {
+    readonly locale: string;
+    /** IANA zone dates and clock times are shown in (the person's); `undefined`: the runtime's own. */
+    readonly timeZone: string | undefined;
+    /** A plain number in the locale: "1,234.5" / "1 234,5". */
+    readonly number: (n: number, options?: Intl.NumberFormatOptions) => string;
+    /** `formatCount`: "58.7k" / "58,7 тыс.". */
+    readonly count: (n: number) => string;
+    /** `formatMoney`: "$1,204" / "1 204 $", in the amount's currency. */
+    readonly money: (amount: Amount) => string;
+    /** Money in words for composite labels: "1.84 US dollars"; dust is "less than 0.01 US dollars". */
+    readonly spokenMoney: (amount: Amount) => string;
+    /** Whole units, for amounts people set: "$25", "25 $". */
+    readonly wholeMoney: (amount: Amount) => string;
+    /** An amount exactly as set or billed: "$25", "$2.50", "$1,204.50"; never rounded to whole units. */
+    readonly exactMoney: (amount: Amount) => string;
+    /** A low–high range: "$0.05–$0.20", "0,05–0,20 $". */
+    readonly moneyRange: (low: Amount, high: Amount) => string;
+    /** A unit price, sub-cent digits kept: "$4", "$2.50", "$0.075". */
+    readonly unitPrice: (amount: Amount) => string;
+    /** A currency's symbol (`currency`'s, else the provider's) and the side the locale writes it on, for amount fields. */
+    readonly currencySymbol: (currency?: string) => {
+        readonly symbol: string;
+        readonly leading: boolean;
+    };
+    /** A size, decimal like Finder: "2.4 MB", "830 kB", "12 bytes" / "2,4 МБ", "12 байт". */
+    readonly bytes: (n: number) => string;
+    /** Memory, binary as the system reports RAM: 32 GiB is "32 GB", 512 MiB "512 MB" / "32 ГБ". */
+    readonly memory: (n: number) => string;
+    /**
+     * A percent (0–100) as the locale writes it (`Intl.NumberFormat`'s percent style): "61%", "61 %",
+     * "%61". Whole by default; `maximumFractionDigits` keeps decimals ("1.8%").
+     */
+    readonly percent: (pct: number, options?: {
+        readonly maximumFractionDigits?: number;
+    }) => string;
+    /** Elapsed time: "850ms", "4.2s", "42s", "3m 05s", "2h 05m". */
+    readonly duration: (ms: number) => string;
+    /** A live counter in whole seconds: "12s", "1m 04s", "1h 02m" (a finished span reads `duration`). */
+    readonly elapsed: (ms: number) => string;
+    /** Whole minutes as the largest sensible unit: "12m", "3h", "2d" (spoken: "12 minutes"). */
+    readonly span: (minutes: number, options?: {
+        readonly spoken?: boolean;
+    }) => string;
+    /**
+     * A future time as a whole phrase in the locale's grammar (`Intl.RelativeTimeFormat`):
+     * "in 12 minutes", "через 1 минуту". For sentences like "Expires {relative}".
+     */
+    readonly future: (value: number, unit: TimeUnit) => string;
+    /**
+     * A past time as a whole phrase in the locale's grammar (`Intl.RelativeTimeFormat`): "4 minutes
+     * ago", "4 минуты назад". For sentences like "Started {relative}" (`relativeTime` is a column label).
+     */
+    readonly past: (value: number, unit: TimeUnit) => string;
+    /** "now", "4m", "3h", "yesterday", "5d", then a short date. */
+    readonly relativeTime: (at: string | number | Date, now?: number) => string;
+    /** "Oct 21" / "21 окт.". */
+    readonly shortDate: (at: string | number | Date) => string;
+    /** "09:41 AM" / "09:41"; undefined for an invalid date. */
+    readonly clockTime: (at: string | number | Date) => string | undefined;
+}
+/**
+ * Builds the formatters for a locale (the exact BCP 47 tag) and its `time` / `money` strings.
+ * `Intl` objects are created on first use and owned by the returned object — never cached at
+ * module scope, since one SSR process may render several locales. `UiI18nProvider` keeps one per
+ * locale; pure helpers build English ones per call (`englishFormatters()`), which is cheap. A number
+ * is shown as money in `currency`; without one, only `Money` amounts (which carry their own) can be.
+ */
+export declare function createFormatters(locale: string, strings: Pick<UiStrings, "time" | "money">, timeZone?: string, currency?: string): UiFormatters;
+/**
+ * Fresh formatters in the default language, whose strings are the source table: the default of the
+ * pure helpers (`formatRelativeTime`, `formatTimeLeft`, …).
+ */
+export declare function englishFormatters(currency?: string): UiFormatters;

package/dist/i18n/format.js

@@ -0,0 +1,169 @@
+import { createNumberFormatters } from "../lib/number-format.js";
+import { ENGLISH_FORMAT_LOCALE } from "./defaults.js";
+import { EN_UI_STRINGS } from "./strings/index.js";
+/** Whole minutes as the largest sensible unit, like `span`: 12 → 12 minutes, 180 → 3 hours, 2880 → 2 days. */
+export function spanValue(minutes) {
+    if (minutes < 60)
+        return { value: minutes, unit: "minute" };
+    const hours = Math.round(minutes / 60);
+    if (hours < 48)
+        return { value: hours, unit: "hour" };
+    return { value: Math.round(hours / 24), unit: "day" };
+}
+/** Sizes count in thousands (Finder, file sizes); memory in 1024s, as systems report RAM. */
+const DECIMAL = 1000;
+const BINARY = 1024;
+/** A byte count in its largest unit of `base` (`Intl` unit names). */
+function byteUnit(bytes, base) {
+    if (bytes >= base ** 3)
+        return [bytes / base ** 3, "gigabyte"];
+    if (bytes >= base ** 2)
+        return [bytes / base ** 2, "megabyte"];
+    if (bytes >= base)
+        return [bytes / base, "kilobyte"];
+    return [bytes, "byte"];
+}
+/**
+ * Builds the formatters for a locale (the exact BCP 47 tag) and its `time` / `money` strings.
+ * `Intl` objects are created on first use and owned by the returned object — never cached at
+ * module scope, since one SSR process may render several locales. `UiI18nProvider` keeps one per
+ * locale; pure helpers build English ones per call (`englishFormatters()`), which is cheap. A number
+ * is shown as money in `currency`; without one, only `Money` amounts (which carry their own) can be.
+ */
+export function createFormatters(locale, strings, timeZone, currency) {
+    const { time, money } = strings;
+    const numbers = createNumberFormatters(locale, currency);
+    let dateFormat;
+    let clockFormat;
+    let relativeFormat;
+    const numberFormats = new Map();
+    const number = (n, options) => {
+        const key = options === undefined ? "" : JSON.stringify(options);
+        let format = numberFormats.get(key);
+        if (format === undefined) {
+            format = new Intl.NumberFormat(locale, options);
+            numberFormats.set(key, format);
+        }
+        return format.format(n);
+    };
+    const integer = (n) => number(n, { useGrouping: false });
+    // A minute or more of whole seconds: "3m 05s" under an hour, "2h 05m" from one.
+    const minutesOrHours = (seconds) => {
+        const m = Math.floor(seconds / 60);
+        if (m < 60) {
+            return time.minutesSecondsShort({
+                minutes: integer(m),
+                seconds: String(seconds % 60).padStart(2, "0"),
+            });
+        }
+        return time.hoursMinutesShort({
+            hours: integer(Math.floor(m / 60)),
+            minutes: String(m % 60).padStart(2, "0"),
+        });
+    };
+    const oneDecimal = (n) => number(n, { minimumFractionDigits: 1, maximumFractionDigits: 1 });
+    const span = (minutes, options) => {
+        const spoken = options?.spoken === true;
+        const { value, unit } = spanValue(minutes);
+        if (unit === "minute") {
+            return spoken ? time.minutes({ count: value }) : time.minutesShort({ value: integer(value) });
+        }
+        if (unit === "hour")
+            return spoken ? time.hours({ count: value }) : time.hoursShort({ value: integer(value) });
+        return spoken ? time.days({ count: value }) : time.daysShort({ value: integer(value) });
+    };
+    const size = (bytes, base) => {
+        const [value, unit] = byteUnit(bytes, base);
+        // Intl's short "byte" doesn't pluralize ("44 byte"); spelled out it does ("44 bytes", "44 байта").
+        const unitDisplay = unit === "byte" ? "long" : "short";
+        return number(value, { style: "unit", unit, unitDisplay, maximumFractionDigits: 1 });
+    };
+    const shortDate = (at) => {
+        dateFormat ??= new Intl.DateTimeFormat(locale, { month: "short", day: "numeric", timeZone });
+        return dateFormat.format(new Date(at));
+    };
+    return {
+        locale,
+        timeZone,
+        number,
+        count: numbers.count,
+        money: numbers.money,
+        spokenMoney: (amount) => {
+            const floor = numbers.dustFloor(amount);
+            return floor === undefined
+                ? numbers.spokenMoney(amount)
+                : money.spokenDust({ amount: numbers.spokenMoney(floor) });
+        },
+        wholeMoney: numbers.wholeMoney,
+        exactMoney: numbers.exactMoney,
+        moneyRange: numbers.moneyRange,
+        unitPrice: numbers.unitPrice,
+        currencySymbol: numbers.currencySymbol,
+        bytes: (n) => size(n, DECIMAL),
+        memory: (n) => size(n, BINARY),
+        percent: (pct, options) => {
+            const digits = options?.maximumFractionDigits ?? 0;
+            // Rounded in percent first, so 57.5 reads as 58, not as 0.575's binary 0.57499….
+            const scale = 10 ** digits;
+            return number(Math.round(pct * scale) / scale / 100, {
+                style: "percent",
+                maximumFractionDigits: digits,
+            });
+        },
+        duration: (ms) => {
+            if (ms < 1000)
+                return time.millisecondsShort({ value: integer(Math.max(1, Math.round(ms))) });
+            if (ms < 10_000)
+                return time.secondsShort({ value: oneDecimal(ms / 1000) });
+            if (ms < 60_000)
+                return time.secondsShort({ value: integer(Math.round(ms / 1000)) });
+            return minutesOrHours(Math.round(ms / 1000));
+        },
+        elapsed: (ms) => {
+            const seconds = Math.max(0, Math.floor(ms / 1000));
+            return seconds < 60 ? time.secondsShort({ value: integer(seconds) }) : minutesOrHours(seconds);
+        },
+        span,
+        future: (value, unit) => {
+            relativeFormat ??= new Intl.RelativeTimeFormat(locale, { numeric: "always" });
+            return relativeFormat.format(value, unit);
+        },
+        past: (value, unit) => {
+            relativeFormat ??= new Intl.RelativeTimeFormat(locale, { numeric: "always" });
+            return relativeFormat.format(-value, unit);
+        },
+        relativeTime: (at, now = Date.now()) => {
+            const t = typeof at === "number" ? at : new Date(at).getTime();
+            const s = Math.max(0, Math.round((now - t) / 1000));
+            if (s < 45)
+                return time.now;
+            const m = Math.round(s / 60);
+            if (m < 60)
+                return time.minutesShort({ value: integer(m) });
+            const h = Math.round(m / 60);
+            if (h < 24)
+                return time.hoursShort({ value: integer(h) });
+            const d = Math.round(h / 24);
+            if (d === 1)
+                return time.yesterday;
+            if (d < 7)
+                return time.daysShort({ value: integer(d) });
+            return shortDate(t);
+        },
+        shortDate,
+        clockTime: (at) => {
+            const date = at instanceof Date ? at : new Date(at);
+            if (Number.isNaN(date.getTime()))
+                return undefined;
+            clockFormat ??= new Intl.DateTimeFormat(locale, { hour: "2-digit", minute: "2-digit", timeZone });
+            return clockFormat.format(date);
+        },
+    };
+}
+/**
+ * Fresh formatters in the default language, whose strings are the source table: the default of the
+ * pure helpers (`formatRelativeTime`, `formatTimeLeft`, …).
+ */
+export function englishFormatters(currency) {
+    return createFormatters(ENGLISH_FORMAT_LOCALE, EN_UI_STRINGS, undefined, currency);
+}

package/dist/i18n/index.d.ts

@@ -0,0 +1,6 @@
+export { createFormatters, englishFormatters, spanValue, type TimeUnit, type UiFormatters, } from "./format.js";
+export { digits, type PluralForms, plural } from "./plural.js";
+export { UiI18nProvider, type UiI18nProviderProps, useFormatters, useUiLocale, useUiStrings, } from "./provider.js";
+export { type RichParams, richText } from "./rich.js";
+export { type DeepReadonly, EN_UI_STRINGS, type UiStrings } from "./strings/index.js";
+export { currentZoneName, type TimeZoneOption, timeZoneOptions, zoneCity, zoneLabel } from "./time-zones.js";

package/dist/i18n/index.js

@@ -0,0 +1,8 @@
+// @nibapp/ui/i18n — the kit's English strings, locale-aware formatters and the provider that localizes
+// its components in any language (another language's table: `@nibapp/ui/locales/ru`, or your own).
+export { createFormatters, englishFormatters, spanValue, } from "./format.js";
+export { digits, plural } from "./plural.js";
+export { UiI18nProvider, useFormatters, useUiLocale, useUiStrings, } from "./provider.js";
+export { richText } from "./rich.js";
+export { EN_UI_STRINGS } from "./strings/index.js";
+export { currentZoneName, timeZoneOptions, zoneCity, zoneLabel } from "./time-zones.js";

package/dist/i18n/locales/ru-formatters.d.ts

@@ -0,0 +1,3 @@
+import type { UiStrings } from "../strings/index.js";
+export declare const RU_TIME: UiStrings["time"];
+export declare const RU_MONEY: UiStrings["money"];

package/dist/i18n/locales/ru-formatters.js

@@ -0,0 +1,22 @@
+/**
+ * The Russian of the kit's formatter words (`time`, `money`), on their own so a host that shows only
+ * failures or times (the CLI, the VS Code host, the Action) loads these without the whole table.
+ */
+import { NBSP, ru } from "../ru-plural.js";
+export const RU_TIME = {
+    now: "сейчас",
+    yesterday: "вчера",
+    millisecondsShort: (p) => `${p.value}${NBSP}мс`,
+    secondsShort: (p) => `${p.value}${NBSP}с`,
+    minutesSecondsShort: (p) => `${p.minutes}${NBSP}мин ${p.seconds}${NBSP}с`,
+    hoursMinutesShort: (p) => `${p.hours}${NBSP}ч ${p.minutes}${NBSP}мин`,
+    minutesShort: (p) => `${p.value}${NBSP}мин`,
+    hoursShort: (p) => `${p.value}${NBSP}ч`,
+    daysShort: (p) => `${p.value}${NBSP}д`,
+    minutes: (p) => ru(p.count, "# минута", "# минуты", "# минут"),
+    hours: (p) => ru(p.count, "# час", "# часа", "# часов"),
+    days: (p) => ru(p.count, "# день", "# дня", "# дней"),
+};
+export const RU_MONEY = {
+    spokenDust: (p) => `меньше ${p.amount}`,
+};

package/dist/i18n/locales/ru.d.ts

@@ -0,0 +1,5 @@
+import type { UiStrings } from "../strings/index.js";
+/** For writing a Russian table: `ru(count, one, few, many)` picks the plural form, `NBSP` joins a number to its unit. */
+export { NBSP, ru } from "../ru-plural.js";
+export { RU_MONEY, RU_TIME } from "./ru-formatters.js";
+export declare const RU_UI_STRINGS: UiStrings;

package/dist/i18n/locales/ru.js

@@ -0,0 +1,185 @@
+/**
+ * The kit's Russian: every key of `EN_UI_STRINGS`, typed complete, so a key added in English is a
+ * compile error until it has Russian. Hand it to `UiI18nProvider` (`strings={RU_UI_STRINGS}`) with a
+ * Russian locale ("ru", "ru-RU"). Plurals go through `plural("ru", …)` inside the functions; nothing
+ * locale-dependent runs at module scope.
+ */
+import { ru } from "../ru-plural.js";
+import { RU_MONEY, RU_TIME } from "./ru-formatters.js";
+/** For writing a Russian table: `ru(count, one, few, many)` picks the plural form, `NBSP` joins a number to its unit. */
+export { NBSP, ru } from "../ru-plural.js";
+export { RU_MONEY, RU_TIME } from "./ru-formatters.js";
+export const RU_UI_STRINGS = {
+    money: RU_MONEY,
+    imageViewer: {
+        open: (p) => `Открыть изображение: ${p.alt}`,
+        untitled: "Изображение",
+        position: (p) => `${p.index} из ${p.total}`,
+        previous: "Предыдущее изображение",
+        next: "Следующее изображение",
+        zoomIn: "Увеличить",
+        zoomOut: "Уменьшить",
+        fit: "По размеру окна",
+        actualSize: "Реальный размер",
+        copy: "Скопировать изображение",
+        copied: "Изображение скопировано",
+        copyFailed: "Не удалось скопировать изображение",
+        save: "Сохранить изображение",
+        loading: "Изображение загружается",
+        failed: "Не удалось загрузить изображение",
+        tooLarge: (p) => p.size === undefined
+            ? "Слишком большое, чтобы показать здесь"
+            : `Слишком большое, чтобы показать здесь (${p.size})`,
+        remote: (p) => `Изображение на ${p.host}`,
+        remoteHost: (p) => `— изображение на ${p.host}`,
+        openInBrowser: "Открыть в браузере",
+    },
+    time: RU_TIME,
+    alertDialog: { confirm: "Подтвердить", cancel: "Отмена" },
+    combobox: {
+        clearSelection: "Очистить выбор",
+        showOptions: "Показать варианты",
+        remove: "Удалить",
+        removeItem: (p) => `Удалить ${p.label}`,
+        noMatches: "Совпадений нет",
+    },
+    commandPalette: {
+        placeholder: "Введите команду или запрос…",
+        label: "Палитра команд",
+        loadingResults: "Загружаем результаты",
+        searching: "Ищем…",
+        noResults: "Ничего не найдено",
+        nothingMatches: (p) => `По запросу «${p.query}» ничего не найдено. Попробуйте другое слово.`,
+        hints: { navigate: "Перейти", select: "Выбрать", close: "Закрыть" },
+    },
+    kbd: {
+        // Russian keyboards print the same Latin keycap words; only Space is named.
+        keys: {
+            ctrl: "Ctrl",
+            alt: "Alt",
+            shift: "Shift",
+            enter: "Enter",
+            esc: "Esc",
+            tab: "Tab",
+            space: "Пробел",
+        },
+        spoken: {
+            command: "Command",
+            control: "Control",
+            option: "Option",
+            alt: "Alt",
+            shift: "Shift",
+            return: "Return",
+            enter: "Enter",
+            escape: "Escape",
+            tab: "Tab",
+            space: "Пробел",
+            upArrow: "Стрелка вверх",
+            downArrow: "Стрелка вниз",
+            leftArrow: "Стрелка влево",
+            rightArrow: "Стрелка вправо",
+            delete: "Delete",
+            backspace: "Backspace",
+            forwardDelete: "Удаление вперёд",
+            repeated: (p) => p.count === 2 ? `${p.key} дважды` : `${p.key} ${p.count} ${ru(p.count, "раз", "раза", "раз")}`,
+        },
+    },
+    progress: { indeterminate: "неопределённый прогресс" },
+    blockStack: {
+        reorder: (p) => `Переместить: ${p.title}`,
+        grip: "перемещаемый",
+        reorderHint: "Перетащите или используйте клавиши со стрелками вверх и вниз.",
+        moved: (p) => `${p.title}: теперь ${p.position}-й из ${p.count}.`,
+    },
+    toast: { notifications: "Уведомления", close: "Закрыть уведомление" },
+    codeBlock: {
+        copy: "Копировать",
+        copied: "Скопировано",
+        copiedAnnouncement: "Скопировано в буфер обмена",
+        copyCommand: (p) => `Копировать ${p.command}`,
+        copyLabelledCommand: (p) => `${p.label}: ${p.command}`,
+        copyCode: "Копировать код",
+    },
+    diffView: {
+        changeKinds: { new: "Новый", deleted: "Удалён", renamed: "Переименован" },
+        stats: (p) => `${ru(p.additions, "# строка добавлена", "# строки добавлено", "# строк добавлено")}, ${ru(p.deletions, "# строка удалена", "# строки удалено", "# строк удалено")}`,
+        expandFile: (p) => `Развернуть ${p.path}`,
+        collapseFile: (p) => `Свернуть ${p.path}`,
+        copyFile: "Копировать файл",
+        copyPatch: "Копировать патч",
+        showUnchangedLines: "Показать неизменённые строки",
+        showAllLines: "Показать все строки",
+        collapseUnchangedLines: "Свернуть неизменённые строки",
+        softWrap: "Перенос строк",
+        wrapLines: "Переносить длинные строки",
+        unwrapLines: "Не переносить строки",
+        splitView: "Две колонки",
+        unifiedView: "Одна колонка",
+        switchToSplit: "Показать в две колонки",
+        switchToUnified: "Показать в одну колонку",
+        expandLines: {
+            up: "Показать строки выше",
+            down: "Показать строки ниже",
+            both: "Показать скрытые строки",
+        },
+        noChanges: "Изменений нет.",
+        nothingToCompare: "Нечего сравнивать.",
+        hunk: {
+            label: (p) => `Фрагмент ${p.index} из ${p.total}`,
+            position: (p) => `Фрагмент ${p.index}/${p.total}`,
+            ask: "Спросить",
+            askLabel: (p) => `Спросить о фрагменте ${p.index}`,
+            comment: "Комментарий",
+            commentLabel: (p) => `Прокомментировать фрагмент ${p.index}`,
+            revert: "Откатить",
+            revertLabel: (p) => `Откатить фрагмент ${p.index}`,
+            accept: "Принять",
+            acceptLabel: (p) => `Принять фрагмент ${p.index}`,
+            accepted: "Принято",
+            reverted: "Откачено",
+        },
+        comment: {
+            you: "Вы",
+            line: (p) => `строка ${p.line}`,
+            remove: (p) => `Удалить комментарий к строке ${p.line}`,
+            onOldLine: (p) => `Комментарий к старой строке ${p.line}`,
+            onNewLine: (p) => `Комментарий к новой строке ${p.line}`,
+            placeholder: "Оставьте комментарий…",
+            toAdd: (p) => `${p.keys} — добавить`,
+            cancel: "Отмена",
+            submit: "Комментировать",
+        },
+    },
+    markdown: {
+        taskDone: "Готово",
+        taskTodo: "Не сделано",
+        remoteImage: (p) => `Изображение с ${p.host}`,
+        remoteImageNamed: (p) => `${p.alt} · ${p.host}`,
+        loadImage: "Загрузить изображение",
+        linkCheck: {
+            title: "Открыть ссылку?",
+            description: "Она ведёт по этому адресу:",
+            open: "Открыть",
+            copy: "Скопировать адрес",
+            copied: "Скопировано",
+            cancel: "Отмена",
+        },
+    },
+    primitives: {
+        close: "Закрыть",
+        dismiss: "Скрыть",
+        clearSearch: "Очистить поиск",
+        showMore: "Показать больше",
+        showLess: "Свернуть",
+        avatarStatus: { online: "в сети", busy: "не беспокоить", away: "нет на месте", offline: "не в сети" },
+        moreAvatars: (p) => ru(p.count, "ещё # человек", "ещё # человека", "ещё # человек"),
+        trail: "Навигационная цепочка",
+    },
+    shortcutRecorder: {
+        change: "Изменить",
+        recording: "Нажмите клавиши…",
+        off: "Выключено",
+        needsModifier: (p) => `Используйте сочетание с ${p.modifiers}.`,
+        needsModifierOrFunctionKey: (p) => `Используйте сочетание с ${p.modifiers} либо функциональную клавишу.`,
+    },
+};

package/dist/i18n/plural.d.ts

@@ -0,0 +1,20 @@
+/**
+ * CLDR plural forms. `other` is required; the rest fall back to it. Russian needs `one` (1, 21, 101),
+ * `few` (2–4, 22–24) and `many` (0, 5–20, 25–30); English only `one` and `other`.
+ */
+export interface PluralForms {
+    readonly other: string;
+    readonly zero?: string;
+    readonly one?: string;
+    readonly two?: string;
+    readonly few?: string;
+    readonly many?: string;
+}
+/**
+ * Picks the plural form for `n` with `Intl.PluralRules` and replaces every `#` with `n` (locale
+ * digits, no grouping): `plural("ru", 5, { one: "# файл", few: "# файла", many: "# файлов", other: "# файла" })`
+ * → "5 файлов". Used by the English defaults; a Paraglide table brings its own plural selection.
+ */
+export declare function plural(locale: string, n: number, forms: PluralForms): string;
+/** A count in `locale`'s digits (no grouping), as `plural`'s `#` writes one: for a number a sentence says bare ("Cycle 3"). */
+export declare function digits(locale: string, n: number): string;

package/dist/i18n/plural.js

@@ -0,0 +1,26 @@
+/** A locale's plural rules and digits, built once per locale: the tables call `plural` per count shown. */
+const PLURAL_INTL = new Map();
+function pluralIntl(locale) {
+    let intl = PLURAL_INTL.get(locale);
+    if (intl === undefined) {
+        intl = {
+            rules: new Intl.PluralRules(locale),
+            digits: new Intl.NumberFormat(locale, { useGrouping: false, maximumFractionDigits: 2 }),
+        };
+        PLURAL_INTL.set(locale, intl);
+    }
+    return intl;
+}
+/**
+ * Picks the plural form for `n` with `Intl.PluralRules` and replaces every `#` with `n` (locale
+ * digits, no grouping): `plural("ru", 5, { one: "# файл", few: "# файла", many: "# файлов", other: "# файла" })`
+ * → "5 файлов". Used by the English defaults; a Paraglide table brings its own plural selection.
+ */
+export function plural(locale, n, forms) {
+    const form = forms[pluralIntl(locale).rules.select(n)] ?? forms.other;
+    return form.includes("#") ? form.replaceAll("#", digits(locale, n)) : form;
+}
+/** A count in `locale`'s digits (no grouping), as `plural`'s `#` writes one: for a number a sentence says bare ("Cycle 3"). */
+export function digits(locale, n) {
+    return pluralIntl(locale).digits.format(n);
+}

package/dist/i18n/provider.d.ts

@@ -0,0 +1,36 @@
+import { type ReactNode } from "react";
+import { type UiFormatters } from "./format.js";
+import { type UiStrings } from "./strings/index.js";
+export interface UiI18nProviderProps {
+    /** BCP 47 locale for numbers, money, dates and plurals, used as given: "ru", "ru-RU", "en-GB", "ar". */
+    locale: string;
+    /**
+     * The kit's words in the locale's language: a complete table, such as `RU_UI_STRINGS` from
+     * `@nibapp/ui/locales/ru`, or one of your own typed as `UiStrings`. English when left out.
+     */
+    strings?: UiStrings | undefined;
+    /** IANA zone for dates and clock times (the person's own); omitted: the runtime's own. */
+    timeZone?: string | undefined;
+    /**
+     * The ISO 4217 currency a plain number is shown in as money ("USD", "EUR"). `Money` amounts carry
+     * their own. Without it, showing a number as money fails: the kit never assumes a currency.
+     */
+    currency?: string | undefined;
+    /** The writing direction of the locale's language ("rtl" for Arabic or Hebrew). Left to right when left out. */
+    direction?: "ltr" | "rtl" | undefined;
+    children?: ReactNode;
+}
+/**
+ * Localizes every kit component below it: its words (`strings`), formatters for the exact tag in its
+ * currency, and the writing direction for Base UI (arrow keys, sliders and popup sides follow it in a
+ * right-to-left language). Any language works: pass its table and its direction. Without a provider,
+ * components render English with "en-GB" formatting, left to right. Explicit label props on a component
+ * always win over these strings.
+ */
+export declare function UiI18nProvider({ locale, strings, timeZone, currency, direction, children, }: UiI18nProviderProps): import("react").JSX.Element;
+/** The provider's strings; English without one. */
+export declare function useUiStrings(): UiStrings;
+/** Exactly the BCP 47 tag the provider was given ("ru-RU", "en-US"); the default language without one. */
+export declare function useUiLocale(): string;
+/** Count, money, percent, duration, relative-time and date formatters for the provider's locale. */
+export declare function useFormatters(): UiFormatters;