@ant-design/pro-components 2.8.9 → 3.0.0-beta.1

package/es/utils/useEditableArray/index.js

@@ -0,0 +1,726 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/utils/useEditableArray/index.tsx
+import { LoadingOutlined } from "@ant-design/icons";
+import { Form, Popconfirm, message } from "antd";
+import useLazyKVMap from "antd/lib/table/hooks/useLazyKVMap";
+import useMergedState from "rc-util/lib/hooks/useMergedState";
+import get from "rc-util/lib/utils/get";
+import set from "rc-util/lib/utils/set";
+import { noteOnce } from "rc-util/lib/warning";
+import React, {
+  createRef,
+  forwardRef,
+  useContext,
+  useEffect,
+  useImperativeHandle,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { useDebounceFn, useRefFunction } from "..";
+import { useIntl } from "../../provider";
+import { ProFormContext } from "../components/ProFormContext";
+import { useDeepCompareEffectDebounce } from "../hooks/useDeepCompareEffect";
+import { usePrevious } from "../hooks/usePrevious";
+import { merge } from "../merge";
+import { useMountMergeState } from "../useMountMergeState";
+var warning = (messageStr) => {
+  return (message.warn || message.warning)(messageStr);
+};
+var recordKeyToString = (rowKey) => {
+  if (Array.isArray(rowKey))
+    return rowKey.join(",");
+  return rowKey;
+};
+function editableRowByKey(keyProps, action) {
+  var _a;
+  const { getRowKey, row, data, childrenColumnName = "children" } = keyProps;
+  const key = (_a = recordKeyToString(keyProps.key)) == null ? void 0 : _a.toString();
+  const kvMap = /* @__PURE__ */ new Map();
+  function dig(records, map_row_parentKey, map_row_index) {
+    records.forEach((record, index) => {
+      const eachIndex = (map_row_index || 0) * 10 + index;
+      const recordKey = getRowKey(record, eachIndex).toString();
+      if (record && typeof record === "object" && childrenColumnName in record) {
+        dig(record[childrenColumnName] || [], recordKey, eachIndex);
+      }
+      const newRecord = __spreadProps(__spreadValues({}, record), {
+        map_row_key: recordKey,
+        children: void 0,
+        map_row_parentKey
+      });
+      delete newRecord.children;
+      if (!map_row_parentKey) {
+        delete newRecord.map_row_parentKey;
+      }
+      kvMap.set(recordKey, newRecord);
+    });
+  }
+  if (action === "top") {
+    kvMap.set(key, __spreadValues(__spreadValues({}, kvMap.get(key)), row));
+  }
+  dig(data);
+  if (action === "update") {
+    kvMap.set(key, __spreadValues(__spreadValues({}, kvMap.get(key)), row));
+  }
+  if (action === "delete") {
+    kvMap.delete(key);
+  }
+  const fill = (map) => {
+    const kvArrayMap = /* @__PURE__ */ new Map();
+    const kvSource = [];
+    const fillNewRecord = (fillChildren = false) => {
+      map.forEach((value) => {
+        var _b;
+        if (value.map_row_parentKey && !value.map_row_key) {
+          const _a2 = value, { map_row_parentKey } = _a2, rest = __objRest(_a2, ["map_row_parentKey"]);
+          if (!kvArrayMap.has(map_row_parentKey)) {
+            kvArrayMap.set(map_row_parentKey, []);
+          }
+          if (fillChildren) {
+            (_b = kvArrayMap.get(map_row_parentKey)) == null ? void 0 : _b.push(rest);
+          }
+        }
+      });
+    };
+    fillNewRecord(action === "top");
+    map.forEach((value) => {
+      var _b;
+      if (value.map_row_parentKey && value.map_row_key) {
+        const _a2 = value, { map_row_parentKey, map_row_key } = _a2, rest = __objRest(_a2, ["map_row_parentKey", "map_row_key"]);
+        if (kvArrayMap.has(map_row_key)) {
+          rest[childrenColumnName] = kvArrayMap.get(map_row_key);
+        }
+        if (!kvArrayMap.has(map_row_parentKey)) {
+          kvArrayMap.set(map_row_parentKey, []);
+        }
+        (_b = kvArrayMap.get(map_row_parentKey)) == null ? void 0 : _b.push(rest);
+      }
+    });
+    fillNewRecord(action === "update");
+    map.forEach((value) => {
+      if (!value.map_row_parentKey) {
+        const _a2 = value, { map_row_key } = _a2, rest = __objRest(_a2, ["map_row_key"]);
+        if (map_row_key && kvArrayMap.has(map_row_key)) {
+          const item = __spreadProps(__spreadValues({}, rest), {
+            [childrenColumnName]: kvArrayMap.get(map_row_key)
+          });
+          kvSource.push(item);
+          return;
+        }
+        kvSource.push(rest);
+      }
+    });
+    return kvSource;
+  };
+  return fill(kvMap);
+}
+function SaveEditableAction({
+  recordKey,
+  onSave,
+  row,
+  children,
+  newLineConfig,
+  editorType,
+  tableName
+}, ref) {
+  const context = useContext(ProFormContext);
+  const form = Form.useFormInstance();
+  const [loading, setLoading] = useMountMergeState(false);
+  const save = useRefFunction(() => __async(this, null, function* () {
+    var _a;
+    try {
+      const isMapEditor = editorType === "Map";
+      const namePath = [
+        tableName,
+        Array.isArray(recordKey) ? recordKey[0] : recordKey
+      ].map((key) => key == null ? void 0 : key.toString()).flat(1).filter(Boolean);
+      setLoading(true);
+      yield form.validateFields(namePath, {
+        recursive: true
+      });
+      const fields = ((_a = context == null ? void 0 : context.getFieldFormatValue) == null ? void 0 : _a.call(context, namePath)) || form.getFieldValue(namePath);
+      if (Array.isArray(recordKey) && recordKey.length > 1) {
+        const [, ...recordKeyPath] = recordKey;
+        const curValue = get(fields, recordKeyPath);
+        set(fields, recordKeyPath, curValue);
+      }
+      const data = isMapEditor ? set({}, namePath, fields) : fields;
+      const res = yield onSave == null ? void 0 : onSave(
+        recordKey,
+        // 如果是 map 模式，fields 就是一个值，所以需要set 到对象中
+        // 数据模式 fields 是一个对象，所以不需要
+        merge({}, row, data),
+        row,
+        newLineConfig
+      );
+      setLoading(false);
+      return res;
+    } catch (error) {
+      setLoading(false);
+      throw error;
+    }
+  }));
+  useImperativeHandle(
+    ref,
+    () => ({
+      save
+    }),
+    [save]
+  );
+  return /* @__PURE__ */ React.createElement(
+    "a",
+    {
+      key: "save",
+      onClick: (e) => __async(this, null, function* () {
+        e.stopPropagation();
+        e.preventDefault();
+        try {
+          yield save();
+        } catch (e2) {
+        }
+      })
+    },
+    loading ? /* @__PURE__ */ React.createElement(
+      LoadingOutlined,
+      {
+        style: {
+          marginInlineEnd: 8
+        }
+      }
+    ) : null,
+    children || "保存"
+  );
+}
+var DeleteEditableAction = ({
+  recordKey,
+  onDelete,
+  preEditRowRef,
+  row,
+  children,
+  deletePopconfirmMessage
+}) => {
+  const [loading, setLoading] = useMountMergeState(() => false);
+  const onConfirm = useRefFunction(() => __async(void 0, null, function* () {
+    try {
+      setLoading(true);
+      const res = yield onDelete == null ? void 0 : onDelete(recordKey, row);
+      setLoading(false);
+      return res;
+    } catch (e) {
+      setLoading(false);
+      return null;
+    } finally {
+      if (preEditRowRef)
+        preEditRowRef.current = null;
+    }
+  }));
+  return children !== false ? /* @__PURE__ */ React.createElement(
+    Popconfirm,
+    {
+      key: "delete",
+      title: deletePopconfirmMessage,
+      onConfirm: () => onConfirm()
+    },
+    /* @__PURE__ */ React.createElement("a", null, loading ? /* @__PURE__ */ React.createElement(
+      LoadingOutlined,
+      {
+        style: {
+          marginInlineEnd: 8
+        }
+      }
+    ) : null, children || "删除")
+  ) : null;
+};
+var CancelEditableAction = (props) => {
+  const {
+    recordKey,
+    tableName,
+    newLineConfig,
+    editorType,
+    onCancel,
+    cancelEditable,
+    row,
+    cancelText,
+    preEditRowRef
+  } = props;
+  const context = useContext(ProFormContext);
+  const form = Form.useFormInstance();
+  return /* @__PURE__ */ React.createElement(
+    "a",
+    {
+      key: "cancel",
+      onClick: (e) => __async(void 0, null, function* () {
+        var _a, _b;
+        e.stopPropagation();
+        e.preventDefault();
+        const isMapEditor = editorType === "Map";
+        const namePath = [tableName, recordKey].flat(1).filter(Boolean);
+        const fields = ((_a = context == null ? void 0 : context.getFieldFormatValue) == null ? void 0 : _a.call(context, namePath)) || (form == null ? void 0 : form.getFieldValue(namePath));
+        const record = isMapEditor ? set({}, namePath, fields) : fields;
+        const res = yield onCancel == null ? void 0 : onCancel(recordKey, record, row, newLineConfig);
+        yield cancelEditable(recordKey);
+        if ((preEditRowRef == null ? void 0 : preEditRowRef.current) !== null) {
+          form.setFieldsValue(set({}, namePath, preEditRowRef == null ? void 0 : preEditRowRef.current));
+        } else {
+          yield (_b = props.onDelete) == null ? void 0 : _b.call(props, recordKey, row);
+        }
+        if (preEditRowRef)
+          preEditRowRef.current = null;
+        return res;
+      })
+    },
+    cancelText || "取消"
+  );
+};
+function defaultActionRender(row, config) {
+  const { recordKey, newLineConfig, saveText, deleteText } = config;
+  const SaveEditableActionRef = forwardRef(
+    SaveEditableAction
+  );
+  const saveRef = createRef();
+  return {
+    save: /* @__PURE__ */ React.createElement(
+      SaveEditableActionRef,
+      __spreadProps(__spreadValues({
+        key: "save" + recordKey
+      }, config), {
+        row,
+        ref: saveRef
+      }),
+      saveText
+    ),
+    saveRef,
+    delete: (newLineConfig == null ? void 0 : newLineConfig.options.recordKey) !== recordKey ? /* @__PURE__ */ React.createElement(DeleteEditableAction, __spreadProps(__spreadValues({ key: "delete" + recordKey }, config), { row }), deleteText) : void 0,
+    cancel: /* @__PURE__ */ React.createElement(CancelEditableAction, __spreadProps(__spreadValues({ key: "cancel" + recordKey }, config), { row }))
+  };
+}
+function useEditableArray(props) {
+  const intl = useIntl();
+  const preEditRowRef = useRef(null);
+  const [newLineRecordCache, setNewLineRecordCache] = useState(void 0);
+  const resetMapRef = () => {
+    const map = /* @__PURE__ */ new Map();
+    const loopGetKey = (dataSource, parentKey) => {
+      dataSource == null ? void 0 : dataSource.forEach((record, index) => {
+        var _a;
+        const key = parentKey === void 0 || parentKey === null ? index.toString() : parentKey + "_" + index.toString();
+        map.set(key, recordKeyToString(props.getRowKey(record, -1)));
+        map.set(
+          (_a = recordKeyToString(props.getRowKey(record, -1))) == null ? void 0 : _a.toString(),
+          key
+        );
+        if (props.childrenColumnName && (record == null ? void 0 : record[props.childrenColumnName])) {
+          loopGetKey(record[props.childrenColumnName], key);
+        }
+      });
+    };
+    loopGetKey(props.dataSource);
+    return map;
+  };
+  const initDataSourceKeyIndexMap = useMemo(() => resetMapRef(), []);
+  const dataSourceKeyIndexMapRef = useRef(
+    initDataSourceKeyIndexMap
+  );
+  const newLineRecordRef = useRef(
+    void 0
+  );
+  useDeepCompareEffectDebounce(() => {
+    dataSourceKeyIndexMapRef.current = resetMapRef();
+  }, [props.dataSource]);
+  newLineRecordRef.current = newLineRecordCache;
+  const editableType = props.type || "single";
+  const [getRecordByKey] = useLazyKVMap(
+    props.dataSource,
+    "children",
+    props.getRowKey
+  );
+  const [editableKeys, setEditableRowKeys] = useMergedState([], {
+    value: props.editableKeys,
+    onChange: props.onChange ? (keys) => {
+      var _a, _b, _c;
+      (_c = props == null ? void 0 : props.onChange) == null ? void 0 : _c.call(
+        props,
+        // 计算编辑的key
+        (_a = keys == null ? void 0 : keys.filter((key) => key !== void 0)) != null ? _a : [],
+        // 计算编辑的行
+        (_b = keys == null ? void 0 : keys.map((key) => getRecordByKey(key)).filter((key) => key !== void 0)) != null ? _b : []
+      );
+    } : void 0
+  });
+  const editableKeysSet = useMemo(() => {
+    const keys = editableType === "single" ? editableKeys == null ? void 0 : editableKeys.slice(0, 1) : editableKeys;
+    return new Set(keys);
+  }, [(editableKeys || []).join(","), editableType]);
+  const editableKeysRef = usePrevious(editableKeys);
+  const isEditable = useRefFunction((row) => {
+    var _a, _b, _c, _d;
+    const recordKeyOrIndex = (_b = (_a = props.getRowKey(row, row.index)) == null ? void 0 : _a.toString) == null ? void 0 : _b.call(_a);
+    const recordKey = (_d = (_c = props.getRowKey(row, -1)) == null ? void 0 : _c.toString) == null ? void 0 : _d.call(_c);
+    const stringEditableKeys = editableKeys == null ? void 0 : editableKeys.map((key) => key == null ? void 0 : key.toString());
+    const stringEditableKeysRef = (editableKeysRef == null ? void 0 : editableKeysRef.map((key) => key == null ? void 0 : key.toString())) || [];
+    const preIsEditable = props.tableName && !!(stringEditableKeysRef == null ? void 0 : stringEditableKeysRef.includes(recordKey)) || !!(stringEditableKeysRef == null ? void 0 : stringEditableKeysRef.includes(recordKeyOrIndex));
+    return {
+      recordKey,
+      isEditable: props.tableName && (stringEditableKeys == null ? void 0 : stringEditableKeys.includes(recordKey)) || (stringEditableKeys == null ? void 0 : stringEditableKeys.includes(recordKeyOrIndex)),
+      preIsEditable
+    };
+  });
+  const startEditable = useRefFunction(
+    (recordKey, record) => {
+      var _a, _b;
+      if (editableKeysSet.size > 0 && editableType === "single" && props.onlyOneLineEditorAlertMessage !== false) {
+        warning(
+          props.onlyOneLineEditorAlertMessage || intl.getMessage(
+            "editableTable.onlyOneLineEditor",
+            "只能同时编辑一行"
+          )
+        );
+        return false;
+      }
+      editableKeysSet.add(recordKey);
+      setEditableRowKeys(Array.from(editableKeysSet));
+      preEditRowRef.current = (_b = record != null ? record : (_a = props.dataSource) == null ? void 0 : _a.find((recordData, index) => {
+        return props.getRowKey(recordData, index) === recordKey;
+      })) != null ? _b : null;
+      return true;
+    }
+  );
+  const cancelEditable = useRefFunction(
+    (recordKey, needReTry) => __async(this, null, function* () {
+      const relayKey = recordKeyToString(recordKey).toString();
+      const key = dataSourceKeyIndexMapRef.current.get(relayKey);
+      if (!editableKeysSet.has(relayKey) && key && (needReTry != null ? needReTry : true) && props.tableName) {
+        cancelEditable(key, false);
+        return;
+      }
+      if (newLineRecordCache && newLineRecordCache.options.recordKey === recordKey) {
+        setNewLineRecordCache(void 0);
+      }
+      editableKeysSet.delete(relayKey);
+      editableKeysSet.delete(recordKeyToString(recordKey));
+      setEditableRowKeys(Array.from(editableKeysSet));
+      return true;
+    })
+  );
+  const propsOnValuesChange = useDebounceFn((...rest) => __async(this, null, function* () {
+    var _a;
+    (_a = props.onValuesChange) == null ? void 0 : _a.call(props, ...rest);
+  }), 64);
+  const onValuesChange = useRefFunction(
+    (value, values) => {
+      var _a;
+      if (!props.onValuesChange) {
+        return;
+      }
+      let { dataSource } = props;
+      editableKeys == null ? void 0 : editableKeys.forEach((eachRecordKey) => {
+        if ((newLineRecordCache == null ? void 0 : newLineRecordCache.options.recordKey) === eachRecordKey)
+          return;
+        const recordKey2 = eachRecordKey.toString();
+        const editRow2 = get(
+          values,
+          [props.tableName || "", recordKey2].flat(1).filter((key) => key || key === 0)
+        );
+        if (!editRow2)
+          return;
+        dataSource = editableRowByKey(
+          {
+            data: dataSource,
+            getRowKey: props.getRowKey,
+            row: editRow2,
+            key: recordKey2,
+            childrenColumnName: props.childrenColumnName || "children"
+          },
+          "update"
+        );
+      });
+      const relayValue = value;
+      const recordKey = (_a = Object.keys(relayValue || {}).pop()) == null ? void 0 : _a.toString();
+      const newLineRecordData = __spreadValues(__spreadValues({}, newLineRecordCache == null ? void 0 : newLineRecordCache.defaultValue), get(
+        values,
+        [props.tableName || "", recordKey.toString()].flat(1).filter((key) => key || key === 0)
+      ));
+      const editRow = dataSourceKeyIndexMapRef.current.has(
+        recordKeyToString(recordKey)
+      ) ? dataSource.find((item, index) => {
+        var _a2;
+        const key = (_a2 = props.getRowKey(item, index)) == null ? void 0 : _a2.toString();
+        return key === recordKey;
+      }) : newLineRecordData;
+      propsOnValuesChange.run(editRow || newLineRecordData, dataSource);
+    }
+  );
+  const saveRefsMap = useRef(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    saveRefsMap.current.forEach((ref, key) => {
+      if (!editableKeysSet.has(key)) {
+        saveRefsMap.current.delete(key);
+      }
+    });
+  }, [saveRefsMap, editableKeysSet]);
+  const saveEditable = useRefFunction(
+    (recordKey, needReTry) => __async(this, null, function* () {
+      var _a;
+      const relayKey = recordKeyToString(recordKey);
+      const key = dataSourceKeyIndexMapRef.current.get(recordKey.toString());
+      if (!editableKeysSet.has(relayKey) && key && (needReTry != null ? needReTry : true) && props.tableName) {
+        return yield saveEditable(key, false);
+      }
+      const saveRef = saveRefsMap.current.get(relayKey) || saveRefsMap.current.get(relayKey.toString());
+      try {
+        yield (_a = saveRef == null ? void 0 : saveRef.current) == null ? void 0 : _a.save();
+      } catch (e) {
+        return false;
+      }
+      editableKeysSet.delete(relayKey);
+      editableKeysSet.delete(relayKey.toString());
+      setEditableRowKeys(Array.from(editableKeysSet));
+      return true;
+    })
+  );
+  const addEditRecord = useRefFunction(
+    (row, options) => {
+      var _a;
+      if ((options == null ? void 0 : options.parentKey) && !dataSourceKeyIndexMapRef.current.has(
+        recordKeyToString(options == null ? void 0 : options.parentKey).toString()
+      )) {
+        console.warn("can't find record by key", options == null ? void 0 : options.parentKey);
+        return false;
+      }
+      if (newLineRecordRef.current && props.onlyAddOneLineAlertMessage !== false) {
+        warning(
+          props.onlyAddOneLineAlertMessage || intl.getMessage("editableTable.onlyAddOneLine", "只能新增一行")
+        );
+        return false;
+      }
+      if (editableKeysSet.size > 0 && editableType === "single" && props.onlyOneLineEditorAlertMessage !== false) {
+        warning(
+          props.onlyOneLineEditorAlertMessage || intl.getMessage(
+            "editableTable.onlyOneLineEditor",
+            "只能同时编辑一行"
+          )
+        );
+        return false;
+      }
+      const recordKey = props.getRowKey(row, -1);
+      if (!recordKey && recordKey !== 0) {
+        noteOnce(
+          !!recordKey,
+          "请设置 recordCreatorProps.record 并返回一个唯一的key  \n  https://procomponents.ant.design/components/editable-table#editable-%E6%96%B0%E5%BB%BA%E8%A1%8C"
+        );
+        throw new Error("请设置 recordCreatorProps.record 并返回一个唯一的key");
+      }
+      editableKeysSet.add(recordKey);
+      setEditableRowKeys(Array.from(editableKeysSet));
+      if ((options == null ? void 0 : options.newRecordType) === "dataSource" || props.tableName) {
+        const actionProps = {
+          data: props.dataSource,
+          getRowKey: props.getRowKey,
+          row: __spreadProps(__spreadValues({}, row), {
+            map_row_parentKey: (options == null ? void 0 : options.parentKey) ? (_a = recordKeyToString(options == null ? void 0 : options.parentKey)) == null ? void 0 : _a.toString() : void 0
+          }),
+          key: recordKey,
+          childrenColumnName: props.childrenColumnName || "children"
+        };
+        props.setDataSource(
+          editableRowByKey(
+            actionProps,
+            (options == null ? void 0 : options.position) === "top" ? "top" : "update"
+          )
+        );
+      } else {
+        setNewLineRecordCache({
+          defaultValue: row,
+          options: __spreadProps(__spreadValues({}, options), {
+            recordKey
+          })
+        });
+      }
+      return true;
+    }
+  );
+  const saveText = (props == null ? void 0 : props.saveText) || intl.getMessage("editableTable.action.save", "保存");
+  const deleteText = (props == null ? void 0 : props.deleteText) || intl.getMessage("editableTable.action.delete", "删除");
+  const cancelText = (props == null ? void 0 : props.cancelText) || intl.getMessage("editableTable.action.cancel", "取消");
+  const actionSaveRef = useRefFunction(
+    (recordKey, editRow, originRow, newLine) => __async(this, null, function* () {
+      var _a, _b, _c;
+      const res = yield (_a = props == null ? void 0 : props.onSave) == null ? void 0 : _a.call(props, recordKey, editRow, originRow, newLine);
+      yield cancelEditable(recordKey);
+      const { options } = newLine || newLineRecordRef.current || {};
+      if (!(options == null ? void 0 : options.parentKey) && (options == null ? void 0 : options.recordKey) === recordKey) {
+        if ((options == null ? void 0 : options.position) === "top") {
+          props.setDataSource([editRow, ...props.dataSource]);
+        } else {
+          props.setDataSource([...props.dataSource, editRow]);
+        }
+        return res;
+      }
+      const actionProps = {
+        data: props.dataSource,
+        getRowKey: props.getRowKey,
+        row: options ? __spreadProps(__spreadValues({}, editRow), {
+          map_row_parentKey: (_c = recordKeyToString(
+            (_b = options == null ? void 0 : options.parentKey) != null ? _b : ""
+          )) == null ? void 0 : _c.toString()
+        }) : editRow,
+        key: recordKey,
+        childrenColumnName: props.childrenColumnName || "children"
+      };
+      props.setDataSource(
+        editableRowByKey(
+          actionProps,
+          (options == null ? void 0 : options.position) === "top" ? "top" : "update"
+        )
+      );
+      yield cancelEditable(recordKey);
+      return res;
+    })
+  );
+  const actionDeleteRef = useRefFunction(
+    (recordKey, editRow) => __async(this, null, function* () {
+      var _a;
+      const actionProps = {
+        data: props.dataSource,
+        getRowKey: props.getRowKey,
+        row: editRow,
+        key: recordKey,
+        childrenColumnName: props.childrenColumnName || "children"
+      };
+      const res = yield (_a = props == null ? void 0 : props.onDelete) == null ? void 0 : _a.call(props, recordKey, editRow);
+      yield cancelEditable(recordKey, false);
+      props.setDataSource(editableRowByKey(actionProps, "delete"));
+      return res;
+    })
+  );
+  const actionCancelRef = useRefFunction(
+    (recordKey, editRow, originRow, newLine) => __async(this, null, function* () {
+      var _a;
+      const res = yield (_a = props == null ? void 0 : props.onCancel) == null ? void 0 : _a.call(
+        props,
+        recordKey,
+        editRow,
+        originRow,
+        newLine
+      );
+      return res;
+    })
+  );
+  const existCustomActionRender = props.actionRender && typeof props.actionRender === "function";
+  const customActionRender = existCustomActionRender ? props.actionRender : () => {
+  };
+  const customActionRenderRef = useRefFunction(
+    customActionRender
+  );
+  const actionRender = (row) => {
+    const key = props.getRowKey(row, row.index);
+    const config = {
+      saveText,
+      cancelText,
+      deleteText,
+      addEditRecord,
+      recordKey: key,
+      cancelEditable,
+      index: row.index,
+      tableName: props.tableName,
+      newLineConfig: newLineRecordCache,
+      onCancel: actionCancelRef,
+      onDelete: actionDeleteRef,
+      onSave: actionSaveRef,
+      editableKeys,
+      setEditableRowKeys,
+      preEditRowRef,
+      deletePopconfirmMessage: props.deletePopconfirmMessage || `${intl.getMessage("deleteThisLine", "删除此项")}?`
+    };
+    const renderResult = defaultActionRender(row, config);
+    if (props.tableName) {
+      saveRefsMap.current.set(
+        dataSourceKeyIndexMapRef.current.get(recordKeyToString(key)) || recordKeyToString(key),
+        renderResult.saveRef
+      );
+    } else {
+      saveRefsMap.current.set(recordKeyToString(key), renderResult.saveRef);
+    }
+    if (existCustomActionRender)
+      return customActionRenderRef(row, config, {
+        save: renderResult.save,
+        delete: renderResult.delete,
+        cancel: renderResult.cancel
+      });
+    return [renderResult.save, renderResult.delete, renderResult.cancel];
+  };
+  return {
+    editableKeys,
+    setEditableRowKeys,
+    isEditable,
+    actionRender,
+    startEditable,
+    cancelEditable,
+    addEditRecord,
+    saveEditable,
+    newLineRecord: newLineRecordCache,
+    preEditableKeys: editableKeysRef,
+    onValuesChange,
+    getRealIndex: props.getRealIndex
+  };
+}
+export {
+  DeleteEditableAction,
+  SaveEditableAction,
+  defaultActionRender,
+  editableRowByKey,
+  recordKeyToString,
+  useEditableArray
+};