@digitaldefiance/i18n-lib 3.8.1 → 3.8.3

package/src/utils.ts

@@ -1,215 +0,0 @@
-import moment from 'moment-timezone';
-
-/**
- * Replaces variables in a string with their corresponding values from vars or constants.
- * @param str - The string containing variables to replace
- * @param vars - An object mapping variable names to their replacement values
- * @param constants - An object containing constant values for replacement
- * @returns The string with variables replaced
- */
-export function replaceVariables(
-  str: string,
-  vars?: Record<string, string | number>,
-  constants?: any,
-): string {
-  // Ensure input is a string
-  if (typeof str !== 'string') {
-    str = String(str);
-  }
-
-  const variables = str.match(/\{(.+?)\}/g);
-  if (!variables) return str;
-
-  let result = str;
-  for (const variable of variables) {
-    const varName = variable.slice(1, -1);
-    let replacement = '';
-
-    if (vars && varName in vars) {
-      replacement = String(vars[varName]);
-    } else if (constants && varName in constants) {
-      replacement = String(constants[varName]);
-    }
-
-    if (replacement) {
-      result = result.replace(variable, replacement);
-    }
-  }
-
-  return result;
-}
-
-/**
- * Checks if a given key indicates a template string.
- * @param key - The key to check
- * @returns True if the key indicates a template, false otherwise
- */
-export function isTemplate(key: string): boolean {
-  return key.trim().toLowerCase().endsWith('template');
-}
-
-/**
- * Checks if a given timezone string is valid.
- * @param timezone - The timezone string to validate
- * @returns
- */
-export function isValidTimezone(timezone: string): boolean {
-  return moment.tz.zone(timezone) !== null;
-}
-
-/**
- * Converts parts to a single string key, joining with underscores.
- * @param parts - The parts to join
- * @returns The joined string key
- */
-export function toStringKey<TStringKey extends string>(
-  ...parts: string[]
-): TStringKey {
-  return parts.join('_') as TStringKey;
-}
-
-/**
- * Converts an enum value to a string key by joining parts with underscores and appending the enum value.
- * @param value - The enum value
- * @param parts - Additional parts to join
- * @returns The constructed string key
- */
-export function toStringKeyFromEnum<TStringKey extends string>(
-  value: string,
-  ...parts: string[]
-): TStringKey {
-  const allParts = [...parts, value];
-  return allParts.join('_') as TStringKey;
-}
-
-/**
- * Type that constructs string keys from enum values with prefixes and optional template suffix
- */
-type BuildStringKey<
-  TEnumValue extends string,
-  TPrefixes extends readonly string[],
-  TIsTemplate extends boolean = false,
-> = TPrefixes extends readonly []
-  ? `${TEnumValue}${TIsTemplate extends true ? 'Template' : ''}`
-  : TPrefixes extends readonly [infer First, ...infer Rest]
-  ? First extends string
-    ? Rest extends readonly string[]
-      ? `${First}_${BuildStringKey<TEnumValue, Rest, TIsTemplate>}`
-      : never
-    : never
-  : never;
-
-/**
- * Type that maps all enum values to their corresponding string keys
- */
-type ReasonMapFromEnum<
-  TEnum extends Record<string, string>,
-  TStringKey extends string,
-  TPrefixes extends readonly string[] = [],
-  TTemplateKeys extends Set<TEnum[keyof TEnum]> = never,
-> = {
-  [K in TEnum[keyof TEnum]]: BuildStringKey<
-    K,
-    TPrefixes,
-    TTemplateKeys extends Set<K> ? true : false
-  > extends TStringKey
-    ? BuildStringKey<K, TPrefixes, TTemplateKeys extends Set<K> ? true : false>
-    : never;
-};
-
-/**
- * Builds a reason map from an enum object, mapping each enum value to a string key.
- * @param enumObj - The enum object
- * @param prefixes - Prefixes to prepend to each string key
- * @param templateKeys - Optional set of enum values that should have 'Template' suffix for template processing
- * @returns The constructed reason map
- */
-export function buildReasonMap<
-  TEnum extends Record<string, string>,
-  TStringKey extends string,
->(
-  enumObj: TEnum,
-  prefixes: string[] = [],
-  templateKeys?: Set<TEnum[keyof TEnum]>,
-): Record<TEnum[keyof TEnum], TStringKey> {
-  const map = {} as Record<TEnum[keyof TEnum], TStringKey>;
-
-  Object.values(enumObj).forEach((value) => {
-    const baseKey = [...prefixes, value].join('_');
-    const finalKey = templateKeys?.has(value as TEnum[keyof TEnum])
-      ? baseKey + 'Template'
-      : baseKey;
-    map[value as TEnum[keyof TEnum]] = finalKey as TStringKey;
-  });
-
-  return map;
-}
-
-/**
- * Type-safe version of buildReasonMap that ensures all enum values are mapped and all string keys exist
- */
-export function buildTypeSafeReasonMap<
-  TEnum extends Record<string, string>,
-  TStringKey extends string,
-  TPrefixes extends readonly string[] = [],
-  TTemplateKeys extends Set<TEnum[keyof TEnum]> = never,
->(
-  enumObj: TEnum,
-  prefixes: TPrefixes,
-  templateKeys?: TTemplateKeys,
-): ReasonMapFromEnum<TEnum, TStringKey, TPrefixes, TTemplateKeys> {
-  const map: Partial<
-    ReasonMapFromEnum<TEnum, TStringKey, TPrefixes, TTemplateKeys>
-  > = {};
-
-  Object.values(enumObj).forEach((value) => {
-    const baseKey = [...prefixes, value].join('_');
-    const finalKey = templateKeys?.has(value as TEnum[keyof TEnum])
-      ? baseKey + 'Template'
-      : baseKey;
-    map[value as TEnum[keyof TEnum]] = finalKey as any;
-  });
-
-  return map as ReasonMapFromEnum<TEnum, TStringKey, TPrefixes, TTemplateKeys>;
-}
-
-/**
- * Validates that a reason map has entries for all enum values
- */
-export function validateReasonMap<
-  TEnum extends Record<string, string>,
-  TStringKey extends string,
->(
-  enumObj: TEnum,
-  reasonMap: Partial<Record<TEnum[keyof TEnum], TStringKey>>,
-): reasonMap is Record<TEnum[keyof TEnum], TStringKey> {
-  return Object.values(enumObj).every(
-    (value) =>
-      value in reasonMap &&
-      reasonMap[value as TEnum[keyof TEnum]] !== undefined,
-  );
-}
-
-/**
- * Creates a complete reason map ensuring all enum values are covered
- */
-export function createCompleteReasonMap<
-  TEnum extends Record<string, string>,
-  TStringKey extends string,
->(
-  enumObj: TEnum,
-  prefixes: readonly string[] = [],
-  templateKeys?: Set<TEnum[keyof TEnum]>,
-): Record<TEnum[keyof TEnum], TStringKey> {
-  const map = buildReasonMap(enumObj, [...prefixes], templateKeys) as Record<
-    TEnum[keyof TEnum],
-    TStringKey
-  >;
-
-  if (!validateReasonMap(enumObj, map)) {
-    const missing = Object.values(enumObj).filter((value) => !(value in map));
-    throw new Error(`Missing reason map entries for: ${missing.join(', ')}`);
-  }
-
-  return map;
-}

package/src/validation/plural-validator.ts

@@ -1,168 +0,0 @@
-/**
- * Plural form validation
- */
-
-import { PluralCategory } from '../pluralization/plural-categories';
-import { PluralString, isPluralString } from '../types/plural-types';
-import { getRequiredPluralForms, getAllPluralForms } from '../pluralization/language-plural-map';
-
-/**
- * Result of validating plural forms.
- */
-export interface PluralValidationResult {
-  /** Whether the validation passed */
-  isValid: boolean;
-  /** Array of validation errors */
-  errors: string[];
-  /** Array of validation warnings */
-  warnings: string[];
-}
-
-/**
- * Options for plural form validation.
- */
-export interface PluralValidationOptions {
-  /** If true, treat missing required forms as errors instead of warnings */
-  strict?: boolean;
-  /** If true, warn about unused plural forms */
-  checkUnused?: boolean;
-  /** If true, check for consistent variable usage across forms */
-  checkVariables?: boolean;
-}
-
-/**
- * Validate plural forms for a specific language.
- * Checks that all required plural forms are present and optionally validates variable consistency.
- * @param value - The plural string value to validate
- * @param language - The language code
- * @param key - The translation key (for error messages)
- * @param options - Validation options
- * @returns Validation result with errors and warnings
- */
-export function validatePluralForms(
-  value: PluralString,
-  language: string,
-  key: string,
-  options: PluralValidationOptions = {}
-): PluralValidationResult {
-  const errors: string[] = [];
-  const warnings: string[] = [];
-
-  if (!isPluralString(value)) {
-    return { isValid: true, errors, warnings };
-  }
-
-  const required = getRequiredPluralForms(language);
-  const all = getAllPluralForms(language);
-  const provided = Object.keys(value) as PluralCategory[];
-
-  // Check required forms
-  for (const form of required) {
-    if (!value[form as PluralCategory]) {
-      if (options.strict) {
-        errors.push(`Missing required plural form '${form}' for language '${language}' in key '${key}'`);
-      } else {
-        warnings.push(`Missing required plural form '${form}' for language '${language}' in key '${key}'`);
-      }
-    }
-  }
-
-  // Check unused forms
-  if (options.checkUnused) {
-    for (const form of provided) {
-      if (!all.includes(form)) {
-        warnings.push(`Unused plural form '${form}' for language '${language}' in key '${key}'`);
-      }
-    }
-  }
-
-  // Check variable consistency
-  if (options.checkVariables) {
-    const variables = extractVariables(value);
-    const inconsistent = findInconsistentVariables(value, variables);
-    for (const [form, missing] of Object.entries(inconsistent)) {
-      warnings.push(`Plural form '${form}' in key '${key}' missing variables: ${missing.join(', ')}`);
-    }
-  }
-
-  return {
-    isValid: errors.length === 0,
-    errors,
-    warnings,
-  };
-}
-
-/**
- * Extract all variables from plural forms.
- * Scans all plural form texts for {variable} patterns.
- * @param value - The plural string value
- * @returns Set of all variable names found
- */
-function extractVariables(value: PluralString): Set<string> {
-  const vars = new Set<string>();
-  if (typeof value === 'string') return vars;
-
-  for (const text of Object.values(value)) {
-    if (text) {
-      const matches = text.match(/\{(\w+)\}/g);
-      if (matches) {
-        matches.forEach(m => vars.add(m.slice(1, -1)));
-      }
-    }
-  }
-  return vars;
-}
-
-/**
- * Find forms with inconsistent variables.
- * Identifies plural forms that are missing variables used in other forms.
- * @param value - The plural string value
- * @param allVars - Set of all variables found across all forms
- * @returns Object mapping form names to arrays of missing variable names
- */
-function findInconsistentVariables(
-  value: PluralString,
-  allVars: Set<string>
-): Record<string, string[]> {
-  const inconsistent: Record<string, string[]> = {};
-  if (typeof value === 'string') return inconsistent;
-
-  for (const [form, text] of Object.entries(value)) {
-    if (text) {
-      const formVars = new Set<string>();
-      const matches = text.match(/\{(\w+)\}/g);
-      if (matches) {
-        matches.forEach(m => formVars.add(m.slice(1, -1)));
-      }
-
-      const missing = Array.from(allVars).filter(v => !formVars.has(v));
-      if (missing.length > 0) {
-        inconsistent[form] = missing;
-      }
-    }
-  }
-  return inconsistent;
-}
-
-/**
- * Validate that count variable exists when plural forms are used.
- * Pluralization requires a 'count' variable to determine which form to use.
- * @param value - The plural string value
- * @param variables - The variables object to check
- * @param key - The translation key (for error messages)
- * @returns Validation result with warnings if count is missing
- */
-export function validateCountVariable(
-  value: PluralString,
-  variables: Record<string, any> | undefined,
-  key: string
-): PluralValidationResult {
-  const errors: string[] = [];
-  const warnings: string[] = [];
-
-  if (isPluralString(value) && (!variables || variables.count === undefined)) {
-    warnings.push(`Plural forms used in key '${key}' but no 'count' variable provided`);
-  }
-
-  return { isValid: true, errors, warnings };
-}

package/src/validation-config.ts

@@ -1,11 +0,0 @@
-/**
- * Configuration for component registration validation
- */
-export interface ValidationConfig {
-  /** Whether to require all languages to have all strings */
-  readonly requireCompleteStrings: boolean;
-  /** Whether to allow registration with missing strings (will use fallbacks) */
-  readonly allowPartialRegistration: boolean;
-  /** Default language to fall back to for missing strings */
-  readonly fallbackLanguageId: string;
-}

package/src/validation-result.ts

@@ -1,12 +0,0 @@
-/**
- * Validation result for component registration
- */
-export interface ValidationResult {
-  readonly isValid: boolean;
-  readonly missingKeys: ReadonlyArray<{
-    readonly languageId: string;
-    readonly componentId: string;
-    readonly stringKey: string;
-  }>;
-  readonly errors: readonly string[];
-}