prosebook 0.0.1 → 0.2.0

package/dist/config-_4HfnJQu.d.ts

@@ -0,0 +1,517 @@
+import { MessageFormatElement } from "@formatjs/icu-messageformat-parser";
+interface Translation {
+  text: string;
+  ast: MessageFormatElement[];
+  file: string;
+}
+interface Message {
+  key: string;
+  /** The first segment of the key, which names its file. */
+  area: string;
+  file: string;
+  kind?: string;
+  surface?: string;
+  /** One sentence telling a translator where the string appears. */
+  context?: string;
+  /** What each placeholder holds, keyed by argument name. */
+  argDocs: Map<string, string>;
+  /** Completes something beside it rather than standing as a sentence, so sentence rules do not apply. */
+  fragment: boolean;
+  /** Lint rules the entry is exempt from, each with the reason. */
+  allow: Map<string, string>;
+  /** A change someone asked for, left for whoever edits the entry next, and deleted once it is made. */
+  comment?: string;
+  /** Asked to go: the entry, its translations and the code that reads it. */
+  remove: boolean;
+  /** The source message, in ICU MessageFormat. */
+  text: string;
+  ast: MessageFormatElement[];
+  /** Argument name to TypeScript type. */
+  args: Map<string, string>;
+  /** How each formatted argument is styled, for the doc comment at the call site. */
+  argFormats: Map<string, string>;
+  tags: string[];
+  /** Translations by locale. */
+  translations: Map<string, Translation>;
+}
+interface Problem {
+  severity: 'error' | 'warn';
+  /** Relative to the project root; none for a problem that isn't in a file. */
+  file?: string;
+  /** The entry it is about, in `file`; none for the file as a whole. */
+  key?: string;
+  message: string;
+}
+/** `file key`, as the CLI names where a problem is. */
+declare function whereOf(problem: Problem): string;
+interface Catalog {
+  messages: Message[];
+  /** The translated locales found under `locales`, without the source. */
+  locales: string[];
+  problems: Problem[];
+}
+declare class CatalogError extends Error {
+  readonly problems: Problem[];
+  constructor(problems: Problem[]);
+}
+/**
+ * A key is dotted lowercase, two segments at least, and its first segment names the file it lives
+ * in. Keys are read at every call site, so they say what the string is for: `cart.checkout.title`.
+ */
+declare const KEY_PATTERN: RegExp;
+/**
+ * Loads and checks the catalog. Throws a `CatalogError` when anything is an error; warnings ride along.
+ * `unsaved` holds file contents by absolute path to read in place of what is on disk, so an edit can be
+ * checked before it is written; a translation file in it that isn't on disk yet is read too.
+ */
+declare function loadCatalog(config: ResolvedConfig, unsaved?: ReadonlyMap<string, string>): Catalog;
+interface EntryLocation {
+  /** Absolute. */
+  file: string;
+  /** From 1. */
+  line: number;
+  /** From 1. */
+  column: number;
+}
+/**
+ * Where a message's entry is written: its translation in `locale` when there is one, else the catalog.
+ * Read from the file as it is now, so an entry moved since the catalog was loaded is still found.
+ */
+declare function entryLocation(config: ResolvedConfig, message: Message, locale?: string): EntryLocation;
+/** The source message as a reader sees it with no placeholders filled: for docs and reports. */
+declare function previewOf(message: Message): string;
+/**
+ * The defaults: four kinds of string, the surfaces they sit on, and the word lists of the strict lint preset.
+ *
+ * The kinds are the four any UI writing guide comes down to. A name identifies, an action says what
+ * pressing it does, a description adds what the name cannot carry, a state reports what is true.
+ * Each carries a budget and a grammar, which is what makes a mechanical check of the words possible.
+ */
+type Severity = 'error' | 'warn' | 'off';
+interface KindRule {
+  /** What the kind is for, shown when an editor completes it. */
+  doc: string;
+  /** The most words it may have. Articles, short prepositions and asides in parentheses are free. */
+  maxWords?: number;
+  /** The most sentences it may have, and per surface where that differs. */
+  maxSentences?: number;
+  maxSentencesOn?: Record<string, number>;
+  /** Whether it ends with a period: always, never, or only on the surfaces listed. */
+  period?: 'always' | 'never' | string[];
+  /** Capitalizes only its first word and proper nouns. */
+  sentenceCase?: boolean;
+  /** Carries no explanation after a dash or colon: `Quick capture`, not `Quick capture: choose an area`. */
+  bare?: boolean;
+}
+declare const DEFAULT_KINDS: Record<string, KindRule>;
+declare const DEFAULT_SURFACES: Record<string, string>;
+/** The word lists of the strict preset: filler, marketing and reassurance, and American spelling. */
+declare const STRICT_LISTS: {
+  banned: {
+    words: string[];
+    why: string;
+  }[];
+  spelling: Record<string, string>;
+};
+/** What a rule is given about one message in one locale. */
+interface RuleContext {
+  /** The entry, as the source catalog has it. */
+  message: Message;
+  /** The locale read: the source, or a translation's. */
+  locale: string;
+  /** The message in that locale. */
+  ast: MessageFormatElement[];
+  /** The shape the message's kind is held to, when it names a kind the config defines. */
+  kind: KindRule | undefined;
+  /** The message in that locale, as prose. */
+  text: Readings;
+  /** The source message as prose, to hold a translation to it: `text` itself in the source locale. */
+  source: Readings;
+  config: ResolvedConfig;
+}
+interface RuleBase {
+  /** One sentence: what the rule holds a string to. */
+  description: string;
+  /** Its severity under `extends: 'recommended'`; off when unset. */
+  recommended?: Severity;
+  /** Its severity under `extends: 'strict'`; `error` when unset. */
+  strict?: Severity;
+  /**
+   * Only entries of these kinds, on these surfaces, or in these areas (a key's first segment); an
+   * entry that says no kind or surface is skipped by a rule that names some. Only the source unless
+   * `locale` says otherwise, since most writing rules are written for one language: `all` reads
+   * every locale, and a list those languages and their regions (`de` covers `de-CH`).
+   */
+  on?: {
+    kind?: string[];
+    surface?: string[];
+    area?: string[];
+    locale?: 'all' | string[];
+  };
+}
+/** A rule written as code. */
+interface CheckRule extends RuleBase {
+  /** What is wrong with the message, a sentence each that states the fix; none when it passes. */
+  check(context: RuleContext): (string | Report)[];
+}
+/** A finding that can say where it is, and what to write instead. */
+interface Report {
+  message: string;
+  /** The words the finding is about, as a reading has them: found in the message's text, in any case. */
+  match?: string;
+  /** What `prosebook lint --fix` writes in place of `match`, wherever it stands; its case follows the text's. */
+  fix?: string;
+}
+/** A replacement in a message's text, by offset. */
+interface Edit {
+  start: number;
+  end: number;
+  text: string;
+}
+/** Words or patterns a string never uses. */
+interface ExistenceRule extends RuleBase {
+  type: 'existence';
+  /** Words or phrases, matched whole and in any case. `{match}` is the one listed. */
+  words?: string[];
+  /** `{match}` is the text matched. */
+  patterns?: string[];
+  ignoreCase?: boolean;
+  message: string;
+}
+/** A word or phrase the product writes another way. */
+interface SubstitutionRule extends RuleBase {
+  type: 'substitution';
+  /** A word or phrase, matched whole and in any case, and the one written instead. */
+  swap: Record<string, string>;
+  /** `{match}` and `{use}`; `"{match}" is written "{use}"` when unset. */
+  message?: string;
+}
+/** A budget, beside the one a kind sets: per surface, say, or in characters. */
+interface OccurrenceRule extends RuleBase {
+  type: 'occurrence';
+  /** Every word, placeholders included; sentences; or characters, placeholders not included. */
+  count: 'words' | 'sentences' | 'characters';
+  max?: number;
+  min?: number;
+  /** `max` and `min` are multiples of the source's count: `max: 1.4` is 40% longer than the source at most. */
+  relative?: boolean;
+  /** `{count}`, `{max}`, `{min}`, and with `relative`, `{source}` (the source's count) and `{limit}`. */
+  message?: string;
+}
+interface CapitalizationRule extends RuleBase {
+  type: 'capitalization';
+  /** `sentence` capitalizes only the first word and proper nouns, `title` every word but short function words. */
+  case: 'sentence' | 'title' | 'lower' | 'upper';
+  /** Words that keep their case, beside `lint.properNouns`. */
+  exceptions?: string[];
+  /** `{match}` is the first word out of case. */
+  message?: string;
+}
+/** A string that matches `when` (every string, when unset) matches `require` too. */
+interface ConditionalRule extends RuleBase {
+  type: 'conditional';
+  when?: string;
+  require: string;
+  ignoreCase?: boolean;
+  /** `{match}` is the text `when` matched. */
+  message: string;
+}
+type Rule = CheckRule | ExistenceRule | SubstitutionRule | OccurrenceRule | CapitalizationRule | ConditionalRule;
+/** A set of rules, named `<name>/<rule>` in `lint.rules` and in an entry's `allow`. */
+interface Plugin {
+  name: string;
+  rules: Record<string, Rule>;
+}
+/** Typed plugin, for `lint.plugins`. */
+declare function definePlugin(plugin: Plugin): Plugin;
+interface Finding {
+  key: string;
+  /** The catalog file, or for a translation, the locale's file. */
+  file: string;
+  /** The locale whose text the finding is about; the source for an `allow` finding. */
+  locale: string;
+  /** The rule's name, or `allow` for an exemption that is itself wrong. */
+  rule: string;
+  severity: Exclude<Severity, 'off'>;
+  message: string;
+  /** Where in the locale's message text, when the rule named a match and it is written there as read. */
+  at?: {
+    start: number;
+    end: number;
+  };
+  /** The edits that fix it, at every place the match stands. */
+  fix?: Edit[];
+}
+/** Stands in for a placeholder in a reading, which no prose rule reads. */
+declare const HOLE = "⁣";
+/** The message as prose: placeholders and verbatim tags read as `HOLE`, and `’` as `'` in `variants`. */
+interface Readings {
+  /** Every `other` arm taken: what a budget is measured on. */
+  primary: string;
+  /** One reading per arm, so a word hidden in `one` is still found. */
+  variants: string[];
+  /** Only the words the message always carries. */
+  skeleton: string;
+}
+/** The words a budget counts: articles, short prepositions and asides in parentheses are free. */
+declare function words(text: string): string[];
+declare function sentences(text: string): number;
+/** A word or phrase on its own, not inside a longer word or a hyphenated compound. */
+declare function phrase(p: string): RegExp;
+/**
+ * The singular of an English plural noun, or nothing where it doesn't look like one. A word with no
+ * vowel is a unit or an abbreviation (`kbps`, `fps`, `hrs`), which reads the same after 1.
+ */
+declare function singularOf(word: string): string | undefined;
+declare const CORE_RULES: {
+  whitespace: {
+    description: string;
+    recommended: "error";
+    on: {
+      locale: "all";
+    };
+    check: ({ text }: RuleContext) => string[] | {
+      message: string;
+      match: string;
+      fix: string;
+    }[];
+  };
+  'word-budget': {
+    description: string;
+    recommended: "warn";
+    check: ({ message: m, kind, text }: RuleContext) => string[];
+  };
+  'sentence-budget': {
+    description: string;
+    recommended: "warn";
+    check: ({ message: m, kind, text }: RuleContext) => string[];
+  };
+  period: {
+    description: string;
+    recommended: "warn";
+    check: ({ message: m, kind, text }: RuleContext) => string[];
+  };
+  'no-period': {
+    description: string;
+    recommended: "warn";
+    check: ({ message: m, kind, text }: RuleContext) => string[];
+  };
+  'bare-name': {
+    description: string;
+    recommended: "warn";
+    check: ({ message: m, kind, text }: RuleContext) => string[];
+  };
+  'sentence-case': {
+    description: string;
+    check: ({ message: m, kind, text, config }: RuleContext) => {
+      message: string;
+      match: string;
+    }[];
+  };
+  'banned-word': {
+    description: string;
+    recommended: "warn";
+    check: ({ text, config }: RuleContext) => {
+      message: string;
+      match: string;
+    }[];
+  };
+  spelling: {
+    description: string;
+    recommended: "warn";
+    check: ({ text, config: { lint } }: RuleContext) => {
+      message: string;
+      match: string;
+      fix: string | undefined;
+    }[];
+  };
+  'one-word': {
+    description: string;
+    recommended: "warn";
+    check: ({ text, config: { lint } }: RuleContext) => {
+      message: string;
+      match: string;
+      fix: string | undefined;
+    }[];
+  };
+  'no-em-dash': {
+    description: string;
+    check: ({ text }: RuleContext) => {
+      message: string;
+      match: string;
+    }[];
+  };
+  path: {
+    description: string;
+    check: ({ text, config }: RuleContext) => {
+      message: string;
+      match: string;
+      fix: string;
+    }[];
+  };
+  contractions: {
+    description: string;
+    check: ({ text }: RuleContext) => {
+      message: string;
+      match: string;
+      fix: string;
+    }[];
+  };
+  ellipsis: {
+    description: string;
+    on: {
+      locale: "all";
+    };
+    check: ({ text }: RuleContext) => {
+      message: string;
+      match: string;
+      fix: string;
+    }[];
+  };
+  'plural-count': {
+    description: string;
+    recommended: "warn";
+    check: ({ ast }: RuleContext) => Report[];
+  };
+  'plural-one': {
+    description: string;
+    recommended: "warn";
+    on: {
+      locale: "all";
+    };
+    check: ({ ast, locale, config }: RuleContext) => Report[];
+  };
+  'arm-endings': {
+    description: string;
+    recommended: "warn";
+    on: {
+      locale: "all";
+    };
+    check: ({ ast }: RuleContext) => string[];
+  };
+  'formatted-by-hand': {
+    description: string;
+    recommended: "warn";
+    on: {
+      locale: "all";
+    };
+    check: ({ ast, text }: RuleContext) => Report[];
+  };
+  'source-ending': {
+    description: string;
+    recommended: "warn";
+    on: {
+      locale: "all";
+    };
+    check: ({ text, source }: RuleContext) => string[];
+  };
+};
+type CoreRule = keyof typeof CORE_RULES;
+/** A rule as code, checked once when the config loads: a JSON config is not type-checked. */
+declare function compileRule(name: string, rule: Rule): CheckRule;
+/** `text` with the edits made, leaving out any that overlaps one before it. */
+declare function applyEdits(text: string, edits: Edit[]): string;
+declare function lint(messages: Message[], config: ResolvedConfig): Finding[];
+interface WordLists {
+  /** Words a string never uses, in groups that say why. */
+  banned?: {
+    words: string[];
+    why: string;
+  }[];
+  /** A spelling, and the one the product uses instead. */
+  spelling?: Record<string, string>;
+  /** A near-synonym, and the one word the product uses for that concept. */
+  concepts?: Record<string, string>;
+  /** Words that keep their capital inside a sentence-case string: product names, platforms. */
+  properNouns?: string[];
+  /** What a path through menus or settings is written with, spaced: `›` by default, as in Settings › General. */
+  pathSeparator?: string;
+}
+type RuleSeverities = Partial<Record<CoreRule, Severity>> & Record<string, Severity>;
+interface LintConfig extends WordLists {
+  /** `recommended` (the default) checks shape; `strict` adds the word lists and rules of a house style guide. */
+  extends?: 'recommended' | 'strict' | 'none';
+  /** Rules of your own, as `<plugin>/<rule>`. Each takes the severity it gives itself under `extends`. */
+  plugins?: Plugin[];
+  rules?: RuleSeverities;
+  /** Severities for one area's entries (a key's first segment) over `rules`: `{ native: { 'sentence-case': 'off' } }`. */
+  areas?: Record<string, RuleSeverities>;
+}
+interface ProsebookConfig {
+  /** The source-language catalog: one `<area>.yaml` per area. */
+  catalog?: string;
+  /** Translations: `<locale>/<area>.yaml` or `<locale>.yaml`, holding `key: message`. */
+  locales?: string;
+  /** Where the generated modules go. */
+  out?: string;
+  /** Records which source text each translation was made from, so a changed source marks it stale. */
+  lock?: string;
+  /** The locale the catalog is written in. Its code is also the field holding the message. */
+  source?: string;
+  /**
+   * The syntax messages are written in: ICU MessageFormat (1) or Unicode MessageFormat 2. Source and
+   * translations alike; `prosebook migrate` rewrites a catalog from one to the other.
+   */
+  messageFormat?: 1 | 2;
+  /** Locales that ship in the main bundle beside the source, rather than loading when first used. */
+  bundled?: string[];
+  /** A pseudo-locale generated from the source (accented and lengthened) to find layout bugs and hardcoded text. */
+  pseudo?: string | false;
+  /** What a translation whose source changed since does: still show (`use`) or show the source (`fallback`). */
+  stale?: 'use' | 'fallback';
+  /** Generated modules as TypeScript or as JavaScript with a `.d.ts` beside the index. */
+  language?: 'ts' | 'js';
+  /** The extension generated imports name: `.js` suits most TypeScript setups, `.ts` suits Node's type stripping. */
+  importExtension?: '.js' | '.ts' | '';
+  /** The fields every entry must have. A shorthand `key: message` entry satisfies none of them. */
+  require?: ('context' | 'kind' | 'surface')[];
+  /** The kinds of string an entry may say it is, with the shape each one is held to. */
+  kinds?: Record<string, KindRule>;
+  /** Where a string may sit, with what each surface means. */
+  surfaces?: Record<string, string>;
+  lint?: LintConfig;
+  /** Where `prosebook scan` looks for hardcoded text and catalog keys. */
+  scan?: {
+    dirs?: string[];
+    extensions?: string[];
+    /** JSX attributes whose literal value a person reads. */
+    attributes?: string[];
+  };
+}
+interface ResolvedConfig {
+  root: string;
+  catalog: string;
+  locales: string;
+  out: string;
+  lock: string;
+  source: string;
+  messageFormat: 1 | 2;
+  bundled: string[];
+  pseudo: string | false;
+  stale: 'use' | 'fallback';
+  language: 'ts' | 'js';
+  importExtension: '.js' | '.ts' | '';
+  require: ('context' | 'kind' | 'surface')[];
+  kinds: Record<string, KindRule>;
+  surfaces: Record<string, string>;
+  lint: {
+    rules: Record<string, {
+      rule: CheckRule;
+      severity: Severity;
+    }>;
+    areas: Record<string, Record<string, Severity>>;
+  } & Required<WordLists>;
+  scan: {
+    dirs: string[];
+    extensions: string[];
+    attributes: string[];
+  };
+}
+/** Typed config, for `prosebook.config.ts`. */
+declare function defineConfig(config: ProsebookConfig): ProsebookConfig;
+declare const CONFIG_FILES: string[];
+/** Finds and reads the config at `root`, or the defaults when there is none. */
+declare function loadConfig(root: string, inline?: ProsebookConfig): Promise<ResolvedConfig>;
+declare function resolveConfig(root: string, config: ProsebookConfig): ResolvedConfig;
+export { sentences as A, EntryLocation as B, RuleContext as C, definePlugin as D, compileRule as E, KindRule as F, entryLocation as G, Message as H, STRICT_LISTS as I, whereOf as J, loadCatalog as K, Severity as L, words as M, DEFAULT_KINDS as N, lint as O, DEFAULT_SURFACES as P, Catalog as R, Rule as S, applyEdits as T, Problem as U, KEY_PATTERN as V, Translation as W, MessageFormatElement as Y, HOLE as _, WordLists as a, Readings as b, resolveConfig as c, CheckRule as d, ConditionalRule as f, Finding as g, ExistenceRule as h, ResolvedConfig as i, singularOf as j, phrase as k, CORE_RULES as l, Edit as m, LintConfig as n, defineConfig as o, CoreRule as p, previewOf as q, ProsebookConfig as r, loadConfig as s, CONFIG_FILES as t, CapitalizationRule as u, OccurrenceRule as v, SubstitutionRule as w, Report as x, Plugin as y, CatalogError as z };
+//# sourceMappingURL=config-_4HfnJQu.d.ts.map

package/dist/config-_4HfnJQu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-_4HfnJQu.d.ts","names":[],"sources":["../src/tools/catalog.ts","../src/tools/presets.ts","../src/tools/lint.ts","../src/tools/config.ts"],"mappings":"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"}

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+import { A as sentences, C as RuleContext, D as definePlugin, F as KindRule, L as Severity, M as words, S as Rule, _ as HOLE, a as WordLists, b as Readings, c as resolveConfig, d as CheckRule, f as ConditionalRule, h as ExistenceRule, i as ResolvedConfig, k as phrase, n as LintConfig, o as defineConfig, r as ProsebookConfig, s as loadConfig, t as CONFIG_FILES, u as CapitalizationRule, v as OccurrenceRule, w as SubstitutionRule, x as Report, y as Plugin } from "./config-_4HfnJQu.js";
+export { CONFIG_FILES, type CapitalizationRule, type CheckRule, type ConditionalRule, type ExistenceRule, HOLE, type KindRule, LintConfig, type OccurrenceRule, type Plugin, ProsebookConfig, type Readings, type Report, ResolvedConfig, type Rule, type RuleContext, type Severity, type SubstitutionRule, WordLists, defineConfig, definePlugin, loadConfig, phrase, resolveConfig, sentences, words };

package/dist/config.js

@@ -0,0 +1 @@
+export { t as CONFIG_FILES, l as HOLE, n as defineConfig, f as definePlugin, r as loadConfig, m as phrase, i as resolveConfig, h as sentences, _ as words } from "./config-D--RITk2.js";