@24i/bigscreen-sdk 1.0.38 → 1.0.40-alpha.2687

package/packages/i18n/src/pluralsCommon/ResolverByLanguage.ts

@@ -1,129 +1,129 @@
-type Resolver<PluralFormResolver extends (n: number) => ReturnType<PluralFormResolver>> = {
-    resolver1: PluralFormResolver,
-    resolver2: PluralFormResolver,
-    resolver3: PluralFormResolver,
-    resolver4: PluralFormResolver,
-    resolver5: PluralFormResolver,
-    resolver6: PluralFormResolver,
-    resolver7: PluralFormResolver,
-    resolver8: PluralFormResolver,
-    resolver9: PluralFormResolver,
-    resolver10: PluralFormResolver,
-    resolver11: PluralFormResolver,
-    resolver12: PluralFormResolver,
-    resolver13: PluralFormResolver,
-    resolver14: PluralFormResolver,
-    resolver15: PluralFormResolver,
-    resolver16: PluralFormResolver,
-    resolver17: PluralFormResolver,
-    resolver18: PluralFormResolver,
-    resolver19: PluralFormResolver,
-    resolver20: PluralFormResolver,
-    resolver21: PluralFormResolver,
-    resolver22: PluralFormResolver,
-};
-
-export const resolverByLanguage = <
-    PluralFormResolver extends (n: number) => ReturnType<PluralFormResolver>,
->(resolvers: Resolver<PluralFormResolver>) => [
-    {
-        languages: [
-            'ach', 'ak', 'am', 'arn', 'br', 'fil', 'gun', 'ln', 'mfe', 'mg', 'mi', 'oc', 'pt',
-            'pt-BR', 'tg', 'ti', 'tr', 'uz', 'wa',
-        ],
-        pluralFormResolver: resolvers.resolver1,
-    },
-    {
-        languages: [
-            'af', 'an', 'ast', 'az', 'bg', 'bn', 'ca', 'da', 'de', 'dev', 'el', 'en', 'eo', 'es',
-            'et', 'eu', 'fi', 'fo', 'fur', 'fy', 'gl', 'gu', 'ha', 'hi', 'hu', 'hy', 'ia', 'it',
-            'kn', 'ku', 'lb', 'mai', 'ml', 'mn', 'mr', 'nah', 'nap', 'nb', 'ne', 'nl', 'nn', 'no',
-            'nso', 'or', 'pa', 'pap', 'pms', 'ps', 'pt-PT', 'rm', 'sco', 'se', 'si', 'so', 'son',
-            'sq', 'sv', 'sw', 'ta', 'te', 'tk', 'ur', 'yo',
-        ],
-        pluralFormResolver: resolvers.resolver2,
-    },
-    {
-        languages: [
-            'ay', 'bo', 'cgg', 'fa', 'ht', 'id', 'ja', 'jbo', 'ka', 'kk', 'km', 'ko', 'ky', 'lo',
-            'ms', 'sah', 'su', 'th', 'tt', 'ug', 'vi', 'wo', 'zh',
-        ],
-        pluralFormResolver: resolvers.resolver3,
-    },
-    {
-        languages: ['be', 'bs', 'cnr', 'dz', 'hr', 'ru', 'sr', 'uk'],
-        pluralFormResolver: resolvers.resolver4,
-    },
-    {
-        languages: ['ar'],
-        pluralFormResolver: resolvers.resolver5,
-    },
-    {
-        languages: ['cs', 'sk'],
-        pluralFormResolver: resolvers.resolver6,
-    },
-    {
-        languages: ['csb', 'pl'],
-        pluralFormResolver: resolvers.resolver7,
-    },
-    {
-        languages: ['cy'],
-        pluralFormResolver: resolvers.resolver8,
-    },
-    {
-        languages: ['fr'],
-        pluralFormResolver: resolvers.resolver9,
-    },
-    {
-        languages: ['ga'],
-        pluralFormResolver: resolvers.resolver10,
-    },
-    {
-        languages: ['gd'],
-        pluralFormResolver: resolvers.resolver11,
-    },
-    {
-        languages: ['is'],
-        pluralFormResolver: resolvers.resolver12,
-    },
-    {
-        languages: ['jv'],
-        pluralFormResolver: resolvers.resolver13,
-    },
-    {
-        languages: ['kw'],
-        pluralFormResolver: resolvers.resolver14,
-    },
-    {
-        languages: ['lt'],
-        pluralFormResolver: resolvers.resolver15,
-    },
-    {
-        languages: ['lv'],
-        pluralFormResolver: resolvers.resolver16,
-    },
-    {
-        languages: ['mk'],
-        pluralFormResolver: resolvers.resolver17,
-    },
-    {
-        languages: ['mnk'],
-        pluralFormResolver: resolvers.resolver18,
-    },
-    {
-        languages: ['mt'],
-        pluralFormResolver: resolvers.resolver19,
-    },
-    {
-        languages: ['ro'],
-        pluralFormResolver: resolvers.resolver20,
-    },
-    {
-        languages: ['sl'],
-        pluralFormResolver: resolvers.resolver21,
-    },
-    {
-        languages: ['he', 'iw'],
-        pluralFormResolver: resolvers.resolver22,
-    },
-];
+type Resolver<PluralFormResolver extends (n: number) => ReturnType<PluralFormResolver>> = {
+    resolver1: PluralFormResolver,
+    resolver2: PluralFormResolver,
+    resolver3: PluralFormResolver,
+    resolver4: PluralFormResolver,
+    resolver5: PluralFormResolver,
+    resolver6: PluralFormResolver,
+    resolver7: PluralFormResolver,
+    resolver8: PluralFormResolver,
+    resolver9: PluralFormResolver,
+    resolver10: PluralFormResolver,
+    resolver11: PluralFormResolver,
+    resolver12: PluralFormResolver,
+    resolver13: PluralFormResolver,
+    resolver14: PluralFormResolver,
+    resolver15: PluralFormResolver,
+    resolver16: PluralFormResolver,
+    resolver17: PluralFormResolver,
+    resolver18: PluralFormResolver,
+    resolver19: PluralFormResolver,
+    resolver20: PluralFormResolver,
+    resolver21: PluralFormResolver,
+    resolver22: PluralFormResolver,
+};
+
+export const resolverByLanguage = <
+    PluralFormResolver extends (n: number) => ReturnType<PluralFormResolver>,
+>(resolvers: Resolver<PluralFormResolver>) => [
+    {
+        languages: [
+            'ach', 'ak', 'am', 'arn', 'br', 'fil', 'gun', 'ln', 'mfe', 'mg', 'mi', 'oc', 'pt',
+            'pt-BR', 'tg', 'ti', 'tr', 'uz', 'wa',
+        ],
+        pluralFormResolver: resolvers.resolver1,
+    },
+    {
+        languages: [
+            'af', 'an', 'ast', 'az', 'bg', 'bn', 'ca', 'da', 'de', 'dev', 'el', 'en', 'eo', 'es',
+            'et', 'eu', 'fi', 'fo', 'fur', 'fy', 'gl', 'gu', 'ha', 'hi', 'hu', 'hy', 'ia', 'it',
+            'kn', 'ku', 'lb', 'mai', 'ml', 'mn', 'mr', 'nah', 'nap', 'nb', 'ne', 'nl', 'nn', 'no',
+            'nso', 'or', 'pa', 'pap', 'pms', 'ps', 'pt-PT', 'rm', 'sco', 'se', 'si', 'so', 'son',
+            'sq', 'sv', 'sw', 'ta', 'te', 'tk', 'ur', 'yo',
+        ],
+        pluralFormResolver: resolvers.resolver2,
+    },
+    {
+        languages: [
+            'ay', 'bo', 'cgg', 'fa', 'ht', 'id', 'ja', 'jbo', 'ka', 'kk', 'km', 'ko', 'ky', 'lo',
+            'ms', 'sah', 'su', 'th', 'tt', 'ug', 'vi', 'wo', 'zh',
+        ],
+        pluralFormResolver: resolvers.resolver3,
+    },
+    {
+        languages: ['be', 'bs', 'cnr', 'dz', 'hr', 'ru', 'sr', 'uk'],
+        pluralFormResolver: resolvers.resolver4,
+    },
+    {
+        languages: ['ar'],
+        pluralFormResolver: resolvers.resolver5,
+    },
+    {
+        languages: ['cs', 'sk'],
+        pluralFormResolver: resolvers.resolver6,
+    },
+    {
+        languages: ['csb', 'pl'],
+        pluralFormResolver: resolvers.resolver7,
+    },
+    {
+        languages: ['cy'],
+        pluralFormResolver: resolvers.resolver8,
+    },
+    {
+        languages: ['fr'],
+        pluralFormResolver: resolvers.resolver9,
+    },
+    {
+        languages: ['ga'],
+        pluralFormResolver: resolvers.resolver10,
+    },
+    {
+        languages: ['gd'],
+        pluralFormResolver: resolvers.resolver11,
+    },
+    {
+        languages: ['is'],
+        pluralFormResolver: resolvers.resolver12,
+    },
+    {
+        languages: ['jv'],
+        pluralFormResolver: resolvers.resolver13,
+    },
+    {
+        languages: ['kw'],
+        pluralFormResolver: resolvers.resolver14,
+    },
+    {
+        languages: ['lt'],
+        pluralFormResolver: resolvers.resolver15,
+    },
+    {
+        languages: ['lv'],
+        pluralFormResolver: resolvers.resolver16,
+    },
+    {
+        languages: ['mk'],
+        pluralFormResolver: resolvers.resolver17,
+    },
+    {
+        languages: ['mnk'],
+        pluralFormResolver: resolvers.resolver18,
+    },
+    {
+        languages: ['mt'],
+        pluralFormResolver: resolvers.resolver19,
+    },
+    {
+        languages: ['ro'],
+        pluralFormResolver: resolvers.resolver20,
+    },
+    {
+        languages: ['sl'],
+        pluralFormResolver: resolvers.resolver21,
+    },
+    {
+        languages: ['he', 'iw'],
+        pluralFormResolver: resolvers.resolver22,
+    },
+];

package/packages/i18n/src/t.tsx

@@ -1,6 +1,6 @@
-import { Translation } from './Translation';
-import { TranslationKey, TranslationOptions } from './types';
-
-export const t = (translationKey: TranslationKey, options: TranslationOptions | string = {}) => (
-    <Translation translationKey={translationKey} options={options} />
-);
+import { Translation } from './Translation';
+import { TranslationKey, TranslationOptions } from './types';
+
+export const t = (translationKey: TranslationKey, options: TranslationOptions | string = {}) => (
+    <Translation translationKey={translationKey} options={options} />
+);

package/packages/i18n/src/typedTranslate.ts

@@ -1,31 +1,31 @@
-import { i18n } from './I18n';
-import { t } from './t';
-import { TranslationOptions } from './types';
-
-export type TypedDictionary<T extends string, Dictionary = any> = (
-    T extends `${infer A}.${infer B}`
-        ? A extends keyof Dictionary
-            ? `${A}.${Extract<TypedDictionary<B, Dictionary[A]>, string>}`
-            : never
-        : T extends keyof Dictionary
-            ? Dictionary[T] extends string
-                ? T
-                : never
-            : never
-);
-
-export const getTypedI18nT = <Dictionary>(namespace = '') => (
-    <T extends string>(
-        key: TypedDictionary<T, Dictionary>, options?: string | TranslationOptions,
-    ) => (
-        i18n.t(namespace + key, options)
-    )
-);
-
-export const getTypedT = <Dictionary>(namespace = '') => (
-    <T extends string>(
-        key: TypedDictionary<T, Dictionary>, options?: string | TranslationOptions,
-    ) => t(namespace + key, options)
-);
-
-// Try at: https://tsplay.dev/Nd4VdN :-)
+import { i18n } from './I18n';
+import { t } from './t';
+import { TranslationOptions } from './types';
+
+export type TypedDictionary<T extends string, Dictionary = any> = (
+    T extends `${infer A}.${infer B}`
+        ? A extends keyof Dictionary
+            ? `${A}.${Extract<TypedDictionary<B, Dictionary[A]>, string>}`
+            : never
+        : T extends keyof Dictionary
+            ? Dictionary[T] extends string
+                ? T
+                : never
+            : never
+);
+
+export const getTypedI18nT = <Dictionary>(namespace = '') => (
+    <T extends string>(
+        key: TypedDictionary<T, Dictionary>, options?: string | TranslationOptions,
+    ) => (
+        i18n.t(namespace + key, options)
+    )
+);
+
+export const getTypedT = <Dictionary>(namespace = '') => (
+    <T extends string>(
+        key: TypedDictionary<T, Dictionary>, options?: string | TranslationOptions,
+    ) => t(namespace + key, options)
+);
+
+// Try at: https://tsplay.dev/Nd4VdN :-)

package/packages/i18n/src/types.ts

@@ -1,66 +1,66 @@
-// Do not use Record, it does not work recursively in TS
-export type Translation = string | {
-    [key: string]: Translation,
-};
-
-export type NamespaceResource = Record<string, Translation>;
-
-export type LanguageResource = Record<string, NamespaceResource>;
-
-export type Resources = Record<string, LanguageResource>;
-
-export type TranslationOptions = {
-    [key: string]: any,
-    lng?: string,
-    defaultValue?: string,
-    fallbackLng?: string,
-    ns?: string,
-    keySeparator?: string,
-    nsSeparator?: string,
-    middlewares?: MiddlewareSetup[],
-    interpolation?: InterpolationOptions,
-    context?: string,
-};
-
-export type PrivateOnlyTranslationOptions = {
-    language?: string,
-    useInterval?: boolean,
-    keyModifyingMiddlewares?: KeyModifyingMiddleware[],
-    valueModifyingMiddlewares?: ValueModifyingMiddleware[],
-};
-
-export type PrivateTranslationOptions = TranslationOptions & PrivateOnlyTranslationOptions;
-
-export type TranslationKey = string | string[];
-
-export interface Middleware {
-    priority: number,
-    name: string,
-    middleware: Function,
-}
-
-export interface KeyModifyingMiddleware extends Middleware {
-    middleware: (
-        key: string, namespace: NamespaceResource, options: PrivateTranslationOptions,
-    ) => string;
-}
-
-export interface ValueModifyingMiddleware extends Middleware {
-    middleware: (value: string, options: PrivateTranslationOptions,) => string;
-}
-
-export type Middlewares = {
-    keyModifying: KeyModifyingMiddleware[],
-    valueModifying: ValueModifyingMiddleware[],
-};
-
-export type MiddlewareSetup = () => Partial<Middlewares>;
-
-type FormatFunction = (value: any, format: string | undefined) => string;
-
-export type InterpolationOptions = {
-    format?: FormatFunction,
-    formatSeparator?: string,
-    prefix?: string,
-    suffix?: string,
-};
+// Do not use Record, it does not work recursively in TS
+export type Translation = string | {
+    [key: string]: Translation,
+};
+
+export type NamespaceResource = Record<string, Translation>;
+
+export type LanguageResource = Record<string, NamespaceResource>;
+
+export type Resources = Record<string, LanguageResource>;
+
+export type TranslationOptions = {
+    [key: string]: any,
+    lng?: string,
+    defaultValue?: string,
+    fallbackLng?: string,
+    ns?: string,
+    keySeparator?: string,
+    nsSeparator?: string,
+    middlewares?: MiddlewareSetup[],
+    interpolation?: InterpolationOptions,
+    context?: string,
+};
+
+export type PrivateOnlyTranslationOptions = {
+    language?: string,
+    useInterval?: boolean,
+    keyModifyingMiddlewares?: KeyModifyingMiddleware[],
+    valueModifyingMiddlewares?: ValueModifyingMiddleware[],
+};
+
+export type PrivateTranslationOptions = TranslationOptions & PrivateOnlyTranslationOptions;
+
+export type TranslationKey = string | string[];
+
+export interface Middleware {
+    priority: number,
+    name: string,
+    middleware: Function,
+}
+
+export interface KeyModifyingMiddleware extends Middleware {
+    middleware: (
+        key: string, namespace: NamespaceResource, options: PrivateTranslationOptions,
+    ) => string;
+}
+
+export interface ValueModifyingMiddleware extends Middleware {
+    middleware: (value: string, options: PrivateTranslationOptions,) => string;
+}
+
+export type Middlewares = {
+    keyModifying: KeyModifyingMiddleware[],
+    valueModifying: ValueModifyingMiddleware[],
+};
+
+export type MiddlewareSetup = () => Partial<Middlewares>;
+
+type FormatFunction = (value: any, format: string | undefined) => string;
+
+export type InterpolationOptions = {
+    format?: FormatFunction,
+    formatSeparator?: string,
+    prefix?: string,
+    suffix?: string,
+};

package/packages/i18n/src/utils.ts

@@ -1,76 +1,76 @@
-import { forEach, map } from '@24i/bigscreen-sdk/perf-utils/array';
-import {
-    KeyModifyingMiddleware,
-    Middleware,
-    MiddlewareSetup,
-    PrivateOnlyTranslationOptions,
-    PrivateTranslationOptions,
-    TranslationOptions,
-    ValueModifyingMiddleware,
-} from './types';
-
-const PRIVATE_OPTION_KEYS: (keyof PrivateOnlyTranslationOptions)[] = [
-    'language', 'useInterval', 'keyModifyingMiddlewares', 'valueModifyingMiddlewares',
-];
-
-export const publicOptionsOnly = (
-    privateOptions: PrivateTranslationOptions,
-): TranslationOptions => {
-    const publicOptions: TranslationOptions = {};
-    forEach(Object.keys(privateOptions), (optionName) => {
-        // @ts-ignore - Searching any string should be possible in array of strings
-        if (PRIVATE_OPTION_KEYS.indexOf(optionName) !== -1) return;
-        publicOptions[optionName] = privateOptions[optionName];
-    });
-    return publicOptions;
-};
-
-const containMiddleware = (middlewares: Middleware[], middleware: Middleware): boolean => {
-    const names = map(middlewares, ({ name }) => name);
-    return names.indexOf(middleware.name) !== -1;
-};
-
-export const addMiddlewaresByPriority = (
-    newMiddlewares: Middleware[], existingMiddlewares: Middleware[],
-) => {
-    forEach(newMiddlewares, (newMiddleware) => {
-        if (containMiddleware(existingMiddlewares, newMiddleware)) return;
-        const { priority } = newMiddleware;
-        const middlewaresLength = existingMiddlewares.length;
-        for (let i = 0; i < middlewaresLength; i++) {
-            if (existingMiddlewares[i].priority > priority) {
-                existingMiddlewares.splice(i, 0, newMiddleware);
-                return;
-            }
-        }
-        existingMiddlewares.push(newMiddleware);
-    });
-};
-
-export const setupMiddlewares = (
-    newMiddlewares: MiddlewareSetup[] = [],
-    keyModifyingMiddlewares: KeyModifyingMiddleware[],
-    valueModifyingMiddlewares: ValueModifyingMiddleware[],
-) => {
-    forEach(newMiddlewares, (middleware) => {
-        const { keyModifying, valueModifying } = middleware();
-        if (keyModifying) {
-            addMiddlewaresByPriority(keyModifying, keyModifyingMiddlewares);
-        }
-        if (valueModifying) {
-            addMiddlewaresByPriority(valueModifying, valueModifyingMiddlewares);
-        }
-    });
-};
-
-export const mergeMiddlewares = <T extends Middleware>(
-    middlewaresA: T[] = [],
-    middlewaresB: T[] = [],
-): T[] => {
-    if (middlewaresA.length === 0) return middlewaresB;
-    if (middlewaresB.length === 0) return middlewaresA;
-    const mergedMiddlewares: T[] = [];
-    addMiddlewaresByPriority(middlewaresA, mergedMiddlewares);
-    addMiddlewaresByPriority(middlewaresB, mergedMiddlewares);
-    return mergedMiddlewares;
-};
+import { forEach, map } from '@24i/bigscreen-sdk/perf-utils/array';
+import {
+    KeyModifyingMiddleware,
+    Middleware,
+    MiddlewareSetup,
+    PrivateOnlyTranslationOptions,
+    PrivateTranslationOptions,
+    TranslationOptions,
+    ValueModifyingMiddleware,
+} from './types';
+
+const PRIVATE_OPTION_KEYS: (keyof PrivateOnlyTranslationOptions)[] = [
+    'language', 'useInterval', 'keyModifyingMiddlewares', 'valueModifyingMiddlewares',
+];
+
+export const publicOptionsOnly = (
+    privateOptions: PrivateTranslationOptions,
+): TranslationOptions => {
+    const publicOptions: TranslationOptions = {};
+    forEach(Object.keys(privateOptions), (optionName) => {
+        // @ts-ignore - Searching any string should be possible in array of strings
+        if (PRIVATE_OPTION_KEYS.indexOf(optionName) !== -1) return;
+        publicOptions[optionName] = privateOptions[optionName];
+    });
+    return publicOptions;
+};
+
+const containMiddleware = (middlewares: Middleware[], middleware: Middleware): boolean => {
+    const names = map(middlewares, ({ name }) => name);
+    return names.indexOf(middleware.name) !== -1;
+};
+
+export const addMiddlewaresByPriority = (
+    newMiddlewares: Middleware[], existingMiddlewares: Middleware[],
+) => {
+    forEach(newMiddlewares, (newMiddleware) => {
+        if (containMiddleware(existingMiddlewares, newMiddleware)) return;
+        const { priority } = newMiddleware;
+        const middlewaresLength = existingMiddlewares.length;
+        for (let i = 0; i < middlewaresLength; i++) {
+            if (existingMiddlewares[i].priority > priority) {
+                existingMiddlewares.splice(i, 0, newMiddleware);
+                return;
+            }
+        }
+        existingMiddlewares.push(newMiddleware);
+    });
+};
+
+export const setupMiddlewares = (
+    newMiddlewares: MiddlewareSetup[] = [],
+    keyModifyingMiddlewares: KeyModifyingMiddleware[],
+    valueModifyingMiddlewares: ValueModifyingMiddleware[],
+) => {
+    forEach(newMiddlewares, (middleware) => {
+        const { keyModifying, valueModifying } = middleware();
+        if (keyModifying) {
+            addMiddlewaresByPriority(keyModifying, keyModifyingMiddlewares);
+        }
+        if (valueModifying) {
+            addMiddlewaresByPriority(valueModifying, valueModifyingMiddlewares);
+        }
+    });
+};
+
+export const mergeMiddlewares = <T extends Middleware>(
+    middlewaresA: T[] = [],
+    middlewaresB: T[] = [],
+): T[] => {
+    if (middlewaresA.length === 0) return middlewaresB;
+    if (middlewaresB.length === 0) return middlewaresA;
+    const mergedMiddlewares: T[] = [];
+    addMiddlewaresByPriority(middlewaresA, mergedMiddlewares);
+    addMiddlewaresByPriority(middlewaresB, mergedMiddlewares);
+    return mergedMiddlewares;
+};