@vocab/core 1.0.4 → 1.1.0

package/src/logger.ts

@@ -1,9 +0,0 @@
-import chalk from 'chalk';
-import debug from 'debug';
-
-export const trace = debug(`vocab:core`);
-
-export const log = (...params: unknown[]) => {
-  // eslint-disable-next-line no-console
-  console.log(chalk.yellow('Vocab'), ...params);
-};

package/src/runtime.test.ts

@@ -1,153 +0,0 @@
-import { FormatXMLElementFn } from 'intl-messageformat';
-import { createTranslationFile, createLanguage } from './runtime';
-
-const createDemoTranslationFile = () =>
-  createTranslationFile<
-    'en' | 'fr',
-    {
-      vocabPublishDate: <T = string>(values: {
-        publishDate: Date | number;
-      }) => string | T | Array<string | T>;
-    }
-  >({
-    en: createLanguage({
-      vocabPublishDate: 'Vocab was published on {publishDate, date, small}',
-    }),
-    fr: createLanguage({
-      vocabPublishDate: 'Vocab a été publié le {publishDate, date, medium}',
-    }),
-  });
-const createDemoTranslationFileWithTag = () =>
-  createTranslationFile<
-    'en' | 'fr',
-    {
-      vocabPublishDate: <T = string>(values: {
-        link: FormatXMLElementFn<T>;
-        strong: FormatXMLElementFn<T>;
-      }) => string | T | Array<string | T>;
-    }
-  >({
-    en: createLanguage({
-      vocabPublishDate: '<link><strong>Vocab</strong> is awesome</link>!',
-    }),
-    fr: createLanguage({
-      vocabPublishDate: '<link><strong>Vocab</strong> est génial</link>!',
-    }),
-  });
-
-describe('createTranslationFile', () => {
-  it('should return translations as a promise', async () => {
-    const translations = createDemoTranslationFile();
-    const translationModule = await translations.getMessages('en');
-    expect(
-      translationModule?.vocabPublishDate.format({
-        publishDate: 1605847714000,
-      }),
-    ).toBe('Vocab was published on 11/20/2020');
-  });
-  it('should return TranslationModules with language as locale', () => {
-    const translations = createDemoTranslationFile();
-    const translationModule = translations.getLoadedMessages('en');
-    expect(
-      translationModule?.vocabPublishDate.format({
-        publishDate: 1605847714000,
-      }),
-    ).toBe('Vocab was published on 11/20/2020');
-  });
-
-  // Support for alternative ICU locales in Node not available in current CI environment
-  // Disabling test for now until `full-icu` can be added. See https://nodejs.org/api/intl.html#intl_options_for_building_node_js
-  // eslint-disable-next-line jest/no-disabled-tests
-  it.skip('should return TranslationModules with en-AU locale', () => {
-    const translations = createDemoTranslationFile();
-    const translationModule = translations.getLoadedMessages('en', 'en-AU');
-    expect(
-      translationModule?.vocabPublishDate.format({
-        publishDate: 1605847714000,
-      }),
-    ).toBe('Vocab was published on 20/11/2020');
-  });
-  it('should return an array when tags return objects', () => {
-    const translations = createDemoTranslationFileWithTag();
-    const translationModule = translations.getLoadedMessages('en', 'en-US');
-    interface TagResult {
-      type: string;
-      children: unknown;
-    }
-    type ExpectedResultType = string | TagResult | Array<string | TagResult>;
-    if (!translationModule) {
-      throw new Error('no translationModule');
-    }
-    const result = translationModule.vocabPublishDate.format<TagResult>({
-      strong: (children) => ({
-        type: 'strong',
-        children,
-      }),
-      link: (children) => ({
-        type: 'link',
-        children,
-      }),
-    });
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const _unused: ExpectedResultType = result;
-    expect(result).toEqual(expect.any(Array));
-    expect(result).toEqual([
-      {
-        children: [{ children: ['Vocab'], type: 'strong' }, ' is awesome'],
-        type: 'link',
-      },
-      '!',
-    ]);
-  });
-  it('should return a string when all tags return strings', () => {
-    const translations = createDemoTranslationFileWithTag();
-    const translationModule = translations.getLoadedMessages('en', 'en-US');
-    type ExpectedResultType = string | Array<string>;
-    if (!translationModule) {
-      throw new Error('no translationModule');
-    }
-    const result = translationModule.vocabPublishDate.format({
-      strong: (children) => `*${children}*`,
-      link: (children) => `[${children}]()`,
-    });
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const _unused: ExpectedResultType = result;
-    expect(typeof result).toBe('string');
-    expect(result).toBe('[*Vocab* is awesome]()!');
-  });
-  it('should return TranslationModules with en-US locale', () => {
-    const translations = createDemoTranslationFile();
-    const translationModule = translations.getLoadedMessages('en', 'en-US');
-    if (!translationModule) {
-      throw new Error('no translationModule');
-    }
-    const result = translationModule.vocabPublishDate.format({
-      publishDate: 1605847714000,
-    });
-    expect(result).toBe('Vocab was published on 11/20/2020');
-  });
-  it('should require parameters to be passed in', () => {
-    const translations = createDemoTranslationFile();
-    const translationModule = translations.getLoadedMessages('en');
-    expect(() => {
-      // @ts-expect-error Incorrect params parameter
-      const result = translationModule?.vocabPublishDate.format({});
-      return result;
-    }).toThrowError(
-      expect.objectContaining({
-        message: expect.stringContaining('not provided'),
-      }),
-    );
-    expect(() => {
-      const result = translationModule?.vocabPublishDate.format({
-        // @ts-expect-error Incorrect params parameter
-        unrelated: 'message',
-      });
-      return result;
-    }).toThrowError(
-      expect.objectContaining({
-        message: expect.stringContaining('not provided'),
-      }),
-    );
-  });
-});

package/src/runtime.ts

@@ -1,12 +0,0 @@
-import { TranslationModule, TranslationMessagesByKey } from '@vocab/types';
-
-import { getParsedICUMessages } from './icu-handler';
-
-export { createTranslationFile } from './translation-file';
-
-export const createLanguage = (
-  module: TranslationMessagesByKey,
-): TranslationModule<any> => ({
-  getValue: (locale) => getParsedICUMessages(module, locale),
-  load: () => Promise.resolve(),
-});

package/src/test-translations/en.translations.json

@@ -1,9 +0,0 @@
-{
-  "Hello": { "message": "Hello" },
-  "Goodbye": {
-    "message": "Goodbye"
-  },
-  "Welcome": {
-    "message": "Welcome"
-  }
-}

package/src/test-translations/th-TH.translations.json

@@ -1 +0,0 @@
-{ "Welcome": { "message": "Welcome in Thai-TH" } }

package/src/test-translations/th.translations.json

@@ -1 +0,0 @@
-{ "Hello": { "message": "Hello in Thai" } }

package/src/translation-file.ts

@@ -1,54 +0,0 @@
-import {
-  TranslationModule,
-  TranslationModuleByLanguage,
-  ParsedICUMessages,
-  LanguageName,
-  ParsedFormatFnByKey,
-  TranslationFile,
-} from '@vocab/types';
-
-export function createTranslationFile<
-  Language extends LanguageName,
-  FormatFnByKey extends ParsedFormatFnByKey,
->(
-  translationsByLanguage: TranslationModuleByLanguage<Language, FormatFnByKey>,
-): TranslationFile<Language, FormatFnByKey> {
-  function getByLanguage(language: Language): TranslationModule<FormatFnByKey> {
-    const translationModule = translationsByLanguage[language];
-    if (!translationModule) {
-      throw new Error(
-        `Attempted to retrieve translations for unknown language "${language}"`,
-      );
-    }
-    return translationModule;
-  }
-
-  return {
-    getLoadedMessages(
-      language: Language,
-      locale?: string,
-    ): ParsedICUMessages<FormatFnByKey> | null {
-      const translationModule = getByLanguage(language);
-      return translationModule.getValue(locale || language) || null;
-    },
-    getMessages(
-      language: Language,
-      locale?: string,
-    ): Promise<ParsedICUMessages<FormatFnByKey>> {
-      const translationModule = getByLanguage(language);
-      return translationModule.load().then(() => {
-        const result = translationModule.getValue(locale || language);
-        if (!result) {
-          throw new Error(
-            `Unable to find translations for ${language} after attempting to load. Module may have failed to load or an internal error may have occurred.`,
-          );
-        }
-        return result;
-      });
-    },
-    load(language: Language): Promise<void> {
-      const translationModule = getByLanguage(language);
-      return translationModule.load();
-    },
-  };
-}

package/src/utils.test.ts

@@ -1,78 +0,0 @@
-import {
-  getDevLanguageFileFromTsFile,
-  getAltLanguageFilePath,
-  getTSFileFromDevLanguageFile,
-  getDevLanguageFileFromAltLanguageFile,
-  isDevLanguageFile,
-  isAltLanguageFile,
-} from './utils';
-
-describe('getDevLanguageFileFromTsFile', () => {
-  it('should find a translation.json file', () => {
-    expect(getDevLanguageFileFromTsFile('/my/foobar/index.ts')).toBe(
-      '/my/foobar/translations.json',
-    );
-  });
-});
-
-describe('getAltLanguageFilePath', () => {
-  it('should find a translation.json file', () => {
-    expect(getAltLanguageFilePath('/my/awesome/translations.json', 'fr')).toBe(
-      '/my/awesome/fr.translations.json',
-    );
-  });
-});
-
-describe('getTSFileFromDevLanguageFile', () => {
-  it('should find a translation.ts file', () => {
-    expect(getTSFileFromDevLanguageFile('/my/foobar/translations.json')).toBe(
-      '/my/foobar/index.ts',
-    );
-  });
-});
-
-describe('getDevLanguageFileFromAltLanguageFile', () => {
-  it('should find a translation.json file', () => {
-    expect(
-      getDevLanguageFileFromAltLanguageFile(
-        '/my/awesome/__translations__/fr.translations.json',
-      ),
-    ).toBe('/my/awesome/__translations__/translations.json');
-  });
-});
-
-describe('isDevLanguageFile', () => {
-  it('should match dev language filename', () => {
-    expect(
-      isDevLanguageFile('/my/awesome/__translations__/translations.json'),
-    ).toBe(true);
-  });
-
-  it('should match relative dev language filename', () => {
-    expect(isDevLanguageFile('translations.json')).toBe(true);
-  });
-
-  it('should not match alt language filename', () => {
-    expect(
-      isDevLanguageFile('/my/awesome/__translations__/fr.translations.json'),
-    ).toBe(false);
-  });
-});
-
-describe('isAltLanguageFile', () => {
-  it('should match alt language filename', () => {
-    expect(
-      isAltLanguageFile('/my/awesome/__translations__/fr.translations.json'),
-    ).toBe(true);
-  });
-
-  it('should match relative alt language filename', () => {
-    expect(isAltLanguageFile('fr.translations.json')).toBe(true);
-  });
-
-  it('should not match alt language filename', () => {
-    expect(
-      isAltLanguageFile('/my/awesome/__translations__/translations.json'),
-    ).toBe(false);
-  });
-});

package/src/utils.ts

@@ -1,143 +0,0 @@
-import path from 'path';
-
-import type {
-  LanguageName,
-  LanguageTarget,
-  TranslationsByKey,
-  TranslationMessagesByKey,
-  UserConfig,
-} from '@vocab/types';
-import { trace } from './logger';
-
-export const defaultTranslationDirSuffix = '.vocab';
-export const devTranslationFileName = 'translations.json';
-
-export type Fallback = 'none' | 'valid' | 'all';
-
-const globAnyPathWithOptionalPrefix = '**/?(*)';
-
-export function isDevLanguageFile(filePath: string) {
-  return (
-    filePath.endsWith(`/${devTranslationFileName}`) ||
-    filePath === devTranslationFileName
-  );
-}
-export function isAltLanguageFile(filePath: string) {
-  return filePath.endsWith('.translations.json');
-}
-export function isTranslationDirectory(
-  filePath: string,
-  {
-    translationsDirectorySuffix = defaultTranslationDirSuffix,
-  }: {
-    translationsDirectorySuffix?: string;
-  },
-) {
-  return filePath.endsWith(translationsDirectorySuffix);
-}
-
-export function getTranslationFolderGlob({
-  translationsDirectorySuffix = defaultTranslationDirSuffix,
-}: {
-  translationsDirectorySuffix?: string;
-}) {
-  const result = `${globAnyPathWithOptionalPrefix}${translationsDirectorySuffix}`;
-
-  trace('getTranslationFolderGlob', result);
-
-  return result;
-}
-
-export function getDevTranslationFileGlob({
-  translationsDirectorySuffix = defaultTranslationDirSuffix,
-}: {
-  translationsDirectorySuffix?: string;
-}) {
-  const result = `${globAnyPathWithOptionalPrefix}${translationsDirectorySuffix}/${devTranslationFileName}`;
-
-  trace('getDevTranslationFileGlob', result);
-
-  return result;
-}
-
-export function getAltTranslationFileGlob(config: UserConfig) {
-  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;
-}
-
-export function getAltLanguages({
-  devLanguage,
-  languages,
-}: {
-  devLanguage: LanguageName;
-  languages: Array<LanguageTarget>;
-}) {
-  return languages.map((v) => v.name).filter((lang) => lang !== devLanguage);
-}
-
-export function getDevLanguageFileFromTsFile(tsFilePath: string) {
-  const directory = path.dirname(tsFilePath);
-  const result = path.normalize(path.join(directory, devTranslationFileName));
-
-  trace(`Returning dev language path ${result} for path ${tsFilePath}`);
-  return result;
-}
-
-export function getDevLanguageFileFromAltLanguageFile(
-  altLanguageFilePath: string,
-) {
-  const directory = path.dirname(altLanguageFilePath);
-  const result = path.normalize(path.join(directory, devTranslationFileName));
-  trace(
-    `Returning dev language path ${result} for path ${altLanguageFilePath}`,
-  );
-  return result;
-}
-
-export function getTSFileFromDevLanguageFile(devLanguageFilePath: string) {
-  const directory = path.dirname(devLanguageFilePath);
-  const result = path.normalize(path.join(directory, 'index.ts'));
-
-  trace(`Returning TS path ${result} for path ${devLanguageFilePath}`);
-  return result;
-}
-
-export function getAltLanguageFilePath(
-  devLanguageFilePath: string,
-  language: string,
-) {
-  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);
-}
-
-export function mapValues<Key extends string, OriginalValue, ReturnValue>(
-  obj: Record<Key, OriginalValue>,
-  func: (val: OriginalValue) => ReturnValue,
-): TranslationMessagesByKey<Key> {
-  const newObj: any = {};
-  const keys = Object.keys(obj) as Key[];
-  for (const key of keys) {
-    newObj[key] = func(obj[key]);
-  }
-  return newObj;
-}
-
-export function getTranslationMessages<Key extends string>(
-  translations: TranslationsByKey<Key>,
-): TranslationMessagesByKey<Key> {
-  return mapValues(translations, (v) => v.message);
-}

package/src/validate/index.test.ts

@@ -1,64 +0,0 @@
-import { LoadedTranslation, LanguageName } from '@vocab/types';
-import { findMissingKeys } from './index';
-
-interface TestCase {
-  loadedTranslation: LoadedTranslation;
-  devLanguage: LanguageName;
-  altLanguages: Array<LanguageName>;
-  valid: boolean;
-  missingKeys?: Record<LanguageName, Array<string>>;
-}
-
-const testCases: Array<TestCase> = [
-  {
-    loadedTranslation: {
-      filePath: 'some-file.json',
-      namespace: 'some-file',
-      keys: ['key1', 'key2'],
-      relativePath: 'some-file.json',
-      languages: {
-        en: { key1: { message: 'Hi' } },
-        th: { key1: { message: 'Bye' } },
-      },
-    },
-    devLanguage: 'en',
-    altLanguages: ['th'],
-    valid: true,
-  },
-  {
-    loadedTranslation: {
-      filePath: 'some-file.json',
-      relativePath: 'some-file.json',
-      namespace: 'some-file-2',
-      keys: ['key1'],
-      languages: {
-        en: { key1: { message: 'Hi' } },
-        th: {},
-      },
-    },
-    devLanguage: 'en',
-    altLanguages: ['th'],
-    valid: false,
-    missingKeys: {
-      th: ['key1'],
-    },
-  },
-];
-
-test.each(testCases)(
-  'validate',
-  ({ loadedTranslation, devLanguage, altLanguages, valid, missingKeys }) => {
-    const result = findMissingKeys(
-      loadedTranslation,
-      devLanguage,
-      altLanguages,
-    );
-
-    expect(result[0]).toBe(valid);
-
-    if (missingKeys) {
-      // eslint-disable-next-line jest/no-conditional-expect
-      expect(result[1]).toMatchObject(missingKeys);
-    }
-  },
-);

package/src/validate/index.ts

@@ -1,81 +0,0 @@
-/* eslint-disable no-console */
-import { UserConfig, LoadedTranslation, LanguageName } from '@vocab/types';
-import chalk from 'chalk';
-
-import { loadAllTranslations } from '../load-translations';
-import { getAltLanguages } from '../utils';
-
-export function findMissingKeys(
-  loadedTranslation: LoadedTranslation,
-  devLanguageName: LanguageName,
-  altLanguages: Array<LanguageName>,
-) {
-  const devLanguage = loadedTranslation.languages[devLanguageName];
-
-  if (!devLanguage) {
-    throw new Error(
-      `Failed to load dev language: ${loadedTranslation.filePath}`,
-    );
-  }
-
-  const result: Record<LanguageName, Array<string>> = {};
-  let valid = true;
-
-  const requiredKeys = Object.keys(devLanguage);
-
-  if (requiredKeys.length > 0) {
-    for (const altLanguageName of altLanguages) {
-      const altLanguage = loadedTranslation.languages[altLanguageName] ?? {};
-
-      for (const key of requiredKeys) {
-        if (typeof altLanguage[key]?.message !== 'string') {
-          if (!result[altLanguageName]) {
-            result[altLanguageName] = [];
-          }
-
-          result[altLanguageName].push(key);
-          valid = false;
-        }
-      }
-    }
-  }
-  return [valid, result] as const;
-}
-
-export async function validate(config: UserConfig) {
-  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;
-}