@steedos-widgets/amis-lib 1.3.20 → 1.3.22-beta.1

package/dist/index.esm.js

@@ -1038,7 +1038,7 @@ var config = {
  * @Author: baozhoutao@steedos.com
  * @Date: 2022-10-28 14:52:55
  * @LastEditors: liaodaxue
- * @LastEditTime: 2023-07-28 16:16:29
+ * @LastEditTime: 2023-12-14 12:01:22
  * @Description: 
  */
 
@@ -1055,6 +1055,7 @@ const AmisFormInputs = [
     'percent',
     'password',
     'url',
+    "color",
     'email'
 ];
 
@@ -1067,7 +1068,7 @@ function getAmisStaticFieldType(type, readonly, options){
         }
         return type;
     }
-    if(_$1.includes(['text','image'], type)){
+    if(_$1.includes(['text','image','color'], type)){
         if('text' === type && options && options.amis && options.amis.tpl){
             return 'static';
         }
@@ -1201,6 +1202,7 @@ var frontend_form_please_select$1 = "Please select";
 var frontend_form_confirm$1 = "Confirm";
 var frontend_form_delete$1 = "Delete";
 var frontend_form_view$1 = "view";
+var frontend_form_details$1 = "details";
 var frontend_delete_confirm_text$1 = "Are you sure you want to delete this item?";
 var frontend_delete_many_selected_required$1 = "Please select the item to be deleted";
 var frontend_delete_many_confirm_text$1 = "Are you sure you want to delete?";
@@ -1287,6 +1289,7 @@ var en_us = {
 	frontend_form_confirm: frontend_form_confirm$1,
 	frontend_form_delete: frontend_form_delete$1,
 	frontend_form_view: frontend_form_view$1,
+	frontend_form_details: frontend_form_details$1,
 	frontend_delete_confirm_text: frontend_delete_confirm_text$1,
 	frontend_delete_many_selected_required: frontend_delete_many_selected_required$1,
 	frontend_delete_many_confirm_text: frontend_delete_many_confirm_text$1,
@@ -1374,6 +1377,7 @@ var frontend_form_please_select = "请选择";
 var frontend_form_confirm = "确认";
 var frontend_form_delete = "删除";
 var frontend_form_view = "查看";
+var frontend_form_details = "详情";
 var frontend_delete_confirm_text = "确定要删除此项目?";
 var frontend_delete_many_selected_required = "请选择要删除的项";
 var frontend_delete_many_confirm_text = "确定要删除吗？";
@@ -1461,6 +1465,7 @@ var zh_cn = {
 	frontend_form_confirm: frontend_form_confirm,
 	frontend_form_delete: frontend_form_delete,
 	frontend_form_view: frontend_form_view,
+	frontend_form_details: frontend_form_details,
 	frontend_delete_confirm_text: frontend_delete_confirm_text,
 	frontend_delete_many_selected_required: frontend_delete_many_selected_required,
 	frontend_delete_many_confirm_text: frontend_delete_many_confirm_text,
@@ -1757,21 +1762,21 @@ async function getQuickEditSchema(field, options){
                     break;
                 case "avatar":
                 case "image":
-                quickEditSchema.body[0].receiver.adaptor = `
-                    const { context } = api.body; 
-                    var rootUrl = context.rootUrl + "/api/files/${field.type}s/";
-                    payload = {
-                        status: response.status == 200 ? 0 : response.status,
-                        msg: response.statusText,
-                        data: {
-                            value: rootUrl + payload._id,//为了实现图片crud的回显，需要将value从id改为url，当保存数据数据时，再在发送适配器内重新将id提取出来
-                            name: payload.original.name,
-                            url: rootUrl + payload._id,
+                    quickEditSchema.body[0].receiver.adaptor = `
+                        const { context } = api.body; 
+                        var rootUrl = context.rootUrl + "/api/files/${field.type}s/";
+                        payload = {
+                            status: response.status == 200 ? 0 : response.status,
+                            msg: response.statusText,
+                            data: {
+                                value: rootUrl + payload._id,//为了实现图片crud的回显，需要将value从id改为url，当保存数据数据时，再在发送适配器内重新将id提取出来
+                                name: payload.original.name,
+                                url: rootUrl + payload._id,
+                            }
                         }
-                    }
-                    return payload;
-                `;
-                break;
+                        return payload;
+                    `;
+                    break;
             }
             quickEditSchema.body[0].visibleOn = "${quickedit_record_permissions.allowEdit && quickedit_record_permissions_loading == false}";
             quickEditSchema.body.push({
@@ -1978,6 +1983,11 @@ async function getQuickEditSchema(field, options){
         if(field.type == "location"){
             quickEditSchema = false;
         }
+        if(field.type == "color"){
+            quickEditSchema = {
+                type: "input-color"
+            };
+        }
     }
     return quickEditSchema;
 }
@@ -2135,6 +2145,11 @@ async function getTableColumns(fields, options){
                     options: field.type === 'html' ? {html: true} : null
                     // toggled: true 
                 }, field.amis, {name: field.name});
+                
+                if(field.type === 'color'){
+                    columnItem.type = 'color';
+                    columnItem.defaultColor = null;
+                }
             }
         }
         if(columnItem){
@@ -4822,8 +4837,8 @@ const getSchema$2 = (uiSchema) => {
 /*
  * @Author: baozhoutao@steedos.com
  * @Date: 2022-11-07 17:00:38
- * @LastEditors: baozhoutao@steedos.com
- * @LastEditTime: 2023-08-24 16:44:42
+ * @LastEditors: liaodaxue
+ * @LastEditTime: 2023-12-13 10:09:05
  * @Description: 
  */
 
@@ -4834,7 +4849,7 @@ const getSchema$1 = (uiSchema)=>{
         "body": [
             {
                 "type": "button",
-                "label": i18next.t('frontend_form_view'),
+                "label": i18next.t('frontend_form_details'),
                 "className": "border-none",
                 "onEvent": {
                   "click": {
@@ -11515,6 +11530,23 @@ async function convertSFieldToAmisField(field, readonly, ctx) {
                 }
             }
 
+            break;
+        case 'color':
+            convertData = {
+                type: getAmisStaticFieldType('color', readonly),
+                name: field.name,
+                label: field.label
+            };
+            if(readonly){
+                convertData.defaultColor = null;
+            }else {
+                convertData.pipeIn = (value, data) => {
+                    if(value && value.indexOf('#')<0){
+                        return '#'+value;
+                    }
+                    return value;
+                };
+            }
             break;
         case 'boolean':
             convertData = {
@@ -12369,7 +12401,7 @@ async function getFormBody(permissionFields, formFields, ctx){
  * @Author: 殷亮辉 yinlianghui@hotoa.com
  * @Date: 2023-11-15 09:50:22
  * @LastEditors: 殷亮辉 yinlianghui@hotoa.com
- * @LastEditTime: 2023-12-12 17:13:37
+ * @LastEditTime: 2023-12-19 15:53:32
  */
 
 /**
@@ -12465,36 +12497,25 @@ async function getInputTableColumns(props) {
 function getFormPagination(props) {
     let onPageChangeScript = `
         let scope = event.context.scoped;
-        let paginationServiceId = event.data.paginationServiceId;
-        let wrapperServiceId = event.data.wrapperServiceId;
-        let formId = event.data.formId;
-        let fieldValue = event.data.changedItems;//这里不可以_.cloneDeep，因为翻页form中用的是event.data.changedItems，直接变更其值即可改变表单中的值
+        let __paginationServiceId = event.data.__paginationServiceId;
+        let __wrapperServiceId = event.data.__wrapperServiceId;
+        let __formId = event.data.__formId;
+        let fieldValue = event.data.__tableItems;//这里不可以_.cloneDeep，因为翻页form中用的是event.data.__tableItems，直接变更其值即可改变表单中的值
         let pageChangeDirection = context.props.pageChangeDirection;
-        let currentPage = event.data.page;
+        let currentPage = event.data.__page;
         let currentIndex = event.data.index;
 
-        // 翻页到下一页之前需要先把当前页改动的内容保存到中间变量changedItems中
-        let currentFormValues = scope.getComponentById(formId).getValues();
+        // 翻页到下一页之前需要先把当前页改动的内容保存到中间变量__tableItems中
+        let currentFormValues = scope.getComponentById(__formId).getValues();
         fieldValue[currentIndex] = currentFormValues;
-        // // 因为翻页form中用的是event.data.changedItems中的数据，所以不需要像下面这样doAction setValue变更中间变量changedItems值
-        // doAction({
-        //     "componentId": wrapperServiceId,
-        //     "actionType": "setValue",
-        //     "args": {
-        //         "value": {
-        //             "changedItems": fieldValue
-        //         }
-        //     }
-        // });
-        // 如果翻页到下一页前需要同时把改动的内容保存到最终正式的表单字段中，需要额外给正式表单字段执行一次setValue
-        // 但是同时保存到正式表单字段中会造成翻页后点击取消无法取消翻页之前的改动内容
-        // doAction({
-        //     "componentId": "${props.id}",
-        //     "actionType": "setValue",
-        //     "args": {
-        //         "value": fieldValue
-        //     }
-        // });
+        // 翻页到下一页前需要同时把改动的内容保存到最终正式的表单字段中，所以额外给正式表单字段执行一次setValue
+        doAction({
+            "componentId": "${props.id}",
+            "actionType": "setValue",
+            "args": {
+                "value": fieldValue
+            }
+        });
 
         // 以下是翻页逻辑，翻到下一页并把下一页内容显示到表单上
         let targetPage;
@@ -12505,13 +12526,13 @@ function getFormPagination(props) {
             targetPage = currentPage - 1;
         }
         let targetIndex = targetPage - 1;//input-table组件行索引，从0开始的索引
-        // let targetFormData = changedItems[targetIndex];
+        // let targetFormData = __tableItems[targetIndex];
         doAction({
             "actionType": "setValue",
-            "componentId": paginationServiceId,
+            "componentId": __paginationServiceId,
             "args": {
                 "value": {
-                    "page": targetPage,
+                    "__page": targetPage,
                     "index": targetIndex
                 }
             }
@@ -12519,7 +12540,7 @@ function getFormPagination(props) {
         // 这里不用进一步把表单内容setValue到form中，是因为编辑表单中schemaApi监听了行索引index的变化，其值变化时会重新build整个form
         // doAction({
         //     "actionType": "setValue",
-        //     "componentId": formId,
+        //     "componentId": __formId,
         //     "args": {
         //         "value": targetFormData
         //     },
@@ -12536,7 +12557,7 @@ function getFormPagination(props) {
                 "icon": `fa fa-angle-left`,
                 "level": "link",
                 "pageChangeDirection": "prev",
-                "disabledOn": "${page <= 1}",
+                "disabledOn": "${__page <= 1}",
                 "size": "sm",
                 "onEvent": {
                     "click": {
@@ -12551,7 +12572,7 @@ function getFormPagination(props) {
             },
             {
                 "type": "tpl",
-                "tpl": "${page}/${total}"
+                "tpl": "${__page}/${__total}"
             },
             {
                 "type": "button",
@@ -12559,7 +12580,7 @@ function getFormPagination(props) {
                 "icon": `fa fa-angle-right`,
                 "level": "link",
                 "pageChangeDirection": "next",
-                "disabledOn": "${page >= total}",
+                "disabledOn": "${__page >= __total}",
                 "size": "sm",
                 "onEvent": {
                     "click": {
@@ -12580,10 +12601,18 @@ function getFormPagination(props) {
  * 传入formSchema输出带翻页容器的wrapper
  * @param {*} props input-table组件props
  * @param {*} form formSchema
+ * @param {*} mode edit/readonly
  * @returns 带翻页容器的wrapper
  */
-function getFormPaginationWrapper(props, form) {
+function getFormPaginationWrapper(props, form, mode) {
     let serviceId = `service_popup_pagination_wrapper__${props.id}`;
+    let innerForm = Object.assign({}, form, {
+        "data": {
+            // 这里加__super前缀是因为__parentForm变量（即主表单）中可能会正好有名为index的字段
+            // 比如“对象字段”对象options字段是一个子表字段，但是主表（即“对象字段”对象）中正好有一个名为index的字段
+            "&": "${__tableItems[__super.index]}"
+        }
+    });
     let formBody = [
         {
             "type": "wrapper",
@@ -12593,59 +12622,56 @@ function getFormPaginationWrapper(props, form) {
                 getFormPagination(props)
             ]
         },
-        // form
-        Object.assign({}, form, {
-            "canAccessSuperData": false,
+        {
+            "type": "service",
+            "body": [
+                innerForm
+            ],
             "data": {
-                // "&": `\${${props.name}[index]}`,
-                "&": "${changedItems[index]}"
+                "&": "${__parentForm}"
             }
-        })
+        }
     ];
     let onServiceInitedScript = `
-        // 以下脚本在inlineEditMode模式时才有必要执行（不过执行了也没有坏处，纯粹是没必要），是为了解决：
-        // inlineEditMode模式时，用户在表格单元格中直接修改数据，然后弹出的表单form中并没有包含单元格中修改的内容
-        // 思路是每次弹出form之前先把其changedItems同步更新为最新值，这样就能在弹出form中包含单元格中做的修改
+        // 以下脚本是为了解决有时弹出编辑表单时，表单中的值比最后一次编辑保存的值会延迟一拍。
+        // 比如：inlineEditMode模式时，用户在表格单元格中直接修改数据，然后弹出的表单form中并没有包含单元格中修改的内容
+        // 另外有的地方在非inlineEditMode模式时也会有这种延迟一拍问题，比如对象字段中下拉框类型字段的”选择项“属性
+        // 再比如工作流规则详细页面修改了子表字段”时间触发器“值后，在只读界面点击查看按钮弹出的表单中__tableItems值是修改前的值
+        // 处理思路是每次弹出form之前先把其__tableItems同步更新为最新值，这样就能在弹出form中包含单元格中做的修改
         // 注意：service init事件只会在每次弹出窗口时才执行，在触发翻页时并不会触发service init事件
-        let inlineEditMode = ${props.inlineEditMode};
-        if(!inlineEditMode){
-            return;
-        }
         let scope = event.context.scoped;
-        let wrapperServiceId = event.data.wrapperServiceId;
-        let wrapperService = scope.getComponentById(wrapperServiceId);
+        let __wrapperServiceId = event.data.__wrapperServiceId;
+        let wrapperService = scope.getComponentById(__wrapperServiceId);
         let wrapperServiceData = wrapperService.getData();
         let lastestFieldValue = wrapperServiceData["${props.name}"];//这里不可以用event.data["${props.name}"]因为amis input talbe有一层单独的作用域，其值会延迟一拍
-        //不可以直接像event.data.changedItems = originalFieldValue; 这样整个赋值，否则作用域会断
-        event.data.changedItems.forEach(function(n,i){
-            event.data.changedItems[i] = lastestFieldValue[i];
+        //不可以直接像event.data.__tableItems = lastestFieldValue; 这样整个赋值，否则作用域会断
+        event.data.__tableItems.forEach(function(n,i){
+            event.data.__tableItems[i] = lastestFieldValue[i];
         });
     `;
     let schema = {
         "type": "service",
         "id": serviceId,
         "schemaApi": {
-            "url": "${context.rootUrl}/graphql?rebuildOn=${index}",
-            // "url": "${context.rootUrl}/graphql",
-            "method": "post",
-            "headers": {
-                "Authorization": "Bearer ${context.tenantId},${context.authToken}"
-            },
-            "requestAdaptor": "api.data={query: '{spaces__findOne(id: \"none\"){_id,name}}'};return api;",
+            // "url": "${context.rootUrl}/graphql?rebuildOn=${index}",
+            "url": "${context.rootUrl}/api/v1/spaces/none",
+            "trackExpression": "${index}",
+            "method": "get",
             "adaptor": `
                 const formBody = ${JSON.stringify(formBody)};
                 return {
                     "body": formBody
                 }
-            `
+            `,
+            "cache": 600000
         },
         // "body": formBody,
         "data": {
-            "page": "${index + 1}",
-            // "total": `\${${props.name}.length}`,
-            "total": "${changedItems.length}",
-            "paginationServiceId": serviceId,
-            "formId": form.id
+            "__page": "${index + 1}",
+            // "__total": `\${${props.name}.length}`,
+            "__total": "${__tableItems.length}",
+            "__paginationServiceId": serviceId,
+            "__formId": form.id
         },
         "onEvent": {
             "init": {
@@ -12665,25 +12691,30 @@ function getFormPaginationWrapper(props, form) {
  * @param {*} props 
  * @param {*} mode edit/new/readonly
  */
-async function getForm(props, mode = "edit") {
+async function getForm(props, mode = "edit", formId) {
     let formFields = getFormFields(props, mode);
     let body = await getFormBody(null, formFields);
-    let forId = `form_popup__${props.id}`;
+    if(!formId){
+        formId = `form_popup__${props.id}`;
+    }
     let schema = {
         "type": "form",
-        "id": forId,
+        "id": formId,
         "title": "表单",
         "debug": false,
         "mode": "normal",
         "body": body,
         "wrapWithPanel": false,
+        "canAccessSuperData": false,
         "className": "steedos-object-form steedos-amis-form"
     };
     if (mode === "edit") {
         let onEditItemSubmitScript = `
             // let fieldValue = _.cloneDeep(event.data["${props.name}"]);
-            let fieldValue = event.data.changedItems;//这里不可以_.cloneDeep，因为翻页form中用的是event.data.changedItems，直接变更其值即可改变表单中的值
-            fieldValue[event.data.index] = JSON.parse(JSON.stringify(event.data));
+            let fieldValue = event.data.__tableItems;//这里不可以_.cloneDeep，因为翻页form中用的是event.data.__tableItems，直接变更其值即可改变表单中的值
+            //这里加__super.__super前缀是因为__parentForm变量（即主表单）中可能会正好有名为index的字段
+            // 比如“对象字段”对象options字段是一个子表字段，但是主表（即“对象字段”对象）中正好有一个名为index的字段
+            fieldValue[event.data.__super.__super.index] = JSON.parse(JSON.stringify(event.data));
             doAction({
                 "componentId": "${props.id}",
                 "actionType": "setValue",
@@ -12691,16 +12722,6 @@ async function getForm(props, mode = "edit") {
                     "value": fieldValue
                 }
             });
-            // // 因为翻页form中用的是event.data.changedItems中的数据，所以不需要像下面这样doAction setValue变更中间变量changedItems值
-            // doAction({
-            //     "componentId": event.data.wrapperServiceId,
-            //     "actionType": "setValue",
-            //     "args": {
-            //         "value": {
-            //             "changedItems": fieldValue
-            //         }
-            //     }
-            // });
         `;
         Object.assign(schema, {
             "onEvent": {
@@ -12728,29 +12749,30 @@ async function getForm(props, mode = "edit") {
     }
     else if (mode === "new") {
         let onNewItemSubmitScript = `
-            // let fieldValue = _.cloneDeep(event.data["${props.name}"]);
-            if(!event.data.changedItems){
-                event.data.changedItems = [];
+            let newItem = JSON.parse(JSON.stringify(event.data));
+            if(event.data["${props.name}"]){
+                // let fieldValue = event.data.__tableItems;
+                // 这里不用__tableItems是因为新建的时候没有翻页，里面没有也不需要走__tableItems变量
+                let fieldValue = event.data["${props.name}"];
+                fieldValue.push(newItem);
+                doAction({
+                    "componentId": "${props.id}",
+                    "actionType": "setValue",
+                    "args": {
+                        "value": fieldValue
+                    }
+                });
+            }
+            else{
+                // 这里不可以执行event.data["${props.name}"]=[newItem]，数据域会断掉
+                doAction({
+                    "componentId": "${props.id}",
+                    "actionType": "setValue",
+                    "args": {
+                        "value": [newItem]
+                    }
+                });
             }
-            let fieldValue = event.data.changedItems;
-            fieldValue.push(JSON.parse(JSON.stringify(event.data)));
-            doAction({
-                "componentId": "${props.id}",
-                "actionType": "setValue",
-                "args": {
-                    "value": fieldValue
-                }
-            });
-            // // 因为翻页form中用的是event.data.changedItems中的数据，所以不需要像下面这样doAction setValue变更中间变量changedItems值
-            // doAction({
-            //     "componentId": event.data.wrapperServiceId,
-            //     "actionType": "setValue",
-            //     "args": {
-            //         "value": {
-            //             "changedItems": fieldValue
-            //         }
-            //     }
-            // });
         `;
         Object.assign(schema, {
             "onEvent": {
@@ -12783,6 +12805,7 @@ async function getForm(props, mode = "edit") {
 }
 
 async function getButtonNew(props) {
+    let formId = `form_popup__${props.id}`;
     return {
         "label": "新增",
         "type": "button",
@@ -12796,14 +12819,28 @@ async function getButtonNew(props) {
                             "type": "dialog",
                             "title": "新增行",
                             "body": [
-                                await getForm(props, "new")
+                                await getForm(props, "new", formId)
                             ],
                             "size": "lg",
                             "showCloseButton": true,
                             "showErrorMsg": true,
                             "showLoading": true,
                             "className": "app-popover",
-                            "closeOnEsc": false
+                            "closeOnEsc": false,
+                            "onEvent": {
+                                "confirm": {
+                                  "actions": [
+                                    {
+                                      "actionType": "validate",
+                                      "componentId": formId
+                                    },
+                                    {
+                                      "preventDefault": true,
+                                      "expression": "${event.data.validateResult.error}" //触发表单校验结果会存入validateResult，amis 3.2不支持，高版本比如 3.5.3支持
+                                    }
+                                  ]
+                                }
+                            }
                         }
                     }
                 ]
@@ -12814,27 +12851,7 @@ async function getButtonNew(props) {
 }
 
 async function getButtonEdit(props, showAsInlineEditMode) {
-    let onCancelScript = `
-        let scope = event.context.scoped;
-        let wrapperServiceId = event.data.wrapperServiceId;
-        let wrapperService = scope.getComponentById(wrapperServiceId);
-        let wrapperServiceData = wrapperService.getData();
-        let originalFieldValue = wrapperServiceData["${props.name}"];//这里不可以用event.data["${props.name}"]因为amis input talbe有一层单独的作用域，其值会延迟一拍
-        //不可以直接像event.data.changedItems = originalFieldValue; 这样整个赋值，否则作用域会断，造成无法还原
-        event.data.changedItems.forEach(function(n,i){
-            event.data.changedItems[i] = originalFieldValue[i];
-        });
-        // 因为翻页form中用的是event.data.changedItems中的数据，所以像下面这样doAction setValue无法实现还原
-        // doAction({
-        //     "componentId": wrapperServiceId,
-        //     "actionType": "setValue",
-        //     "args": {
-        //         "value": {
-        //             "changedItems": originalFieldValue
-        //         }
-        //     }
-        // });
-    `;
+    let formId = `form_popup__${props.id}`;
     return {
         "type": "button",
         "label": "",
@@ -12849,7 +12866,7 @@ async function getButtonEdit(props, showAsInlineEditMode) {
                             "type": "dialog",
                             "title": "编辑行",
                             "body": [
-                                await getForm(props, "edit")
+                                await getForm(props, "edit", formId)
                             ],
                             "size": "lg",
                             "showCloseButton": true,
@@ -12858,25 +12875,31 @@ async function getButtonEdit(props, showAsInlineEditMode) {
                             "className": "app-popover",
                             "closeOnEsc": false,
                             "data": {
-                                // 这里必须加data数据映射，否则翻页功能中取changedItems值时会乱，比如翻页编辑后会把上一页中没改过的字段值带过去
+                                // 这里必须加data数据映射，否则翻页功能中取__tableItems值时会乱，比如翻页编辑后会把上一页中没改过的字段值带过去
                                 // 额外把华炎魔方主表记录ObjectForm中的字段值从record变量中映射到子表form中，因为子表lookup字段filtersFunction中可能依赖了主表记录中的字段值，比如“工作流规则”对象“时间触发器”字段中的“日期字段”字段
                                 // 额外把global、uiSchema也映射过去，有可能要用，后续需要用到其他变更可以这里加映射
-                                "&": "${record || {}}",
+                                // "&": "${record || {}}",
+                                // 换成从__super来映射上级表单数据是因为对象列表视图界面中每行下拉菜单中的编辑按钮弹出的表单中的子表所在作用域中没有record变量
+                                // 映射到中间变量__parentForm而不是直接用&展开映射是为了避免表单中字段名与作用域中变量重名
+                                "__parentForm": "${__super.__super || {}}",
                                 "global": "${global}",
                                 "uiSchema": "${uiSchema}",
-                                "grid": "${grid}",
                                 "index": "${index}",
-                                "changedItems": "${changedItems}",
-                                "wrapperServiceId": "${wrapperServiceId}"
+                                "__tableItems": `\${${props.name}}`,
+                                "__wrapperServiceId": "${__wrapperServiceId}"
                             },
                             "onEvent": {
-                                "cancel": {
-                                    "actions": [
-                                        {
-                                            "actionType": "custom",
-                                            "script": onCancelScript
-                                        }
-                                    ]
+                                "confirm": {
+                                  "actions": [
+                                    {
+                                      "actionType": "validate",
+                                      "componentId": formId
+                                    },
+                                    {
+                                      "preventDefault": true,
+                                      "expression": "${event.data.validateResult.error}" //触发表单校验结果会存入validateResult，amis 3.2不支持，高版本比如 3.5.3支持
+                                    }
+                                  ]
                                 }
                             }
                         }
@@ -12912,14 +12935,16 @@ async function getButtonView(props) {
                             "closeOnEsc": false,
                             "actions": [],
                             "data": {
-                                // 这里必须加data数据映射，否则翻页功能中取changedItems值时会乱，比如翻页编辑后会把上一页中没改过的字段值带过去
+                                // 这里必须加data数据映射，否则翻页功能中取__tableItems值时会乱，比如翻页编辑后会把上一页中没改过的字段值带过去
                                 // 额外把华炎魔方主表记录ObjectForm中的字段值从formData变量中映射到子表form中，因为子表lookup字段filtersFunction中可能依赖了主表记录中的字段值，比如“工作流规则”对象“时间触发器”字段中的“日期字段”字段
                                 // global、uiSchema等常用变量本来就在formData变量已经存在了，无需另外映射
-                                "&": "${formData || {}}",
-                                "grid": "${grid}",
+                                // "&": "${formData || {}}",
+                                // 换成从__super来映射上级表单数据是因为对象列表视图界面中每行下拉菜单中的编辑按钮弹出的表单中的子表所在作用域中没有formData变量
+                                // 映射到中间变量__parentForm而不是直接用&展开映射是为了避免表单中字段名与作用域中变量重名
+                                "__parentForm": "${__super.__super || {}}",
                                 "index": "${index}",
-                                "changedItems": "${changedItems}",
-                                "wrapperServiceId": "${wrapperServiceId}"
+                                "__tableItems": `\${${props.name}}`,
+                                "__wrapperServiceId": "${__wrapperServiceId}"
                             }
                         }
                     }
@@ -12931,30 +12956,20 @@ async function getButtonView(props) {
 
 function getButtonDelete(props) {
     let onDeleteItemScript = `
-        // let fieldValue = _.cloneDeep(event.data["${props.name}"]);
-        if(!event.data.changedItems){
-            event.data.changedItems = [];
-        }
-        let fieldValue = event.data.changedItems;
-        // fieldValue.push(JSON.parse(JSON.stringify(event.data)));
-        fieldValue.splice(event.data.index, 1)
+        // let fieldValue = event.data["${props.name}"];
+        let scope = event.context.scoped;
+        let __wrapperServiceId = event.data.__wrapperServiceId;
+        let wrapperService = scope.getComponentById(__wrapperServiceId);
+        let wrapperServiceData = wrapperService.getData();
+        let lastestFieldValue = wrapperServiceData["${props.name}"];//这里不可以用event.data["${props.name}"]因为amis input talbe有一层单独的作用域，其值会延迟一拍
+        lastestFieldValue.splice(event.data.index, 1);
         doAction({
             "componentId": "${props.id}",
             "actionType": "setValue",
             "args": {
-                "value": fieldValue
+                "value": lastestFieldValue
             }
         });
-        // // 因为翻页form中用的是event.data.changedItems中的数据，所以不需要像下面这样doAction setValue变更中间变量changedItems值
-        // doAction({
-        //     "componentId": event.data.wrapperServiceId,
-        //     "actionType": "setValue",
-        //     "args": {
-        //         "value": {
-        //             "changedItems": fieldValue
-        //         }
-        //     }
-        // });
     `;
     return {
         "type": "button",
@@ -12992,13 +13007,15 @@ const getAmisInputTableSchema = async (props) => {
     if (props.editable) {
         let showEditButton = true;
         if (showAsInlineEditMode) {
-            // inline edit模式下只在有列被隐藏时才需要显示编辑按钮
-            if (props.columns && props.columns.length > 0 && props.columns.length < props.fields.length) {
-                showEditButton = true;
-            }
-            else {
-                showEditButton = false;
-            }
+            // 始终显示弹出子表表单按钮，如果需要判断只在有列被隐藏时才需要显示弹出表单按钮放开下面的if逻辑就好
+            showEditButton = true;
+            // // inline edit模式下只在有列被隐藏时才需要显示编辑按钮
+            // if (props.columns && props.columns.length > 0 && props.columns.length < props.fields.length) {
+            //     showEditButton = true;
+            // }
+            // else {
+            //     showEditButton = false;
+            // }
         }
         // 编辑时显示编辑按钮
         if (showEditButton) {
@@ -13008,11 +13025,9 @@ const getAmisInputTableSchema = async (props) => {
     }
     else {
         // 只读时显示查看按钮
-        if (props.columns && props.columns.length > 0 && props.columns.length < props.fields.length) {
-            // 只在有列被隐藏时才需要显示查看按钮
-            let buttonViewSchema = await getButtonView(props);
-            buttonsForColumnOperations.push(buttonViewSchema);
-        }
+        // 如果想只在有列被隐藏时才需要显示查看按钮可以加上判断：if (props.columns && props.columns.length > 0 && props.columns.length < props.fields.length)
+        let buttonViewSchema = await getButtonView(props);
+        buttonsForColumnOperations.push(buttonViewSchema);
     }
     if (props.removable) {
         let buttonDeleteSchema = getButtonDelete(props);
@@ -13032,7 +13047,7 @@ const getAmisInputTableSchema = async (props) => {
         "id": props.id,
         "columns": await getInputTableColumns(props),
         // "needConfirm": false, //不可以配置为false，否则，单元格都是可编辑状态，且很多static类型无法正常显示，比如static-mapping
-        "strictMode": true,
+        "strictMode": props.strictMode,
         "showTableAddBtn": false,
         "showFooterAddBtn": false,
         "className": props.tableClassName
@@ -13048,40 +13063,53 @@ const getAmisInputTableSchema = async (props) => {
     if (showAsInlineEditMode) {
         inputTableSchema.needConfirm = false;
     }
-    let dataProviderInited = `
-        // 单独维护一份中间变量changedItems，因为原变量在input-table组件有单独的作用域，翻页功能中无法维护此作用域中的行记录值
-        setData({ changedItems: _.cloneDeep(data["${props.name}"]) || []});
-    `;
-    let schema = {
-        "type": "service",
-        "body": [
-            inputTableSchema
-        ],
-        "className": props.className,
-        "id": serviceId,
-        "data": {
-            "wrapperServiceId": serviceId
-        },
-        "dataProvider": {
-            "inited": dataProviderInited
-        }
-    };
+    let amis = props["input-table"] || props.amis;//额外支持"input-table"代替amis属性，是因为在字段yml文件中用amis作为key不好理解
+    if (amis) {
+        // 支持配置amis属性重写或添加最终生成的input-table中任何属性。
+        delete amis.id;//如果steedos-input-table组件配置了amis.id属性，会造成新建编辑行功能不生效
+        Object.assign(inputTableSchema, amis);
+    }
+    const isAnyFieldHasDependOn = (props.fields || []).find(function (item) {
+        return item.depend_on;
+    });
+    if (isAnyFieldHasDependOn) {
+        // 有任意一个子字段有depend_on属性时，强制设置禁用静态模式
+        Object.assign(inputTableSchema, {
+            strictMode: false
+        });
+    }
+    let schemaBody = [inputTableSchema];
     let footerToolbar = clone(props.footerToolbar || []); //这里不clone的话，会造成死循环，应该是因为props属性变更会让组件重新渲染
     if (props.addable) {
         let buttonNewSchema = await getButtonNew(props);
         footerToolbar.unshift(buttonNewSchema);
     }
     if (footerToolbar.length) {
-        schema.body.push({
+        schemaBody.push({
             "type": "wrapper",
             "size": "none",
             "body": footerToolbar
         });
     }
-    if (props.amis) {
-        delete props.amis.id;
-        Object.assign(schema.body[0], props.amis);
-    }
+    // 不可以直接把headerToolbar unshift进schemaBody，因为它没有显示在label下面，而是显示在上面了，这没有意义
+    // 看起来amis官方后续会支持给input-table组件配置headerToolbar，见：https://github.com/baidu/amis/issues/7246
+    // let headerToolbar = clone(props.headerToolbar || []); //这里不clone的话，会造成死循环，应该是因为props属性变更会让组件重新渲染
+    // if (headerToolbar.length) {
+    //     schemaBody.unshift({
+    //         "type": "wrapper",
+    //         "size": "none",
+    //         "body": headerToolbar
+    //     });
+    // }
+    let schema = {
+        "type": "service",
+        "body": schemaBody,
+        "className": props.className,
+        "id": serviceId,
+        "data": {
+            "__wrapperServiceId": serviceId
+        }
+    };
     // console.log("===schema===", schema);
     return schema;
 };