stream-chat 10.0.0-rc.4 → 10.0.0-rc.6

package/codegen/i18n/callSites.ts

@@ -0,0 +1,126 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type * as ts from 'typescript';
+
+import type { CallSiteCopy, TypeScriptModule } from './types';
+
+const DEFAULT_IGNORE_DIRS = ['__tests__', 'mock-builders'];
+
+/**
+ * Every `t()` call in the source is the catalog's source of truth.
+ *
+ * A prose key exists because a component asks for it and passes its English copy inline; delete the
+ * call and the key is gone. That is what removes the need for a checked-in `en.json` and for an
+ * extract / remove-unused-keys pass, and it makes a dead prose key structurally impossible.
+ *
+ * The only keys that cannot be described this way are the ones with no inline copy — a formatter
+ * expression, or a key built from a runtime value. Those come from `runtimeDefaults`, and the generator
+ * cross-checks the two.
+ */
+const isTCallee = (tsModule: TypeScriptModule, expr: ts.Expression): boolean =>
+  (tsModule.isIdentifier(expr) && expr.text === 't') ||
+  (tsModule.isPropertyAccessExpression(expr) && expr.name.text === 't');
+
+export const sourceFiles = ({
+  ignoreDirs = DEFAULT_IGNORE_DIRS,
+  srcRoot = 'src',
+}: {
+  ignoreDirs?: string[];
+  srcRoot?: string;
+} = {}): string[] => {
+  const out: string[] = [];
+  const walk = (dir: string) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (ignoreDirs.includes(entry.name)) continue;
+        walk(full);
+      } else if (/\.tsx?$/.test(entry.name) && !entry.name.endsWith('.d.ts')) {
+        out.push(full);
+      }
+    }
+  };
+  walk(srcRoot);
+  return out;
+};
+
+export const readCallSiteCopy = ({
+  ignoreDirs,
+  srcRoot,
+  ts: tsModule,
+}: {
+  ts: TypeScriptModule;
+  ignoreDirs?: string[];
+  srcRoot?: string;
+}): CallSiteCopy => {
+  const copy = new Map<string, string>();
+  const withoutCopy = new Map<string, string>();
+  const pluralWithoutCopy = new Map<string, string>();
+  const conflicts: CallSiteCopy['conflicts'] = [];
+
+  const record = (key: string, value: string, file: string) => {
+    const existing = copy.get(key);
+    if (existing !== undefined && existing !== value) {
+      conflicts.push({ a: existing, b: value, file, key });
+      return;
+    }
+    copy.set(key, value);
+  };
+
+  for (const file of sourceFiles({ ignoreDirs, srcRoot })) {
+    const sourceFile = tsModule.createSourceFile(
+      file,
+      fs.readFileSync(file, 'utf8'),
+      tsModule.ScriptTarget.Latest,
+      true,
+      file.endsWith('.tsx') ? tsModule.ScriptKind.TSX : tsModule.ScriptKind.TS,
+    );
+
+    const visit = (node: ts.Node) => {
+      if (tsModule.isCallExpression(node) && isTCallee(tsModule, node.expression)) {
+        const [keyArg, second] = node.arguments;
+        if (keyArg && tsModule.isStringLiteralLike(keyArg)) {
+          const key = keyArg.text;
+          if (second && tsModule.isStringLiteralLike(second)) {
+            // t('key', 'Copy')
+            record(key, second.text, file);
+          } else if (second && tsModule.isObjectLiteralExpression(second)) {
+            // t('key', { count, defaultValue_one, defaultValue_other }) — the catalog holds the
+            // `_one` / `_other` forms, never the bare key.
+            let plurals = 0;
+            let hasCount = false;
+            for (const prop of second.properties) {
+              // `count` can arrive shorthand (`{ count }`), which is not a PropertyAssignment.
+              if (
+                tsModule.isShorthandPropertyAssignment(prop) &&
+                prop.name.text === 'count'
+              ) {
+                hasCount = true;
+                continue;
+              }
+              if (!tsModule.isPropertyAssignment(prop)) continue;
+              const name = prop.name.getText(sourceFile).replace(/['"]/g, '');
+              if (name === 'count') hasCount = true;
+              const suffix = name.match(/^defaultValue_(\w+)$/)?.[1];
+              if (suffix && tsModule.isStringLiteralLike(prop.initializer)) {
+                record(`${key}_${suffix}`, prop.initializer.text, file);
+                plurals++;
+              }
+            }
+            // A `count` with no inline plural copy is a *bundled plural*: i18next will look up
+            // `<key>_<category>`, so the guard has to demand that shape rather than the bare key.
+            if (!plurals) (hasCount ? pluralWithoutCopy : withoutCopy).set(key, file);
+          } else {
+            // t('key') — no inline copy, so it has to resolve from runtimeDefaults.
+            withoutCopy.set(key, file);
+          }
+        }
+      }
+      tsModule.forEachChild(node, visit);
+    };
+
+    visit(sourceFile);
+  }
+
+  return { conflicts, copy, pluralWithoutCopy, withoutCopy };
+};

package/codegen/i18n/generate.ts

@@ -0,0 +1,226 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { readCallSiteCopy } from './callSites';
+import {
+  formatFailures,
+  guardBundledPluralShape,
+  guardConflictingCopy,
+  guardPrefixCollisions,
+  guardShadowedKeys,
+  guardUnresolvableKeys,
+} from './guards';
+import { readStringMap } from './stringMaps';
+import type { GeneratedCatalog, GeneratorConfig } from './types';
+
+/** Values under these prefixes are dayjs/i18next expressions, not copy. */
+const BUILTIN_FORMATTER_PREFIXES = ['timestamp.', 'duration.'];
+
+/**
+ * A catalog entry that is one plural category of a key, e.g. `x.y_other`.
+ *
+ * These are excluded from the emitted `BundledTranslationKey` union: a call site passes the *bare* key
+ * and `StreamTFunctionFor`'s plural overload already accepts it, so listing the suffixed forms as
+ * bundled keys would offer `t('x.y_other')` — a call that resolves nothing.
+ */
+const PLURAL_CATEGORY_SUFFIX = /_(zero|one|two|few|many|other)$/;
+
+/**
+ * Two ways English hides inside a formatter expression, both of which have to be reported: a translator
+ * working from the JSON export never sees these keys otherwise.
+ */
+const hasEnglishWords = (value: string) =>
+  // Day words baked into a `calendarFormats` argument, e.g. `[Yesterday]` — dayjs escapes literal text
+  // in brackets.
+  [...value.matchAll(/\[([^\]]+)\]/g)].some(([, literal]) =>
+    /[A-Za-z]{2}/.test(literal),
+  ) ||
+  // Prose sitting beside the interpolation, e.g. `Last seen {{ timestamp | … }}`. Each expression is
+  // matched individually — a greedy `{{[\s\S]*}}` would span from the first `{{` to the last `}}` and
+  // swallow the prose between two of them. Stopping at `}}` rather than any `}` is what keeps the
+  // nested braces of a `calendarFormats` argument inside the match.
+  /[A-Za-z]{2}/.test(value.replace(/\{\{(?:[^}]|\}(?!\}))*\}\}/g, ''));
+
+/**
+ * Builds the catalog and runs every guard, without writing anything.
+ *
+ * Separate from {@link generateI18nKeys} so a test — or a caller wanting to inspect before committing —
+ * can get the failures as data rather than as process output.
+ */
+export const buildCatalog = (config: GeneratorConfig): GeneratedCatalog => {
+  const { runtimeDefaultsPath, ts } = config;
+
+  const runtimeDefaults = readStringMap({
+    exportName: 'runtimeDefaults',
+    file: runtimeDefaultsPath,
+    ts,
+  });
+  const {
+    conflicts,
+    copy: inlineCopy,
+    pluralWithoutCopy,
+    withoutCopy,
+  } = readCallSiteCopy({
+    ignoreDirs: config.ignoreDirs,
+    srcRoot: config.srcRoot,
+    ts,
+  });
+
+  const catalogEntries = new Map([...inlineCopy, ...runtimeDefaults]);
+  const keys = [...catalogEntries.keys()].sort();
+  const catalog = new Map(keys.map((key) => [key, catalogEntries.get(key) as string]));
+
+  const failures = [
+    guardConflictingCopy(conflicts),
+    guardUnresolvableKeys({
+      pluralWithoutCopy,
+      runtimeDefaults,
+      runtimeDefaultsPath,
+      withoutCopy,
+    }),
+    guardBundledPluralShape({ pluralWithoutCopy, runtimeDefaults, runtimeDefaultsPath }),
+    guardShadowedKeys({ inlineCopy, runtimeDefaults, runtimeDefaultsPath }),
+    guardPrefixCollisions(keys),
+  ].filter((failure): failure is NonNullable<typeof failure> => failure !== null);
+
+  return { bundledKeys: [...runtimeDefaults.keys()].sort(), catalog, failures };
+};
+
+const renderKeysFile = ({
+  bundledKeys,
+  catalog,
+  emitBundledKeyUnion,
+}: {
+  bundledKeys: string[];
+  catalog: Map<string, string>;
+  emitBundledKeyUnion?: boolean;
+}): string => {
+  const lines: string[] = [
+    '// AUTO-GENERATED — do not edit by hand.',
+    '// Regenerate with `yarn build-translations`. CI fails if this file is out of sync.',
+    '//',
+    '// Type-only: no runtime value is emitted, so this adds nothing to the bundle.',
+    '',
+    '/**',
+    ' * Every translation entry shipped with the SDK, mapped to its English copy.',
+    ' *',
+    ' * Plural entries appear as `<key>_one` / `<key>_other`; call sites use the bare `<key>` and',
+    ' * pass `count`.',
+    ' */',
+    'export type TranslationCatalog = {',
+  ];
+
+  for (const [key, value] of catalog) {
+    lines.push(`  ${JSON.stringify(key)}: ${JSON.stringify(value)};`);
+  }
+  lines.push('};', '');
+
+  if (emitBundledKeyUnion) {
+    lines.push(
+      '/**',
+      ' * Keys whose copy is bundled rather than passed inline at the call site.',
+      ' *',
+      ' * They reach `t()` as runtime values — a JSX prop, a ternary branch, a lookup table — so there',
+      ' * is nowhere to write a `defaultValue`. Call sites pass the key alone.',
+      ' */',
+      'export type BundledTranslationKey =',
+    );
+    for (const key of bundledKeys) lines.push(`  | ${JSON.stringify(key)}`);
+    lines.push(';', '');
+  }
+
+  return lines.join('\n');
+};
+
+/**
+ * Regenerates an SDK's translation catalog from its `t()` call sites and bundled defaults.
+ *
+ * Throws on a guard failure with every failure formatted, so the caller's script exits non-zero and CI
+ * fails. The catalog is written only when all guards pass.
+ */
+export const generateI18nKeys = (config: GeneratorConfig): GeneratedCatalog => {
+  const log = config.log ?? ((message: string) => console.log(message));
+  const result = buildCatalog(config);
+
+  if (result.failures.length) {
+    throw new Error(formatFailures(result.failures));
+  }
+
+  const { bundledKeys, catalog } = result;
+  const keys = [...catalog.keys()];
+
+  fs.mkdirSync(path.dirname(config.keysOut), { recursive: true });
+  fs.writeFileSync(
+    config.keysOut,
+    renderKeysFile({
+      bundledKeys: bundledKeys.filter((key) => !PLURAL_CATEGORY_SUFFIX.test(key)),
+      catalog,
+      emitBundledKeyUnion: config.emitBundledKeyUnion,
+    }),
+  );
+
+  if (config.fixtureOut) {
+    fs.mkdirSync(path.dirname(config.fixtureOut), { recursive: true });
+    fs.writeFileSync(
+      config.fixtureOut,
+      `${JSON.stringify(Object.fromEntries(catalog), null, 2)}\n`,
+    );
+  }
+
+  log(
+    `generated ${config.keysOut} (${keys.length} entries, type-only) — ` +
+      `${keys.length - bundledKeys.length} from inline defaults, ${bundledKeys.length} bundled`,
+  );
+
+  if (config.json) {
+    const formatterPrefixes = [
+      ...BUILTIN_FORMATTER_PREFIXES,
+      ...(config.extraFormatterPrefixes ?? []),
+    ];
+    const isFormatterKey = (key: string) =>
+      formatterPrefixes.some((prefix) => key.startsWith(prefix));
+
+    const exported = config.json.includeFormats
+      ? keys
+      : keys.filter((k) => !isFormatterKey(k));
+    fs.writeFileSync(
+      config.json.out,
+      `${JSON.stringify(
+        Object.fromEntries(exported.map((key) => [key, catalog.get(key)])),
+        null,
+        2,
+      )}\n`,
+    );
+
+    log(
+      `wrote ${config.json.out} (${exported.length} ${
+        config.json.includeFormats
+          ? 'entries, formatter expressions included'
+          : 'translatable entries'
+      })`,
+    );
+
+    const excluded = keys.filter((key) => !exported.includes(key));
+    if (excluded.length) {
+      // Excluding formatter expressions does drop some translatable text: a few embed English day
+      // words. It is not translatable *as copy* — the format string has to be rewritten — so it is
+      // named here and handled by overriding the key. Detected rather than hardcoded, so the list
+      // cannot go stale.
+      const withEnglish = excluded.filter((key) =>
+        hasEnglishWords(catalog.get(key) as string),
+      );
+      log(
+        `  excluded ${excluded.length} formatter expressions (${formatterPrefixes.join(', ')}) — ` +
+          `not copy, and a TMS that translates them breaks date rendering. Pass --all to include ` +
+          `them.` +
+          (withEnglish.length
+            ? `\n  ${withEnglish.length} of them do carry English copy and must be translated by ` +
+              `overriding the key:\n${withEnglish.map((key) => `    ${key}`).join('\n')}` +
+              (config.migrationGuideRef ? `\n  see ${config.migrationGuideRef}.` : '')
+            : ''),
+      );
+    }
+  }
+
+  return result;
+};

package/codegen/i18n/guards.ts

@@ -0,0 +1,178 @@
+import type { CallSiteCopy, GuardFailure } from './types';
+
+/**
+ * The five hard-fail checks the catalog has to pass.
+ *
+ * Each is a pure function returning failures as data. The guard both UI SDKs carried that is *not* here
+ * — checking that an `EXTERNAL_STRING_KEYS` entry's wording matched the key's catalog copy — is gone
+ * because the map it policed is gone: notifications now resolve through a stable identifier instead of
+ * by matching English prose.
+ */
+
+/** A key must render one thing. */
+export const guardConflictingCopy = (
+  conflicts: CallSiteCopy['conflicts'],
+): GuardFailure | null => {
+  if (!conflicts.length) return null;
+  return {
+    entries: conflicts.map(
+      ({ a, b, file, key }) =>
+        `${key}\n    ${JSON.stringify(a)}\n    ${JSON.stringify(b)}  (${file})`,
+    ),
+    kind: 'conflicting-copy',
+    summary:
+      `${conflicts.length} key(s) used with conflicting inline copy — a key must render ` +
+      `one thing:`,
+  };
+};
+
+/**
+ * A key called without inline copy resolves from the bundled data or not at all.
+ *
+ * Without this, i18next renders the raw dotted key in the UI — the failure mode is a user seeing
+ * `message.status.sent.text` where a word should be.
+ */
+export const guardUnresolvableKeys = ({
+  pluralWithoutCopy,
+  runtimeDefaults,
+  runtimeDefaultsPath,
+  withoutCopy,
+}: {
+  pluralWithoutCopy: CallSiteCopy['pluralWithoutCopy'];
+  runtimeDefaults: Map<string, string>;
+  runtimeDefaultsPath: string;
+  withoutCopy: CallSiteCopy['withoutCopy'];
+}): GuardFailure | null => {
+  const unresolvable = [
+    ...[...withoutCopy].filter(([key]) => !runtimeDefaults.has(key)),
+    // A plural resolves as `<key>_<category>`, so `_other` — the one category every language has — is
+    // what has to be bundled. Demanding the bare key here is what used to reject a correct catalog.
+    //
+    // A key bundled under the *bare* name is skipped here on purpose: it is not unresolvable, it is
+    // the wrong shape, and `guardBundledPluralShape` says so precisely. Reporting both would give two
+    // failures with different advice for one mistake.
+    ...[...pluralWithoutCopy]
+      .filter(
+        ([key]) => !runtimeDefaults.has(`${key}_other`) && !runtimeDefaults.has(key),
+      )
+      .map(([key, file]): [string, string] => [`${key}_other`, file]),
+  ];
+  if (!unresolvable.length) return null;
+  return {
+    entries: unresolvable.map(([key, file]) => `${key}  (${file})`),
+    kind: 'unresolvable-key',
+    summary:
+      `${unresolvable.length} key(s) are called with no inline default and are missing from ` +
+      `${runtimeDefaultsPath}.\nThey would render as the raw key. Either pass the English copy ` +
+      `inline — t('key', 'Copy') — or add an entry to ${runtimeDefaultsPath}:`,
+  };
+};
+
+/**
+ * A bundled plural must be stored under its category suffixes, not under the bare key.
+ *
+ * i18next falls back to an unsuffixed entry when no `<key>_<category>` exists, so the bare form does
+ * render — it just renders the same string for every count, with plural selection silently dead and no
+ * error anywhere. Verified against i18next directly: a bundled `'x.y': '{{count}} items'` answers
+ * `count: 1` with "1 items".
+ */
+export const guardBundledPluralShape = ({
+  pluralWithoutCopy,
+  runtimeDefaults,
+  runtimeDefaultsPath,
+}: {
+  pluralWithoutCopy: CallSiteCopy['pluralWithoutCopy'];
+  runtimeDefaults: Map<string, string>;
+  runtimeDefaultsPath: string;
+}): GuardFailure | null => {
+  const bare = [...pluralWithoutCopy].filter(([key]) => runtimeDefaults.has(key));
+  if (!bare.length) return null;
+  return {
+    entries: bare.map(
+      ([key, file]) =>
+        `${key}\n    bundled as: ${JSON.stringify(runtimeDefaults.get(key))}\n` +
+        `    called as:  t('${key}', { count })  (${file})`,
+    ),
+    kind: 'bundled-plural-shape',
+    summary:
+      `${bare.length} key(s) are called with \`count\` but bundled under the bare key in ` +
+      `${runtimeDefaultsPath}.\ni18next resolves plurals as \`<key>_<category>\`, so this renders ` +
+      `one form for every count with no error. Split the entry into \`_one\` / \`_other\`:`,
+  };
+};
+
+/**
+ * A key must not be in both places.
+ *
+ * The bundled value wins over a `defaultValue`, so a key in both silently renders the bundled string
+ * and ignores the call site — meaning an edit to the copy at the call site changes nothing, with no
+ * error. This is the bug class that used to hide behind a checked-in `en.json`.
+ */
+export const guardShadowedKeys = ({
+  inlineCopy,
+  runtimeDefaults,
+  runtimeDefaultsPath,
+}: {
+  inlineCopy: Map<string, string>;
+  runtimeDefaults: Map<string, string>;
+  runtimeDefaultsPath: string;
+}): GuardFailure | null => {
+  const shadowed = [...runtimeDefaults.keys()].filter((key) => inlineCopy.has(key));
+  if (!shadowed.length) return null;
+  return {
+    entries: shadowed.map(
+      (key) =>
+        `${key}\n    bundled:   ${JSON.stringify(runtimeDefaults.get(key))}\n` +
+        `    call site: ${JSON.stringify(inlineCopy.get(key))}`,
+    ),
+    kind: 'shadowed-key',
+    summary:
+      `${shadowed.length} key(s) are in both ${runtimeDefaultsPath} and an inline default.\n` +
+      `The bundled value wins, so editing the call site would silently change nothing. Remove ` +
+      `the ${runtimeDefaultsPath} entry:`,
+  };
+};
+
+/**
+ * A key cannot be both a leaf and a namespace.
+ *
+ * With i18next's default `keySeparator: '.'` the shorter key would resolve to an object, and a nested
+ * resource tree cannot represent both at once. The SDKs set `keySeparator: false` so this is latent
+ * rather than active — but it is a landmine for anyone who ever flips that, and cheap to prevent.
+ *
+ * Compared on segment boundaries, so `poll.title` / `poll.titleText` is fine while `poll.title` /
+ * `poll.title.text` is not.
+ */
+export const guardPrefixCollisions = (keys: string[]): GuardFailure | null => {
+  const keySet = new Set(keys);
+  const collisions: Array<{ leaf: string; nested: string }> = [];
+
+  for (const key of keys) {
+    const segments = key.split('.');
+    for (let i = 1; i < segments.length; i++) {
+      const ancestor = segments.slice(0, i).join('.');
+      if (keySet.has(ancestor)) collisions.push({ leaf: ancestor, nested: key });
+    }
+  }
+
+  if (!collisions.length) return null;
+  return {
+    entries: collisions.map(
+      ({ leaf, nested }) => `${leaf}\n    is a strict prefix of: ${nested}`,
+    ),
+    kind: 'prefix-collision',
+    summary:
+      `${collisions.length} key(s) are a strict prefix of another key — a key cannot be both a ` +
+      `leaf and a namespace. Rename one, usually by giving the shorter key a modality segment ` +
+      `(.label / .text / .title):`,
+  };
+};
+
+/** Formats failures the way the generator prints them before exiting. */
+export const formatFailures = (failures: GuardFailure[]): string =>
+  failures
+    .map(
+      ({ entries, summary }) =>
+        `\n${summary}\n${entries.map((e) => `  ${e}`).join('\n')}`,
+    )
+    .join('\n');

package/codegen/i18n/index.ts

@@ -0,0 +1,29 @@
+/**
+ * Build-time codegen for a UI SDK's translation catalog, published as `stream-chat/i18n/codegen`.
+ *
+ * **Node-only.** This reads the filesystem and uses the TypeScript parser API, so it must never be
+ * reachable from `stream-chat/i18n` — which is why it lives beside `src/i18n/` rather than inside it.
+ * `scripts/bundle.mts` asserts that boundary at build time.
+ *
+ * `typescript` is injected through {@link GeneratorConfig.ts} rather than imported, so `stream-chat`
+ * does not depend on the compiler.
+ *
+ * Each SDK keeps a thin script that supplies its own paths:
+ *
+ * ```ts
+ * import ts from 'typescript';
+ * import { generateI18nKeys } from 'stream-chat/i18n/codegen';
+ *
+ * generateI18nKeys({
+ *   ts,
+ *   runtimeDefaultsPath: 'src/i18n/runtimeDefaults.ts',
+ *   keysOut: 'src/i18n/keys.ts',
+ *   fixtureOut: 'src/i18n/__tests__/catalog.fixture.json',
+ * });
+ * ```
+ */
+export * from './callSites';
+export * from './generate';
+export * from './guards';
+export * from './stringMaps';
+export * from './types';

package/codegen/i18n/stringMaps.ts

@@ -0,0 +1,91 @@
+import fs from 'node:fs';
+import type * as ts from 'typescript';
+
+import type { TypeScriptModule } from './types';
+
+/**
+ * Reads a flat `Record<string, string>` export out of a source file.
+ *
+ * Parsed rather than imported: `await import()` works under Node's type stripping but warns
+ * `MODULE_TYPELESS_PACKAGE_JSON` on every run, and the SDK packages cannot be `"type": "module"`.
+ *
+ * Throws rather than exiting, so a caller — including a test — can handle the failure.
+ */
+export const readStringMap = ({
+  exportName,
+  file,
+  ts: tsModule,
+}: {
+  exportName: string;
+  file: string;
+  ts: TypeScriptModule;
+}): Map<string, string> => {
+  if (!fs.existsSync(file)) {
+    throw new Error(
+      `i18n-codegen: could not read the file expected to export \`${exportName}\`: ${file}`,
+    );
+  }
+
+  const source = tsModule.createSourceFile(
+    file,
+    fs.readFileSync(file, 'utf8'),
+    tsModule.ScriptTarget.Latest,
+    true,
+    tsModule.ScriptKind.TS,
+  );
+
+  const out = new Map<string, string>();
+  let found = false;
+
+  tsModule.forEachChild(source, (node) => {
+    if (!tsModule.isVariableStatement(node)) return;
+
+    for (const declaration of node.declarationList.declarations) {
+      if (
+        !tsModule.isIdentifier(declaration.name) ||
+        declaration.name.text !== exportName ||
+        !declaration.initializer
+      ) {
+        continue;
+      }
+
+      // `= { … } as const` and `satisfies …` are both fine.
+      let initializer: ts.Expression = declaration.initializer;
+      while (
+        tsModule.isAsExpression(initializer) ||
+        tsModule.isSatisfiesExpression(initializer)
+      ) {
+        initializer = initializer.expression;
+      }
+      if (!tsModule.isObjectLiteralExpression(initializer)) continue;
+
+      found = true;
+      for (const property of initializer.properties) {
+        if (!tsModule.isPropertyAssignment(property)) {
+          throw new Error(
+            `i18n-codegen: ${exportName} in ${file} must be a flat object of string literals, got: ` +
+              property.getText(source).slice(0, 80),
+          );
+        }
+        if (
+          !tsModule.isStringLiteralLike(property.name) ||
+          !tsModule.isStringLiteralLike(property.initializer)
+        ) {
+          throw new Error(
+            `i18n-codegen: ${exportName} entries must be 'quoted.key': 'string literal', got: ` +
+              property.getText(source).slice(0, 80),
+          );
+        }
+        out.set(property.name.text, property.initializer.text);
+      }
+    }
+  });
+
+  if (!found) {
+    throw new Error(
+      `i18n-codegen: could not find an exported \`${exportName}\` object literal in ${file}`,
+    );
+  }
+
+  return out;
+};