@vocab/core 1.6.4 → 1.6.5-fix-messageformat-import-20250923004826

package/dist/vocab-core.esm.js

@@ -1,866 +0,0 @@
-import { existsSync, promises } from 'fs';
-import path from 'path';
-import { TYPE, parse, isSelectElement, isPluralElement, isTagElement, isArgumentElement, isNumberElement, isDateElement, isTimeElement } from '@formatjs/icu-messageformat-parser';
-import prettier from 'prettier';
-import chokidar from 'chokidar';
-import pc from 'picocolors';
-import debug from 'debug';
-import glob from 'fast-glob';
-import IntlMessageFormat from 'intl-messageformat';
-import { printAST } from '@formatjs/icu-messageformat-parser/printer';
-import findUp from 'find-up';
-import Validator from 'fastest-validator';
-
-const trace = debug(`vocab:core`);
-
-const defaultTranslationDirSuffix = '.vocab';
-const devTranslationFileName = 'translations.json';
-const globAnyPathWithOptionalPrefix = '**/?(*)';
-function isDevLanguageFile(filePath) {
-  return filePath.endsWith(`/${devTranslationFileName}`) || filePath === devTranslationFileName;
-}
-function isAltLanguageFile(filePath) {
-  return filePath.endsWith('.translations.json');
-}
-function isTranslationDirectory(filePath, {
-  translationsDirectorySuffix = defaultTranslationDirSuffix
-}) {
-  return filePath.endsWith(translationsDirectorySuffix);
-}
-function getTranslationFolderGlob({
-  translationsDirectorySuffix = defaultTranslationDirSuffix
-}) {
-  const result = `${globAnyPathWithOptionalPrefix}${translationsDirectorySuffix}`;
-  trace('getTranslationFolderGlob', result);
-  return result;
-}
-function getDevTranslationFileGlob({
-  translationsDirectorySuffix = defaultTranslationDirSuffix
-}) {
-  const result = `${globAnyPathWithOptionalPrefix}${translationsDirectorySuffix}/${devTranslationFileName}`;
-  trace('getDevTranslationFileGlob', result);
-  return result;
-}
-function getAltTranslationFileGlob(config) {
-  const altLanguages = getAltLanguages(config);
-  const langMatch = altLanguages.length === 1 ? altLanguages[0] : `{${altLanguages.join(',')}}`;
-  const {
-    translationsDirectorySuffix = defaultTranslationDirSuffix
-  } = config;
-  const result = `**/*${translationsDirectorySuffix}/${langMatch}.translations.json`;
-  trace('getAltTranslationFileGlob', result);
-  return result;
-}
-function getAltLanguages({
-  devLanguage,
-  languages
-}) {
-  return languages.map(v => v.name).filter(lang => lang !== devLanguage);
-}
-function getDevLanguageFileFromTsFile(tsFilePath) {
-  const directory = path.dirname(tsFilePath);
-  const result = path.normalize(path.join(directory, devTranslationFileName));
-  trace(`Returning dev language path ${result} for path ${tsFilePath}`);
-  return result;
-}
-function getDevLanguageFileFromAltLanguageFile(altLanguageFilePath) {
-  const directory = path.dirname(altLanguageFilePath);
-  const result = path.normalize(path.join(directory, devTranslationFileName));
-  trace(`Returning dev language path ${result} for path ${altLanguageFilePath}`);
-  return result;
-}
-function getTSFileFromDevLanguageFile(devLanguageFilePath) {
-  const directory = path.dirname(devLanguageFilePath);
-  const result = path.normalize(path.join(directory, 'index.ts'));
-  trace(`Returning TS path ${result} for path ${devLanguageFilePath}`);
-  return result;
-}
-function getAltLanguageFilePath(devLanguageFilePath, language) {
-  const directory = path.dirname(devLanguageFilePath);
-  const result = path.normalize(path.join(directory, `${language}.translations.json`));
-  trace(`Returning alt language path ${result} for path ${devLanguageFilePath}`);
-  return path.normalize(result);
-}
-function mapValues(obj, func) {
-  const newObj = {};
-  const keys = Object.keys(obj);
-  for (const key of keys) {
-    newObj[key] = func(obj[key]);
-  }
-  return newObj;
-}
-function getTranslationMessages(translations) {
-  return mapValues(translations, v => v.message);
-}
-
-function generateLanguageFromTranslations({
-  baseTranslations,
-  generator
-}) {
-  if (!generator.transformElement && !generator.transformMessage) {
-    return baseTranslations;
-  }
-  const translationKeys = Object.keys(baseTranslations);
-  const generatedTranslations = {};
-  for (const translationKey of translationKeys) {
-    const translation = baseTranslations[translationKey];
-    let transformedMessage = translation.message;
-    if (generator.transformElement) {
-      const messageAst = new IntlMessageFormat(translation.message).getAst();
-      const transformedAst = messageAst.map(transformMessageFormatElement(generator.transformElement));
-      transformedMessage = printAST(transformedAst);
-    }
-    if (generator.transformMessage) {
-      transformedMessage = generator.transformMessage(transformedMessage);
-    }
-    generatedTranslations[translationKey] = {
-      message: transformedMessage
-    };
-  }
-  return generatedTranslations;
-}
-function transformMessageFormatElement(transformElement) {
-  return messageFormatElement => {
-    const transformedMessageFormatElement = {
-      ...messageFormatElement
-    };
-    switch (transformedMessageFormatElement.type) {
-      case TYPE.literal:
-        const transformedValue = transformElement(transformedMessageFormatElement.value);
-        transformedMessageFormatElement.value = transformedValue;
-        break;
-      case TYPE.select:
-      case TYPE.plural:
-        const transformedOptions = {
-          ...transformedMessageFormatElement.options
-        };
-        for (const key of Object.keys(transformedOptions)) {
-          transformedOptions[key].value = transformedOptions[key].value.map(transformMessageFormatElement(transformElement));
-        }
-        break;
-      case TYPE.tag:
-        const transformedChildren = transformedMessageFormatElement.children.map(transformMessageFormatElement(transformElement));
-        transformedMessageFormatElement.children = transformedChildren;
-        break;
-    }
-    return transformedMessageFormatElement;
-  };
-}
-
-function getUniqueKey(key, namespace) {
-  return `${key}.${namespace}`;
-}
-function mergeWithDevLanguageTranslation({
-  translation,
-  devTranslation
-}) {
-  // Only use keys from the dev translation
-  const keys = Object.keys(devTranslation);
-  const newLanguage = {};
-  for (const key of keys) {
-    if (translation[key]) {
-      newLanguage[key] = {
-        message: translation[key].message,
-        description: devTranslation[key].description
-      };
-    }
-  }
-  return newLanguage;
-}
-function getLanguageFallbacks({
-  languages
-}) {
-  const languageFallbackMap = new Map();
-  for (const lang of languages) {
-    if (lang.extends) {
-      languageFallbackMap.set(lang.name, lang.extends);
-    }
-  }
-  return languageFallbackMap;
-}
-function getLanguageHierarchy({
-  languages
-}) {
-  const hierarchyMap = new Map();
-  const fallbacks = getLanguageFallbacks({
-    languages
-  });
-  for (const lang of languages) {
-    const langHierarchy = [];
-    let currLang = lang.extends;
-    while (currLang) {
-      langHierarchy.push(currLang);
-      currLang = fallbacks.get(currLang);
-    }
-    hierarchyMap.set(lang.name, langHierarchy);
-  }
-  return hierarchyMap;
-}
-function getFallbackLanguageOrder({
-  languages,
-  languageName,
-  devLanguage,
-  fallbacks
-}) {
-  const languageHierarchy = getLanguageHierarchy({
-    languages
-  }).get(languageName);
-  if (!languageHierarchy) {
-    throw new Error(`Missing language hierarchy for ${languageName}`);
-  }
-  const fallbackLanguageOrder = [languageName];
-  if (fallbacks !== 'none') {
-    fallbackLanguageOrder.unshift(...languageHierarchy.reverse());
-    if (fallbacks === 'all' && fallbackLanguageOrder[0] !== devLanguage) {
-      fallbackLanguageOrder.unshift(devLanguage);
-    }
-  }
-  return fallbackLanguageOrder;
-}
-function getNamespaceByFilePath(relativePath, {
-  translationsDirectorySuffix = defaultTranslationDirSuffix
-}) {
-  let namespace = path.dirname(relativePath).replace(/^src\//, '').replace(/\//g, '_');
-  if (namespace.endsWith(translationsDirectorySuffix)) {
-    namespace = namespace.slice(0, -translationsDirectorySuffix.length);
-  }
-  return namespace;
-}
-function printValidationError(...params) {
-  // eslint-disable-next-line no-console
-  console.error(pc.red('Error loading translation:'), ...params);
-}
-function getTranslationsFromFile(translationFileContents, {
-  isAltLanguage,
-  filePath,
-  withTags
-}) {
-  if (!translationFileContents || typeof translationFileContents !== 'object') {
-    throw new Error(`Unable to read translation file ${filePath}. Translations must be an object.`);
-  }
-  const {
-    $namespace,
-    _meta,
-    ...keys
-  } = translationFileContents;
-  if (isAltLanguage && $namespace) {
-    printValidationError(`Found $namespace in alt language file in ${filePath}. $namespace is only used in the dev language and will be ignored.`);
-  }
-  if (!isAltLanguage && $namespace && typeof $namespace !== 'string') {
-    printValidationError(`Found non-string $namespace in language file in ${filePath}. $namespace must be a string.`);
-  }
-  if (isAltLanguage && _meta !== null && _meta !== void 0 && _meta.tags) {
-    printValidationError(`Found _meta.tags in alt language file in ${filePath}. _meta.tags is only used in the dev language and will be ignored.`);
-  }
-
-  // Never return tags if we're fetching translations for an alt language
-  const includeTags = !isAltLanguage && withTags;
-  const validKeys = {};
-  for (const [translationKey, {
-    tags,
-    ...translation
-  }] of Object.entries(keys)) {
-    if (typeof translation === 'string') {
-      printValidationError(`Found string for a translation "${translationKey}" in ${filePath}. Translation must be an object of the format {message: string}.`);
-      continue;
-    }
-    if (!translation) {
-      printValidationError(`Found empty translation "${translationKey}" in ${filePath}. Translation must be an object of the format {message: string}.`);
-      continue;
-    }
-    if (!translation.message || typeof translation.message !== 'string') {
-      printValidationError(`No message found for translation "${translationKey}" in ${filePath}. Translation must be an object of the format {message: string}.`);
-      continue;
-    }
-    validKeys[translationKey] = {
-      ...translation,
-      tags: includeTags ? tags : undefined
-    };
-  }
-  const metadata = {
-    tags: includeTags ? _meta === null || _meta === void 0 ? void 0 : _meta.tags : undefined
-  };
-  return {
-    $namespace,
-    keys: validKeys,
-    metadata
-  };
-}
-function loadAltLanguageFile({
-  filePath,
-  languageName,
-  devTranslation,
-  fallbacks
-}, {
-  devLanguage,
-  languages
-}) {
-  const altLanguageTranslation = {};
-  const fallbackLanguageOrder = getFallbackLanguageOrder({
-    languages,
-    languageName,
-    devLanguage,
-    fallbacks
-  });
-  trace(`Loading alt language file with precedence: ${fallbackLanguageOrder.slice().reverse().join(' -> ')}`);
-  for (const fallbackLanguage of fallbackLanguageOrder) {
-    if (fallbackLanguage !== devLanguage) {
-      try {
-        const altFilePath = getAltLanguageFilePath(filePath, fallbackLanguage);
-        delete require.cache[altFilePath];
-
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const translationFile = require(altFilePath);
-        const {
-          keys: fallbackLanguageTranslation
-        } = getTranslationsFromFile(translationFile, {
-          filePath: altFilePath,
-          isAltLanguage: true
-        });
-        Object.assign(altLanguageTranslation, mergeWithDevLanguageTranslation({
-          translation: fallbackLanguageTranslation,
-          devTranslation
-        }));
-      } catch {
-        trace(`Missing alt language file ${getAltLanguageFilePath(filePath, fallbackLanguage)}
-        `);
-      }
-    } else {
-      Object.assign(altLanguageTranslation, devTranslation);
-    }
-  }
-  return altLanguageTranslation;
-}
-function stripTagsFromTranslations(translations) {
-  return Object.fromEntries(Object.entries(translations).map(([key, {
-    tags,
-    ...rest
-  }]) => [key, rest]));
-}
-function loadTranslation({
-  filePath,
-  fallbacks,
-  withTags
-}, userConfig) {
-  trace(`Loading translation file in "${fallbacks}" fallback mode: "${filePath}"`);
-  const languageSet = {};
-  delete require.cache[filePath];
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const translationContent = require(filePath);
-  const relativePath = path.relative(userConfig.projectRoot || process.cwd(), filePath);
-  const {
-    $namespace,
-    keys: devTranslation,
-    metadata
-  } = getTranslationsFromFile(translationContent, {
-    filePath,
-    isAltLanguage: false,
-    withTags
-  });
-  const namespace = typeof $namespace === 'string' ? $namespace : getNamespaceByFilePath(relativePath, userConfig);
-  trace(`Found file ${filePath}. Using namespace ${namespace}`);
-  languageSet[userConfig.devLanguage] = devTranslation;
-  const devTranslationNoTags = withTags ? stripTagsFromTranslations(devTranslation) : devTranslation;
-  const altLanguages = getAltLanguages(userConfig);
-  for (const languageName of altLanguages) {
-    languageSet[languageName] = loadAltLanguageFile({
-      filePath,
-      languageName,
-      devTranslation: devTranslationNoTags,
-      fallbacks
-    }, userConfig);
-  }
-  for (const generatedLanguage of userConfig.generatedLanguages || []) {
-    const {
-      name: generatedLanguageName,
-      generator
-    } = generatedLanguage;
-    const baseLanguage = generatedLanguage.extends || userConfig.devLanguage;
-    const baseTranslations = languageSet[baseLanguage];
-    languageSet[generatedLanguageName] = generateLanguageFromTranslations({
-      baseTranslations,
-      generator
-    });
-  }
-  return {
-    filePath,
-    keys: Object.keys(devTranslation),
-    namespace,
-    relativePath,
-    languages: languageSet,
-    metadata
-  };
-}
-async function loadAllTranslations({
-  fallbacks,
-  includeNodeModules,
-  withTags
-}, config) {
-  const {
-    projectRoot,
-    ignore = []
-  } = config;
-  const translationFiles = await glob(getDevTranslationFileGlob(config), {
-    ignore: includeNodeModules ? ignore : [...ignore, '**/node_modules/**'],
-    absolute: true,
-    cwd: projectRoot
-  });
-  trace(`Found ${translationFiles.length} translation files`);
-  const loadedTranslations = [];
-  const keys = new Set();
-  for (const translationFile of translationFiles) {
-    const loadedTranslation = loadTranslation({
-      filePath: translationFile,
-      fallbacks,
-      withTags
-    }, config);
-    loadedTranslations.push(loadedTranslation);
-    for (const key of loadedTranslation.keys) {
-      const uniqueKey = getUniqueKey(key, loadedTranslation.namespace);
-      if (keys.has(uniqueKey)) {
-        trace(`Duplicate keys found`);
-        throw new Error(`Duplicate keys found. Key with namespace ${loadedTranslation.namespace} and key ${key} was found multiple times.`);
-      }
-      keys.add(uniqueKey);
-      const globalKey = loadedTranslation.languages[config.devLanguage][key].globalKey;
-      if (globalKey) {
-        if (keys.has(globalKey)) {
-          throw new Error(`Duplicate keys found. Key with global key ${globalKey} and key ${key} was found multiple times`);
-        }
-        keys.add(globalKey);
-      }
-    }
-  }
-  return loadedTranslations;
-}
-
-function extractHasTags(ast) {
-  return ast.some(element => {
-    if (isSelectElement(element) || isPluralElement(element)) {
-      const children = Object.values(element.options).map(o => o.value);
-      return children.some(child => extractHasTags(child));
-    }
-    return isTagElement(element);
-  });
-}
-function extractParamTypes(ast, currentParams) {
-  let params = {
-    ...currentParams
-  };
-  let vocabTypesImports = new Set();
-  for (const element of ast) {
-    if (isArgumentElement(element)) {
-      if (!(element.value in params)) {
-        // Preserve existing types for parameters that we've already parsed
-        // This applies to self-referential parameters, for example `{foo, plural, 1 {{foo} thing} other {{foo} things}}`
-        params[element.value] = 'string';
-      }
-    } else if (isNumberElement(element)) {
-      params[element.value] = 'number';
-    } else if (isPluralElement(element)) {
-      params[element.value] = 'number';
-      const children = Object.values(element.options).map(o => o.value);
-      for (const child of children) {
-        const [newParams, subImports] = extractParamTypes(child, params);
-        vocabTypesImports = new Set([...vocabTypesImports, ...subImports]);
-        params = newParams;
-      }
-    } else if (isDateElement(element) || isTimeElement(element)) {
-      params[element.value] = 'Date | number';
-    } else if (isTagElement(element)) {
-      params[element.value] = 'FormatXMLElementFn<T>';
-      vocabTypesImports.add('FormatXMLElementFn');
-      const [newParams, subImports] = extractParamTypes(element.children, params);
-      vocabTypesImports = new Set([...vocabTypesImports, ...subImports]);
-      params = newParams;
-    } else if (isSelectElement(element)) {
-      const options = Object.keys(element.options);
-
-      // `other` will always be an option as the parser enforces this by default
-      const nonOtherOptions = options.filter(o => o !== 'other');
-      const nonOtherOptionsUnion = nonOtherOptions.map(o => `'${o}'`).join(' | ');
-      params[element.value] = `StringWithSuggestions<${nonOtherOptionsUnion}>`;
-      vocabTypesImports.add('StringWithSuggestions');
-      const children = Object.values(element.options).map(o => o.value);
-      for (const child of children) {
-        const [newParams, subImports] = extractParamTypes(child, params);
-        vocabTypesImports = new Set([...vocabTypesImports, ...subImports]);
-        params = newParams;
-      }
-    }
-  }
-  return [params, vocabTypesImports];
-}
-function serialiseObjectToType(v) {
-  let result = '';
-  for (const [key, value] of Object.entries(v)) {
-    result += `${JSON.stringify(key)}: ${value && typeof value === 'object' ? serialiseObjectToType(value) : value},`;
-  }
-  return `{ ${result} }`;
-}
-const serializeTypeImports = (imports, moduleName) => {
-  if (imports.size === 0) {
-    return '';
-  }
-  const importNames = Array.from(imports);
-  return `import type { ${importNames.join(', ')} } from '${moduleName}';`;
-};
-function serialiseTranslationRuntime(value, imports, loadedTranslation) {
-  trace('Serialising translations:', loadedTranslation);
-  const translationsType = {};
-  for (const [key, {
-    params,
-    message,
-    hasTags
-  }] of value.entries()) {
-    let translationFunctionString = `() => ${message}`;
-    if (Object.keys(params).length > 0) {
-      const formatGeneric = hasTags ? '<T = string>' : '';
-      const formatReturn = hasTags && imports.has('FormatXMLElementFn') ? 'ReturnType<FormatXMLElementFn<T>>' : 'string';
-      translationFunctionString = `${formatGeneric}(values: ${serialiseObjectToType(params)}) => ${formatReturn}`;
-    }
-    translationsType[key] = translationFunctionString;
-  }
-  const languagesUnionAsString = Object.keys(loadedTranslation.languages).map(l => `'${l}'`).join(' | ');
-  const languageEntries = Object.entries(loadedTranslation.languages).map(([languageName, translations]) => `${JSON.stringify(languageName)}: createLanguage(${JSON.stringify(getTranslationMessages(translations))})`).join(',');
-  return /* ts */`
-    // This file is automatically generated by Vocab.
-    // To make changes update translation.json files directly.
-
-    ${serializeTypeImports(imports, '@vocab/core')}
-    import { createLanguage, createTranslationFile } from '@vocab/core/runtime';
-
-    const translations = createTranslationFile<
-      ${languagesUnionAsString},
-      ${serialiseObjectToType(translationsType)}
-    >({
-      ${languageEntries}
-    });
-
-    export default translations;
-  `;
-}
-async function generateRuntime(loadedTranslation) {
-  const {
-    languages: loadedLanguages,
-    filePath
-  } = loadedTranslation;
-  trace('Generating types for', filePath);
-  const translationTypes = new Map();
-  let imports = new Set();
-  for (const key of loadedTranslation.keys) {
-    let params = {};
-    const messages = new Set();
-    let hasTags = false;
-    for (const translatedLanguage of Object.values(loadedLanguages)) {
-      if (translatedLanguage[key]) {
-        const ast = parse(translatedLanguage[key].message);
-        hasTags = hasTags || extractHasTags(ast);
-        const [parsedParams, vocabTypesImports] = extractParamTypes(ast, params);
-        imports = new Set([...imports, ...vocabTypesImports]);
-        params = parsedParams;
-        messages.add(JSON.stringify(translatedLanguage[key].message));
-      }
-    }
-    translationTypes.set(key, {
-      params,
-      hasTags,
-      message: Array.from(messages).join(' | ')
-    });
-  }
-  const prettierConfig = await prettier.resolveConfig(filePath);
-  const serializedTranslationType = serialiseTranslationRuntime(translationTypes, imports, loadedTranslation);
-  const declaration = await prettier.format(serializedTranslationType, {
-    ...prettierConfig,
-    parser: 'typescript'
-  });
-  const outputFilePath = getTSFileFromDevLanguageFile(filePath);
-  trace(`Writing translation types to ${outputFilePath}`);
-  await writeIfChanged(outputFilePath, declaration);
-}
-function watch(config) {
-  const cwd = config.projectRoot || process.cwd();
-  const watcher = chokidar.watch([getDevTranslationFileGlob(config), getAltTranslationFileGlob(config), getTranslationFolderGlob(config)], {
-    cwd,
-    ignored: config.ignore ? [...config.ignore, '**/node_modules/**'] : ['**/node_modules/**'],
-    ignoreInitial: true
-  });
-  const onTranslationChange = async relativePath => {
-    trace(`Detected change for file ${relativePath}`);
-    let targetFile;
-    if (isDevLanguageFile(relativePath)) {
-      targetFile = path.resolve(cwd, relativePath);
-    } else if (isAltLanguageFile(relativePath)) {
-      targetFile = getDevLanguageFileFromAltLanguageFile(path.resolve(cwd, relativePath));
-    }
-    if (targetFile) {
-      try {
-        const loadedTranslation = loadTranslation({
-          filePath: targetFile,
-          fallbacks: 'all'
-        }, config);
-        await generateRuntime(loadedTranslation);
-      } catch (e) {
-        // eslint-disable-next-line no-console
-        console.log('Failed to generate types for', relativePath);
-        // eslint-disable-next-line no-console
-        console.error(e);
-      }
-    }
-  };
-  const onNewDirectory = async relativePath => {
-    trace('Detected new directory', relativePath);
-    if (!isTranslationDirectory(relativePath, config)) {
-      trace('Ignoring non-translation directory:', relativePath);
-      return;
-    }
-    const newFilePath = path.join(relativePath, devTranslationFileName);
-    if (!existsSync(newFilePath)) {
-      await promises.writeFile(newFilePath, JSON.stringify({}, null, 2));
-      trace('Created new empty translation file:', newFilePath);
-    } else {
-      trace(`New directory already contains translation file. Skipping creation. Existing file ${newFilePath}`);
-    }
-  };
-  watcher.on('addDir', onNewDirectory);
-  watcher.on('add', onTranslationChange).on('change', onTranslationChange);
-  return () => watcher.close();
-}
-async function compile({
-  watch: shouldWatch = false
-} = {}, config) {
-  const translations = await loadAllTranslations({
-    fallbacks: 'all',
-    includeNodeModules: false
-  }, config);
-  for (const loadedTranslation of translations) {
-    await generateRuntime(loadedTranslation);
-  }
-  if (shouldWatch) {
-    trace('Listening for changes to files...');
-    return watch(config);
-  }
-}
-async function writeIfChanged(filepath, contents) {
-  let hasChanged = true;
-  try {
-    const existingContents = await promises.readFile(filepath, {
-      encoding: 'utf-8'
-    });
-    hasChanged = existingContents !== contents;
-  } catch {
-    // ignore error, likely a file doesn't exist error so we want to write anyway
-  }
-  if (hasChanged) {
-    await promises.writeFile(filepath, contents, {
-      encoding: 'utf-8'
-    });
-  }
-}
-
-/* eslint-disable no-console */
-function findMissingKeys(loadedTranslation, devLanguageName, altLanguages) {
-  const devLanguage = loadedTranslation.languages[devLanguageName];
-  if (!devLanguage) {
-    throw new Error(`Failed to load dev language: ${loadedTranslation.filePath}`);
-  }
-  const result = {};
-  let valid = true;
-  const requiredKeys = Object.keys(devLanguage);
-  if (requiredKeys.length > 0) {
-    for (const altLanguageName of altLanguages) {
-      var _loadedTranslation$la;
-      const altLanguage = (_loadedTranslation$la = loadedTranslation.languages[altLanguageName]) !== null && _loadedTranslation$la !== void 0 ? _loadedTranslation$la : {};
-      for (const key of requiredKeys) {
-        var _altLanguage$key;
-        if (typeof ((_altLanguage$key = altLanguage[key]) === null || _altLanguage$key === void 0 ? void 0 : _altLanguage$key.message) !== 'string') {
-          if (!result[altLanguageName]) {
-            result[altLanguageName] = [];
-          }
-          result[altLanguageName].push(key);
-          valid = false;
-        }
-      }
-    }
-  }
-  return [valid, result];
-}
-async function validate(config) {
-  const allTranslations = await loadAllTranslations({
-    fallbacks: 'valid',
-    includeNodeModules: true
-  }, config);
-  let valid = true;
-  for (const loadedTranslation of allTranslations) {
-    const [translationValid, result] = findMissingKeys(loadedTranslation, config.devLanguage, getAltLanguages(config));
-    if (!translationValid) {
-      valid = false;
-      console.log(pc.red(`Incomplete translations: "${pc.bold(loadedTranslation.relativePath)}"`));
-      for (const lang of Object.keys(result)) {
-        const missingKeys = result[lang];
-        console.log(pc.yellow(lang), '->', missingKeys.map(v => `"${v}"`).join(', '));
-      }
-    }
-  }
-  return valid;
-}
-
-class ValidationError extends Error {
-  constructor(code, message) {
-    super(`Invalid vocab.config.js: ${code} - ${message}`);
-    this.code = code;
-    this.rawMessage = message;
-  }
-}
-
-const boldCyan = s => pc.bold(pc.cyan(s));
-const validator = new Validator();
-const schema = {
-  $$strict: true,
-  devLanguage: {
-    type: 'string'
-  },
-  languages: {
-    type: 'array',
-    items: {
-      type: 'object',
-      props: {
-        name: {
-          type: 'string'
-        },
-        extends: {
-          type: 'string',
-          optional: true
-        }
-      }
-    }
-  },
-  generatedLanguages: {
-    type: 'array',
-    items: {
-      type: 'object',
-      props: {
-        name: {
-          type: 'string'
-        },
-        extends: {
-          type: 'string',
-          optional: true
-        },
-        generator: {
-          type: 'object',
-          props: {
-            transformElement: {
-              type: 'function',
-              optional: true
-            },
-            transformMessage: {
-              type: 'function',
-              optional: true
-            }
-          }
-        }
-      }
-    },
-    optional: true
-  },
-  translationsDirectorySuffix: {
-    type: 'string',
-    optional: true
-  },
-  projectRoot: {
-    type: 'string',
-    optional: true
-  },
-  ignore: {
-    type: 'array',
-    items: 'string',
-    optional: true
-  }
-};
-const checkConfigFile = validator.compile(schema);
-const splitMap = (message, callback) => message.split(' ,').map(v => callback(v)).join(' ,');
-function validateConfig(c) {
-  trace('Validating configuration file');
-  // Note: checkConfigFile mutates the config file by applying defaults
-  const isValid = checkConfigFile(c);
-  if (isValid !== true) {
-    throw new ValidationError('InvalidStructure', (Array.isArray(isValid) ? isValid : []).map(v => {
-      if (v.type === 'objectStrict') {
-        return `Invalid key(s) ${splitMap(v.actual, m => `"${pc.cyan(m)}"`)}. Expected one of ${splitMap(v.expected, pc.green)}`;
-      }
-      if (v.field) {
-        var _v$message;
-        return (_v$message = v.message) === null || _v$message === void 0 ? void 0 : _v$message.replace(v.field, pc.cyan(v.field));
-      }
-      return v.message;
-    }).join(' \n'));
-  }
-  const languageStrings = c.languages.map(v => v.name);
-
-  // Dev Language should exist in languages
-  if (!languageStrings.includes(c.devLanguage)) {
-    throw new ValidationError('InvalidDevLanguage', `The dev language "${boldCyan(c.devLanguage)}" was not found in languages ${languageStrings.join(', ')}.`);
-  }
-  const foundLanguages = [];
-  for (const lang of c.languages) {
-    // Languages must only exist once
-    if (foundLanguages.includes(lang.name)) {
-      throw new ValidationError('DuplicateLanguage', `The language "${boldCyan(lang.name)}" was defined multiple times.`);
-    }
-    foundLanguages.push(lang.name);
-
-    // Any extends must be in languages
-    if (lang.extends && !languageStrings.includes(lang.extends)) {
-      throw new ValidationError('InvalidExtends', `The language "${boldCyan(lang.name)}"'s extends of ${boldCyan(lang.extends)} was not found in languages ${languageStrings.join(', ')}.`);
-    }
-  }
-  const foundGeneratedLanguages = [];
-  for (const generatedLang of c.generatedLanguages || []) {
-    // Generated languages must only exist once
-    if (foundGeneratedLanguages.includes(generatedLang.name)) {
-      throw new ValidationError('DuplicateGeneratedLanguage', `The generated language "${boldCyan(generatedLang.name)}" was defined multiple times.`);
-    }
-    foundGeneratedLanguages.push(generatedLang.name);
-
-    // Generated language names must not conflict with language names
-    if (languageStrings.includes(generatedLang.name)) {
-      throw new ValidationError('InvalidGeneratedLanguage', `The generated language "${boldCyan(generatedLang.name)}" is already defined as a language.`);
-    }
-
-    // Any extends must be in languages
-    if (generatedLang.extends && !languageStrings.includes(generatedLang.extends)) {
-      throw new ValidationError('InvalidExtends', `The generated language "${boldCyan(generatedLang.name)}"'s extends of ${boldCyan(generatedLang.extends)} was not found in languages ${languageStrings.join(', ')}.`);
-    }
-  }
-  trace('Configuration file is valid');
-  return true;
-}
-function createConfig(configFilePath) {
-  const cwd = path.dirname(configFilePath);
-  return {
-    projectRoot: cwd,
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    ...require(configFilePath)
-  };
-}
-async function resolveConfig(customConfigFilePath) {
-  const configFilePath = customConfigFilePath ? path.resolve(customConfigFilePath) : await findUp(['vocab.config.js', 'vocab.config.cjs']);
-  if (configFilePath) {
-    trace(`Resolved configuration file to ${configFilePath}`);
-    return createConfig(configFilePath);
-  }
-  trace('No configuration file found');
-  return null;
-}
-function resolveConfigSync(customConfigFilePath) {
-  const configFilePath = customConfigFilePath ? path.resolve(customConfigFilePath) : findUp.sync(['vocab.config.js', 'vocab.config.cjs']);
-  if (configFilePath) {
-    trace(`Resolved configuration file to ${configFilePath}`);
-    return createConfig(configFilePath);
-  }
-  trace('No configuration file found');
-  return null;
-}
-
-export { compile, getAltLanguageFilePath, getAltLanguages, getDevLanguageFileFromTsFile, getUniqueKey, loadAllTranslations, loadTranslation, resolveConfig, resolveConfigSync, validate, validateConfig, watch };