import _useEffectState3 from 'parsec-hooks/lib/effectStateHooks';
import _useLoadMore2 from 'parsec-hooks/lib/loadMoreHooks';
var _excluded = [
  'getList',
  'renderItem',
  'cacheKey',
  'noData',
  'noMore',
  'loadingTip',
  'renderItemHeight',
  'className',
  'style',
  'defaultLimit',
  'space',
  'needGet',
];

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 _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 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;
}

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, {
  forwardRef,
  useImperativeHandle,
  useEffect,
  useMemo,
  useState,
} from 'react';
import Visible from '../visible';
import NoData from '../no-data';
import Loading from '../loading';
import Button from '../button';
import NeedWrap from '../need-wrap';
import Space from '../space';
import getCurrentPage from '../get-current-page';
import { View } from 'remax/one';
var List = /*#__PURE__*/ forwardRef(
  // eslint-disable-next-line @typescript-eslint/ban-types
  function(_ref, ref) {
    var getList = _ref.getList,
      renderItem = _ref.renderItem,
      _ref$cacheKey = _ref.cacheKey,
      cacheKey = _ref$cacheKey === void 0 ? getCurrentPage() : _ref$cacheKey,
      _ref$noData = _ref.noData,
      noData =
        _ref$noData === void 0
          ? useMemo(function() {
              return /*#__PURE__*/ React.createElement(NoData, null);
            }, [])
          : _ref$noData,
      noMore = _ref.noMore,
      loadingTip = _ref.loadingTip,
      renderItemHeight = _ref.renderItemHeight,
      className = _ref.className,
      style = _ref.style,
      _ref$defaultLimit = _ref.defaultLimit,
      defaultLimit = _ref$defaultLimit === void 0 ? 10 : _ref$defaultLimit,
      space = _ref.space,
      needGet = _ref.needGet,
      options = _objectWithoutProperties(_ref, _excluded);

    var _useState = useState(false),
      _useState2 = _slicedToArray(_useState, 2),
      visible = _useState2[0],
      setVisible = _useState2[1];

    var _useLoadMore = _useLoadMore2(
        getList,
        _objectSpread(
          {
            cacheKey: cacheKey,
            loadMoreVisible: visible,
            defaultLimit: defaultLimit,
            needGet: needGet,
          },
          options,
        ),
      ),
      refreshList = _useLoadMore.refreshList,
      list = _useLoadMore.list,
      isEnd = _useLoadMore.isEnd,
      error = _useLoadMore.error,
      loading = _useLoadMore.loading;

    var _useEffectState = _useEffectState3(error),
      _useEffectState2 = _slicedToArray(_useEffectState, 2),
      showError = _useEffectState2[0],
      setShowError = _useEffectState2[1];

    useImperativeHandle(ref, function() {
      return {
        refreshList: refreshList,
      };
    });
    useEffect(
      function() {
        if (error) {
          console.error(error);
        }
      },
      [error],
    );
    loadingTip = useMemo(
      function() {
        return (
          loadingTip ||
          /*#__PURE__*/ React.createElement(Loading, {
            type: 'inline',
          })
        );
      },
      [loadingTip],
    );
    var footer = useMemo(
      function() {
        return /*#__PURE__*/ React.createElement(
          Visible,
          {
            onVisible: function onVisible() {
              setVisible(true);
            },
            onHidden: function onHidden() {
              setVisible(false);
            },
          },
          loading
            ? loadingTip
            : list.length === 0
            ? noData || noMore || loadingTip
            : isEnd
            ? noMore || noData
            : loadingTip,
        );
      },
      [isEnd, list.length, loading, loadingTip, noData, noMore],
    );
    var list2 = useMemo(
      function() {
        var result = [];
        list.forEach(function(_, i) {
          if (!(i % defaultLimit)) {
            result.push(_toConsumableArray(list).slice(i, i + defaultLimit));
          }
        });
        return result;
      },
      [defaultLimit, list],
    );
    return useMemo(
      function() {
        return /*#__PURE__*/ React.createElement(
          NeedWrap,
          {
            wrap: Space,
            wrapProps: space,
            need: !!space,
          },
          showError
            ? /*#__PURE__*/ React.createElement(
                Button,
                {
                  onTap: function onTap() {
                    setShowError(false);
                    refreshList();
                  },
                  style: {
                    margin: '20px auto',
                  },
                },
                '\u52A0\u8F7D\u5931\u8D25\uFF0C\u70B9\u51FB\u91CD\u8BD5',
              )
            : renderItemHeight
            ? /*#__PURE__*/ React.createElement(
                React.Fragment,
                null,
                list2.map(function(items, index) {
                  var height = 0;
                  items.forEach(function(item, i) {
                    height += renderItemHeight(item, index * defaultLimit + i);
                  });
                  return /*#__PURE__*/ React.createElement(
                    Visible,
                    {
                      key: index,
                      height: height,
                      perf: true,
                    },
                    /*#__PURE__*/ React.createElement(
                      View,
                      {
                        style: style,
                      },
                      items.map(function(data, i) {
                        return renderItem(
                          data,
                          index * defaultLimit + i,
                          list,
                          refreshList,
                        );
                      }),
                    ),
                  );
                }),
                footer,
              )
            : /*#__PURE__*/ React.createElement(
                React.Fragment,
                null,
                /*#__PURE__*/ React.createElement(
                  View,
                  {
                    style: style,
                  },
                  list.map(function(data, index) {
                    return renderItem(data, index, list, refreshList);
                  }),
                ),
                footer,
              ),
        );
      },
      [
        defaultLimit,
        footer,
        list,
        list2,
        refreshList,
        renderItem,
        renderItemHeight,
        setShowError,
        showError,
        space,
      ],
    );
  },
);
export default List;
