@wise/dynamic-flow-client 5.25.2-experimental-a8a898e → 5.25.2

package/build/domain/mappers/utils/FeatureFlags.js

@@ -0,0 +1,22 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _FeatureFlags_features;
+export class FeatureFlags {
+    constructor(features) {
+        _FeatureFlags_features.set(this, void 0);
+        __classPrivateFieldSet(this, _FeatureFlags_features, features, "f");
+    }
+    isEnabled(featureName) {
+        return __classPrivateFieldGet(this, _FeatureFlags_features, "f")[featureName] != null && __classPrivateFieldGet(this, _FeatureFlags_features, "f")[featureName] !== false;
+    }
+}
+_FeatureFlags_features = new WeakMap();

package/build/domain/mappers/utils/behavior-utils.js

@@ -0,0 +1,58 @@
+import { safeParseLink } from '../../../utils/safe-parse-link';
+export const getDomainLayerBehavior = ({ action, behavior: specBehavior }, stepActions, registerSubmissionBehavior) => {
+    if (specBehavior) {
+        const behavior = normaliseBehavior(specBehavior, stepActions);
+        registerSubmissionBehavior === null || registerSubmissionBehavior === void 0 ? void 0 : registerSubmissionBehavior(behavior);
+        return behavior;
+    }
+    if (action) {
+        const behavior = actionToBehavior(action, stepActions);
+        registerSubmissionBehavior === null || registerSubmissionBehavior === void 0 ? void 0 : registerSubmissionBehavior(behavior);
+        return behavior;
+    }
+    return { type: 'none', track: false };
+};
+export const normaliseBehavior = (behavior, stepActions) => {
+    // New "discriminated union" behavior type
+    if ('type' in behavior) {
+        if (behavior.type === 'subflow') {
+            return Object.assign(Object.assign({}, behavior), { track: true, onCompletion: behavior.onCompletion
+                    ? normaliseBehavior(behavior.onCompletion, stepActions)
+                    : undefined, onError: behavior.onError ? normaliseBehavior(behavior.onError, stepActions) : undefined });
+        }
+        if (behavior.type === 'delay') {
+            return Object.assign(Object.assign({}, behavior), { behavior: normaliseBehavior(behavior.behavior, stepActions), track: true });
+        }
+        if (behavior.type === 'dispatch-event') {
+            return {
+                type: 'none',
+                track: false,
+            };
+        }
+        if (behavior.type === 'link') {
+            return Object.assign(Object.assign({}, behavior), { type: 'link', url: safeParseLink(behavior.url), track: true });
+        }
+        return Object.assign(Object.assign({}, behavior), { track: true });
+    }
+    // Deprecated "container" behavior type
+    if ('action' in behavior && behavior.action) {
+        return actionToBehavior(behavior.action, stepActions);
+    }
+    if ('link' in behavior && behavior.link) {
+        return { type: 'link', url: safeParseLink(behavior.link.url), track: true };
+    }
+    return { type: 'none', track: false };
+};
+const actionToBehavior = (action, stepActions) => ({
+    type: 'action',
+    action: inlineAction(action, stepActions),
+    track: false,
+});
+export const inlineAction = (action, stepActions = []) => action.$ref ? Object.assign(Object.assign({}, getActionByReference(action.$ref, stepActions)), action) : action;
+const getActionByReference = ($ref, actions = []) => {
+    const action = actions.find((a) => a.$id === $ref);
+    if (!action) {
+        throw new Error('Action reference not found in actions array.');
+    }
+    return action;
+};

package/build/domain/mappers/utils/call-to-action-utils.js

@@ -0,0 +1,24 @@
+import { getDomainLayerBehavior } from './behavior-utils';
+import { getHrefWithTracking } from './getHrefWithTracking';
+import { mapLegacyContext } from './legacy-utils';
+export function getDomainLayerCallToAction(cta, mapperProps) {
+    var _a, _b;
+    if (!cta) {
+        return undefined;
+    }
+    const { step, onBehavior, trackEvent, registerSubmissionBehavior } = mapperProps;
+    const stepActions = (_a = step.actions) !== null && _a !== void 0 ? _a : [];
+    const behavior = getDomainLayerBehavior(cta, stepActions, registerSubmissionBehavior);
+    const isLink = behavior.type === 'link';
+    return {
+        type: behavior.type,
+        title: (_b = cta.title) !== null && _b !== void 0 ? _b : '',
+        context: cta.context ? mapLegacyContext(cta.context) : undefined,
+        accessibilityDescription: cta.accessibilityDescription,
+        href: isLink ? behavior.url : undefined,
+        hrefWithTracking: getHrefWithTracking({ behavior, onBehavior, trackEvent }),
+        onClick: () => {
+            void onBehavior(behavior);
+        },
+    };
+}

package/build/domain/mappers/utils/getAutocompleteString.js

@@ -0,0 +1,76 @@
+export const getAutocompleteString = (hints) => {
+    if (!hints || hints.length === 0) {
+        return 'off';
+    }
+    const validHints = hints.filter((hint) => autocompleteTokenMap[hint]);
+    if (validHints.length === 0) {
+        return 'off';
+    }
+    return validHints.map((hint) => autocompleteTokenMap[hint]).join(' ');
+};
+const autocompleteTokenMap = {
+    on: 'on',
+    name: 'name',
+    'name-prefix': 'honorific-prefix',
+    'given-name': 'given-name',
+    'additional-name': 'additional-name',
+    'family-name': 'family-name',
+    'name-suffix': 'honorific-suffix',
+    nickname: 'nickname',
+    email: 'email',
+    // Web doesn't have a specific mapping for new username, but this is semantically close enough
+    'new-username': 'username',
+    username: 'username',
+    'new-password': 'new-password',
+    password: 'current-password',
+    'one-time-code': 'one-time-code',
+    'job-title': 'organization-title',
+    'organization-name': 'organization',
+    'full-street-address': 'street-address',
+    'street-address-line-1': 'address-line1',
+    'street-address-line-2': 'address-line2',
+    'street-address-line-3': 'address-line3',
+    'address-level-1': 'address-level1',
+    'address-level-2': 'address-level2',
+    'address-level-3': 'address-level3',
+    'address-level-4': 'address-level4',
+    'country-code': 'country',
+    'country-name': 'country-name',
+    'postal-code': 'postal-code',
+    'credit-card-name': 'cc-name',
+    'credit-card-given-name': 'cc-given-name',
+    'credit-card-middle-name': 'cc-additional-name',
+    'credit-card-family-name': 'cc-family-name',
+    'credit-card-number': 'cc-number',
+    'credit-card-expiration': 'cc-exp',
+    'credit-card-expiration-month': 'cc-exp-month',
+    'credit-card-expiration-year': 'cc-exp-year',
+    'credit-card-security-code': 'cc-csc',
+    'credit-card-type': 'cc-type',
+    'transaction-currency': 'transaction-currency',
+    'transaction-amount': 'transaction-amount',
+    language: 'language',
+    birthdate: 'bday',
+    'birthdate-day': 'bday-day',
+    'birthdate-month': 'bday-month',
+    'birthdate-year': 'bday-year',
+    gender: 'sex',
+    'phone-number': 'tel',
+    'phone-country-code': 'tel-country-code',
+    'phone-national': 'tel-national',
+    'phone-area-code': 'tel-area-code',
+    'phone-local': 'tel-local',
+    'phone-local-prefix': 'tel-local-prefix',
+    'phone-local-suffix': 'tel-local-suffix',
+    'phone-extension': 'tel-extension',
+    url: 'url',
+    photo: 'photo',
+    impp: 'impp',
+    shipping: 'shipping',
+    billing: 'billing',
+    home: 'home',
+    work: 'work',
+    mobile: 'mobile',
+    fax: 'fax',
+    pager: 'pager',
+};

package/build/domain/mappers/utils/getAutocompleteString.test.js

@@ -0,0 +1,21 @@
+import { getAutocompleteString } from './getAutocompleteString';
+describe('getAutocompleteString', () => {
+    it('should return "off" if no hints are provided', () => {
+        expect(getAutocompleteString(undefined)).toBe('off');
+        expect(getAutocompleteString([])).toBe('off');
+    });
+    it('should return a string for valid hints', () => {
+        expect(getAutocompleteString(['name-prefix'])).toBe('honorific-prefix');
+    });
+    it('should return a space delimited, concatenated string for multiple valid hints', () => {
+        expect(getAutocompleteString(['name', 'billing'])).toBe('name billing');
+    });
+    it('should discard invalid hints', () => {
+        // @ts-expect-error testing an invalid hint
+        expect(getAutocompleteString(['name', 'cats'])).toBe('name');
+    });
+    it('should return "off" if no valid hints are provided', () => {
+        // @ts-expect-error testing an invalid hint
+        expect(getAutocompleteString(['cats'])).toBe('off');
+    });
+});

package/build/domain/mappers/utils/getHrefWithTracking.js

@@ -0,0 +1,16 @@
+export const getHrefWithTracking = ({ behavior, onBehavior, trackEvent, }) => {
+    if (behavior.type === 'link' && behavior.url) {
+        return () => ({
+            href: behavior.url,
+            target: '_blank',
+            onClick: () => {
+                trackEvent('Behavior Triggered', Object.assign(Object.assign({}, behavior.analytics), { behaviorType: behavior.type }));
+            },
+        });
+    }
+    return () => ({
+        onClick: () => {
+            void onBehavior(behavior);
+        },
+    });
+};

package/build/domain/mappers/utils/groupLayoutByPinned.js

@@ -0,0 +1,38 @@
+export const groupLayoutByPinned = (layouts) => {
+    return layouts.reduce(groupLayout, { pinned: [], nonPinned: [] });
+};
+const groupLayout = (acc, layout) => {
+    if (layout.type === 'button' && layout.pinOrder !== undefined) {
+        return {
+            pinned: [...acc.pinned, layout],
+            nonPinned: acc.nonPinned,
+        };
+    }
+    if (hasColumns(layout)) {
+        const leftChildren = groupLayoutByPinned(layout.left);
+        const rightChildren = groupLayoutByPinned(layout.right);
+        return {
+            pinned: [...acc.pinned, ...leftChildren.pinned, ...rightChildren.pinned],
+            nonPinned: [
+                ...acc.nonPinned,
+                Object.assign(Object.assign({}, layout), { left: leftChildren.nonPinned, right: rightChildren.nonPinned }),
+            ],
+        };
+    }
+    if (hasChildren(layout)) {
+        const childComponents = groupLayoutByPinned(layout.components);
+        return {
+            pinned: [...acc.pinned, ...childComponents.pinned],
+            nonPinned: [
+                ...acc.nonPinned,
+                Object.assign(Object.assign({}, layout), { components: childComponents.nonPinned }),
+            ],
+        };
+    }
+    return {
+        pinned: [...acc.pinned],
+        nonPinned: [...acc.nonPinned, layout],
+    };
+};
+const hasChildren = (component) => 'components' in component;
+const hasColumns = (component) => 'right' in component && 'left' in component;

package/build/domain/mappers/utils/groupLayoutByPinned.test.js

@@ -0,0 +1,166 @@
+import { groupLayoutByPinned } from './groupLayoutByPinned';
+describe('groupLayoutByPinned', () => {
+    it('should handle empty layouts array', () => {
+        const result = groupLayoutByPinned([]);
+        expect(result.pinned).toEqual([]);
+        expect(result.nonPinned).toEqual([]);
+    });
+    it('should leave unpinned layouts as is', () => {
+        const layouts = [
+            { type: 'button' },
+            { type: 'heading', text: 'Heading' },
+            { type: 'paragraph', text: 'Paragraph' },
+            {
+                type: 'columns',
+                left: [
+                    { type: 'button' },
+                    { type: 'heading', text: 'Heading' },
+                    { type: 'paragraph', text: 'Paragraph' },
+                ],
+                right: [
+                    { type: 'button' },
+                    { type: 'heading', text: 'Heading' },
+                    { type: 'paragraph', text: 'Paragraph' },
+                ],
+            },
+        ];
+        const result = groupLayoutByPinned(layouts);
+        expect(result.pinned).toEqual([]);
+        expect(result.nonPinned).toEqual(layouts);
+    });
+    it('should group layouts by pinned', () => {
+        const layouts = [
+            { type: 'button', pinOrder: 1 },
+            { type: 'button', pinOrder: 2 },
+            { type: 'button' },
+        ];
+        const result = groupLayoutByPinned(layouts);
+        expect(result.pinned).toEqual([
+            { type: 'button', pinOrder: 1 },
+            { type: 'button', pinOrder: 2 },
+        ]);
+        expect(result.nonPinned).toEqual([{ type: 'button' }]);
+    });
+    it('should group layouts by pinned in nested layout', () => {
+        const layouts = [
+            {
+                type: 'columns',
+                left: [
+                    {
+                        type: 'button',
+                        pinOrder: 1,
+                    },
+                    {
+                        type: 'heading',
+                        text: 'Money for here, there and everywhere',
+                    },
+                    {
+                        type: 'button',
+                        pinOrder: 2,
+                    },
+                ],
+                right: [
+                    {
+                        type: 'paragraph',
+                        text: "Sending money shouldn't cost the earth. That's why we charge you as little as possible when you transfer and exchange money internationally – you can save up to 9x compared to UK high street banks.",
+                    },
+                    {
+                        type: 'button',
+                        pinOrder: 3,
+                    },
+                ],
+            },
+            { type: 'button' },
+        ];
+        const result = groupLayoutByPinned(layouts);
+        expect(result.pinned).toEqual([
+            { type: 'button', pinOrder: 1 },
+            { type: 'button', pinOrder: 2 },
+            { type: 'button', pinOrder: 3 },
+        ]);
+        expect(result.nonPinned).toEqual([
+            {
+                type: 'columns',
+                left: [
+                    {
+                        type: 'heading',
+                        text: 'Money for here, there and everywhere',
+                    },
+                ],
+                right: [
+                    {
+                        type: 'paragraph',
+                        text: "Sending money shouldn't cost the earth. That's why we charge you as little as possible when you transfer and exchange money internationally – you can save up to 9x compared to UK high street banks.",
+                    },
+                ],
+            },
+            { type: 'button' },
+        ]);
+    });
+    it('should handle layouts with child components', () => {
+        const layouts = [
+            {
+                type: 'section',
+                title: 'Container',
+                components: [
+                    { type: 'button', pinOrder: 0 },
+                    { type: 'paragraph', text: 'Some text' },
+                    { type: 'button', pinOrder: 1 },
+                ],
+            },
+            { type: 'button' },
+        ];
+        const result = groupLayoutByPinned(layouts);
+        expect(result.pinned).toEqual([
+            { type: 'button', pinOrder: 0 },
+            { type: 'button', pinOrder: 1 },
+        ]);
+        expect(result.nonPinned).toEqual([
+            {
+                type: 'section',
+                title: 'Container',
+                components: [{ type: 'paragraph', text: 'Some text' }],
+            },
+            { type: 'button' },
+        ]);
+    });
+    it('should handle mixed nested structures', () => {
+        const layouts = [
+            {
+                type: 'columns',
+                left: [
+                    {
+                        type: 'section',
+                        title: 'Left Container',
+                        components: [
+                            { type: 'button', pinOrder: 1 },
+                            { type: 'paragraph', text: 'Left text' },
+                        ],
+                    },
+                ],
+                right: [
+                    { type: 'button', pinOrder: 2 },
+                    { type: 'paragraph', text: 'Right paragraph' },
+                ],
+            },
+        ];
+        const result = groupLayoutByPinned(layouts);
+        expect(result.pinned).toEqual([
+            { type: 'button', pinOrder: 1 },
+            { type: 'button', pinOrder: 2 },
+        ]);
+        expect(result.nonPinned).toEqual([
+            {
+                type: 'columns',
+                left: [
+                    {
+                        type: 'section',
+                        title: 'Left Container',
+                        components: [{ type: 'paragraph', text: 'Left text' }],
+                    },
+                ],
+                right: [{ type: 'paragraph', text: 'Right paragraph' }],
+            },
+        ]);
+    });
+});

package/build/domain/mappers/utils/image.js

@@ -0,0 +1,6 @@
+export const mapSpecImage = (image) => { var _a, _b, _c; return image
+    ? {
+        uri: (_b = (_a = image.uri) !== null && _a !== void 0 ? _a : image.url) !== null && _b !== void 0 ? _b : '',
+        accessibilityDescription: (_c = image.accessibilityDescription) !== null && _c !== void 0 ? _c : image.text,
+    }
+    : undefined; };

package/build/domain/mappers/utils/layout-utils.js

@@ -0,0 +1,11 @@
+/**
+ * Normalizes the margin of the last layout component in the container by removing its margin if it is not explicitly set.
+ * @param container The array of layout components.
+ * @returns The array of layout components with the last component's margin normalized if needed.
+ */
+export const normaliseMarginInLastComponent = (container) => {
+    return container.map((component, index) => {
+        const shouldRemoveMargin = index === container.length - 1 && component.margin === undefined;
+        return shouldRemoveMargin ? Object.assign(Object.assign({}, component), { margin: 'xs' }) : component;
+    });
+};

package/build/domain/mappers/utils/legacy-utils.js

@@ -0,0 +1,49 @@
+export const mapLegacyContext = (context) => {
+    switch (context) {
+        case 'success':
+            return 'positive';
+        case 'failure':
+            return 'negative';
+        case 'info':
+        case 'primary':
+            return 'neutral';
+        default:
+            return context;
+    }
+};
+export const mapLegacyBias = (bias) => {
+    switch (bias) {
+        case 'left':
+            return 'start';
+        case 'right':
+            return 'end';
+        default:
+            return bias;
+    }
+};
+export const mapLegacyAlign = (align) => {
+    switch (align) {
+        case 'left':
+            return 'start';
+        case 'right':
+            return 'end';
+        default:
+            return align;
+    }
+};
+const legacyActionTypeToContext = {
+    positive: 'positive',
+    negative: 'negative',
+    primary: 'neutral',
+    secondary: 'neutral',
+    link: 'neutral',
+};
+export const mapLegacyActionTypeToContext = (type) => type && type in legacyActionTypeToContext ? legacyActionTypeToContext[type] : 'neutral';
+const legacyActionTypeToControl = {
+    primary: 'primary',
+    secondary: 'secondary',
+    link: 'tertiary',
+    positive: 'primary',
+    negative: 'primary',
+};
+export const mapLegacyActionTypeToControl = (type) => type && type in legacyActionTypeToControl ? legacyActionTypeToControl[type] : 'secondary';

package/build/domain/mappers/utils/media-utils.js

@@ -0,0 +1,14 @@
+import { mapSpecImage } from './image';
+export const getDomainLayerMedia = ({ icon, image, media }) => {
+    if (media) {
+        return media;
+    }
+    if (icon || image) {
+        return {
+            type: 'legacy',
+            icon,
+            image: mapSpecImage(image),
+        };
+    }
+    return undefined;
+};

package/build/domain/mappers/utils/suggestions-utils.js

@@ -0,0 +1,26 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { getDomainLayerMedia } from './media-utils';
+import { mapTags } from './tags-utils';
+export const mapSuggestions = (suggestions, logEvent) => {
+    if (!suggestions)
+        return undefined;
+    return {
+        values: suggestions.values.map((_a) => {
+            var { icon, image, media, value } = _a, rest = __rest(_a, ["icon", "image", "media", "value"]);
+            if (typeof value !== 'string') {
+                logEvent('warning', `Suggestion values must be of type string. Found ${typeof value} instead.`);
+            }
+            return Object.assign(Object.assign({}, rest), { media: getDomainLayerMedia({ icon, image, media }), value, tags: mapTags(rest) });
+        }),
+    };
+};

package/build/domain/mappers/utils/suggestions-utils.test.js

@@ -0,0 +1,36 @@
+import { mapSuggestions } from './suggestions-utils';
+import { vi } from 'vitest';
+describe('mapSuggestions', () => {
+    it('logs a warning when the value is a not a string', () => {
+        const logEvent = vi.fn();
+        const suggestions = {
+            values: [{ value: 123, label: 'Number suggestion' }],
+        };
+        mapSuggestions(suggestions, logEvent);
+        expect(logEvent).toHaveBeenCalledWith('warning', 'Suggestion values must be of type string. Found number instead.');
+    });
+    it('logs a warning when the value is null', () => {
+        const logEvent = vi.fn();
+        const suggestions = {
+            values: [{ value: null, label: 'Null suggestion' }],
+        };
+        mapSuggestions(suggestions, logEvent);
+        expect(logEvent).toHaveBeenCalledWith('warning', 'Suggestion values must be of type string. Found object instead.');
+    });
+    it('does not log a warning when the value is a string', () => {
+        const logEvent = vi.fn();
+        const suggestions = {
+            values: [{ value: 'string', label: 'String suggestion' }],
+        };
+        mapSuggestions(suggestions, logEvent);
+        expect(logEvent).not.toHaveBeenCalled();
+    });
+    it('does not log a warning when the value is an empty string', () => {
+        const logEvent = vi.fn();
+        const suggestions = {
+            values: [{ value: '', label: 'Empty string suggestion' }],
+        };
+        mapSuggestions(suggestions, logEvent);
+        expect(logEvent).not.toHaveBeenCalled();
+    });
+});

package/build/domain/mappers/utils/tags-utils.js

@@ -0,0 +1 @@
+export const mapTags = ({ tag, tags }) => tags !== null && tags !== void 0 ? tags : (tag != null ? [tag] : undefined);

package/build/domain/mappers/utils/utils.js

@@ -0,0 +1,45 @@
+import { getDomainLayerBehavior } from './behavior-utils';
+import { getHrefWithTracking } from './getHrefWithTracking';
+import { mapLegacyContext } from './legacy-utils';
+import { getDomainLayerMedia } from './media-utils';
+export const mapInlineAlert = (alert) => {
+    return alert
+        ? {
+            content: alert.content,
+            context: alert.context ? mapLegacyContext(alert.context) : 'neutral',
+            media: getDomainLayerMedia({ media: alert.media }),
+        }
+        : undefined;
+};
+export const mapAdditionalInfo = (info, mapperProps) => {
+    const { onBehavior, trackEvent, registerSubmissionBehavior } = mapperProps;
+    if (info) {
+        const behavior = getDomainLayerBehavior(info, [], registerSubmissionBehavior);
+        const isLink = behavior.type === 'link';
+        return {
+            text: info.text,
+            href: isLink ? behavior.url : undefined,
+            hrefWithTracking: getHrefWithTracking({
+                behavior,
+                onBehavior,
+                trackEvent,
+            }),
+            accessibilityDescription: info.accessibilityDescription,
+            onClick: behavior.type === 'none'
+                ? undefined
+                : () => {
+                    void onBehavior(behavior);
+                },
+        };
+    }
+    return undefined;
+};
+export const mapSchemaAlert = (alert) => {
+    return alert
+        ? {
+            content: alert.markdown,
+            context: alert.context ? mapLegacyContext(alert.context) : 'neutral',
+            media: getDomainLayerMedia({ media: alert.media }),
+        }
+        : undefined;
+};

package/build/domain/types.js

@@ -0,0 +1 @@
+export {};

package/build/i18n/index.js

@@ -0,0 +1,40 @@
+import cs from './cs.json';
+import de from './de.json';
+import en from './en.json';
+import es from './es.json';
+import fr from './fr.json';
+import hu from './hu.json';
+import id from './id.json';
+import it from './it.json';
+import ja from './ja.json';
+import nl from './nl.json';
+import pl from './pl.json';
+import pt from './pt.json';
+import ro from './ro.json';
+import ru from './ru.json';
+import th from './th.json';
+import tr from './tr.json';
+import zhCN from './zh_CN.json';
+import zhHK from './zh_HK.json';
+const translations = {
+    cs,
+    en,
+    de,
+    es,
+    fr,
+    hu,
+    id,
+    it,
+    ja,
+    nl,
+    pl,
+    pt,
+    ro,
+    ru,
+    th,
+    tr,
+    zh: zhCN,
+    'zh-CN': zhCN,
+    'zh-HK': zhHK,
+};
+export default translations;