prosebook 0.0.1 → 0.2.0

package/src/cli.ts

@@ -0,0 +1,528 @@
+#!/usr/bin/env node
+/**
+ * The `prosebook` command. Each subcommand is a function of the resolved config; `check` runs the
+ * ones CI needs in one go.
+ */
+import { existsSync, mkdirSync, readFileSync, watch, writeFileSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import { parseArgs } from 'node:util';
+
+import { stringify } from 'yaml';
+
+import { CatalogError, entryLocator, whereOf, type Catalog, type Problem } from './tools/catalog.ts';
+import { CONFIG_FILES, loadConfig, type ResolvedConfig } from './tools/config.ts';
+import { formatDiff, wordDiff } from './tools/diff.ts';
+import { applyFixes } from './tools/entry.ts';
+import { applyExtract, planExtract } from './tools/extract.ts';
+import { generate, render } from './tools/generate.ts';
+import { lint } from './tools/lint.ts';
+import type { StaleTranslation } from './tools/lock.ts';
+import { applyMigrate, planMigrate } from './tools/migrate.ts';
+import { SarifReport } from './tools/sarif.ts';
+import { isReferenced, scan, sourceFiles } from './tools/scan.ts';
+import { SYNTAX_NAME } from './tools/syntax.ts';
+
+const HELP = `prosebook: every string your app shows, in one typed catalog
+
+Usage: prosebook <command> [options]
+
+Commands:
+  init                    Create a config and a first catalog file
+  generate                Compile the catalog into typed modules  (--check: fail if out of date, --watch)
+  lint                    Check the messages and their translations against the writing rules
+                          (--fix: write the fixes the rules know, such as spellings and …)
+  status                  Translation coverage and stale translations per locale  (--strict, --verbose)
+  accept <locale> [keys]  Mark stale translations as still right  (--all for every stale one)
+  todo <locale>           Print the missing and stale entries of a locale, ready to translate
+  scan                    Find hardcoded text in JSX and catalog keys no code reads  (--strict)
+  extract [paths]         Move hardcoded JSX text into the catalog and rewrite the code to read it
+                          (dry run unless --write; --area <name> puts every entry in one area)
+  migrate <1|2>           Rewrite the catalog and translations in ICU MessageFormat (1) or MessageFormat 2
+                          (dry run unless --write)
+  check                   generate --check, lint and status --strict together, for CI
+
+Options:
+  --root <dir>            Project root (default: the current directory)
+  --format <text|sarif>   With lint, scan, status and check: sarif writes a SARIF 2.1.0 log to stdout
+                          for code scanning, and the usual text to stderr
+  -h, --help              Show this help
+`;
+
+const SARIF_COMMANDS = ['lint', 'scan', 'status', 'check'];
+
+/** What the checks that aren't lint rules hold the project to, for the rules in a SARIF log. */
+const RULES = {
+  catalog: 'The catalog and its translations parse, and each translation keeps the placeholders of its source.',
+  'out-of-date': 'The generated modules match the catalog: run `prosebook generate`.',
+  'missing-translation': 'Every locale translates every entry.',
+  'stale-translation': 'A translation was made from the source text as it is now.',
+  'hardcoded-text': 'Text a person reads comes from the catalog, not from a literal in JSX.',
+  'unused-key': 'Code reads every catalog key.',
+  allow: "An entry's exemption names a rule the entry breaks, and says why in a sentence.",
+};
+
+/** Text for people. Under `--format sarif` stdout holds only the log, so this goes to stderr. */
+let out = (s = '') => process.stdout.write(`${s}\n`);
+const err = (s = '') => process.stderr.write(`${s}\n`);
+
+async function main(argv: string[]): Promise<number> {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      root: { type: 'string' },
+      check: { type: 'boolean' },
+      watch: { type: 'boolean' },
+      strict: { type: 'boolean' },
+      verbose: { type: 'boolean' },
+      all: { type: 'boolean' },
+      write: { type: 'boolean' },
+      fix: { type: 'boolean' },
+      area: { type: 'string' },
+      format: { type: 'string' },
+      help: { type: 'boolean', short: 'h' },
+    },
+  });
+  const [command, ...rest] = positionals;
+  if (values.help || command === undefined) {
+    out(HELP);
+    return 0;
+  }
+  if (values.format !== undefined && values.format !== 'text' && values.format !== 'sarif') {
+    err(`prosebook: --format is text or sarif, not "${values.format}"`);
+    return 1;
+  }
+  const report = values.format === 'sarif' ? new SarifReport() : undefined;
+  if (report !== undefined) {
+    if (!SARIF_COMMANDS.includes(command)) {
+      err(`prosebook: --format sarif works with ${SARIF_COMMANDS.join(', ')}`);
+      return 1;
+    }
+    out = err;
+  }
+  const root = values.root ?? process.cwd();
+  if (command === 'init') return init(root);
+  const config = await loadConfig(root);
+  let code: number;
+  try {
+    switch (command) {
+      case 'generate':
+      case 'gen':
+        if (values.watch) return watchMode(config);
+        return runGenerate(config, values.check === true);
+      case 'lint':
+        code = runLint(config, report, values.fix === true);
+        break;
+      case 'status':
+        code = runStatus(config, values.strict === true, values.verbose === true, report);
+        break;
+      case 'accept':
+        return runAccept(config, rest, values.all === true);
+      case 'todo':
+        return runTodo(config, rest[0]);
+      case 'scan':
+        code = runScan(config, values.strict === true, report);
+        break;
+      case 'extract':
+        return runExtract(config, rest, values.write === true, values.area);
+      case 'migrate':
+        return runMigrate(config, rest[0], values.write === true);
+      case 'check': {
+        const results = [runGenerate(config, true, report), runLint(config, report), runStatus(config, true, false, report)];
+        code = results.some((r) => r !== 0) ? 1 : 0;
+        break;
+      }
+      default:
+        err(`prosebook: no command "${command}"\n`);
+        out(HELP);
+        return 1;
+    }
+  } catch (e) {
+    if (!(e instanceof CatalogError)) throw e;
+    reportProblems(config, e.problems, report);
+    err(`\n${e.problems.filter((p) => p.severity === 'error').length} error(s) in the catalog.`);
+    code = 1;
+  }
+  if (report !== undefined) process.stdout.write(`${JSON.stringify(report.toJSON(config.root, tool()), null, 2)}\n`);
+  return code;
+}
+
+function tool() {
+  const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')) as { version: string; homepage: string };
+  return { name: 'prosebook', version: pkg.version, informationUri: pkg.homepage };
+}
+
+function reportProblems(config: ResolvedConfig, problems: Problem[], report?: SarifReport) {
+  for (const p of problems) err(`${p.severity === 'error' ? 'error' : 'warn '} ${whereOf(p)}: ${p.message}`);
+  if (report === undefined) return;
+  const locate = entryLocator(config.root);
+  report.rule('catalog', RULES.catalog);
+  for (const p of problems) {
+    report.add({
+      rule: 'catalog',
+      level: p.severity === 'error' ? 'error' : 'warning',
+      message: p.message,
+      file: p.file,
+      ...(p.file !== undefined && p.key !== undefined ? locate(p.file, p.key) : {}),
+    });
+  }
+}
+
+function rel(config: ResolvedConfig, path: string) {
+  return relative(config.root, path).replaceAll('\\', '/');
+}
+
+function runGenerate(config: ResolvedConfig, check: boolean, report?: SarifReport): number {
+  const { changed, catalog, stale } = generate(config, { check });
+  reportProblems(config, catalog.problems, report);
+  const staleCount = [...stale.values()].reduce((n, s) => n + s.size, 0);
+  const summary = `${catalog.messages.length} messages, ${catalog.locales.length + 1} locale(s)${staleCount > 0 ? `, ${staleCount} stale translation(s)` : ''}`;
+  if (check) {
+    if (changed.length === 0) {
+      out(`prosebook: generated files are up to date (${summary})`);
+      return 0;
+    }
+    err(`prosebook: out of date, run \`prosebook generate\`:\n  ${changed.map((p) => rel(config, p)).join('\n  ')}`);
+    report?.rule('out-of-date', RULES['out-of-date']);
+    for (const p of changed)
+      report?.add({ rule: 'out-of-date', level: 'error', message: 'out of date: run `prosebook generate`', file: rel(config, p) });
+    return 1;
+  }
+  out(`prosebook: ${changed.length === 0 ? 'nothing changed' : `wrote ${changed.length} file(s)`} (${summary})`);
+  return 0;
+}
+
+function watchMode(config: ResolvedConfig): Promise<number> {
+  const regenerate = () => {
+    try {
+      runGenerate(config, false);
+    } catch (e) {
+      if (e instanceof CatalogError) reportProblems(config, e.problems);
+      else err(String(e));
+    }
+  };
+  regenerate();
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  for (const dir of [config.catalog, config.locales]) {
+    if (!existsSync(dir)) continue;
+    watch(dir, { recursive: true }, (_event, file) => {
+      if (file === null || !file.endsWith('.yaml')) return;
+      clearTimeout(timer);
+      timer = setTimeout(regenerate, 50);
+    });
+  }
+  out('prosebook: watching the catalog for changes');
+  return new Promise(() => {});
+}
+
+function runLint(config: ResolvedConfig, report?: SarifReport, fix = false): number {
+  let { catalog } = render(config);
+  let findings = lint(catalog.messages, config);
+  if (fix) {
+    const { fixed, problems } = applyFixes(config, catalog, findings);
+    if (problems.length > 0) {
+      reportProblems(config, problems, report);
+      err('The fixes would break the catalog, so nothing was written.');
+      return 1;
+    }
+    if (fixed > 0) {
+      out(`prosebook: fixed ${fixed} finding(s); run prosebook generate to compile them`);
+      ({ catalog } = render(config));
+      findings = lint(catalog.messages, config);
+    }
+  }
+  const locate = entryLocator(config.root);
+  const placed = findings.map((f) => ({ ...f, ...locate(f.file, f.key, f.at?.start, config.source) }));
+  for (const f of placed) {
+    const severity = f.severity === 'error' ? 'error' : 'warn ';
+    err(`${severity} ${f.file}:${f.line}:${f.column} ${f.key}: [${f.rule}] ${f.message}${f.fix === undefined ? '' : ' (fixable)'}`);
+  }
+  if (report !== undefined) {
+    for (const [name, { rule }] of Object.entries(config.lint.rules)) report.rule(name, rule.description);
+    report.rule('allow', RULES.allow);
+    for (const f of placed) {
+      report.add({
+        rule: f.rule,
+        level: f.severity === 'error' ? 'error' : 'warning',
+        message: `${f.key}: ${f.message}`,
+        file: f.file,
+        line: f.line,
+        column: f.column,
+      });
+    }
+  }
+  const errors = findings.filter((f) => f.severity === 'error').length;
+  const fixable = findings.filter((f) => f.fix !== undefined).length;
+  if (findings.length === 0) {
+    out(`prosebook: ${catalog.messages.length} messages pass the writing rules`);
+  } else {
+    err(
+      `\n${errors} error(s), ${findings.length - errors} warning(s). Fix the string, or add \`allow: { <rule>: <why> }\` where the rule is wrong about it.`,
+    );
+    if (fixable > 0) err(`${fixable} of them can be fixed with prosebook lint --fix.`);
+  }
+  return errors > 0 ? 1 : 0;
+}
+
+function missingKeys(catalog: Catalog, locale: string): string[] {
+  return catalog.messages.filter((m) => !m.translations.has(locale)).map((m) => m.key);
+}
+
+function runStatus(config: ResolvedConfig, strict: boolean, verbose: boolean, report?: SarifReport): number {
+  const { catalog, stale } = render(config);
+  if (report !== undefined) reportStatus(config, catalog, stale, strict ? 'error' : 'warning', report);
+  const total = catalog.messages.length;
+  if (catalog.locales.length === 0) {
+    out(`prosebook: ${total} messages in ${config.source}, no translations yet`);
+    return 0;
+  }
+  let incomplete = false;
+  out(`${'locale'.padEnd(10)} ${'translated'.padStart(12)} ${'missing'.padStart(8)} ${'stale'.padStart(6)}`);
+  for (const locale of catalog.locales) {
+    const missing = missingKeys(catalog, locale);
+    const staleHere = stale.get(locale) ?? new Map<string, StaleTranslation>();
+    const staleKeys = [...staleHere.keys()];
+    const done = total - missing.length;
+    if (missing.length > 0 || staleKeys.length > 0) incomplete = true;
+    const pct = total === 0 ? 100 : Math.floor((done / total) * 100);
+    out(
+      `${locale.padEnd(10)} ${`${done}/${total} ${String(pct).padStart(3)}%`.padStart(12)} ${String(missing.length).padStart(8)} ${String(staleKeys.length).padStart(6)}`,
+    );
+    if (verbose) {
+      for (const key of missing) out(`  missing ${key}`);
+      for (const [key, s] of staleHere) out(`  stale   ${key}: ${changeOf(s)}`);
+    }
+  }
+  if (incomplete && !verbose)
+    out('\n`prosebook status --verbose` lists the keys; `prosebook todo <locale>` prints them ready to translate.');
+  return strict && incomplete ? 1 : 0;
+}
+
+function reportStatus(
+  config: ResolvedConfig,
+  catalog: Catalog,
+  stale: Map<string, Map<string, StaleTranslation>>,
+  level: 'error' | 'warning',
+  report: SarifReport,
+) {
+  const locate = entryLocator(config.root);
+  report.rule('missing-translation', RULES['missing-translation']);
+  report.rule('stale-translation', RULES['stale-translation']);
+  for (const locale of catalog.locales) {
+    for (const m of catalog.messages) {
+      if (m.translations.has(locale)) continue;
+      const message = `${m.key} has no ${locale} translation: \`prosebook todo ${locale}\` prints it ready to translate`;
+      report.add({ rule: 'missing-translation', level, message, file: m.file, ...locate(m.file, m.key) });
+    }
+    for (const [key, s] of stale.get(locale) ?? []) {
+      const file = catalog.messages.find((m) => m.key === key)?.translations.get(locale)?.file;
+      if (file === undefined) continue;
+      const message = `the ${locale} translation of ${key} was made from an earlier source (${changeOf(s)}): update it, or \`prosebook accept ${locale} ${key}\` if it is still right`;
+      report.add({ rule: 'stale-translation', level, message, file, ...locate(file, key) });
+    }
+  }
+}
+
+function runAccept(config: ResolvedConfig, args: string[], all: boolean): number {
+  const [locale, ...keys] = args;
+  if (locale === undefined || (keys.length === 0 && !all)) {
+    err('Usage: prosebook accept <locale> <key>... | prosebook accept <locale> --all');
+    return 1;
+  }
+  const before = render(config).stale.get(locale) ?? new Map<string, StaleTranslation>();
+  const accepting = all ? new Set(before.keys()) : new Set(keys);
+  for (const key of accepting) if (!before.has(key)) err(`warn  ${locale} ${key} is not stale`);
+  generate(config, { accept: new Map([[locale, all ? true : new Set(keys)]]) });
+  out(`prosebook: accepted ${[...accepting].filter((k) => before.has(k)).length} translation(s) in ${locale}`);
+  return 0;
+}
+
+/** What changed in the source of a stale translation, as a word diff, or why that isn't known. */
+function changeOf(stale: StaleTranslation): string {
+  if (stale.was === undefined) return "the earlier text isn't recorded (the lock predates prosebook 0.2)";
+  return formatDiff(wordDiff(stale.was, stale.now)).replaceAll('\n', ' ');
+}
+
+function runTodo(config: ResolvedConfig, locale: string | undefined): number {
+  if (locale === undefined) {
+    err('Usage: prosebook todo <locale>');
+    return 1;
+  }
+  const { catalog, stale } = render(config);
+  const staleKeys = stale.get(locale) ?? new Map<string, StaleTranslation>();
+  const byArea = new Map<string, string[]>();
+  let count = 0;
+  for (const m of catalog.messages) {
+    const current = m.translations.get(locale);
+    if (current !== undefined && !staleKeys.has(m.key)) continue;
+    count += 1;
+    const lines = byArea.get(m.area) ?? [];
+    lines.push('');
+    if (m.context) lines.push(`# ${m.context}`);
+    for (const [arg, said] of m.argDocs) lines.push(`#   {${arg}}: ${said}`);
+    lines.push(`# ${config.source}: ${m.text.replaceAll('\n', ' ')}`);
+    const change = staleKeys.get(m.key);
+    if (change !== undefined) lines.push(`# stale, the source changed: ${changeOf(change)}`);
+    lines.push(stringify({ [m.key]: current?.text ?? '' }, { lineWidth: 0 }).trimEnd());
+    byArea.set(m.area, lines);
+  }
+  if (count === 0) {
+    out(`# ${locale} is complete`);
+    return 0;
+  }
+  out(
+    `# prosebook todo: ${count} entr${count === 1 ? 'y' : 'ies'} for ${locale}. Fill them in and paste each block into ${rel(config, config.locales)}/${locale}/<area>.yaml (or ${locale}.yaml).`,
+  );
+  for (const [area, lines] of byArea) {
+    out(`\n# ── ${area}.yaml ──`);
+    out(lines.join('\n'));
+  }
+  return 0;
+}
+
+function runScan(config: ResolvedConfig, strict: boolean, report?: SarifReport): number {
+  const { catalog } = render(config);
+  const result = scan(config.scan.dirs, config.scan.extensions, config.scan.attributes, config.root, [config.out]);
+  for (const h of result.hardcoded)
+    err(`${h.file}:${h.line}:${h.column} hardcoded ${h.where === 'text' ? 'text' : `${h.where}=`} "${h.text}"`);
+  const unused = catalog.messages.filter((m) => !isReferenced(m.key, result.refs));
+  for (const m of unused) err(`${m.file} ${m.key}: no code reads this key`);
+  if (report !== undefined) {
+    const level = strict ? 'error' : 'warning';
+    const locate = entryLocator(config.root);
+    report.rule('hardcoded-text', RULES['hardcoded-text']);
+    report.rule('unused-key', RULES['unused-key']);
+    for (const h of result.hardcoded) {
+      const what = `${h.where === 'text' ? '' : `${h.where}=`}"${h.text}"`;
+      const message = `${what} is hardcoded: move it into the catalog with \`prosebook extract\`, or mark the line \`prosebook-ignore\``;
+      report.add({ rule: 'hardcoded-text', level, message, file: h.file, line: h.line, column: h.column });
+    }
+    for (const m of unused)
+      report.add({ rule: 'unused-key', level, message: `no code reads ${m.key}: remove it`, file: m.file, ...locate(m.file, m.key) });
+  }
+  out(
+    `prosebook: scanned ${result.files} file(s): ${result.hardcoded.length} hardcoded string(s), ${unused.length} unused key(s)` +
+      (result.hardcoded.length > 0
+        ? '. `prosebook extract` moves the text into the catalog; mark a deliberate line `prosebook-ignore`.'
+        : ''),
+  );
+  return strict && result.hardcoded.length + unused.length > 0 ? 1 : 0;
+}
+
+async function runExtract(config: ResolvedConfig, paths: string[], write: boolean, area: string | undefined): Promise<number> {
+  const targets = paths.length > 0 ? paths.map((p) => resolve(config.root, p)) : config.scan.dirs;
+  const files = sourceFiles(targets, ['.tsx', '.jsx'], [config.out]).concat(targets.filter((t) => /\.[jt]sx$/.test(t) && existsSync(t)));
+  const plan = await planExtract(config, [...new Set(files)], { area });
+  const extractions = plan.files.flatMap((f) => f.extractions);
+  for (const x of extractions) {
+    out(`${x.file}:${x.line}:${x.column}  ${x.where === 'text' ? '' : `${x.where}=`}"${x.message}"`);
+    out(`  → ${x.key}${x.reused ? ' (already in the catalog)' : ''}: ${x.replacement.trim()}`);
+  }
+  for (const f of plan.files) for (const w of f.warnings) err(`warn  ${w}`);
+  if (extractions.length === 0) {
+    out('prosebook: no hardcoded text to extract');
+    return 0;
+  }
+  const changedFiles = plan.files.filter((f) => f.edits.length > 0).length;
+  const areas = [...new Set(plan.entries.map((e) => e.area))].map((a) => `${a}.yaml`);
+  const summary = `${extractions.length} string(s) in ${changedFiles} file(s), ${plan.entries.length} new entr${plan.entries.length === 1 ? 'y' : 'ies'}${areas.length > 0 ? ` in ${areas.join(', ')}` : ''}`;
+  out(`
+Placeholder types: ${plan.types === 'syntax' ? 'read from the code alone (no TypeScript 7 project found)' : `from ${plan.types}`}.`);
+  if (!write) {
+    out(`prosebook: would extract ${summary}. Run again with --write to apply.`);
+    return 0;
+  }
+  applyExtract(config, plan);
+  out(`
+prosebook: extracted ${summary}.`);
+  out('The new entries are marked `TODO(prosebook extract)`: check each key, kind, context and argument, then run `prosebook lint`.');
+  return runGenerate(config, false);
+}
+
+function runMigrate(config: ResolvedConfig, target: string | undefined, write: boolean): number {
+  const to = target === '1' ? 1 : target === '2' ? 2 : undefined;
+  if (to === undefined) {
+    err('Usage: prosebook migrate <1|2> [--write]');
+    return 1;
+  }
+  if (config.messageFormat === to) {
+    out(`prosebook: the catalog is already in ${SYNTAX_NAME[to]}`);
+    return 0;
+  }
+  const plan = planMigrate(config, to);
+  const where = (x: { file: string; key: string; locale: string }) =>
+    `${x.file} ${x.key}${x.locale === config.source ? '' : ` (${x.locale})`}`;
+  for (const r of plan.rewrites) out(`${where(r)}\n  ${r.after.replaceAll('\n', '\n  ')}`);
+  for (const c of plan.changed) err(`warn  ${where(c)}: renders differently for ${c.values}: "${c.before}" becomes "${c.after}"`);
+  for (const b of plan.blocked) err(`error ${where(b)}: ${b.reason}`);
+  if (plan.blocked.length > 0) {
+    err(`
+prosebook: ${plan.blocked.length} message(s) have no ${SYNTAX_NAME[to]} equivalent. Change them, then migrate again; nothing was written.`);
+    return 1;
+  }
+  const files = new Set(plan.rewrites.map((r) => r.file)).size;
+  const summary = `${plan.rewrites.length} message(s) in ${files} file(s) in ${SYNTAX_NAME[to]}`;
+  if (!write) {
+    out(`
+prosebook: would rewrite ${summary}. Run again with --write to apply.`);
+    return 0;
+  }
+  applyMigrate(config, plan);
+  out(`
+prosebook: rewrote ${summary}.`);
+  out(`Now set \`messageFormat: ${to}\` in the config, then run \`prosebook generate\`.`);
+  return 0;
+}
+
+const SAMPLE_CONFIG = `import { defineConfig } from 'prosebook/config';
+
+export default defineConfig({
+  catalog: 'copy/catalog',
+  locales: 'copy/locales',
+  out: 'src/copy',
+  source: 'en',
+  // Write messages in Unicode MessageFormat 2 rather than ICU MessageFormat:
+  // messageFormat: 2,
+});
+`;
+
+const SAMPLE_CATALOG = `# yaml-language-server: $schema=./catalog.schema.json
+app.title:
+  kind: name
+  surface: title
+  context: The app's name, in the window title and the header.
+  en: My app
+
+app.greeting:
+  kind: state
+  surface: status
+  context: Greets the person signed in, at the top of the home page.
+  args:
+    name: the person's first name
+  en: Welcome back, {name}.
+`;
+
+function init(root: string): number {
+  const configured = CONFIG_FILES.find((f) => existsSync(join(root, f)));
+  if (configured === undefined) {
+    writeFileSync(join(root, 'prosebook.config.ts'), SAMPLE_CONFIG);
+    out('created prosebook.config.ts');
+  }
+  const catalogDir = join(root, 'copy', 'catalog');
+  if (!existsSync(catalogDir)) {
+    mkdirSync(catalogDir, { recursive: true });
+    mkdirSync(join(root, 'copy', 'locales'), { recursive: true });
+    writeFileSync(join(catalogDir, 'app.yaml'), SAMPLE_CATALOG);
+    out('created copy/catalog/app.yaml');
+  }
+  out('\nNext: `prosebook generate`, then `createCopy(catalog)` from the generated src/copy.');
+  return 0;
+}
+
+main(process.argv.slice(2)).then(
+  (code) => process.exit(code),
+  (e: unknown) => {
+    err(e instanceof Error ? (e.stack ?? e.message) : String(e));
+    process.exit(1);
+  },
+);

package/src/index.ts

@@ -0,0 +1,31 @@
+/**
+ * `prosebook`: every string an app shows, in one typed catalog.
+ *
+ * The catalog is YAML, one entry per string, with the context a translator needs beside it.
+ * `prosebook generate` compiles it into typed modules, one per locale, whose messages are plain
+ * functions: this runtime looks them up, picks the locale and falls back, and parses nothing.
+ */
+export { createCopy, defineCatalog, type Catalog, type Copy, type CopyOptions } from './runtime/copy.ts';
+export { chainOf, negotiate, preferredLocales } from './runtime/locale.ts';
+export { createHelpers, flatten } from './runtime/helpers.ts';
+export type {
+  AnyTagFn,
+  ArgsParam,
+  Chunks,
+  Compiled,
+  CompiledMessages,
+  DefaultTags,
+  Helpers,
+  DevHooks,
+  HotHook,
+  MessageShape,
+  MessageShapes,
+  ReadHook,
+  Register,
+  RegisteredLocale,
+  RegisteredMessages,
+  RichKey,
+  RichParam,
+  RichValues,
+  TagFn,
+} from './runtime/types.ts';