@antscorp/antsomi-ui 1.3.2-beta.9 → 1.3.3

package/es/utils/common.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Function to reorder list
+ * @param {Object[]} list - list of item want to reorder
+ * @param {number} startIndex - start item index want to replace position: ;
+ * @param {number} endIndex - end item index want to replace position: ;
+ * @returns {object[]}
+ */
+export declare const reorder: (list: Array<Record<string, unknown> | string | number>, startIndex: number, endIndex: number) => any[];
+export declare const safeParse: (val: any, defaultVal: any) => any;
+export declare function getPortalId(config: any): any;
+export declare const safeParseInt: (val: any, defaultVal: any) => any;
+export declare function isUrlEmbedded(): boolean;
+export declare function getWindowParam(name: any, config: any): any;
+export declare function getSessionStorage(key: any, config: any): any;
+export declare function getMessageByCode(messageCode: any, def?: undefined | string): any;
+export declare function urlHasQueryString(url: any): boolean;
+export declare function isNumeric(num: any): boolean;
+export declare function getUserLocaleLanguage(config: any): any;
+export declare function getAppSession(key: any, config: any): any;
+export declare function getAppParamURL(pathname: any, forceVersionV2: boolean | undefined, config: any): {
+    portalId: number;
+    accessUserId: number;
+};
+export declare function callApiWithAuth(endpoint: any, method: string | undefined, body: any, domain?: string, config?: {}, token?: string, userId?: string, isTicket?: boolean, type?: string, isAccount?: boolean, isPermission?: boolean, others?: any): Promise<void | import("axios").AxiosResponse<any, any>>;
+export declare function getData(res: any, def: any): {
+    code: number;
+    message: any;
+    data: any;
+    codeMessage?: undefined;
+} | {
+    code: number;
+    codeMessage: string;
+    message: any;
+    data: any;
+};
+export declare function getEntriesV2(res: any, def: any): {
+    code: number;
+    codeMessage: any;
+    messageAPI: any;
+    data: any;
+} | {
+    code: number;
+    codeMessage: string;
+    data: any;
+    messageAPI?: undefined;
+};
+export declare const getNumberFromString: (str: string) => number;
+/**
+ * Maps a number to its corresponding ordinal text representation.
+ * @param {number} num - The number to be mapped.
+ * @return {string} The ordinal text representation of the number.
+ */
+export declare function mapNumberToOrdinalText(num: number): string;

package/es/utils/common.js

@@ -0,0 +1,355 @@
+/* eslint-disable no-underscore-dangle */
+// Libraries
+import axios from 'axios';
+// Constants
+import { MESSAGES, PORTAL_KEYS } from '@antscorp/antsomi-ui/es/services/constants';
+/**
+ * Function to reorder list
+ * @param {Object[]} list - list of item want to reorder
+ * @param {number} startIndex - start item index want to replace position: ;
+ * @param {number} endIndex - end item index want to replace position: ;
+ * @returns {object[]}
+ */
+export const reorder = (list, startIndex, endIndex) => {
+    const result = Array.from(list);
+    const [removed] = result.splice(startIndex, 1);
+    result.splice(endIndex, 0, removed);
+    return result;
+};
+export const safeParse = (val, defaultVal) => {
+    if (typeof val === 'undefined' ||
+        val === 'undefined' ||
+        val === null ||
+        val.length === 0 ||
+        val === 'NaN') {
+        return defaultVal;
+    }
+    return val;
+};
+export function getPortalId(config) {
+    const portalId = safeParse(getSessionStorage('api_pid', config), 0);
+    if (portalId === 0) {
+        return getAppParamURL(window.location.pathname, false, config).portalId;
+    }
+    return portalId;
+    // return safeParse(getAppSession('api_pid'), 0);
+}
+export const safeParseInt = (val, defaultVal) => {
+    let tempt = safeParse(val, 0);
+    if (tempt !== 0) {
+        tempt = parseInt(tempt);
+        if (Number.isNaN(tempt)) {
+            return defaultVal;
+        }
+    }
+    return tempt;
+};
+export function isUrlEmbedded() {
+    return false;
+}
+function getDataWithEmbeddedPublic(key, config) {
+    const data = safeParse(config.embeddedData, {});
+    return data[key];
+}
+export function getWindowParam(name, config) {
+    return config[name];
+}
+export function getSessionStorage(key, config) {
+    if (isUrlEmbedded()) {
+        return getDataWithEmbeddedPublic(key, config);
+    }
+    const tempt = getWindowParam(key, config);
+    if (tempt !== undefined) {
+        return tempt;
+    }
+    if (typeof Storage !== 'undefined') {
+        return sessionStorage.getItem(key);
+    }
+    return '';
+}
+export function getMessageByCode(messageCode, def = undefined) {
+    if (def === undefined) {
+        def = 'Error happened. Please try again.';
+    }
+    const tempt = MESSAGES[messageCode];
+    if (tempt === undefined) {
+        return def;
+    }
+    return tempt;
+}
+export function urlHasQueryString(url) {
+    const arr = url.split('?');
+    if (arr.length > 1 && arr[1] !== '') {
+        return true;
+    }
+    return false;
+}
+export function isNumeric(num) {
+    return !isNaN(num) && num !== '';
+}
+export function getUserLocaleLanguage(config) {
+    return safeParse(getWindowParam(PORTAL_KEYS.USER_LANGUAGE, config), 'en');
+}
+export function getAppSession(key, config) {
+    if (isUrlEmbedded()) {
+        return getDataWithEmbeddedPublic(key, config);
+    }
+    let tempt = safeParse(getSessionStorage(key, config), '');
+    if (tempt === '') {
+        // console.error('------CAN"T NOT GET APP SESSION');
+        tempt = getCookie(key, config);
+    }
+    return window.decodeURIComponent(tempt);
+}
+export function getAppParamURL(pathname, forceVersionV2 = false, config) {
+    const output = {
+        portalId: 0,
+        accessUserId: 0,
+    };
+    const isV3 = pathname.indexOf('marketing-hub') > -1;
+    let portalId = 0;
+    let accessUserId = 0;
+    if (forceVersionV2 || !isV3) {
+        try {
+            // const arr = pathname.split('/');
+            const arr = pathname.split('v2');
+            if (arr.length >= 2) {
+                const arrTmp = arr[1].split('/');
+                // console.log('arrTmp', arrTmp);
+                if (arrTmp.length >= 2) {
+                    // console.log('arr', arrTmp);
+                    portalId = safeParseInt(arrTmp[2], 0);
+                    if (portalId <= 0) {
+                        portalId = safeParseInt(arrTmp[1], 0);
+                    }
+                }
+            }
+            if (portalId <= 0) {
+                portalId = safeParseInt(getAppSession('api_pid', config), 0);
+            }
+        }
+        catch (e) {
+            // console.error(e);
+        }
+    }
+    // V3 thêm param userid trên URL
+    // http://localhost:5000/gen2/33167/marketing-hub/journeys/3/create
+    // => http://localhost:5000/gen2/33167/1600082431/marketing-hub/journeys/3/create
+    if (isV3) {
+        try {
+            // const arr = pathname.split('/');
+            const arr = pathname.split('v2');
+            if (arr.length >= 2) {
+                const arrTmp = arr[1].split('/');
+                if (arrTmp.length >= 2) {
+                    portalId = safeParseInt(arrTmp[1], 0);
+                    accessUserId = safeParseInt(arrTmp[2], 0);
+                    // if (portalId <= 0) {
+                    //   portalId = safeParseInt(arrTmp[1], 0);
+                    // }
+                }
+            }
+            if (portalId <= 0) {
+                portalId = safeParseInt(getAppSession('api_pid', config), 0);
+            }
+        }
+        catch (e) {
+            // console.error(e);
+        }
+    }
+    output.portalId = portalId;
+    output.accessUserId = accessUserId;
+    return output;
+}
+export function callApiWithAuth(endpoint, method = 'GET', body, domain = '', config = {}, token = '', userId = '', isTicket = false, type = '', isAccount = false, isPermission = false, others = {}) {
+    console.log(token);
+    const apiPid = getPortalId(config);
+    const apiToken = token;
+    const _user_id = userId;
+    let _owner_id = userId;
+    // get from other params
+    if (isTicket) {
+        const params = {
+            _token: apiToken,
+            _account_id: _owner_id,
+            _user_id,
+        };
+        // endpoint += `${apiToken}&_account_id=${_owner_id}&_user_id=${_user_id}`;
+        if (type) {
+            params.type = type;
+            // endpoint += `&type=${type}`
+        }
+        if (body.isGetAllAppInfo) {
+            params.hasChild = body.hasChild;
+            params.from = body.from;
+        }
+        return axios({
+            method,
+            url: `${domain}/${endpoint}`,
+            params,
+            data: body,
+        }).catch(err => {
+            console.log(err);
+        });
+    }
+    if (isAccount) {
+        const params = {
+            _token: apiToken,
+            _account_id: _owner_id,
+            _user_id,
+            account_type: type,
+        };
+        return axios({
+            method,
+            url: `${domain}/${endpoint}`,
+            params,
+            data: body,
+        }).catch(err => {
+            console.log(err);
+        });
+    }
+    if (isPermission) {
+        const params = {
+            type,
+            appCode: body.appCode,
+            menuCode: body.menuCode,
+            fullParent: body.fullParent,
+            _token: apiToken,
+            _user_id: body.ownerId || _user_id,
+            _account_id: _user_id,
+        };
+        return axios({
+            method,
+            url: `${domain}/${endpoint}`,
+            params,
+            data: body,
+        }).catch(err => {
+            console.log(err);
+        });
+    }
+    if (Object.prototype.hasOwnProperty.call(others, '_owner_id')) {
+        _owner_id = safeParse(others._owner_id, '');
+    }
+    const isJourney = window.location.href.includes('marketing-hub/journeys');
+    if (_owner_id === 'all' && !isJourney) {
+        _owner_id = _user_id;
+    }
+    const headers = {
+        'Content-Type': 'application/json; charset=utf-8',
+        token: apiToken,
+    };
+    if (urlHasQueryString(endpoint)) {
+        endpoint += `&portalId=${apiPid}&languageCode=${getUserLocaleLanguage(config)}&_user_id=${_user_id}`;
+    }
+    else {
+        endpoint += `?portalId=${apiPid}&languageCode=${getUserLocaleLanguage(config)}&_user_id=${_user_id}`;
+    }
+    if (isNumeric(_owner_id)) {
+        endpoint += `&_owner_id=${_owner_id}`;
+    }
+    if (endpoint.includes('journey-histories')) {
+        endpoint += `&token=${apiToken}`;
+    }
+    return axios({
+        method,
+        url: `${domain}/${endpoint}`,
+        data: body,
+        headers,
+    }).catch(err => {
+        console.log(err);
+    });
+}
+export function getData(res, def) {
+    if (typeof res !== 'undefined') {
+        const code = parseInt(safeParse(res.data.code, 500));
+        const message = safeParse(res.data.message, '');
+        // if (code === 200) {
+        const data = safeParse(res.data.data, def);
+        return {
+            code,
+            message,
+            data,
+        };
+    }
+    return {
+        code: 500,
+        codeMessage: 'INTERNAL_SERVER_ERROR',
+        message: getMessageByCode('INTERNAL_SERVER_ERROR'),
+        data: def,
+    };
+}
+export function getEntriesV2(res, def) {
+    if (typeof res !== 'undefined') {
+        const code = parseInt(safeParse(res.data.code, 500));
+        const message = safeParse(res.data.message, '');
+        // validateRedirect(code, message);
+        let codeMessage = safeParse(res.data.codeMessage, 'INTERNAL_SERVER_ERROR');
+        let entries = def;
+        if (code === 200) {
+            const data = safeParse(res.data.data, {});
+            entries = safeParse(data.entries, []);
+            codeMessage = 'SUCCESS';
+        }
+        else {
+            const data = safeParse(res.data.data, {});
+            entries = safeParse(data.entries, def);
+        }
+        return {
+            code,
+            codeMessage,
+            // message: getMessageByCode(codeMessage),
+            messageAPI: message,
+            data: entries,
+        };
+    }
+    return {
+        code: 500,
+        codeMessage: 'INTERNAL_SERVER_ERROR',
+        // message: getMessageByCode('INTERNAL_SERVER_ERROR'),
+        data: def,
+    };
+}
+function getCookie(key, config) {
+    throw new Error('Function not implemented.');
+}
+export const getNumberFromString = (str) => {
+    try {
+        return +(str.match(/^-?\d+/) || []).flat()[0];
+    }
+    catch (error) {
+        return 0;
+    }
+};
+/**
+ * Maps a number to its corresponding ordinal text representation.
+ * @param {number} num - The number to be mapped.
+ * @return {string} The ordinal text representation of the number.
+ */
+export function mapNumberToOrdinalText(num) {
+    switch (num) {
+        case 0:
+            return 'zeroth';
+        case 1:
+            return 'first';
+        case 2:
+            return 'second';
+        case 3:
+            return 'third';
+        case 4:
+            return 'fourth';
+        case 5:
+            return 'fifth';
+        case 6:
+            return 'sixth';
+        case 7:
+            return 'seventh';
+        case 8:
+            return 'eighth';
+        case 9:
+            return 'ninth';
+        case 10:
+            return 'tenth';
+        default:
+            return '';
+    }
+}

package/es/utils/handleError.d.ts

@@ -0,0 +1,2 @@
+import { THandleErrorPayload } from '@antscorp/antsomi-ui/es/types';
+export declare const handleError: (error: any, payload: THandleErrorPayload) => void;

package/es/utils/handleError.js

@@ -0,0 +1,6 @@
+export const handleError = (error, payload) => {
+    // eslint-disable-next-line no-console
+    console.log({
+        error: payload,
+    });
+};

package/es/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './color';
+export * from './common';
+export * from './handleError';

package/es/utils/index.js

@@ -0,0 +1,3 @@
+export * from './color';
+export * from './common';
+export * from './handleError';

package/es/utils/loadable.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface Opts {
+    fallback: React.ReactNode;
+}
+type Unpromisify<T> = T extends Promise<infer P> ? P : never;
+export declare const lazyLoad: <T extends Promise<any>, U extends React.ComponentType<any>>(importFunc: () => T, selectorFunc?: ((s: Unpromisify<T>) => U) | undefined, opts?: Opts) => (props: React.ComponentProps<U>) => JSX.Element;
+export {};

package/es/utils/loadable.js

@@ -0,0 +1,10 @@
+import React, { lazy, Suspense } from 'react';
+export const lazyLoad = (importFunc, selectorFunc, opts = { fallback: null }) => {
+    let lazyFactory = importFunc;
+    if (selectorFunc) {
+        lazyFactory = () => importFunc().then(module => ({ default: selectorFunc(module) }));
+    }
+    const LazyComponent = lazy(lazyFactory);
+    return (props) => (React.createElement(Suspense, { fallback: opts.fallback },
+        React.createElement(LazyComponent, Object.assign({}, props))));
+};

package/es/utils/web.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Function to parse search params string to object
+ * @param {string} searchParams - search params
+ * @returns {Record<string, unknown>}
+ */
+export declare const searchPramsToObject: (searchParams?: string) => Record<string, unknown>;
+export declare const getPreventKeyboardAction: (actions?: Array<'undo' | 'copy' | 'paste'>) => {
+    onKeyDown: (e: React.KeyboardEvent | KeyboardEvent) => false | undefined;
+    onKeyUp: (e: React.KeyboardEvent | KeyboardEvent) => void;
+};

package/es/utils/web.js

@@ -0,0 +1,26 @@
+import { VALUE_C, VALUE_CONTROL, VALUE_LEFT_WINDOW, VALUE_V, VALUE_Z, } from '@antscorp/antsomi-ui/es/constants/keyCode';
+/**
+ * Function to parse search params string to object
+ * @param {string} searchParams - search params
+ * @returns {Record<string, unknown>}
+ */
+export const searchPramsToObject = (searchParams = '') => Object.fromEntries(new URLSearchParams(searchParams));
+let ctrlDown = false;
+export const getPreventKeyboardAction = (actions = []) => ({
+    onKeyDown: (e) => {
+        if (e.key === VALUE_CONTROL || e.key === VALUE_LEFT_WINDOW) {
+            ctrlDown = true;
+        }
+        if ((actions.includes('undo') && ctrlDown && e.key === VALUE_Z) ||
+            (actions.includes('copy') && ctrlDown && e.key === VALUE_V) ||
+            (actions.includes('paste') && ctrlDown && e.key === VALUE_C)) {
+            e.preventDefault();
+            return false;
+        }
+    },
+    onKeyUp: (e) => {
+        if (e.key === VALUE_CONTROL || e.key === VALUE_LEFT_WINDOW) {
+            ctrlDown = false;
+        }
+    },
+});