@oracle/oraclejet 14.1.1 → 14.1.3

package/dist/css/stable/oj-stable.css

@@ -333,7 +333,7 @@
   visibility: hidden; }
 
 .oj-theme-json {
-  font-family: '{"name":"stable","targetPlatform":"all","behavior":"redwood","jetReleaseVersion":"v14.1.1"}' !important; }
+  font-family: '{"name":"stable","targetPlatform":"all","behavior":"redwood","jetReleaseVersion":"v14.1.3"}' !important; }
 
 .oj-helper-hidden-accessible {
   border: 0;

package/dist/icu-l10n/Bundler.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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 {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,
+  additionalLocales,
+  hooks
+}: {
+  rootDir: string;
+  bundleName: string;
+  locale: string;
+  outDir: string;
+  module?: string | undefined;
+  exportType?: string | 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/dist/icu-l10n/Bundler.js

@@ -4,6 +4,7 @@ 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.
@@ -47,6 +48,7 @@ function getBundle(filepath) {
 /**
  * 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
@@ -56,12 +58,14 @@ function getBundle(filepath) {
  * @param {boolean?} withBundleType Whether to export the bundle type definition
  * @private
  */
-function convertBundle(bundleId, bundle, locale, targetFile, exportType, withBundleType) {
+function convertBundle(rootBundleFile, bundleId, bundle, locale, targetFile, exportType, withBundleType) {
   const compiler = new PatternCompiler(locale);
   const processed = traverse(compiler, bundle);
   // apply hooks and type imports
   const convertor = customHooks.convertor;
-  const typeImport = customHooks.typeImport ? Object.keys(customHooks.typeImport).map(k => customHooks.typeImport[k])[0]: '';
+  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) => {
@@ -72,14 +76,18 @@ function convertBundle(bundleId, bundle, locale, targetFile, exportType, withBun
       (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 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,
+  fsx.writeFileSync(
+    targetFile,
     generateContent(
+      rootBundleFile,
       otherImports.concat(typeImport),
       translations,
       withBundleType,
@@ -89,10 +97,14 @@ function convertBundle(bundleId, bundle, locale, targetFile, exportType, withBun
   );
 }
 
-function generateContent(imports, translations, withBundleType, convertor, exportType) {
-  return `${imports.join('\n')}
+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 && `
+${
+  (convertor &&
+    `
 type ParamsType = {
   bundleId: string,
   id: string,
@@ -100,13 +112,16 @@ type ParamsType = {
   translation: string
 };
 
-const convert = ${convertor}` || ''}
+const convert = ${convertor}`) ||
+  ''
+}
 const bundle = {
-${translations.map(t => `  ${t[0]}: ${t[1]}`).join(',\n')}
+${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')}`}
+${
+  (exportType === 'default' && `export default bundle;`) ||
+  `${translations.map((t) => `export const ${t[0]} = bundle.${t[0]}`).join(';\n')}`
+}
 ${withBundleType ? 'export type BundleType = typeof bundle;' : ''}
 `;
 }
@@ -120,20 +135,33 @@ function isNlsDir(name) {
   return (name.match(/^[a-z]{2,3}$/i) || name.match(/^[a-z]{2,3}-.+/)) && !name.match(/\.\w+$/);
 }
 
-function transpile(rootDir, moduleType) {
+function transpile(files, module) {
   const moduleMap = {
     amd: ts.ModuleKind.AMD,
+    'legacy-amd': ts.ModuleKind.AMD,
     esm: ts.ModuleKind.ES2020
   };
-  const options = {
-    module: moduleMap[moduleType],
-    target: 'ES2021'
-  };
-  const program = ts.createProgram(glob.sync(`${rootDir}/**/*.ts`), options);
+  const program = ts.createProgram(files, {
+    module: moduleMap[module],
+    target: 'ES2021',
+    strict: true
+  });
   program.emit();
 }
 
-let customHooks = { };
+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"
@@ -148,17 +176,26 @@ let customHooks = { };
  * @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 -- 'amd' or 'esm'
- * @param {string?} props.exportType The type of export to produce -- 'default' or 'named'
- * @param {string[]?} props.additionalLocales An array of additional locales to build
- * @param {string?} hooks A path to the custom hooks file
+ * @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 {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', additionalLocales = [], hooks }) {
+function build({
+  rootDir,
+  bundleName,
+  locale,
+  outDir,
+  module,
+  exportType = 'default',
+  additionalLocales = [],
+  hooks
+}) {
   const jsonRegEx = /\.json$/;
   if (!jsonRegEx.test(bundleName)) {
     throw Error(`${bundleName} must be a JSON file`);
   }
-  const pkg = require('./package.json');
+  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
@@ -166,19 +203,19 @@ function build({ rootDir, bundleName, locale, outDir, module, exportType = 'defa
     ...new Set(fsx.readdirSync(rootDir).filter(isNlsDir).concat(additionalLocales).sort())
   ];
 
-  if (hooks) {
-    customHooks = require(hooks);
-  }
+  customHooks = hooks ? require(hooks) : {};
 
   // Traverse root bundle
-  const rootBundle = getBundle(path.join(rootDir, bundleName));
+  const rootBundleFile = path.relative(__dirname, path.join(rootDir, bundleName));
+  const rootBundle = getBundle(rootBundleFile);
   if (rootBundle) {
     convertBundle(
+      rootBundleFile,
       bundleName,
       rootBundle,
       locale,
       path.join(outDir, targetBundleName),
-      exportType,
+      isLegacyAmd ? 'default' : exportType,
       true
     );
   }
@@ -194,14 +231,15 @@ function build({ rootDir, bundleName, locale, outDir, module, exportType = 'defa
       Object.assign(combinedBundle, perBundle);
     }
 
-      convertBundle(
-        bundleName,
-        combinedBundle,
-        locale,
-        path.join(outDir, locale, targetBundleName),
-        exportType
-      );
-    });
+    convertBundle(
+      rootBundleFile,
+      bundleName,
+      combinedBundle,
+      locale,
+      path.join(outDir, locale, targetBundleName),
+      isLegacyAmd ? 'default' : exportType
+    );
+  });
 
   fsx.writeFileSync(
     path.join(outDir, 'supportedLocales.ts'),
@@ -209,7 +247,13 @@ function build({ rootDir, bundleName, locale, outDir, module, exportType = 'defa
   );
 
   if (module) {
-    transpile(path.resolve(outDir), 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 = {

package/dist/icu-l10n/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/dist/icu-l10n/PatternCompiler.js

@@ -95,7 +95,7 @@ module.exports = class PatternCompiler {
     const num = this._getParameterExpression(node, paramAccumulator, 'number');
 
     const pluralMatch = opts.length === 0 ? 'undefined' :
-      `{${opts.join(',')}}[new Intl.PluralRules('${this._locale}').select(${num}${offset})]`;
+      `({${opts.join(',')}} as Partial<Record<Intl.LDMLPluralRule, string>>)[new Intl.PluralRules('${this._locale}').select(${num}${offset})]`;
     const exactMatch =
       exactPlurals.length > 0 ? `{${exactPlurals.join(',')}}[${num}]||` : '';
 

package/dist/icu-l10n/README.md

@@ -177,12 +177,17 @@ The directory where the resource bundles will be written
 
 ### **module** _(optional)_
 
-The type of module to produce for the bundles. Supported values are `esm` or `amd`.
+The type of module to produce for the bundles. Supported values are `esm`, `amd`, or `legacy-amd`.
 If not specified, only the original Typescript source files will be produced, and
 no transpilation is performed.
 
 > ex. `--module=esm`
 
+> For backwards compatibility with previous forms of the bundle in AMD, the `legacy-amd` format
+> will produce a bundle with all keys at the root, similar to using named exports. There will also be no
+> TypeScript or type definitions present for the bundle.
+> This option overrides the `--exportType` argument.
+
 ### **exportType** _(optional)_
 
 The type of export to be used. Possible values `named` or `default`. If not given,

package/dist/icu-l10n/l10nBundleBuilder.js

@@ -28,7 +28,7 @@ if ('rootDir' in argsMap && 'bundleName' in argsMap && 'locale' in argsMap && 'o
       --locale\tThe bundle's locale (not required for override bundles)
       --outDir\tThe output directory where the built bundle will be written
     Optional:
-      --module\tProduce bundles as 'amd' or 'esm' modules
+      --module\tProduce bundles as 'esm', 'amd', or 'legacy-amd' modules
       --exportType\tThe type of export, either 'named' or 'default' (default='default')
       --hooks\tThe hooks file to use (see example)
       --supportedLocales\tA list of comma-separated additional locales to build. If

package/dist/icu-l10n/package.json

@@ -17,9 +17,11 @@
     "typescript": "4.8.4"
   },
   "devDependencies": {
+    "@jest/globals": "27.5.1",
     "@oracle/oraclejet-test-utils": "workspace:^",
     "jest": "27.5.1",
-    "rimraf": "3.0.2"
+    "rimraf": "3.0.2",
+    "ts-jest": "29.1.0"
   },
   "bin": {
     "l10nBundleBuilder": "./l10nBundleBuilder.js"

package/dist/icu-l10n/test/bundleTypeTest.ts

@@ -0,0 +1,40 @@
+import * as fsx from 'fs-extra';
+
+import { describe, expect, test } from '@jest/globals';
+
+import { build } from '../Bundler';
+import glob from 'glob';
+import path from 'path';
+
+describe('L10n builder TypeScript tests', () => {
+  const outputRoot = `${__dirname}/built`;
+  const rootDir = `${__dirname}/resources/nls`;
+
+  describe('TS-only output', () => {
+    const outDir = path.resolve(outputRoot, 'ts');
+    beforeAll(() => {
+      fsx.removeSync(outDir);
+      build({
+        rootDir,
+        bundleName: 'app-strings.json',
+        locale: 'en-US',
+        outDir
+      });
+      build({
+        rootDir,
+        bundleName: 'app-strings-x.json',
+        locale: 'en-US',
+        outDir
+      });
+    });
+
+    test('does not produce JS', () => {
+      expect(glob.sync(`${outDir}/**/*.js`).length).toEqual(0);
+    });
+
+    test('retrieves a value from the TS bundle', async () => {
+      const bundle = (await import(`${outDir}/app-strings`)).default;
+      expect(bundle.testPlural({ itemCount: 2 })).toEqual('You have 2 items');
+    });
+  });
+});

package/dist/icu-l10n/test/jest.config.js

@@ -2,7 +2,8 @@ const pkg = require('../package.json');
 const workspaceConfig = require('@oracle/oraclejet-test-utils/workspace-jest-config');
 
 module.exports = workspaceConfig({
+  preset: 'ts-jest',
   displayName: pkg.name,
   rootDir: __dirname,
-  testMatch: [ "**/*Test.js" ]
+  testMatch: [ '**/*Test.js', '**/*Test.ts' ]
 });

package/dist/icu-l10n/test/l10nTest.js

@@ -14,15 +14,15 @@ function runTestCases(extractBundle) {
     it('ignores unsupported types', () => {
       const bundle = extractBundle(`app-strings.js`);
       assert(Object.keys(bundle).indexOf('@count') === -1, '@count should not be in bundle');
-      assert(Object.keys(bundle).indexOf('@another_button') === -1, '@another_button should not be in bundle');
       assert(
-        Object.keys(bundle).indexOf('@@x-base-bundle') === -1,
-        '@@x-base-bundle should not be in bundle'
+        Object.keys(bundle).indexOf('@another_button') === -1,
+        '@another_button should not be in bundle'
       );
       assert(
-        Object.keys(bundle).indexOf('@@locale') === -1,
-        '@@locale should not be in bundle'
+        Object.keys(bundle).indexOf('@@x-base-bundle') === -1,
+        '@@x-base-bundle should not be in bundle'
       );
+      assert(Object.keys(bundle).indexOf('@@locale') === -1, '@@locale should not be in bundle');
     });
 
     it('creates the root bundle in English', () => {
@@ -210,31 +210,7 @@ function runTestCases(extractBundle) {
   });
 }
 
-describe('TS output', () => {
-  const outDir = path.resolve(outputRoot, 'ts');
-  beforeAll(() => {
-    fsx.removeSync(outDir);
-    build({
-      rootDir,
-      bundleName: 'app-strings.json',
-      locale: 'en-US',
-      outDir
-    });
-    build({
-      rootDir,
-      bundleName: 'app-strings-x.json',
-      locale: 'en-US',
-      outDir
-    });
-  });
-
-  it('does not produce JS', () => {
-    assert(glob.sync(`${outDir}/**/*.js`).length === 0, 'should not have JS');
-  });
-});
-
 describe('Custom hooks', () => {
-
   it('can produce custom return types', () => {
     const outDir = path.resolve(outputRoot, 'custom-hooks');
     fsx.removeSync(outDir);
@@ -243,7 +219,7 @@ describe('Custom hooks', () => {
       bundleName: 'app-strings.json',
       locale: 'en-US',
       outDir,
-      hooks: require.resolve('./custom-hooks.js'),
+      hooks: require.resolve('./resources/custom-hooks.js'),
       module: 'cjs'
     });
 
@@ -262,7 +238,7 @@ describe('Custom hooks', () => {
       bundleName: 'app-strings.json',
       locale: 'en-US',
       outDir,
-      hooks: require.resolve('./custom-hooks-no-def.js'),
+      hooks: require.resolve('./resources/custom-hooks-no-def.js'),
       module: 'cjs'
     });
 
@@ -306,35 +282,36 @@ describe('CJS default export', () => {
 });
 
 describe('AMD', () => {
+  /**
+   * Read contents of ES6 file and convert to CommonJS export for Node testing
+   * @param {string} filepath
+   */
+  function extractBundle(filepath, exportType) {
+    const bundleContents = fsx.readFileSync(filepath).toString();
+    // Create a 'define' method in the context which returns the object passed in
+    const script = new vm.Script(bundleContents, '');
+    const context = vm.createContext({
+      define: function (rb) {
+        // define({ ... })
+        if (arguments.length === 1) {
+          return rb;
+        }
+        // define(['require', 'exports'], function(require, exports))
+        const exp = {};
+        // pass exports for every argument
+        const args = new Array(arguments[0].length);
+        const ret = arguments[1](...args.fill(exp));
+        // AMD may return the value or assign to 'exports'
+        const resource = ret || exp;
+        return exportType === 'default' ? resource.default : resource;
+      }
+    });
+    const rb = script.runInContext(context);
+    return rb;
+  }
+
   function testAmd(exportType) {
     const outDir = path.resolve(outputRoot, `amd-${exportType}`);
-    /**
-     * Read contents of ES6 file and convert to CommonJS export for Node testing
-     * @param {string} filePath
-     */
-    function extractBundle(filepath) {
-      const bundleContents = fsx.readFileSync(path.join(outDir, filepath)).toString();
-      // Create a 'define' method in the context which returns the object passed in
-      const script = new vm.Script(bundleContents, '');
-      const context = vm.createContext({
-        define: function (rb) {
-          // define({ ... })
-          if (arguments.length === 1) {
-            return rb;
-          }
-          // define(['require', 'exports'], function(require, exports))
-          const exp = {};
-          // pass exports for every argument
-          const args = new Array(arguments[0].length);
-          const ret = arguments[1](...args.fill(exp));
-          // AMD may return the value or assign to 'exports'
-          const resource = ret || exp;
-          return exportType === 'default' ? resource.default : resource;
-        }
-      });
-      const rb = script.runInContext(context);
-      return rb;
-    }
 
     fsx.removeSync(outDir);
     build({
@@ -354,7 +331,7 @@ describe('AMD', () => {
       exportType
     });
 
-    runTestCases(extractBundle);
+    runTestCases((fp) => extractBundle(path.join(outDir, fp), exportType));
   }
 
   describe('default output', () => {
@@ -365,6 +342,34 @@ describe('AMD', () => {
     testAmd('named');
   });
 
+  describe('legacy-amd', () => {
+    const outDir = path.resolve(outputRoot, 'legacy-amd');
+
+    beforeAll(() => {
+      fsx.removeSync(outDir);
+      build({
+        rootDir,
+        bundleName: 'app-strings-legacy-keys.json',
+        locale: 'en-US',
+        outDir,
+        module: 'legacy-amd'
+      });
+    });
+
+    it('does not contain ts output', () => {
+      expect(glob.sync(path.join(outDir, '**', '*.ts'))).toEqual([]);
+    });
+
+    it('creates non-standard keys', () => {
+      const bundle = extractBundle(
+        path.join(outDir, 'app-strings-legacy-keys.js'),
+        'named'
+      );
+      expect(bundle['dot.key']()).toEqual('Dot key');
+      expect(bundle['.leading.dot.key']()).toEqual('Leading dot key');
+      expect(bundle['dash-key']()).toEqual('Dash key');
+    });
+  });
 });
 
 describe('Extra locales', () => {

package/dist/icu-l10n/test/{custom-hooks.js → resources/custom-hooks.js}

@@ -2,7 +2,7 @@ module.exports = {
   typeImport: {
     CustomMessageType: 'import { CustomMessageType } from "../../resources/CustomMessageType";'
   },
-  otherImports: 'import { escape } from "../../escape-util";',
+  otherImports: 'import { escape } from "../../resources/escape-util";',
   // remap some of the parameter names to different keys
   convertor: '(args: ParamsType): CustomMessageType => ({bundle: args.bundleId, key: args.id, params: args.params, value: escape(args.translation)})'
 };

package/dist/icu-l10n/test/resources/nls/app-strings-legacy-keys.json

@@ -0,0 +1,5 @@
+{
+  "dot.key": "Dot key",
+  ".leading.dot.key": "Leading dot key",
+  "dash-key": "Dash key"
+}

package/dist/icu-l10n/test/resources/nls/app-strings.json

@@ -19,5 +19,6 @@
   },
   "delta": "Delta",
   "epsilon": "Epsilon",
-  "blank": ""
+  "blank": "",
+  "testPlural": "You have {itemCount, plural, =0 {no items} one {item} other {{itemCount} items}}"
 }