@vocab/core 1.0.3 → 1.1.1

package/dist/vocab-core.esm.js

@@ -1,11 +1,13 @@
 import { existsSync, promises } from 'fs';
 import path from 'path';
-import { parse, isSelectElement, isTagElement, isArgumentElement, isNumberElement, isPluralElement, isDateElement, isTimeElement } from '@formatjs/icu-messageformat-parser';
+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';
 
@@ -93,11 +95,78 @@ 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 mergeWithDevLanguage(translation, devTranslation) {
+function mergeWithDevLanguageTranslation({
+  translation,
+  devTranslation
+}) {
   // Only use keys from the dev translation
   const keys = Object.keys(devTranslation);
   const newLanguage = {};
@@ -128,7 +197,7 @@ function getLanguageFallbacks({
   return languageFallbackMap;
 }
 
-function getLanguageHierarcy({
+function getLanguageHierarchy({
   languages
 }) {
   const hierarchyMap = new Map();
@@ -137,19 +206,45 @@ function getLanguageHierarcy({
   });
 
   for (const lang of languages) {
-    const langHierachy = [];
+    const langHierarchy = [];
     let currLang = lang.extends;
 
     while (currLang) {
-      langHierachy.push(currLang);
+      langHierarchy.push(currLang);
       currLang = fallbacks.get(currLang);
     }
 
-    hierarchyMap.set(lang.name, langHierachy);
+    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
@@ -193,17 +288,17 @@ function getTranslationsFromFile(translations, {
 
   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 {mesage: 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 {mesage: string}.`);
+      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 {mesage: string}.`);
+      printValidationError(`No message found for translation "${translationKey}" in ${filePath}. Translation must be an object of the format {message: string}.`);
       continue;
     }
 
@@ -225,54 +320,44 @@ function loadAltLanguageFile({
   devLanguage,
   languages
 }) {
-  const result = {};
-  const languageHierarchy = getLanguageHierarcy({
-    languages
-  }).get(languageName);
-
-  if (!languageHierarchy) {
-    throw new Error(`Missing language hierarchy for ${languageName}`);
-  }
-
-  const fallbackLanguages = [languageName];
-
-  if (fallbacks !== 'none') {
-    fallbackLanguages.unshift(...languageHierarchy);
-
-    if (fallbacks === 'all' && fallbackLanguages[0] !== devLanguage) {
-      fallbackLanguages.unshift(devLanguage);
-    }
-  }
-
-  trace(`Loading alt language file with precendence: ${fallbackLanguages.slice().reverse().join(' -> ')}`);
+  const altLanguageTranslation = {};
+  const fallbackLanguageOrder = getFallbackLanguageOrder({
+    languages,
+    languageName,
+    devLanguage,
+    fallbacks
+  });
+  trace(`Loading alt language file with precedence: ${fallbackLanguageOrder.slice().reverse().join(' -> ')}`);
 
-  for (const fallbackLang of fallbackLanguages) {
-    if (fallbackLang !== devLanguage) {
+  for (const fallbackLanguage of fallbackLanguageOrder) {
+    if (fallbackLanguage !== devLanguage) {
       try {
-        const altFilePath = getAltLanguageFilePath(filePath, fallbackLang);
+        const altFilePath = getAltLanguageFilePath(filePath, fallbackLanguage);
         delete require.cache[altFilePath];
 
         const translationFile = require(altFilePath);
 
         const {
-          keys
+          keys: fallbackLanguageTranslation
         } = getTranslationsFromFile(translationFile, {
           filePath: altFilePath,
           isAltLanguage: true
         });
-        Object.assign(result, mergeWithDevLanguage(keys, devTranslation));
+        Object.assign(altLanguageTranslation, mergeWithDevLanguageTranslation({
+          translation: fallbackLanguageTranslation,
+          devTranslation
+        }));
       } catch (e) {
-        trace(`Missing alt language file ${getAltLanguageFilePath(filePath, fallbackLang)}
+        trace(`Missing alt language file ${getAltLanguageFilePath(filePath, fallbackLanguage)}
         `);
       }
     } else {
-      Object.assign(result, devTranslation);
+      Object.assign(altLanguageTranslation, devTranslation);
     }
   }
 
-  return result;
+  return altLanguageTranslation;
 }
-
 function loadTranslation({
   filePath,
   fallbacks
@@ -305,6 +390,19 @@ function loadTranslation({
     }, 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),
@@ -588,7 +686,7 @@ async function writeIfChanged(filepath, contents) {
 }
 
 /* eslint-disable no-console */
-function findMissingKeys(loadedTranslation, devLanguageName, altLangauges) {
+function findMissingKeys(loadedTranslation, devLanguageName, altLanguages) {
   const devLanguage = loadedTranslation.languages[devLanguageName];
 
   if (!devLanguage) {
@@ -600,7 +698,7 @@ function findMissingKeys(loadedTranslation, devLanguageName, altLangauges) {
   const requiredKeys = Object.keys(devLanguage);
 
   if (requiredKeys.length > 0) {
-    for (const altLanguageName of altLangauges) {
+    for (const altLanguageName of altLanguages) {
       var _loadedTranslation$la;
 
       const altLanguage = (_loadedTranslation$la = loadedTranslation.languages[altLanguageName]) !== null && _loadedTranslation$la !== void 0 ? _loadedTranslation$la : {};
@@ -676,6 +774,35 @@ const schema = {
       }
     }
   },
+  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
@@ -713,13 +840,12 @@ function validateConfig(c) {
 
       return v.message;
     }).join(' \n'));
-  } // Dev Language should exist in languages
-
+  }
 
-  const languageStrings = c.languages.map(v => v.name);
+  const languageStrings = c.languages.map(v => v.name); // Dev Language should exist in languages
 
   if (!languageStrings.includes(c.devLanguage)) {
-    throw new ValidationError('InvalidDevLanguage', `InvalidDevLanguage: The dev language "${chalk.bold.cyan(c.devLanguage)}" was not found in languages ${languageStrings.join(', ')}.`);
+    throw new ValidationError('InvalidDevLanguage', `The dev language "${chalk.bold.cyan(c.devLanguage)}" was not found in languages ${languageStrings.join(', ')}.`);
   }
 
   const foundLanguages = [];
@@ -737,6 +863,26 @@ function validateConfig(c) {
     }
   }
 
+  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;
 }

package/package.json

@@ -1,8 +1,27 @@
 {
   "name": "@vocab/core",
-  "version": "1.0.3",
+  "version": "1.1.1",
   "main": "dist/vocab-core.cjs.js",
   "module": "dist/vocab-core.esm.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./dist/vocab-core.esm.js",
+      "default": "./dist/vocab-core.cjs.js"
+    },
+    "./icu-handler": {
+      "module": "./icu-handler/dist/vocab-core-icu-handler.esm.js",
+      "default": "./icu-handler/dist/vocab-core-icu-handler.cjs.js"
+    },
+    "./runtime": {
+      "module": "./runtime/dist/vocab-core-runtime.esm.js",
+      "default": "./runtime/dist/vocab-core-runtime.cjs.js"
+    },
+    "./translation-file": {
+      "module": "./translation-file/dist/vocab-core-translation-file.esm.js",
+      "default": "./translation-file/dist/vocab-core-translation-file.cjs.js"
+    }
+  },
   "author": "SEEK",
   "license": "MIT",
   "preconstruct": {
@@ -13,9 +32,15 @@
       "translation-file.ts"
     ]
   },
+  "files": [
+    "dist",
+    "runtime",
+    "icu-handler",
+    "translation-file"
+  ],
   "dependencies": {
     "@formatjs/icu-messageformat-parser": "^2.0.10",
-    "@vocab/types": "^1.0.1",
+    "@vocab/types": "^1.1.0",
     "chalk": "^4.1.0",
     "chokidar": "^3.4.3",
     "debug": "^4.3.1",

package/src/ValidationError.ts

@@ -1,9 +0,0 @@
-export class ValidationError extends Error {
-  code: string;
-  rawMessage: string;
-  constructor(code: string, message: string) {
-    super(`Invalid vocab.config.js: ${code} - ${message}`);
-    this.code = code;
-    this.rawMessage = message;
-  }
-}