@xndrjs/i18n 0.8.0 → 0.8.2-alpha.0

package/src/validation/normalize.ts

@@ -1,299 +0,0 @@
-import { mergeVariableMetaAcrossLocales, type VariableMetaSpec } from "../icu/extract-variables.js";
-import { parseTemplate } from "../icu/parse-template.js";
-import type { VariableSpec } from "../icu/extract-variables.js";
-import type {
-  DictionarySpec,
-  NormalizedDictionary,
-  NormalizedKeyDictionary,
-  ParsedKeyEntry,
-  ValidationIssue,
-  ValidationResult,
-} from "./types.js";
-
-function failure(issues: ValidationIssue[]): ValidationResult<NormalizedDictionary> {
-  return { ok: false, issues };
-}
-
-function success(data: NormalizedDictionary): ValidationResult<NormalizedDictionary> {
-  return { ok: true, data };
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function normalizeSingleKey(
-  key: string,
-  keyValue: Record<string, unknown>,
-  keyPathPrefix: readonly string[]
-): { entry: ParsedKeyEntry; issues: ValidationIssue[] } {
-  const issues: ValidationIssue[] = [];
-  const locales: Record<string, ParsedKeyEntry["locales"][string]> = {};
-  const localeMetas: VariableMetaSpec[] = [];
-  let mergedArgs: ParsedKeyEntry["mergedArgs"] = {};
-  let localeArgsMismatch: ValidationIssue | undefined;
-
-  for (const [locale, template] of Object.entries(keyValue)) {
-    const localePath = [...keyPathPrefix, key, locale];
-
-    if (typeof template !== "string") {
-      issues.push({
-        kind: "invalid_locale_value",
-        path: localePath,
-        message: `expected string, got ${typeof template}`,
-      });
-      continue;
-    }
-
-    const parsed = parseTemplate(template);
-    if (!parsed.ok) {
-      issues.push({
-        kind: "icu_syntax_error",
-        path: localePath,
-        message: parsed.message,
-      });
-      continue;
-    }
-
-    locales[locale] = { template, args: parsed.args };
-    localeMetas.push(parsed.meta);
-  }
-
-  if (localeMetas.length > 0) {
-    const merged = mergeVariableMetaAcrossLocales(localeMetas);
-    if (!merged.ok) {
-      const localeArgs: Record<string, ParsedKeyEntry["mergedArgs"]> = {};
-      for (const [loc, entry] of Object.entries(locales)) {
-        localeArgs[loc] = entry.args;
-      }
-      localeArgsMismatch = {
-        kind: "locale_args_mismatch",
-        path: [...keyPathPrefix, key],
-        locales: localeArgs,
-        message: merged.message,
-      };
-    } else {
-      mergedArgs = merged.merged;
-    }
-  }
-
-  if (localeArgsMismatch) {
-    issues.push(localeArgsMismatch);
-  }
-
-  return { entry: { locales, mergedArgs }, issues };
-}
-
-function normalizeKeyDictionary(
-  input: Record<string, unknown>,
-  requiredKeys: readonly string[],
-  keyPathPrefix: readonly string[]
-): ValidationResult<NormalizedKeyDictionary> {
-  const issues: ValidationIssue[] = [];
-  const keys: Record<string, ParsedKeyEntry> = {};
-
-  for (const key of requiredKeys) {
-    if (!(key in input)) {
-      issues.push({ kind: "missing_key", path: [...keyPathPrefix, key] });
-      continue;
-    }
-
-    const keyValue = input[key];
-    if (!isPlainObject(keyValue)) {
-      issues.push({
-        kind: "invalid_input",
-        message: `Expected object for key "${key}", got ${typeof keyValue}`,
-      });
-      continue;
-    }
-
-    const result = normalizeSingleKey(key, keyValue, keyPathPrefix);
-    issues.push(...result.issues);
-    keys[key] = result.entry;
-  }
-
-  if (issues.length > 0) {
-    return { ok: false, issues };
-  }
-
-  return { ok: true, data: keys };
-}
-
-/**
- * Validation step 1 (partial): coerce external input into a normalized key dictionary
- * for only the keys present in the payload.
- */
-export function normalizeKeyDictionaryPartial(
-  input: unknown,
-  knownKeys: readonly string[],
-  _argsByKey: Readonly<Record<string, VariableSpec>>,
-  keyPathPrefix: readonly string[]
-): ValidationResult<NormalizedKeyDictionary> {
-  if (!isPlainObject(input)) {
-    return {
-      ok: false,
-      issues: [
-        {
-          kind: "invalid_input",
-          message: `Expected object, got ${input === null ? "null" : typeof input}`,
-        },
-      ],
-    };
-  }
-
-  const knownKeysSet = new Set(knownKeys);
-  const issues: ValidationIssue[] = [];
-  const keys: Record<string, ParsedKeyEntry> = {};
-
-  for (const key of Object.keys(input)) {
-    if (!knownKeysSet.has(key)) {
-      issues.push({ kind: "unknown_key", path: [...keyPathPrefix, key] });
-      continue;
-    }
-
-    const keyValue = input[key];
-    if (!isPlainObject(keyValue)) {
-      issues.push({
-        kind: "invalid_input",
-        message: `Expected object for key "${key}", got ${typeof keyValue}`,
-      });
-      continue;
-    }
-
-    if (Object.keys(keyValue).length === 0) {
-      issues.push({
-        kind: "invalid_input",
-        message: `Key "${key}" must include at least one locale`,
-      });
-      continue;
-    }
-
-    const result = normalizeSingleKey(key, keyValue, keyPathPrefix);
-    issues.push(...result.issues);
-    keys[key] = result.entry;
-  }
-
-  if (issues.length > 0) {
-    return { ok: false, issues };
-  }
-
-  return { ok: true, data: keys };
-}
-
-/**
- * Validation step 1: coerce external input into a normalized dictionary shape
- * (keys, locales, ICU args) against a `DictionarySpec`.
- */
-export function normalizeDictionary(
-  input: unknown,
-  spec: DictionarySpec
-): ValidationResult<NormalizedDictionary> {
-  if (!isPlainObject(input)) {
-    return failure([
-      {
-        kind: "invalid_input",
-        message: `Expected object, got ${input === null ? "null" : typeof input}`,
-      },
-    ]);
-  }
-
-  if (spec.mode === "single") {
-    const result = normalizeKeyDictionary(input, spec.requiredKeys, []);
-    if (!result.ok) {
-      return result;
-    }
-
-    return success({ mode: "single", keys: result.data });
-  }
-
-  const issues: ValidationIssue[] = [];
-  const namespaces: Record<string, NormalizedKeyDictionary> = {};
-
-  for (const [namespace, requiredKeys] of Object.entries(spec.requiredKeys)) {
-    if (!(namespace in input)) {
-      for (const key of requiredKeys) {
-        issues.push({ kind: "missing_key", path: [namespace, key] });
-      }
-      continue;
-    }
-
-    const namespaceValue = input[namespace];
-    if (!isPlainObject(namespaceValue)) {
-      issues.push({
-        kind: "invalid_input",
-        message: `Expected object for namespace "${namespace}", got ${typeof namespaceValue}`,
-      });
-      continue;
-    }
-
-    const result = normalizeKeyDictionary(namespaceValue, requiredKeys, [namespace]);
-    if (!result.ok) {
-      issues.push(...result.issues);
-    } else {
-      namespaces[namespace] = result.data;
-    }
-  }
-
-  if (issues.length > 0) {
-    return failure(issues);
-  }
-
-  return success({ mode: "multi", namespaces });
-}
-
-/**
- * Validation step 1 (partial, multi): coerce external input into normalized namespace
- * slices for only the namespaces and keys present in the payload.
- */
-export function normalizeDictionaryPartial(
-  input: unknown,
-  spec: Extract<DictionarySpec, { mode: "multi" }>
-): ValidationResult<NormalizedDictionary> {
-  if (!isPlainObject(input)) {
-    return failure([
-      {
-        kind: "invalid_input",
-        message: `Expected object, got ${input === null ? "null" : typeof input}`,
-      },
-    ]);
-  }
-
-  const knownNamespaces = Object.keys(spec.requiredKeys);
-  const knownNamespacesSet = new Set(knownNamespaces);
-  const issues: ValidationIssue[] = [];
-  const namespaces: Record<string, NormalizedKeyDictionary> = {};
-
-  for (const namespace of Object.keys(input)) {
-    if (!knownNamespacesSet.has(namespace)) {
-      issues.push({ kind: "unknown_key", path: [namespace] });
-      continue;
-    }
-
-    const namespaceValue = input[namespace];
-    if (!isPlainObject(namespaceValue)) {
-      issues.push({
-        kind: "invalid_input",
-        message: `Expected object for namespace "${namespace}", got ${typeof namespaceValue}`,
-      });
-      continue;
-    }
-
-    const result = normalizeKeyDictionaryPartial(
-      namespaceValue,
-      spec.requiredKeys[namespace] ?? [],
-      spec.argsByKey[namespace] ?? {},
-      [namespace]
-    );
-    if (!result.ok) {
-      issues.push(...result.issues);
-    } else {
-      namespaces[namespace] = result.data;
-    }
-  }
-
-  if (issues.length > 0) {
-    return failure(issues);
-  }
-
-  return success({ mode: "multi", namespaces });
-}

package/src/validation/to-dictionary.ts

@@ -1,67 +0,0 @@
-import type { NormalizedDictionary } from "./types.js";
-
-type LocaleDictionary = Record<string, string>;
-type KeyDictionary = Record<string, LocaleDictionary>;
-type MultiDictionary = Record<string, KeyDictionary>;
-
-export function toDictionary(normalized: NormalizedDictionary): KeyDictionary | MultiDictionary {
-  if (normalized.mode === "single") {
-    const dictionary: KeyDictionary = {};
-
-    for (const [key, entry] of Object.entries(normalized.keys)) {
-      const locales: LocaleDictionary = {};
-      for (const [locale, localeEntry] of Object.entries(entry.locales)) {
-        locales[locale] = localeEntry.template;
-      }
-      dictionary[key] = locales;
-    }
-
-    return dictionary;
-  }
-
-  const dictionary: MultiDictionary = {};
-
-  for (const [namespace, keys] of Object.entries(normalized.namespaces)) {
-    const namespaceDictionary: KeyDictionary = {};
-
-    for (const [key, entry] of Object.entries(keys)) {
-      const locales: LocaleDictionary = {};
-      for (const [locale, localeEntry] of Object.entries(entry.locales)) {
-        locales[locale] = localeEntry.template;
-      }
-      namespaceDictionary[key] = locales;
-    }
-
-    dictionary[namespace] = namespaceDictionary;
-  }
-
-  return dictionary;
-}
-
-export function toNamespaceDictionary(
-  normalized: NormalizedDictionary,
-  namespace: string
-): KeyDictionary {
-  if (normalized.mode !== "multi") {
-    throw new Error(
-      `[i18n] toNamespaceDictionary requires multi-mode normalized dictionary, got "${normalized.mode}"`
-    );
-  }
-
-  const keys = normalized.namespaces[namespace];
-  if (!keys) {
-    return {};
-  }
-
-  const dictionary: KeyDictionary = {};
-
-  for (const [key, entry] of Object.entries(keys)) {
-    const locales: LocaleDictionary = {};
-    for (const [locale, localeEntry] of Object.entries(entry.locales)) {
-      locales[locale] = localeEntry.template;
-    }
-    dictionary[key] = locales;
-  }
-
-  return dictionary;
-}

package/src/validation/types.ts

@@ -1,82 +0,0 @@
-import type { VariableSpec, VariableType } from "../icu/extract-variables.js";
-
-export type { VariableSpec, VariableType };
-
-export type ParsedLocaleEntry = {
-  readonly template: string;
-  readonly args: VariableSpec;
-};
-
-export type ParsedKeyEntry = {
-  readonly locales: Readonly<Record<string, ParsedLocaleEntry>>;
-  readonly mergedArgs: VariableSpec;
-};
-
-export type NormalizedKeyDictionary = Readonly<Record<string, ParsedKeyEntry>>;
-
-export type NormalizedMultiDictionary = Readonly<Record<string, NormalizedKeyDictionary>>;
-
-export type NormalizedDictionary =
-  | { readonly mode: "single"; readonly keys: NormalizedKeyDictionary }
-  | { readonly mode: "multi"; readonly namespaces: NormalizedMultiDictionary };
-
-export type DictionarySpec =
-  | {
-      readonly mode: "single";
-      readonly requiredKeys: readonly string[];
-      readonly argsByKey: Readonly<Record<string, VariableSpec>>;
-    }
-  | {
-      readonly mode: "multi";
-      readonly requiredKeys: Readonly<Record<string, readonly string[]>>;
-      readonly argsByKey: Readonly<Record<string, Readonly<Record<string, VariableSpec>>>>;
-    };
-
-export type ValidationIssue =
-  | {
-      readonly kind: "invalid_input";
-      readonly message: string;
-    }
-  | {
-      readonly kind: "missing_key";
-      readonly path: readonly string[];
-    }
-  | {
-      readonly kind: "unknown_key";
-      readonly path: readonly string[];
-    }
-  | {
-      readonly kind: "invalid_locale_value";
-      readonly path: readonly string[];
-      readonly message: string;
-    }
-  | {
-      readonly kind: "icu_syntax_error";
-      readonly path: readonly string[];
-      readonly message: string;
-    }
-  | {
-      readonly kind: "locale_args_mismatch";
-      readonly path: readonly string[];
-      readonly locales: Readonly<Record<string, VariableSpec>>;
-      readonly message: string;
-    }
-  | {
-      readonly kind: "variable_mismatch";
-      readonly path: readonly string[];
-      readonly expected: VariableSpec;
-      readonly found: VariableSpec;
-      readonly message: string;
-    }
-  | {
-      readonly kind: "variable_type_mismatch";
-      readonly path: readonly string[];
-      readonly variable: string;
-      readonly expected: VariableType;
-      readonly found: VariableType;
-      readonly message: string;
-    };
-
-export type ValidationResult<T> =
-  | { readonly ok: true; readonly data: T }
-  | { readonly ok: false; readonly issues: readonly ValidationIssue[] };

package/src/validation/validate-normalized.ts

@@ -1,133 +0,0 @@
-import type { ZodError } from "zod";
-import { mapArgsSchemaError } from "./create-args-schema.js";
-import {
-  createKeyDictionarySchema,
-  createNormalizedDictionarySchema,
-} from "./create-normalized-schema.js";
-import type {
-  DictionarySpec,
-  NormalizedDictionary,
-  NormalizedKeyDictionary,
-  ValidationIssue,
-  ValidationResult,
-  VariableSpec,
-} from "./types.js";
-
-function getExpectedArgs(spec: DictionarySpec, path: readonly string[]): VariableSpec | undefined {
-  if (spec.mode === "single") {
-    const key = path[path.length - 1];
-    if (typeof key !== "string") {
-      return undefined;
-    }
-    return spec.argsByKey[key];
-  }
-
-  const namespace = path[0];
-  const key = path[path.length - 1];
-  if (typeof namespace !== "string" || typeof key !== "string") {
-    return undefined;
-  }
-
-  return spec.argsByKey[namespace]?.[key];
-}
-
-function getFoundArgs(
-  normalized: NormalizedDictionary,
-  path: readonly string[]
-): VariableSpec | undefined {
-  if (normalized.mode === "single") {
-    const key = path[path.length - 1];
-    if (typeof key !== "string") {
-      return undefined;
-    }
-    return normalized.keys[key]?.mergedArgs;
-  }
-
-  const namespace = path[0];
-  const key = path[path.length - 1];
-  if (typeof namespace !== "string" || typeof key !== "string") {
-    return undefined;
-  }
-
-  return normalized.namespaces[namespace]?.[key]?.mergedArgs;
-}
-
-function mapZodError(
-  error: ZodError,
-  spec: DictionarySpec,
-  normalized: NormalizedDictionary
-): ValidationIssue[] {
-  return error.issues.map((issue) => {
-    const path = issue.path.map(String);
-
-    if (path.includes("mergedArgs")) {
-      const keyPath = path.slice(0, path.indexOf("mergedArgs"));
-      const expected = getExpectedArgs(spec, keyPath);
-      const found = getFoundArgs(normalized, keyPath);
-
-      if (expected && found) {
-        return mapArgsSchemaError(expected, found, issue.message, keyPath);
-      }
-    }
-
-    return {
-      kind: "invalid_input" as const,
-      message: path.length > 0 ? `${path.join(".")}: ${issue.message}` : issue.message,
-    };
-  });
-}
-
-export function validateNormalizedKeyDictionaryPartial(
-  keys: NormalizedKeyDictionary,
-  argsByKey: Readonly<Record<string, VariableSpec>>,
-  spec: DictionarySpec,
-  keyPathPrefix: readonly string[]
-): ValidationResult<NormalizedKeyDictionary> {
-  const presentKeys = Object.keys(keys);
-  const subsetArgsByKey = Object.fromEntries(
-    presentKeys.filter((key) => key in argsByKey).map((key) => [key, argsByKey[key]!])
-  );
-
-  if (presentKeys.length === 0) {
-    return { ok: true, data: keys };
-  }
-
-  const schema = createKeyDictionarySchema(subsetArgsByKey);
-  const result = schema.safeParse(keys);
-
-  if (result.success) {
-    return { ok: true, data: result.data };
-  }
-
-  const normalized: NormalizedDictionary =
-    spec.mode === "single"
-      ? { mode: "single", keys }
-      : {
-          mode: "multi",
-          namespaces: {
-            [keyPathPrefix[0] ?? ""]: keys,
-          },
-        };
-
-  return {
-    ok: false,
-    issues: mapZodError(result.error, spec, normalized),
-  };
-}
-
-export function validateNormalizedDictionary(
-  normalized: NormalizedDictionary,
-  spec: DictionarySpec
-): ValidationResult<NormalizedDictionary> {
-  const schema = createNormalizedDictionarySchema(spec);
-  const result = schema.safeParse(normalized);
-
-  if (result.success) {
-    return { ok: true, data: result.data };
-  }
-
-  return {
-    ok: false,
-    issues: mapZodError(result.error, spec, normalized),
-  };
-}