@giteeteam/apps-team-components 1.2.2-alpha.4 → 1.3.0-alpha.1

package/dist/index.js

@@ -12,6 +12,7 @@ export { default as CreatedAtReadView } from './components/fields/created-at/Rea
 export { default as CreatedByReadView } from './components/fields/created-by/ReadView';
 export { default as DataQuoteReadView } from './components/fields/data-quote/ReadView';
 export { default as DateReadView } from './components/fields/date/ReadView';
+export { default as DropdownCell } from './components/fields/dropdown/Cell';
 export { default as DropdownReadView } from './components/fields/dropdown/ReadView';
 export { default as FileReadView } from './components/fields/file/ReadView';
 export { default as FormulaReadView } from './components/fields/formula/ReadView';

package/dist/lib/app/utils.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare const requestIdleCallback: (((callback: IdleRequestCallback, options?: IdleRequestOptions) => number) & typeof globalThis.requestIdleCallback) | ((cb: any) => NodeJS.Timeout);
+export declare const cancelIdleCallback: ((handle: number) => void) & typeof globalThis.cancelIdleCallback;

package/dist/lib/app/utils.js

@@ -0,0 +1,16 @@
+export const requestIdleCallback = (window === null || window === void 0 ? void 0 : window.requestIdleCallback) ||
+    function (cb) {
+        const start = Date.now();
+        return setTimeout(function () {
+            cb({
+                didTimeout: false,
+                timeRemaining: function () {
+                    return Math.max(0, 50 - (Date.now() - start));
+                },
+            });
+        }, 1);
+    };
+export const cancelIdleCallback = (window === null || window === void 0 ? void 0 : window.cancelIdleCallback) ||
+    function (id) {
+        clearTimeout(id);
+    };

package/dist/lib/config.d.ts

@@ -0,0 +1,14 @@
+import { IPublicRuntimeProps, IUserConfig } from '../global';
+export declare const getPublicRuntimeConfig: () => Partial<IPublicRuntimeProps>;
+export declare const getUserConfig: () => Partial<IUserConfig>;
+export declare const publicRuntimeConfig: Partial<IPublicRuntimeProps>;
+export declare const userConfig: Partial<IUserConfig>;
+export type LocalLng = string;
+export declare function getAcceptLanguageHeader(locale: LocalLng): string;
+export declare const getQiankunConfig: () => {
+    gateway: string;
+    appId: string;
+    sessionToken: string;
+    basePath: string;
+    locales: string;
+};

package/dist/lib/config.js

@@ -0,0 +1,45 @@
+export const getPublicRuntimeConfig = () => {
+    var _a;
+    if (typeof window !== 'undefined') {
+        return (_a = window.__PROXIMA_DATA__) === null || _a === void 0 ? void 0 : _a.publicRuntimeConfig;
+    }
+    return {};
+};
+export const getUserConfig = () => {
+    var _a;
+    if (typeof window !== 'undefined') {
+        return (_a = window.__PROXIMA_DATA__) === null || _a === void 0 ? void 0 : _a.userConfig;
+    }
+    return {};
+};
+export const publicRuntimeConfig = getPublicRuntimeConfig() || {};
+export const userConfig = getUserConfig();
+export function getAcceptLanguageHeader(locale) {
+    switch (locale) {
+        case 'zh-CN':
+            return 'zh-CN;q=0.9,zh;q=0.8,en;q=0.7';
+        case 'zh':
+            return 'zh;q=0.8,en;q=0.7';
+        case 'ru-RU':
+            return 'ru-RU;q=0.9,ru;q=0.8,en;q=0.7';
+        case 'ru':
+            return 'ru;q=0.8,en;q=0.7';
+        case 'en-US':
+            return 'en-US,en;q=0.9';
+        case 'en':
+        default:
+            return 'en;q=0.9';
+    }
+}
+export const getQiankunConfig = () => {
+    var _a, _b, _c;
+    const context = (_a = window === null || window === void 0 ? void 0 : window.QiankunProps) === null || _a === void 0 ? void 0 : _a.context;
+    const env = context === null || context === void 0 ? void 0 : context.env;
+    return {
+        gateway: (env === null || env === void 0 ? void 0 : env.PROXIMA_GATEWAY) || '',
+        appId: env === null || env === void 0 ? void 0 : env.PROXIMA_APP_ID,
+        sessionToken: env === null || env === void 0 ? void 0 : env.sessionToken,
+        basePath: env === null || env === void 0 ? void 0 : env.PROXIMA_BASE_PATH,
+        locales: (_c = (_b = env === null || env === void 0 ? void 0 : env.LOCALES) !== null && _b !== void 0 ? _b : process.env.LOCALES) !== null && _c !== void 0 ? _c : 'zh',
+    };
+};

package/dist/lib/constants/code.d.ts

@@ -0,0 +1,4 @@
+export declare const ParseErrorCode: {
+    INVALID_SESSION_TOKEN: number;
+    OBJECT_NOT_FOUND: number;
+};

package/dist/lib/constants/code.js

@@ -0,0 +1,4 @@
+export const ParseErrorCode = {
+    INVALID_SESSION_TOKEN: 209,
+    OBJECT_NOT_FOUND: 101,
+};

package/dist/lib/constants/field.d.ts

@@ -0,0 +1 @@
+export declare const REMOTE_DATA_QUOTE_FIELD_TYPE: string[];

package/dist/lib/constants/field.js

@@ -0,0 +1,2 @@
+import { FIELD_TYPE_KEY_MAPPINGS } from 'lib/global';
+export const REMOTE_DATA_QUOTE_FIELD_TYPE = [FIELD_TYPE_KEY_MAPPINGS.RemoteFieldRemoteDataQuote];

package/dist/lib/contexts/index.js

@@ -11,7 +11,7 @@ import { ItemConfigProvider } from './itemConfig';
 import { TeamConfigProvider } from './teamConfig';
 import { TenantProvider } from './tenant';
 import { WorkflowConfigProvider } from './workflowConfig';
-export const LibraryProvider = ({ getPopupContainer, locale, tenant, datetimeFormat, teamBasePath, teamGateway, isMicroApp, workspaceKey, workflow, item, currentUser, emotionCacheOptions, children, }) => {
+export const LibraryProvider = ({ getPopupContainer, locale, tenant, datetimeFormat, teamBasePath, teamGateway, isMicroApp, publicRuntimeConfig, userConfig, workspaceKey, workflow, item, currentUser, emotionCacheOptions, children, }) => {
     const emotionCache = useMemo(() => {
         return createCache({
             key: 'apps',
@@ -21,5 +21,5 @@ export const LibraryProvider = ({ getPopupContainer, locale, tenant, datetimeFor
     useEffect(() => {
         i18n.setLocale(locale);
     }, [locale]);
-    return (_jsx(CacheProvider, { value: emotionCache, children: _jsx(AntdConfigProvider, { getPopupContainer: getPopupContainer, children: _jsx(TeamConfigProvider, { teamBasePath: teamBasePath, teamGateway: teamGateway, isMicroApp: isMicroApp, children: _jsx(TenantProvider, { tenant: tenant, children: _jsx(CurrentWorkspaceProvider, { workspaceKey: workspaceKey, children: _jsx(DatetimeFormatProvider, { datetimeFormat: datetimeFormat, children: _jsx(CurrentUserProvider, { currentUser: currentUser, children: _jsx(WorkflowConfigProvider, { workflow: workflow, children: _jsx(ItemConfigProvider, { item: item, children: children }) }) }) }) }) }) }) }) }));
+    return (_jsx(CacheProvider, { value: emotionCache, children: _jsx(AntdConfigProvider, { getPopupContainer: getPopupContainer, children: _jsx(TeamConfigProvider, { teamBasePath: teamBasePath, teamGateway: teamGateway, isMicroApp: isMicroApp, publicRuntimeConfig: publicRuntimeConfig, userConfig: userConfig, children: _jsx(TenantProvider, { tenant: tenant, children: _jsx(CurrentWorkspaceProvider, { workspaceKey: workspaceKey, children: _jsx(DatetimeFormatProvider, { datetimeFormat: datetimeFormat, children: _jsx(CurrentUserProvider, { currentUser: currentUser, children: _jsx(WorkflowConfigProvider, { workflow: workflow, children: _jsx(ItemConfigProvider, { item: item, children: children }) }) }) }) }) }) }) }) }));
 };

package/dist/lib/contexts/teamConfig.d.ts

@@ -1,8 +1,11 @@
 import React from 'react';
+import { IPublicRuntimeProps, IUserConfig } from '../../global';
 export interface ITeamConfigContext {
     teamGateway?: string;
     teamBasePath?: string;
     isMicroApp?: boolean;
+    publicRuntimeConfig?: Partial<IPublicRuntimeProps>;
+    userConfig?: Partial<IUserConfig>;
 }
 export declare const TeamConfigContext: React.Context<ITeamConfigContext>;
 export interface TeamConfigProviderProps extends React.PropsWithChildren, ITeamConfigContext {

package/dist/lib/contexts/teamConfig.js

@@ -1,11 +1,26 @@
 import { jsx as _jsx } from "@emotion/react/jsx-runtime";
-import { createContext } from 'react';
+import { createContext, useMemo } from 'react';
+import { getPublicRuntimeConfig, getQiankunConfig, getUserConfig } from 'lib/config';
 const defaultContext = {};
 export const TeamConfigContext = createContext(defaultContext);
-export const TeamConfigProvider = ({ teamGateway, teamBasePath, isMicroApp, children, }) => {
+export const TeamConfigProvider = ({ teamGateway, teamBasePath, isMicroApp, children, publicRuntimeConfig, userConfig, }) => {
+    const runtimeConfig = useMemo(() => {
+        const config = { ...getQiankunConfig(), ...getPublicRuntimeConfig(), ...(publicRuntimeConfig || {}) };
+        if (teamGateway) {
+            config.gateway = teamGateway;
+        }
+        if (teamBasePath) {
+            config.basePath = teamBasePath;
+        }
+        return config;
+    }, [publicRuntimeConfig, teamBasePath, teamGateway]);
+    const _userConfig = useMemo(() => {
+        const config = { ...getUserConfig(), ...(userConfig || {}) };
+        return config;
+    }, [userConfig]);
     return (_jsx(TeamConfigContext.Provider, { value: {
-            teamGateway,
-            teamBasePath,
             isMicroApp,
+            publicRuntimeConfig: runtimeConfig,
+            userConfig: _userConfig,
         }, children: children }));
 };

package/dist/lib/error/index.d.ts

@@ -0,0 +1,2 @@
+export { ErrorLog, default as log } from './log';
+export * from './utils';

package/dist/lib/error/index.js

@@ -0,0 +1,2 @@
+export { ErrorLog, default as log } from './log';
+export * from './utils';

package/dist/lib/error/log.d.ts

@@ -0,0 +1,10 @@
+type ErrorLogOptions = {
+    timeout?: number;
+};
+export declare class ErrorLog {
+    private showError;
+    constructor(options?: ErrorLogOptions);
+    show: (msg: string) => void;
+}
+declare const _default: ErrorLog;
+export default _default;

package/dist/lib/error/log.js

@@ -0,0 +1,25 @@
+import { message } from 'antd';
+import debug from 'debug';
+import { throttle } from 'lodash-es';
+import { isChinese } from 'components/common/utils';
+import { i18n, nsSeparator } from 'lib/i18n';
+const logger = debug('lib:error');
+export class ErrorLog {
+    constructor(options) {
+        this.show = (msg) => {
+            logger('errorMessage', msg);
+            this.showError(msg);
+        };
+        const { timeout = 1000 } = options || {};
+        this.showError = throttle(msg => {
+            if (isChinese(msg) || msg.includes(nsSeparator)) {
+                message.error(msg);
+                return;
+            }
+            const MsgSet = i18n.t(`libs.error.MsgSet.${msg}`);
+            const errorMessage = (MsgSet === null || MsgSet === void 0 ? void 0 : MsgSet.includes('libs.error.MsgSet.')) ? msg : MsgSet;
+            message.error(errorMessage);
+        }, timeout, { trailing: false });
+    }
+}
+export default new ErrorLog();

package/dist/lib/error/utils.d.ts

@@ -0,0 +1,14 @@
+export declare const LOGIN_PAGE_URL = "/login";
+export declare const REDIRECT_API = "/frame";
+type ErrorData = any;
+export type ErrorResponse = any;
+type GetErrorMessageHandler = (errorData: ErrorData, defaultMessage?: string) => string;
+export declare const getRedirectURI: (errorPageURL: string | URL, baseAPI?: string) => string;
+export declare const getRedirectURL: (redirectConfig: {
+    enabled: 'true' | 'false' | undefined;
+}, errorPageURL: string | URL) => string;
+export declare const getKeycloakErrorMsg: GetErrorMessageHandler;
+export declare const getParseErrorMsg: GetErrorMessageHandler;
+export declare const getNormalErrorMsg: GetErrorMessageHandler;
+export declare const getErrorMessage: GetErrorMessageHandler;
+export {};

package/dist/lib/error/utils.js

@@ -0,0 +1,50 @@
+import { isEmpty } from 'lodash-es';
+export const LOGIN_PAGE_URL = '/login';
+export const REDIRECT_API = '/frame';
+export const getRedirectURI = (errorPageURL, baseAPI = LOGIN_PAGE_URL) => {
+    const redirectApi = new URL(baseAPI, errorPageURL);
+    redirectApi.searchParams.append('redirect_uri', errorPageURL);
+    return encodeURIComponent(redirectApi.toString());
+};
+export const getRedirectURL = (redirectConfig, errorPageURL) => {
+    if (isEmpty(redirectConfig))
+        return LOGIN_PAGE_URL;
+    if ((redirectConfig === null || redirectConfig === void 0 ? void 0 : redirectConfig.enabled) !== 'true')
+        return LOGIN_PAGE_URL;
+    const redirectUri = getRedirectURI(errorPageURL);
+    return redirectUri;
+};
+export const getKeycloakErrorMsg = errorData => {
+    if (!(errorData === null || errorData === void 0 ? void 0 : errorData.error_description) || !(errorData === null || errorData === void 0 ? void 0 : errorData.error))
+        return null;
+    return `${errorData.error}: ${errorData.error_description}`;
+};
+export const getParseErrorMsg = errorData => {
+    if (!(errorData === null || errorData === void 0 ? void 0 : errorData.code) || !(errorData === null || errorData === void 0 ? void 0 : errorData.error))
+        return null;
+    if ('string' === typeof errorData.error) {
+        return errorData.error;
+    }
+    else {
+        let msg;
+        try {
+            msg = JSON.stringify(errorData.error, null, 2);
+        }
+        catch (error) {
+            console.warn('parse error fail, source error', errorData);
+        }
+        if (msg)
+            return msg;
+        return null;
+    }
+};
+export const getNormalErrorMsg = errorData => 'string' === typeof errorData ? errorData : null;
+export const getErrorMessage = (errorData, defaultMsg = '请求失败.') => {
+    const errorMessage = getNormalErrorMsg(errorData) ||
+        (errorData === null || errorData === void 0 ? void 0 : errorData.message) ||
+        (errorData === null || errorData === void 0 ? void 0 : errorData.error) ||
+        getKeycloakErrorMsg(errorData) ||
+        getParseErrorMsg(errorData) ||
+        defaultMsg;
+    return errorMessage;
+};

package/dist/lib/error/withServerError.d.ts

@@ -0,0 +1 @@
+export declare const IGNORE_URL: string[];

package/dist/lib/error/withServerError.js

@@ -0,0 +1 @@
+export const IGNORE_URL = ['/', '/login', '/register', '/resetPassword', '/configuration-guide', '/reset-config'];

package/dist/lib/fetch.d.ts

@@ -0,0 +1,45 @@
+import { AxiosInstance, AxiosRequestConfig } from 'axios';
+export type WrapperAxiosRequestConfig<T = any> = AxiosRequestConfig<T> & {
+    useJson?: boolean;
+    useCompress?: boolean;
+    useJsonDecompress?: boolean;
+    hiddenErrorModal?: boolean;
+    ignoreParseHeaders?: boolean;
+    hiddenTimeout?: boolean;
+};
+export interface IFetchInstance extends AxiosInstance {
+    $get<T = any, P = any>(url: string, config?: {
+        params?: P;
+    } & Omit<WrapperAxiosRequestConfig, 'params'>): Promise<T>;
+    $delete<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    $head<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    $options<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    $post<T = any>(url: string, data?: any, config?: WrapperAxiosRequestConfig): Promise<T>;
+    $put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    $patch<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+}
+export declare const useGetConfigTimeout: () => number;
+export declare const baseApi = "/parse/api";
+export declare const useGetLoginBasePath: () => string;
+export declare const useGetServerGateway: () => string;
+export declare const useGetGateway: (extraPath?: string) => string;
+interface GetConfigParams {
+    sessionToken: string;
+    tenant: string;
+    Cookie: string;
+}
+interface ConfigType {
+    baseURL: string;
+    headers: {
+        'X-Parse-Session-Token': string;
+        'X-Parse-Application-Id': string;
+        Cookie: string;
+    };
+}
+export declare function useGetRequestConfig({ sessionToken, tenant, Cookie }: GetConfigParams): ConfigType;
+export declare const useAxiosConfig: () => AxiosRequestConfig;
+export declare const LOCALE_KEY = "lang";
+export declare const useGetHeaderLang: () => string;
+export declare const getGlobalEnv: () => Record<string, any>;
+declare const useFetch: () => IFetchInstance;
+export default useFetch;

package/dist/lib/fetch.js

@@ -0,0 +1,301 @@
+import { useCallback, useContext, useEffect, useMemo } from 'react';
+import axios, { HttpStatusCode } from 'axios';
+import cjson from 'compressed-json';
+import debug from 'debug';
+import { toNumber } from 'lodash-es';
+import { CANCEL_FETCH_STRING, REDIRECT_URL_KEY } from 'lib/global';
+import throttleWithCache, { THROTTLE_TYPE } from 'lib/swr/throttleWithCache';
+import { ParseErrorCode } from './constants/code';
+import { TeamConfigContext } from './contexts/teamConfig';
+import { IGNORE_URL } from './error/withServerError';
+import { getErrorMessage, log as ErrorLog } from './error';
+import { i18n } from './i18n';
+import isInOne from './isInOne';
+import { useGetSourcePath } from './path';
+import { getCurLocationInfo } from './router';
+import { removeParseItems } from './storage';
+import { useAppProps } from './useConfig';
+const Blob = window.Blob;
+const isDev = process.env.NODE_ENV === 'development';
+const DEFAULT_TIMEOUT = 15 * 1000;
+export const useGetConfigTimeout = () => {
+    const { publicRuntimeConfig = {} } = useContext(TeamConfigContext);
+    const { globalFetchTimeout } = publicRuntimeConfig;
+    return toNumber(globalFetchTimeout) || DEFAULT_TIMEOUT;
+};
+export const baseApi = '/parse/api';
+export const useGetLoginBasePath = () => {
+    const { publicRuntimeConfig = {} } = useContext(TeamConfigContext);
+    const basePath = useMemo(() => {
+        const { basePath = '' } = publicRuntimeConfig;
+        if (isDev)
+            return basePath;
+        return '';
+    }, [publicRuntimeConfig]);
+    return basePath;
+};
+export const useGetServerGateway = () => {
+    const { publicRuntimeConfig } = useContext(TeamConfigContext);
+    return (publicRuntimeConfig === null || publicRuntimeConfig === void 0 ? void 0 : publicRuntimeConfig.gateway) || '';
+};
+export const useGetGateway = (extraPath = '') => {
+    const gateway = useGetServerGateway();
+    const result = useMemo(() => {
+        const inOne = isInOne(gateway);
+        if (!gateway)
+            return inOne ? '' : extraPath;
+        if (inOne)
+            return gateway;
+        return extraPath;
+    }, [extraPath, gateway]);
+    return result;
+};
+export function useGetRequestConfig({ sessionToken, tenant, Cookie }) {
+    const gateway = useGetServerGateway();
+    const baseURL = useMemo(() => {
+        return `${gateway}${baseApi}`;
+    }, [gateway]);
+    return {
+        baseURL,
+        headers: {
+            'X-Parse-Session-Token': sessionToken,
+            'X-Parse-Application-Id': tenant,
+            ...(Cookie && {
+                Cookie,
+            }),
+        },
+    };
+}
+export const useAxiosConfig = () => {
+    const gateway = useGetGateway();
+    const baseURL = useMemo(() => {
+        return `${gateway}${baseApi}`;
+    }, [gateway]);
+    const defaultTimeout = useGetConfigTimeout();
+    return {
+        baseURL,
+        timeout: defaultTimeout,
+    };
+};
+const errorLog = msg => {
+    return ErrorLog.show(msg);
+};
+export const LOCALE_KEY = 'lang';
+export const useGetHeaderLang = () => {
+    const { locale } = useAppProps();
+    return locale;
+};
+export const getGlobalEnv = () => {
+    return window.env || {};
+};
+const checkLog = debug('lib:fetch:checkSessionToken');
+const NO_SESSION_KEY = 'sessionToken is required';
+const CHECK_WHITE_LIST = [
+    '/api/auth/demo/login',
+    '/api/auth/login',
+    '/api/auth/logout',
+    '/api/auth/code',
+    '/api/license/serviceId',
+    '/api/license/register',
+    '/api/license/status',
+    '/api/auth/install/addAdminUser',
+    '/submit/',
+    '/api/license/licenseInfo',
+];
+function checkSessionToken(config) {
+    checkLog('......checkSessionToken', config.headers['X-Parse-Session-Token'], !!config.headers['X-Parse-Session-Token'], config.url, config.baseURL);
+    if (!config.baseURL) {
+        return;
+    }
+    if (config.baseURL.endsWith('apps/api'))
+        return;
+    if (CHECK_WHITE_LIST.includes(config.url))
+        return;
+    const hasToken = config.headers['X-Parse-Session-Token'] != null;
+    if (!hasToken) {
+        throw new Error(NO_SESSION_KEY, { cause: config.url });
+    }
+}
+const useRedirectToLogin = () => {
+    const { publicRuntimeConfig = {} } = useContext(TeamConfigContext);
+    const router = getCurLocationInfo();
+    const getSourcePath = useGetSourcePath();
+    const redirectToLogin = useCallback((_error, _form) => {
+        checkLog('......redirectToLogin', _error, _form);
+        if (publicRuntimeConfig.disableRedirect) {
+            return;
+        }
+        if (!IGNORE_URL.includes(router.asPath)) {
+            const redirectURL = getSourcePath(router.asPath);
+            const loginURL = getSourcePath('/login');
+            console.info('..........currentPath', redirectURL, loginURL);
+            removeParseItems();
+            localStorage.setItem(REDIRECT_URL_KEY, redirectURL);
+            window.location.href = loginURL;
+        }
+    }, [getSourcePath, publicRuntimeConfig.disableRedirect, router.asPath]);
+    return redirectToLogin;
+};
+const useRequestInterceptors = () => {
+    const { sessionToken, locale, appId } = useAppProps();
+    const requestInterceptors = useCallback(config => {
+        if (!config.ignoreParseHeaders) {
+            if (!config.headers)
+                config.headers = {};
+            if (!config.headers['X-Parse-Application-Id']) {
+                config.headers['X-Parse-Application-Id'] = appId;
+            }
+            if (config.headers['X-Parse-Session-Token'] == null && sessionToken) {
+                config.headers['X-Parse-Session-Token'] = sessionToken;
+            }
+        }
+        if (Object.hasOwnProperty.call(config.headers, 'Cookie') && !config.headers.Cookie) {
+            delete config.headers.Cookie;
+        }
+        if (Object.hasOwnProperty.call(config.headers, 'cookie') && !config.headers.cookie) {
+            delete config.headers.cookie;
+        }
+        const parseHeaderLang = locale;
+        if (parseHeaderLang && !config.headers['Accept-Language']) {
+            config.headers['Accept-Language'] = parseHeaderLang;
+        }
+        if (config.useCompress) {
+            config.headers['x-has-compression'] = 'true';
+        }
+        if (config.useJsonDecompress) {
+            config.headers['x-has-json-compression'] = 'true';
+        }
+        checkSessionToken(config);
+        return config;
+    }, [appId, locale, sessionToken]);
+    return requestInterceptors;
+};
+const useAddResponseInterceptors = (fetch) => {
+    const { publicRuntimeConfig } = useContext(TeamConfigContext);
+    const redirectToLogin = useRedirectToLogin();
+    useEffect(() => {
+        fetch.interceptors.response.use((response) => {
+            if (response.status >= 200 && response.status <= 300) {
+                return Promise.resolve(response);
+            }
+            else {
+                return Promise.reject(response);
+            }
+        }, async (error) => {
+            var _a;
+            console.error('[$fetch] response ERROR', error);
+            const { showTimeoutMessage: showTimeout } = publicRuntimeConfig;
+            const { hiddenErrorModal, hiddenTimeout } = error.config || {};
+            const inOne = isInOne();
+            if (error.code === 'ECONNREFUSED') {
+                errorLog(i18n.t('apis.error.refused'));
+            }
+            else if (error.code === 'ECONNABORTED') {
+                !hiddenTimeout && showTimeout && errorLog(i18n.t('apis.error.timeout'));
+                return Promise.reject('timeout');
+            }
+            else if (error.code === 'ERR_CANCELED') {
+                console.info('request canceled', error.message);
+                return Promise.reject('canceled');
+            }
+            else if (error.code === 'ERR_BAD_REQUEST' && HttpStatusCode.PayloadTooLarge === ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status)) {
+                errorLog(i18n.t('apis.error.payloadTooLarge'));
+                return Promise.reject(error.response.statusText);
+            }
+            else if (error.response) {
+                if (error.response.status) {
+                    let errorData = error.response.data;
+                    if (error.response.data instanceof Blob) {
+                        errorData = await new Response(error.response.data).json();
+                    }
+                    if (typeof errorData === 'object') {
+                        if (!inOne && errorData.code === ParseErrorCode.INVALID_SESSION_TOKEN) {
+                            redirectToLogin(error, errorData.message);
+                            return Promise.reject(error.response);
+                        }
+                        const errorMessage = getErrorMessage(errorData, i18n.t('apis.error.responseError', { dot: '.' }));
+                        !hiddenErrorModal && errorLog(errorMessage);
+                    }
+                    else {
+                        !hiddenErrorModal && errorLog(errorData || i18n.t('apis.error.responseError', { dot: '' }));
+                    }
+                    return Promise.reject(error.response);
+                }
+            }
+            else {
+                if (!inOne && (error === null || error === void 0 ? void 0 : error.message) === NO_SESSION_KEY) {
+                    redirectToLogin(error, NO_SESSION_KEY);
+                }
+                else if ((error === null || error === void 0 ? void 0 : error.message) !== CANCEL_FETCH_STRING) {
+                    errorLog(error.message);
+                }
+                else if (axios.isCancel(error)) {
+                    console.info('.........is cancel', error);
+                }
+                return Promise.reject(error);
+            }
+        });
+    }, [fetch.interceptors.response, publicRuntimeConfig, redirectToLogin]);
+};
+const $fetch = async (method, url, ...args) => {
+    if (!url) {
+        return;
+    }
+    const toSuccessData = response => {
+        var _a, _b;
+        const requestConfig = (args[0] || {});
+        const { useJson, useJsonDecompress } = requestConfig;
+        if (useJson) {
+            if (response.data.code !== 0) {
+                return Promise.reject(response.data);
+            }
+            else {
+                if (useJsonDecompress) {
+                    return cjson.decompress((_a = response.data) === null || _a === void 0 ? void 0 : _a.payload);
+                }
+                else {
+                    return (_b = response.data) === null || _b === void 0 ? void 0 : _b.payload;
+                }
+            }
+        }
+        return response.data;
+    };
+    const response = await throttleWithCache({
+        type: THROTTLE_TYPE.CUSTOM_FETCH,
+        params: {
+            url,
+            args,
+        },
+        fn: () => {
+            return fetch[method](url, ...args);
+        },
+        method,
+    });
+    return toSuccessData(response);
+};
+const setFetchInstance = (config) => {
+    const fetch = axios.create(config);
+    fetch.$get = async (...args) => $fetch('get', ...args);
+    fetch.$post = async (...args) => $fetch('post', ...args);
+    fetch.$delete = async (...args) => $fetch('delete', ...args);
+    fetch.$put = async (...args) => $fetch('put', ...args);
+    fetch.$patch = async (...args) => $fetch('patch', ...args);
+    fetch.$head = async (...args) => $fetch('head', ...args);
+    fetch.$options = async (...args) => $fetch('options', ...args);
+    return fetch;
+};
+const useFetch = () => {
+    const config = useAxiosConfig();
+    const requestInterceptors = useRequestInterceptors();
+    const fetch = useMemo(() => {
+        const fetch = setFetchInstance(config);
+        fetch.interceptors.request.use(requestInterceptors, error => {
+            console.error('[$fetch] request ERROR', error);
+            return Promise.reject(error);
+        });
+        return fetch;
+    }, [config, requestInterceptors]);
+    useAddResponseInterceptors(fetch);
+    return fetch;
+};
+export default useFetch;

package/dist/lib/global.d.ts

@@ -101,3 +101,21 @@ export declare const CustomFieldComponentTypes: {
     Radio: string;
     Checkbox: string;
 };
+export declare const BASE_FIELD_WIDTH = 104;
+export declare const CURRENT_WORKSPACE = "currentWorkspace()";
+export declare const FIELD_CONTAINERS_PAGE: {
+    readonly DETAIL: "detail";
+    readonly MODAL: "modal";
+    readonly DRAWER: "drawer";
+    readonly FILTER: "filter";
+    readonly SCREEN: "screen";
+    readonly AUTOMATION_FIELD: "automation_field";
+    readonly VIEW_MODAL: "view_modal";
+};
+export declare const SCREEN_TYPE: {
+    readonly View: "view";
+    readonly Create: "create";
+    readonly Edit: "edit";
+};
+export declare const CANCEL_FETCH_STRING = "cancel_fetch_string";
+export declare const REDIRECT_URL_KEY = "team_redirect_url";