@teamix/pro 1.5.16 → 1.5.18-beta

package/lib/table/utils/columnRender.js

@@ -4,7 +4,7 @@ function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" =
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.renderColumnsTitle = exports.renderCell = void 0;
+exports.renderColumnsTitle = exports.renderCellSmartWidth = exports.renderCell = void 0;
 var _react = _interopRequireDefault(require("react"));
 var _utils = require("@teamix/utils");
 var _actions = require("../../actions");
@@ -186,14 +186,61 @@ dataTeamixSpm) {
     });
   }
   // 渲染 ProField
-  return /*#__PURE__*/_react.default.createElement(_field.default, _objectSpread({
+  return /*#__PURE__*/_react.default.createElement(_field.default
+  // style={{width: `${width}px`}}
+  , _objectSpread({
+    // style={{width: `${width}px`}}
     type: valueType || 'text',
     value: value,
     render: newRender,
     dataSource: newDataSource,
-    format: format
+    format: format,
+    proFieldWidthType: valueType
   }, props));
 };
+exports.renderCell = renderCell;
+var renderCellSmartWidth = function renderCellSmartWidth(value, item, index, record, actionRef, /** 接收外部比如 dialog-table 传过来的 context，用于弹窗关闭等 */
+context) {
+  var _item$valueType2 = item.valueType,
+    valueType = _item$valueType2 === void 0 ? 'text' : _item$valueType2,
+    render = item.render,
+    actionSchema = item.actionSchema,
+    dataIndex = item.dataIndex,
+    format = item.format;
+  var newRender = null;
+  var newDataSource = null;
+  var props = item.props;
+  // 如果 render 直接传函数
+  if (typeof render === 'function') {
+    newRender = function newRender() {
+      return render === null || render === void 0 ? void 0 : render(value, index, record);
+    };
+  } else {
+    newRender = processBuriedPoint(processRenderFunction(render, value, index, record), record, value, index);
+    if (valueType === 'selectGroup') {
+      newRender = _objectSpread(_objectSpread({
+        maxShowNumber: 'auto',
+        foldText: 'more',
+        editOnClick: function editOnClick() {},
+        edit: true
+      }, newRender), {}, {
+        ellipsis: false
+      });
+      props = _objectSpread({
+        valueAlias: {
+          value: 'TagValue',
+          key: 'TagKey'
+        }
+      }, props);
+    }
+    if ((render === null || render === void 0 ? void 0 : render.type) === 'step') {
+      newRender = _objectSpread(_objectSpread({}, newRender), {}, {
+        ellipsis: false
+      });
+    }
+  }
+  // return getProFieldWidthBox(valueType, newRender)?.minWidth || undefined
+};
 /**
  * 处理 render 配置项是函数的情况
  * @param render ProFieldRender
@@ -202,7 +249,7 @@ dataTeamixSpm) {
  * @param record table cell record
  * @returns
  */
-exports.renderCell = renderCell;
+exports.renderCellSmartWidth = renderCellSmartWidth;
 var processRenderFunction = function processRenderFunction() {
   var render = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   var value = arguments.length > 1 ? arguments[1] : undefined;

package/lib/table/utils/genAutoWidthColumns.d.ts

@@ -0,0 +1,35 @@
+import { MutableRefObject } from 'react';
+import { ProTableColumnProps } from '../typing';
+/**
+ * @param fileteredColumns
+ * @param ref
+ * @param data
+ * @returns
+ */
+export declare function genAutoWidthColumns(fileteredColumns: ProTableColumnProps[], ref: MutableRefObject<HTMLDivElement | null>, data: any[], size: 'small' | 'medium', useRowSelection?: boolean | undefined, actionColumnRef?: MutableRefObject<HTMLDivElement | null>): ProTableColumnProps[];
+interface IShadowContainerProps {
+    columns: ProTableColumnProps[];
+    data: any[];
+    shadowContainerRef: MutableRefObject<null>;
+}
+export declare const shadowContainer: (props: IShadowContainerProps) => JSX.Element;
+export declare const shadowActionColumnContainer: (columns: ProTableColumnProps[], shadowActionColumnContainerRef: MutableRefObject<null>) => JSX.Element | undefined;
+export declare const computeableWidthTypeList: {};
+export declare const fixedWidthTypeList: {
+    dateTime: number;
+    dateMonth: number;
+    dateWeek: number;
+    date: number;
+    dateYear: number;
+    dateQuarter: number;
+    dateRange: number;
+    dateWeekRange: number;
+    dateMonthRange: number;
+    dateYearRange: number;
+    dateQuarterRange: number;
+    dateTimeRange: number;
+    time: number;
+    timeRange: number;
+};
+export declare const fieldTypeShrink: any;
+export {};

package/lib/table/utils/genAutoWidthColumns.js

@@ -0,0 +1,345 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fixedWidthTypeList = exports.fieldTypeShrink = exports.computeableWidthTypeList = void 0;
+exports.genAutoWidthColumns = genAutoWidthColumns;
+exports.shadowContainer = exports.shadowActionColumnContainer = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _utils = require("@teamix/utils");
+var _pureColumnRender = require("./pureColumnRender");
+var _columnRender = require("./columnRender");
+var _actions = require("../../actions");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+// 最大宽度
+var maxColumnWidth = 600;
+// 最小宽度
+var minColumnWidth = 48;
+// 每个列可以缩减的最大宽度
+var columnShrinkMaxWidth = 100;
+/**
+ * @param fileteredColumns
+ * @param ref
+ * @param data
+ * @returns
+ */
+function genAutoWidthColumns(fileteredColumns, ref, data, size, useRowSelection, actionColumnRef) {
+  if (!ref.current) {
+    return fileteredColumns;
+  }
+  var hasLockFlag = false;
+  var dom = ref.current;
+  var actionColumnDom = actionColumnRef === null || actionColumnRef === void 0 ? void 0 : actionColumnRef.current;
+  var childNodes = dom.children;
+  var finalColumns = [];
+  fileteredColumns.forEach(function (column, index) {
+    var render = column.render,
+      _column$valueType = column.valueType,
+      valueType = _column$valueType === void 0 ? 'text' : _column$valueType,
+      _column$autoWidth = column.autoWidth,
+      autoWidth = _column$autoWidth === void 0 ? true : _column$autoWidth,
+      actionSchema = column.actionSchema,
+      sortable = column.sortable,
+      lock = column.lock;
+    if (lock) {
+      hasLockFlag = true;
+    }
+    //@ts-ignore
+    var type = render === null || render === void 0 ? void 0 : render.type;
+    var finalType = type || valueType || '';
+    var shrink = fieldTypeShrink[finalType];
+    column.shrink = column.shrink || (shrink !== undefined ? shrink : 1);
+    //@ts-ignore
+    // if (!autoWidth) {
+    //   finalColumns.push(column);
+    //   return;
+    // }
+    if (actionSchema) {
+      // TODO 操作列暂时未处理，但是应该根据actionSchema的数量直接推测出操作列的宽度
+      // console.log('column', column);
+      column.shrink = 0;
+      // column.width = 280;
+      // console.log(
+      //   'actionColumnDom',
+      //   actionColumnDom?.childNodes[0].scrollWidth,
+      // );
+      if (actionColumnDom === null || actionColumnDom === void 0 ? void 0 : actionColumnDom.childNodes[0]) {
+        //@ts-ignore
+        var width = actionColumnDom === null || actionColumnDom === void 0 ? void 0 : actionColumnDom.childNodes[0].scrollWidth;
+        if (width >= 280) {
+          width = 280;
+        }
+        console.log('actionWidth', width);
+        column.width = defaultPaddingFixer(width, size, false);
+      }
+      finalColumns.push(column);
+      return;
+    }
+    // @ts-ignore
+    var titleWidth = childNodes[index].children[0].scrollWidth;
+    // @ts-ignore
+    if (fixedWidthTypeList[finalType]) {
+      // console.log(
+      //   'fixedWidthTypeList[finalType]',
+      //   fixedWidthTypeList[finalType],
+      // );
+      // 固定宽度
+      column.width = defaultPaddingFixer(
+      // @ts-ignore
+      Math.max(titleWidth, fixedWidthTypeList[finalType]), size, index === 0 && useRowSelection);
+      // @ts-ignore
+    } else if (computeableWidthTypeList[finalType]) {
+      // 可计算宽度
+      column.width = defaultPaddingFixer(
+      // @ts-ignore
+      Math.max(titleWidth, computeableWidthTypeList[finalType](data, render)), size, index === 0 && useRowSelection);
+    } else {
+      // 直接根据 dom 计算
+      column.width = defaultPaddingFixer(Math.max(titleWidth,
+      // @ts-ignore
+      calcWidthWithParentDOM(childNodes[index], column.shrink)), size, index === 0 && useRowSelection);
+    }
+    if (index === 0) {
+      // 首列不会被挤占
+      column.shrink = 0;
+    }
+    finalColumns.push(column);
+  });
+  if (!hasLockFlag) {
+    // 如果没有锁列的情况，需要将所有列放到一屏内，此时需要将所有列放到一起计算一次
+    var containerWidth = dom.offsetWidth;
+    var comboColumns = calcMultiColumnLength(finalColumns, useRowSelection ? containerWidth - 50 : containerWidth);
+    return comboColumns;
+  }
+  console.log('[ finalColumns ] >', finalColumns);
+  return finalColumns;
+}
+var shadowContainer = function shadowContainer(props) {
+  var ref = (0, _react.useRef)();
+  var columns = props.columns,
+    data = props.data,
+    shadowContainerRef = props.shadowContainerRef;
+  return /*#__PURE__*/_react.default.createElement("div", {
+    ref: shadowContainerRef,
+    className: "teamix-pro-table-shadow-container"
+  }, columns.map(function (column, index) {
+    var dataIndex = column.dataIndex,
+      valueType = column.valueType;
+    if (!(column === null || column === void 0 ? void 0 : column.actionSchema)) {
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: "teamix-pro-table-shadow-container-columns",
+        key: index
+      }, /*#__PURE__*/_react.default.createElement("div", null, (0, _columnRender.renderColumnsTitle)(column, ref)),
+      //@ts-ignore
+      !computeableWidthTypeList[valueType] &&
+      //@ts-ignore
+      !fixedWidthTypeList[valueType] && data.map(function (item, index) {
+        return (0, _pureColumnRender.renderCell)(getValueFromRecord(dataIndex, item), column, index, item);
+      }));
+    }
+  }));
+};
+exports.shadowContainer = shadowContainer;
+var shadowActionColumnContainer = function shadowActionColumnContainer(columns, shadowActionColumnContainerRef) {
+  var actionColumn = columns.find(function (column) {
+    return column === null || column === void 0 ? void 0 : column.actionSchema;
+  });
+  if (actionColumn === null || actionColumn === void 0 ? void 0 : actionColumn.actionSchema) {
+    return /*#__PURE__*/_react.default.createElement("div", {
+      ref: shadowActionColumnContainerRef,
+      className: "teamix-pro-table-action-column-shadow-container"
+    }, /*#__PURE__*/_react.default.createElement(_actions.ProActionGroup, _objectSpread(_objectSpread({
+      type: "text"
+    }, actionColumn === null || actionColumn === void 0 ? void 0 : actionColumn.actionSchema), {}, {
+      context: _objectSpread({}, actionColumn === null || actionColumn === void 0 ? void 0 : actionColumn.actionSchema.context)
+    })));
+  }
+};
+// 计算操作列的宽度
+exports.shadowActionColumnContainer = shadowActionColumnContainer;
+function getValueFromRecord(dataIndex, record) {
+  if (!dataIndex) {
+    return null;
+  }
+  if (Array.isArray(dataIndex)) {
+    var value = dataIndex.map(function (item) {
+      return (0, _utils.getTargetValue)("{{".concat(item, "}}"), _objectSpread(_objectSpread({}, record), {}, {
+        record: record
+      }));
+    });
+    return value;
+  } else {
+    var result = record;
+    var array = dataIndex.split('.');
+    array.forEach(function (item) {
+      return result = result ? result[item] : undefined;
+    });
+    return result;
+  }
+}
+// TODO 某些可以直接算出结果的 profield 类型白名单，待补充，每个类型下支持一个函数，用当前值和渲染类型算出一个结果
+var computeableWidthTypeList = {
+  // text: (data: any[], render: ITableCellRender) => {
+  // }
+};
+// TODO 某些固定宽度的 profield 类型白名单，这里的数据可能需要综合考虑 dataFold 和 render.rows
+exports.computeableWidthTypeList = computeableWidthTypeList;
+var fixedWidthTypeList = {
+  // 时间日期
+  dateTime: 160,
+  dateMonth: 74,
+  dateWeek: 74,
+  date: 100,
+  dateYear: 46,
+  dateQuarter: 64,
+  dateRange: 212,
+  dateWeekRange: 156,
+  dateMonthRange: 156,
+  dateYearRange: 102,
+  dateQuarterRange: 136,
+  dateTimeRange: 326,
+  time: 38,
+  timeRange: 124
+};
+// TODO 不同类型的 profield 的 shrink，0表示不可以省略号，数字越大越容易被挤占空间
+exports.fixedWidthTypeList = fixedWidthTypeList;
+var fieldTypeShrink = {
+  tag: 0,
+  statusTag: 0,
+  statusIconTag: 0,
+  circle: 0,
+  rank: 0,
+  progress: 0,
+  money: 0,
+  number: 0,
+  percent: 0,
+  dateTime: 0,
+  ip: 0
+};
+exports.fieldTypeShrink = fieldTypeShrink;
+function calcWidthWithParentDOM(dom, shrink) {
+  var childNodes = _toConsumableArray(dom.children);
+  childNodes.shift();
+  return calcSingleColumnLength(childNodes.map(function (node) {
+    return node.scrollWidth;
+  }), shrink);
+}
+function calcSingleColumnLength() {
+  var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var shrink = arguments.length > 1 ? arguments[1] : undefined;
+  if (shrink === 0) {
+    return Math.ceil(Math.max.apply(null, list));
+  }
+  return getConfidence90UpperBound(list);
+}
+/**
+ * 根据所有列的宽度和权重，结合总宽度，计算出各个列合适的宽度
+ * 目前算法：
+ * 当前需要的总宽度-总宽度=需要降低的宽度
+ * 从后往前，将shrink不为0的列，降低一些宽度到最小宽度
+ * 最小宽度可以用百分比去算
+ * TODO 当前shrink只用了0，其他的权重也要考虑一下
+ * @param list
+ * @param max
+ * @returns
+ */
+function calcMultiColumnLength() {
+  var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var max = arguments.length > 1 ? arguments[1] : undefined;
+  var result = _toConsumableArray(list);
+  var targetList = [];
+  var needWidth = 0;
+  var canShrink = 0;
+  list.forEach(function (item) {
+    //@ts-ignore
+    needWidth += item.width;
+    console.log('item.width', item.width);
+    if (item.shrink !== 0) {
+      targetList.push(item);
+      //@ts-ignore
+      canShrink += Math.min(item.width - minColumnWidth, columnShrinkMaxWidth);
+    }
+  });
+  console.log('needWidth', needWidth);
+  console.log('max', max);
+  var widthToBeRemoved = needWidth - max;
+  if (widthToBeRemoved <= 0) {
+    return list;
+  }
+  console.log('canShrink', canShrink);
+  console.log('widthToBeRemoved', widthToBeRemoved);
+  // TODO 超过的特别多直接加锁列，这个逻辑怎么设计
+  // 目前用可以缩小的宽度加起来比较一下
+  if (canShrink < widthToBeRemoved) {
+    console.log('canShrink', canShrink);
+    console.log('widthToBeRemoved', widthToBeRemoved);
+    list[0].lock = 'left';
+    if (list[list.length - 1].actionSchema) {
+      list[list.length - 1].lock = 'right';
+    }
+    return list;
+  }
+  //@ts-ignore
+  var sortedList = targetList.sort(function (a, b) {
+    return a.width - b.width;
+  });
+  var shrinkedWidth = 0;
+  for (var i = sortedList.length - 1; i >= 0; i--) {
+    if (shrinkedWidth >= widthToBeRemoved) {
+      break;
+    }
+    var singleShrinkedWidth = Math.min(sortedList[i].width - minColumnWidth, columnShrinkMaxWidth, widthToBeRemoved - shrinkedWidth);
+    sortedList[i].width = sortedList[i].width - singleShrinkedWidth;
+    shrinkedWidth += singleShrinkedWidth;
+  }
+  return result;
+}
+/**
+ * 修正内容放在table中默认的padding
+ * @param width
+ * @returns
+ */
+function defaultPaddingFixer(width) {
+  var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'medium';
+  var half = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  return size === 'medium' ? width + (half ? 16 : 32) + 0.5 : width + (half ? 8 : 16) + 0.5;
+}
+function sum() {
+  var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return list.reduce(function (a, b) {
+    return a + b;
+  });
+}
+/**
+ * 假设样本正态分布，取 90% 置信区间的上界
+ * 当上界与最大值差距不大(目前是20)的时候，直接用最大值
+ * TODO 这里没考虑是否可以直接用标准差做评判依据，如标准差过大时，直接排序并展示前90%，或标准差很小时直接用最大值
+ * TODO 这里极限情况是不是会挂？ 如：长度为9个100和2个10000，估计会挂，是否置信区间这个不靠谱。。。最差情况就直接展示90%的数据算了
+ */
+function getConfidence90UpperBound() {
+  var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var max = Math.max.apply(null, list);
+  var length = list.length;
+  var mean = sum(list) / length;
+  var std = Math.sqrt(sum(list.map(function (n) {
+    return (n - mean) * (n - mean);
+  })) / length);
+  var interval = length > 30 ? 1.65 * std / Math.sqrt(length) : 2.2622 * std / Math.sqrt(length);
+  var bound = Math.ceil(mean + interval);
+  if (max - bound < 20) {
+    return Math.min(max, maxColumnWidth);
+  }
+  return Math.min(bound, maxColumnWidth);
+}

package/lib/xconsole.scss

@@ -500,4 +500,27 @@
     border: 0 solid #d9d9d9;
     border: var(--colortag-border-width,0) solid var(--color-line1-2,#d9d9d9);
   }
+  .teamix-pro-table-toolbar-filter-column-all-select {
+    .next-menu-item-inner {
+      display: flex;
+    }
+  }
+  .next-dialog-centered {
+    text-align: center;
+  }
+  .next-dialog-wrapper {
+    position: fixed;
+    left: 0;
+    top: 0;
+    right: 0;
+    bottom: 0;
+
+    .next-dialog-v2 {
+      margin: 40px 0;
+      display: inline-block;
+      text-align: left;
+      vertical-align: middle;
+      position: relative;
+    }
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamix/pro",
-  "version": "1.5.16",
+  "version": "1.5.18-beta",
   "description": "TeamixPro大包",
   "keywords": [
     "aliyun",

package/es/actions/base.d.ts

@@ -1,24 +0,0 @@
-/// <reference types="react" />
-import { MaybePromise } from '@teamix/utils';
-export interface BaseAction {
-    /** 事件触发方式，默认是 onClick */
-    trigger?: string;
-    /** 事件发生时，是否执行 e.preventDefault() 方法 */
-    preventDefault?: boolean;
-    /** 事件发生时，是否执行 e.stopPropagation() 方法 */
-    stopPropagation?: boolean;
-    /** 事件执行前的处理函数
-     * 如果返回 false 或者 Promise<false>，则停止 Action 执行。
-     * 如果返回 true 或者 Promise<true>，则正常执行 Action。
-     * 如果返回其他对象，则正常执行 Action，并把返回的对象放到接下来 Action 的上下文中。
-     */
-    beforeAction?: () => MaybePromise<any>;
-    /** 事件开始执行后的回调函数 */
-    onTrigger?: () => void;
-    /** 事件开始执行完毕的回调函数 */
-    onFinish?: (params?: any) => any;
-}
-export declare function eventHandler(action: BaseAction, actionContext: any, onTrigger: (context: any, e: React.MouseEvent<HTMLElement>) => void): {
-    [x: string]: (e: React.MouseEvent<HTMLElement>) => Promise<void>;
-};
-export default eventHandler;

package/es/actions/confirm.d.ts

@@ -1,7 +0,0 @@
-import { DialogAction } from './dialog';
-export interface ConfirmAction extends DialogAction {
-}
-export declare function useConfirmAction(action: DialogAction, context?: any): {
-    [x: string]: (e: import("react").MouseEvent<HTMLElement, MouseEvent>) => Promise<void>;
-};
-export default useConfirmAction;

package/es/actions/danger-confirm.d.ts

@@ -1,7 +0,0 @@
-import { DialogAction } from './dialog';
-export interface DangerConfirmAction extends DialogAction {
-}
-export declare function useDangerConfirmAction(action: DialogAction, context?: any): {
-    [x: string]: (e: import("react").MouseEvent<HTMLElement, MouseEvent>) => Promise<void>;
-};
-export default useDangerConfirmAction;

package/es/actions/danger-pop-confirm.d.ts

@@ -1,5 +0,0 @@
-import { PopConfirmAction } from './pop-confirm';
-export declare function useDangerPopConfirmAction(action: PopConfirmAction, context?: any): {
-    [x: string]: (e: import("react").MouseEvent<HTMLElement, MouseEvent>) => Promise<void>;
-};
-export default useDangerPopConfirmAction;

package/es/actions/dialog-component.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import { DialogAction } from './dialog';
-export interface DialogComponentAction extends DialogAction {
-    schema: any;
-    component: React.FC<any>;
-}
-export declare function useDialogComponentAction(action: DialogComponentAction, context?: any): {
-    [x: string]: (e: React.MouseEvent<HTMLElement, MouseEvent>) => Promise<void>;
-};
-export default useDialogComponentAction;

package/es/actions/dialog-form.d.ts

@@ -1,29 +0,0 @@
-import React from 'react';
-import { ProFormProps, ProFormSchema, ProFormType } from '../form';
-import { RequestAction } from './request';
-import { DialogAction } from './dialog';
-export interface DialogFormAction extends DialogAction {
-    /** 表单初始值 */
-    initialValues?: any;
-    /** 表单初始化数据请求 */
-    initialRequest?: RequestAction;
-    /** 表单提交发送数据请求时，是否携带全部表单数据。默认携带 */
-    useFieldValuesForRequest?: boolean;
-    /**
-     * @deprecated 建议使用 schema 配置 ProFormProps 代替
-     */
-    formProps?: Omit<ProFormProps, 'schema' | 'form'>;
-    /** 同时支持两种配置方式:
-     * 如果想完整定制表单，可使用完整的表单配置项 ProFormProps，但不可以传 form 字段，可以通过 formRef 获取内部 form 实例。
-     * 否则可以只配置 ProFormSchema
-     */
-    schema: ProFormSchema | Omit<ProFormProps, 'form'>;
-    /** 外部传来的 formRef，用于获取内置 form 实例 */
-    formRef?: React.MutableRefObject<ProFormType | undefined>;
-    /** 是否开启懒惰校验，只校验第一个非法规则，默认开启 */
-    validateFirst?: boolean;
-}
-export declare function useDialogFormAction(action: DialogFormAction, context?: any): {
-    [x: string]: (e: React.MouseEvent<HTMLElement, MouseEvent>) => Promise<void>;
-};
-export default useDialogFormAction;

package/es/actions/dialog-info.d.ts

@@ -1,9 +0,0 @@
-import { DialogAction } from './dialog';
-import { ProInfoProps } from '..';
-export interface DialogInfoAction extends DialogAction {
-    schema: ProInfoProps;
-}
-export declare function useDialogInfoAction(action: DialogInfoAction, context?: any): {
-    [x: string]: (e: import("react").MouseEvent<HTMLElement, MouseEvent>) => Promise<void>;
-};
-export default useDialogInfoAction;

package/es/actions/dialog-table.d.ts

@@ -1,9 +0,0 @@
-import { DialogAction } from './dialog';
-import { ProTableProps } from '..';
-export interface DialogTableAction extends DialogAction {
-    schema: ProTableProps;
-}
-export declare function useDialogTableAction(action: DialogTableAction, context?: any): {
-    [x: string]: (e: import("react").MouseEvent<HTMLElement, MouseEvent>) => Promise<void>;
-};
-export default useDialogTableAction;

package/es/actions/dialog.d.ts

@@ -1,40 +0,0 @@
-import React from 'react';
-import { QuickShowConfig } from '@alicloudfe/components/types/dialog';
-import { quickShowDrawerProps } from '@alicloudfe/components/types/drawer';
-import { ProFormSchema, ProFormSchemaItem } from '../form';
-import { ProMessageProps } from '../utils/message';
-import { RequestAction } from './request';
-export interface DialogAction extends Omit<RequestAction, 'url'>, Omit<QuickShowConfig, 'onError' | 'type'>, Omit<quickShowDrawerProps, 'trigger' | 'animation' | 'height' | 'locale' | 'onError'> {
-    /** 点击「确认按钮」后的数据请求地址，非必填，不填就不发请求 */
-    url?: string;
-    /** 弹窗类型，支持普通弹窗和抽屉两种模式，默认为普通弹窗 */
-    dialogType?: 'dialog' | 'drawer' | 'pop';
-    /** 弹窗快捷调用类型 */
-    dialogQuickShowType?: 'alert' | 'confirm';
-    /** 弹窗消息类型 */
-    messageType?: 'success' | 'warning' | 'error' | 'notice' | 'help' | 'loading';
-    /** 位于弹窗内容最上方的自定义内容区 */
-    beforeContent?: React.ReactNode;
-    /** 位于弹窗内容上方的消息提示区 */
-    message?: ProMessageProps;
-    /** 位于弹窗内容下方的自定义内容区 */
-    afterContent?: React.ReactNode;
-    /** 弹窗页脚描述区，位于按钮组的对面 */
-    footerDescription?: React.ReactNode | ProFormSchema | ProFormSchemaItem;
-    /** 弹窗内容组件的 schema */
-    schema?: any;
-    /** 弹窗内容区的组件 */
-    component?: any;
-    /** 点击确定自定义回调函数 */
-    onOk?: any;
-    /** 点击取消自定义回调函数  */
-    onCancel?: any;
-    /** 隐藏footer区域  */
-    hideFooter?: boolean;
-    /** 支持通过传函数自定义底部按钮 */
-    footer?: any;
-}
-export declare function useDialogAction(action: DialogAction, actionContext?: any, hasForm?: boolean): {
-    [x: string]: (e: React.MouseEvent<HTMLElement, MouseEvent>) => Promise<void>;
-};
-export default useDialogAction;

package/es/actions/drawer-form.d.ts

@@ -1,6 +0,0 @@
-import { DialogFormAction } from './dialog-form';
-export declare type DrawerFormAction = DialogFormAction;
-export declare function useDrawerFormAction(action: DrawerFormAction, context?: any): {
-    [x: string]: (e: import("react").MouseEvent<HTMLElement, MouseEvent>) => Promise<void>;
-};
-export default useDrawerFormAction;

package/es/actions/drawer-info.d.ts

@@ -1,6 +0,0 @@
-import { DialogInfoAction } from './dialog-info';
-export declare type DrawerInfoAction = DialogInfoAction;
-export declare function useDrawerInfoAction(action: DrawerInfoAction, context?: any): {
-    [x: string]: (e: import("react").MouseEvent<HTMLElement, MouseEvent>) => Promise<void>;
-};
-export default useDrawerInfoAction;