@vocab/core 0.0.0-intl-dep-bump-202301323944

package/dist/vocab-core.esm.js

@@ -0,0 +1,921 @@
+import { existsSync, promises } from 'fs';
+import path from 'path';
+import { TYPE, parse, isSelectElement, isTagElement, isArgumentElement, isNumberElement, isPluralElement, isDateElement, isTimeElement } from '@formatjs/icu-messageformat-parser';
+import prettier from 'prettier';
+import chokidar from 'chokidar';
+import chalk from 'chalk';
+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(chalk.red('Error loading translation:'), ...params);
+}
+
+function getTranslationsFromFile(translations, {
+  isAltLanguage,
+  filePath
+}) {
+  if (!translations || typeof translations !== 'object') {
+    throw new Error(`Unable to read translation file ${filePath}. Translations must be an object`);
+  }
+
+  const {
+    $namespace,
+    ...keys
+  } = translations;
+
+  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.`);
+  }
+
+  const validKeys = {};
+
+  for (const [translationKey, 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;
+  }
+
+  return {
+    $namespace,
+    keys: validKeys
+  };
+}
+
+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];
+
+        const translationFile = require(altFilePath);
+
+        const {
+          keys: fallbackLanguageTranslation
+        } = getTranslationsFromFile(translationFile, {
+          filePath: altFilePath,
+          isAltLanguage: true
+        });
+        Object.assign(altLanguageTranslation, mergeWithDevLanguageTranslation({
+          translation: fallbackLanguageTranslation,
+          devTranslation
+        }));
+      } catch (e) {
+        trace(`Missing alt language file ${getAltLanguageFilePath(filePath, fallbackLanguage)}
+        `);
+      }
+    } else {
+      Object.assign(altLanguageTranslation, devTranslation);
+    }
+  }
+
+  return altLanguageTranslation;
+}
+function loadTranslation({
+  filePath,
+  fallbacks
+}, userConfig) {
+  trace(`Loading translation file in "${fallbacks}" fallback mode: "${filePath}"`);
+  const languageSet = {};
+  delete require.cache[filePath];
+
+  const translationContent = require(filePath);
+
+  const relativePath = path.relative(userConfig.projectRoot || process.cwd(), filePath);
+  const {
+    $namespace,
+    keys: devTranslation
+  } = getTranslationsFromFile(translationContent, {
+    filePath,
+    isAltLanguage: false
+  });
+  const namespace = typeof $namespace === 'string' ? $namespace : getNamespaceByFilePath(relativePath, userConfig);
+  trace(`Found file ${filePath}. Using namespace ${namespace}`);
+  languageSet[userConfig.devLanguage] = devTranslation;
+  const altLanguages = getAltLanguages(userConfig);
+
+  for (const languageName of altLanguages) {
+    languageSet[languageName] = loadAltLanguageFile({
+      filePath,
+      languageName,
+      devTranslation,
+      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
+  };
+}
+async function loadAllTranslations({
+  fallbacks,
+  includeNodeModules
+}, 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 result = await Promise.all(translationFiles.map(filePath => loadTranslation({
+    filePath,
+    fallbacks
+  }, config)));
+  const keys = new Set();
+
+  for (const loadedTranslation of result) {
+    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);
+    }
+  }
+
+  return result;
+}
+
+const encodeWithinSingleQuotes = v => v.replace(/'/g, "\\'");
+
+const encodeBackslash = v => v.replace(/\\/g, '\\\\');
+
+function extractHasTags(ast) {
+  return ast.some(element => {
+    if (isSelectElement(element)) {
+      const children = Object.values(element.options).map(o => o.value);
+      return children.some(child => extractHasTags(child));
+    }
+
+    return isTagElement(element);
+  });
+}
+
+function extractParamTypes(ast) {
+  let params = {};
+  let imports = new Set();
+
+  for (const element of ast) {
+    if (isArgumentElement(element)) {
+      params[element.value] = 'string';
+    } else if (isNumberElement(element)) {
+      params[element.value] = 'number';
+    } else if (isPluralElement(element)) {
+      params[element.value] = 'number';
+    } else if (isDateElement(element) || isTimeElement(element)) {
+      params[element.value] = 'Date | number';
+    } else if (isTagElement(element)) {
+      params[element.value] = 'FormatXMLElementFn<T>';
+      imports.add(`import { FormatXMLElementFn } from '@vocab/types';`);
+      const [subParams, subImports] = extractParamTypes(element.children);
+      imports = new Set([...imports, ...subImports]);
+      params = { ...params,
+        ...subParams
+      };
+    } else if (isSelectElement(element)) {
+      params[element.value] = Object.keys(element.options).map(o => `'${o}'`).join(' | ');
+      const children = Object.values(element.options).map(o => o.value);
+
+      for (const child of children) {
+        const [subParams, subImports] = extractParamTypes(child);
+        imports = new Set([...imports, ...subImports]);
+        params = { ...params,
+          ...subParams
+        };
+      }
+    }
+  }
+
+  return [params, imports];
+}
+
+function serialiseObjectToType(v) {
+  let result = '';
+
+  for (const [key, value] of Object.entries(v)) {
+    if (value && typeof value === 'object') {
+      result += `'${encodeWithinSingleQuotes(key)}': ${serialiseObjectToType(value)},`;
+    } else {
+      result += `'${encodeWithinSingleQuotes(key)}': ${value},`;
+    }
+  }
+
+  return `{ ${result} }`;
+}
+
+const banner = `// This file is automatically generated by Vocab.\n// To make changes update translation.json files directly.`;
+
+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 ? 'string | T | Array<string | T>' : 'string';
+      translationFunctionString = `${formatGeneric}(values: ${serialiseObjectToType(params)}) => ${formatReturn}`;
+    }
+
+    translationsType[encodeBackslash(key)] = translationFunctionString;
+  }
+
+  const content = Object.entries(loadedTranslation.languages).map(([languageName, translations]) => `'${encodeWithinSingleQuotes(languageName)}': createLanguage(${JSON.stringify(getTranslationMessages(translations))})`).join(',');
+  const languagesUnionAsString = Object.keys(loadedTranslation.languages).map(l => `'${l}'`).join(' | ');
+  return `${banner}
+
+  ${Array.from(imports).join('\n')}
+  import { createLanguage, createTranslationFile } from '@vocab/core/runtime';
+
+  const translations = createTranslationFile<${languagesUnionAsString}, ${serialiseObjectToType(translationsType)}>({${content}});
+
+  export default translations;`;
+}
+
+async function generateRuntime(loadedTranslation) {
+  const {
+    languages: loadedLanguages,
+    filePath
+  } = loadedTranslation;
+  trace('Generating types for', loadedTranslation.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, parsedImports] = extractParamTypes(ast);
+        imports = new Set([...imports, ...parsedImports]);
+        params = { ...params,
+          ...parsedParams
+        };
+        messages.add(`'${encodeWithinSingleQuotes(translatedLanguage[key].message)}'`);
+      }
+    }
+
+    const returnType = hasTags ? 'NonNullable<ReactNode>' : 'string';
+    translationTypes.set(key, {
+      params,
+      hasTags,
+      message: Array.from(messages).join(' | '),
+      returnType
+    });
+  }
+
+  const prettierConfig = await prettier.resolveConfig(filePath);
+  const serializedTranslationType = serialiseTranslationRuntime(translationTypes, imports, loadedTranslation);
+  const declaration = 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 = await 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 (e) {// 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(chalk.red`Incomplete translations: "${chalk.bold(loadedTranslation.relativePath)}"`);
+
+      for (const lang of Object.keys(result)) {
+        const missingKeys = result[lang];
+        console.log(chalk.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 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 => `"${chalk.cyan(m)}"`)}. Expected one of ${splitMap(v.expected, chalk.green)}`;
+      }
+
+      if (v.field) {
+        var _v$message;
+
+        return (_v$message = v.message) === null || _v$message === void 0 ? void 0 : _v$message.replace(v.field, chalk.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 "${chalk.bold.cyan(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 "${chalk.bold.cyan(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 "${chalk.bold.cyan(lang.name)}"'s extends of ${chalk.bold.cyan(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 "${chalk.bold.cyan(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 "${chalk.bold.cyan(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 "${chalk.bold.cyan(generatedLang.name)}"'s extends of ${chalk.bold.cyan(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,
+    ...require(configFilePath)
+  };
+}
+
+async function resolveConfig(customConfigFilePath) {
+  const configFilePath = customConfigFilePath ? path.resolve(customConfigFilePath) : await findUp('vocab.config.js');
+
+  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');
+
+  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 };