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

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

package/dist/lib/storage.js

@@ -0,0 +1,62 @@
+export 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;
+    }
+};
+export const setLocalStorageItem = (key, value) => {
+    try {
+        localStorage.setItem(key, JSON.stringify(value));
+        return true;
+    }
+    catch (e) {
+        console.error(e);
+        return false;
+    }
+};
+const getStorageKeys = () => {
+    return Object.keys(localStorage);
+};
+export 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 default {
+    getItem: getLocalStorageItem,
+    setItem: setLocalStorageItem,
+    removeParseItems,
+};
+const setLocalStorageState = (key, data) => {
+    localStorage.setItem(key, JSON.stringify({ time: new Date().getDate(), data }));
+};
+export const getLocalStorageState = async (key, fn) => {
+    try {
+        const target = localStorage.getItem(key);
+        if (target) {
+            const targetFormat = JSON.parse(target);
+            if ((targetFormat === null || targetFormat === void 0 ? void 0 : targetFormat.time) === new Date().getDate()) {
+                if (typeof targetFormat.data !== 'string') {
+                    return targetFormat.data;
+                }
+            }
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+    const data = await fn();
+    setLocalStorageState(key, data);
+    return data;
+};

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,108 @@
+import debug from 'debug';
+import { getLocalStorageItem } from 'lib/storage';
+export 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);
+            });
+        }
+    });
+};
+export 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 = {}));
+export const createKeyByParams = ({ type, params }) => {
+    if (!params)
+        return `${+new Date()}`;
+    return `${type}_${JSON.stringify(params)}`;
+};
+export default throttleWithCache;

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,66 @@
+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();
+export 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);
+};
+export 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);
+            });
+        }
+    });
+}

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,28 @@
+import { useContext, useMemo } from 'react';
+import Cookie from 'js-cookie';
+import { TeamConfigContext } from './contexts/teamConfig';
+import { getAcceptLanguageHeader } from './config';
+export const LOCALE_KEY = 'lang';
+export const PROXIMA_TENANT_KEY = 'team_tenant';
+export const SESSION_KEY = 'sessionToken';
+export 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,
+    };
+};