@vocab/core 1.0.4 → 1.1.0

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,6 +95,71 @@ 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}`;
 }
@@ -221,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;
     }
 
@@ -323,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),
@@ -694,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
@@ -731,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 = [];
@@ -755,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,6 +1,6 @@
 {
   "name": "@vocab/core",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "main": "dist/vocab-core.cjs.js",
   "module": "dist/vocab-core.esm.js",
   "author": "SEEK",
@@ -13,9 +13,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;
-  }
-}

package/src/compile.ts

@@ -1,329 +0,0 @@
-import { promises as fs, existsSync } from 'fs';
-import path from 'path';
-
-import { LoadedTranslation, UserConfig } from '@vocab/types';
-import {
-  isArgumentElement,
-  isDateElement,
-  isNumberElement,
-  isPluralElement,
-  isSelectElement,
-  isTagElement,
-  isTimeElement,
-  MessageFormatElement,
-  parse,
-} from '@formatjs/icu-messageformat-parser';
-import prettier from 'prettier';
-import chokidar from 'chokidar';
-
-import {
-  getTranslationMessages,
-  getDevTranslationFileGlob,
-  getTSFileFromDevLanguageFile,
-  getDevLanguageFileFromAltLanguageFile,
-  getAltTranslationFileGlob,
-  isDevLanguageFile,
-  isAltLanguageFile,
-  getTranslationFolderGlob,
-  devTranslationFileName,
-  isTranslationDirectory,
-} from './utils';
-import { trace } from './logger';
-import { loadAllTranslations, loadTranslation } from './load-translations';
-
-type ICUParams = { [key: string]: string };
-
-interface TranslationTypeInfo {
-  params: ICUParams;
-  message: string;
-  returnType: string;
-  hasTags: boolean;
-}
-
-const encodeWithinSingleQuotes = (v: string) => v.replace(/'/g, "\\'");
-
-const encodeBackslash = (v: string) => v.replace(/\\/g, '\\\\');
-
-function extractHasTags(ast: MessageFormatElement[]): boolean {
-  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: MessageFormatElement[],
-): [params: ICUParams, imports: Set<string>] {
-  let params: ICUParams = {};
-  let imports = new Set<string>();
-
-  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: any) {
-  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: Map<string, TranslationTypeInfo>,
-  imports: Set<string>,
-  loadedTranslation: LoadedTranslation,
-) {
-  trace('Serialising translations:', loadedTranslation);
-  const translationsType: any = {};
-
-  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;`;
-}
-
-export async function generateRuntime(loadedTranslation: LoadedTranslation) {
-  const { languages: loadedLanguages, filePath } = loadedTranslation;
-
-  trace('Generating types for', loadedTranslation.filePath);
-  const translationTypes = new Map<string, TranslationTypeInfo>();
-
-  let imports = new Set<string>();
-
-  for (const key of loadedTranslation.keys) {
-    let params: ICUParams = {};
-    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);
-}
-
-export function watch(config: UserConfig) {
-  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: string) => {
-    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: string) => {
-    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 fs.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();
-}
-
-export async function compile(
-  { watch: shouldWatch = false } = {},
-  config: UserConfig,
-) {
-  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: string, contents: string) {
-  let hasChanged = true;
-
-  try {
-    const existingContents = await fs.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 fs.writeFile(filepath, contents, { encoding: 'utf-8' });
-  }
-}

package/src/config.test.ts

@@ -1,39 +0,0 @@
-import { validateConfig } from './config';
-
-describe('validateConfig', () => {
-  it('should allow a valid config', () => {
-    const config = { devLanguage: 'en', languages: [{ name: 'en' }] };
-    expect(() => validateConfig(config)).not.toThrow();
-  });
-
-  it('should throw an error on no config', () => {
-    // @ts-expect-error For Science!!!
-    expect(() => validateConfig({})).toThrowError(
-      expect.objectContaining({ code: 'InvalidStructure' }),
-    );
-  });
-
-  it("should throw an error when the devLanguage isn't defined in languages", () => {
-    expect(() =>
-      validateConfig({ devLanguage: 'en', languages: [{ name: 'th' }] }),
-    ).toThrowError(expect.objectContaining({ code: 'InvalidDevLanguage' }));
-  });
-
-  it('should throw an error when there are duplicate languages', () => {
-    expect(() =>
-      validateConfig({
-        devLanguage: 'en',
-        languages: [{ name: 'en' }, { name: 'en' }],
-      }),
-    ).toThrowError(expect.objectContaining({ code: 'DuplicateLanguage' }));
-  });
-
-  it('should throw an error when extending a missing language', () => {
-    expect(() =>
-      validateConfig({
-        devLanguage: 'en',
-        languages: [{ name: 'en' }, { name: 'en-US', extends: 'en-AU' }],
-      }),
-    ).toThrowError(expect.objectContaining({ code: 'InvalidExtends' }));
-  });
-});