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

package/dist/lib/i18n.js

@@ -1,4 +1,5 @@
-import { en, ru, zh } from '../locales';
+import { zh, ru, en } from '../locales/index.js';
+
 let locale = 'zh';
 const getTranslate = () => {
     switch (locale) {
@@ -15,7 +16,7 @@ const getTranslate = () => {
             return zh;
     }
 };
-export const i18n = {
+const i18n = {
     t: (key, opts) => {
         var _a;
         const translate = getTranslate();
@@ -32,3 +33,6 @@ export const i18n = {
         locale = _locale;
     },
 };
+const nsSeparator = '@';
+
+export { i18n, 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,60 @@
+import { useMemo } from 'react';
+import { useGetBasePath } from '../path.js';
+
+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',
+};
+const takeIconFromUrl = (url) => {
+    const arr = url.split('/');
+    const last = arr[arr.length - 1];
+    const [icon] = last.split('.');
+    return icon;
+};
+const useIsIconFont = (url) => {
+    const basePath = useGetBasePath();
+    return !(url.startsWith('/icons') || url.endsWith('.svg') || url.startsWith(basePath) || url.startsWith('/project'));
+};
+const isServerUrl = (url) => {
+    return url.startsWith('http') || url.startsWith('/parse/files');
+};
+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 isBase64Img = (str) => {
+    return /^data:image\/(png|jpeg|jpg|gif|svg\+xml);base64,/.test(str);
+};
+
+export { isBase64Img, isServerUrl, polyfillItemTypeIconMap, takeIconFromUrl, useIsIconFont, usePolyFillIcon };

package/dist/lib/isInOne.js

@@ -11,4 +11,5 @@ const isInOne = (gateway, isMicroApp) => {
         return gateway.startsWith('/api');
     }
 };
-export default isInOne;
+
+export { isInOne as default };

package/dist/lib/number.js

@@ -1,3 +1,5 @@
-export const numberPrecisionInit = (value, precision) => {
+const numberPrecisionInit = (value, precision) => {
     return Math.round(value * Math.pow(10, precision)) / Math.pow(10, precision);
 };
+
+export { numberPrecisionInit };

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,50 @@
+import { useCallback, useContext } from 'react';
+import { startsWith } from 'lodash-es';
+import { TeamConfigContext } from './contexts/teamConfig.js';
+
+const iconBasePath = '/icons';
+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;
+};
+const useGetBasePath = () => {
+    const { publicRuntimeConfig } = useContext(TeamConfigContext);
+    return (publicRuntimeConfig === null || publicRuntimeConfig === void 0 ? void 0 : publicRuntimeConfig.basePath) || '';
+};
+const useGetSourcePath = () => {
+    const basePath = useGetBasePath();
+    const getSourcePath = useCallback((path) => {
+        return mergePath(basePath, path);
+    }, [basePath]);
+    return getSourcePath;
+};
+const usePatchIconUrl = () => {
+    const getSourcePath = useGetSourcePath();
+    const patchIconUrl = useCallback((iconUrl) => {
+        if (startsWithIconPath(iconUrl)) {
+            return getSourcePath(iconUrl);
+        }
+        return iconUrl;
+    }, [getSourcePath]);
+    return patchIconUrl;
+};
+
+export { iconBasePath, startsWithIconPath, useGetBasePath, useGetSourcePath, usePatchIconUrl };

package/dist/lib/regExp.js

@@ -1 +1,3 @@
-export const REG_EN_NUMBER = /^[A-Za-z0-9]+$/;
+const REG_EN_NUMBER = /^[A-Za-z0-9]+$/;
+
+export { REG_EN_NUMBER };

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,23 @@
+import queryString from 'query-string';
+
+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;
+};
+
+export { getCurLocationInfo };

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

package/dist/lib/storage.js

@@ -0,0 +1,27 @@
+const getLocalStorageItem = (key, defaults = '') => {
+    let item;
+    try {
+        item = localStorage.getItem(key);
+        return (item && JSON.parse(item)) || defaults;
+    }
+    catch (e) {
+        return item !== null && item !== void 0 ? item : defaults;
+    }
+};
+const getStorageKeys = () => {
+    return Object.keys(localStorage);
+};
+const removeParseItems = () => {
+    try {
+        const keys = getStorageKeys();
+        const parseKeys = keys.filter(fieldKey => fieldKey.startsWith('Parse/') && fieldKey.endsWith('/currentUser'));
+        parseKeys.forEach(paresKey => {
+            localStorage.removeItem(paresKey);
+        });
+    }
+    catch (error) {
+        console.error('removeParseItems', error);
+    }
+};
+
+export { getLocalStorageItem, removeParseItems };

package/dist/lib/store/dataQuoteStore.js

@@ -1,9 +1,12 @@
 import { atom } from 'recoil';
-export const dataQuoteState = atom({
+
+const dataQuoteState = atom({
     key: 'dataQuoteState',
     default: [],
 });
-export const currentDeleteState = atom({
+const currentDeleteState = atom({
     key: 'currentDeleteState',
     default: '',
 });
+
+export { currentDeleteState, dataQuoteState };

package/dist/lib/swr/constants.js

@@ -1,4 +1,4 @@
-export var API_KEY;
+var API_KEY;
 (function (API_KEY) {
     API_KEY["GET_SEARCH_ITEM_GROUP"] = "GET_SEARCH_ITEM_GROUP";
     API_KEY["GET_SEARCH_ITEM_TYPE"] = "GET_SEARCH_ITEM_TYPE";
@@ -24,9 +24,11 @@ export var API_KEY;
     API_KEY["GET_TABLE_DEMO_CUSTOM_FIELDS"] = "GET_TABLE_DEMO_CUSTOM_FIELDS";
     API_KEY["GET_SETTINGS_FIELDS_LIST"] = "GET_SETTINGS_FIELDS_LIST";
 })(API_KEY || (API_KEY = {}));
-export var FetchCustomFieldTypeBySchemeType;
+var FetchCustomFieldTypeBySchemeType;
 (function (FetchCustomFieldTypeBySchemeType) {
     FetchCustomFieldTypeBySchemeType["table"] = "tableView";
     FetchCustomFieldTypeBySchemeType["criteriaList"] = "criteriaList";
     FetchCustomFieldTypeBySchemeType["default"] = "default";
 })(FetchCustomFieldTypeBySchemeType || (FetchCustomFieldTypeBySchemeType = {}));
+
+export { API_KEY, FetchCustomFieldTypeBySchemeType };

package/dist/lib/swr/hooks.js

@@ -1,7 +1,8 @@
 import useSWR from 'swr';
-import useItemConfig from '../hooks/useItemConfig';
-import { API_KEY } from './constants';
-export const useFetchItemById = ({ id, disable = false, detail, }) => {
+import useItemConfig from '../hooks/useItemConfig.js';
+import { API_KEY } from './constants.js';
+
+const useFetchItemById = ({ id, disable = false, detail, }) => {
     const { fetchItemById } = useItemConfig();
     const res = useSWR(!disable && id && [API_KEY.GET_ITEM_BY_ID, id], async () => {
         let result;
@@ -12,3 +13,5 @@ export const useFetchItemById = ({ id, disable = false, detail, }) => {
     });
     return res;
 };
+
+export { useFetchItemById };

package/dist/lib/swr/throttleWithCache.d.ts

@@ -0,0 +1,17 @@
+export declare const DISABLE_THROTTLE_API_FETCH = "DISABLE_THROTTLE_API_FETCH";
+declare const throttleWithCache: ({ type, params, fn, method, }: {
+    type: THROTTLE_TYPE;
+    params: unknown;
+    fn: () => Promise<any>;
+    method?: string;
+}) => Promise<any>;
+export declare enum THROTTLE_TYPE {
+    PLUGIN_RESOURCE_FETCH = "PLUGIN_RESOURCE_FETCH",
+    QUERY_FETCH = "QUERY_FETCH",
+    CUSTOM_FETCH = "CUSTOM_FETCH"
+}
+export declare const createKeyByParams: ({ type, params }: {
+    type: THROTTLE_TYPE;
+    params: any;
+}) => string;
+export default throttleWithCache;

package/dist/lib/swr/throttleWithCache.js

@@ -0,0 +1,110 @@
+import debug from 'debug';
+import { getLocalStorageItem } from '../storage.js';
+
+const DISABLE_THROTTLE_API_FETCH = 'DISABLE_THROTTLE_API_FETCH';
+const log = debug('repeat-api');
+const disableThrottle = !!getLocalStorageItem(DISABLE_THROTTLE_API_FETCH) || false;
+let cacheKeys = [];
+let results = [];
+let resolves = [];
+const THROTTLE_TIME = 3000;
+let postPending = false;
+let postPendingTime = 0;
+const refreshCache = () => {
+    const dirtyIds = [];
+    cacheKeys.forEach(item => {
+        if (Date.now() - item.time > THROTTLE_TIME) {
+            dirtyIds.push(item.id);
+        }
+    });
+    cacheKeys = cacheKeys.filter(item => !dirtyIds.includes(item.id));
+    results = results.filter(item => !dirtyIds.includes(item.id));
+    resolves = resolves.filter(item => !dirtyIds.includes(item.id));
+};
+const refreshPostPending = () => {
+    if (postPending) {
+        const curTime = Date.now();
+        if (curTime - postPendingTime > THROTTLE_TIME) {
+            postPending = false;
+        }
+    }
+};
+const throttleWithCache = ({ type, params, fn, method, }) => {
+    if (disableThrottle) {
+        return fn();
+    }
+    const key = createKeyByParams({ type, params });
+    refreshCache();
+    refreshPostPending();
+    if (postPending) {
+        return fn();
+    }
+    const _method = String(method).toLowerCase();
+    if (_method !== 'get') {
+        postPending = true;
+        postPendingTime = +new Date();
+        return fn();
+    }
+    return new Promise((resolve, reject) => {
+        var _a;
+        const findItem = cacheKeys.find(item => item.key === key && +new Date() - item.time < THROTTLE_TIME);
+        if (findItem) {
+            try {
+                const getStackTrace = (limitFrames = 50) => {
+                    const obj = { stack: '' };
+                    const stackTraceLimit = Error.stackTraceLimit;
+                    Error.stackTraceLimit = stackTraceLimit < limitFrames ? limitFrames : stackTraceLimit;
+                    Error.captureStackTrace(obj, getStackTrace);
+                    Error.stackTraceLimit = stackTraceLimit;
+                    return obj.stack.split('\n');
+                };
+                const stackFrames = getStackTrace();
+                log('stackFrame', stackFrames, key);
+            }
+            catch (e) {
+                console.error(e);
+            }
+            const result = (_a = results.find(item => item.key === findItem.key)) === null || _a === void 0 ? void 0 : _a.data;
+            if (result) {
+                resolve(result);
+            }
+            else {
+                resolves.push({
+                    key: findItem.key,
+                    resolve,
+                    id: findItem.id,
+                });
+            }
+        }
+        else {
+            const curTime = +new Date();
+            cacheKeys.push({ key, time: curTime, id: `${key}${curTime}` });
+            fn()
+                .then(res => {
+                results.push({ key, data: res, id: `${key}${curTime}` });
+                resolve(res);
+                resolves.forEach(item => {
+                    if (item.key === key) {
+                        item.resolve(res);
+                    }
+                });
+            })
+                .catch(_error => {
+                reject(_error);
+            });
+        }
+    });
+};
+var THROTTLE_TYPE;
+(function (THROTTLE_TYPE) {
+    THROTTLE_TYPE["PLUGIN_RESOURCE_FETCH"] = "PLUGIN_RESOURCE_FETCH";
+    THROTTLE_TYPE["QUERY_FETCH"] = "QUERY_FETCH";
+    THROTTLE_TYPE["CUSTOM_FETCH"] = "CUSTOM_FETCH";
+})(THROTTLE_TYPE || (THROTTLE_TYPE = {}));
+const createKeyByParams = ({ type, params }) => {
+    if (!params)
+        return `${+new Date()}`;
+    return `${type}_${JSON.stringify(params)}`;
+};
+
+export { DISABLE_THROTTLE_API_FETCH, THROTTLE_TYPE, createKeyByParams, throttleWithCache as default };

package/dist/lib/throttleFetch.d.ts

@@ -0,0 +1,2 @@
+export declare const generateHash: (content: any) => string;
+export declare function throttleFetch<Key = any, Data = any>(key: Key, fetcher: () => Promise<Data>): Promise<Data>;

package/dist/lib/throttleFetch.js

@@ -0,0 +1,68 @@
+class PubSub {
+    constructor() {
+        this.events = {};
+    }
+    subscribe(event, resolve, reject) {
+        if (!(event in this.events)) {
+            this.events[event] = [];
+        }
+        this.events[event].push([resolve, reject]);
+    }
+    publish(event, data, err) {
+        if (!(event in this.events)) {
+            return;
+        }
+        while (this.events[event].length) {
+            const [resolve, reject] = this.events[event].shift();
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(data);
+            }
+        }
+        delete this.events[event];
+    }
+}
+const pubSub = new PubSub();
+const generateHash = (content) => {
+    if (content && typeof content === 'object')
+        try {
+            content = JSON.stringify(content);
+        }
+        catch (e) {
+            content = content === null || content === void 0 ? void 0 : content.toString();
+            console.error('[Error] getStringHash JSON.stringify(content)', e);
+        }
+    if (!content)
+        return;
+    let hash = 0;
+    let chr;
+    if (content.length === 0)
+        return '';
+    for (let i = 0; i < content.length; i++) {
+        chr = content.charCodeAt(i);
+        hash = (hash << 5) - hash + chr;
+        hash |= 0;
+    }
+    return btoa('hash-' + hash);
+};
+async function throttleFetch(key, fetcher) {
+    return new Promise((resolve, reject) => {
+        const hashKey = generateHash(key);
+        const hasEvent = hashKey in pubSub.events;
+        pubSub.subscribe(hashKey, resolve, reject);
+        if (!hasEvent) {
+            pubSub.subscribe(hashKey, resolve, reject);
+            fetcher()
+                .then(data => {
+                pubSub.publish(hashKey, data);
+            })
+                .catch(err => {
+                pubSub.publish(hashKey, undefined, err);
+            });
+        }
+    });
+}
+
+export { generateHash, throttleFetch };

package/dist/lib/useConfig.d.ts

@@ -0,0 +1,8 @@
+export declare const LOCALE_KEY = "lang";
+export declare const PROXIMA_TENANT_KEY = "team_tenant";
+export declare const SESSION_KEY = "sessionToken";
+export declare const useAppProps: () => {
+    locale: string;
+    sessionToken: string;
+    appId: string;
+};

package/dist/lib/useConfig.js

@@ -0,0 +1,31 @@
+import { useContext, useMemo } from 'react';
+import Cookie from 'js-cookie';
+import { TeamConfigContext } from './contexts/teamConfig.js';
+import { getAcceptLanguageHeader } from './config.js';
+
+const LOCALE_KEY = 'lang';
+const PROXIMA_TENANT_KEY = 'team_tenant';
+const SESSION_KEY = 'sessionToken';
+const useAppProps = () => {
+    const { userConfig = {}, publicRuntimeConfig = {} } = useContext(TeamConfigContext);
+    const locale = useMemo(() => {
+        const userLocale = userConfig.locale;
+        const [defaultLang] = navigator.languages;
+        const locale = userLocale || Cookie.get(LOCALE_KEY) || defaultLang;
+        return getAcceptLanguageHeader(locale);
+    }, [userConfig.locale]);
+    const { sessionToken, appId } = useMemo(() => {
+        const { userTenant, sessionToken } = userConfig;
+        return {
+            appId: userTenant || Cookie.get(PROXIMA_TENANT_KEY) || publicRuntimeConfig.appId,
+            sessionToken: sessionToken || Cookie.get(SESSION_KEY),
+        };
+    }, [publicRuntimeConfig.appId, userConfig]);
+    return {
+        locale,
+        sessionToken,
+        appId,
+    };
+};
+
+export { LOCALE_KEY, PROXIMA_TENANT_KEY, SESSION_KEY, useAppProps };

package/dist/lib/useUser.js

@@ -1,8 +1,9 @@
-import { toBoolean } from './dataType';
-import { i18n } from './i18n';
-export const isUserDeleted = (user) => toBoolean(user === null || user === void 0 ? void 0 : user.deleted, false) === true;
-export const isUserDisabled = (user) => toBoolean(user === null || user === void 0 ? void 0 : user.enabled, true) === false;
-export const generateUserDisplayName = (user, onlyNickname = false) => {
+import { toBoolean } from './dataType.js';
+import { i18n } from './i18n.js';
+
+const isUserDeleted = (user) => toBoolean(user === null || user === void 0 ? void 0 : user.deleted, false) === true;
+const isUserDisabled = (user) => toBoolean(user === null || user === void 0 ? void 0 : user.enabled, true) === false;
+const generateUserDisplayName = (user, onlyNickname = false) => {
     const getDisplaySuffix = () => {
         if (isUserDeleted(user)) {
             return i18n.t('pages.users.default.delete');
@@ -20,7 +21,7 @@ export const generateUserDisplayName = (user, onlyNickname = false) => {
         return `${(user === null || user === void 0 ? void 0 : user.nickname) || (user === null || user === void 0 ? void 0 : user.username)}${displaySuffix}`;
     return (user === null || user === void 0 ? void 0 : user.nickname) ? `${user === null || user === void 0 ? void 0 : user.nickname}${displaySuffix}` : user === null || user === void 0 ? void 0 : user.username;
 };
-export const userDataFormat = (user) => {
+const userDataFormat = (user) => {
     var _a;
     return ({
         label: generateUserDisplayName(user),
@@ -31,3 +32,5 @@ export const userDataFormat = (user) => {
         enabled: user.enabled,
     });
 };
+
+export { generateUserDisplayName, isUserDeleted, isUserDisabled, userDataFormat };

package/dist/lib/users.js

@@ -1,8 +1,11 @@
-import { generateUserDisplayName } from './useUser';
-export const userOptionAdapter = (user) => {
+import { generateUserDisplayName } from './useUser.js';
+
+const userOptionAdapter = (user) => {
     return {
         label: generateUserDisplayName(user),
         value: user === null || user === void 0 ? void 0 : user.objectId,
         key: user === null || user === void 0 ? void 0 : user.username,
     };
 };
+
+export { userOptionAdapter };