@vocab/core 1.0.3 → 1.1.1

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' }));
-  });
-});

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';