@tachybase/client 0.23.48 → 1.0.6

package/lib/collection-manager/Configuration/AddCollectionAction.js

@@ -46,6 +46,7 @@ const external_ResourceActionProvider_js_namespaceObject = require("../ResourceA
 const external_components_index_js_namespaceObject = require("./components/index.js");
 const TemplateSummary_js_namespaceObject = require("./components/TemplateSummary.js");
 const external_ImportCollectionMetaAction_js_namespaceObject = require("./ImportCollectionMetaAction.js");
+const ImportXlsxMetaAction_js_namespaceObject = require("./ImportXlsx/ImportXlsxMetaAction.js");
 const getSchema = (schema, category, compile)=>{
     if (!schema) return;
     const properties = (0, external_lodash_namespaceObject.cloneDeep)(schema.configurableProperties);
@@ -165,6 +166,7 @@ const AddCollectionAction = (props)=>{
     const compile = (0, external_schema_component_index_js_namespaceObject.useCompile)();
     const { t } = (0, external_react_i18next_namespaceObject.useTranslation)();
     const importRef = (0, external_react_namespaceObject.useRef)(null);
+    const importxlsxRef = (0, external_react_namespaceObject.useRef)(null);
     const items = (0, external_react_namespaceObject.useMemo)(()=>{
         const result = [];
         collectionTemplates.forEach((item)=>{
@@ -189,10 +191,14 @@ const AddCollectionAction = (props)=>{
             onClick: (info)=>{
                 if ('import' === info.key) {
                     var _importRef_current;
-                    console.log('import', importRef.current);
                     null === (_importRef_current = importRef.current) || void 0 === _importRef_current || _importRef_current.showModal();
                     return;
                 }
+                if ('importXlsx' === info.key) {
+                    var _importxlsxRef_current;
+                    null === (_importxlsxRef_current = importxlsxRef.current) || void 0 === _importxlsxRef_current || _importxlsxRef_current.showModal();
+                    return;
+                }
                 const schema = getSchema(getTemplate(info.key), category, compile);
                 setSchema(schema);
                 setVisible(true);
@@ -201,7 +207,8 @@ const AddCollectionAction = (props)=>{
         }), [
         category,
         items,
-        importRef
+        importRef,
+        importxlsxRef
     ]);
     return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(external_record_provider_index_js_namespaceObject.RecordProvider, {
         record: record,
@@ -248,6 +255,9 @@ const AddCollectionAction = (props)=>{
             }),
             /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_ImportCollectionMetaAction_js_namespaceObject.ImportCollectionMetaAction, {
                 ref: importRef
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ImportXlsxMetaAction_js_namespaceObject.ImportXlsxMetaAction, {
+                ref: importxlsxRef
             })
         ]
     });

package/lib/collection-manager/Configuration/ImportXlsx/ImportXlsxMetaAction.js

@@ -0,0 +1,304 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = function(module) {
+        var getter = module && module.__esModule ? function() {
+            return module['default'];
+        } : function() {
+            return module;
+        };
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ImportXlsxMetaAction: ()=>ImportXlsxMetaAction
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+const schema_namespaceObject = require("@tachybase/schema");
+const icons_namespaceObject = require("@ant-design/icons");
+const external_antd_namespaceObject = require("antd");
+const external_dayjs_namespaceObject = require("dayjs");
+var external_dayjs_default = /*#__PURE__*/ __webpack_require__.n(external_dayjs_namespaceObject);
+const external_lodash_namespaceObject = require("lodash");
+const external_react_i18next_namespaceObject = require("react-i18next");
+const external_xlsx_namespaceObject = require("xlsx");
+const index_js_namespaceObject = require("../../../schema-component/index.js");
+const external_hooks_index_js_namespaceObject = require("../../hooks/index.js");
+const external_XlsxCollectionSchema_js_namespaceObject = require("./XlsxCollectionSchema.js");
+const external_XlsxEditFieldAction_js_namespaceObject = require("./XlsxEditFieldAction.js");
+const external_xlsxFieldsConfigure_js_namespaceObject = require("./xlsxFieldsConfigure.js");
+const external_xlsxPreviewTable_js_namespaceObject = require("./xlsxPreviewTable.js");
+const { Dragger } = external_antd_namespaceObject.Upload;
+const ImportUpload = (props)=>{
+    const { t } = (0, external_react_i18next_namespaceObject.useTranslation)();
+    const { close } = props;
+    const { getInterface } = (0, external_hooks_index_js_namespaceObject.useCollectionManager_deprecated)();
+    const [fileList, setFile] = (0, external_react_namespaceObject.useState)([]);
+    const [filedata, setFileData] = (0, external_react_namespaceObject.useState)({});
+    const [visible, setVisible] = (0, external_react_namespaceObject.useState)(false);
+    const [schema, setSchema] = (0, external_react_namespaceObject.useState)({});
+    const inferType = (values, header)=>{
+        const isDateHeader = /date|time|日期/i.test(header);
+        const isPossibleDate = isDateHeader && values.every((value)=>external_dayjs_default()(value).isValid());
+        if (isPossibleDate) return 'date';
+        const types = values.map((value)=>{
+            if (null != value) {
+                const valueLower = value.toString().toLowerCase();
+                if ('true' === valueLower || 'yes' === valueLower) return 'boolean';
+                if ('false' === valueLower || 'no' === valueLower) return 'boolean';
+            }
+            const num = Number(value);
+            if (!isNaN(num)) return Number.isInteger(num) ? 'integer' : 'float';
+            try {
+                JSON.parse(value);
+                return 'json';
+            } catch  {}
+            return 'string';
+        });
+        const typeCount = types.reduce((acc, type)=>{
+            acc[type] = (acc[type] || 0) + 1;
+            return acc;
+        }, {});
+        const uniqueTypes = Object.keys(typeCount);
+        if (uniqueTypes.length > 1) return 'string';
+        return uniqueTypes[0];
+    };
+    const inferInterface = (type, header)=>{
+        switch(type){
+            case 'json':
+                return 'json';
+            case 'boolean':
+                return 'checkbox';
+            case 'string':
+                return 'input';
+            case 'integer':
+                return 'integer';
+            case 'float':
+                return 'number';
+            case 'date':
+                return 'datetime';
+            default:
+                return null;
+        }
+    };
+    const handleFileUpload = (file)=>{
+        const reader = new FileReader();
+        reader.onload = async (e)=>{
+            const binaryStr = e.target.result;
+            const workbook = external_xlsx_namespaceObject.read(binaryStr, {
+                type: 'binary'
+            });
+            const firstSheetName = workbook.SheetNames[0];
+            const worksheet = workbook.Sheets[firstSheetName];
+            const jsonData = external_xlsx_namespaceObject.utils.sheet_to_json(worksheet, {
+                header: 1
+            });
+            if (0 === jsonData.length) return;
+            const headers = jsonData[0];
+            const rows = jsonData.slice(1);
+            const fields = await Promise.all(headers.map(async (header, index)=>{
+                const columnValues = rows.map((row)=>row[index]);
+                const type = inferType(columnValues, header);
+                const interfaceType = type ? inferInterface(type, header) : null;
+                const interfaceConfig = interfaceType ? getInterface(interfaceType) : null;
+                const interfaceConfigValues = (0, external_lodash_namespaceObject.cloneDeep)(interfaceConfig);
+                const defaultUiSchema = (null == interfaceConfigValues ? void 0 : interfaceConfigValues.default.uiSchema) || {};
+                const fieldsName = "f_".concat((0, schema_namespaceObject.uid)());
+                return {
+                    name: fieldsName,
+                    type,
+                    interface: interfaceType,
+                    uiSchema: {
+                        title: header,
+                        ...defaultUiSchema
+                    }
+                };
+            }));
+            const parseValue = (value, type)=>{
+                try {
+                    switch(type){
+                        case 'boolean':
+                            {
+                                const valueLower = value.toString().toLowerCase();
+                                if ('true' === valueLower || 'yes' === valueLower) return true;
+                                if ('false' === valueLower || 'no' === valueLower) return false;
+                                throw new Error('Invalid boolean');
+                            }
+                        case 'integer':
+                            if (!/^-?\d+$/.test(value)) throw new Error('Invalid integer');
+                            return parseInt(value, 10);
+                        case 'float':
+                            if (!/^-?\d+(\.\d+)?$/.test(value)) throw new Error('Invalid number');
+                            return Number(value);
+                        case 'json':
+                            return JSON.parse(value);
+                        case 'date':
+                            if (isNaN(Date.parse(value))) throw new Error('Invalid date');
+                            return new Date(value);
+                        default:
+                            if (null == value || '' === value) return '';
+                            return value.toString();
+                    }
+                } catch (error) {
+                    throw new Error("Type conversion error: ".concat(error.message));
+                }
+            };
+            const convertedRows = rows.map((row, rowIndex)=>headers.reduce((acc, header, index)=>{
+                    var _fields_index, _fields_index1;
+                    const fieldsName = null === (_fields_index = fields[index]) || void 0 === _fields_index ? void 0 : _fields_index.name;
+                    const type = null === (_fields_index1 = fields[index]) || void 0 === _fields_index1 ? void 0 : _fields_index1.type;
+                    if (fieldsName && type) try {
+                        const convertedValue = parseValue(row[index], type);
+                        acc[fieldsName] = convertedValue;
+                    } catch (error) {
+                        acc[fieldsName] = null;
+                        external_antd_namespaceObject.message.error('Error in column "'.concat(header, '" at row ').concat(rowIndex + 1, ": ").concat(error.message));
+                    }
+                    return acc;
+                }, {}));
+            const fileData = {
+                fields: fields,
+                data: convertedRows
+            };
+            setFileData(fileData);
+        };
+        reader.readAsBinaryString(file);
+    };
+    const importProps = {
+        onRemove: (file)=>{
+            const index = fileList.indexOf(file);
+            const newFileList = fileList.slice();
+            newFileList.splice(index, 1);
+            setFile(newFileList);
+        },
+        beforeUpload: (file)=>{
+            const isExcel = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' === file.type || file.name.endsWith('.xlsx') || file.name.endsWith('.xls');
+            if (!isExcel) {
+                external_antd_namespaceObject.message.error(t('You can only upload Excel files!'));
+                return external_antd_namespaceObject.Upload.LIST_IGNORE;
+            }
+            handleFileUpload(file);
+            setFile([
+                file
+            ]);
+            return false;
+        },
+        fileList
+    };
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+        children: [
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(Dragger, {
+                maxCount: 1,
+                ...importProps,
+                children: [
+                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("p", {
+                        className: "ant-upload-drag-icon",
+                        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(icons_namespaceObject.InboxOutlined, {})
+                    }),
+                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("p", {
+                        className: "ant-upload-text",
+                        children: [
+                            " ",
+                            t('Click or drag file to this area to upload')
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(index_js_namespaceObject.ActionContextProvider, {
+                value: {
+                    visible,
+                    setVisible
+                },
+                children: [
+                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_antd_namespaceObject.Button, {
+                        type: "primary",
+                        onClick: async ()=>{
+                            const xlsxCollectionSchema = (0, external_XlsxCollectionSchema_js_namespaceObject.createXlsxCollectionSchema)(fileList, filedata);
+                            setSchema(xlsxCollectionSchema);
+                            setVisible(true);
+                            close();
+                        },
+                        disabled: 0 === fileList.length,
+                        style: {
+                            marginTop: 16
+                        },
+                        children: t('Upload')
+                    }),
+                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(index_js_namespaceObject.SchemaComponent, {
+                        schema: schema,
+                        components: {
+                            xlsxFieldsConfigure: external_xlsxFieldsConfigure_js_namespaceObject.xlsxFieldsConfigure
+                        },
+                        scope: {
+                            xlsxPreviewTable: external_xlsxPreviewTable_js_namespaceObject.xlsxPreviewTable,
+                            xlsxImportAction: external_XlsxEditFieldAction_js_namespaceObject.xlsxImportAction
+                        }
+                    })
+                ]
+            })
+        ]
+    });
+};
+const ImportXlsxMetaAction = /*#__PURE__*/ external_react_default().forwardRef((props, ref)=>{
+    const { t } = (0, external_react_i18next_namespaceObject.useTranslation)();
+    const [isModalOpen, setIsModalOpen] = (0, external_react_namespaceObject.useState)(false);
+    const [loading, setLoading] = (0, external_react_namespaceObject.useState)(false);
+    const showModal = ()=>{
+        setIsModalOpen(true);
+    };
+    (0, external_react_namespaceObject.useImperativeHandle)(ref, ()=>({
+            showModal
+        }));
+    const handleCancel = ()=>{
+        setIsModalOpen(false);
+    };
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_antd_namespaceObject.Drawer, {
+            title: t('Import collection'),
+            footer: void 0,
+            open: isModalOpen,
+            onClose: handleCancel,
+            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_antd_namespaceObject.Spin, {
+                spinning: loading,
+                children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ImportUpload, {
+                    close: handleCancel
+                })
+            })
+        })
+    });
+});
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});

package/lib/collection-manager/Configuration/ImportXlsx/XlsxCollectionSchema.js

@@ -0,0 +1,130 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createXlsxCollectionSchema: ()=>createXlsxCollectionSchema
+});
+const schema_namespaceObject = require("@tachybase/schema");
+const createXlsxCollectionSchema = (filelist, filedata)=>{
+    var _filelist_;
+    return {
+        type: 'object',
+        properties: {
+            [(0, schema_namespaceObject.uid)()]: {
+                type: 'void',
+                'x-decorator': 'FormV2',
+                'x-component': 'Action.Drawer',
+                'x-component-props': {
+                    width: '70%'
+                },
+                'x-use-component-props': 'useFormBlockProps',
+                properties: {
+                    action: {
+                        type: 'void',
+                        'x-component': 'ActionBar',
+                        'x-component-props': {
+                            layout: 'one-column',
+                            style: {
+                                justifyContent: 'right'
+                            }
+                        },
+                        properties: {
+                            cancel: {
+                                title: 'Cancel',
+                                'x-component': 'Action',
+                                'x-use-component-props': 'useCancelActionProps'
+                            },
+                            submit: {
+                                title: '{{t("Submit")}}',
+                                'x-component': 'Action',
+                                'x-component-props': {
+                                    type: 'primary',
+                                    htmlType: 'submit'
+                                },
+                                'x-use-component-props': 'xlsxImportAction'
+                            }
+                        }
+                    },
+                    title: {
+                        type: 'string',
+                        default: null === (_filelist_ = filelist[0]) || void 0 === _filelist_ ? void 0 : _filelist_.name.replace(/\.[^/.]+$/, ''),
+                        title: '{{ t("Collection display name") }}',
+                        required: true,
+                        'x-decorator': 'FormItem',
+                        'x-component': 'Input'
+                    },
+                    name: {
+                        type: 'string',
+                        title: '{{t("Collection name")}}',
+                        default: '{{ useNewId("t_") }}',
+                        required: true,
+                        'x-decorator': 'FormItem',
+                        'x-component': 'Input',
+                        'x-validator': 'uid',
+                        description: "{{t('Randomly generated and can be modified. Support letters, numbers and underscores, must start with an letter.')}}"
+                    },
+                    category: {
+                        title: '{{t("Categories")}}',
+                        type: 'hasMany',
+                        name: 'category',
+                        'x-decorator': 'FormItem',
+                        'x-component': 'Select',
+                        'x-component-props': {
+                            mode: 'multiple'
+                        },
+                        'x-reactions': [
+                            '{{useAsyncDataSource(loadCategories)}}'
+                        ]
+                    },
+                    description: {
+                        title: '{{t("Description")}}',
+                        type: 'string',
+                        name: 'description',
+                        'x-decorator': 'FormItem',
+                        'x-component': 'Input.TextArea'
+                    },
+                    fields: {
+                        type: 'array',
+                        title: '{{t("Fields")}}',
+                        default: filedata.fields,
+                        'x-decorator': 'FormItem',
+                        'x-component': 'xlsxFieldsConfigure',
+                        'x-component-props': {
+                            filedata
+                        },
+                        required: true
+                    }
+                }
+            }
+        }
+    };
+};
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});

package/lib/collection-manager/Configuration/ImportXlsx/XlsxEditFieldAction.js

@@ -0,0 +1,81 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    xlsxImportAction: ()=>xlsxImportAction
+});
+const schema_namespaceObject = require("@tachybase/schema");
+const external_antd_namespaceObject = require("antd");
+const external_lodash_namespaceObject = require("lodash");
+const external_react_i18next_namespaceObject = require("react-i18next");
+const index_js_namespaceObject = require("../../../api-client/index.js");
+const external_schema_component_index_js_namespaceObject = require("../../../schema-component/index.js");
+const external_hooks_index_js_namespaceObject = require("../../hooks/index.js");
+const external_ResourceActionProvider_js_namespaceObject = require("../../ResourceActionProvider.js");
+const xlsxImportAction = ()=>{
+    const form = (0, schema_namespaceObject.useForm)();
+    const ctx = (0, external_schema_component_index_js_namespaceObject.useActionContext)();
+    const field = (0, schema_namespaceObject.useField)();
+    const api = (0, index_js_namespaceObject.useAPIClient)();
+    const { refresh } = (0, external_ResourceActionProvider_js_namespaceObject.useResourceActionContext)();
+    const { refreshCM } = (0, external_hooks_index_js_namespaceObject.useCollectionManager_deprecated)();
+    const { t } = (0, external_react_i18next_namespaceObject.useTranslation)();
+    return {
+        async onClick () {
+            field.data = field.data || {};
+            field.data.loading = true;
+            try {
+                await form.submit();
+                const values = (0, external_lodash_namespaceObject.cloneDeep)(form.values);
+                const { collectionData, ...collections } = values;
+                if (!collections.autoCreateReverseField) delete collections.reverseField;
+                delete collections.autoCreateReverseField;
+                await api.resource('collections').create({
+                    values: {
+                        logging: true,
+                        ...collections
+                    }
+                });
+                api.resource("".concat(collections.name)).create({
+                    values: collectionData
+                });
+                ctx.setVisible(false);
+                null == refresh || refresh();
+                await refreshCM();
+                field.data.loading = false;
+            } catch (error) {
+                field.data.loading = false;
+                external_antd_namespaceObject.message.error(t('Operation failed'));
+            }
+        }
+    };
+};
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});

package/lib/collection-manager/Configuration/ImportXlsx/setUpdateXlsxCollectionField.js

@@ -0,0 +1,78 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    setUpdateXlsxCollectionField: ()=>setUpdateXlsxCollectionField
+});
+const schema_namespaceObject = require("@tachybase/schema");
+const external_antd_namespaceObject = require("antd");
+const external_lodash_namespaceObject = require("lodash");
+const external_react_i18next_namespaceObject = require("react-i18next");
+const index_js_namespaceObject = require("../../../schema-component/index.js");
+const external_xlsxFormValueContextProvider_js_namespaceObject = require("./xlsxFormValueContextProvider.js");
+const setUpdateXlsxCollectionField = ()=>{
+    const form = (0, schema_namespaceObject.useForm)();
+    const { value, setFormValue } = (0, external_xlsxFormValueContextProvider_js_namespaceObject.useFormValueContext)();
+    const ctx = (0, index_js_namespaceObject.useActionContext)();
+    const { t } = (0, external_react_i18next_namespaceObject.useTranslation)();
+    const handleFieldChange = (index, updatedField)=>{
+        const updatedFieldData = [
+            ...value
+        ];
+        if (updatedField.primaryKey) {
+            const existingPrimaryKey = updatedFieldData.find((field, i)=>true === field.primaryKey && i !== index);
+            if (existingPrimaryKey) {
+                external_antd_namespaceObject.message.error(t('existingPrimaryKeyError', {
+                    name: existingPrimaryKey.name
+                }));
+                return;
+            }
+        }
+        updatedFieldData[index] = updatedField;
+        setFormValue(updatedFieldData);
+    };
+    return {
+        async onClick () {
+            await form.submit();
+            const values = (0, external_lodash_namespaceObject.cloneDeep)(form.values);
+            values.autoCreateReverseField || delete values.reverseField;
+            delete values.autoCreateReverseField;
+            const { index, ...updatedField } = values;
+            if (index < 0 || index >= value.length) {
+                external_antd_namespaceObject.message.error('Invalid field index');
+                return;
+            }
+            handleFieldChange(index, updatedField);
+            ctx.setVisible(false);
+        }
+    };
+};
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});