prosebook 0.0.1 → 0.2.0

package/dist/tools.d.ts

@@ -0,0 +1,377 @@
+import { A as sentences, B as EntryLocation, C as RuleContext, D as definePlugin, E as compileRule, F as KindRule, G as entryLocation, H as Message, I as STRICT_LISTS, J as whereOf, K as loadCatalog, L as Severity, M as words, N as DEFAULT_KINDS, O as lint, P as DEFAULT_SURFACES, R as Catalog, S as Rule, T as applyEdits, U as Problem, V as KEY_PATTERN, W as Translation, Y as MessageFormatElement, _ as HOLE, b as Readings, c as resolveConfig, d as CheckRule, f as ConditionalRule, g as Finding, h as ExistenceRule, i as ResolvedConfig, j as singularOf, k as phrase, l as CORE_RULES, m as Edit, o as defineConfig, p as CoreRule, q as previewOf, r as ProsebookConfig, s as loadConfig, u as CapitalizationRule, v as OccurrenceRule, w as SubstitutionRule, x as Report, y as Plugin, z as CatalogError } from "./config-_4HfnJQu.js";
+import "@formatjs/icu-messageformat-parser";
+type Entry = readonly [key: string, ast: MessageFormatElement[]];
+interface CompiledLocale {
+  /** `const oN = {…};` lines the messages refer to. */
+  declarations: string[];
+  /** `"key": message,` lines. */
+  rows: string[];
+}
+/** One locale's messages as code, keeping only `keep` when given. */
+export declare function compileLocale(entries: Iterable<Entry>, keep?: (key: string) => boolean): CompiledLocale;
+/** The locale as an ES module whose default export is its messages. */
+export declare function localeModule(compiled: CompiledLocale, banner: string, ts: boolean): string;
+/** The locale as one expression, for a bundler to inline in place of the module. */
+export declare function localeExpression(compiled: CompiledLocale): string;
+interface Extraction {
+  file: string;
+  line: number;
+  column: number;
+  key: string;
+  /** The ICU message. */
+  message: string;
+  /** Whether an entry with this key and message already exists, so none is added. */
+  reused: boolean;
+  where: string;
+  /** The code that replaces the hardcoded text. */
+  replacement: string;
+}
+interface NewEntry {
+  key: string;
+  area: string;
+  message: string;
+  kind?: string;
+  surface?: string;
+  context: string;
+  args: Record<string, string>;
+}
+interface Edit$1 {
+  start: number;
+  end: number;
+  text: string;
+}
+interface FilePlan {
+  path: string;
+  file: string;
+  code: string;
+  edits: Edit$1[];
+  extractions: Extraction[];
+  warnings: string[];
+}
+interface ExtractPlan {
+  files: FilePlan[];
+  entries: NewEntry[];
+  /** What said which placeholders are numbers and dates: `TypeScript`, or `syntax` alone. */
+  types: string;
+}
+/** The area a file's strings go in: its name in kebab case, or its folder's for an `index`. */
+export declare function areaOf(file: string): string;
+/** A key segment from the words of a message: its first four, plain ASCII, lowercase. */
+export declare function slugOf(message: string): string;
+/**
+ * A count followed by a plural noun, `{n, number} files`, as the plural it needs: `{n, plural, one {#
+ * file} other {# files}}`. English only, and a draft: the TODO above the entry asks for a look.
+ */
+export declare function draftPlurals(message: string): string;
+/**
+ * Plans an extraction over the files in `paths` against the current catalog. With `types` (the
+ * default), the project's TypeScript says which placeholders are numbers and dates.
+ */
+export declare function planExtract(config: ResolvedConfig, paths: string[], options?: {
+  area?: string;
+  types?: boolean;
+}): Promise<ExtractPlan>;
+/** Applies a plan: rewrites the files and appends the new entries to their area's catalog file. */
+export declare function applyExtract(config: ResolvedConfig, plan: ExtractPlan): string[];
+interface EntryFields {
+  /** The source message. */
+  message: string;
+  /** By locale. Empty or missing is no translation, so the locale falls back. */
+  translations: Record<string, string>;
+  context: string;
+  kind: string;
+  surface: string;
+  fragment: boolean;
+  /** What each placeholder holds, by name. */
+  args: Record<string, string>;
+  /** A change asked of whoever edits next; empty is none. */
+  comment: string;
+  /** Asks for the entry to go, with the code that reads it. */
+  remove: boolean;
+}
+interface EntryYaml {
+  /** The entry in the catalog, from its key to the end of its value. */
+  catalog: string;
+  /** By locale, the entry in that locale's file. Empty is no translation. */
+  translations?: Record<string, string>;
+}
+interface EntryView {
+  key: string;
+  /** The source locale. */
+  source: string;
+  /** Every translated locale, the source aside. */
+  locales: string[];
+  /** Relative to the project root. A locale without the entry names the file it would go in. */
+  files: {
+    catalog: string;
+    translations: Record<string, string>;
+  };
+  /** With every locale in `translations`, empty where it has none. */
+  fields: EntryFields;
+  yaml: Required<EntryYaml>;
+  /** The source message's placeholders. */
+  argNames: string[];
+  kinds: string[];
+  surfaces: string[];
+  /** What lint says of the entry as it stands, in every locale. */
+  findings: EntryFinding[];
+}
+interface EntryFinding extends Finding {
+  /** The locale's text with this finding fixed, so the page can make the fix without lint's code. */
+  fixed?: string;
+}
+type EntryEdit = {
+  fields: EntryFields;
+} | {
+  yaml: EntryYaml;
+};
+/** The entry for `key`, with its translation in every locale. */
+export declare function readEntry(config: ResolvedConfig, key: string): EntryView;
+/**
+ * Applies an edit and checks the catalog with it. With `write`, a clean edit is written; without, it
+ * only comes back as the view, which is how the dialog turns fields into YAML and back.
+ */
+export declare function editEntry(config: ResolvedConfig, key: string, edit: EntryEdit, write: boolean): {
+  view?: EntryView;
+  problems: Problem[];
+};
+/**
+ * Makes the edits that lint's findings carry, each message in its own file, and writes them only if
+ * the catalog they make loads clean: the problems come back instead, and nothing is written.
+ */
+export declare function applyFixes(config: ResolvedConfig, catalog: Catalog, findings: Finding[]): {
+  fixed: number;
+  problems: Problem[];
+};
+interface Lock {
+  version: 2;
+  /** Source text by hash: every text some translation is anchored to. */
+  sources: Record<string, string>;
+  /** Per locale, per key: `<source hash>:<translation hash>`. */
+  translations: Record<string, Record<string, string>>;
+}
+export declare function hash(text: string): string;
+export declare function emptyLock(): Lock;
+/** The lock at `path`. A version 1 lock, which held only the translations, reads with no source texts. */
+export declare function readLock(path: string): Lock;
+export declare function serializeLock(lock: Lock): string;
+interface StaleTranslation {
+  /** The source the translation was made from, where the lock recorded it. */
+  was: string | undefined;
+  /** The source now. */
+  now: string;
+  /** The translation, made from `was`. */
+  translation: string;
+}
+interface Reconciled {
+  lock: Lock;
+  /** Per locale, per key: the translations made from a source that has changed since. */
+  stale: Map<string, Map<string, StaleTranslation>>;
+}
+/**
+ * The lock brought up to date with the catalog, and what is stale. `accept` re-anchors the given
+ * translations (per locale, keys, or `true` for all of them) to the current source.
+ */
+export declare function reconcile(catalog: Catalog, previous: Lock, accept?: Map<string, Set<string> | true>): Reconciled;
+/** Every locale the app can switch to, in order: the source, the translations, the pseudo-locale. */
+export declare function localesOf(catalog: Catalog, config: ResolvedConfig): string[];
+/** Per locale, the messages its module holds. A translated locale holds only what it translates. */
+export declare function localeEntries(catalog: Catalog, config: ResolvedConfig, stale: Map<string, Map<string, StaleTranslation>>): Map<string, Entry[]>;
+/** The JSON Schema an editor reads to complete and explain catalog entries. */
+export declare function catalogSchema(config: ResolvedConfig): object;
+interface Generated {
+  catalog: Catalog;
+  /** Absolute path to content. */
+  files: Map<string, string>;
+  lock: Lock;
+  stale: Map<string, Map<string, StaleTranslation>>;
+  entries: Map<string, Entry[]>;
+}
+/** Everything `generate` writes, in memory. */
+export declare function render(config: ResolvedConfig, accept?: Map<string, Set<string> | true>): Generated;
+/** Writes what changed. With `check`, writes nothing and returns what would have changed. */
+export declare function writeFiles(files: Map<string, string>, check?: boolean): string[];
+export declare function generate(config: ResolvedConfig, options?: {
+  check?: boolean;
+  accept?: Map<string, Set<string> | true>;
+}): Generated & {
+  changed: string[];
+};
+/**
+ * A word diff, for showing a translator what changed in the source since they translated it. Words,
+ * runs of whitespace and single punctuation marks are the units, so an ICU brace or a period changes
+ * on its own rather than taking its word with it.
+ */
+interface DiffPart {
+  op: 'same' | 'add' | 'del';
+  text: string;
+}
+export declare function wordDiff(before: string, after: string): DiffPart[];
+/** The diff as one line: `Save [-the-]{+a+} draft`, the notation of `git diff --word-diff`. */
+export declare function formatDiff(parts: DiffPart[]): string;
+export declare function pseudoText(text: string): string;
+export declare function pseudoAst(ast: MessageFormatElement[]): MessageFormatElement[];
+type Element$1 = MessageFormatElement;
+/** A function as written: `:number minimumFractionDigits=2`. Kept on the styles it produces, to write back. */
+interface Mf2Function {
+  name: string;
+  options: Record<string, string>;
+}
+/** An MF2 message as the element tree. Throws, with the fix, where it can't be read or compiled. */
+export declare function parseMf2(text: string, locale: string): Element$1[];
+/** The `Intl.NumberFormat` options a numeric function formats with. */
+export declare function intlNumber(fn: Mf2Function): Intl.NumberFormatOptions;
+/**
+ * The `Intl.DateTimeFormat` options a date or time function formats with. MF2's date and time
+ * functions are still a draft; this follows the spec's semantic options as the `messageformat`
+ * package does, so a message reads the same in both.
+ */
+export declare function intlDate(fn: Mf2Function): Intl.DateTimeFormatOptions;
+/** A message tree as MF2 text. Throws, saying what has no MF2 equivalent, where it can't be written. */
+export declare function toMf2(ast: Element$1[], locale: string): string;
+type Element = MessageFormatElement;
+export declare function toMf1(ast: Element[]): string;
+type MessageFormatVersion = 1 | 2;
+export declare const SYNTAX_NAME: Record<MessageFormatVersion, string>;
+/**
+ * A message as the element tree. MF2 is read per locale: which variants a value can reach depends
+ * on the locale's plural rules (see `matchTree` in mf2.ts).
+ */
+export declare function readMessage(version: MessageFormatVersion, text: string, locale: string): MessageFormatElement[];
+/** A tree as text in the given syntax. Throws, saying what the syntax can't express, where it can't. */
+export declare function writeMessage(version: MessageFormatVersion, ast: MessageFormatElement[], locale: string): string;
+interface Located {
+  key: string;
+  locale: string;
+  /** The file, relative to the project root. */
+  file: string;
+}
+interface MigratePlan {
+  to: MessageFormatVersion;
+  rewrites: (Located & {
+    before: string;
+    after: string;
+  })[];
+  /** Messages the target syntax can't say, and why. Nothing is written while there are any. */
+  blocked: (Located & {
+    reason: string;
+  })[];
+  /** Messages that would render differently, with the first values that show it. */
+  changed: (Located & {
+    values: string;
+    before: string;
+    after: string;
+  })[];
+}
+export declare function planMigrate(config: ResolvedConfig, to: MessageFormatVersion): MigratePlan;
+/** Writes the plan's rewrites into the YAML files, keeping their comments and layout. Returns the files written. */
+export declare function applyMigrate(config: ResolvedConfig, plan: MigratePlan): string[];
+type Node = {
+  type: string;
+  start: number;
+  end: number;
+  [field: string]: any;
+};
+/** `node` is markup or an object, which a message can't hold as text. */
+type ValueKind = 'string' | 'number' | 'date' | 'node' | 'unknown';
+interface Span {
+  start: number;
+  end: number;
+}
+interface TypeOracle {
+  /** Where the answers come from, for the report. */
+  readonly source: string;
+  /** The kind of each span's expression in `file`, or nothing where the oracle can't say. */
+  kinds(file: string, spans: readonly Span[]): Promise<(ValueKind | undefined)[]>;
+  close(): Promise<void>;
+}
+/**
+ * An oracle over the projects the files belong to, or nothing where TypeScript 7 isn't installed or
+ * none of the files has a tsconfig. One compiler process serves every project and is closed by `close`.
+ */
+export declare function typescriptOracle(root: string, files: readonly string[]): Promise<TypeOracle | undefined>;
+/** The kind an expression's syntax gives away, where it does: `items.length`, `a * b`, `new Date()`. */
+export declare function syntaxKind(expr: Node): ValueKind | undefined;
+interface SarifResult {
+  /** A rule the report describes, or one of a lint plugin's. */
+  rule: string;
+  level: 'error' | 'warning';
+  message: string;
+  /** Relative to the project root, with forward slashes; none for a problem that isn't in a file. */
+  file?: string;
+  /** From 1; none for the file as a whole. */
+  line?: number;
+  column?: number;
+}
+interface SarifTool {
+  name: string;
+  version: string;
+  informationUri: string;
+}
+/** Collects what a command found, then writes it as one SARIF run. */
+export declare class SarifReport {
+  readonly results: SarifResult[];
+  private readonly rules;
+  /** Describes a rule in one sentence; the first description given for an id stands. */
+  rule(id: string, description?: string): void;
+  add(result: SarifResult): void;
+  toJSON(root: string, tool: SarifTool): object;
+}
+export declare function sourceFiles(dirs: string[], extensions: string[], skip?: string[]): string[];
+interface KeyRefs {
+  exact: Set<string>;
+  /** `nav.` from `nav.${id}` or `'nav.' + id`: every key under it may be read. */
+  prefixes: Set<string>;
+}
+export declare function keyRefs(code: string, into?: KeyRefs): KeyRefs;
+export declare function isReferenced(key: string, refs: KeyRefs): boolean;
+interface Hardcoded {
+  file: string;
+  line: number;
+  column: number;
+  text: string;
+  /** Where it sits: `text`, or the attribute it is the value of. */
+  where: string;
+}
+/**
+ * Text that reads as code rather than prose: one token holding a path, a call, an identifier with an
+ * underscore or a dotted name, as in `form.json()` or `src/index.ts`. Trailing punctuation doesn't
+ * count, so `Done.` is still prose.
+ */
+export declare function looksLikeCode(text: string): boolean;
+/** Literal text in JSX that a person reads, where it should be a catalog entry. */
+export declare function hardcodedText(file: string, code: string, attributes: string[]): Hardcoded[];
+interface ScanResult {
+  hardcoded: Hardcoded[];
+  refs: KeyRefs;
+  files: number;
+}
+export declare function scan(dirs: string[], extensions: string[], attributes: string[], root: string, skip?: string[]): ScanResult;
+/** A copy's methods that take a key first. */
+export declare const READERS: Set<string>;
+interface UnseenRead {
+  file: string;
+  line: number;
+  column: number;
+  /** The read as written, on one line. */
+  code: string;
+  /** What it calls: a reader, the name it was imported by, or `Text`. */
+  name: string;
+}
+interface Reads {
+  /** Reads whose key a build can't see, in calls that may be to a copy's `t` or `rich`. */
+  unseen: UnseenRead[];
+  /** Names a copy's readers are bound to here, as in `const { rich: tRich } = copy`. */
+  aliases: Set<string>;
+}
+/**
+ * The reads in a module whose key a pruned build can't see, as in `t(item.key)` or `<Text id={id} />`:
+ * the build would leave the message out, and the key would show in its place. A build has no types,
+ * so readers are known by name: `t` and `rich` called alone or as methods, and any name imported here,
+ * which may be bound to one elsewhere (`aliases`); the caller keeps those whose name turns out to be a
+ * reader. `<Text>` counts where it is imported from `prosebook/react`. Lines marked `prosebook-ignore`
+ * are skipped.
+ */
+export declare function unseenReads(file: string, code: string): Reads;
+export { CORE_RULES, type CapitalizationRule, type Catalog, CatalogError, type CheckRule, type CompiledLocale, type ConditionalRule, type CoreRule, DEFAULT_KINDS, DEFAULT_SURFACES, type DiffPart, type Edit, type Entry, type EntryEdit, type EntryFields, type EntryFinding, type EntryLocation, type EntryView, type EntryYaml, type ExistenceRule, type ExtractPlan, type Extraction, type FilePlan, type Finding, type Generated, HOLE, type Hardcoded, KEY_PATTERN, type KeyRefs, type KindRule, type Lock, type Message, type MessageFormatVersion, type Mf2Function, type MigratePlan, type NewEntry, type OccurrenceRule, type Plugin, type Problem, type ProsebookConfig, type Readings, type Reads, type Report, type ResolvedConfig, type Rule, type RuleContext, STRICT_LISTS, type SarifResult, type SarifTool, type Severity, type Span, type StaleTranslation, type SubstitutionRule, type Translation, type TypeOracle, type UnseenRead, type ValueKind, applyEdits, compileRule, defineConfig, definePlugin, entryLocation, lint, loadCatalog, loadConfig, phrase, previewOf, resolveConfig, sentences, singularOf, whereOf, words };
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","names":["Edit","Element"],"sources":["../src/tools/compile.ts","../src/tools/extract.ts","../src/tools/entry.ts","../src/tools/lock.ts","../src/tools/generate.ts","../src/tools/diff.ts","../src/tools/pseudo.ts","../src/tools/mf2.ts","../src/tools/mf1.ts","../src/tools/syntax.ts","../src/tools/migrate.ts","../src/tools/types.ts","../src/tools/sarif.ts","../src/tools/scan.ts"],"mappings":"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"}

package/dist/tools.js

@@ -0,0 +1,4 @@
+import { A as entryLocation, B as parseMf2, C as editEntry, D as localeModule, E as localeExpression, F as SYNTAX_NAME, H as toMf1, I as readMessage, L as writeMessage, M as loadCatalog, N as previewOf, O as CatalogError, P as whereOf, R as intlDate, S as applyFixes, T as compileLocale, V as toMf2, _ as emptyLock, a as looksLikeCode, b as reconcile, c as unseenReads, d as localeEntries, f as localesOf, g as pseudoText, h as pseudoAst, i as keyRefs, k as KEY_PATTERN, l as catalogSchema, m as writeFiles, n as hardcodedText, o as scan, p as render, r as isReferenced, s as sourceFiles, t as READERS, u as generate, v as hash, w as readEntry, x as serializeLock, y as readLock, z as intlNumber } from "./scan-Ch2BfIUD.js";
+import { a as wordDiff, c as draftPlurals, d as syntaxKind, f as typescriptOracle, i as formatDiff, l as planExtract, n as applyMigrate, o as applyExtract, r as planMigrate, s as areaOf, t as SarifReport, u as slugOf } from "./sarif-CI8HOokm.js";
+import { _ as words, a as DEFAULT_KINDS, c as CORE_RULES, d as compileRule, f as definePlugin, g as singularOf, h as sentences, i as resolveConfig, l as HOLE, m as phrase, n as defineConfig, o as DEFAULT_SURFACES, p as lint, r as loadConfig, s as STRICT_LISTS, u as applyEdits } from "./config-D--RITk2.js";
+export { CORE_RULES, CatalogError, DEFAULT_KINDS, DEFAULT_SURFACES, HOLE, KEY_PATTERN, READERS, STRICT_LISTS, SYNTAX_NAME, SarifReport, applyEdits, applyExtract, applyFixes, applyMigrate, areaOf, catalogSchema, compileLocale, compileRule, defineConfig, definePlugin, draftPlurals, editEntry, emptyLock, entryLocation, formatDiff, generate, hardcodedText, hash, intlDate, intlNumber, isReferenced, keyRefs, lint, loadCatalog, loadConfig, localeEntries, localeExpression, localeModule, localesOf, looksLikeCode, parseMf2, phrase, planExtract, planMigrate, previewOf, pseudoAst, pseudoText, readEntry, readLock, readMessage, reconcile, render, resolveConfig, scan, sentences, serializeLock, singularOf, slugOf, sourceFiles, syntaxKind, toMf1, toMf2, typescriptOracle, unseenReads, whereOf, wordDiff, words, writeFiles, writeMessage };

package/dist/vite.d.ts

@@ -0,0 +1,24 @@
+import { r as ProsebookConfig } from "./config-_4HfnJQu.js";
+import { Plugin } from "vite";
+export interface ProsebookPluginOptions {
+  /** The config, inline. Without it, `prosebook.config.*` at `root` is read. */
+  config?: ProsebookConfig;
+  /**
+   * The folder the config's paths resolve from, and where its file is found: the Vite root when
+   * unset. Apps that share one catalog name its folder, so each build generates the same files.
+   */
+  root?: string;
+  /**
+   * Ship only the messages the code names. `strict`, the default, also fails the build on a read
+   * whose key it can't see, such as `t(item.key)`, which would show the key where its message was
+   * pruned. `loose` prunes without that check; `false` ships every message.
+   */
+  prune?: 'strict' | 'loose' | false;
+  /** Keys a build always keeps, exactly or as `prefix.*`: for keys built at runtime from data. */
+  keep?: string[];
+  /** In dev, Alt-click a string on the page to open its entry in the editor. On by default. */
+  inspect?: boolean;
+}
+export declare function prosebook(options?: ProsebookPluginOptions): Plugin;
+export { prosebook as default };
+//# sourceMappingURL=vite.d.ts.map

package/dist/vite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.d.ts","names":[],"sources":["../src/vite.ts"],"mappings":";;iBA2BiB;;EAEf,SAAS;;;;;EAKT;;;;;;EAMA;;EAEA;;EAEA;;wBAgCc,UAAU,UAAS,yBAA8B"}