@oracle/oraclejet-icu-l10n 16.0.0

package/Bundler.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Compile the message bundle in ICU format. This function starts with the "root"
+ * message bundle and attempts to discover bundles for all available locales by
+ * traversing the root bundle's directory and looking for locale directory names.
+ * Any file found under locale directories whose names match the root bundle will
+ * also be compiled.
+ * When creating the output file in the given targetDir, the locale directory
+ * structure from the source will be recreated.
+ * @param {object} props The properties with which to build the bundle
+ * @param {string} props.rootDir The path to the root message bundle
+ * @param {string} props.bundleName The name of the bundle file
+ * @param {string} props.locale The locale of the root message bundle
+ * @param {string} props.outDir The target directory where the compiled root message
+ * @param {string=} props.module The type of module to produce -- 'esm', 'amd', or 'legacy-amd'
+ * @param {string=} props.exportType The type of export to produce -- 'default' or 'named'
+ * @param {boolean=} props.override Indicates the bundle is an override, and only the root
+ * locale and those explicitly stated in [--supportedLocales] will be built.
+ * @param {string[]=} props.additionalLocales An array of additional locales to build
+ * @param {string=} hooks A path to the custom hooks file
+ */
+export function build({
+  rootDir,
+  bundleName,
+  locale,
+  outDir,
+  module,
+  exportType,
+  override,
+  additionalLocales,
+  hooks
+}: {
+  rootDir: string;
+  bundleName: string;
+  locale: string;
+  outDir: string;
+  module?: string | undefined;
+  exportType?: string | undefined;
+  override?: boolean | undefined;
+  additionalLocales?: string[] | undefined;
+}): void;
+/**
+ * Test if a given directory name (base name only) is an NLS directory.
+ * @param {string} name The directory name
+ * @return True if NLS directory, false otherwise
+ */
+export function isNlsDir(name: string): boolean;

package/Bundler.js

@@ -0,0 +1,312 @@
+const fsx = require('fs-extra');
+const glob = require('glob');
+const path = require('path');
+const os = require('os');
+const PatternCompiler = require('./PatternCompiler');
+const ts = require('typescript');
+const pkg = require('./package.json');
+
+/**
+ * Traverse the message bundle and compile all strings.
+ * @param {PatternCompiler} compiler The instance of the PatternCompiler
+ * @param {Object} bundle The message bundle
+ * @return {Object} A message bundle whose strings are wrapped by functions
+ * generated from the PatternCompiler.
+ * @private
+ */
+function traverse(compiler, bundle) {
+  const metadata = {};
+  // sort so that metadata '@' keys are processed first
+  const output = Object.keys(bundle).sort().reduce((accum, key) => {
+    if (key.match(/^@/)) {
+      metadata[key.substring(1)] = getMetadataParamTypes(bundle[key]);
+    } else {
+      const value = bundle[key];
+      if (typeof value !== 'string') {
+        throw Error(`"${key}" value must be a string`);
+      }
+      return {
+        ...accum,
+        [key]: compiler.compile(value, metadata[key])
+      };
+    }
+    return accum;
+  }, {});
+  return output;
+}
+
+function getMetadataParamTypes(metadata) {
+  return Object.keys(metadata.placeholders || {}).reduce((accum, key) => (
+    {
+      ...accum,
+      [key]: metadata.placeholders?.[key].type
+    }
+  ), {});
+}
+
+/**
+ * Get the bundle as an object from the given filepath
+ * @param {string} filepath
+ * @return {object} The bundle from the file
+ * @private
+ */
+function getBundle(filepath) {
+  let bundle;
+  if (fsx.existsSync(filepath)) {
+    const bundleContents = fsx.readFileSync(filepath);
+    bundle = JSON.parse(bundleContents);
+  }
+  return bundle;
+}
+
+/**
+ * Process the given bundle for the given locale and write the compiled contents
+ * to the given file path
+ * @param {string} rootBundleFile The path to the root bundle JSON file
+ * @param {string} bundleId The id of the bundle
+ * @param {object} bundle The message bundle
+ * @param {string} locale The locale of the bundle
+ * @param {string} targetFile The path to the target file where the contents will
+ * be written.
+ * @param {string} exportType The type of export to produce, either 'default' or 'named'
+ * @param {boolean?} withBundleType Whether to export the bundle type definition
+ * @private
+ */
+function convertBundle(
+  rootBundleFile,
+  bundleId,
+  bundle,
+  locale,
+  targetFile,
+  exportType,
+  withBundleType
+) {
+  const compiler = new PatternCompiler(locale);
+  let processed;
+  try {
+    processed = traverse(compiler, bundle);
+  } catch (ex) {
+    throw Error(`While processing ${locale}/${bundleId}:\n${ex.message}`);
+  }
+  // apply hooks and type imports
+  const convertor = customHooks.convertor;
+  const typeImport = customHooks.typeImport
+    ? Object.keys(customHooks.typeImport).map((k) => customHooks.typeImport[k])[0]
+    : '';
+  const otherImports = customHooks.otherImports ? [customHooks.otherImports] : [];
+  const valueType = typeImport ? Object.keys(customHooks.typeImport)[0] : '';
+  const translations = Object.keys(processed).map((messageKey) => {
+    const entry = processed[messageKey];
+    const translation = entry.formatter || '""';
+    // Param types for TS
+    const params = Object.keys(entry.paramTypes).map(
+      (paramKey) => `${paramKey}:${entry.paramTypes[paramKey]}`
+    );
+    const paramString = params.length ? `p: {${params.join(',')}}` : '';
+    const paramVar = params.length ? 'p' : undefined;
+    const output = convertor
+      ? `convert({bundleId:"${bundleId}",id:"${messageKey}",params:${paramVar},translation:${translation}})`
+      : translation;
+    return [messageKey, `(${paramString})${valueType && ':' + valueType} => ${output}`];
+  });
+  const targetDir = path.dirname(targetFile);
+  fsx.ensureDirSync(targetDir);
+  fsx.writeFileSync(
+    targetFile,
+    generateContent(
+      rootBundleFile,
+      otherImports.concat(typeImport),
+      translations,
+      withBundleType,
+      convertor,
+      exportType
+    )
+  );
+}
+
+function generateContent(
+  rootBundleFile,
+  imports,
+  translations,
+  withBundleType,
+  convertor,
+  exportType
+) {
+  return `// This file is auto-generated by ${pkg.name} from ${rootBundleFile}
+// and should not be edited by hand. Update the JSON file and rerun the build to regenerate this content.
+  ${imports.join('\n')}
+
+${
+  (convertor &&
+    `
+type ParamsType = {
+  bundleId: string,
+  id: string,
+  params: { [key:string]: any } | undefined,
+  translation: string
+};
+
+const convert = ${convertor}`) ||
+  ''
+}
+const bundle = {
+${translations.map((t) => `  "${t[0]}": ${t[1]}`).join(',\n')}
+};
+${
+  (exportType === 'default' && `export default bundle;`) ||
+  `${translations.map((t) => `export const ${t[0]} = bundle.${t[0]}`).join(';\n')}`
+}
+${withBundleType ? 'export type BundleType = typeof bundle;' : ''}
+`;
+}
+
+/**
+ * Test if a given directory name (base name only) is an NLS directory.
+ * @param {string} name The directory name
+ * @return True if NLS directory, false otherwise
+ */
+function isNlsDir(name) {
+  return (name.match(/^[a-z]{2,3}$/i) || name.match(/^[a-z]{2,3}-.+/)) && !name.match(/\.\w+$/);
+}
+
+function transpile(files, module) {
+  const moduleMap = {
+    amd: ts.ModuleKind.AMD,
+    'legacy-amd': ts.ModuleKind.AMD,
+    esm: ts.ModuleKind.ES2020
+  };
+  const program = ts.createProgram(files, {
+    module: moduleMap[module],
+    target: 'ES2021',
+    strict: true
+  });
+  program.emit();
+}
+
+function convertToLegacyAmd(files) {
+  // Replace default export with top-level keys
+  const amdDefaultExport = 'exports.default = bundle;';
+  files.forEach((file) => {
+    const contents = fsx.readFileSync(file).toString();
+    if (contents.indexOf(amdDefaultExport) === -1) {
+      throw Error(`No default export found in ${file}`);
+    }
+    fsx.writeFileSync(file, contents.replace(amdDefaultExport, 'Object.assign(exports, bundle);'));
+  });
+}
+
+let customHooks = {};
+
+/**
+ * Compile the message bundle in ICU format. This function starts with the "root"
+ * message bundle and attempts to discover bundles for all available locales by
+ * traversing the root bundle's directory and looking for locale directory names.
+ * Any file found under locale directories whose names match the root bundle will
+ * also be compiled.
+ * When creating the output file in the given targetDir, the locale directory
+ * structure from the source will be recreated.
+ * @param {object} props The properties with which to build the bundle
+ * @param {string} props.rootDir The path to the root message bundle
+ * @param {string} props.bundleName The name of the bundle file
+ * @param {string} props.locale The locale of the root message bundle
+ * @param {string} props.outDir The target directory where the compiled root message
+ * @param {string=} props.module The type of module to produce -- 'esm', 'amd', or 'legacy-amd'
+ * @param {string=} props.exportType The type of export to produce -- 'default' or 'named'
+ * @param {boolean=} props.override Indicates the bundle is an override, and only the root
+ * locale and those explicitly stated in [--supportedLocales] will be built.
+ * @param {string[]=} props.additionalLocales An array of additional locales to build
+ * @param {string=} hooks A path to the custom hooks file
+ */
+function build({
+  rootDir,
+  bundleName,
+  locale,
+  outDir,
+  module,
+  exportType = 'default',
+  override,
+  additionalLocales = [],
+  hooks
+}) {
+  const jsonRegEx = /\.json$/;
+  if (!jsonRegEx.test(bundleName)) {
+    throw Error(`${bundleName} must be a JSON file`);
+  }
+  const isLegacyAmd = module === 'legacy-amd';
+  const targetBundleName = bundleName.replace(jsonRegEx, '.ts');
+  // Merge in supported locales to build. If physical dirs don't exist, they'll
+  // inherit the root translations
+  const supportedLocales = [
+    ...new Set(
+      // for override bundles, only look in root and additionalLocales folders
+      (override ? [] : fsx.readdirSync(rootDir).filter(isNlsDir)).concat(additionalLocales).sort()
+    )
+  ];
+
+  customHooks = hooks ? require(hooks) : {};
+
+  // Traverse root bundle
+  const rootBundleFile = path.relative(process.cwd(), path.join(rootDir, bundleName));
+  const rootBundle = getBundle(rootBundleFile);
+  let rootBundleKeys;
+  if (rootBundle) {
+    convertBundle(
+      rootBundleFile,
+      bundleName,
+      rootBundle,
+      locale,
+      path.join(outDir, targetBundleName),
+      isLegacyAmd ? 'default' : exportType,
+      true
+    );
+    rootBundleKeys = new Set(Object.keys(rootBundle));
+  }
+
+  supportedLocales.forEach((locale) => {
+    // Combine all levels into single bundle, starting with rootBundle
+    const combinedBundle = Object.assign({}, rootBundle);
+    const localeParts = locale.split('-');
+    for (let i = 0, len = localeParts.length; i < len; i++) {
+      // Build segment from region (0) to index
+      let segment = localeParts.slice(0, i + 1).join('-');
+      const perBundlePath = path.join(rootDir, segment, bundleName);
+      const perBundle = getBundle(perBundlePath);
+      Object.assign(combinedBundle, perBundle);
+      // combinedBundle should not have keys not in rootBundle
+      if (rootBundleKeys) {
+        const extraKeys = Object.keys(combinedBundle).filter((k) => !rootBundleKeys.has(k));
+        if (extraKeys.length) {
+          throw Error(`${perBundlePath} has keys not found in ${rootBundleFile}: ${extraKeys}`);
+        }
+      }
+    }
+
+    convertBundle(
+      rootBundleFile,
+      bundleName,
+      combinedBundle,
+      locale,
+      path.join(outDir, locale, targetBundleName),
+      isLegacyAmd ? 'default' : exportType
+    );
+  });
+
+  !override && fsx.writeFileSync(
+    path.join(outDir, 'supportedLocales.ts'),
+    `export default ${JSON.stringify(supportedLocales)};\n`
+  );
+
+  if (module) {
+    const transpileFiles = glob.sync(`${path.resolve(outDir)}/**/*.ts`);
+    transpile(transpileFiles, module);
+
+    if (module === 'legacy-amd') {
+      convertToLegacyAmd(glob.sync(`${outDir}/**/${bundleName.replace(jsonRegEx, '')}.js`));
+      transpileFiles.forEach(fsx.removeSync);
+    }
+  }
+}
+module.exports = {
+  build,
+  isNlsDir
+};

package/PatternCompiler.d.ts

@@ -0,0 +1,83 @@
+export = PatternCompiler;
+declare class PatternCompiler {
+  constructor(locale: any);
+  _locale: any;
+  compile(pattern: any): {
+    paramTypes: any;
+    formatter: any;
+  };
+  _processParts(ast: any, paramAccumulator: any, currentPluralNode: any): any;
+  _getNumberFormat(node: any, paramAccumulator: any): string;
+  _getDateTimeFormat(node: any, type: any, paramAccumulator: any): string;
+  _getSelectFormat(node: any, paramAccumulator: any): string;
+  _getPluralFormat(node: any, paramAccumulator: any): string;
+  _getPoundFormat(node: any, paramAccumulator: any): string;
+  _getSelectOptions(
+    node: any,
+    paramAccumulator: any,
+    pluralNode: any
+  ): {
+    opts: any[];
+    other: string;
+    exactPlurals: any[];
+  };
+  _getParameterExpression(node: any, paramAccumulator: any, type: any): string;
+  _stringifyOptions(obj: any): any;
+  _getFormatOpts(): {
+    number: {
+      currency: {
+        style: string;
+      };
+      percent: {
+        style: string;
+      };
+    };
+    date: {
+      short: {
+        month: string;
+        day: string;
+        year: string;
+      };
+      medium: {
+        month: string;
+        day: string;
+        year: string;
+      };
+      long: {
+        month: string;
+        day: string;
+        year: string;
+      };
+      full: {
+        weekday: string;
+        month: string;
+        day: string;
+        year: string;
+      };
+    };
+    time: {
+      short: {
+        hour: string;
+        minute: string;
+      };
+      medium: {
+        hour: string;
+        minute: string;
+        second: string;
+      };
+      long: {
+        hour: string;
+        minute: string;
+        second: string;
+        timeZoneName: string;
+      };
+      full: {
+        hour: string;
+        minute: string;
+        second: string;
+        timeZoneName: string;
+      };
+    };
+  };
+  _getLanguage(): any;
+}

package/PatternCompiler.js

@@ -0,0 +1,253 @@
+const Parser = require('@formatjs/icu-messageformat-parser');
+
+module.exports = class PatternCompiler {
+  constructor(locale) {
+    this._locale = locale;
+  }
+
+  compile(pattern, paramTypes = {}) {
+    // set ignioreTag flag, so that < and > characters are treated as regular characters that do not
+    // require escaping
+    const ast = Parser.parse(pattern, {ignoreTag: true});
+    const paramAccumulator = Object.create(null);
+    const combinedParts = this._processParts(ast, paramAccumulator);
+    return {paramTypes: combineParams(paramAccumulator, paramTypes), formatter: combinedParts};
+  }
+
+  _processParts(ast, paramAccumulator, currentPluralNode) {
+    if (!ast) {
+      return undefined;
+    }
+    const acc = [];
+    return ast.reduce(
+        (acc, node) => {
+            switch (node.type) {
+                case 0: // raw text
+                    acc.push(`${JSON.stringify(node.value)}`);
+                    break;
+                case 1: // argument
+                    acc.push(this._getParameterExpression(node, paramAccumulator));
+                    break;
+                case 2: // number
+                    acc.push(this._getNumberFormat(node, paramAccumulator));
+                    break;
+                case 3: // date
+                    acc.push(this._getDateTimeFormat(node, 'date', paramAccumulator));
+                    break;
+                case 4: // time
+                    acc.push(this._getDateTimeFormat(node, 'time', paramAccumulator));
+                    break;
+                case 5: // select
+                    acc.push(this._getSelectFormat(node, paramAccumulator));
+                    break;
+                case 6: // plural
+                  acc.push(this._getPluralFormat(node, paramAccumulator));
+                    break;
+                case 7: // pound
+                  acc.push(this._getPoundFormat(currentPluralNode, paramAccumulator));
+                  break;
+                default:
+                    throw new Error('Unsupported token type: ' + node.type);
+
+            }
+
+            return acc;
+
+        },
+        acc
+    ).join('+');
+  }
+
+  _getNumberFormat(node, paramAccumulator) {
+      let opts;
+      const style = node.style;
+      if (typeof style === 'string') {
+          opts = this._getFormatOpts().number[style];
+      } else if (Parser.isNumberSkeleton(style)) {
+          opts = style.parsedOptions;
+      }
+      return `new Intl.NumberFormat("${this._locale}",${this._stringifyOptions(opts)}).
+                format(${this._getParameterExpression(node, paramAccumulator, 'number')})`;
+  }
+
+  _getDateTimeFormat(node, type, paramAccumulator) {
+    let opts;
+    const style = node.style;
+    if (typeof style === 'string') {
+        opts = this._getFormatOpts()[type][style];
+    } else if (Parser.isDateTimeSkeleton(style)) {
+        opts = style.parsedOptions;
+    }
+    return `new Intl.DateTimeFormat("${this._locale}",${this._stringifyOptions(opts)}).
+              format(new Date(${this._getParameterExpression(node, paramAccumulator, 'string')}))`;
+  }
+
+  _getSelectFormat(node, paramAccumulator) {
+    const {opts, other} = this._getSelectOptions(node, paramAccumulator);
+    // The generated code will look like the following:
+    // {male: "he said", female: "she said"}[param]||{"they said"}
+    return `({${opts.join(',')}}[${this._getParameterExpression(node, paramAccumulator)}]${other})`;
+  }
+
+  _getPluralFormat(node, paramAccumulator) {
+    const {opts, other, exactPlurals} = this._getSelectOptions(node, paramAccumulator, node);
+    const offset = node.offset !== 0 ? `-(${node.offset})` :  '';
+    const num = this._getParameterExpression(node, paramAccumulator, 'number');
+
+    const pluralMatch = opts.length === 0 ? 'undefined' :
+      `({${opts.join(',')}} as Partial<Record<Intl.LDMLPluralRule, string>>)[new Intl.PluralRules('${this._locale}').select(${num}${offset})]`;
+    const exactMatch =
+      exactPlurals.length > 0 ? `{${exactPlurals.join(',')}}[${num}]||` : '';
+
+    // The generated code will look like the following:
+    // {0: "message for zero"}[pluralNum]||
+    // {one: "one message", many: "many message"}[new Intl.PluralRules(loc).select(pluralNum-offset)]||
+    // {"default message"}
+    return `(${exactMatch}${pluralMatch}${other})`;
+}
+
+  _getPoundFormat(node, paramAccumulator) {
+    if (!node) {
+      throw new Error("Unexpected pound roken outside of the plural rule!");
+    }
+    const offset = node.offset !== 0 ? `-${node.offset}` :  '';
+    const num = this._getParameterExpression(node, paramAccumulator, 'number');
+    return `new Intl.NumberFormat("${this._locale}").format(${num}${offset})`;
+  }
+
+  _getSelectOptions(node, paramAccumulator, pluralNode) {
+    const options = node.options;
+    const opts = []; // regular options
+    let other = ''; // default option
+    const exactPlurals = []; // exact plural values
+    Object.keys(options).forEach(key => {
+      const opt = options[key];
+      if (key === 'other') {
+        other = `||${this._processParts(opt.value, paramAccumulator, pluralNode)}`;
+      } else {
+        if (pluralNode && key.length > 1 && key.startsWith('=')) {
+          exactPlurals.push(`${key.substring(1)}:${this._processParts(opt.value, paramAccumulator, pluralNode)}`);
+        } else {
+          opts.push(`"${key}":${this._processParts(opt.value, paramAccumulator, pluralNode)}`);
+        }
+      }
+    });
+
+    return {opts, other, exactPlurals};
+  }
+
+ _getParameterExpression(node, paramAccumulator, type) {
+    const paramName = node.value;
+    paramAccumulator[paramName] = type || 'string';
+    // no need to escape parameter name since it is supposed to be a valid identifier or number
+    return `p["${paramName}"]`;
+  }
+
+  _stringifyOptions(obj) {
+    if (obj === undefined)
+      return obj;
+    const inner = Object.keys(obj)
+      .map(key => `${key}:${JSON.stringify(obj[key])}`)
+      .join(',');
+    return `{${inner}}`;
+  }
+
+  _getFormatOpts()  {
+    return {
+      number: {
+        currency: {
+          style: 'currency',
+        },
+
+        percent: {
+          style: 'percent',
+        },
+      },
+
+      date: {
+        short: {
+          month: 'numeric',
+          day: 'numeric',
+          year: '2-digit',
+        },
+
+        medium: {
+          month: 'short',
+          day: 'numeric',
+          year: 'numeric',
+        },
+
+        long: {
+          month: 'long',
+          day: 'numeric',
+          year: 'numeric',
+        },
+
+        full: {
+          weekday: 'long',
+          month: 'long',
+          day: 'numeric',
+          year: 'numeric',
+        },
+      },
+
+      time: {
+        short: {
+          hour: 'numeric',
+          minute: 'numeric',
+        },
+
+        medium: {
+          hour: 'numeric',
+          minute: 'numeric',
+          second: 'numeric',
+        },
+
+        long: {
+          hour: 'numeric',
+          minute: 'numeric',
+          second: 'numeric',
+          timeZoneName: 'short',
+        },
+
+        full: {
+          hour: 'numeric',
+          minute: 'numeric',
+          second: 'numeric',
+          timeZoneName: 'short',
+        },
+      },
+    };
+  }
+  _getLanguage() {
+    return this._locale.split('-')[0];
+  }
+}
+
+/**
+ * Combine params from newParams into origParams, but throw exception if existing type differs
+ * @param {*} origParams
+ * @param {*} newParams
+ * @return A combined object of params
+ */
+function combineParams(origParams, newParams) {
+  const typeMap = {
+    'date': 'string',
+    'number': 'number',
+    'plural': 'number',
+    'select': 'string',
+    'text': 'string'
+  }
+  return Object.keys(newParams).reduce((accum, key) => {
+    const newType = typeMap[newParams[key]] || newParams[key];
+    if (key in accum && newType !== undefined && accum[key] !== newType) {
+      throw Error(`Parameter '${key}' defined as type '${accum[key]}' in usage, but ${newType} in metadata`);
+    }
+    return {
+      ...accum,
+      [key]: newType
+    }
+  }, origParams);
+}
+
+