@teamix/pro 1.0.22 → 1.1.0

package/es/actions/base.d.ts

@@ -0,0 +1,13 @@
+export interface BaseAction {
+    trigger?: string;
+    onTrigger?: () => void;
+    onFinish?: (prams?: any) => any;
+    preventDefault?: boolean;
+    stopPropagation?: boolean;
+    schema?: any;
+    component?: any;
+}
+export declare function eventHandler(action: BaseAction, onTrigger: () => void): {
+    [x: string]: (e: React.MouseEvent<HTMLElement>) => void;
+};
+export default eventHandler;

package/es/actions/base.js

@@ -0,0 +1,23 @@
+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; }
+
+export function eventHandler(action, onTrigger) {
+  var _action$trigger = action.trigger,
+      trigger = _action$trigger === void 0 ? 'onClick' : _action$trigger,
+      preventDefault = action.preventDefault,
+      stopPropagation = action.stopPropagation;
+  return _defineProperty({}, "".concat(trigger), function _(e) {
+    var _action$onTrigger;
+
+    if (preventDefault) {
+      e.preventDefault();
+    }
+
+    if (stopPropagation) {
+      e.stopPropagation();
+    }
+
+    onTrigger();
+    (_action$onTrigger = action.onTrigger) === null || _action$onTrigger === void 0 ? void 0 : _action$onTrigger.call(action);
+  });
+}
+export default eventHandler;

package/es/actions/confirm.d.ts

@@ -0,0 +1,7 @@
+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>) => void;
+};
+export default useConfirmAction;

package/es/actions/confirm.js

@@ -0,0 +1,11 @@
+import { deepMerge } from '@teamix/utils';
+import useDialogAction from './dialog';
+export function useConfirmAction(action, context) {
+  return useDialogAction(deepMerge({
+    dialogQuickShowType: 'confirm',
+    messageProps: {
+      type: 'warning'
+    }
+  }, action), context);
+}
+export default useConfirmAction;

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

@@ -0,0 +1,7 @@
+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>) => void;
+};
+export default useDangerConfirmAction;

package/es/actions/danger-confirm.js

@@ -0,0 +1,14 @@
+import { deepMerge } from '@teamix/utils';
+import useDialogAction from './dialog';
+export function useDangerConfirmAction(action, context) {
+  return useDialogAction(deepMerge({
+    dialogQuickShowType: 'confirm',
+    messageProps: {
+      type: 'warning'
+    },
+    okProps: {
+      warning: true
+    }
+  }, action), context);
+}
+export default useDangerConfirmAction;

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

@@ -0,0 +1,10 @@
+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>) => void;
+};
+export default useDialogComponentAction;

package/es/actions/dialog-component.js

@@ -0,0 +1,25 @@
+var _excluded = ["schema", "component"];
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+import React from 'react';
+import useDialogAction from './dialog';
+export function useDialogComponentAction(action, context) {
+  var schema = action.schema,
+      Component = action.component,
+      others = _objectWithoutProperties(action, _excluded);
+
+  return useDialogAction(Object.assign({
+    content: /*#__PURE__*/React.createElement(Component, _objectSpread({}, schema)),
+    closeable: true
+  }, others), context);
+}
+export default useDialogComponentAction;

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

@@ -0,0 +1,15 @@
+import React from 'react';
+import { IProFormProps } from '../form';
+import { RequestAction } from './request';
+import { DialogAction } from './dialog';
+export interface DialogFormAction extends DialogAction {
+    initialValues?: any;
+    initialRequest?: RequestAction;
+    useFieldValuesForRequest?: boolean;
+    formProps?: IProFormProps;
+    schema: any[];
+}
+export declare function useDialogFormAction(action: DialogFormAction, context?: any): {
+    [x: string]: (e: React.MouseEvent<HTMLElement, MouseEvent>) => void;
+};
+export default useDialogFormAction;

package/es/actions/dialog-form.js

@@ -0,0 +1,129 @@
+var _excluded = ["schema", "useFieldValuesForRequest", "initialValues", "initialRequest", "formProps", "size", "onFinish"];
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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 _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 _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+import React, { useState, useMemo } from 'react';
+import { Loading } from '@alicloudfe/components';
+import ProForm, { createForm } from '../form';
+import { getTargetValue } from '@teamix/utils';
+import { doRequest } from './request';
+import useDialogAction from './dialog';
+
+function getDefaultFormPropsByDialogSize(size) {
+  if (size === 'small') {
+    return {
+      layout: 'horizontal',
+      labelCol: 6,
+      wrapperCol: 18
+    };
+  }
+
+  if (size === 'medium') {
+    return {
+      layout: 'horizontal',
+      labelCol: 6,
+      wrapperCol: 18
+    };
+  }
+
+  if (size === 'large') {
+    return {
+      layout: 'horizontal',
+      labelCol: 4,
+      wrapperCol: 12
+    };
+  }
+
+  return {
+    layout: 'vertical',
+    labelCol: 24,
+    wrapperCol: 24
+  };
+}
+
+export function useDialogFormAction(action, context) {
+  var schema = action.schema,
+      _action$useFieldValue = action.useFieldValuesForRequest,
+      useFieldValuesForRequest = _action$useFieldValue === void 0 ? true : _action$useFieldValue,
+      initialValues = action.initialValues,
+      initialRequest = action.initialRequest,
+      _action$formProps = action.formProps,
+      formProps = _action$formProps === void 0 ? {} : _action$formProps,
+      _action$size = action.size,
+      size = _action$size === void 0 ? 'small' : _action$size,
+      _onFinish = action.onFinish,
+      others = _objectWithoutProperties(action, _excluded);
+
+  var form = useMemo(function () {
+    return createForm({
+      initialValues: getTargetValue(initialValues, context)
+    });
+  }, []);
+
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      loading = _useState2[0],
+      setLoading = _useState2[1];
+
+  return useDialogAction(Object.assign({
+    content: /*#__PURE__*/React.createElement(Loading, {
+      visible: loading,
+      style: {
+        display: 'block'
+      }
+    }, /*#__PURE__*/React.createElement(ProForm, _objectSpread(_objectSpread({
+      form: form,
+      schema: getTargetValue(schema, context)
+    }, getDefaultFormPropsByDialogSize(size)), getTargetValue(formProps, context)))),
+    size: size,
+    closeable: true,
+    extendParams: useFieldValuesForRequest ? '{{fields}}' : undefined,
+    beforeRequest: function beforeRequest() {
+      return new Promise(function (resolve) {
+        form.validate().then(function () {
+          resolve({
+            fields: form.values
+          });
+        }).catch(function () {
+          resolve(false);
+        });
+      });
+    },
+    onTrigger: function onTrigger() {
+      if (initialRequest) {
+        setLoading(true);
+        doRequest(initialRequest, context).then(function (res) {
+          form.setValues(res);
+          setLoading(false);
+        }).catch(function () {
+          setLoading(false);
+        });
+      }
+    },
+    onFinish: function onFinish() {
+      form.reset();
+      _onFinish && _onFinish(form.values);
+    }
+  }, others), context);
+}
+export default useDialogFormAction;

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

@@ -0,0 +1,4 @@
+import { DialogAction } from './dialog';
+export interface DialogTableAction extends DialogAction {
+    schema: any;
+}

package/es/actions/dialog-table.js

@@ -0,0 +1 @@
+export {};

package/es/actions/dialog.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { QuickShowConfig } from '@alicloudfe/components/types/dialog';
+import { quickShowDrawerProps } from '@alicloudfe/components/types/drawer';
+import { LinkBase } from './link';
+import { RequestAction } from './request';
+export interface DialogAction extends Omit<RequestAction, 'url'>, Omit<QuickShowConfig, 'onError' | 'type'>, Omit<quickShowDrawerProps, 'trigger' | 'animation' | 'height' | 'locale' | 'onOk' | 'onCancel' | 'onError'> {
+    url?: string;
+    dialogType?: 'dialog' | 'drawer';
+    dialogQuickShowType?: 'alert' | 'confirm';
+    messageType?: 'success' | 'warning' | 'error' | 'notice' | 'help' | 'loading';
+    beforeRequest?: () => Promise<any>;
+    link?: LinkBase;
+}
+export declare function useDialogAction(action: DialogAction, context?: any): {
+    [x: string]: (e: React.MouseEvent<HTMLElement, MouseEvent>) => void;
+};
+export default useDialogAction;

package/es/actions/dialog.js

@@ -0,0 +1,197 @@
+var _excluded = ["url", "method", "params", "data", "extendParams", "successMsg", "errorMsg", "formatParams", "formatResult", "onSuccess", "onError"],
+    _excluded2 = ["title", "content", "component", "schema", "onFinish", "dialogType", "dialogQuickShowType", "messageType", "beforeRequest", "onTrigger", "link"];
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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 _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 _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import React, { useState } from 'react';
+import { useHistory } from 'react-router-dom';
+import { Dialog, Drawer } from '@alicloudfe/components';
+import { getTargetValue } from '@teamix/utils';
+import { eventHandler } from './base';
+import { goToLink } from './link';
+import { doRequest } from './request';
+
+function addContextForReactNode(content, context) {
+  if (typeof content === 'function' && context) {
+    return content(context);
+  }
+
+  return content;
+} // 弹窗 -> 请求（点击确认，发送数据请求）
+
+
+export function useDialogAction(action, context) {
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      loading = _useState2[0],
+      setLoading = _useState2[1];
+
+  var history = useHistory();
+  return _objectSpread({}, eventHandler(action, function () {
+    var url = action.url,
+        method = action.method,
+        params = action.params,
+        data = action.data,
+        extendParams = action.extendParams,
+        successMsg = action.successMsg,
+        errorMsg = action.errorMsg,
+        formatParams = action.formatParams,
+        formatResult = action.formatResult,
+        onSuccess = action.onSuccess,
+        onError = action.onError,
+        others = _objectWithoutProperties(action, _excluded);
+
+    var _getTargetValue = getTargetValue(others, context),
+        title = _getTargetValue.title,
+        content = _getTargetValue.content,
+        Component = _getTargetValue.component,
+        schema = _getTargetValue.schema,
+        onFinish = _getTargetValue.onFinish,
+        dialogType = _getTargetValue.dialogType,
+        dialogQuickShowType = _getTargetValue.dialogQuickShowType,
+        _getTargetValue$messa = _getTargetValue.messageType,
+        messageType = _getTargetValue$messa === void 0 ? 'notice' : _getTargetValue$messa,
+        beforeRequest = _getTargetValue.beforeRequest,
+        onTrigger = _getTargetValue.onTrigger,
+        link = _getTargetValue.link,
+        dialogOtherProps = _objectWithoutProperties(_getTargetValue, _excluded2);
+
+    var dialogMethod = dialogType === 'drawer' ? Drawer : Dialog;
+    var dialogProps = dialogType === 'drawer' ? {} : {
+      type: dialogQuickShowType,
+      messageProps: {
+        type: messageType
+      }
+    };
+
+    var onOk = function onOk() {
+      return new Promise( /*#__PURE__*/function () {
+        var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(resolve) {
+          var beforeRequestContext, res;
+          return regeneratorRuntime.wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  if (!link) {
+                    _context.next = 5;
+                    break;
+                  }
+
+                  goToLink(link, history);
+                  resolve(true);
+                  onFinish && onFinish();
+                  return _context.abrupt("return");
+
+                case 5:
+                  if (!beforeRequest) {
+                    _context.next = 13;
+                    break;
+                  }
+
+                  _context.next = 8;
+                  return beforeRequest();
+
+                case 8:
+                  res = _context.sent;
+
+                  if (!(res === false)) {
+                    _context.next = 12;
+                    break;
+                  }
+
+                  resolve(false);
+                  return _context.abrupt("return");
+
+                case 12:
+                  beforeRequestContext = res;
+
+                case 13:
+                  if (url) {
+                    _context.next = 17;
+                    break;
+                  }
+
+                  resolve(true);
+                  onFinish && onFinish();
+                  return _context.abrupt("return");
+
+                case 17:
+                  setLoading(true);
+                  _context.prev = 18;
+                  _context.next = 21;
+                  return doRequest(action, Object.assign({}, context, beforeRequestContext));
+
+                case 21:
+                  setLoading(false);
+                  resolve(true);
+                  onFinish && onFinish();
+                  _context.next = 30;
+                  break;
+
+                case 26:
+                  _context.prev = 26;
+                  _context.t0 = _context["catch"](18);
+                  setLoading(false);
+                  resolve(false);
+
+                case 30:
+                case "end":
+                  return _context.stop();
+              }
+            }
+          }, _callee, null, [[18, 26]]);
+        }));
+
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }());
+    };
+
+    var store = {
+      hide: function hide() {}
+    };
+
+    var hide = function hide() {
+      store.hide && store.hide();
+    };
+
+    var componentProps = schema ? schema : {};
+    var dialogContext = Object.assign({}, context, {
+      hide: hide
+    });
+    var ret = dialogMethod.show(_objectSpread(_objectSpread({
+      // @ts-ignore
+      onOk: onOk,
+      title: addContextForReactNode(title, dialogContext),
+      content: Component ? /*#__PURE__*/React.createElement(Component, _objectSpread({}, componentProps)) : addContextForReactNode(content, dialogContext),
+      closeable: !loading
+    }, dialogProps), dialogOtherProps));
+    store.hide = ret.hide;
+  }));
+}
+export default useDialogAction;

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

@@ -0,0 +1,6 @@
+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>) => void;
+};
+export default useDrawerFormAction;

package/es/actions/drawer-form.js

@@ -0,0 +1,7 @@
+import { useDialogFormAction } from './dialog-form';
+export function useDrawerFormAction(action, context) {
+  return useDialogFormAction(Object.assign({
+    dialogType: 'drawer'
+  }, action), context);
+}
+export default useDrawerFormAction;

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

@@ -0,0 +1,2 @@
+import { DialogTableAction } from './dialog-table';
+export declare type DrawerTableAction = DialogTableAction;

package/es/actions/drawer-table.js

@@ -0,0 +1 @@
+export {};

package/es/actions/drawer.d.ts

@@ -0,0 +1,6 @@
+import { DialogAction } from './dialog';
+export declare type DrawerAction = Omit<DialogAction, 'dialogQuickShowType' | 'messageType'>;
+export declare function useDrawerAction(action: DrawerAction, context?: any): {
+    [x: string]: (e: import("react").MouseEvent<HTMLElement, MouseEvent>) => void;
+};
+export default useDrawerAction;

package/es/actions/drawer.js

@@ -0,0 +1,7 @@
+import useDialogAction from './dialog';
+export function useDrawerAction(action, context) {
+  return useDialogAction(Object.assign({
+    dialogType: 'drawer'
+  }, action), context);
+}
+export default useDrawerAction;

package/es/actions/error.d.ts

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

package/es/actions/error.js

@@ -0,0 +1,11 @@
+import { deepMerge } from '@teamix/utils';
+import useDialogAction from './dialog';
+export function useErrorAction(action, context) {
+  return useDialogAction(deepMerge({
+    dialogQuickShowType: 'confirm',
+    messageProps: {
+      type: 'error'
+    }
+  }, action), context);
+}
+export default useErrorAction;

package/es/actions/index.d.ts

@@ -0,0 +1,76 @@
+import React from 'react';
+import { ButtonProps } from '@alicloudfe/components/types/button';
+import { MenuButtonProps } from '@alicloudfe/components/types/menu-button';
+import { LinkAction } from './link';
+import { RequestAction } from './request';
+import { DialogAction } from './dialog';
+import { ConfirmAction } from './confirm';
+import { DangerConfirmAction } from './danger-confirm';
+import { NoticeAction } from './notice';
+import { ErrorAction } from './error';
+import { DialogFormAction } from './dialog-form';
+import { DialogTableAction } from './dialog-table';
+import { DrawerAction } from './drawer';
+import { DrawerFormAction } from './drawer-form';
+import { DrawerTableAction } from './drawer-table';
+import './index.scss';
+export declare type ActionConfig = ({
+    type: 'link';
+} & LinkAction) | ({
+    type: 'request';
+} & RequestAction) | ({
+    type: 'dialog';
+} & DialogAction) | ({
+    type: 'confirm';
+} & ConfirmAction) | ({
+    type: 'danger-confirm';
+} & DangerConfirmAction) | ({
+    type: 'notice';
+} & NoticeAction) | ({
+    type: 'error';
+} & ErrorAction) | ({
+    type: 'dialog-form';
+} & DialogFormAction) | ({
+    type: 'drawer';
+} & DrawerAction) | ({
+    type: 'drawer-form';
+} & DrawerFormAction) | ({
+    type: 'dialog-table';
+} & DialogTableAction) | ({
+    type: 'drawer-table';
+} & DrawerTableAction);
+export declare function registerActionHandler(id: string, extendActionId: string, defaultConfig: any): void;
+export declare const useAction: any;
+export interface IActionButton extends ButtonProps {
+    config?: ActionConfig;
+    visible?: any;
+    disabled?: any;
+    icon?: string;
+    context?: any;
+    onClick?: (event: React.MouseEvent<Element, MouseEvent>, context?: any) => void;
+}
+export declare const ActionButton: (props: IActionButton) => JSX.Element;
+export interface IActionMenuButton extends MenuButtonProps {
+    actions: IActionButton[];
+    visible?: any;
+    icon?: string;
+    context?: any;
+}
+export interface IActionGroupMenuButton extends MenuButtonProps {
+    actions: CommonActionButton[];
+    icon?: string;
+    context?: any;
+}
+export declare const ActionMenuButton: (props: IActionGroupMenuButton) => JSX.Element;
+export declare type CommonActionButton = IActionButton | IActionMenuButton;
+export declare type CommonActionGroupButton = CommonActionButton | IActionGroupMenuButton;
+export declare type ActionGroupProps = {
+    type?: 'button' | 'text';
+    context?: any;
+    actions: CommonActionButton[];
+    max?: number;
+    moreText?: string;
+    divider?: boolean;
+} & React.HTMLAttributes<HTMLElement>;
+export declare function ActionGroup(props: ActionGroupProps): JSX.Element;
+export default ActionButton;