@cliff-format/i18n 0.0.0-stage → 0.2.0

package/dist/types-CtbwKSot.d.ts

@@ -0,0 +1,462 @@
+import { CliffDocument, CliffGroup, ValidationIssue, Correction, CliffEntry, ParseOptions } from '@cliff-format/core';
+
+interface EntryIdCatalogContext {
+    readonly knownNamespaces: ReadonlySet<string>;
+    readonly knownClans: ReadonlySet<string>;
+    readonly defaultGroup: string;
+    readonly aliases: Readonly<Record<string, string>>;
+    hasCanonical(canonical: string): boolean;
+    recordForCanonical(canonical: string): MessageRecord | undefined;
+    suffixMatches(suffix: string): readonly string[];
+}
+declare function joinCanonical(namespace: string, clan: string, group: string, id: string): string;
+declare function assertScope(scope: TranslationScope): void;
+declare function resolveEntryId(input: EntryIdInput, scope: TranslationScope, context: EntryIdCatalogContext, strictEntryIds?: boolean): ResolvedEntryId;
+
+interface CatalogOptions {
+    aliases?: Readonly<Record<string, string>>;
+    defaultGroup?: string;
+}
+declare class Catalog implements EntryIdCatalogContext {
+    readonly defaultGroup: string;
+    readonly aliases: Readonly<Record<string, string>>;
+    private readonly documentsList;
+    private readonly byLocale;
+    private readonly byCanonical;
+    private readonly suffixMap;
+    private readonly namespaceSet;
+    private readonly clanSet;
+    private readonly groupSet;
+    private readonly localeSet;
+    private readonly sourceLanguageSet;
+    constructor(options?: CatalogOptions);
+    get knownNamespaces(): ReadonlySet<string>;
+    get knownClans(): ReadonlySet<string>;
+    get documents(): readonly CliffDocument[];
+    get sourceLanguages(): readonly string[];
+    addDocument(document: CliffDocument): MessageRecord[];
+    addDraft(parts: {
+        namespace: string;
+        clan: string;
+        group: string;
+        id: string;
+        sourceLanguage: string;
+        targetLanguage: string;
+    }, draft: TranslatedDraft): MessageRecord;
+    private ensureDocument;
+    private indexRecord;
+    hasCanonical(canonical: string): boolean;
+    recordForCanonical(canonical: string): MessageRecord | undefined;
+    recordsForCanonical(canonical: string): readonly MessageRecord[];
+    suffixMatches(suffix: string): readonly string[];
+    record(canonical: string, locale: string): MessageRecord | undefined;
+    selectRecord(canonical: string, localeChain: readonly string[], sourceLanguage?: string): MessageRecord | undefined;
+    localeChain(locale: string, fallbacks?: readonly string[], sourceLanguage?: string): string[];
+    namespaces(): string[];
+    clans(namespace?: string): string[];
+    groups(scope?: Partial<TranslationScope>): string[];
+    entryIds(scope?: Partial<TranslationScope>): string[];
+    allRecords(): MessageRecord[];
+    query(options?: EntryQuery): MessageRecord[];
+    untranslated(options?: Omit<EntryQuery, "status" | "target">): MessageRecord[];
+    byStatus(status: StatusTag, options?: Omit<EntryQuery, "status">): MessageRecord[];
+    statusCounts(options?: Omit<EntryQuery, "status">): StatusCounts;
+    locales(): string[];
+    findGroup(namespace: string, clan: string, groupPath: string): CliffGroup | undefined;
+    files(options?: FileOptions): CliffFile[];
+    toCliff(options?: FileOptions): string;
+    validate(): ValidationIssue[];
+}
+declare function assertCatalogParts(parts: {
+    namespace: string;
+    clan: string;
+    group: string;
+    id: string;
+}): void;
+
+type IcuDialect = "plain" | "mf1" | "mf2";
+interface IcuError {
+    type: string;
+    message: string;
+    source?: string;
+}
+type MessagePart = {
+    type: "literal";
+    value: string;
+} | {
+    type: "expression";
+    source: string;
+    value: string;
+    locale?: string;
+} | {
+    type: "markup";
+    kind: "open" | "close" | "standalone";
+    name: string;
+    source: string;
+};
+interface IcuFormatResult {
+    text: string;
+    errors: IcuError[];
+}
+interface IcuPartsResult {
+    parts: MessagePart[];
+    errors: IcuError[];
+}
+interface IcuAnalysis {
+    dialect: IcuDialect;
+    arguments: string[];
+    errors: IcuError[];
+}
+interface IcuFormatOptions {
+    currency?: string;
+    timeZone?: string;
+}
+interface IcuRuntime {
+    format(message: string, locale: string, values: Record<string, unknown>, options?: IcuFormatOptions): IcuFormatResult;
+    formatToParts(message: string, locale: string, values: Record<string, unknown>, options?: IcuFormatOptions): IcuPartsResult;
+    analyze(message: string): IcuAnalysis;
+}
+
+declare const TYPE: {
+    readonly noun: "noun";
+    readonly verb: "verb";
+    readonly adjective: "adjective";
+    readonly adverb: "adverb";
+    readonly pronoun: "pronoun";
+    readonly numeral: "numeral";
+    readonly preposition: "preposition";
+    readonly conjunction: "conjunction";
+    readonly particle: "particle";
+    readonly interjection: "interjection";
+    readonly "proper-noun": "proper-noun";
+    readonly "noun-phrase": "noun-phrase";
+    readonly "verb-phrase": "verb-phrase";
+    readonly "adjective-phrase": "adjective-phrase";
+    readonly "adverb-phrase": "adverb-phrase";
+    readonly "fixed-phrase": "fixed-phrase";
+    readonly idiom: "idiom";
+    readonly sentence: "sentence";
+    readonly description: "description";
+    readonly narration: "narration";
+    readonly dialogue: "dialogue";
+    readonly monologue: "monologue";
+    readonly prompt: "prompt";
+    readonly label: "label";
+    readonly subtitle: "subtitle";
+    readonly "accessibility-cue": "accessibility-cue";
+};
+type TypeTag = (typeof TYPE)[keyof typeof TYPE];
+declare const EMOTION: {
+    readonly neutral: "neutral";
+    readonly objective: "objective";
+    readonly mechanical: "mechanical";
+    readonly joyful: "joyful";
+    readonly sad: "sad";
+    readonly angry: "angry";
+    readonly fearful: "fearful";
+    readonly surprised: "surprised";
+    readonly curious: "curious";
+    readonly disgusted: "disgusted";
+    readonly anxious: "anxious";
+    readonly calm: "calm";
+    readonly playful: "playful";
+    readonly serious: "serious";
+    readonly urgent: "urgent";
+    readonly romantic: "romantic";
+    readonly hopeful: "hopeful";
+    readonly grateful: "grateful";
+    readonly formal: "formal";
+    readonly informal: "informal";
+    readonly polite: "polite";
+    readonly rude: "rude";
+    readonly nostalgic: "nostalgic";
+};
+type EmotionTag = (typeof EMOTION)[keyof typeof EMOTION];
+declare const STATUS: {
+    readonly initial: "initial";
+    readonly translated: "translated";
+    readonly reviewed: "reviewed";
+    readonly final: "final";
+};
+type StatusTag = (typeof STATUS)[keyof typeof STATUS];
+declare const VARIANT: {
+    readonly standard: "standard";
+    readonly glossary: "glossary";
+};
+type VariantTag = (typeof VARIANT)[keyof typeof VARIANT];
+declare const STATUS_ORDER: readonly ["initial", "translated", "reviewed", "final"];
+type Params = Record<string, unknown>;
+type EntryIdOf<EntryIds extends string> = string extends EntryIds ? string : EntryIds | (string & {});
+type CliffResource = string | Uint8Array | CliffDocument;
+interface TranslationScope {
+    namespace: string;
+    clan: string;
+    group?: string;
+}
+type EntryIdInput = string | {
+    namespace?: string;
+    clan?: string;
+    group?: string;
+    id: string;
+};
+interface EntryQuery {
+    namespace?: string;
+    clan?: string;
+    group?: string;
+    locale?: string | "all";
+    status?: StatusTag | readonly StatusTag[];
+    target?: "any" | "present" | "missing";
+}
+type StatusCounts = Record<StatusTag, number>;
+interface ResolvedEntryId {
+    namespace: string;
+    clan: string;
+    group: string;
+    id: string;
+    canonical: string;
+    exists: boolean;
+    ambiguous?: boolean;
+    candidates?: readonly string[];
+}
+interface MessageRecord {
+    canonical: string;
+    namespace: string;
+    clan: string;
+    group: string;
+    id: string;
+    locale: string;
+    sourceLanguage: string;
+    document: CliffDocument;
+    groupRef: CliffGroup;
+    entry: CliffEntry;
+    variant: string;
+    source: string;
+    target?: string;
+    type?: string;
+    emotion: string[];
+    status?: string;
+    context?: string;
+    maxWidth?: number;
+    reference: string[];
+    reviewer?: string;
+    extensions: Record<string, string>;
+    filePath?: string;
+}
+interface MessageMetadata {
+    entryId: string;
+    namespace: string;
+    clan: string;
+    group: string;
+    id: string;
+    locale: string;
+    sourceLanguage: string;
+    targetLanguage: string;
+    variant: string;
+    source: string;
+    target?: string;
+    type?: string;
+    emotion: string[];
+    status?: string;
+    context?: string;
+    maxWidth?: number;
+    reference: string[];
+    reviewer?: string;
+    extensions: Record<string, string>;
+}
+interface MessageState {
+    source: boolean;
+    type: boolean;
+}
+type RenderMethod<S extends MessageState> = S["source"] extends true ? S["type"] extends true ? (params?: Params) => string : never : (params?: Params) => string;
+type RenderPartsMethod<S extends MessageState> = S["source"] extends true ? S["type"] extends true ? (params?: Params) => MessagePart[] : never : (params?: Params) => MessagePart[];
+interface CommitOptions {
+    overwrite?: boolean;
+    validate?: boolean;
+}
+interface MessageBuilder<S extends MessageState = {
+    source: false;
+    type: false;
+}> {
+    source(text: string, params?: Params): MessageBuilder<{
+        source: true;
+        type: S["type"];
+    }>;
+    type(tag: TypeTag): MessageBuilder<{
+        source: S["source"];
+        type: true;
+    }>;
+    typeFromGroup: S extends {
+        source: true;
+        type: false;
+    } ? () => MessageBuilder<{
+        source: true;
+        type: true;
+    }> : never;
+    emotion(...tags: readonly (EmotionTag | readonly EmotionTag[])[]): MessageBuilder<S>;
+    context(text: string): MessageBuilder<S>;
+    maxWidth(cells: number): MessageBuilder<S>;
+    reference(...paths: string[]): MessageBuilder<S>;
+    reviewer(name: string): MessageBuilder<S>;
+    extension(name: string, value: string): MessageBuilder<S>;
+    target(text: string, params?: Params): MessageBuilder<S>;
+    status(tag: StatusTag): MessageBuilder<S>;
+    locale(tag: string): MessageBuilder<S>;
+    params(params: Params): MessageBuilder<S>;
+    count(value: number): MessageBuilder<S>;
+    render: RenderMethod<S>;
+    renderToParts: RenderPartsMethod<S>;
+    commit: S extends {
+        source: true;
+        type: true;
+    } ? (options?: CommitOptions) => MessageBuilder<S> : never;
+    meta(): MessageMetadata;
+    entry(): CliffEntry | undefined;
+    width(params?: Params): number;
+    fits(params?: Params): boolean;
+    toString(): string;
+}
+interface TFunction<EntryIds extends string = string> {
+    (entryId: EntryIdOf<EntryIds>): MessageBuilder<{
+        source: false;
+        type: false;
+    }>;
+    (entryId: EntryIdOf<EntryIds>, params: Params): string;
+    render(entryId: EntryIdOf<EntryIds>, params?: Params): string;
+    renderToParts(entryId: EntryIdOf<EntryIds>, params?: Params): MessagePart[];
+    has(entryId: EntryIdOf<EntryIds>): boolean;
+    entry(entryId: EntryIdOf<EntryIds>): CliffEntry | undefined;
+    meta(entryId: EntryIdOf<EntryIds>): MessageMetadata | undefined;
+    entryIds(): string[];
+}
+interface ScopedI18n<EntryIds extends string = string> {
+    readonly t: TFunction<EntryIds>;
+    readonly scope: TranslationScope;
+}
+type MissingBehavior = "entryId" | "empty" | "throw" | "source";
+type WidthPolicy = "off" | "warn" | "error";
+type DiagnosticSeverity = "error" | "warning" | "info";
+interface I18nDiagnostic {
+    code: string;
+    severity: DiagnosticSeverity;
+    message: string;
+    entryId?: string;
+    locale?: string;
+    namespace?: string;
+    clan?: string;
+    group?: string;
+    line?: number;
+    details?: Record<string, unknown>;
+}
+interface I18nOptions {
+    locale: string;
+    fallbackLocale?: string | readonly string[];
+    resources?: readonly CliffResource[];
+    sourceLanguage?: string;
+    defaultGroup?: string;
+    params?: Params;
+    aliases?: Readonly<Record<string, string>>;
+    missing?: MissingBehavior;
+    strictEntryIds?: boolean;
+    requireEmotion?: boolean | readonly TypeTag[];
+    enforceMaxWidth?: WidthPolicy;
+    icu?: IcuRuntime;
+    parse?: ParseOptions;
+    onDiagnostic?: (diagnostic: I18nDiagnostic) => void;
+    maxDiagnostics?: number;
+}
+interface TranslatedDraft {
+    source?: string;
+    target?: string;
+    type?: string;
+    emotion?: readonly string[];
+    status?: string;
+    context?: string;
+    maxWidth?: number;
+    reference?: readonly string[];
+    reviewer?: string;
+    extensions?: Record<string, string>;
+}
+interface AddOptions {
+    sourcePath?: string;
+    tolerant?: boolean;
+    validate?: boolean;
+}
+interface AddResult {
+    documents: readonly CliffDocument[];
+    issues: readonly ValidationIssue[];
+    corrections: readonly Correction[];
+}
+interface FileOptions {
+    layout?: "folder" | "flat";
+}
+interface CliffFile {
+    filePath: string;
+    namespace: string;
+    clan: string;
+    locale: string;
+    text: string;
+    document: CliffDocument;
+}
+interface I18n<EntryIds extends string = string> {
+    readonly locale: string;
+    readonly language: string;
+    readonly sourceLanguage: string | undefined;
+    getLocale(): string;
+    setLocale(locale: string): void;
+    changeLanguage(locale: string): void;
+    getVersion(): number;
+    subscribe(listener: () => void): () => void;
+    scope(scope: TranslationScope): ScopedI18n<EntryIds>;
+    add(resource: CliffResource, options?: AddOptions): AddResult;
+    addDocument(document: CliffDocument, options?: AddOptions): AddResult;
+    has(entryId: EntryIdOf<EntryIds> | Exclude<EntryIdInput, string>, scope: TranslationScope): boolean;
+    resolve(entryId: EntryIdOf<EntryIds> | Exclude<EntryIdInput, string>, scope: TranslationScope): ResolvedEntryId;
+    entryIds(scope?: Partial<TranslationScope>): string[];
+    query(options?: EntryQuery): MessageRecord[];
+    untranslated(options?: Omit<EntryQuery, "status" | "target">): MessageRecord[];
+    byStatus(status: StatusTag, options?: Omit<EntryQuery, "status">): MessageRecord[];
+    statusCounts(options?: Omit<EntryQuery, "status">): StatusCounts;
+    namespaces(): string[];
+    clans(namespace?: string): string[];
+    groups(scope?: Partial<TranslationScope>): string[];
+    locales(): string[];
+    files(options?: FileOptions): CliffFile[];
+    toCliff(options?: FileOptions): string;
+    validate(): ValidationIssue[];
+    diagnostics(): readonly I18nDiagnostic[];
+    clearDiagnostics(): void;
+    format(message: string, params?: Params, options?: {
+        locale?: string;
+        currency?: string;
+        timeZone?: string;
+    }): string;
+    formatToParts(message: string, params?: Params, options?: {
+        locale?: string;
+        currency?: string;
+        timeZone?: string;
+    }): MessagePart[];
+}
+interface I18nRuntime {
+    resolve(entryId: EntryIdInput, scope: TranslationScope): ResolvedEntryId;
+    recordFor(canonical: string, locale: string): MessageRecord | undefined;
+    format(message: string, params: Params, options: {
+        locale: string;
+        currency?: string;
+        timeZone?: string;
+    }): string;
+    formatToParts(message: string, params: Params, options: {
+        locale: string;
+        currency?: string;
+        timeZone?: string;
+    }): MessagePart[];
+    diagnose(diagnostic: I18nDiagnostic): void;
+    getSourceLanguage(): string;
+    getLocale(): string;
+    getCatalog(): Catalog;
+    readonly defaultParams: Params;
+    readonly missing: MissingBehavior;
+    readonly requireEmotion: boolean | readonly TypeTag[];
+    readonly enforceMaxWidth: WidthPolicy;
+}
+
+export { type AddOptions as A, type ResolvedEntryId as B, Catalog as C, type DiagnosticSeverity as D, EMOTION as E, type FileOptions as F, STATUS_ORDER as G, type ScopedI18n as H, type I18nOptions as I, type StatusCounts as J, type StatusTag as K, TYPE as L, type MessageBuilder as M, type TranslatedDraft as N, type TranslationScope as O, type Params as P, type TypeTag as Q, type RenderMethod as R, STATUS as S, type TFunction as T, type VariantTag as U, VARIANT as V, type WidthPolicy as W, assertCatalogParts as X, assertScope as Y, joinCanonical as Z, resolveEntryId as _, type I18n as a, type IcuRuntime as b, type AddResult as c, type CatalogOptions as d, type CliffFile as e, type CliffResource as f, type CommitOptions as g, type EmotionTag as h, type EntryIdCatalogContext as i, type EntryIdInput as j, type EntryIdOf as k, type EntryQuery as l, type I18nDiagnostic as m, type I18nRuntime as n, type IcuAnalysis as o, type IcuDialect as p, type IcuError as q, type IcuFormatOptions as r, type IcuFormatResult as s, type IcuPartsResult as t, type MessageMetadata as u, type MessagePart as v, type MessageRecord as w, type MessageState as x, type MissingBehavior as y, type RenderPartsMethod as z };

package/dist/vocabulary-riKZ5HrX.d.ts

@@ -0,0 +1,135 @@
+import { p as IcuDialect, o as IcuAnalysis, b as IcuRuntime, n as I18nRuntime, O as TranslationScope, j as EntryIdInput, P as Params, Q as TypeTag, h as EmotionTag, K as StatusTag, v as MessagePart, u as MessageMetadata, g as CommitOptions, T as TFunction, U as VariantTag } from './types-CtbwKSot.js';
+import { CliffEntry } from '@cliff-format/core';
+
+declare function detectDialect(message: string): IcuDialect;
+declare function argumentNames(message: string, dialect: IcuDialect): string[];
+declare function analyzePlain(message: string, dialect: IcuDialect, errors?: IcuAnalysis["errors"]): IcuAnalysis;
+
+declare function createLiteIcu(): IcuRuntime;
+
+declare class MessageBuilderImpl {
+    private readonly i18n;
+    private readonly scope;
+    private readonly entryIdInput;
+    private sourceText;
+    private sourceParams;
+    private targetText;
+    private targetParams;
+    private extraParams;
+    private typeTag;
+    private inheritType;
+    private emotionTags;
+    private statusTag;
+    private contextText;
+    private maxWidthCells;
+    private referencePaths;
+    private reviewerName;
+    private extensionMap;
+    private localeOverride;
+    constructor(i18n: I18nRuntime, scope: TranslationScope, entryIdInput: EntryIdInput);
+    source(text: string, params?: Params): MessageBuilderImpl;
+    type(tag: TypeTag): MessageBuilderImpl;
+    typeFromGroup(): MessageBuilderImpl;
+    emotion(...tags: readonly (EmotionTag | readonly EmotionTag[])[]): MessageBuilderImpl;
+    context(text: string): MessageBuilderImpl;
+    maxWidth(cells: number): MessageBuilderImpl;
+    reference(...paths: string[]): MessageBuilderImpl;
+    reviewer(name: string): MessageBuilderImpl;
+    extension(name: string, value: string): MessageBuilderImpl;
+    target(text: string, params?: Params): MessageBuilderImpl;
+    status(tag: StatusTag): MessageBuilderImpl;
+    locale(tag: string): MessageBuilderImpl;
+    params(params: Params): MessageBuilderImpl;
+    count(value: number): MessageBuilderImpl;
+    private activeLocale;
+    private resolved;
+    private recordFor;
+    private mergedParams;
+    private diagnose;
+    private requireEffectiveType;
+    private ensureAuthoringMetadata;
+    private groupEmotion;
+    private requireEmotionIfConfigured;
+    private createDraft;
+    private checkWidth;
+    private renderRecord;
+    private expectationDiagnostics;
+    private missing;
+    render(params?: Params): string;
+    renderToParts(params?: Params): MessagePart[];
+    meta(): MessageMetadata;
+    entry(): CliffEntry | undefined;
+    commit(options?: CommitOptions): MessageBuilderImpl;
+    private applyOverwrite;
+    private validateDocument;
+    width(params?: Params): number;
+    fits(params?: Params): boolean;
+    toString(): string;
+}
+declare function createT<EntryIds extends string = string>(i18n: I18nRuntime, scope: TranslationScope): TFunction<EntryIds>;
+
+declare class CliffI18nError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+declare class CliffScopeError extends CliffI18nError {
+    readonly scope: Partial<TranslationScope>;
+    constructor(message: string, scope?: Partial<TranslationScope>);
+}
+declare class CliffScopeMismatchError extends CliffScopeError {
+    readonly entryId: string;
+    constructor(entryId: string, scope: TranslationScope, expected: string);
+}
+declare class CliffMissingEntryError extends CliffI18nError {
+    readonly entryId: string;
+    readonly locale: string;
+    constructor(entryId: string, locale: string);
+}
+declare class CliffAmbiguousEntryError extends CliffI18nError {
+    readonly entryId: string;
+    readonly candidates: readonly string[];
+    constructor(entryId: string, candidates: readonly string[]);
+}
+declare class CliffDuplicateEntryError extends CliffI18nError {
+    readonly entryId: string;
+    readonly locale: string;
+    constructor(entryId: string, locale: string);
+}
+declare class CliffMissingMetadataError extends CliffI18nError {
+    readonly entryId: string;
+    readonly fields: readonly string[];
+    constructor(entryId: string, fields: readonly string[], detail?: string);
+}
+declare class CliffIcuError extends CliffI18nError {
+    readonly messageText: string;
+    constructor(messageText: string, detail: string);
+}
+
+declare const STATUS_TRANSITIONS: Record<StatusTag, readonly StatusTag[]>;
+declare function statusOf(entry: CliffEntry): StatusTag;
+declare function canTransitionStatus(from: StatusTag, to: StatusTag): boolean;
+interface StatusContext {
+    source?: string;
+    target?: string;
+    explicit?: StatusTag;
+}
+/**
+ * Return the status a write should leave on an entry.
+ * An explicit status wins. Otherwise a missing target is initial, and a changed
+ * source or reworked reviewed/final target returns to translated.
+ */
+declare function reconcileEntryStatus(entry: CliffEntry, previous?: StatusContext): StatusTag;
+declare function nextStatuses(status: StatusTag): readonly StatusTag[];
+declare function statusOrder(): readonly StatusTag[];
+
+declare function isTypeTag(value: string): value is TypeTag;
+declare function isEmotionTag(value: string): value is EmotionTag;
+declare function isStatusTag(value: string): value is StatusTag;
+declare function isVariantTag(value: string): value is VariantTag;
+declare function assertTypeTag(value: string): TypeTag;
+declare function assertEmotionTag(value: string): EmotionTag;
+declare function assertStatusTag(value: string): StatusTag;
+declare function assertVariantTag(value: string): VariantTag;
+
+export { CliffAmbiguousEntryError as C, MessageBuilderImpl as M, STATUS_TRANSITIONS as S, CliffDuplicateEntryError as a, CliffI18nError as b, CliffIcuError as c, CliffMissingEntryError as d, CliffMissingMetadataError as e, CliffScopeError as f, CliffScopeMismatchError as g, type StatusContext as h, analyzePlain as i, argumentNames as j, assertEmotionTag as k, assertStatusTag as l, assertTypeTag as m, assertVariantTag as n, canTransitionStatus as o, createLiteIcu as p, createT as q, detectDialect as r, isEmotionTag as s, isStatusTag as t, isTypeTag as u, isVariantTag as v, nextStatuses as w, reconcileEntryStatus as x, statusOf as y, statusOrder as z };