Utilities in the I18N package are designed for internationalization of Gravity UI services.

• Removed static method setDefaultLang, you have to use i18n.setLang instead
• Removed default Rum Logger, you have to connect your own logger from application side
• Removed static property LANGS

npm install --save @gravity-ui/i18n

Accepts options object with optional logger that would be used for logging library warnings.

Logger should have explicit log method with following signature:

• message - string of message that would be logged
• options - object of logging options:
  • level - level for logging message, always 'info'
  • logger - where to log library messages
  • extra - additional options object, with a single type string, that is always i18n

{
  "wizard": {
    "label_error-widget-no-access": "No access to the chart"
  }
}

{
  "wizard": {
    "label_error-widget-no-access": "Нет доступа к чарту"
  }
}

const ru = require('./keysets/ru.json');
const en = require('./keysets/en.json');

const {I18N} = require('../src');

const i18n = new I18N();
i18n.registerKeysets('ru', ru);
i18n.registerKeysets('en', en);

i18n.setLang('ru');
console.log(
    i18n.i18n('wizard', 'label_error-widget-no-access')
); // -> "Нет доступа к чарту"

i18n.setLang('en');
console.log(
    i18n.i18n('wizard', 'label_error-widget-no-access')
); // -> "No access to the chart

// Keyset allows for a simpler translations retrieval
const keyset = i18n.keyset('wizard');
console.log(
    keyset('label_error-widget-no-access')
); // -> "No access to the chart"


i18n.setLang('ru');
console.log(
    keyset('label_error-widget-no-access')
); // -> "Нет доступа к чарту"

// Checking if keyset has a key
if (i18n.has('wizard', 'label_error-widget-no-access')) {
    i18n.i18n('wizard', 'label_error-widget-no-access')
}

The library supports templating. Templated variables are enclosed in double curly brackets, and the values are passed to the i18n function as a key-value dictionary:

{
  "label_template": "No matches found for '{{inputValue}}' in '{{folderName}}'"
}

i18n('label_template', {inputValue: 'something', folderName: 'somewhere'});  // => No matches found for "something" "somewhere"

Pluralization can be used for easy localization of keys that depend on numeric values:

{
  "label_seconds": ["{{count}} second is left", "{{count}} seconds are left", "{{count}} seconds are left", "No time left"]
}

i18n('label_seconds', {count: 1});  // => 1 second
i18n('label_seconds', {count: 3});  // => 3 seconds
i18n('label_seconds', {count: 7});  // => 7 seconds
i18n('label_seconds', {count: 10}); // => 10 seconds
i18n('label_seconds', {count: 0});  // => No time left

A pluralized key contains 4 values, each corresponding to a PluralForm enum value. The enum values are: One, Few, Many, and None, respectively. Template variable name for pluralization is count.

Since every language has its own way of pluralization, the library provides a method to configure the rules for any chosen language.

The configuration function accepts an object with languages as keys, and pluralization functions as values.

A pluralization function accepts a number and the PluralForm enum, and is expected to return one of the enum values depending on the provided number.

const {I18N} = require('@gravity-ui/i18n');

const i18n = new I18N();

i18n.configurePluralization({
  en: (count, pluralForms) => {
    if (!count) return pluralForms.None;
    if (count === 1) return pluralForms.One;
    return pluralForms.Many;
  },
});

The two languages supported out of the box are English and Russian.

Language key: en.

• One corresponds to 1 and -1.
• Few is not used.
• Many corresponds to any other number, except 0.
• None corresponds to 0.

Language key: ru.

• One corresponds to any number ending in 1, except ±11.
• Few corresponds to any number ending in 2, 3 or 4, except ±12, ±13 and ±14.
• Many corresponds to any other number, except 0.
• None corresponds to 0.

The English ruleset is used by default, for any language without a configured pluralization function.

To type the i18nInstance.i18n function, follow the steps:

Prepare a JSON keyset file so that the typing procedure can fetch data. Where you fetch keysets from, add creation of an additional data.json file. To decrease the file size and speed up IDE parsing, you can replace all values by 'str'.

// Example from the console

async function createFiles(keysets: Record<Lang, LangKeysets>) {
    await mkdirp(DEST_PATH);

    const createFilePromises = Object.keys(keysets).map((lang) => {
        const keysetsJSON = JSON.stringify(keysets[lang as Lang], null, 4);
        const content = umdTemplate(keysetsJSON);
        const hash = getContentHash(content);
        const filePath = path.resolve(DEST_PATH, `${lang}.${hash.slice(0, 8)}.js`);

        // <New lines>
        let typesPromise;

        if (lang === 'ru') {
            const keyset = keysets[lang as Lang];
            Object.keys(keyset).forEach((keysetName) => {
                const keyPhrases = keyset[keysetName];
                Object.keys(keyPhrases).forEach((keyName) => {
                    // mutate object!
                    keyPhrases[keyName] = 'str';
                });
            });

            const JSONForTypes = JSON.stringify(keyset, null, 4);
            typesPromise = writeFile(path.resolve(DEST_PATH, `data.json`), JSONForTypes, 'utf-8');
        }
        // </New lines>

        return Promise.all([typesPromise, writeFile(filePath, content, 'utf-8')]);
    });

    await Promise.all(createFilePromises);
}

In your ui/utils/i18n directories (where you configure i18n and export it to be used by all interfaces), import the typing function I18NFn with your Keysets. After your i18n has been configured, return the casted function

// Example from the console

import {I18NFn} from '@gravity-ui/i18n';
// This must be a typed import!
import type Keysets from '../../../dist/public/build/i18n/data.json';

const i18nInstance = new I18N();
type TypedI18n = I18NFn<typeof Keysets>;
// ...
export const ci18n = (i18nInstance.i18n as TypedI18n).bind(i18nInstance, 'common');
export const cui18n = (i18nInstance.i18n as TypedI18n).bind(i18nInstance, 'common.units');
export const i18n = i18nInstance.i18n.bind(i18nInstance) as TypedI18n;

Typing logic

There are several typing use cases:

• Calling a function with keys passed as string literals

i18n('common', 'label_subnet'); // ok
i18n('dcommon', 'label_dsubnet'); // error: Argument of type '"dcommon"' is not assignable to parameter of type ...
i18n('common', 'label_dsubnet'); // error: Argument of type '"label_dsubnet"' is not assignable to parameter of type ...

• Calling a function, passing to it strings that can't be converted into literals (if ts can't derive the string type, it doesn't throw an error)

const someUncomputebleString = `label_random-index-${Math.floor(Math.random() * 4)}`;
i18n('some_service', someUncomputebleString); // ok

for (let i = 0; i < 4; i++) {
    i18n('some_service', `label_random-index-${i}`); // ok
}

• Calling a function, passing to it strings that can be converted into literals

const labelColors = ['red', 'green', 'yelllow', 'white'] as const;
for (let i = 0; i < 4; i++) {
    i18n('some_service', `label_color-${labelColors[i]}`); // ok
}

const labelWrongColors = ['red', 'not-existing', 'yelllow', 'white'] as const;
for (let i = 0; i < 4; i++) {
    i18n('some_service', `label_color-${labelWrongColors[i]}`); // error: Argument of type '"not-existing"' is not assignable to parameter of type ...
}

Why typing via a class isn't supported

This function can break or complicate some i18n scenarios, so it was added as a functional extension. If it proves effective, we would probably add it to a class to avoid casting exported functions.

Why built-in methods might fail

Implementing of traversal of nested structures and conditional types using typed built-in function methods is a complex enough task. That's why typing works only when using a direct function call and a bind call up to the third argument.

Why can't I generate a ts file straightforwardly to typecast key values as well?

You can do that by passing the result type to I18NFn. However, with large file sizes, ts starts consuming huge amounts of resources, slowing down the IDE dramatically, but with JSON file this is not the case.

Why other methods of the I18N class haven't been typed?

They can be typed, we'll appreciate if you help implementing it. The case is that other methods are used in 1% of cases.