@vocab/core 1.0.4 → 1.1.0

package/src/config.ts

@@ -1,144 +0,0 @@
-import { UserConfig } from '@vocab/types';
-import path from 'path';
-
-import chalk from 'chalk';
-import findUp from 'find-up';
-import Validator from 'fastest-validator';
-import { ValidationError } from './ValidationError';
-import { trace } from './logger';
-
-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 },
-      },
-    },
-  },
-  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: string, callback: (value: string) => string) =>
-  message
-    .split(' ,')
-    .map((v) => callback(v))
-    .join(' ,');
-
-export function validateConfig(c: UserConfig) {
-  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) {
-            return v.message?.replace(v.field, chalk.cyan(v.field));
-          }
-          return v.message;
-        })
-        .join(' \n'),
-    );
-  }
-
-  // Dev Language should exist in languages
-  const languageStrings = c.languages.map((v) => v.name);
-  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(', ')}.`,
-    );
-  }
-
-  const foundLanguages: string[] = [];
-  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(', ')}.`,
-      );
-    }
-  }
-  trace('Configuration file is valid');
-  return true;
-}
-
-function createConfig(configFilePath: string) {
-  const cwd = path.dirname(configFilePath);
-
-  return {
-    projectRoot: cwd,
-    ...(require(configFilePath as string) as UserConfig),
-  };
-}
-
-export async function resolveConfig(
-  customConfigFilePath?: string,
-): Promise<UserConfig | null> {
-  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;
-}
-
-export function resolveConfigSync(
-  customConfigFilePath?: string,
-): UserConfig | null {
-  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;
-}

package/src/icu-handler.ts

@@ -1,35 +0,0 @@
-import { ParsedICUMessages, TranslationMessagesByKey } from '@vocab/types';
-import IntlMessageFormat from 'intl-messageformat';
-
-type ICUMessagesByLocale = {
-  [locale: string]: ParsedICUMessages<any>;
-};
-
-const moduleCache = new WeakMap<
-  TranslationMessagesByKey,
-  ICUMessagesByLocale
->();
-
-export const getParsedICUMessages = (
-  m: TranslationMessagesByKey,
-  locale: string,
-): ParsedICUMessages<any> => {
-  const moduleCachedResult = moduleCache.get(m);
-
-  if (moduleCachedResult && moduleCachedResult[locale]) {
-    return moduleCachedResult[locale];
-  }
-
-  const parsedICUMessages: ParsedICUMessages<any> = {};
-
-  for (const translation of Object.keys(m)) {
-    const intlMessageFormat = new IntlMessageFormat(m[translation], locale);
-    parsedICUMessages[translation] = {
-      format: (params: any) => intlMessageFormat.format(params),
-    };
-  }
-
-  moduleCache.set(m, { ...moduleCachedResult, [locale]: parsedICUMessages });
-
-  return parsedICUMessages;
-};

package/src/index.ts

@@ -1,14 +0,0 @@
-export { compile, watch } from './compile';
-export { validate } from './validate';
-export { resolveConfig, resolveConfigSync, validateConfig } from './config';
-export {
-  getAltLanguages,
-  getAltLanguageFilePath,
-  getDevLanguageFileFromTsFile,
-} from './utils';
-export {
-  getUniqueKey,
-  loadAllTranslations,
-  loadTranslation,
-} from './load-translations';
-export type { TranslationFile } from '@vocab/types';

package/src/load-translations.test.ts

@@ -1,165 +0,0 @@
-import {
-  getFallbackLanguageOrder,
-  getLanguageHierarchy,
-  loadAltLanguageFile,
-  mergeWithDevLanguageTranslation,
-} from './load-translations';
-import path from 'path';
-
-describe('mergeWithDevLanguage', () => {
-  const key = 'Hello';
-
-  describe('when the translation has a message for a key in the dev translation', () => {
-    it('should have a message from the translation', () => {
-      const thTranslation = { Hello: { message: 'Hello in Thai' } };
-      const devTranslation = { Hello: { message: 'Hello' } };
-
-      const mergedTranslations = mergeWithDevLanguageTranslation({
-        translation: thTranslation,
-        devTranslation,
-      });
-
-      expect(mergedTranslations[key]).toEqual({ message: 'Hello in Thai' });
-    });
-  });
-
-  describe('when the translation does not have a message for a key in the dev translation', () => {
-    it('should not have a message for the given key', () => {
-      const translation = {};
-      const devTranslation = { Hello: { message: 'Hello' } };
-
-      const mergedTranslations = mergeWithDevLanguageTranslation({
-        translation,
-        devTranslation,
-      });
-
-      expect(mergedTranslations[key]).toEqual(undefined);
-    });
-  });
-});
-
-describe('getLanguageHierarchy', () => {
-  it('should return a correct language hierarchy', () => {
-    expect(
-      getLanguageHierarchy({
-        languages: [
-          { name: 'en' },
-          { name: 'th', extends: 'en' },
-          { name: 'th-TH', extends: 'th' },
-          { name: 'en-AU', extends: 'en' },
-        ],
-      }),
-    ).toEqual(
-      new Map([
-        ['en', []],
-        ['th', ['en']],
-        ['th-TH', ['th', 'en']],
-        ['en-AU', ['en']],
-      ]),
-    );
-  });
-});
-
-describe('getFallbackLanguageOrder', () => {
-  const languages = [
-    { name: 'fr' },
-    { name: 'en' },
-    { name: 'th', extends: 'en' },
-    { name: 'th-TH', extends: 'th' },
-  ];
-  const languageName = 'th-TH';
-  const devLanguage = 'fr';
-
-  describe('fallbacks = none', () => {
-    it('should return just the requested language', () => {
-      const fallbacks = 'none';
-
-      expect(
-        getFallbackLanguageOrder({
-          languages,
-          languageName,
-          devLanguage,
-          fallbacks,
-        }),
-      ).toEqual(['th-TH']);
-    });
-  });
-
-  describe('fallbacks = valid', () => {
-    it('should return just the requested language', () => {
-      const fallbacks = 'valid';
-
-      expect(
-        getFallbackLanguageOrder({
-          languages,
-          languageName,
-          devLanguage,
-          fallbacks,
-        }),
-      ).toEqual(['en', 'th', 'th-TH']);
-    });
-  });
-
-  describe('fallbacks = all', () => {
-    it('should return just the requested language', () => {
-      const fallbacks = 'all';
-
-      expect(
-        getFallbackLanguageOrder({
-          languages,
-          languageName,
-          devLanguage,
-          fallbacks,
-        }),
-      ).toEqual(['fr', 'en', 'th', 'th-TH']);
-    });
-  });
-});
-
-describe('loadAltLanguageFile', () => {
-  describe('when a language extends a language that also extends another language', () => {
-    it('should resolve translation message correctly according to the fallback hierarchy', () => {
-      const filePath = path.join(
-        __dirname,
-        'test-translations/translations.json',
-      );
-      const devTranslation = {
-        Hello: { message: 'Hello in French' },
-        Goodbye: {
-          message: 'Goodbye in French',
-        },
-        Welcome: {
-          message: 'Welcome in French',
-        },
-        'Good morning': {
-          message: 'Good morning in French',
-        },
-      };
-
-      const thTHTranslations = loadAltLanguageFile(
-        {
-          filePath,
-          languageName: 'th-TH',
-          devTranslation,
-          fallbacks: 'all',
-        },
-        {
-          devLanguage: 'fr',
-          languages: [
-            { name: 'fr' },
-            { name: 'en' },
-            { name: 'th', extends: 'en' },
-            { name: 'th-TH', extends: 'th' },
-          ],
-        },
-      );
-
-      expect(thTHTranslations).toEqual({
-        Hello: { message: 'Hello in Thai' },
-        Goodbye: { message: 'Goodbye' },
-        Welcome: { message: 'Welcome in Thai-TH' },
-        'Good morning': { message: 'Good morning in French' },
-      });
-    });
-  });
-});

package/src/load-translations.ts

@@ -1,351 +0,0 @@
-import path from 'path';
-
-import glob from 'fast-glob';
-import {
-  TranslationsByKey,
-  UserConfig,
-  LoadedTranslation,
-  LanguageTarget,
-  LanguageName,
-} from '@vocab/types';
-import chalk from 'chalk';
-
-import { trace } from './logger';
-import {
-  defaultTranslationDirSuffix,
-  Fallback,
-  getAltLanguageFilePath,
-  getAltLanguages,
-  getDevTranslationFileGlob,
-} from './utils';
-
-export function getUniqueKey(key: string, namespace: string) {
-  return `${key}.${namespace}`;
-}
-
-export function mergeWithDevLanguageTranslation({
-  translation,
-  devTranslation,
-}: {
-  translation: TranslationsByKey;
-  devTranslation: TranslationsByKey;
-}) {
-  // Only use keys from the dev translation
-  const keys = Object.keys(devTranslation);
-  const newLanguage: TranslationsByKey = {};
-
-  for (const key of keys) {
-    if (translation[key]) {
-      newLanguage[key] = {
-        message: translation[key].message,
-        description: devTranslation[key].description,
-      };
-    }
-  }
-
-  return newLanguage;
-}
-
-function getLanguageFallbacks({
-  languages,
-}: {
-  languages: Array<LanguageTarget>;
-}) {
-  const languageFallbackMap = new Map<LanguageName, LanguageName>();
-
-  for (const lang of languages) {
-    if (lang.extends) {
-      languageFallbackMap.set(lang.name, lang.extends);
-    }
-  }
-
-  return languageFallbackMap;
-}
-
-export function getLanguageHierarchy({
-  languages,
-}: {
-  languages: Array<LanguageTarget>;
-}) {
-  const hierarchyMap = new Map<LanguageName, Array<LanguageName>>();
-  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;
-}
-
-export function getFallbackLanguageOrder({
-  languages,
-  languageName,
-  devLanguage,
-  fallbacks,
-}: {
-  languages: LanguageTarget[];
-  languageName: string;
-  devLanguage: string;
-  fallbacks: Fallback;
-}) {
-  const languageHierarchy = getLanguageHierarchy({ languages }).get(
-    languageName,
-  );
-
-  if (!languageHierarchy) {
-    throw new Error(`Missing language hierarchy for ${languageName}`);
-  }
-
-  const fallbackLanguageOrder: Array<string> = [languageName];
-
-  if (fallbacks !== 'none') {
-    fallbackLanguageOrder.unshift(...languageHierarchy.reverse());
-
-    if (fallbacks === 'all' && fallbackLanguageOrder[0] !== devLanguage) {
-      fallbackLanguageOrder.unshift(devLanguage);
-    }
-  }
-
-  return fallbackLanguageOrder;
-}
-
-function getNamespaceByFilePath(
-  relativePath: string,
-  { translationsDirectorySuffix = defaultTranslationDirSuffix }: UserConfig,
-) {
-  let namespace = path
-    .dirname(relativePath)
-    .replace(/^src\//, '')
-    .replace(/\//g, '_');
-
-  if (namespace.endsWith(translationsDirectorySuffix)) {
-    namespace = namespace.slice(0, -translationsDirectorySuffix.length);
-  }
-
-  return namespace;
-}
-
-function printValidationError(...params: unknown[]) {
-  // eslint-disable-next-line no-console
-  console.error(chalk.red('Error loading translation:'), ...params);
-}
-
-function getTranslationsFromFile(
-  translations: unknown,
-  { isAltLanguage, filePath }: { isAltLanguage: boolean; filePath: string },
-): { $namespace: unknown; keys: TranslationsByKey } {
-  if (!translations || typeof translations !== 'object') {
-    throw new Error(
-      `Unable to read translation file ${filePath}. Translations must be an object`,
-    );
-  }
-  const { $namespace, ...keys } = translations as TranslationsByKey;
-  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: TranslationsByKey = {};
-  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}.`,
-      );
-      continue;
-    }
-    if (!translation) {
-      printValidationError(
-        `Found empty translation "${translationKey}" in ${filePath}. Translation must be an object of the format {mesage: 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}.`,
-      );
-      continue;
-    }
-    validKeys[translationKey] = translation;
-  }
-  return { $namespace, keys: validKeys };
-}
-
-export function loadAltLanguageFile(
-  {
-    filePath,
-    languageName,
-    devTranslation,
-    fallbacks,
-  }: {
-    filePath: string;
-    languageName: string;
-    devTranslation: TranslationsByKey;
-    fallbacks: Fallback;
-  },
-  { devLanguage, languages }: UserConfig,
-): TranslationsByKey {
-  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;
-}
-
-export function loadTranslation(
-  {
-    filePath,
-    fallbacks,
-  }: {
-    filePath: string;
-    fallbacks: Fallback;
-  },
-  userConfig: UserConfig,
-): LoadedTranslation {
-  trace(
-    `Loading translation file in "${fallbacks}" fallback mode: "${filePath}"`,
-  );
-
-  const languageSet: Record<
-    string,
-    Record<string, { message: string; description?: string | undefined }>
-  > = {};
-
-  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: string =
-    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,
-    );
-  }
-
-  return {
-    filePath,
-    keys: Object.keys(devTranslation),
-    namespace,
-    relativePath,
-    languages: languageSet,
-  };
-}
-
-export async function loadAllTranslations(
-  {
-    fallbacks,
-    includeNodeModules,
-  }: { fallbacks: Fallback; includeNodeModules: boolean },
-  config: UserConfig,
-): Promise<Array<LoadedTranslation>> {
-  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;
-}