@tap-payments/auth-jsconnect 2.1.12-test → 2.1.14-test

package/build/utils/array.d.ts

@@ -0,0 +1,63 @@
+import { CountryCode, SaleChannel } from '../@types';
+export declare const isArray: (value: any) => value is any[];
+export declare const joinArray: (items: Array<any>, joiner?: string) => string;
+export declare const replaceStringArrayItems: (items: Array<string>, include: string, withThis: string) => string[];
+export declare const uniqueArray: (items: Array<string>) => string[];
+export declare const removeArrayItem: (items: Array<string>, item: string) => string[];
+export declare const splitString: (string: string, splitter?: string) => string[];
+export declare const isInclude: (items: Array<string | number>, item: any) => boolean;
+export declare const findItem: (items: Array<string | number>, key: any) => string | number | undefined;
+export declare const isExist: (items: Array<any>, id: string) => any;
+export declare const allAreTruthy: (items: Array<any>, condition: boolean | string, key: string, exclude?: string) => boolean;
+export declare const sortCountries: (countries: Array<CountryCode>) => CountryCode[];
+export declare const findCountryByIso2: (countries: Array<CountryCode>, iso2: string) => CountryCode | undefined;
+export declare const findCurrencyByIso2: (code: string) => "" | "SAR" | "KD";
+export declare const findCountryByIddPrefix: (countries: Array<CountryCode>, iddPrefix: string) => CountryCode | undefined;
+export declare const mapSalesChannel: (salesChannel: Array<SaleChannel>) => {
+    sub?: import("../@types").SubSaleChannel[] | undefined;
+    address: string;
+    id: string;
+    code: string;
+    name?: {
+        ar: string;
+        en: string;
+    } | undefined;
+    logo?: string | undefined;
+}[];
+export declare const mapBrandSalesChannel: (salesChannel: Array<SaleChannel>, brandSalesChannel: Array<SaleChannel>) => ({
+    sub: ({
+        id: string;
+        code: string;
+        name?: {
+            ar: string;
+            en: string;
+        } | undefined;
+        address?: string | undefined;
+        logo?: string | undefined;
+    } | undefined)[] | undefined;
+    id: string;
+    code: string;
+    name?: {
+        ar: string;
+        en: string;
+    } | undefined;
+    address?: string | undefined;
+    logo?: string | undefined;
+} | {
+    sub?: import("../@types").SubSaleChannel[] | undefined;
+    id: string;
+    code: string;
+    name?: {
+        ar: string;
+        en: string;
+    } | undefined;
+    address?: string | undefined;
+    logo?: string | undefined;
+} | undefined)[];
+export declare const removeDuplicationById: (items: Array<any>) => any[];
+export declare const fixBrandList: (items: Array<{
+    channel_services: Array<SaleChannel>;
+}>, salesChannel: Array<SaleChannel>) => {
+    channel_services: any[];
+}[];
+export declare const findFirstId: (items: Array<SaleChannel>) => string;

package/build/utils/array.js

@@ -0,0 +1,140 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+export var isArray = function (value) { return Array.isArray(value); };
+export var joinArray = function (items, joiner) {
+    if (joiner === void 0) { joiner = '__'; }
+    if (!items)
+        return '';
+    return items.join(joiner);
+};
+export var replaceStringArrayItems = function (items, include, withThis) {
+    if (!items)
+        return [];
+    return items.map(function (item) {
+        if (item.includes(include))
+            return withThis;
+        return item;
+    });
+};
+export var uniqueArray = function (items) {
+    if (!items)
+        return [];
+    return items.filter(function (path, i) { return items.indexOf(path) === i; });
+};
+export var removeArrayItem = function (items, item) {
+    if (!items)
+        return [];
+    return items.filter(function (path) { return path !== item; });
+};
+export var splitString = function (string, splitter) {
+    if (splitter === void 0) { splitter = '&&&'; }
+    if (!string)
+        return [];
+    return string.split(splitter);
+};
+export var isInclude = function (items, item) {
+    return items.includes(item);
+};
+export var findItem = function (items, key) {
+    return items.find(function (item) { return item === key; });
+};
+export var isExist = function (items, id) {
+    return items.find(function (_a) {
+        var sub = _a.sub, itemID = _a.id;
+        if (!sub)
+            return itemID === id;
+        return sub.some(function (item) {
+            return item.id === id;
+        });
+    });
+};
+export var allAreTruthy = function (items, condition, key, exclude) {
+    return items.every(function (item) {
+        if (exclude && item['name'] === exclude)
+            return true;
+        return item[key] === condition;
+    });
+};
+export var sortCountries = function (countries) {
+    return (countries || []).sort(function (cOne, cTwo) {
+        return cOne.name.english.localeCompare(cTwo.name.english);
+    });
+};
+export var findCountryByIso2 = function (countries, iso2) {
+    if (!iso2)
+        throw new Error('iso2 is required');
+    return countries.find(function (country) { return country.iso2.toLowerCase() === iso2.toLowerCase(); });
+};
+export var findCurrencyByIso2 = function (code) {
+    if (!code)
+        return '';
+    if (code.toLowerCase() === 'sa')
+        return 'SAR';
+    if (code.toLowerCase() === 'kw')
+        return 'KD';
+    return '';
+};
+export var findCountryByIddPrefix = function (countries, iddPrefix) {
+    if (!iddPrefix)
+        throw new Error('idd_prefix is required');
+    return countries.find(function (country) { return country.idd_prefix.toString() === iddPrefix; });
+};
+export var mapSalesChannel = function (salesChannel) {
+    return salesChannel.map(function (item) {
+        var hasSub = item.sub && item.sub.length > 0;
+        return __assign(__assign(__assign({}, item), { address: (item.address || '').replaceAll('https://', '').replaceAll('@', '') }), (hasSub && {
+            sub: item.sub.map(function (subItem) {
+                return __assign(__assign({}, subItem), { address: (subItem.address || '').replaceAll('https://', '').replaceAll('@', '') });
+            })
+        }));
+    });
+};
+export var mapBrandSalesChannel = function (salesChannel, brandSalesChannel) {
+    var findSalesChannel = function (id) { return salesChannel.find(function (item) { return item.id === id; }); };
+    var mapped = brandSalesChannel
+        .map(function (item) {
+        var _a;
+        var originalSalasChannel = findSalesChannel(item.id);
+        if (!originalSalasChannel)
+            return undefined;
+        var hasSub = item.sub && item.sub.length > 0;
+        if (hasSub)
+            return __assign(__assign({}, item), { sub: (_a = originalSalasChannel.sub) === null || _a === void 0 ? void 0 : _a.map(function (subItem) {
+                    var _a;
+                    var brandSubItem = (_a = item.sub) === null || _a === void 0 ? void 0 : _a.find(function (brandSub) { return brandSub.id === subItem.id; });
+                    if (!brandSubItem)
+                        return undefined;
+                    return __assign(__assign({}, subItem), brandSubItem);
+                }).filter(Boolean) });
+        return __assign({}, item);
+    })
+        .filter(Boolean);
+    return mapped;
+};
+export var removeDuplicationById = function (items) {
+    return items.filter(function (item, index) {
+        return items.findIndex(function (i) { return i.id === item.id; }) === index;
+    });
+};
+export var fixBrandList = function (items, salesChannel) {
+    return items.map(function (item) {
+        return __assign(__assign({}, item), { channel_services: removeDuplicationById(mapBrandSalesChannel(salesChannel, item.channel_services || [])) });
+    });
+};
+export var findFirstId = function (items) {
+    var first = items[0];
+    if (!first)
+        return '';
+    if (first.sub && first.sub.length > 0)
+        return first.sub[0].id;
+    return first.id;
+};

package/build/utils/common.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (milliseconds: number) => Promise<unknown>;

package/build/utils/common.js

@@ -0,0 +1,3 @@
+export var sleep = function (milliseconds) {
+    return new Promise(function (resolve) { return setTimeout(resolve, milliseconds); });
+};

package/build/utils/date.d.ts

@@ -0,0 +1 @@
+export declare const dateFormat: (date: Date, fmt?: string) => string;

package/build/utils/date.js

@@ -0,0 +1,5 @@
+import moment from 'moment';
+export var dateFormat = function (date, fmt) {
+    if (fmt === void 0) { fmt = 'YYYY-MM-DD'; }
+    return moment(date).format('YYYY-MM-DD');
+};

package/build/utils/device.d.ts

@@ -0,0 +1,5 @@
+import { DeviceDetectorResult } from 'device-detector-js';
+import { GetResult } from '@fingerprintjs/fingerprintjs';
+export declare const getBrowserInfo: () => DeviceDetectorResult;
+export declare const getFingerPrint: () => Promise<GetResult>;
+export declare const mobileOS: () => 'Windows Phone' | 'Android' | 'iOS' | 'unknown';

package/build/utils/device.js

@@ -0,0 +1,26 @@
+import DeviceDetector from 'device-detector-js';
+import FingerprintJS from '@fingerprintjs/fingerprintjs';
+export var getBrowserInfo = function () {
+    var deviceDetector = new DeviceDetector();
+    return deviceDetector.parse(window.navigator.userAgent);
+};
+export var getFingerPrint = function () {
+    return FingerprintJS.load().then(function (fp) {
+        return fp.get().then(function (result) {
+            return result;
+        });
+    });
+};
+export var mobileOS = function () {
+    var userAgent = navigator.userAgent || navigator.vendor || window.opera;
+    if (/windows phone/i.test(userAgent)) {
+        return 'Windows Phone';
+    }
+    if (/android/i.test(userAgent)) {
+        return 'Android';
+    }
+    if (/iPad|iPhone|iPod/.test(userAgent) && !window.MSStream) {
+        return 'iOS';
+    }
+    return 'unknown';
+};

package/build/utils/html.d.ts

@@ -0,0 +1,5 @@
+export declare const createElementAndInject: (id: string) => HTMLDivElement;
+export declare const reactElement: (elementId: string) => import("react-dom/client").Root;
+export declare const scrollUp: (elementId: string, top?: number) => void;
+export declare const scrollDown: (elementId: string) => void;
+export declare const removeElement: (elementId: string) => void;

package/build/utils/html.js

@@ -0,0 +1,32 @@
+import { createRoot } from 'react-dom/client';
+export var createElementAndInject = function (id) {
+    var element = document.createElement('div');
+    element.setAttribute('id', id);
+    document.body.appendChild(element);
+    return element;
+};
+export var reactElement = function (elementId) {
+    var element = document.getElementById(elementId);
+    if (!element) {
+        element = createElementAndInject('tap-payments-sdk-element');
+    }
+    return createRoot(element);
+};
+export var scrollUp = function (elementId, top) {
+    var el = document.getElementById(elementId);
+    if (!el)
+        return;
+    el.scrollTop = top || 300;
+};
+export var scrollDown = function (elementId) {
+    var el = document.getElementById(elementId);
+    if (!el)
+        return;
+    el.scrollTop = 0;
+};
+export var removeElement = function (elementId) {
+    var el = document.getElementById(elementId);
+    if (!el)
+        return;
+    el.remove();
+};

package/build/utils/index.d.ts

@@ -0,0 +1,11 @@
+export * from './storage';
+export * from './array';
+export * from './style';
+export * from './object';
+export * from './html';
+export * from './validation';
+export * from './string';
+export * from './device';
+export * from './rsa';
+export * from './common';
+export * from './date';

package/build/utils/index.js

@@ -0,0 +1,11 @@
+export * from './storage';
+export * from './array';
+export * from './style';
+export * from './object';
+export * from './html';
+export * from './validation';
+export * from './string';
+export * from './device';
+export * from './rsa';
+export * from './common';
+export * from './date';

package/build/utils/locale.d.ts

@@ -0,0 +1,2 @@
+import { LocalProps } from '../@types';
+export declare const updateLocale: (locale: LocalProps, country: string) => void;

package/build/utils/locale.js

@@ -0,0 +1,22 @@
+import { initReactI18next } from 'react-i18next';
+import i18n from '../i18n';
+export var updateLocale = function (locale, country) {
+    var data = locale['SA'] || locale[country.toUpperCase()] || locale['default'];
+    if (i18n.isInitialized) {
+        i18n.removeResourceBundle('*', 'translation');
+        i18n.addResourceBundle('en', 'translation', data.en.translation);
+        i18n.addResourceBundle('ar', 'translation', data.ar.translation);
+    }
+    else {
+        i18n.use(initReactI18next).init({
+            resources: data,
+            fallbackLng: 'en',
+            initImmediate: false,
+            preload: ['ar', 'en'],
+            debug: false,
+            interpolation: {
+                escapeValue: false
+            }
+        });
+    }
+};

package/build/utils/object.d.ts

@@ -0,0 +1,5 @@
+export declare const compareTwoObjects: (obj1: any, obj2: any) => boolean;
+export declare const encodeObjectBase64: (obj: any) => string;
+export declare const decodeObjectBase64: (str: string) => any;
+export declare const hasKey: (obj: any, key: string) => boolean;
+export declare const concatenateObjectValues: (data: Record<string, any>, keys: Array<string>) => string;

package/build/utils/object.js

@@ -0,0 +1,35 @@
+export var compareTwoObjects = function (obj1, obj2) {
+    if (obj1 === obj2)
+        return true;
+    if (!obj1 || !obj2)
+        return false;
+    return JSON.stringify(obj1) === JSON.stringify(obj2);
+};
+export var encodeObjectBase64 = function (obj) {
+    return Buffer.from(JSON.stringify(obj)).toString('base64');
+};
+export var decodeObjectBase64 = function (str) {
+    try {
+        return JSON.parse(Buffer.from(str, 'base64').toString('ascii'));
+    }
+    catch (error) {
+        throw new Error('Invalid base64 string or invalid json format. try to check [decodeObjectBase64]');
+    }
+};
+export var hasKey = function (obj, key) {
+    if (!obj)
+        return false;
+    return Object.keys(obj).includes(key);
+};
+export var concatenateObjectValues = function (data, keys) {
+    if (!data)
+        return '';
+    var result = '';
+    for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+        var key = keys_1[_i];
+        if (data[key]) {
+            result += data[key].trim() + ' ';
+        }
+    }
+    return result.trim();
+};

package/build/utils/rsa.d.ts

@@ -0,0 +1,2 @@
+export declare const encryptObject: (data: unknown) => any;
+export declare const encryptString: (string: string) => any;

package/build/utils/rsa.js

@@ -0,0 +1,19 @@
+import { RSA_FRONTEND_MW_PUBLIC_KEY } from '../constants';
+var JSEncrypt = require('jsencrypt').JSEncrypt;
+var rsa = new JSEncrypt();
+rsa.setPublicKey(RSA_FRONTEND_MW_PUBLIC_KEY);
+export var encryptObject = function (data) {
+    if (typeof data !== 'object')
+        throw new Error('data should be from type object');
+    var obj2Str = JSON.stringify(data);
+    var encrypted = rsa.encrypt(obj2Str);
+    return encrypted;
+};
+export var encryptString = function (string) {
+    if (typeof string !== 'string')
+        throw new Error('string should be from type string');
+    var encrypted = rsa.encrypt(string);
+    if (!encrypted)
+        throw new Error('encryption data reached max allowed length');
+    return encrypted;
+};

package/build/utils/storage.d.ts

@@ -0,0 +1,5 @@
+export declare const storeData: (key: string, value: string | number | object) => void;
+export declare const getStoredData: (key: string) => any;
+export declare const removeStoredData: (key: string) => void;
+export declare const clearStoredData: () => void;
+export declare const getStoredDataKeys: () => string[];

package/build/utils/storage.js

@@ -0,0 +1,21 @@
+export var storeData = function (key, value) {
+    localStorage.setItem(key, JSON.stringify(value));
+};
+export var getStoredData = function (key) {
+    try {
+        var value = localStorage.getItem(key);
+        return value ? JSON.parse(value) : null;
+    }
+    catch (error) {
+        throw new Error(error);
+    }
+};
+export var removeStoredData = function (key) {
+    localStorage.removeItem(key);
+};
+export var clearStoredData = function () {
+    localStorage.clear();
+};
+export var getStoredDataKeys = function () {
+    return Object.keys(localStorage);
+};

package/build/utils/string.d.ts

@@ -0,0 +1,58 @@
+import { DeviceInfo } from '../@types';
+export declare const maskPhone: (str?: string) => string;
+export declare const shortenString: (str: string, length: number) => string;
+export declare const maskID: (str: string) => string;
+export declare const maskEmail: (str: string) => string;
+export declare const shortenBrand: (str: string) => string;
+export declare const showLastFour: (str: string) => string;
+export declare const maskFileName: (str: string) => string;
+export declare const getIndividualName: (name: string) => {
+    first: string;
+    middle: string;
+    last: string;
+} | undefined;
+export declare const convertNumbers2English: (str: string) => string;
+export declare const getParameterByName: (name: string) => string | null;
+export declare const getClientEmailUrl: () => string;
+export declare const getFlowUrl: (path: string, lang: string) => string;
+export declare const getResetFlowUrl: (path: string, lang: string, operationType: string, id: string, infoId: string) => string;
+export declare const capitalizeTheFirstLetterOfEachWord: (words: string) => string;
+export declare const getRequestHeaders: (deviceInfo: DeviceInfo) => {
+    al: any;
+    at: any;
+    aid: any;
+    an: any;
+    av: any;
+    acv: any;
+    asv: any;
+    rn: any;
+    rt: any;
+    rb: any;
+    rm: any;
+    ro: any;
+    rov: any;
+    bn: any;
+    bb: any;
+    bv: any;
+    bua: any;
+    bi: string;
+    ci: any;
+    cm: any;
+    l: any;
+};
+export declare const removeRequestHeaders: () => void;
+export declare const getBaseUrl: () => string;
+export declare const getScreenNameBasedOnFlow: (flow: string) => "CONNECT_NID_STEP" | "" | "BUSINESS_BUSINESS_TYPE_STEP" | "INDIVIDUAL_ADDITIONAL_INDIVIDUAL_INFO_STEP" | "BANK_BANK_DETAILS_STEP" | "TAX_TAX_DETAILS_STEP";
+export declare const getEighteenYearsAgo: () => string;
+export declare const isKW: (flag: string) => boolean;
+export declare const isSA: (flag: string) => boolean;
+export declare const isLinkedIn: (flag: string) => boolean;
+export declare const isTwitter: (flag: string) => boolean;
+export declare const isWebsite: (flag: string) => boolean;
+export declare const isIos: (flag: string) => boolean;
+export declare const isAndroid: (flag: string) => boolean;
+export declare const isFacebook: (flag: string) => boolean;
+export declare const isInstagram: (flag: string) => boolean;
+export declare const isPhysicalStore: (flag: string) => boolean;
+export declare const isCallCenter: (flag: string) => boolean;
+export declare const getChannelIcon: (channel: string) => string;