@24i/bigscreen-sdk 0.9.9-alpha.2147

package/packages/i18n/src/I18n.ts

@@ -0,0 +1,246 @@
+import { forEach } from '@24i/bigscreen-sdk/perf-utils/array';
+import { EventsManager } from '@24i/bigscreen-sdk/events-manager';
+import { mergeMiddlewares, setupMiddlewares } from './utils';
+import { getDirection } from './direction';
+import {
+    Resources,
+    TranslationKey,
+    TranslationOptions,
+    Middlewares,
+    NamespaceResource,
+    MiddlewareSetup,
+    PrivateTranslationOptions,
+    KeyModifyingMiddleware,
+    ValueModifyingMiddleware,
+} from './types';
+
+const DEFAULT_NS = 'translation';
+const DEFAULT_NS_SEPARATOR = ':';
+const DEFAULT_KEY_SEPARATOR = '.';
+const FALLBACK_LNG = 'en';
+
+type Options = {
+    resources?: Resources,
+    lng: string,
+    fallbackLng?: string,
+    defaultNS?: string,
+    keySeparator?: string,
+    nsSeparator?: string,
+};
+
+type Events = {
+    'languagechange': () => void,
+};
+
+class I18n {
+    private readonly events = new EventsManager<Events>();
+
+    addEventListener = this.events.addEventListener;
+
+    removeEventListener = this.events.removeEventListener;
+
+    private resources: Resources = {};
+
+    private lng = '';
+
+    private fallbackLng: string = FALLBACK_LNG;
+
+    private defaultNS: string = DEFAULT_NS;
+
+    private keySeparator: string = DEFAULT_KEY_SEPARATOR;
+
+    private nsSeparator: string = DEFAULT_NS_SEPARATOR;
+
+    private readonly middlewares: Middlewares = {
+        keyModifying: [],
+        valueModifying: [],
+    };
+
+    init({
+        resources = {},
+        lng,
+        fallbackLng = FALLBACK_LNG,
+        defaultNS = DEFAULT_NS,
+        keySeparator = DEFAULT_KEY_SEPARATOR,
+        nsSeparator = DEFAULT_NS_SEPARATOR,
+    }: Options) {
+        this.resources = resources;
+        this.lng = lng;
+        this.fallbackLng = fallbackLng;
+        this.defaultNS = defaultNS;
+        this.keySeparator = keySeparator;
+        this.nsSeparator = nsSeparator;
+        this.setDocumentDir();
+    }
+
+    t(translationKey: TranslationKey, passedOptions: TranslationOptions | string = {}): string {
+        const options: TranslationOptions = typeof passedOptions === 'string'
+            ? { defaultValue: passedOptions }
+            : passedOptions;
+        if (typeof translationKey === 'string') {
+            return (
+                this.translateSingleKey(translationKey, options)
+                || this.runValueModifyingMiddlewares(options.defaultValue, options)
+                || translationKey
+            );
+        }
+        const translationKeysLength = translationKey.length;
+        for (let i = 0; i < translationKeysLength; i++) {
+            const translation = this.translateSingleKey(translationKey[i], options);
+            if (translation) return translation;
+        }
+        return (
+            this.runValueModifyingMiddlewares(options.defaultValue, options)
+            || translationKey[translationKeysLength - 1]
+        );
+    }
+
+    middleware(...middlewares: MiddlewareSetup[]) {
+        setupMiddlewares(
+            middlewares,
+            this.middlewares.keyModifying,
+            this.middlewares.valueModifying,
+        );
+    }
+
+    getLanguage(): string {
+        return this.lng;
+    }
+
+    getLanguages(): string[] {
+        return Object.keys(this.resources);
+    }
+
+    setLanguage(lng: string) {
+        this.lng = lng;
+        this.setDocumentDir();
+        this.events.triggerEvent('languagechange');
+    }
+
+    getResources() {
+        return this.resources;
+    }
+
+    setResources(resources: Resources) {
+        this.resources = resources;
+    }
+
+    dir(language: string = this.lng) {
+        return getDirection(language);
+    }
+
+    setDocumentDir() {
+        document.dir = this.dir();
+    }
+
+    private translateSingleKey(translationKey: string, options: TranslationOptions) {
+        const privateOptions: PrivateTranslationOptions = { ...options };
+        const { ns, pathWithKey } = this.getNSAndPath(translationKey, privateOptions);
+        const { resources, language } = this.getResourcesAndUsedLanguage(privateOptions);
+        privateOptions.language = language;
+        this.prepareMergedMiddlewares(privateOptions);
+        if (!resources) return undefined;
+        const namespace = resources[ns];
+        if (!namespace) return undefined;
+        const translation = this.getTranslationFromNamespace(
+            namespace, pathWithKey, privateOptions,
+        );
+        if (!translation) return undefined;
+        return this.runValueModifyingMiddlewares(translation, privateOptions);
+    }
+
+    private getResourcesAndUsedLanguage(options: PrivateTranslationOptions) {
+        const primaryLanguage = options.lng || this.lng;
+        const primaryResources = this.resources[primaryLanguage];
+        if (primaryResources) {
+            return {
+                resources: primaryResources,
+                language: primaryLanguage,
+            };
+        }
+        const fallbackLanguage = options.fallbackLng || this.fallbackLng;
+        return {
+            resources: this.resources[fallbackLanguage],
+            language: fallbackLanguage,
+        };
+    }
+
+    private getNSAndPath(translationKey: string, options: PrivateTranslationOptions) {
+        const parts = translationKey.split(options.nsSeparator || this.nsSeparator);
+        const isNSInTranslationKey = parts.length === 2;
+        const ns = isNSInTranslationKey ? parts[0] : options.ns || this.defaultNS;
+        const pathWithKey = isNSInTranslationKey ? parts[1] : parts[0];
+        return { ns, pathWithKey };
+    }
+
+    private getTranslationFromNamespace(
+        namespace: NamespaceResource,
+        pathWithKey: string,
+        options: PrivateTranslationOptions,
+    ) {
+        const { key, pathParts } = this.getPathPartsAndKey(pathWithKey, options);
+        let currentNamespace: any = namespace;
+        const pathPartsLength = pathParts.length;
+        for (let i = 0; i < pathPartsLength; i++) {
+            currentNamespace = currentNamespace[pathParts[i]];
+            if (!currentNamespace) return undefined;
+        }
+        const finalKey = this.runKeyModifyingMiddlewares(key, currentNamespace, options);
+        return currentNamespace[finalKey];
+    }
+
+    private getPathPartsAndKey(pathWithKey: string, { keySeparator }: PrivateTranslationOptions) {
+        const pathParts = pathWithKey.split(keySeparator || this.keySeparator);
+        const [key] = pathParts.splice(pathParts.length - 1, 1);
+        return { key, pathParts };
+    }
+
+    private prepareMergedMiddlewares(privateOptions: PrivateTranslationOptions) {
+        const translationKeyModifyingMiddlewares: KeyModifyingMiddleware[] = [];
+        const translationValueModifyingMiddlewares: ValueModifyingMiddleware[] = [];
+        const { middlewares } = privateOptions;
+        setupMiddlewares(
+            middlewares,
+            translationKeyModifyingMiddlewares,
+            translationValueModifyingMiddlewares,
+        );
+        privateOptions.keyModifyingMiddlewares = mergeMiddlewares(
+            translationKeyModifyingMiddlewares,
+            this.middlewares.keyModifying,
+        );
+        privateOptions.valueModifyingMiddlewares = mergeMiddlewares(
+            translationValueModifyingMiddlewares,
+            this.middlewares.valueModifying,
+        );
+    }
+
+    private runKeyModifyingMiddlewares(
+        key: string,
+        namespace: NamespaceResource,
+        options: PrivateTranslationOptions,
+    ) {
+        let currentKey = key;
+        const { keyModifyingMiddlewares = [] } = options;
+        const middlewares = keyModifyingMiddlewares;
+        forEach(middlewares, ({ middleware }) => {
+            currentKey = middleware(currentKey, namespace, options);
+        });
+        return currentKey;
+    }
+
+    private runValueModifyingMiddlewares(
+        value: string | undefined,
+        options: PrivateTranslationOptions,
+    ) {
+        if (typeof value === 'undefined') return undefined;
+        let currentValue = value;
+        const { valueModifyingMiddlewares = [] } = options;
+        const middlewares = valueModifyingMiddlewares;
+        forEach(middlewares, ({ middleware }) => {
+            currentValue = middleware(currentValue, options);
+        });
+        return currentValue;
+    }
+}
+
+export const i18n = new I18n();

package/packages/i18n/src/Translation.tsx

@@ -0,0 +1,36 @@
+import { Component, createRef, TextNode } from '@24i/bigscreen-sdk/jsx';
+import { i18n } from './I18n';
+import { TranslationKey, TranslationOptions } from './types';
+
+type Props = {
+    translationKey: TranslationKey,
+    options?: TranslationOptions | string,
+};
+
+export class Translation extends Component<Props> {
+    textNode = createRef<Text>();
+
+    static defaultProps = {
+        options: {},
+    };
+
+    componentDidMount() {
+        i18n.addEventListener('languagechange', this.onLanguageChange);
+    }
+
+    componentWillUnmount() {
+        i18n.removeEventListener('languagechange', this.onLanguageChange);
+    }
+
+    onLanguageChange = () => {
+        const { translationKey, options } = this.props;
+        if (!this.textNode.current) return;
+        this.textNode.current.nodeValue = i18n.t(translationKey, options);
+    };
+
+    // @ts-ignore - Special case for BIGscreen JSX incompatible with types/react
+    render() {
+        const { translationKey, options } = this.props;
+        return <TextNode ref={this.textNode}>{i18n.t(translationKey, options)}</TextNode>;
+    }
+}

package/packages/i18n/src/addResourceBundle.ts

@@ -0,0 +1,73 @@
+import { forEach } from '@24i/bigscreen-sdk/perf-utils/array';
+import { i18n } from './I18n';
+import { NamespaceResource, Resources } from './types';
+
+const DEFAULT_DEEP = false;
+const DEFAULT_OVERWRITE = false;
+
+const addNewLanguage = (
+    resource: Resources,
+    language: string,
+    namespace: string,
+    newResource: NamespaceResource,
+) => {
+    resource[language] = {
+        [namespace]: newResource,
+    };
+};
+
+const addNewNamespace = (
+    resource: Resources,
+    language: string,
+    namespace: string,
+    newResource: NamespaceResource,
+) => {
+    resource[language][namespace] = newResource;
+};
+
+const mergeNamespace = (
+    nsResource: NamespaceResource,
+    newResource: NamespaceResource,
+    overwrite: boolean = DEFAULT_OVERWRITE,
+) => {
+    forEach(Object.keys(newResource), (key) => {
+        if (typeof nsResource[key] === 'undefined') {
+            nsResource[key] = newResource[key];
+        } else if (typeof nsResource[key] === 'string') {
+            if (!overwrite) return;
+            nsResource[key] = newResource[key];
+        } else if (typeof newResource[key] === 'string' && overwrite) { // nsResource[key] is object
+            nsResource[key] = newResource[key];
+        } else { // newResource[key] is also an object
+            mergeNamespace(
+                nsResource[key] as NamespaceResource,
+                newResource[key] as NamespaceResource,
+                overwrite,
+            );
+        }
+    });
+};
+
+export const addResourceBundle = (
+    language: string,
+    namespace: string,
+    resource: NamespaceResource,
+    deep: boolean = DEFAULT_DEEP,
+    overwrite: boolean = DEFAULT_OVERWRITE,
+) => {
+    const currentResources = i18n.getResources();
+    const shouldAddNewLanguage = !currentResources[language];
+    if (shouldAddNewLanguage) {
+        addNewLanguage(currentResources, language, namespace, resource);
+        return;
+    }
+    const shouldAddNewNamespace = (
+        (currentResources[language] && !currentResources[language][namespace])
+        || !deep
+    );
+    if (shouldAddNewNamespace) {
+        addNewNamespace(currentResources, language, namespace, resource);
+        return;
+    }
+    mergeNamespace(currentResources[language][namespace], resource, overwrite);
+};

package/packages/i18n/src/direction.ts

@@ -0,0 +1,33 @@
+import { includes } from '@24i/bigscreen-sdk/perf-utils/array';
+
+/**
+ * Codes of all RTL languages in ISO_639-1 format (ISO_639-2 for those not defined in -1)
+ */
+const RTL_LANGUAGES = [
+    'ar', 'shu', 'sqr', 'ssh', 'xaa', 'yhd', 'yud', 'aao', 'abh',
+    'abv', 'acm', 'acq', 'acw', 'acx', 'acy', 'adf', 'ads', 'aeb',
+    'aec', 'afb', 'ajp', 'apc', 'apd', 'arb', 'arq', 'ars', 'ary',
+    'arz', 'auz', 'avl', 'ayh', 'ayl', 'ayn', 'ayp', 'bbz', 'pga',
+    'he', 'iw', 'ps', 'pbt', 'pbu', 'pst', 'prp', 'prd', 'ug', 'ur',
+    'ydd', 'yds', 'yih', 'ji', 'yi', 'hbo', 'men', 'xmn', 'fa', 'jpr',
+    'peo', 'pes', 'prs', 'dv', 'sam',
+];
+
+type Direction = 'ltr' | 'rtl';
+
+const cache: Record<string, Direction> = {};
+
+/**
+ * Returns text direction for a language
+ * @param languageAndRegion ISO_639-1 code of language (can be with -region) or ISO_639-2 for
+ * languages not defined in ISO_639-1
+ */
+export const getDirection = (languageAndRegion: string): Direction => {
+    const [language] = languageAndRegion.split('-');
+    if (!cache[language]) {
+        cache[language] = includes(RTL_LANGUAGES, language)
+            ? 'rtl'
+            : 'ltr';
+    }
+    return cache[language];
+};

package/packages/i18n/src/index.ts

@@ -0,0 +1,4 @@
+export { t } from './t';
+export { i18n } from './I18n';
+export { isRtl } from './isRtl';
+export { getTypedT, getTypedI18nT } from './typedTranslate';

package/packages/i18n/src/isRtl.ts

@@ -0,0 +1,3 @@
+import { i18n } from './I18n';
+
+export const isRtl = () => i18n.dir() === 'rtl';

package/packages/i18n/src/middlewares/i18next/Context/Context.ts

@@ -0,0 +1,25 @@
+import {
+    KeyModifyingMiddleware,
+    MiddlewareSetup,
+    PrivateTranslationOptions,
+    Translation,
+} from '../../../types';
+
+const lookForContext: KeyModifyingMiddleware['middleware'] = (
+    key: string, namespace: Record<string, Translation>, { context }: PrivateTranslationOptions,
+) => {
+    if (typeof context !== 'string') return key;
+    const contextedKey = `${key}_${context}`;
+    if (typeof namespace[contextedKey] === 'string') return contextedKey;
+    return key;
+};
+
+export const Context: MiddlewareSetup = () => ({
+    keyModifying: [
+        {
+            priority: 1,
+            name: 'context-key-modifier',
+            middleware: lookForContext,
+        },
+    ],
+});

package/packages/i18n/src/middlewares/i18next/Context/index.ts

@@ -0,0 +1 @@
+export { Context } from './Context';

package/packages/i18n/src/middlewares/i18next/Interpolation/Interpolation.ts

@@ -0,0 +1,95 @@
+import { forEach, map } from '@24i/bigscreen-sdk/perf-utils/array';
+import {
+    InterpolationOptions,
+    MiddlewareSetup,
+    TranslationOptions,
+    ValueModifyingMiddleware,
+} from '../../../types';
+
+const DEFAULT_SEPARATOR = ',';
+const DEFAULT_PREFIX = '{{';
+const DEFAULT_SUFFIX = '}}';
+const KEY_SEPARATOR = '.';
+
+const getValueFromObject = (keyName: string, options: Record<string, any>) => {
+    const keyParts = keyName.split(KEY_SEPARATOR);
+    const keyPartsLength = keyParts.length;
+    let part = options;
+    for (let i = 0; i < keyPartsLength; i++) {
+        part = part[keyParts[i]];
+        if (typeof part === 'undefined' || part === null) return undefined;
+    }
+    return part as unknown as string;
+};
+
+const getKeyNameAndValueFormat = (
+    keyNameAndFormat: string,
+    { format, formatSeparator = DEFAULT_SEPARATOR }: InterpolationOptions = {},
+) => {
+    if (typeof format === 'undefined') {
+        return {
+            keyName: keyNameAndFormat,
+            valueFormat: undefined,
+        };
+    }
+    const [keyName, valueFormat] = map(
+        keyNameAndFormat.split(formatSeparator),
+        (s: string) => s.trim(),
+    );
+    return { keyName, valueFormat };
+};
+
+const interpolateMatch = (
+    interpolatedValue: string,
+    keyNameAndFormat: string,
+    match: string,
+    options: TranslationOptions,
+): string => {
+    const { interpolation = {} } = options;
+    const {
+        keyName,
+        valueFormat,
+    } = getKeyNameAndValueFormat(keyNameAndFormat, interpolation);
+    const value = keyName.indexOf(KEY_SEPARATOR) === -1
+        ? options[keyName]
+        : getValueFromObject(keyName, options);
+    if (typeof value === 'undefined') return interpolatedValue;
+    const { format } = interpolation;
+    return (
+        typeof format === 'function'
+            ? interpolatedValue.replace(match, format(value, valueFormat))
+            : interpolatedValue.replace(match, value)
+    );
+};
+
+const interpolate: ValueModifyingMiddleware['middleware'] = (
+    value: string, options: TranslationOptions,
+): string => {
+    const { interpolation = {} } = options;
+    const {
+        prefix = DEFAULT_PREFIX,
+        suffix = DEFAULT_SUFFIX,
+        formatSeparator = DEFAULT_SEPARATOR,
+    } = interpolation;
+    const regex = new RegExp(`${prefix}[\\w\\.\\-${formatSeparator}\\s]+${suffix}`, 'g');
+    const matches = value.match(regex);
+    if (!matches) return value;
+    const prefixRegExp = new RegExp(`^${prefix}`);
+    const suffixRegExp = new RegExp(`${suffix}$`);
+    let interpolatedValue = value;
+    forEach(matches, (match) => {
+        const keyName = match.replace(prefixRegExp, '').replace(suffixRegExp, '');
+        interpolatedValue = interpolateMatch(interpolatedValue, keyName, match, options);
+    });
+    return interpolatedValue;
+};
+
+export const Interpolation: MiddlewareSetup = () => ({
+    valueModifying: [
+        {
+            priority: 4,
+            name: 'interpolation-name-modifier',
+            middleware: interpolate,
+        },
+    ],
+});

package/packages/i18n/src/middlewares/i18next/Interpolation/index.ts

@@ -0,0 +1 @@
+export { Interpolation } from './Interpolation';

package/packages/i18n/src/middlewares/i18next/Nesting/Nesting.ts

@@ -0,0 +1,38 @@
+import { forEach } from '@24i/bigscreen-sdk/perf-utils/array';
+import { i18n } from '../../../I18n';
+import { publicOptionsOnly } from '../../../utils';
+import {
+    MiddlewareSetup,
+    PrivateTranslationOptions,
+    ValueModifyingMiddleware,
+} from '../../../types';
+
+/**
+ * Matches $t(any word character . or :)
+ */
+// eslint-disable-next-line no-useless-escape
+const NESTED_REGEX = /\$t\([\w\.:]+\)/g;
+
+const findNested: ValueModifyingMiddleware['middleware'] = (
+    value: string, options: PrivateTranslationOptions,
+): string => {
+    const matches = value.match(NESTED_REGEX);
+    if (!matches) return value;
+    let modifiedValue = value;
+    forEach(matches, (match) => {
+        const key = match.replace(/^\$t\(/, '').replace(/\)$/, '');
+        const translation = i18n.t(key, publicOptionsOnly(options));
+        modifiedValue = modifiedValue.replace(match, translation);
+    });
+    return modifiedValue;
+};
+
+export const Nesting: MiddlewareSetup = () => ({
+    valueModifying: [
+        {
+            priority: 2,
+            name: 'nesting-value-modifier',
+            middleware: findNested,
+        },
+    ],
+});

package/packages/i18n/src/middlewares/i18next/Nesting/index.ts

@@ -0,0 +1 @@
+export { Nesting } from './Nesting';

package/packages/i18n/src/middlewares/i18next/Plurals/Plurals.ts

@@ -0,0 +1,123 @@
+import { forEach } from '@24i/bigscreen-sdk/perf-utils/array';
+import * as resolvers from './Resolvers';
+import { PluralsHelper } from '../../../pluralsCommon/PluralsHelper';
+import { resolverByLanguage } from '../../../pluralsCommon/ResolverByLanguage';
+import type { PluralFormResolver } from './types';
+import type {
+    KeyModifyingMiddleware,
+    MiddlewareSetup,
+    PrivateTranslationOptions,
+    Translation,
+    ValueModifyingMiddleware,
+} from '../../../types';
+
+const RESOLVER_BY_LANGUAGE = resolverByLanguage<PluralFormResolver>(resolvers);
+const plurals = new PluralsHelper<PluralFormResolver>(RESOLVER_BY_LANGUAGE);
+
+const keyExists = (key: string, namespace: Record<string, Translation>) => (
+    typeof namespace[key] !== 'undefined'
+);
+
+const getIntervalKey = (key: string) => `${key}_interval`;
+const getPluralFormKey = (key: string, form: number) => `${key}_${form}`;
+const getPluralKey = (key: string) => `${key}_plural`;
+
+/* eslint-disable no-useless-escape */
+/**
+ * Matches {anything} or {anything{{anything}}anything}
+ */
+const INTERVAL_VALUE_REGEX = /\{((.*?{{.+?(?=}})\}\}.*)|(.+?(?=})))\}/g;
+/**
+ * Matches (number) or (number-number) or (number-inf)
+ * and {anything} or {anything{{anything}}anything}
+ * and ;
+ */
+const INTERVAL_REGEX = /\((\d+|(\d+\-(\d+|inf)))\)\{((.+?(?=}))|(.*?{{.+?(?=}})\}\}.*))\};/g;
+/**
+ * Matches (number) or (number-number) or (number-inf)
+ */
+const NUMBERS_IN_INTERVAL_REGEX = /\((\d+|(\d+\-(\d+|inf)))\)/g;
+/* eslint-disable no-useless-escape */
+
+const isCountInInterval = (count: number, interval: string) => {
+    const numbers = interval.match(NUMBERS_IN_INTERVAL_REGEX)![0]
+        .replace(/^\(/, '').replace(/\)$/, '').split('-');
+    if (numbers.length === 1 && parseInt(numbers[0], 10) === count) return true;
+    const from = parseInt(numbers[0], 10);
+    const to = numbers[1] === 'inf' ? Infinity : parseInt(numbers[1], 10);
+    if (count >= from && count <= to) return true;
+    return false;
+};
+
+const shouldUseInterval = (
+    intervalKey: string,
+    namespace: Record<string, Translation>,
+    count: number,
+) => {
+    if (!keyExists(intervalKey, namespace)) return false;
+    const value = namespace[intervalKey];
+    if (typeof value !== 'string') return false;
+    const matches = value.match(INTERVAL_REGEX);
+    if (!matches) return false;
+    const matchesLength = matches.length;
+    for (let i = 0; i < matchesLength; i++) {
+        if (isCountInInterval(count, matches[i])) return true;
+    }
+    return false;
+};
+
+const pluralsKeyModifier: KeyModifyingMiddleware['middleware'] = (
+    key: string,
+    namespace: Record<string, Translation>,
+    options: PrivateTranslationOptions,
+): string => {
+    const { count } = options;
+    if (typeof count !== 'number') return key;
+    const intervalKey = getIntervalKey(key);
+    if (shouldUseInterval(intervalKey, namespace, count)) {
+        options.useInterval = true;
+        return intervalKey;
+    }
+    const form = plurals.resolveForm(count);
+    const exactKey = getPluralFormKey(key, form);
+    if (keyExists(exactKey, namespace)) return exactKey;
+    const vagueKey = count === 1 ? key : getPluralKey(key);
+    if (keyExists(vagueKey, namespace)) return vagueKey;
+    return key;
+};
+
+const pluralsValueModifier: ValueModifyingMiddleware['middleware'] = (
+    value: string, { count, useInterval }: PrivateTranslationOptions,
+) => {
+    if (!useInterval) return value;
+    const intervalMatches = value.match(INTERVAL_REGEX);
+    if (!intervalMatches) return value;
+    let modifiedValue = value;
+    forEach(intervalMatches, (interval) => {
+        if (isCountInInterval(count, interval)) {
+            const intervalValue = interval.match(INTERVAL_VALUE_REGEX)![0]
+                .replace(/^\{/, '').replace(/\}$/, '');
+            modifiedValue = modifiedValue.replace(interval, intervalValue);
+        } else {
+            modifiedValue = modifiedValue.replace(interval, '');
+        }
+    });
+    return modifiedValue;
+};
+
+export const Plurals: MiddlewareSetup = () => ({
+    keyModifying: [
+        {
+            priority: 3,
+            name: 'plurals-key-modifier',
+            middleware: pluralsKeyModifier,
+        },
+    ],
+    valueModifying: [
+        {
+            priority: 3,
+            name: 'plurals-value-modifier',
+            middleware: pluralsValueModifier,
+        },
+    ],
+});