@vocab/react 1.0.2 → 1.1.2

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @vocab/react
 
+## 1.1.2
+
+### Patch Changes
+
+- [`240d6ad`](https://github.com/seek-oss/vocab/commit/240d6ad7e0cf43fed92655a2f95fb463bd7b6644) [#85](https://github.com/seek-oss/vocab/pull/85) Thanks [@askoufis](https://github.com/askoufis)! - The `t` function returned from `useTranslations` is now memoized. `t` should now only change after the initial loading of translations, and when the language changes, making it more useful inside a hook's dependency array.
+
+## 1.1.1
+
+### Patch Changes
+
+- [`e9c7067`](https://github.com/seek-oss/vocab/commit/e9c7067b31215a176e70ac1e73f2c878107f328f) [#83](https://github.com/seek-oss/vocab/pull/83) Thanks [@michaeltaranto](https://github.com/michaeltaranto)! - Add React 18 support
+
+## 1.1.0
+
+### Minor Changes
+
+- [`6de02b3`](https://github.com/seek-oss/vocab/commit/6de02b35839e8ecdd9016fec49a95e17d3696f87) [#69](https://github.com/seek-oss/vocab/pull/69) Thanks [@mattcompiles](https://github.com/mattcompiles)! - Automatically assign keys to React elements
+
+  Previously, when using React elements within translation templates, React would warn about missing keys as the return type is an array. This meant you needed to supply a key manually. Vocab can now automatically assign a key to React elements. Keys that are passed explicitly will remain untouched.
+
 ## 1.0.2
 
 ### Patch Changes

package/README.md

@@ -184,6 +184,14 @@ Configuration can either be passed into the Node API directly or be gathered fro
 **vocab.config.js**
 
 ```js
+function capitalize(element) {
+  return element.toUpperCase();
+}
+
+function pad(message) {
+  return '[' + message + ']';
+}
+
 module.exports = {
   devLanguage: 'en',
   languages: [
@@ -192,11 +200,25 @@ module.exports = {
     { name: 'en-US', extends: 'en' },
     { name: 'fr-FR' }
   ],
+  /**
+   * An array of languages to generate based off translations for existing languages
+   * Default: []
+   */
+  generatedLanguages: [
+    {
+      name: 'generatedLangauge',
+      extends: 'en',
+      generator: {
+        transformElement: capitalize,
+        transformMessage: pad
+      }
+    }
+  ],
   /**
    * The root directory to compile and validate translations
    * Default: Current working directory
    */
-  projectRoot: './example/';
+  projectRoot: './example/',
   /**
    * A custom suffix to name vocab translation directories
    * Default: '.vocab'
@@ -209,6 +231,131 @@ module.exports = {
 };
 ```
 
+## Generated languages
+
+Vocab supports the creation of generated languages via the `generatedLanguages` config.
+
+Generated languages are created by running a message `generator` over every translation message in an existing translation.
+A `generator` may contain a `transformElement` function, a `transformMessage` function, or both.
+Both of these functions accept a single string parameter and return a string.
+
+`transformElement` is applied to string literal values contained within `MessageFormatElement`s.
+A `MessageFormatElement` is an object representing a node in the AST of a compiled translation message.
+Simply put, any text that would end up being translated by a translator, i.e. anything that is not part of the [ICU Message syntax], will be passed to `transformElement`.
+An example of a use case for this function would be adding [diacritics] to every letter in order to stress your UI from a vertical line-height perspective.
+
+`transformMessage` receives the entire translation message _after_ `transformElement` has been applied to its individual elements.
+An example of a use case for this function would be adding padding text to the start/end of your messages in order to easily identify which text in your app has not been extracted into a `translations.json` file.
+
+By default, a generated language's messages will be based off the `devLanguage`'s messages, but this can be overridden by providing an `extends` value that references another language.
+
+**vocab.config.js**
+
+```js
+function capitalize(message) {
+  return message.toUpperCase();
+}
+
+function pad(message) {
+  return '[' + message + ']';
+}
+
+module.exports = {
+  devLanguage: 'en',
+  languages: [{ name: 'en' }, { name: 'fr' }],
+  generatedLanguages: [
+    {
+      name: 'generatedLanguage',
+      extends: 'en',
+      generator: {
+        transformElement: capitalize,
+        transformMessage: pad
+      }
+    }
+  ]
+};
+```
+
+Generated languages are consumed the same way as regular languages.
+Any Vocab API that accepts a `language` parameter will work with a generated language as well as a regular language.
+
+**App.tsx**
+
+```tsx
+const App = () => (
+  <VocabProvider language="generatedLanguage">
+    ...
+  </VocabProvider>
+);
+```
+
+[icu message syntax]: https://formatjs.io/docs/intl-messageformat/#message-syntax
+[diacritics]: https://en.wikipedia.org/wiki/Diacritic
+
+## Pseudo-localization
+
+The `@vocab/pseudo-localize` package exports low-level functions that can be used for pseudo-localization of translation messages.
+
+```ts
+import {
+  extendVowels,
+  padString,
+  pseudoLocalize,
+  substituteCharacters
+} from '@vocab/pseudo-localize';
+
+const message = 'Hello';
+
+// [Hello]
+const paddedMessage = padString(message);
+
+// Ḩẽƚƚö
+const substitutedMessage = substituteCharacters(message);
+
+// Heelloo
+const extendedMessage = extendVowels(message);
+
+// Extend the message and then substitute characters
+// Ḩẽẽƚƚöö
+const pseudoLocalizedMessage = pseudoLocalize(message);
+```
+
+Pseudo-localization is a transformation that can be applied to a translation message.
+Vocab's implementation of this transformation contains the following elements:
+
+- _Start and end markers (`padString`):_ All strings are encapsulated in `[` and `]`. If a developer doesn’t see these characters they know the string has been clipped by an inflexible UI element.
+- _Transformation of ASCII characters to extended character equivalents (`substituteCharacters`):_ Stresses the UI from a vertical line-height perspective, tests font and encoding support, and weeds out strings that haven’t been externalized correctly (they will not have the pseudo-localization applied to them).
+- _Padding text (`extendVowels`):_ Simulates translation-induced expansion. Vocab's implementation of this involves repeating vowels (and `y`) to simulate a 40% expansion in the message's length.
+
+This Netflix technology [blog post][blog post] inspired Vocab's implementation of this
+functionality.
+
+### Generating a pseudo-localized language using Vocab
+
+Vocab can generate a pseudo-localized language via the [`generatedLanguages` config][generated languages config], either via the webpack plugin or your `vocab.config.js` file.
+`@vocab/pseudo-localize` exports a `generator` that can be used directly in your config.
+
+**vocab.config.js**
+
+```js
+const { generator } = require('@vocab/pseudo-localize');
+
+module.exports = {
+  devLanguage: 'en',
+  languages: [{ name: 'en' }, { name: 'fr' }],
+  generatedLanguages: [
+    {
+      name: 'pseudo',
+      extends: 'en',
+      generator
+    }
+  ]
+};
+```
+
+[blog post]: https://netflixtechblog.com/pseudo-localization-netflix-12fff76fbcbe
+[generated languages config]: #generated-languages
+
 ## Use without React
 
 If you need to use Vocab outside of React, you can access the returned Vocab file directly. You'll then be responsible for when to load translations and how to update on translation load.

package/dist/declarations/src/index.d.ts

@@ -1,11 +1,14 @@
 import { TranslationFile, LanguageName, ParsedFormatFnByKey, ParsedFormatFn } from '@vocab/types';
-import { FunctionComponent, ReactNode } from 'react';
+import { ReactNode } from 'react';
 declare type Locale = string;
 interface TranslationsValue {
     language: LanguageName;
     locale?: Locale;
 }
-export declare const VocabProvider: FunctionComponent<TranslationsValue>;
+interface VocabProviderProps extends TranslationsValue {
+    children: ReactNode;
+}
+export declare const VocabProvider: ({ children, language, locale, }: VocabProviderProps) => JSX.Element;
 export declare const useLanguage: () => TranslationsValue;
 declare type FormatXMLElementReactNodeFn = (parts: ReactNode[]) => ReactNode;
 declare type MapToReactNodeFunction<Params extends Record<string, any>> = {

package/dist/vocab-react.cjs.dev.js

@@ -43,6 +43,7 @@ function useTranslations(translations) {
   } = useLanguage();
   const [, forceRender] = React.useReducer(s => s + 1, 0);
   const translationsObject = translations.getLoadedMessages(language, locale || language);
+  let ready = true;
 
   if (!translationsObject) {
     if (SERVER_RENDERING) {
@@ -52,24 +53,40 @@ function useTranslations(translations) {
     translations.load(language).then(() => {
       forceRender();
     });
-    return {
-      t: () => ' ',
-      ready: false
-    };
+    ready = false;
   }
 
-  const t = (key, params) => {
-    if (!(translationsObject !== null && translationsObject !== void 0 && translationsObject[key])) {
+  const t = React.useCallback((key, params) => {
+    if (!translationsObject) {
+      return ' ';
+    }
+
+    const message = translationsObject === null || translationsObject === void 0 ? void 0 : translationsObject[key];
+
+    if (!message) {
       // eslint-disable-next-line no-console
       console.error(`Unable to find translation for key "${key}". Possible keys are ${Object.keys(translationsObject).map(v => `"${v}"`).join(', ')}`);
       return '';
     }
 
-    return translationsObject[key].format(params);
-  };
+    const result = message.format(params);
+
+    if (Array.isArray(result)) {
+      for (let i = 0; i < result.length; i++) {
+        const item = result[i];
+
+        if (typeof item === 'object' && item && !item.key && /*#__PURE__*/React.isValidElement(item)) {
+          result[i] = /*#__PURE__*/React.cloneElement(item, {
+            key: `_vocab-${i}`
+          });
+        }
+      }
+    }
 
+    return result;
+  }, [translationsObject]);
   return {
-    ready: true,
+    ready,
     t
   };
 }

package/dist/vocab-react.cjs.prod.js

@@ -43,6 +43,7 @@ function useTranslations(translations) {
   } = useLanguage();
   const [, forceRender] = React.useReducer(s => s + 1, 0);
   const translationsObject = translations.getLoadedMessages(language, locale || language);
+  let ready = true;
 
   if (!translationsObject) {
     if (SERVER_RENDERING) {
@@ -52,24 +53,40 @@ function useTranslations(translations) {
     translations.load(language).then(() => {
       forceRender();
     });
-    return {
-      t: () => ' ',
-      ready: false
-    };
+    ready = false;
   }
 
-  const t = (key, params) => {
-    if (!(translationsObject !== null && translationsObject !== void 0 && translationsObject[key])) {
+  const t = React.useCallback((key, params) => {
+    if (!translationsObject) {
+      return ' ';
+    }
+
+    const message = translationsObject === null || translationsObject === void 0 ? void 0 : translationsObject[key];
+
+    if (!message) {
       // eslint-disable-next-line no-console
       console.error(`Unable to find translation for key "${key}". Possible keys are ${Object.keys(translationsObject).map(v => `"${v}"`).join(', ')}`);
       return '';
     }
 
-    return translationsObject[key].format(params);
-  };
+    const result = message.format(params);
+
+    if (Array.isArray(result)) {
+      for (let i = 0; i < result.length; i++) {
+        const item = result[i];
+
+        if (typeof item === 'object' && item && !item.key && /*#__PURE__*/React.isValidElement(item)) {
+          result[i] = /*#__PURE__*/React.cloneElement(item, {
+            key: `_vocab-${i}`
+          });
+        }
+      }
+    }
 
+    return result;
+  }, [translationsObject]);
   return {
-    ready: true,
+    ready,
     t
   };
 }

package/dist/vocab-react.esm.js

@@ -1,4 +1,4 @@
-import React, { useMemo, useContext, useReducer } from 'react';
+import React, { useMemo, useContext, useReducer, useCallback, isValidElement, cloneElement } from 'react';
 
 const TranslationsContext = /*#__PURE__*/React.createContext(undefined);
 const VocabProvider = ({
@@ -35,6 +35,7 @@ function useTranslations(translations) {
   } = useLanguage();
   const [, forceRender] = useReducer(s => s + 1, 0);
   const translationsObject = translations.getLoadedMessages(language, locale || language);
+  let ready = true;
 
   if (!translationsObject) {
     if (SERVER_RENDERING) {
@@ -44,24 +45,40 @@ function useTranslations(translations) {
     translations.load(language).then(() => {
       forceRender();
     });
-    return {
-      t: () => ' ',
-      ready: false
-    };
+    ready = false;
   }
 
-  const t = (key, params) => {
-    if (!(translationsObject !== null && translationsObject !== void 0 && translationsObject[key])) {
+  const t = useCallback((key, params) => {
+    if (!translationsObject) {
+      return ' ';
+    }
+
+    const message = translationsObject === null || translationsObject === void 0 ? void 0 : translationsObject[key];
+
+    if (!message) {
       // eslint-disable-next-line no-console
       console.error(`Unable to find translation for key "${key}". Possible keys are ${Object.keys(translationsObject).map(v => `"${v}"`).join(', ')}`);
       return '';
     }
 
-    return translationsObject[key].format(params);
-  };
+    const result = message.format(params);
+
+    if (Array.isArray(result)) {
+      for (let i = 0; i < result.length; i++) {
+        const item = result[i];
+
+        if (typeof item === 'object' && item && !item.key && /*#__PURE__*/isValidElement(item)) {
+          result[i] = /*#__PURE__*/cloneElement(item, {
+            key: `_vocab-${i}`
+          });
+        }
+      }
+    }
 
+    return result;
+  }, [translationsObject]);
   return {
-    ready: true,
+    ready,
     t
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vocab/react",
-  "version": "1.0.2",
+  "version": "1.1.2",
   "main": "dist/vocab-react.cjs.js",
   "module": "dist/vocab-react.esm.js",
   "author": "SEEK",
@@ -13,7 +13,7 @@
     "intl-messageformat": "^9.9.0"
   },
   "devDependencies": {
-    "@types/react": "^17.0.0",
-    "react": "^17.0.1"
+    "@types/react": "^18.0.9",
+    "react": "^18.1.0"
   }
 }

package/src/index.tsx

@@ -5,11 +5,13 @@ import {
   ParsedFormatFn,
 } from '@vocab/types';
 import React, {
-  FunctionComponent,
   ReactNode,
   useContext,
   useMemo,
   useReducer,
+  isValidElement,
+  cloneElement,
+  useCallback,
 } from 'react';
 
 type Locale = string;
@@ -23,11 +25,14 @@ const TranslationsContext = React.createContext<TranslationsValue | undefined>(
   undefined,
 );
 
-export const VocabProvider: FunctionComponent<TranslationsValue> = ({
+interface VocabProviderProps extends TranslationsValue {
+  children: ReactNode;
+}
+export const VocabProvider = ({
   children,
   language,
   locale,
-}) => {
+}: VocabProviderProps) => {
   const value = useMemo(() => ({ language, locale }), [language, locale]);
 
   return (
@@ -49,6 +54,7 @@ export const useLanguage = (): TranslationsValue => {
       'Attempted to access translation without language set. Did you forget to pass language to VocabProvider?',
     );
   }
+
   return context;
 };
 
@@ -92,44 +98,70 @@ export function useTranslations<
 } {
   const { language, locale } = useLanguage();
   const [, forceRender] = useReducer((s: number) => s + 1, 0);
+
   const translationsObject = translations.getLoadedMessages(
     language as any,
     locale || language,
   );
 
+  let ready = true;
+
   if (!translationsObject) {
     if (SERVER_RENDERING) {
       throw new Error(
         `Translations not synchronously available on server render. Applying translations dynamically server-side is not supported.`,
       );
     }
+
     translations.load(language as any).then(() => {
       forceRender();
     });
-    return {
-      t: (() => ' ') as TranslateFn<ParsedFormatFnByKey>,
-      ready: false,
-    };
+    ready = false;
   }
 
-  const t = (key: string, params?: any) => {
-    if (!translationsObject?.[key]) {
-      // eslint-disable-next-line no-console
-      console.error(
-        `Unable to find translation for key "${key}". Possible keys are ${Object.keys(
-          translationsObject,
-        )
-          .map((v) => `"${v}"`)
-          .join(', ')}`,
-      );
-      return '';
-    }
+  const t = useCallback(
+    (key: string, params?: any) => {
+      if (!translationsObject) {
+        return ' ';
+      }
 
-    return translationsObject[key].format(params);
-  };
+      const message = translationsObject?.[key];
+
+      if (!message) {
+        // eslint-disable-next-line no-console
+        console.error(
+          `Unable to find translation for key "${key}". Possible keys are ${Object.keys(
+            translationsObject,
+          )
+            .map((v) => `"${v}"`)
+            .join(', ')}`,
+        );
+        return '';
+      }
+
+      const result = message.format(params);
+
+      if (Array.isArray(result)) {
+        for (let i = 0; i < result.length; i++) {
+          const item = result[i];
+          if (
+            typeof item === 'object' &&
+            item &&
+            !item.key &&
+            isValidElement(item)
+          ) {
+            result[i] = cloneElement(item, { key: `_vocab-${i}` });
+          }
+        }
+      }
+
+      return result;
+    },
+    [translationsObject],
+  );
 
   return {
-    ready: true,
+    ready,
     t,
   };
 }