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

package/dist/components/fields/dropdown/ReadView.js

@@ -1,15 +1,16 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "@emotion/react/jsx-runtime";
+import { jsxs, Fragment, jsx } from '@emotion/react/jsx-runtime';
 import { memo, useMemo } from 'react';
-import EmptyField from '../../common/EmptyField';
-import SimpleOverflowToolTip from '../../common/overflow-tooltip/SimpleOverflowToolTip';
-import { handleValue } from './BaseField';
+import EmptyField from '../../common/EmptyField.js';
+import SimpleOverflowToolTip from '../../common/overflow-tooltip/SimpleOverflowToolTip.js';
+import { handleValue } from './BaseField.js';
+
 var MUTIPLE_MODE;
 (function (MUTIPLE_MODE) {
     MUTIPLE_MODE["multiple"] = "multiple";
     MUTIPLE_MODE["tags"] = "tags";
 })(MUTIPLE_MODE || (MUTIPLE_MODE = {}));
 const getFormattedLabel = ({ label, style = {}, }) => {
-    return _jsx("span", { style: { borderRadius: 2, color: style === null || style === void 0 ? void 0 : style.color, background: style === null || style === void 0 ? void 0 : style.background }, children: label });
+    return jsx("span", { style: { borderRadius: 2, color: style === null || style === void 0 ? void 0 : style.color, background: style === null || style === void 0 ? void 0 : style.background }, children: label });
 };
 const DropdownReadView = memo(props => {
     const { value, options, readonly: propsReadonly, userData, mode } = props;
@@ -45,7 +46,7 @@ const DropdownReadView = memo(props => {
                 return '';
             return valueArr.map((item, index) => {
                 const content = optionsMap[item] ? getFormattedLabel(optionsMap[item]) : item;
-                return index === value.length - 1 ? content : _jsxs(_Fragment, { children: [content, ","] });
+                return index === value.length - 1 ? content : jsxs(Fragment, { children: [content, ","] });
             });
         }
         else {
@@ -73,7 +74,8 @@ const DropdownReadView = memo(props => {
             .join(',');
         return result;
     }, [options, value]);
-    return (_jsx(_Fragment, { children: showValue ? (_jsx(SimpleOverflowToolTip, { title: showValueTitle, children: showValue })) : (_jsx(EmptyField, { readonly: readonly })) }));
+    return showValue ? (jsx(SimpleOverflowToolTip, { title: showValueTitle, children: showValue })) : (jsx(EmptyField, { readonly: readonly }));
 });
 DropdownReadView.displayName = 'DropdownReadView';
-export default DropdownReadView;
+
+export { DropdownReadView as default };

package/dist/components/fields/dropdown/data.d.ts

@@ -0,0 +1,9 @@
+interface FetchDropdownParams {
+    fieldId: string;
+    keyword?: string;
+    workspaceId?: string;
+    page?: string;
+    propsValue?: string;
+}
+export declare const useFetchDropdown: () => ((data: FetchDropdownParams) => Promise<any>);
+export {};

package/dist/components/fields/dropdown/data.js

@@ -0,0 +1,29 @@
+import { useCallback } from 'react';
+import useFetch from '../../../lib/fetch.js';
+import { throttleFetch } from '../../../lib/throttleFetch.js';
+
+const useFetchDropdown = () => {
+    const fetch = useFetch();
+    const fetchDropdownData = useCallback(({ keyword, workspaceId, page, fieldId, propsValue }) => {
+        return throttleFetch({ keyword, workspaceId, page, fieldId }, async () => {
+            try {
+                const { data } = await fetch.get(`/dropdown/data/${fieldId}`, {
+                    params: {
+                        keyword,
+                        workspaceId,
+                        page,
+                        propsValue,
+                    },
+                });
+                return data === null || data === void 0 ? void 0 : data.data;
+            }
+            catch (e) {
+                console.error('fetchDropdownData_error', e);
+                return [];
+            }
+        });
+    }, [fetch]);
+    return fetchDropdownData;
+};
+
+export { useFetchDropdown };

package/dist/components/fields/dropdown/hook.d.ts

@@ -0,0 +1,102 @@
+import { SelectProps } from 'antd';
+import { Item, ItemType, PointerObject } from 'lib/types/models';
+import { FieldProps, IScreenLabelProps } from '../base-component/types';
+import { IParams } from '../hooks/useParamsAdapter';
+interface optionType {
+    key: string;
+    value: string;
+    disabled: undefined | boolean;
+    children: {
+        props: selectValue;
+    };
+}
+export interface selectValue {
+    label: React.ReactNode;
+    value: string | number;
+    disabled?: boolean;
+    enable?: boolean;
+    icon?: string;
+    itemType?: PointerObject | ItemType;
+    archived?: boolean;
+    values?: {
+        [propName: string]: any;
+    };
+}
+export type BaseDropdownProps = SelectProps<any> & FieldProps & {
+    value?: string[] | number[] | Array<IParams>;
+    options?: selectValue[];
+    placeholder?: string;
+    onChange?: (e: any, option?: optionType | optionType[] | string) => void;
+    onSelect?: (e: any, option: any) => void;
+    onOptionsChange?: (options: any[]) => void;
+    onBlur?: (e: any) => void;
+    onClear?: () => void;
+    fetchOptions?: (keywords: string) => Promise<selectValue[]>;
+    fetchValues?: (values: string[], key: string) => Promise<selectValue[]>;
+    debounceTimeout?: number;
+    useChange?: boolean;
+    expression?: string;
+    iql?: string;
+    display?: string;
+    objectId?: string;
+    dataQuoteInit?: (dates: Item[] | selectValue[], value: string[], display?: string) => selectValue[];
+    workspace?: string;
+    label?: string;
+    valueDisplayWrap?: boolean;
+    optionDisplayWrap?: boolean;
+    disabledSwr?: boolean;
+    onlyValue?: boolean;
+    isGroup?: boolean;
+    fetchChange?: (value?: boolean) => void;
+    displayValueHidden?: boolean;
+    disabledLineThrough?: boolean;
+    displayWorkspace?: boolean;
+    onlyWorkspace?: boolean;
+    setOnlyWorkspace?: (e: boolean) => void;
+    isShowOnlyWorkspace?: boolean;
+    fieldTypeKey?: string;
+    iqlKey?: string;
+    detailKey?: string;
+    fetchOnFocus?: boolean;
+    isCascaded?: boolean;
+    cascadeCustomData?: selectValue[];
+    onlyWorkspaceTip?: string;
+    hasCurrentWorkspace?: boolean;
+    clickFetch?: boolean;
+    iqlToNeedMore?: boolean;
+    itemId?: string;
+    workspaceId?: string;
+    dataSource?: string;
+    userData?: Record<string, any>;
+    page?: string;
+    labelWidth?: number;
+    labelAlign?: IScreenLabelProps;
+    editMode?: boolean;
+    apply?: string;
+    hiddenLabel?: boolean;
+    screenMode?: string;
+    searchComponent?: boolean;
+};
+export declare const EMPTY_OPTIONS: any[];
+export declare const useCommonProps: (props: BaseDropdownProps) => {
+    propsValue: any;
+    fetchChange: (value?: boolean) => void;
+    onSearchChange: any;
+    options: any[];
+    onlyWorkspace: boolean;
+    setOnlyWorkspace: (e: any) => void;
+    detailKey: string;
+    loading: boolean;
+    _setValue: import("react").Dispatch<import("react").SetStateAction<any[]>>;
+    setLoading: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    setOptions: import("react").Dispatch<import("react").SetStateAction<any[]>>;
+    propsOptions: any[];
+    cachedOptionsRef: import("react").MutableRefObject<selectValue[]>;
+    needFetchDataSource: boolean;
+    fetchOptions: (keyword?: string) => Promise<any>;
+    fetchValues: (value: string[], key: string) => Promise<any>;
+    canAsyncFetchOption: boolean;
+    cacheSelectOptions: (opts: selectValue[]) => selectValue[];
+    value: any[];
+};
+export {};

package/dist/components/fields/dropdown/hook.js

@@ -0,0 +1,155 @@
+import { useState, useMemo, useRef, useCallback } from 'react';
+import { uniqWith, debounce } from 'lodash-es';
+import { getArrayValue } from '../../../lib/array.js';
+import { REMOTE_DATA_QUOTE_FIELD_TYPE } from '../../../lib/constants/field.js';
+import { FIELD_TYPE_KEY_MAPPINGS } from '../../../lib/global.js';
+import { useFetchDropdown } from './data.js';
+
+const useGenerateFetchFunction = ({ workspaceId, page, fieldId, propsValue, needFetchDataSource, defaultFetchValues, defaultFetchOptions, }) => {
+    const fetchDropdownData = useFetchDropdown();
+    const fetchOptions = useMemo(() => {
+        if (!needFetchDataSource) {
+            return defaultFetchOptions;
+        }
+        else {
+            return async (keyword) => await fetchDropdownData({
+                fieldId,
+                keyword: keyword ? keyword : undefined,
+                workspaceId,
+                page,
+                propsValue,
+            });
+        }
+    }, [defaultFetchOptions, fetchDropdownData, fieldId, needFetchDataSource, page, propsValue, workspaceId]);
+    const fetchValues = useMemo(() => {
+        if (!needFetchDataSource) {
+            return defaultFetchValues;
+        }
+        else {
+            return async (value) => await fetchDropdownData({
+                fieldId,
+                workspaceId,
+                page,
+                propsValue: JSON.stringify(value),
+            });
+        }
+    }, [defaultFetchValues, fetchDropdownData, fieldId, needFetchDataSource, page, workspaceId]);
+    return {
+        fetchOptions,
+        fetchValues,
+    };
+};
+const EMPTY_OPTIONS = [];
+const useCommonProps = (props) => {
+    var _a;
+    const { value: propsValue, options: _propsOptions = EMPTY_OPTIONS, fetchValues: _fetchValues, fetchOptions: _fetchOptions, debounceTimeout = 600, objectId, userData, workspace, page, fetchChange, onlyWorkspace, setOnlyWorkspace, fieldTypeKey, detailKey, isCascaded, cascadeCustomData, workspaceId, dataSource, } = props;
+    const [loading, setLoading] = useState(true);
+    const [value, _setValue] = useState([]);
+    const propsOptions = useMemo(() => {
+        return isCascaded ? cascadeCustomData : _propsOptions;
+    }, [_propsOptions, isCascaded, cascadeCustomData]);
+    const [options, setOptions] = useState(propsOptions || []);
+    const cachedOptionsRef = useRef([]);
+    const needFetchDataSource = !!(userData === null || userData === void 0 ? void 0 : userData.source) || !!dataSource;
+    const { fetchOptions, fetchValues } = useGenerateFetchFunction({
+        workspaceId: workspaceId || workspace,
+        page,
+        fieldId: objectId,
+        propsValue: Array.isArray(propsValue) ? ((_a = propsValue === null || propsValue === void 0 ? void 0 : propsValue[0]) === null || _a === void 0 ? void 0 : _a.value) || (propsValue === null || propsValue === void 0 ? void 0 : propsValue[0]) : propsValue,
+        needFetchDataSource,
+        defaultFetchOptions: _fetchOptions,
+        defaultFetchValues: _fetchValues,
+    });
+    const canAsyncFetchOption = useMemo(() => typeof fetchValues === 'function' && typeof fetchOptions === 'function', [fetchOptions, fetchValues]);
+    const cacheSelectOptions = useCallback((opts) => {
+        var _a;
+        const optsInit = opts === null || opts === void 0 ? void 0 : opts.map(ele => {
+            var _a;
+            if (ele === null || ele === void 0 ? void 0 : ele.itemType) {
+                return {
+                    ...ele,
+                    icon: (_a = ele.itemType) === null || _a === void 0 ? void 0 : _a.icon,
+                };
+            }
+            return ele;
+        });
+        if (Array.isArray(cachedOptionsRef.current) && Array.isArray(optsInit)) {
+            let cachedOptionsRefCopy = cachedOptionsRef.current;
+            if (REMOTE_DATA_QUOTE_FIELD_TYPE.includes(fieldTypeKey)) {
+                cachedOptionsRefCopy = (_a = cachedOptionsRef.current) === null || _a === void 0 ? void 0 : _a.map(opt => {
+                    const currentOpt = optsInit.find(ele => ele.value === opt.value);
+                    return {
+                        ...opt,
+                        values: currentOpt === null || currentOpt === void 0 ? void 0 : currentOpt.values,
+                    };
+                });
+            }
+            const cachedOptions = cachedOptionsRefCopy.concat(optsInit);
+            let cachedOptionsFilter = cachedOptions;
+            if ([FIELD_TYPE_KEY_MAPPINGS.Version, FIELD_TYPE_KEY_MAPPINGS.Team, FIELD_TYPE_KEY_MAPPINGS.Sprint].includes(fieldTypeKey)) {
+                cachedOptionsFilter = cachedOptions.map(ele => {
+                    const versionWithArchived = optsInit === null || optsInit === void 0 ? void 0 : optsInit.find(opt => {
+                        return opt.value === ele.value;
+                    });
+                    return versionWithArchived ? Object.assign(ele, versionWithArchived) : ele;
+                });
+            }
+            cachedOptionsRef.current = uniqWith(cachedOptionsFilter, (a, b) => a.value === b.value);
+        }
+        return cachedOptionsRef.current;
+    }, [fieldTypeKey]);
+    const handleSearch = useMemo(() => {
+        if (!canAsyncFetchOption) {
+            return undefined;
+        }
+        const searchFunc = _keyword => {
+            const keyword = _keyword === null || _keyword === void 0 ? void 0 : _keyword.trim();
+            if (!keyword) {
+                setOptions(cachedOptionsRef.current);
+            }
+            else {
+                setLoading(true);
+                fetchOptions(keyword).then(opts => {
+                    setLoading(false);
+                    cacheSelectOptions(opts);
+                    const _value = getArrayValue(value);
+                    const noExistValues = _value.filter(v => opts.every(item => item.value !== v));
+                    if (noExistValues.length) {
+                        opts = noExistValues
+                            .map(v => { var _a; return (_a = cachedOptionsRef.current) === null || _a === void 0 ? void 0 : _a.find(item => item.value === v); })
+                            .filter(Boolean)
+                            .concat(opts);
+                    }
+                    setOptions(opts);
+                });
+            }
+        };
+        return debounce(searchFunc, debounceTimeout);
+    }, [fetchOptions, canAsyncFetchOption, debounceTimeout, cacheSelectOptions, value]);
+    const onChangeCurrent = useCallback(e => {
+        setOnlyWorkspace(e.target.checked);
+    }, [setOnlyWorkspace]);
+    return {
+        propsValue,
+        fetchChange: fetchChange,
+        onSearchChange: handleSearch,
+        options,
+        onlyWorkspace,
+        setOnlyWorkspace: onChangeCurrent,
+        detailKey,
+        loading,
+        _setValue,
+        setLoading,
+        setOptions,
+        propsOptions,
+        cachedOptionsRef,
+        needFetchDataSource,
+        fetchOptions,
+        fetchValues,
+        canAsyncFetchOption,
+        cacheSelectOptions,
+        value,
+    };
+};
+
+export { EMPTY_OPTIONS, useCommonProps };

package/dist/components/fields/dropdown/style.d.ts

@@ -0,0 +1,16 @@
+export declare const dropdownSelectDisabled = "\n  text-decoration: line-through;\n";
+export declare const onlyWorkspaceStyle = "\n  padding: 5px 12px;\n";
+export declare const onlyWorkspaceDividerStyle = "\n  &:not(.add-weights) {\n    margin: 4px 0;\n  }\n";
+export declare const hiddenHoverClass: string;
+export declare const displayWrapClass: string;
+export declare const valueOptionClass: string;
+export declare const valueOptionContentClass: string;
+export declare const valueOptionIconClass: string;
+export declare const valueOptionLabelClass: string;
+export declare const workspaceClass: string;
+export declare const hoverIconClass: string;
+export declare const optionDisplayWrapClass: string;
+export declare const dropdownStyle: (antPrefix: string) => string;
+export declare const dropdownSelectOptionClass: string;
+export declare const disabledClass: string;
+export declare const dropdownSelectStyle: (antPrefix: string) => string;

package/dist/components/fields/dropdown/style.js

@@ -0,0 +1,93 @@
+import { randomClassName } from '../../../style/common.js';
+import { hoverStyle, hoverIconStyle } from '../../common/style/mixin.js';
+
+const dropdownSelectDisabled = `
+  text-decoration: line-through;
+`;
+const onlyWorkspaceStyle = `
+  padding: 5px 12px;
+`;
+const onlyWorkspaceDividerStyle = `
+  &:not(.add-weights) {
+    margin: 4px 0;
+  }
+`;
+const hiddenHoverClass = randomClassName('hidden-hover');
+const displayWrapClass = randomClassName('display-wrap');
+const valueOptionClass = randomClassName('value-option');
+const valueOptionContentClass = randomClassName('value-option-content');
+const valueOptionIconClass = randomClassName('value-option-icon');
+const valueOptionLabelClass = randomClassName('value-option-label');
+const workspaceClass = randomClassName('workspace');
+const hoverIconClass = randomClassName('hover-icon');
+const optionDisplayWrapClass = randomClassName('option-display-wrap');
+const dropdownStyle = (antPrefix) => `
+  width: 100%;
+
+  &:not(.${hiddenHoverClass}) &:not(.${displayWrapClass}) :hover {
+    ${hoverStyle}
+
+    .${hoverIconClass} {
+      display: inline-block;
+    }
+  }
+
+  .${hoverIconClass} {
+    ${hoverIconStyle}
+  }
+
+  .${antPrefix}-select {
+    width: 100%;
+  }
+
+  .${antPrefix}-select-selection-item) {
+    .${workspaceClass} {
+      display: none;
+    }
+  }
+
+  .${valueOptionClass} {
+    margin-bottom: 8px;
+  }
+
+  .${valueOptionContentClass} {
+    width: 100%;
+    padding-top: 6px;
+
+    .${valueOptionIconClass} {
+      position: absolute;
+      margin-top: 3px;
+    }
+
+    .${valueOptionLabelClass} {
+      display: inline-block;
+      width: ~'calc(100% - 22px)';
+      margin-left: 22px;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+  }
+
+  .${optionDisplayWrapClass} {
+    .${antPrefix}-select-selection-overflow {
+      display: block;
+      .${antPrefix}-select-selection-overflow-item {
+        width: fit-content;
+      }
+    }
+  }
+`;
+const dropdownSelectOptionClass = randomClassName('dropdown-select-option');
+const disabledClass = randomClassName('disabled');
+const dropdownSelectStyle = (antPrefix) => `
+  .${dropdownSelectOptionClass}.${disabledClass} {
+    text-decoration: line-through;
+  }
+
+  .${antPrefix}-select-selection-item-content {
+    text-decoration: line-through;   
+  }
+`;
+
+export { disabledClass, displayWrapClass, dropdownSelectDisabled, dropdownSelectOptionClass, dropdownSelectStyle, dropdownStyle, hiddenHoverClass, hoverIconClass, onlyWorkspaceDividerStyle, onlyWorkspaceStyle, optionDisplayWrapClass, valueOptionClass, valueOptionContentClass, valueOptionIconClass, valueOptionLabelClass, workspaceClass };

package/dist/components/fields/file/ReadView.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { ReadViewBaseProps } from '../types';
 declare const FileReadView: import("react").NamedExoticComponent<ReadViewBaseProps>;
 export default FileReadView;

package/dist/components/fields/file/ReadView.js

@@ -1,7 +1,8 @@
-import { jsx as _jsx, Fragment as _Fragment } from "@emotion/react/jsx-runtime";
+import { jsx, Fragment } from '@emotion/react/jsx-runtime';
 import { memo } from 'react';
-import EmptyField from '../../common/EmptyField';
-import SimpleOverflowToolTip from '../../common/overflow-tooltip/SimpleOverflowToolTip';
+import EmptyField from '../../common/EmptyField.js';
+import SimpleOverflowToolTip from '../../common/overflow-tooltip/SimpleOverflowToolTip.js';
+
 const FileReadView = memo(({ value }) => {
     const showValue = (value === null || value === void 0 ? void 0 : value.length)
         ? value
@@ -9,6 +10,7 @@ const FileReadView = memo(({ value }) => {
             .filter(Boolean)
             .join(',')
         : '';
-    return (_jsx(_Fragment, { children: showValue ? (_jsx(SimpleOverflowToolTip, { title: showValue, children: showValue })) : (_jsx(EmptyField, { readonly: true })) }));
+    return (jsx(Fragment, { children: showValue ? (jsx(SimpleOverflowToolTip, { title: showValue, children: showValue })) : (jsx(EmptyField, { readonly: true })) }));
 });
-export default FileReadView;
+
+export { FileReadView as default };

package/dist/components/fields/formula/ReadView.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 export type FormulaReadViewProps = {
     value?: string | number | boolean | undefined;
     placeholder?: string;

package/dist/components/fields/formula/ReadView.js

@@ -1,7 +1,8 @@
-import { jsx as _jsx, Fragment as _Fragment } from "@emotion/react/jsx-runtime";
+import { jsx, Fragment } from '@emotion/react/jsx-runtime';
 import { memo, useMemo } from 'react';
-import EmptyField from '../../common/EmptyField';
-import SimpleOverflowToolTip from '../../common/overflow-tooltip/SimpleOverflowToolTip';
+import EmptyField from '../../common/EmptyField.js';
+import SimpleOverflowToolTip from '../../common/overflow-tooltip/SimpleOverflowToolTip.js';
+
 const FormulaReadView = memo(({ value, addonBefore = '', addonAfter = '' }) => {
     const showValue = useMemo(() => {
         return (value === null || value === void 0 ? void 0 : value.toString()) || '';
@@ -9,6 +10,7 @@ const FormulaReadView = memo(({ value, addonBefore = '', addonAfter = '' }) => {
     const valueWithPrefix = useMemo(() => {
         return `${addonBefore}${showValue || ''}${addonAfter}`;
     }, [addonBefore, showValue, addonAfter]);
-    return (_jsx(_Fragment, { children: valueWithPrefix ? (_jsx(SimpleOverflowToolTip, { title: valueWithPrefix, children: valueWithPrefix })) : (_jsx(EmptyField, { readonly: true })) }));
+    return (jsx(Fragment, { children: valueWithPrefix ? (jsx(SimpleOverflowToolTip, { title: valueWithPrefix, children: valueWithPrefix })) : (jsx(EmptyField, { readonly: true })) }));
 });
-export default FormulaReadView;
+
+export { FormulaReadView as default };

package/dist/components/fields/hooks/useViewClass.d.ts

@@ -0,0 +1,11 @@
+interface IViewClass {
+    screenMode: string;
+    editing: boolean;
+    readonly: boolean;
+}
+interface IViewClassResult {
+    viewClassNames: Record<string, boolean>;
+    isView: boolean;
+}
+declare const useViewClass: ({ screenMode, editing, readonly }: IViewClass) => IViewClassResult;
+export default useViewClass;

package/dist/components/fields/hooks/useViewClass.js

@@ -0,0 +1,20 @@
+import { useMemo } from 'react';
+import { SCREEN_TYPE } from '../../../lib/global.js';
+
+const useViewClass = ({ screenMode, editing, readonly }) => {
+    const isView = useMemo(() => {
+        return screenMode === SCREEN_TYPE.View;
+    }, [screenMode]);
+    const viewClassNames = useMemo(() => {
+        return {
+            'field-value-view': isView && !editing,
+            'field-value-readonly': readonly,
+        };
+    }, [isView, editing, readonly]);
+    return {
+        viewClassNames,
+        isView,
+    };
+};
+
+export { useViewClass as default };

package/dist/components/fields/hyper-link/ReadView.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { CellProps } from '../base-component/types';
 export interface BaseFieldProps {
     value: {

package/dist/components/fields/hyper-link/ReadView.js

@@ -1,17 +1,19 @@
-import { jsx as _jsx, jsxs as _jsxs } from "@emotion/react/jsx-runtime";
+import { jsx, jsxs } from '@emotion/react/jsx-runtime';
 import { memo, useMemo } from 'react';
 import { css } from '@emotion/react';
 import { Popover } from 'antd';
-import EmptyField from '../../common/EmptyField';
-import { hyperLinkItemStyle, hyperLinkListStyle, hyperLinkTipItem } from './style';
+import EmptyField from '../../common/EmptyField.js';
+import { hyperLinkTipItem, hyperLinkListStyle, hyperLinkItemStyle } from './style/index.js';
+
 const HyperLinkCell = memo(props => {
     const { value } = props;
     const list = useMemo(() => {
         return value === null || value === void 0 ? void 0 : value.filter(item => item === null || item === void 0 ? void 0 : item.value);
     }, [value]);
     const content = useMemo(() => {
-        return list === null || list === void 0 ? void 0 : list.map(item => (_jsx("a", { href: item.value, target: "_blank", rel: "noreferrer", css: css(hyperLinkTipItem), children: item.label }, item.id)));
+        return list === null || list === void 0 ? void 0 : list.map(item => (jsx("a", { href: item.value, target: "_blank", rel: "noreferrer", css: css(hyperLinkTipItem), children: item.label }, item.id)));
     }, [list]);
-    return (list === null || list === void 0 ? void 0 : list.length) > 0 ? (_jsx(Popover, { content: content, destroyTooltipOnHide: true, children: _jsx("div", { css: css(hyperLinkListStyle), children: list.map((item, index) => (_jsxs("a", { href: item.value, target: "_blank", rel: "noreferrer", css: css(hyperLinkItemStyle), children: [item.label, index + 1 !== list.length && _jsx("span", { children: ",\u00A0" })] }, item.id))) }) })) : (_jsx(EmptyField, { readonly: true }));
+    return (list === null || list === void 0 ? void 0 : list.length) > 0 ? (jsx(Popover, { content: content, destroyTooltipOnHide: true, children: jsx("div", { css: css(hyperLinkListStyle), children: list.map((item, index) => (jsxs("a", { href: item.value, target: "_blank", rel: "noreferrer", css: css(hyperLinkItemStyle), children: [item.label, index + 1 !== list.length && jsx("span", { children: ",\u00A0" })] }, item.id))) }) })) : (jsx(EmptyField, { readonly: true }));
 });
-export default HyperLinkCell;
+
+export { HyperLinkCell as default };

package/dist/components/fields/hyper-link/style/index.js

@@ -1,18 +1,21 @@
-import { blue6 } from '../../../../style/common';
-export const hyperLinkListStyle = `
-  display: flex;
-  width: 100%;
+import { blue6 } from '../../../../style/common.js';
+
+const hyperLinkListStyle = `
+  display: flex;
+  width: 100%;
 `;
-export const hyperLinkItemStyle = `
-  ${hyperLinkListStyle} & {
-    overflow: hidden;
-    color: @blue-6;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-    -webkit-line-clamp: 1;
-  }
+const hyperLinkItemStyle = `
+  ${hyperLinkListStyle} & {
+    overflow: hidden;
+    color: @blue-6;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    -webkit-line-clamp: 1;
+  }
 `;
-export const hyperLinkTipItem = `
-  display: block;
-  color: ${blue6};
+const hyperLinkTipItem = `
+  display: block;
+  color: ${blue6};
 `;
+
+export { hyperLinkItemStyle, hyperLinkListStyle, hyperLinkTipItem };

package/dist/components/fields/item-group/ReadView.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { ReadViewBaseProps } from '../types';
 type ItemGroupReadViewProps = ReadViewBaseProps;
 declare const ItemGroupReadView: React.FC<ItemGroupReadViewProps>;

package/dist/components/fields/item-group/ReadView.js

@@ -1,6 +1,8 @@
-import { jsx as _jsx, Fragment as _Fragment } from "@emotion/react/jsx-runtime";
-import EmptyField from '../../common/EmptyField';
+import { jsx, Fragment } from '@emotion/react/jsx-runtime';
+import EmptyField from '../../common/EmptyField.js';
+
 const ItemGroupReadView = ({ value }) => {
-    return _jsx(_Fragment, { children: (value === null || value === void 0 ? void 0 : value.name) || _jsx(EmptyField, { readonly: true }) });
+    return jsx(Fragment, { children: (value === null || value === void 0 ? void 0 : value.name) || jsx(EmptyField, { readonly: true }) });
 };
-export default ItemGroupReadView;
+
+export { ItemGroupReadView as default };

package/dist/components/fields/item-type/ItemTypeIcon.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export declare const NoItemTypeIconUrl = "/icons/NoItemType.svg";
+export declare const useNoItemTypeIcon: () => string;
+export declare const ItemTypeIcon: ({ icon, name, className, }: {
+    icon?: string;
+    name?: string;
+    className?: string;
+}) => React.ReactElement;
+export default ItemTypeIcon;