trex-hooks/dist/index.js

Common hooks used for antd 4.0

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var react = require('react');

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 _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 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 _objectSpread2(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 _slicedToArray(arr, i) {
  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
}

function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}

function _iterableToArrayLimit(arr, i) {
  if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
    return;
  }

  var _arr = [];
  var _n = true;
  var _d = false;
  var _e = undefined;

  try {
    for (var _i = arr[Symbol.iterator](), _s; !(_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 _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance");
}

function useModal(props) {
  var _useState = react.useState(false),
      _useState2 = _slicedToArray(_useState, 2),
      visible = _useState2[0],
      setVisible = _useState2[1];

  var _useState3 = react.useState(false),
      _useState4 = _slicedToArray(_useState3, 2),
      confirmLoading = _useState4[0],
      setConfirmLoading = _useState4[1];

  var _props$onOk = props.onOk,
      onOk = _props$onOk === void 0 ? function () {
    return Promise.resolve(true);
  } : _props$onOk,
      _props$onCancel = props.onCancel,
      onCancel = _props$onCancel === void 0 ? function () {
    return Promise.resolve(true);
  } : _props$onCancel;

  var show = function show() {
    setVisible(true);
  };

  var close = function close() {
    setConfirmLoading(false);
    setVisible(false);
  };

  var ok =
  /*#__PURE__*/
  function () {
    var _ref = _asyncToGenerator(
    /*#__PURE__*/
    regeneratorRuntime.mark(function _callee() {
      var status;
      return regeneratorRuntime.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              setConfirmLoading(true);
              _context.prev = 1;
              _context.next = 4;
              return onOk();

            case 4:
              status = _context.sent;

              if (status) {
                setVisible(false);
              }

              _context.next = 12;
              break;

            case 8:
              _context.prev = 8;
              _context.t0 = _context["catch"](1);
              console.warn(_context.t0);
              setConfirmLoading(false);

            case 12:
              setConfirmLoading(false);

            case 13:
            case "end":
              return _context.stop();
          }
        }
      }, _callee, null, [[1, 8]]);
    }));

    return function ok() {
      return _ref.apply(this, arguments);
    };
  }();

  var cancel =
  /*#__PURE__*/
  function () {
    var _ref2 = _asyncToGenerator(
    /*#__PURE__*/
    regeneratorRuntime.mark(function _callee2(event) {
      var status;
      return regeneratorRuntime.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              _context2.prev = 0;
              _context2.next = 3;
              return onCancel(event);

            case 3:
              status = _context2.sent;

              if (status) {
                setVisible(false);
                setConfirmLoading(false);
              }

              _context2.next = 10;
              break;

            case 7:
              _context2.prev = 7;
              _context2.t0 = _context2["catch"](0);
              console.warn(_context2.t0);

            case 10:
            case "end":
              return _context2.stop();
          }
        }
      }, _callee2, null, [[0, 7]]);
    }));

    return function cancel(_x) {
      return _ref2.apply(this, arguments);
    };
  }();

  var modalProps = {
    visible: visible,
    confirmLoading: confirmLoading,
    onOk: ok,
    onCancel: cancel
  };
  return {
    modalProps: modalProps,
    show: show,
    close: close
  };
}

function useSteps(total) {
  var _useState = react.useState(0),
      _useState2 = _slicedToArray(_useState, 2),
      current = _useState2[0],
      setCurrenct = _useState2[1];

  var jump = function jump(location) {
    if (location <= total - 1 && location >= 0) {
      setCurrenct(location);
    }
  };

  var prev = function prev() {
    if (current > 0) {
      setCurrenct(current - 1);
    }
  };

  var next = function next() {
    if (current < total - 1) {
      setCurrenct(current + 1);
    }
  };

  var reset = function reset() {
    setCurrenct(0);
  };

  return {
    current: current,
    prev: prev,
    next: next,
    jump: jump,
    reset: reset
  };
}

function useTable(props) {
  var _props$defaultPaginat = props.defaultPagination,
      defaultPagination = _props$defaultPaginat === void 0 ? {
    current: 1,
    pageSize: 10,
    total: 0,
    showQuickJumper: true,
    showSizeChanger: true,
    showTotal: function showTotal(total) {
      return "\u5171 ".concat(total, " \u6761\u8BB0\u5F55");
    }
  } : _props$defaultPaginat,
      getTableInfo = props.getTableInfo;

  var _useState = react.useState([]),
      _useState2 = _slicedToArray(_useState, 2),
      dataSource = _useState2[0],
      setDataSource = _useState2[1];

  var _useState3 = react.useState(defaultPagination),
      _useState4 = _slicedToArray(_useState3, 2),
      pagination = _useState4[0],
      setPagination = _useState4[1];

  var _useState5 = react.useState({}),
      _useState6 = _slicedToArray(_useState5, 2),
      sorter = _useState6[0],
      setSorter = _useState6[1];

  var handleQuery =
  /*#__PURE__*/
  function () {
    var _ref = _asyncToGenerator(
    /*#__PURE__*/
    regeneratorRuntime.mark(function _callee(newPagination, newFilters, newSorter) {
      var _newPagination$curren, current, _newPagination$pageSi, pageSize, tableInfo, mergedPagination;

      return regeneratorRuntime.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              _newPagination$curren = newPagination.current, current = _newPagination$curren === void 0 ? 1 : _newPagination$curren, _newPagination$pageSi = newPagination.pageSize, pageSize = _newPagination$pageSi === void 0 ? 10 : _newPagination$pageSi;
              _context.next = 3;
              return getTableInfo(current, pageSize, newFilters, newSorter);

            case 3:
              tableInfo = _context.sent;

              if (tableInfo) {
                setDataSource(tableInfo.dataSource);
                mergedPagination = _objectSpread2({}, newPagination, {
                  total: tableInfo.total
                });
                setPagination(mergedPagination);
                setSorter(sorter);
              }

            case 5:
            case "end":
              return _context.stop();
          }
        }
      }, _callee);
    }));

    return function handleQuery(_x, _x2, _x3) {
      return _ref.apply(this, arguments);
    };
  }();
  /** 条件查询时间 */


  var query = function query() {
    handleQuery(defaultPagination, {}, {});
  };

  var refresh = function refresh() {
    handleQuery(pagination, {}, sorter);
  };

  var clear = function clear() {
    setDataSource([]);
    setPagination(defaultPagination);
  };
  /** 表格分页变化 */


  var onChange = function onChange(newPagination, newFilters, newSorter) {
    handleQuery(newPagination, newFilters, newSorter);
  };

  var tableProps = {
    dataSource: dataSource,
    pagination: pagination,
    onChange: onChange
  };
  return {
    tableProps: tableProps,
    query: query,
    refresh: refresh,
    clear: clear
  };
}

exports.useModal = useModal;
exports.useSteps = useSteps;
exports.useTable = useTable;