@vocab/core 1.1.2 → 1.2.1

package/dist/vocab-core.cjs.prod.js

@@ -27,7 +27,7 @@ var IntlMessageFormat__default = /*#__PURE__*/_interopDefault(IntlMessageFormat)
 var findUp__default = /*#__PURE__*/_interopDefault(findUp);
 var Validator__default = /*#__PURE__*/_interopDefault(Validator);
 
-const trace = debug__default['default'](`vocab:core`);
+const trace = debug__default["default"](`vocab:core`);
 
 const defaultTranslationDirSuffix = '.vocab';
 const devTranslationFileName = 'translations.json';
@@ -74,37 +74,35 @@ function getAltLanguages({
   return languages.map(v => v.name).filter(lang => lang !== devLanguage);
 }
 function getDevLanguageFileFromTsFile(tsFilePath) {
-  const directory = path__default['default'].dirname(tsFilePath);
-  const result = path__default['default'].normalize(path__default['default'].join(directory, devTranslationFileName));
+  const directory = path__default["default"].dirname(tsFilePath);
+  const result = path__default["default"].normalize(path__default["default"].join(directory, devTranslationFileName));
   trace(`Returning dev language path ${result} for path ${tsFilePath}`);
   return result;
 }
 function getDevLanguageFileFromAltLanguageFile(altLanguageFilePath) {
-  const directory = path__default['default'].dirname(altLanguageFilePath);
-  const result = path__default['default'].normalize(path__default['default'].join(directory, devTranslationFileName));
+  const directory = path__default["default"].dirname(altLanguageFilePath);
+  const result = path__default["default"].normalize(path__default["default"].join(directory, devTranslationFileName));
   trace(`Returning dev language path ${result} for path ${altLanguageFilePath}`);
   return result;
 }
 function getTSFileFromDevLanguageFile(devLanguageFilePath) {
-  const directory = path__default['default'].dirname(devLanguageFilePath);
-  const result = path__default['default'].normalize(path__default['default'].join(directory, 'index.ts'));
+  const directory = path__default["default"].dirname(devLanguageFilePath);
+  const result = path__default["default"].normalize(path__default["default"].join(directory, 'index.ts'));
   trace(`Returning TS path ${result} for path ${devLanguageFilePath}`);
   return result;
 }
 function getAltLanguageFilePath(devLanguageFilePath, language) {
-  const directory = path__default['default'].dirname(devLanguageFilePath);
-  const result = path__default['default'].normalize(path__default['default'].join(directory, `${language}.translations.json`));
+  const directory = path__default["default"].dirname(devLanguageFilePath);
+  const result = path__default["default"].normalize(path__default["default"].join(directory, `${language}.translations.json`));
   trace(`Returning alt language path ${result} for path ${devLanguageFilePath}`);
-  return path__default['default'].normalize(result);
+  return path__default["default"].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) {
@@ -118,60 +116,49 @@ function generateLanguageFromTranslations({
   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__default['default'](translation.message).getAst();
+      const messageAst = new IntlMessageFormat__default["default"](translation.message).getAst();
       const transformedAst = messageAst.map(transformMessageFormatElement(generator.transformElement));
       transformedMessage = printer.printAST(transformedAst);
     }
-
     if (generator.transformMessage) {
       transformedMessage = generator.transformMessage(transformedMessage);
     }
-
     generatedTranslations[translationKey] = {
       message: transformedMessage
     };
   }
-
   return generatedTranslations;
 }
-
 function transformMessageFormatElement(transformElement) {
   return messageFormatElement => {
-    const transformedMessageFormatElement = { ...messageFormatElement
+    const transformedMessageFormatElement = {
+      ...messageFormatElement
     };
-
     switch (transformedMessageFormatElement.type) {
       case icuMessageformatParser.TYPE.literal:
         const transformedValue = transformElement(transformedMessageFormatElement.value);
         transformedMessageFormatElement.value = transformedValue;
         break;
-
       case icuMessageformatParser.TYPE.select:
       case icuMessageformatParser.TYPE.plural:
-        const transformedOptions = { ...transformedMessageFormatElement.options
+        const transformedOptions = {
+          ...transformedMessageFormatElement.options
         };
-
         for (const key of Object.keys(transformedOptions)) {
           transformedOptions[key].value = transformedOptions[key].value.map(transformMessageFormatElement(transformElement));
         }
-
         break;
-
       case icuMessageformatParser.TYPE.tag:
         const transformedChildren = transformedMessageFormatElement.children.map(transformMessageFormatElement(transformElement));
         transformedMessageFormatElement.children = transformedChildren;
         break;
     }
-
     return transformedMessageFormatElement;
   };
 }
@@ -186,7 +173,6 @@ function mergeWithDevLanguageTranslation({
   // Only use keys from the dev translation
   const keys = Object.keys(devTranslation);
   const newLanguage = {};
-
   for (const key of keys) {
     if (translation[key]) {
       newLanguage[key] = {
@@ -195,24 +181,19 @@ function mergeWithDevLanguageTranslation({
       };
     }
   }
-
   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
 }) {
@@ -220,19 +201,15 @@ function getLanguageHierarchy({
   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({
@@ -244,89 +221,87 @@ function getFallbackLanguageOrder({
   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__default['default'].dirname(relativePath).replace(/^src\//, '').replace(/\//g, '_');
-
+  let namespace = path__default["default"].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__default['default'].red('Error loading translation:'), ...params);
+  console.error(chalk__default["default"].red('Error loading translation:'), ...params);
 }
-
-function getTranslationsFromFile(translations, {
+function getTranslationsFromFile(translationFileContents, {
   isAltLanguage,
-  filePath
+  filePath,
+  withTags
 }) {
-  if (!translations || typeof translations !== 'object') {
-    throw new Error(`Unable to read translation file ${filePath}. Translations must be an object`);
+  if (!translationFileContents || typeof translationFileContents !== 'object') {
+    throw new Error(`Unable to read translation file ${filePath}. Translations must be an object.`);
   }
-
   const {
     $namespace,
+    _meta,
     ...keys
-  } = translations;
-
+  } = 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, translation] of Object.entries(keys)) {
+  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;
+    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
+    keys: validKeys,
+    metadata
   };
 }
-
 function loadAltLanguageFile({
   filePath,
   languageName,
@@ -344,15 +319,12 @@ function loadAltLanguageFile({
     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, {
@@ -371,41 +343,46 @@ function loadAltLanguageFile({
       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
+  fallbacks,
+  withTags
 }, userConfig) {
   trace(`Loading translation file in "${fallbacks}" fallback mode: "${filePath}"`);
   const languageSet = {};
   delete require.cache[filePath];
-
   const translationContent = require(filePath);
-
-  const relativePath = path__default['default'].relative(userConfig.projectRoot || process.cwd(), filePath);
+  const relativePath = path__default["default"].relative(userConfig.projectRoot || process.cwd(), filePath);
   const {
     $namespace,
-    keys: devTranslation
+    keys: devTranslation,
+    metadata
   } = getTranslationsFromFile(translationContent, {
     filePath,
-    isAltLanguage: false
+    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,
+      devTranslation: devTranslationNoTags,
       fallbacks
     }, userConfig);
   }
-
   for (const generatedLanguage of userConfig.generatedLanguages || []) {
     const {
       name: generatedLanguageName,
@@ -418,24 +395,25 @@ function loadTranslation({
       generator
     });
   }
-
   return {
     filePath,
     keys: Object.keys(devTranslation),
     namespace,
     relativePath,
-    languages: languageSet
+    languages: languageSet,
+    metadata
   };
 }
 async function loadAllTranslations({
   fallbacks,
-  includeNodeModules
+  includeNodeModules,
+  withTags
 }, config) {
   const {
     projectRoot,
     ignore = []
   } = config;
-  const translationFiles = await glob__default['default'](getDevTranslationFileGlob(config), {
+  const translationFiles = await glob__default["default"](getDevTranslationFileGlob(config), {
     ignore: includeNodeModules ? ignore : [...ignore, '**/node_modules/**'],
     absolute: true,
     cwd: projectRoot
@@ -443,45 +421,37 @@ async function loadAllTranslations({
   trace(`Found ${translationFiles.length} translation files`);
   const result = await Promise.all(translationFiles.map(filePath => loadTranslation({
     filePath,
-    fallbacks
+    fallbacks,
+    withTags
   }, 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 (icuMessageformatParser.isSelectElement(element)) {
       const children = Object.values(element.options).map(o => o.value);
       return children.some(child => extractHasTags(child));
     }
-
     return icuMessageformatParser.isTagElement(element);
   });
 }
-
 function extractParamTypes(ast) {
   let params = {};
   let imports = new Set();
-
   for (const element of ast) {
     if (icuMessageformatParser.isArgumentElement(element)) {
       params[element.value] = 'string';
@@ -489,6 +459,15 @@ function extractParamTypes(ast) {
       params[element.value] = 'number';
     } else if (icuMessageformatParser.isPluralElement(element)) {
       params[element.value] = 'number';
+      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
+        };
+      }
     } else if (icuMessageformatParser.isDateElement(element) || icuMessageformatParser.isTimeElement(element)) {
       params[element.value] = 'Date | number';
     } else if (icuMessageformatParser.isTagElement(element)) {
@@ -496,29 +475,27 @@ function extractParamTypes(ast) {
       imports.add(`import { FormatXMLElementFn } from '@vocab/types';`);
       const [subParams, subImports] = extractParamTypes(element.children);
       imports = new Set([...imports, ...subImports]);
-      params = { ...params,
+      params = {
+        ...params,
         ...subParams
       };
     } else if (icuMessageformatParser.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,
+        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)},`;
@@ -526,32 +503,25 @@ function serialiseObjectToType(v) {
       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}
@@ -563,34 +533,31 @@ function serialiseTranslationRuntime(value, imports, loadedTranslation) {
 
   export default translations;`;
 }
-
 async function generateRuntime(loadedTranslation) {
   const {
     languages: loadedLanguages,
     filePath
   } = loadedTranslation;
-  trace('Generating types for', loadedTranslation.filePath);
+  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 = icuMessageformatParser.parse(translatedLanguage[key].message);
         hasTags = hasTags || extractHasTags(ast);
         const [parsedParams, parsedImports] = extractParamTypes(ast);
         imports = new Set([...imports, ...parsedImports]);
-        params = { ...params,
+        params = {
+          ...params,
           ...parsedParams
         };
         messages.add(`'${encodeWithinSingleQuotes(translatedLanguage[key].message)}'`);
       }
     }
-
     const returnType = hasTags ? 'NonNullable<ReactNode>' : 'string';
     translationTypes.set(key, {
       params,
@@ -599,10 +566,10 @@ async function generateRuntime(loadedTranslation) {
       returnType
     });
   }
-
-  const prettierConfig = await prettier__default['default'].resolveConfig(filePath);
+  const prettierConfig = await prettier__default["default"].resolveConfig(filePath);
   const serializedTranslationType = serialiseTranslationRuntime(translationTypes, imports, loadedTranslation);
-  const declaration = prettier__default['default'].format(serializedTranslationType, { ...prettierConfig,
+  const declaration = prettier__default["default"].format(serializedTranslationType, {
+    ...prettierConfig,
     parser: 'typescript'
   });
   const outputFilePath = getTSFileFromDevLanguageFile(filePath);
@@ -611,48 +578,41 @@ async function generateRuntime(loadedTranslation) {
 }
 function watch(config) {
   const cwd = config.projectRoot || process.cwd();
-  const watcher = chokidar__default['default'].watch([getDevTranslationFileGlob(config), getAltTranslationFileGlob(config), getTranslationFolderGlob(config)], {
+  const watcher = chokidar__default["default"].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__default['default'].resolve(cwd, relativePath);
+      targetFile = path__default["default"].resolve(cwd, relativePath);
     } else if (isAltLanguageFile(relativePath)) {
-      targetFile = getDevLanguageFileFromAltLanguageFile(path__default['default'].resolve(cwd, relativePath));
+      targetFile = getDevLanguageFileFromAltLanguageFile(path__default["default"].resolve(cwd, relativePath));
     }
-
     if (targetFile) {
       try {
-        const loadedTranslation = await loadTranslation({
+        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.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__default['default'].join(relativePath, devTranslationFileName);
-
+    const newFilePath = path__default["default"].join(relativePath, devTranslationFileName);
     if (!fs.existsSync(newFilePath)) {
       await fs.promises.writeFile(newFilePath, JSON.stringify({}, null, 2));
       trace('Created new empty translation file:', newFilePath);
@@ -660,7 +620,6 @@ function watch(config) {
       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();
@@ -672,28 +631,24 @@ async function compile({
     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 fs.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
+  } catch (e) {
+    // ignore error, likely a file doesn't exist error so we want to write anyway
   }
-
   if (hasChanged) {
     await fs.promises.writeFile(filepath, contents, {
       encoding: 'utf-8'
@@ -704,36 +659,28 @@ async function writeIfChanged(filepath, contents) {
 /* 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) {
@@ -742,21 +689,17 @@ async function validate(config) {
     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__default['default'].red`Incomplete translations: "${chalk__default['default'].bold(loadedTranslation.relativePath)}"`);
-
+      console.log(chalk__default["default"].red`Incomplete translations: "${chalk__default["default"].bold(loadedTranslation.relativePath)}"`);
       for (const lang of Object.keys(result)) {
         const missingKeys = result[lang];
-        console.log(chalk__default['default'].yellow(lang), '->', missingKeys.map(v => `"${v}"`).join(', '));
+        console.log(chalk__default["default"].yellow(lang), '->', missingKeys.map(v => `"${v}"`).join(', '));
       }
     }
   }
-
   return valid;
 }
 
@@ -766,10 +709,9 @@ class ValidationError extends Error {
     this.code = code;
     this.rawMessage = message;
   }
-
 }
 
-const validator = new Validator__default['default']();
+const validator = new Validator__default["default"]();
 const schema = {
   $$strict: true,
   devLanguage: {
@@ -834,102 +776,85 @@ const schema = {
   }
 };
 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
-
+  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__default['default'].cyan(m)}"`)}. Expected one of ${splitMap(v.expected, chalk__default['default'].green)}`;
+        return `Invalid key(s) ${splitMap(v.actual, m => `"${chalk__default["default"].cyan(m)}"`)}. Expected one of ${splitMap(v.expected, chalk__default["default"].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__default['default'].cyan(v.field));
+        return (_v$message = v.message) === null || _v$message === void 0 ? void 0 : _v$message.replace(v.field, chalk__default["default"].cyan(v.field));
       }
-
       return v.message;
     }).join(' \n'));
   }
+  const languageStrings = c.languages.map(v => v.name);
 
-  const languageStrings = c.languages.map(v => v.name); // Dev Language should exist in languages
-
+  // Dev Language should exist in languages
   if (!languageStrings.includes(c.devLanguage)) {
-    throw new ValidationError('InvalidDevLanguage', `The dev language "${chalk__default['default'].bold.cyan(c.devLanguage)}" was not found in languages ${languageStrings.join(', ')}.`);
+    throw new ValidationError('InvalidDevLanguage', `The dev language "${chalk__default["default"].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__default['default'].bold.cyan(lang.name)}" was defined multiple times.`);
+      throw new ValidationError('DuplicateLanguage', `The language "${chalk__default["default"].bold.cyan(lang.name)}" was defined multiple times.`);
     }
+    foundLanguages.push(lang.name);
 
-    foundLanguages.push(lang.name); // Any extends must be in languages
-
+    // Any extends must be in languages
     if (lang.extends && !languageStrings.includes(lang.extends)) {
-      throw new ValidationError('InvalidExtends', `The language "${chalk__default['default'].bold.cyan(lang.name)}"'s extends of ${chalk__default['default'].bold.cyan(lang.extends)} was not found in languages ${languageStrings.join(', ')}.`);
+      throw new ValidationError('InvalidExtends', `The language "${chalk__default["default"].bold.cyan(lang.name)}"'s extends of ${chalk__default["default"].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__default['default'].bold.cyan(generatedLang.name)}" was defined multiple times.`);
+      throw new ValidationError('DuplicateGeneratedLanguage', `The generated language "${chalk__default["default"].bold.cyan(generatedLang.name)}" was defined multiple times.`);
     }
+    foundGeneratedLanguages.push(generatedLang.name);
 
-    foundGeneratedLanguages.push(generatedLang.name); // Generated language names must not conflict with language names
-
+    // Generated language names must not conflict with language names
     if (languageStrings.includes(generatedLang.name)) {
-      throw new ValidationError('InvalidGeneratedLanguage', `The generated language "${chalk__default['default'].bold.cyan(generatedLang.name)}" is already defined as a language.`);
-    } // Any extends must be in languages
-
+      throw new ValidationError('InvalidGeneratedLanguage', `The generated language "${chalk__default["default"].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__default['default'].bold.cyan(generatedLang.name)}"'s extends of ${chalk__default['default'].bold.cyan(generatedLang.extends)} was not found in languages ${languageStrings.join(', ')}.`);
+      throw new ValidationError('InvalidExtends', `The generated language "${chalk__default["default"].bold.cyan(generatedLang.name)}"'s extends of ${chalk__default["default"].bold.cyan(generatedLang.extends)} was not found in languages ${languageStrings.join(', ')}.`);
     }
   }
-
   trace('Configuration file is valid');
   return true;
 }
-
 function createConfig(configFilePath) {
-  const cwd = path__default['default'].dirname(configFilePath);
+  const cwd = path__default["default"].dirname(configFilePath);
   return {
     projectRoot: cwd,
     ...require(configFilePath)
   };
 }
-
 async function resolveConfig(customConfigFilePath) {
-  const configFilePath = customConfigFilePath ? path__default['default'].resolve(customConfigFilePath) : await findUp__default['default']('vocab.config.js');
-
+  const configFilePath = customConfigFilePath ? path__default["default"].resolve(customConfigFilePath) : await findUp__default["default"]('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__default['default'].resolve(customConfigFilePath) : findUp__default['default'].sync('vocab.config.js');
-
+  const configFilePath = customConfigFilePath ? path__default["default"].resolve(customConfigFilePath) : findUp__default["default"].sync('vocab.config.js');
   if (configFilePath) {
     trace(`Resolved configuration file to ${configFilePath}`);
     return createConfig(configFilePath);
   }
-
   trace('No configuration file found');
   return null;
 }