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

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";

package/dist/lib/global.js

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

package/dist/lib/i18n.d.ts

@@ -3,4 +3,5 @@ export declare const i18n: {
     t: (key: string, opts?: Record<string, any>) => string;
     setLocale: (_locale: LocalLng) => void;
 };
+export declare const nsSeparator = "@";
 export {};

package/dist/lib/i18n.js

@@ -32,3 +32,4 @@ export const i18n = {
         locale = _locale;
     },
 };
+export const nsSeparator = '@';

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

@@ -0,0 +1,23 @@
+export declare const polyfillItemTypeIconMap: {
+    BookMark: string;
+    Book: string;
+    Flask: string;
+    Archive: string;
+    EmptyTag: string;
+    Branch: string;
+    Checked: string;
+    Flag: string;
+    LightBulb: string;
+    List: string;
+    Bug: string;
+    Task: string;
+    Signet: string;
+    Risk: string;
+    ManHour: string;
+};
+export declare const takeIconFromUrl: (url: string) => string;
+export declare const useIsIconFont: (url: string) => boolean;
+export declare const isServerUrl: (url: string) => boolean;
+export declare const usePolyFillIcon: (url: string, defaultIconFontType?: string) => [boolean, string];
+export declare const joinIconColorSuffix: (icon: string, colored: boolean) => string;
+export declare const isBase64Img: (str: string) => boolean;

package/dist/lib/icons/utils.js

@@ -0,0 +1,59 @@
+import { useMemo } from 'react';
+import { useGetBasePath } from 'lib/path';
+export const polyfillItemTypeIconMap = {
+    BookMark: 'Issue_Story',
+    Book: 'Issue_Demand',
+    Flask: 'Issue_Test',
+    Archive: 'Issue_Doc',
+    EmptyTag: 'Issue_develop',
+    Branch: 'Issue_Subtask',
+    Checked: 'Issue_Task',
+    Flag: 'Issue_Plan',
+    LightBulb: 'Issue_Idea',
+    List: 'Issue_List',
+    Bug: 'Issue_Bug',
+    Task: 'Issue_Product',
+    Signet: 'Issue_Approval',
+    Risk: 'Issue_Risk',
+    ManHour: 'Issue_Time',
+};
+export const takeIconFromUrl = (url) => {
+    const arr = url.split('/');
+    const last = arr[arr.length - 1];
+    const [icon] = last.split('.');
+    return icon;
+};
+export const useIsIconFont = (url) => {
+    const basePath = useGetBasePath();
+    return !(url.startsWith('/icons') || url.endsWith('.svg') || url.startsWith(basePath) || url.startsWith('/project'));
+};
+export const isServerUrl = (url) => {
+    return url.startsWith('http') || url.startsWith('/parse/files');
+};
+export const usePolyFillIcon = (url, defaultIconFontType) => {
+    const isIconFont = useIsIconFont(url);
+    const data = useMemo(() => {
+        if (!url) {
+            return [false, defaultIconFontType];
+        }
+        if (isServerUrl(url)) {
+            return [true, url];
+        }
+        else {
+            if (isIconFont) {
+                return [false, url];
+            }
+            else {
+                let icon = takeIconFromUrl(url);
+                icon = polyfillItemTypeIconMap[icon] ? polyfillItemTypeIconMap[icon] : icon;
+                return [false, icon || defaultIconFontType];
+            }
+        }
+    }, [defaultIconFontType, isIconFont, url]);
+    return data;
+};
+const SUFFIX = 'B';
+export const joinIconColorSuffix = (icon, colored) => (colored ? `${icon}${SUFFIX}` : icon);
+export const isBase64Img = (str) => {
+    return /^data:image\/(png|jpeg|jpg|gif|svg\+xml);base64,/.test(str);
+};

package/dist/lib/path.d.ts

@@ -0,0 +1,5 @@
+export declare const iconBasePath = "/icons";
+export declare const startsWithIconPath: any;
+export declare const useGetBasePath: () => string;
+export declare const useGetSourcePath: () => (path: string) => string;
+export declare const usePatchIconUrl: () => (path: string) => string;

package/dist/lib/path.js

@@ -0,0 +1,47 @@
+import { useCallback, useContext } from 'react';
+import { startsWith } from 'lodash-es';
+import { TeamConfigContext } from './contexts/teamConfig';
+export const iconBasePath = '/icons';
+export const startsWithIconPath = startsWith(iconBasePath);
+const removeExtraSlash = (paths) => {
+    if (!paths)
+        return '';
+    const isEndsWithSlash = paths.endsWith('/');
+    const isStartsWithSlash = paths.startsWith('/');
+    const result = paths.split('/').filter(Boolean).join('/');
+    return `${isStartsWithSlash ? '/' : ''}${result}${isEndsWithSlash ? '/' : ''}`;
+};
+const mergePath = (path1, path2) => {
+    const paths = [path1, path2].filter(Boolean).join('/');
+    let result = '';
+    try {
+        const urlObj = new URL(paths);
+        urlObj.pathname = removeExtraSlash(urlObj.pathname);
+        result = urlObj.toString();
+    }
+    catch (error) {
+        result = removeExtraSlash(paths);
+    }
+    return result;
+};
+export const useGetBasePath = () => {
+    const { publicRuntimeConfig } = useContext(TeamConfigContext);
+    return (publicRuntimeConfig === null || publicRuntimeConfig === void 0 ? void 0 : publicRuntimeConfig.basePath) || '';
+};
+export const useGetSourcePath = () => {
+    const basePath = useGetBasePath();
+    const getSourcePath = useCallback((path) => {
+        return mergePath(basePath, path);
+    }, [basePath]);
+    return getSourcePath;
+};
+export const usePatchIconUrl = () => {
+    const getSourcePath = useGetSourcePath();
+    const patchIconUrl = useCallback((iconUrl) => {
+        if (startsWithIconPath(iconUrl)) {
+            return getSourcePath(iconUrl);
+        }
+        return iconUrl;
+    }, [getSourcePath]);
+    return patchIconUrl;
+};

package/dist/lib/router.d.ts

@@ -0,0 +1,23 @@
+import { RouterQuery } from './types/models';
+export type IRouteReplace = (url: string | {
+    pathname?: string;
+    query: RouterQuery;
+}, state?: any) => void;
+interface IUserRouterRes {
+    asPath: string;
+    query: {
+        [x: string]: string | string[];
+    };
+    search: {
+        [x: string]: string | string[];
+    };
+    routePath: string;
+    push: (url: string | {
+        pathname?: string;
+        query: RouterQuery;
+    }) => void;
+    replace: IRouteReplace;
+    back: () => void;
+}
+export declare const getCurLocationInfo: () => IUserRouterRes;
+export {};

package/dist/lib/router.js

@@ -0,0 +1,20 @@
+import queryString from 'query-string';
+export const getCurLocationInfo = () => {
+    const { pathname, search } = window.location;
+    const basePath = window.__PROXIMA_BASE_NAME__ || '';
+    const pathWithoutBasePath = basePath !== '/' && pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    const router = {
+        asPath: pathWithoutBasePath + search,
+        query: {
+            ...queryString.parse(search),
+        },
+        search: {
+            ...queryString.parse(search),
+        },
+        routePath: '',
+        push: history.push,
+        replace: history.replace,
+        back: history.back,
+    };
+    return router;
+};

package/dist/lib/storage.d.ts

@@ -0,0 +1,10 @@
+export declare const getLocalStorageItem: (key: string, defaults?: any) => any;
+export declare const setLocalStorageItem: (key: string, value: unknown) => boolean;
+export declare const removeParseItems: () => void;
+declare const _default: {
+    getItem: (key: string, defaults?: any) => any;
+    setItem: (key: string, value: unknown) => boolean;
+    removeParseItems: () => void;
+};
+export default _default;
+export declare const getLocalStorageState: (key: string, fn: () => any) => Promise<any>;