@_linked/translation 0.9.3 → 0.9.5

package/src/message-format.ts

@@ -1,214 +0,0 @@
-import {
-  isArgumentElement,
-  isDateElement,
-  isNumberElement,
-  isPluralElement,
-  isSelectElement,
-  isTagElement,
-  isTimeElement,
-  parse,
-  type MessageFormatElement,
-} from '@formatjs/icu-messageformat-parser';
-import type { MessageFormat } from './core/messages.js';
-
-export type MessageArgumentKind =
-  | 'argument'
-  | 'number'
-  | 'date'
-  | 'time'
-  | 'select'
-  | 'plural'
-  | 'selectordinal';
-
-export interface MessageArgument {
-  name: string;
-  kinds: MessageArgumentKind[];
-}
-
-export interface MessageAnalysis {
-  valid: boolean;
-  arguments: MessageArgument[];
-  error?: string;
-}
-
-export interface MessageArgumentComparison {
-  valid: boolean;
-  missing: string[];
-  extra: string[];
-  typeMismatches: Array<{
-    name: string;
-    source: MessageArgumentKind[];
-    target: MessageArgumentKind[];
-  }>;
-  sourceError?: string;
-  targetError?: string;
-}
-
-export interface LegacyPluralSuffix {
-  countArgument: string;
-  suffixArgument: string;
-}
-
-/**
- * FormatSimple remains intentionally looser than ICU identifiers: existing
- * apps may use positional (`{0}`), dotted (`{user.name}`), hyphenated
- * (`{item-count}`), or Unicode (`{名前}`) variable names.
- */
-const SIMPLE_ARGUMENT_RE =
-  /\{\s*([\p{L}\p{N}_][\p{L}\p{N}\p{M}_.-]*)\s*\}/gu;
-
-function argumentKind(element: MessageFormatElement): MessageArgumentKind | null {
-  if (isArgumentElement(element)) return 'argument';
-  if (isNumberElement(element)) return 'number';
-  if (isDateElement(element)) return 'date';
-  if (isTimeElement(element)) return 'time';
-  if (isSelectElement(element)) return 'select';
-  if (isPluralElement(element)) {
-    return element.pluralType === 'ordinal' ? 'selectordinal' : 'plural';
-  }
-  return null;
-}
-
-function collectIcuArguments(
-  elements: MessageFormatElement[],
-  found: Map<string, Set<MessageArgumentKind>>,
-): void {
-  for (const element of elements) {
-    const kind = argumentKind(element);
-    if (kind && 'value' in element) {
-      const kinds = found.get(element.value) ?? new Set<MessageArgumentKind>();
-      kinds.add(kind);
-      found.set(element.value, kinds);
-    }
-    if (isPluralElement(element) || isSelectElement(element)) {
-      for (const option of Object.values(element.options)) {
-        collectIcuArguments(option.value, found);
-      }
-    } else if (isTagElement(element)) {
-      collectIcuArguments(element.children, found);
-    }
-  }
-}
-
-const toArguments = (
-  found: Map<string, Set<MessageArgumentKind>>,
-): MessageArgument[] =>
-  [...found.entries()]
-    .map(([name, kinds]) => ({ name, kinds: [...kinds].sort() }))
-    .sort((a, b) => a.name.localeCompare(b.name));
-
-/** Parse the variables a translator must preserve in a simple or ICU message. */
-export function analyzeMessage(
-  text: string,
-  format: MessageFormat = 'simple',
-): MessageAnalysis {
-  const found = new Map<string, Set<MessageArgumentKind>>();
-  if (format === 'simple') {
-    for (const match of text.matchAll(SIMPLE_ARGUMENT_RE)) {
-      found.set(match[1], new Set(['argument']));
-    }
-    return { valid: true, arguments: toArguments(found) };
-  }
-
-  try {
-    collectIcuArguments(
-      parse(text, { ignoreTag: true, requiresOtherClause: true }),
-      found,
-    );
-    return { valid: true, arguments: toArguments(found) };
-  } catch (cause) {
-    return {
-      valid: false,
-      arguments: [],
-      error: cause instanceof Error ? cause.message : String(cause),
-    };
-  }
-}
-
-/**
- * Compare runtime arguments without requiring identical word order or plural
- * categories. Categories legitimately differ by language; variable names and
- * their ICU roles may not.
- */
-export function compareMessageArguments(
-  source: string,
-  target: string,
-  format: MessageFormat = 'simple',
-): MessageArgumentComparison {
-  const sourceAnalysis = analyzeMessage(source, format);
-  const targetAnalysis = analyzeMessage(target, format);
-  const sourceByName = new Map(
-    sourceAnalysis.arguments.map((argument) => [argument.name, argument]),
-  );
-  const targetByName = new Map(
-    targetAnalysis.arguments.map((argument) => [argument.name, argument]),
-  );
-  const optionalLegacySuffixes =
-    format === 'simple'
-      ? new Set(
-          detectLegacyPluralSuffixes(source).map(
-            ({ suffixArgument }) => suffixArgument,
-          ),
-        )
-      : new Set<string>();
-  const missing = [...sourceByName.keys()]
-    .filter((name) => !targetByName.has(name) && !optionalLegacySuffixes.has(name))
-    .sort();
-  const extra = [...targetByName.keys()]
-    .filter((name) => !sourceByName.has(name))
-    .sort();
-  const typeMismatches = [...sourceByName.keys()]
-    .filter((name) => targetByName.has(name))
-    .flatMap((name) => {
-      const sourceKinds = sourceByName.get(name)!.kinds;
-      const targetKinds = targetByName.get(name)!.kinds;
-      return sourceKinds.length === targetKinds.length &&
-        sourceKinds.every((kind, index) => kind === targetKinds[index])
-        ? []
-        : [{ name, source: sourceKinds, target: targetKinds }];
-    });
-
-  return {
-    valid:
-      sourceAnalysis.valid &&
-      targetAnalysis.valid &&
-      missing.length === 0 &&
-      extra.length === 0 &&
-      typeMismatches.length === 0,
-    missing,
-    extra,
-    typeMismatches,
-    sourceError: sourceAnalysis.error,
-    targetError: targetAnalysis.error,
-  };
-}
-
-/**
- * Detect the legacy English suffix idiom (`{n} mission{s}`). `{s}` is not a
- * plural operator; callers merely pass either "s" or "". Other languages may
- * omit it, and the key should eventually be rewritten as an ICU plural.
- */
-export function detectLegacyPluralSuffixes(
-  text: string,
-): LegacyPluralSuffix[] {
-  const countArguments = [
-    ...text.matchAll(
-      /\{\s*([\p{L}\p{N}_][\p{L}\p{N}\p{M}_.-]*)\s*\}/gu,
-    ),
-  ].map((match) => match[1]);
-  if (countArguments.length < 2) return [];
-  const suffixes = [
-    ...text.matchAll(
-      /[\p{L}\p{N}]\{\s*([\p{L}\p{N}_][\p{L}\p{N}\p{M}_.-]*)\s*\}/gu,
-    ),
-  ].map((match) => match[1]);
-  if (suffixes.length === 0) return [];
-  const countArgument = countArguments.find(
-    (name) => !suffixes.includes(name),
-  );
-  if (!countArgument) return [];
-  return [...new Set(suffixes)].map((suffixArgument) => ({
-    countArgument,
-    suffixArgument,
-  }));
-}

package/src/mt.ts

@@ -1,253 +0,0 @@
-/**
- * Machine-translation provider registry (Plan 014 AD-L / Plan 017 Slice B).
- * Providers implement one method — translate a batch of UI strings — and
- * register by key ('claude', 'deepl', …). Resolution is PER TARGET LANGUAGE
- * with a fallback chain: not every provider covers every language (DeepL has
- * no Swahili or Urdu), so the preferred provider is used where it supports
- * the target and the chain falls through otherwise. Pure module: no I/O, no
- * SDK imports — concrete providers live with the host application and are
- * registered at boot.
- */
-import { sharedState } from '@_linked/core/utils/sharedState';
-import {
-  analyzeMessage,
-  compareMessageArguments,
-} from './message-format.js';
-import type { MessageFormat } from './core/messages.js';
-
-export interface MtItem {
-  key: string;
-  sourceText: string;
-  /** Authoring context shown to the translator/model. */
-  description?: string;
-  format?: 'simple' | 'icu';
-}
-
-export interface MtGlossaryEntry {
-  term: string;
-  /** prefer (default) = translate as `translation`; keep = do-not-translate; forbid = never use. */
-  termType?: 'prefer' | 'require' | 'keep' | 'forbid';
-  /** Preferred translation (prefer entries); empty/undefined = keep the term as-is. */
-  translation?: string;
-  /** Replacement wording (forbid entries). */
-  useInstead?: string;
-  /** Target language this applies to; empty = all languages. */
-  language?: string;
-  /** Exact-casing matching (proper nouns / brand styling). */
-  caseSensitive?: boolean;
-  description?: string;
-}
-
-/** Register/tone controls (Plan 017 §7.4b) — NOT sampling temperature. */
-export interface MtStyle {
-  formality?: 'formal' | 'informal';
-  /** Free-text tone guidance, e.g. "friendly, energetic, no bureaucratese". */
-  note?: string;
-}
-
-/** An established translation the provider should stay consistent with. */
-export interface MtReference {
-  sourceText: string;
-  text: string;
-}
-
-export interface MtBatchRequest {
-  sourceLanguage: string;
-  targetLanguage: string;
-  items: MtItem[];
-  glossary: MtGlossaryEntry[];
-  style?: MtStyle;
-  /** Translation-memory context: reviewed units for consistency (Plan 017 §7.4c). */
-  references?: MtReference[];
-}
-
-export interface MtBatchResult {
-  key: string;
-  text: string;
-}
-
-export interface TranslationMtProvider {
-  readonly key: string;
-  /** Absent ⇒ the provider claims every language. */
-  supportsLanguage?(language: string): boolean;
-  translateBatch(request: MtBatchRequest): Promise<MtBatchResult[]>;
-}
-
-// On globalThis so a provider the host registers on one copy of this module is found by
-// another copy.
-const { providers } = sharedState('@_linked/translation', 'mt', () => ({
-  providers: new Map<string, TranslationMtProvider>(),
-}));
-
-export function registerMtProvider(provider: TranslationMtProvider): void {
-  providers.set(provider.key, provider);
-}
-
-export function getMtProvider(key: string): TranslationMtProvider | undefined {
-  return providers.get(key);
-}
-
-export function listMtProviders(): TranslationMtProvider[] {
-  return [...providers.values()];
-}
-
-/** Test seam. */
-export function clearMtProviders(): void {
-  providers.clear();
-}
-
-/**
- * Ordered provider chain for one target language: the preferred provider
- * first when it exists AND supports the language, then every other provider
- * that supports it, registration order.
- */
-export function resolveMtProviders(
-  targetLanguage: string,
-  preferred?: string,
-): TranslationMtProvider[] {
-  const supports = (p: TranslationMtProvider) =>
-    !p.supportsLanguage || p.supportsLanguage(targetLanguage);
-  const chain = listMtProviders().filter(supports);
-  if (!preferred) return chain;
-  const first = chain.find((p) => p.key === preferred);
-  if (!first) return chain;
-  return [first, ...chain.filter((p) => p !== first)];
-}
-
-/** Unique `{placeholder}` tokens in a message, sorted for set comparison. */
-export function extractPlaceholders(
-  text: string,
-  format: MessageFormat = 'simple',
-): string[] {
-  return analyzeMessage(text, format).arguments.map(({ name }) => name);
-}
-
-/**
- * A translation is only usable if it preserves the source's placeholder SET
- * exactly — a dropped or renamed `{param}` breaks interpolation at runtime.
- */
-export function placeholdersIntact(
-  source: string,
-  translated: string,
-  format: MessageFormat = 'simple',
-): boolean {
-  return compareMessageArguments(source, translated, format).valid;
-}
-
-/** Glossary entries applying to one target language (global + language-specific). */
-export function glossaryForLanguage(
-  glossary: MtGlossaryEntry[],
-  language: string,
-): MtGlossaryEntry[] {
-  return glossary.filter((g) => !g.language || g.language === language);
-}
-
-export function chunkItems<T>(items: T[], size: number): T[][] {
-  if (size < 1) throw new Error('chunk size must be >= 1');
-  const chunks: T[][] = [];
-  for (let i = 0; i < items.length; i += size) chunks.push(items.slice(i, i + size));
-  return chunks;
-}
-
-/**
- * Resolve the formality for one language from the encoded config entries
- * ("formal" = app default; "de:informal" = per-language override; override wins).
- */
-export function formalityForLanguage(
-  entries: string[],
-  language: string,
-): 'formal' | 'informal' | undefined {
-  let result: 'formal' | 'informal' | undefined;
-  for (const entry of entries ?? []) {
-    const i = entry.indexOf(':');
-    const value = i === -1 ? entry : entry.slice(i + 1);
-    if (value !== 'formal' && value !== 'informal') continue;
-    if (i === -1) {
-      if (!result) result = value;
-    } else if (entry.slice(0, i) === language) {
-      return value;
-    }
-  }
-  return result;
-}
-
-// ── Consistency (Plan 017 §7.4c) ────────────────────────────────────────
-
-/** Minimal entry view the consistency helpers need (client-safe). */
-export interface ConsistencyEntry {
-  key: string;
-  namespace?: string;
-  sourceText: string;
-  format?: 'simple' | 'icu';
-  units: Record<string, { text: string; state: string } | undefined>;
-}
-
-/** Identical English source translated DIFFERENTLY within one language. */
-export interface ConsistencyConflict {
-  sourceText: string;
-  language: string;
-  /** One entry per distinct translation: the text + the keys carrying it. */
-  variants: Array<{ text: string; keys: string[] }>;
-}
-
-/**
- * Find keys whose IDENTICAL source text has diverging translations in a
- * language — the core "same words, same translation" consistency check.
- * Empty/untranslated units are ignored; whitespace-trimmed comparison.
- */
-export function findInconsistentTranslations(
-  entries: ConsistencyEntry[],
-  language: string,
-): ConsistencyConflict[] {
-  const bySource = new Map<string, Map<string, string[]>>();
-  for (const entry of entries) {
-    const source = entry.sourceText.trim();
-    const text = entry.units[language]?.text?.trim();
-    if (!source || !text) continue;
-    const variants = bySource.get(source) ?? new Map<string, string[]>();
-    variants.set(text, [...(variants.get(text) ?? []), entry.key]);
-    bySource.set(source, variants);
-  }
-  const conflicts: ConsistencyConflict[] = [];
-  for (const [sourceText, variants] of bySource) {
-    if (variants.size < 2) continue;
-    conflicts.push({
-      sourceText,
-      language,
-      variants: [...variants].map(([text, keys]) => ({ text, keys: keys.sort() })),
-    });
-  }
-  return conflicts.sort((a, b) => a.sourceText.localeCompare(b.sourceText));
-}
-
-/**
- * Pick reviewed units as translation-memory REFERENCES for an MT batch:
- * same-namespace reviewed translations first (shared vocabulary), then the
- * shortest reviewed units overall (vocabulary-dense). Deterministic.
- */
-export function pickReferenceUnits(
-  entries: ConsistencyEntry[],
-  language: string,
-  batchNamespaces: string[],
-  max = 20,
-): MtReference[] {
-  const namespaces = new Set(batchNamespaces);
-  const reviewed = entries
-    .map((entry) => ({
-      namespace: entry.namespace ?? '',
-      sourceText: entry.sourceText.trim(),
-      unit: entry.units[language],
-    }))
-    .filter(
-      (row) =>
-        row.sourceText &&
-        row.unit?.state === 'reviewed' &&
-        row.unit.text.trim(),
-    );
-  const score = (row: (typeof reviewed)[number]) =>
-    (namespaces.has(row.namespace) ? 0 : 100000) + row.sourceText.length;
-  return reviewed
-    .sort((a, b) => score(a) - score(b) || a.sourceText.localeCompare(b.sourceText))
-    .slice(0, max)
-    .map((row) => ({ sourceText: row.sourceText, text: row.unit!.text.trim() }));
-}

package/src/ontologies/translation.register.ts

@@ -1,17 +0,0 @@
-/**
- * Registers this ontology.
- *
- * Kept out of `translation.ts` because registration needs that module's whole export
- * namespace, and a module cannot import itself once a bundler is involved: Rollup
- * treats a static self-reference as a circular import and elides it, so the binding is
- * undefined at runtime and the consuming app dies at boot with `_this is not
- * defined`. `tsc` preserves it, which is why the pattern survived for as long as
- * packages were built with `tsc` alone.
- *
- * From a sibling module the same import is ordinary and survives.
- */
-import * as terms from './translation.js';
-import {dataFiles, loadData, ns} from './translation.js';
-import {linkedOntology} from '../package.js';
-
-linkedOntology(terms, ns, 'translation', loadData, dataFiles);