@eifi1/ui-kit 0.53.0 → 0.55.0

package/src/i18n/languages.ts

@@ -1,349 +0,0 @@
-import { useEffect, useState } from "react";
-import type { UiKitLabels } from "./kit-labels";
-import type { LanguageOption } from "../shell/topbar-controls";
-
-/**
- * "Which language is this reader in, and what does the kit say in it?" — the one
- * answer the three apps each wrote for themselves (docs/i18n-harmonization.md, H2).
- *
- * kastlan, keksdose and Kurvenschmiede all ship a subset of the same seven languages,
- * and every one of them hand-rolled the same three things: a list of languages with
- * their names and flags, a rule for turning what a browser asks for (`de-AT`, `zh-TW`,
- * `en-AU`) into a code the app ships, and a bridge from that code to the kit's label
- * catalogue. The three disagreed where nobody was looking: a reader asking for `zh-TW`
- * got German in kastlan and Chinese in Kurvenschmiede; keksdose's English got the raw
- * defaults, so its counts read "12345" where the other two wrote "12,345"; kastlan
- * formatted French as `fr-CH` and Kurvenschmiede as `fr-FR`. None of it was a decision.
- * This module makes it one, in one place, tested once.
- *
- * WHAT IT IS NOT: an i18n library. It resolves no app strings, carries no detector and
- * depends on nothing — the app keeps i18next (or whatever it uses) for its own words and
- * asks this module only the questions the kit can answer for all three apps alike:
- *   - {@link KIT_LANGUAGES}: the seven codes, each with its own name, its English name,
- *     the flag it flies and the locale it formats in;
- *   - {@link resolveLanguage}: which of the codes an app offers answers a reader;
- *   - {@link formatLocaleOf}: the `Intl` tag for a code (the provider's `locale`,
- *     `<html lang>`, every `toLocaleString` in the app);
- *   - {@link loadUiKitLabels}: the kit's catalogue for a code, fetched on demand;
- *   - {@link languageOptions}: the rows `LanguageMenu` and `LanguageSetting` take.
- *
- * THE CODE AND THE FORMATTING LOCALE ARE TWO THINGS (Kurvenschmiede's insight, made
- * the rule). The code names a catalogue — what the account stores, what i18next
- * resolves, what a mail is chosen by — and a bare `en` says nothing about how a date is
- * written. Each language formats like its home (Marcel, 2026-10-02, H6): `de-CH`,
- * `en-GB` (British, like the spelling), `es-ES`, `fr-FR`, `it-IT`, `hu-HU`, `zh-CN`. An
- * app that must format otherwise — kastlan's QR bill follows the SIX spec, not the
- * reader — passes its own locale where it needs it; the registry is the default.
- *
- * THERE IS ONE GERMAN, `de-CH`: Swiss Standard German, formal (0.18). Every other
- * German a browser or an old localStorage can hand over — `de`, `de-DE`, `de-AT`,
- * `de-LI`, the briefly offered `de-informal` / `de-CH-informal` — is read as it.
- * Its name is plain "Deutsch": it is the only German, so there is nothing to tell it
- * apart from, and the Swiss flag beside it is what says where the spelling comes from.
- *
- * AND ONE CHINESE, `zh`, WHICH IS SIMPLIFIED. `zh-TW`, `zh-HK` and `zh-Hant` resolve to
- * it: there is no Traditional catalogue, and a reader of Traditional characters reads
- * Simplified far more readily than whichever second language a fallback would guess
- * at (Kurvenschmiede's reasoning, now everyone's). Its name says "简体中文" so that
- * reader sees what they are getting before they pick it.
- */
-
-/** The seven languages the kit ships a catalogue for. An app offers a subset. */
-export type KitLanguageCode = "de-CH" | "en" | "es" | "fr" | "it" | "hu" | "zh";
-
-/** One language the kit ships: what it is called, which flag it flies and which
- *  BCP 47 tag it formats in. */
-export interface KitLanguage {
-  /** The catalogue code — what an app stores, sends and hands i18next. */
-  readonly code: KitLanguageCode;
-  /** The language's name in itself, for a switcher: the reader looking for theirs may
-   *  not read the language the page is currently in. */
-  readonly nativeName: string;
-  /** The name in English, for places that list languages to a team rather than to a
-   *  reader (a translation review's locale column, an admin's reviewer grant). */
-  readonly englishName: string;
-  /** The BCP 47 tag the language formats numbers and dates in, and declares itself in
-   *  on `<html lang>`. See {@link formatLocaleOf}. */
-  readonly formatLocale: string;
-  /** ISO 3166-1 alpha-2 country (lowercase) for flag-icons' `fi fi-<flag>` class —
-   *  NOT the language code: English flies the UK flag, German the Swiss one, Chinese
-   *  the PRC's (the catalogue is Simplified). The kit renders the class name only; the
-   *  app supplies the flag stylesheet (README, "What you install alongside it"). */
-  readonly flag: string;
-}
-
-/**
- * Every language the kit ships, in the order a switcher lists them: alphabetical by
- * native name (Deutsch, English, Español … 简体中文), which is what a reader scanning for
- * their own language's name expects.
- *
- * An app offering four of them passes those four codes to {@link resolveLanguage} and
- * {@link languageOptions}; it does not copy this list. A language added here is one the
- * kit has a catalogue for (the loader map below is typed by {@link KitLanguageCode}, so
- * a code without one does not compile).
- */
-export const KIT_LANGUAGES: readonly KitLanguage[] = [
-  { code: "de-CH", nativeName: "Deutsch", englishName: "German", formatLocale: "de-CH", flag: "ch" },
-  { code: "en", nativeName: "English", englishName: "English", formatLocale: "en-GB", flag: "gb" },
-  { code: "es", nativeName: "Español", englishName: "Spanish", formatLocale: "es-ES", flag: "es" },
-  { code: "fr", nativeName: "Français", englishName: "French", formatLocale: "fr-FR", flag: "fr" },
-  { code: "it", nativeName: "Italiano", englishName: "Italian", formatLocale: "it-IT", flag: "it" },
-  { code: "hu", nativeName: "Magyar", englishName: "Hungarian", formatLocale: "hu-HU", flag: "hu" },
-  { code: "zh", nativeName: "简体中文", englishName: "Chinese (Simplified)", formatLocale: "zh-CN", flag: "cn" },
-];
-
-const ALL_CODES: readonly KitLanguageCode[] = KIT_LANGUAGES.map((language) => language.code);
-
-/** The kit's home language: what a reader nothing else matches gets, when it is offered. */
-const HOME: KitLanguageCode = "de-CH";
-
-/** The language part of a tag, lower-cased: `de-CH-informal` → `de`, `zh_Hant` → `zh`. */
-const languagePart = (tag: string) => tag.split("-")[0].toLowerCase();
-
-/**
- * The offered code that answers ONE requested tag, or `undefined`.
- *
- * Exact first, ignoring case (`DE-ch` → `de-CH`), then by language part: since the kit
- * has exactly one code per language, "the offered code whose language is the tag's
- * language" is the whole of the rule, and it is what takes every German to `de-CH`
- * (`de-AT`, `de-informal`), every Chinese to `zh` (`zh-TW`, `zh-Hant-HK`) and every
- * regional form to its base (`fr-CA` → `fr`, `en-AU` → `en`). A language the app does
- * not offer answers nothing, so the caller moves on to the reader's next preference
- * rather than landing on a guess. Underscores are read as hyphens (`de_CH`), the way a
- * Java or Python backend may have stored the account's locale.
- */
-function answer(candidate: unknown, offered: readonly KitLanguageCode[]): KitLanguageCode | undefined {
-  if (typeof candidate !== "string") return undefined;
-  const tag = candidate.trim().replace(/_/g, "-");
-  if (!tag) return undefined;
-  const lower = tag.toLowerCase();
-  const exact = offered.find((code) => code.toLowerCase() === lower);
-  if (exact) return exact;
-  const language = languagePart(tag);
-  return offered.find((code) => languagePart(code) === language);
-}
-
-/**
- * Which of the codes an app offers answers this reader.
- *
- * `candidates` are the reader's preferences **in precedence order**, and the first
- * one that matches wins — so the order is the policy. The one the harmonisation plan
- * gives every app (H5):
- *
- *     resolveLanguage(
- *       [localStorage.getItem("<app>-lang"), user?.locale, ...navigator.languages],
- *       OFFERED,
- *     );
- *
- * the choice stored on this device (the reader picked it, here) → the account's
- * language (read back on sign-in, so a new device starts in it) → the browser's list,
- * in its own order → the fallback. Missing sources are simply `null` / `undefined`;
- * they are skipped, as is an empty string.
- *
- * Each candidate is matched exactly (case-insensitively), then by language — every
- * German variant to `de-CH`, every Chinese to `zh` (Simplified), any other regional
- * form to its base language (`fr-CA` → `fr`, `en-AU` → `en`) — and only within
- * `offered`: a reader whose browser says `es-MX` first and `en` second, in an app that
- * offers no Spanish, gets English rather than the fallback. That is the difference
- * from a single-tag lookup, and why the browser's whole list is passed, not its first
- * entry.
- *
- * `fallback` is what a reader nothing matches gets: by default `de-CH` when the app
- * offers it — the kit's and the three apps' home language — else the app's first
- * offered code. It is returned as given, offered or not; the app chose it.
- *
- * Why not i18next's own matcher (`getBestMatchFromCodes`, which Kurvenschmiede calls):
- * it needs an i18next instance, it reduces `de-AT` to a `de` none of the apps ships
- * unless every caller remembers a converter first, and its answer to a list depends on
- * `supportedLngs` and `nonExplicitSupportedLngs` being set exactly so. This is a pure
- * function of its arguments, so the switcher, the account form, a server-rendered
- * guess and a test all get the same answer without one.
- */
-export function resolveLanguage(
-  candidates: readonly (string | null | undefined)[],
-  offered: readonly KitLanguageCode[],
-  fallback?: KitLanguageCode,
-): KitLanguageCode {
-  for (const candidate of candidates) {
-    const found = answer(candidate, offered);
-    if (found) return found;
-  }
-  return fallback ?? (offered.includes(HOME) ? HOME : (offered[0] ?? HOME));
-}
-
-/**
- * The BCP 47 tag a language formats in — `formatLocaleOf("en")` is `"en-GB"`.
- *
- * For `<UiKitProvider locale>`, for `<html lang>` (a screen reader pronounces by it,
- * and `en` alone does not say which English) and for the app's own `Intl` calls, so
- * the kit's counts and the app's amounts group their digits the same way.
- *
- * Takes any tag, not only a {@link KitLanguageCode}. A tag of one of the seven
- * languages formats in that language's home, by decision — not the reader's region:
- * `de-AT` as `de-CH`, `en-AU` and `en-US` as `en-GB`, `zh-TW` as `zh-CN`. So an app can
- * hand it i18next's `resolvedLanguage` as it comes.
- *
- * A tag of a language the kit does NOT ship formats as itself (canonicalised): `sv-SE`
- * stays `sv-SE`. That is a formatting preference, not a language — keksdose's date
- * setting offers ISO order as `sv-SE`, and 0.19.0 turned it into a German weekday by
- * resolving it to the home language (keksdose's 0.19 adoption). Words are another
- * matter: {@link resolveLanguage} and {@link loadUiKitLabels} still fall back to
- * `de-CH` for such a tag. A tag `Intl` cannot read formats as `de-CH`.
- */
-export function formatLocaleOf(code: string): string {
-  const shipped = answer(code, ALL_CODES);
-  if (shipped) return homeFormat(shipped);
-  try {
-    return Intl.getCanonicalLocales(code)[0] ?? homeFormat(HOME);
-  } catch {
-    return homeFormat(HOME);
-  }
-}
-
-function homeFormat(code: KitLanguageCode): string {
-  return KIT_LANGUAGES.find((language) => language.code === code)!.formatLocale;
-}
-
-/** The format tag of the catalogue a code loads — always one of the seven languages'
- *  own, so the words and the digits of a catalogue agree. */
-const catalogueFormat = (code: string) => homeFormat(resolveLanguage([code], ALL_CODES));
-
-/**
- * One loader per catalogue, each a LITERAL relative `import()`.
- *
- * The literal is load-bearing twice. The library is built one file per module
- * (`bundle: false`, tsup.config.ts), so `./locales/fr` stays a module of its own in
- * dist/ and `scripts/fix-esm-extensions.mjs` gives the specifier its `.js`. And an
- * app's bundler can only split what it can read: a path assembled from a code is a
- * chunk rollup cannot make, and the failure is at runtime. With literals, each
- * language is a chunk of its own and a reader downloads exactly theirs — about 25 kB of
- * JavaScript a catalogue, so an entry chunk holding all of them would carry six that
- * the reader never uses.
- *
- * Relative, not `@eifi1/ui-kit/i18n/fr`: a package importing itself by name resolves
- * through the consumer's node_modules, which a linked checkout or a test of this repo
- * does not have.
- */
-const LOADERS: Record<KitLanguageCode, (formatLocale: string) => Promise<UiKitLabels>> = {
-  "de-CH": async (locale) => (await import("./locales/de-CH")).uiKitLabelsDeCh(locale),
-  en: async (locale) => (await import("./locales/en")).uiKitLabelsEn(locale),
-  es: async (locale) => (await import("./locales/es")).uiKitLabelsEs(locale),
-  fr: async (locale) => (await import("./locales/fr")).uiKitLabelsFr(locale),
-  it: async (locale) => (await import("./locales/it")).uiKitLabelsIt(locale),
-  hu: async (locale) => (await import("./locales/hu")).uiKitLabelsHu(locale),
-  zh: async (locale) => (await import("./locales/zh")).uiKitLabelsZh(locale),
-};
-
-/** One promise per (language, format locale), so asking twice is one fetch and one
- *  object: the provider's context value keeps its identity, and every kit component
- *  reading it is spared a re-render on a switch back. */
-const loaded = new Map<string, Promise<UiKitLabels>>();
-/** The same catalogues once they have arrived — what {@link peekUiKitLabels} reads. */
-const ready = new Map<string, UiKitLabels>();
-
-function cacheKey(code: string, formatLocale: string): [KitLanguageCode, string] {
-  const language = resolveLanguage([code], ALL_CODES);
-  return [language, `${language}\u0000${formatLocale}`];
-}
-
-/**
- * The kit's catalogue for a language, fetched on demand and formatted in
- * `formatLocale` — for `<UiKitProvider labels={…}>`.
- *
- * Every language goes through its catalogue's factory, English included:
- * `uiKitLabelsEn("en-GB")` writes "12,345 rows" where the bare
- * `DEFAULT_UI_KIT_LABELS` print "12345" (and keksdose's English did, by passing no
- * labels at all). `formatLocale` defaults to the language's own
- * ({@link formatLocaleOf}); pass another only for a reason, as the factories' own
- * docs describe (`"de-DE"` keeps the Swiss words and writes German digits).
- *
- * `code` may be any tag and is resolved like {@link formatLocaleOf}'s, so `de` loads
- * the one German and a language the kit does not ship loads `de-CH` — the same answer
- * the app's own fallback gives, rather than English beside the app's German.
- *
- * Asynchronous on purpose, and there is no synchronous twin: one would have to import
- * all seven catalogues statically, which puts every language in every app's entry
- * chunk — exactly what one subpath per language exists to prevent. Await it before the
- * first render, beside the app's own catalogue (the apps already await i18next's init
- * for the same reason: no frame in the wrong language), and keep the result in state.
- * To change a few words, spread over what it returns rather than copying a catalogue:
- * a copy misses every key a later release adds.
- *
- * A rejected fetch (a deploy replaced the chunk, the device went offline) is not
- * remembered, so the next call tries again.
- */
-export function loadUiKitLabels(code: string, formatLocale: string = catalogueFormat(code)): Promise<UiKitLabels> {
-  const [language, key] = cacheKey(code, formatLocale);
-  let labels = loaded.get(key);
-  if (!labels) {
-    labels = LOADERS[language](formatLocale);
-    loaded.set(key, labels);
-    labels.then(
-      (done) => ready.set(key, done),
-      () => loaded.delete(key),
-    );
-  }
-  return labels;
-}
-
-/**
- * The catalogue {@link loadUiKitLabels} already fetched for this language and format
- * locale — synchronously — or `undefined` while it has not arrived. For the provider's
- * render, which cannot await: kastlan wrapped the loader in a cache of its own
- * (`hasKitLabels` / `kitLabelsFor`) to get exactly this, and the other apps would have
- * written the same lines. Same object as the promise resolved to.
- */
-export function peekUiKitLabels(code: string, formatLocale: string = catalogueFormat(code)): UiKitLabels | undefined {
-  return ready.get(cacheKey(code, formatLocale)[1]);
-}
-
-/**
- * The kit's catalogue for `code`, loading it on first use: `<UiKitProvider
- * labels={useUiKitLabels(language)} locale={formatLocaleOf(language)}>`.
- *
- * On a switch it keeps returning the PREVIOUS language's catalogue until the next one
- * has arrived, so the kit's words never blank out mid-switch; `undefined` only before
- * the very first catalogue (render nothing, or the English defaults, until then — or
- * await {@link loadUiKitLabels} before the first render, as the apps do for their own
- * catalogue). A failed fetch keeps the previous catalogue; the next switch tries again.
- */
-export function useUiKitLabels(code: string, formatLocale: string = catalogueFormat(code)): UiKitLabels | undefined {
-  const current = peekUiKitLabels(code, formatLocale);
-  const [previous, setPrevious] = useState<UiKitLabels | undefined>(current);
-  useEffect(() => {
-    if (peekUiKitLabels(code, formatLocale)) return;
-    let live = true;
-    loadUiKitLabels(code, formatLocale).then(
-      (labels) => {
-        if (live) setPrevious(labels);
-      },
-      () => {},
-    );
-    return () => {
-      live = false;
-    };
-  }, [code, formatLocale]);
-  if (current && current !== previous) setPrevious(current);
-  return current ?? previous;
-}
-
-/**
- * The rows `LanguageMenu` and `LanguageSetting` take, for the codes an app offers, in
- * the order given: `{ code, label: nativeName, country: flag }`.
- *
- * `LanguageMenu` draws `country` as a flag-icons class (`fi fi-ch`) and nothing more —
- * the kit ships no flag artwork and no flag CSS, the app loads the stylesheet (or just
- * the rules for its flags, as Kurvenschmiede and keksdose do). `LanguageSetting` is a
- * native `<select>`, whose options can hold text only, so it shows the names and
- * ignores `country`; the same array serves both.
- *
- * A label of the app's own (keksdose's "Deutsch (Schweiz)") is a `.map` over the
- * result.
- */
-export function languageOptions(codes: readonly KitLanguageCode[] = ALL_CODES): LanguageOption[] {
-  return codes.flatMap((code) => {
-    const language = KIT_LANGUAGES.find((entry) => entry.code === code);
-    if (!language) return [];
-    return [{ code: language.code, label: language.nativeName, country: language.flag }];
-  });
-}

package/src/i18n/locales/de-CH.ts

@@ -1,24 +0,0 @@
-import type { UiKitLabels } from "../kit-labels";
-import { germanLabels } from "../german";
-import { swiss } from "../swiss";
-
-/**
- * The kit's words in German — Swiss Standard German, formal ("Sie"), the kit's ONE German
- * catalogue: `<UiKitProvider labels={UI_KIT_LABELS_DE_CH}>`. Swiss spelling — "ss" for
- * every "ß" (Schliessen, Grösse), which is the one systematic difference in UI text — and
- * `de-CH` number formatting (1’234.5).
- *
- * Derived from the internal German source (`../german`) rather than written out, so a
- * key added there is Swiss the moment it lands. Function labels are wrapped: their
- * RESULT is respelled, so an argument the app passes in (a file name, a phrase to type)
- * is respelled too — which is what a Swiss app writing "ss" everywhere wants.
- *
- * {@link uiKitLabelsDeCh} takes another number locale (e.g. `"de-DE"` for 1.234,5, or
- * `"de-AT"`) without touching the words — the spelling stays Swiss, as the factories of
- * the other catalogues keep their words.
- */
-export function uiKitLabelsDeCh(numberLocale = "de-CH"): UiKitLabels {
-  return swiss(germanLabels(numberLocale));
-}
-
-export const UI_KIT_LABELS_DE_CH: UiKitLabels = uiKitLabelsDeCh();

package/src/i18n/locales/en.ts

@@ -1,267 +0,0 @@
-import { DEFAULT_UI_KIT_LABELS } from "../defaults";
-import { formatFileSize } from "../kit-labels";
-import type { UiKitLabels } from "../kit-labels";
-
-/**
- * The kit's English words with every count and file size formatted for
- * `numberLocale` — `uiKitLabelsEn("en-CH")` reads "12’345 rows", where the defaults
- * print "12345". For `<UiKitProvider labels={uiKitLabelsEn("en-CH")}>`.
- *
- * A factory and not a constant on purpose: {@link DEFAULT_UI_KIT_LABELS} prints counts
- * raw and has since 0.1, so an app that passes nothing must keep seeing exactly that.
- * Formatting is something an app asks for, by calling this.
- *
- * Derived rather than copied: every word is the default's own, spread in, and only the
- * labels that print a number are restated — with the same wording and the same
- * singular/plural split — so a key added to the defaults is here the moment it lands.
- * A new label that prints a count must be restated by hand; the catalogue parity test
- * in `__tests__/locales.test.ts` fails until it is (round 0.34 DOC-6: eleven were not).
- * Row and line numbers (`lineItems.row`, `measuredGrid.cell`) are positions, not
- * counts, and stay as the defaults print them, as in the other catalogues.
- */
-export function uiKitLabelsEn(numberLocale = "en-US"): UiKitLabels {
-  const num = new Intl.NumberFormat(numberLocale);
-  const n = (value: number) => num.format(value);
-  const d = DEFAULT_UI_KIT_LABELS;
-  // As `inDays` in src/billing/billing-labels.ts: 0 (or less) is today, 1 tomorrow.
-  const inDays = (days: number) => (days <= 0 ? "today" : days === 1 ? "tomorrow" : `in ${n(days)} days`);
-
-  return {
-    ...d,
-    feedbackAttachment: {
-      ...d.feedbackAttachment,
-      attachmentLimit: (max) =>
-        max === 1
-          ? "Up to 1 attachment — remove it to add another."
-          : `Up to ${n(max)} attachments — remove one to add another.`,
-    },
-    feedbackToast: {
-      ...d.feedbackToast,
-      attachmentTooMany: (count) =>
-        count === 1
-          ? "Only 1 attachment fits — the rest were left out."
-          : `Only ${n(count)} attachments fit — the rest were left out.`,
-    },
-    feedbackPage: {
-      ...d.feedbackPage,
-      // `userFallback`'s number is an id, not a count: it stays as the default prints it.
-      reworkChip: (count) => (count === 1 ? "Rework" : `Rework ×${n(count)}`),
-    },
-    // 0.38.0: the public list's two counts.
-    feedbackPublic: {
-      ...d.feedbackPublic,
-      total: (count) => (count === 1 ? "1 report" : `${n(count)} reports`),
-      comments: (count) => (count === 1 ? "1 comment" : `${n(count)} comments`),
-      votes: (count) => (count === 1 ? "1 vote" : `${n(count)} votes`),
-      page: (page) => `Page ${n(page)}`,
-    },
-    measuredGrid: {
-      ...d.measuredGrid,
-      points: (count) => (count === 1 ? "1 point" : `${n(count)} points`),
-      problems: (count) => (count === 1 ? "1 cell is not a number" : `${n(count)} cells are not numbers`),
-    },
-    dataTable: {
-      ...d.dataTable,
-      filterResults: (shown, total) => `${n(shown)} of ${n(total)} rows`,
-      pageChanged: (page, totalPages) => `Page ${n(page)} of ${n(totalPages)}`,
-      pageRange: (from, to, total) => `${n(from)}–${n(to)} / ${n(total)}`,
-      rowCount: (total) => n(total),
-      columnsCount: (visible, total) => `Columns (${n(visible)}/${n(total)})`,
-    },
-    calendarHeatmap: {
-      ...d.calendarHeatmap,
-      truncated: (count) =>
-        `Showing the most recent days; ${n(count)} earlier ${count === 1 ? "day is" : "days are"} not shown.`,
-    },
-    combobox: {
-      ...d.combobox,
-      selectedCount: (count) => `${n(count)} selected`,
-      resultCount: (count) => (count === 1 ? "1 result" : `${n(count)} results`),
-      minChars: (count) => (count === 1 ? "Type at least 1 character" : `Type at least ${n(count)} characters`),
-    },
-    multiSelect: {
-      ...d.multiSelect,
-      selectedCount: (count) => n(count),
-    },
-    chipInput: {
-      ...d.chipInput,
-      atLimit: (max) => `Limit of ${n(max)} reached`,
-    },
-    list: {
-      ...d.list,
-      showAll: (count) => `Show all (${n(count)})`,
-    },
-    iconPicker: {
-      ...d.iconPicker,
-      resultCount: (count) => (count === 1 ? "1 icon" : `${n(count)} icons`),
-    },
-    bulkActionBar: {
-      ...d.bulkActionBar,
-      selected: (count) => `${n(count)} selected`,
-    },
-    file: {
-      // The kit's own `Intl` unit formatting, pinned to this locale ("3.4 MB").
-      size: (bytes) => formatFileSize(bytes, numberLocale),
-    },
-    filePicker: {
-      ...d.filePicker,
-      rejectedCount: (name, maxFiles) =>
-        `“${name}” was not added: at most ${n(maxFiles)} ${maxFiles === 1 ? "file" : "files"}`,
-      rejectedMany: (count) => `${n(count)} files were not added`,
-      rejectedPick: (count) => (count === 1 ? "The file was not added" : `None of the ${n(count)} files were added`),
-      selected: (count, firstName) => (count === 1 ? `“${firstName}” selected` : `${n(count)} files selected`),
-    },
-    wizard: {
-      ...d.wizard,
-      step: (current, total) => `Step ${n(current)} of ${n(total)}`,
-    },
-    tour: {
-      ...d.tour,
-      step: (current, total) => `${n(current)} / ${n(total)}`,
-    },
-    passwordStrength: {
-      ...d.passwordStrength,
-      ruleLength: (minLength) => `At least ${n(minLength)} characters`,
-      tooLong: (maxBytes) => `At most ${n(maxBytes)} characters (accents and emoji count for more than one).`,
-    },
-    floatingPanel: {
-      ...d.floatingPanel,
-      badge: (count) => `${n(count)} new`,
-    },
-    imageGrid: {
-      ...d.imageGrid,
-      item: (index, count) => `Image ${n(index)} of ${n(count)}`,
-    },
-    lightbox: {
-      ...d.lightbox,
-      counter: (index, count) => `${n(index)} / ${n(count)}`,
-      position: (index, count) => `Image ${n(index)} of ${n(count)}`,
-    },
-    translationReview: {
-      ...d.translationReview,
-      filterCount: (label, count) => `${label} · ${n(count)}`,
-      placeholdersOnly: (count) => `Only placeholder problems (${n(count)})`,
-      progress: (approved, total) => `${n(approved)} of ${n(total)} approved`,
-      localeProgress: (approved, total) => `${n(approved)}/${n(total)}`,
-      exportCorrections: (count) => `Export corrections (${n(count)})`,
-      approvedToast: (count) => (count === 1 ? "String approved" : `${n(count)} strings approved`),
-      clearedToast: (count) => (count === 1 ? "String marked unreviewed" : `${n(count)} strings marked unreviewed`),
-      groupCount: (unreviewed, total) => `${n(unreviewed)} unreviewed / ${n(total)}`,
-      approveGroup: (count) => `Approve unreviewed (${n(count)})`,
-      confirmGroup: (count, group) =>
-        count === 1
-          ? `Approve the unreviewed string in ${group}?`
-          : `Approve all ${n(count)} unreviewed strings in ${group}, including those not on screen?`,
-    },
-    characterCount: {
-      ...d.characterCount,
-      count: (used, max) => `${n(used)} of ${n(max)} characters`,
-      remaining: (left) => (left === 1 ? "1 character left" : `${n(left)} characters left`),
-    },
-    ibanInput: {
-      ...d.ibanInput,
-      length: (actual, expected) =>
-        `An IBAN from this country has ${n(expected)} characters — this one has ${n(actual)}.`,
-    },
-    columnMapper: {
-      ...d.columnMapper,
-      summary: (columns, rows) =>
-        `${n(columns)} ${columns === 1 ? "column" : "columns"}, ${n(rows)} ${rows === 1 ? "row" : "rows"}`,
-      unreadCount: (count) => (count === 1 ? "1 line could not be read" : `${n(count)} lines could not be read`),
-      unreadMore: (count) => `…and ${n(count)} more`,
-      previewOf: (shown, total) =>
-        shown === 1 ? `The first of ${n(total)} rows` : `The first ${n(shown)} of ${n(total)} rows`,
-    },
-    signIn: {
-      ...d.signIn,
-      recoveryCodeHint: (length) => `${n(length)} letters and digits. Dashes and spaces don’t matter.`,
-    },
-    verifyEmail: {
-      ...d.verifyEmail,
-      resendIn: (seconds) => `Send again in ${n(seconds)} s`,
-    },
-    deleteAccount: {
-      ...d.deleteAccount,
-      afterDays: (days) =>
-        days === 1
-          ? "Your account is deactivated at once and erased for good 1 day later."
-          : `Your account is deactivated at once and erased for good ${n(days)} days later.`,
-      handOver: (count) =>
-        count === 1
-          ? "1 item others can see will pass to an administrator."
-          : `${n(count)} items others can see will pass to an administrator.`,
-    },
-    notifications: {
-      ...d.notifications,
-      testSent: (count) => (count === 1 ? "Test sent to 1 device" : `Test sent to ${n(count)} devices`),
-      failures: (count) => (count === 1 ? "1 failed delivery in a row" : `${n(count)} failed deliveries in a row`),
-      bellUnread: (count) => `${n(count)} unread`,
-    },
-    settings: {
-      ...d.settings,
-      matchCount: (count) => (count === 1 ? "1 match" : `${n(count)} matches`),
-    },
-    // 0.42.0: the admin area's two counts (docs/admin-harmonization.md §3.1).
-    adminArea: {
-      ...d.adminArea,
-      waiting: (count) => `${n(count)} waiting`,
-      waitingLabel: (label, count) => `${label}, ${n(count)} waiting`,
-      tiles: { ...d.adminArea.tiles, usersNew: (count) => `${n(count)} new in 7 days` },
-    },
-    // 0.43.0: the tours page's counts (docs/tours-harmonization.md §3).
-    tourCatalogue: {
-      ...d.tourCatalogue,
-      groupAll: (count) => `All topics (${n(count)})`,
-      groupOption: (group, count) => `${group} (${n(count)})`,
-      stateAll: (count) => `All (${n(count)})`,
-      stateTodo: (count) => `Not taken (${n(count)})`,
-      stateDone: (count) => `Completed (${n(count)})`,
-      showing: (shown, total) => `Showing ${n(shown)} of ${n(total)} tours`,
-      points: (count) => `+${n(count)} pts`,
-      steps: (count) => (count === 1 ? "1 step" : `${n(count)} steps`),
-      duration: (minutes) => `About ${n(minutes)} min`,
-    },
-    // 0.42.0: the top bar's three counts (docs/top-bar-harmonization.md §3.1).
-    topBarParts: {
-      ...d.topBarParts,
-      sync: {
-        ...d.topBarParts.sync,
-        blocked: (count) =>
-          count === 1
-            ? "1 change cannot be sent from this device"
-            : `${n(count)} changes cannot be sent from this device`,
-        pending: (count) => (count === 1 ? "1 change waiting to sync" : `${n(count)} changes waiting to sync`),
-        waitingShort: (count) => `${n(count)} waiting`,
-      },
-    },
-    demo: {
-      ...d.demo,
-      rateLimited: (minutes) =>
-        minutes
-          ? `Too many demos from this network. Try again in ${n(minutes)} min.`
-          : "Too many demos from this network. Try again later.",
-      hoursLeft: (hours, minutes) => `Demo · ${n(hours)} h ${n(minutes)} min left`,
-      minutesLeft: (minutes) => `Demo · ${n(minutes)} min left`,
-    },
-    billing: {
-      ...d.billing,
-      trialEnding: (days) =>
-        `Your trial ends ${inDays(days)}. After that you can still view everything, but changes need a plan.`,
-      grantEnding: (days) =>
-        `Your free access ends ${inDays(days)}. After that you can still view everything, but changes need a plan.`,
-      waitingChanges: (count) =>
-        count === 1 ? "1 change waiting for a plan" : `${n(count)} changes waiting for a plan`,
-    },
-    signOutPending: {
-      ...d.signOutPending,
-      lost: (count) =>
-        count === 1
-          ? d.signOutPending.lost(1)
-          : `${n(count)} changes are still waiting to sync. Logging out clears this device’s copy, and it is the only copy.`,
-      kept: (count) =>
-        count === 1
-          ? d.signOutPending.kept(1)
-          : `${n(count)} changes are still waiting to sync. They stay on this device for you and sync the next time you log in here.`,
-    },
-  };
-}