acud 0.0.60

package/es/upload/utils.js

@@ -0,0 +1,144 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _extends from "@babel/runtime/helpers/esm/extends";
+export function file2Obj(file) {
+  return _extends(_extends({}, file), {
+    lastModified: file.lastModified,
+    lastModifiedDate: file.lastModifiedDate,
+    name: file.name,
+    size: file.size,
+    type: file.type,
+    uid: file.uid,
+    percent: 0,
+    originFileObj: file
+  });
+}
+/** Upload fileList. Replace file if exist or just push into it. */
+
+export function updateFileList(file, fileList) {
+  var nextFileList = _toConsumableArray(fileList);
+
+  var fileIndex = nextFileList.findIndex(function (_ref) {
+    var uid = _ref.uid;
+    return uid === file.uid;
+  });
+
+  if (fileIndex === -1) {
+    nextFileList.push(file);
+  } else {
+    nextFileList[fileIndex] = file;
+  }
+
+  return nextFileList;
+}
+export function getFileItem(file, fileList) {
+  var matchKey = file.uid !== undefined ? 'uid' : 'name';
+  return fileList.filter(function (item) {
+    return item[matchKey] === file[matchKey];
+  })[0];
+}
+export function removeFileItem(file, fileList) {
+  var matchKey = file.uid !== undefined ? 'uid' : 'name';
+  var removed = fileList.filter(function (item) {
+    return item[matchKey] !== file[matchKey];
+  });
+
+  if (removed.length === fileList.length) {
+    return null;
+  }
+
+  return removed;
+} // ==================== Default Image Preview ====================
+
+var extname = function extname() {
+  var url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  var temp = url.split('/');
+  var filename = temp[temp.length - 1];
+  var filenameWithoutSuffix = filename.split(/#|\?/)[0];
+  return (/\.[^./\\]*$/.exec(filenameWithoutSuffix) || [''])[0];
+};
+
+var isImageFileType = function isImageFileType(type) {
+  return type.indexOf('image/') === 0;
+};
+
+export var isImageUrl = function isImageUrl(file) {
+  if (file.type && !file.thumbUrl) {
+    return isImageFileType(file.type);
+  }
+
+  var url = file.thumbUrl || file.url || file.name || file.fileName || '';
+  var extension = extname(url);
+
+  if (/^data:image\//.test(url) || /(?:webp|svg|png|gif|jpg|jpeg|jfif|bmp|dpg|ico)$/i.test(extension)) {
+    return true;
+  }
+
+  if (/^data:/.test(url)) {
+    // other file types of base64
+    return false;
+  }
+
+  if (extension) {
+    // other file types which have extension
+    return false;
+  }
+
+  return true;
+};
+var MEASURE_SIZE = 200;
+export function previewImage(file) {
+  return new Promise(function (resolve) {
+    if (!file.type || !isImageFileType(file.type)) {
+      resolve('');
+      return;
+    }
+
+    var canvas = document.createElement('canvas');
+    canvas.width = MEASURE_SIZE;
+    canvas.height = MEASURE_SIZE;
+    canvas.style.cssText = "position: fixed;\n                left: 0;\n                top: 0;\n                width: ".concat(MEASURE_SIZE, "px;\n                height: ").concat(MEASURE_SIZE, "px;\n                z-index: 9999;\n                display: none;");
+    document.body.appendChild(canvas);
+    var ctx = canvas.getContext('2d');
+    var img = new Image();
+
+    img.onload = function () {
+      var width = img.width,
+          height = img.height;
+      var drawWidth = MEASURE_SIZE;
+      var drawHeight = MEASURE_SIZE;
+      var offsetX = 0;
+      var offsetY = 0;
+
+      if (width > height) {
+        drawHeight = height * (MEASURE_SIZE / width);
+        offsetY = -(drawHeight - drawWidth) / 2;
+      } else {
+        drawWidth = width * (MEASURE_SIZE / height);
+        offsetX = -(drawWidth - drawHeight) / 2;
+      }
+
+      ctx.drawImage(img, offsetX, offsetY, drawWidth, drawHeight);
+      var dataURL = canvas.toDataURL();
+      document.body.removeChild(canvas);
+      resolve(dataURL);
+    };
+
+    img.src = window.URL.createObjectURL(file);
+  });
+}
+export var getFiletypeByName = function getFiletypeByName(fileName) {
+  var type = 'unknow';
+  var extension = extname(fileName);
+
+  if (/(?:jpeg|jpg|bmp|png|tif|gif|pcx|tga|exif|fpx|svg|psd|cdr|pcd|dxf|ufo|eps|ai|raw|WMF|webp|avif|apng)$/i.test(extension)) {
+    type = 'image';
+  } else if (/(?:3gpp|wmv|avi|flv|f4v|mkv|mov|mp4|m4a|mp2|mpeg|mpg|ogg|wmv|wma|rm|rmvb)$/i.test(extension)) {
+    type = 'video';
+  } else if (/(?:mp3|wav|wmv|aac|flac|ape)$/i.test(extension)) {
+    type = 'audio';
+  } else if (/(?:zip|tar|rar)$/i.test(extension)) {
+    type = 'zip';
+  }
+
+  return type;
+};

package/es/virtual-list/Filler.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+interface FillerProps {
+    prefixCls?: string;
+    /** Virtual filler height. Should be `count * itemMinHeight` */
+    height: number;
+    /** Set offset of visible items. Should be the top of start item position */
+    offset?: number;
+    children: React.ReactNode;
+    onInnerResize?: () => void;
+}
+/**
+ * Fill component to provided the scroll content real height.
+ */
+declare const Filler: React.ForwardRefExoticComponent<FillerProps & React.RefAttributes<HTMLDivElement>>;
+export default Filler;

package/es/virtual-list/Filler.js

@@ -0,0 +1,54 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import ResizeObserver from 'rc-resize-observer';
+import classNames from 'classnames';
+/**
+ * Fill component to provided the scroll content real height.
+ */
+
+var Filler = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
+  var height = _ref.height,
+      offset = _ref.offset,
+      children = _ref.children,
+      prefixCls = _ref.prefixCls,
+      onInnerResize = _ref.onInnerResize;
+  var outerStyle = {};
+  var innerStyle = {
+    display: 'flex',
+    flexDirection: 'column'
+  };
+
+  if (offset !== undefined) {
+    outerStyle = {
+      height: height,
+      position: 'relative',
+      overflow: 'hidden'
+    };
+    innerStyle = _extends(_extends({}, innerStyle), {
+      transform: "translateY(".concat(offset, "px)"),
+      position: 'absolute',
+      left: 0,
+      right: 0,
+      top: 0
+    });
+  }
+
+  return /*#__PURE__*/React.createElement("div", {
+    style: outerStyle
+  }, /*#__PURE__*/React.createElement(ResizeObserver, {
+    onResize: function onResize(_ref2) {
+      var offsetHeight = _ref2.offsetHeight;
+
+      if (offsetHeight && onInnerResize) {
+        onInnerResize();
+      }
+    }
+  }, /*#__PURE__*/React.createElement("div", {
+    style: innerStyle,
+    className: classNames(_defineProperty({}, "".concat(prefixCls, "-holder-inner"), prefixCls)),
+    ref: ref
+  }, children)));
+});
+Filler.displayName = 'Filler';
+export default Filler;

package/es/virtual-list/Item.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+export interface ItemProps {
+    children: React.ReactElement;
+    setRef: (element: HTMLElement) => void;
+}
+export declare function Item({ children, setRef }: ItemProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;

package/es/virtual-list/Item.js

@@ -0,0 +1,11 @@
+import * as React from 'react';
+export function Item(_ref) {
+  var children = _ref.children,
+      setRef = _ref.setRef;
+  var refFunc = React.useCallback(function (node) {
+    setRef(node);
+  }, []);
+  return /*#__PURE__*/React.cloneElement(children, {
+    ref: refFunc
+  });
+}

package/es/virtual-list/List.d.ts

@@ -0,0 +1,39 @@
+import * as React from 'react';
+import type { RenderFunc } from './interface';
+export declare type ScrollAlign = 'top' | 'bottom' | 'auto';
+export declare type ScrollConfig = {
+    index: number;
+    align?: ScrollAlign;
+    offset?: number;
+} | {
+    key: React.Key;
+    align?: ScrollAlign;
+    offset?: number;
+};
+export declare type ScrollTo = (arg: number | ScrollConfig) => void;
+export declare type ListRef = {
+    scrollTo: ScrollTo;
+};
+export interface ListProps<T> extends React.HTMLAttributes<any> {
+    prefixCls?: string;
+    children: RenderFunc<T>;
+    data: T[];
+    height?: number;
+    itemHeight?: number;
+    /** If not match virtual scroll condition, Set List still use height of container. */
+    fullHeight?: boolean;
+    itemKey: React.Key | ((item: T) => React.Key);
+    component?: string | React.FC<any> | React.ComponentClass<any>;
+    /** Set `false` will always use real scroll instead of virtual one */
+    virtual?: boolean;
+    onScroll?: React.UIEventHandler<HTMLElement>;
+    /** Trigger when render list item changed */
+    onVisibleChange?: (visibleList: T[], fullList: T[]) => void;
+}
+export declare function RawList<T>(props: ListProps<T>, ref: React.Ref<ListRef>): JSX.Element;
+declare const _default: <Item = any>(props: ListProps<Item> & {
+    children?: React.ReactNode;
+} & {
+    ref?: React.Ref<ListRef>;
+}) => React.ReactElement;
+export default _default;

package/es/virtual-list/List.js

@@ -0,0 +1,354 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+import * as React from 'react';
+import { useRef, useState } from 'react';
+import classNames from 'classnames';
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+import Filler from './Filler';
+import ScrollBar from './ScrollBar';
+import useChildren from './hooks/useChildren';
+import useHeights from './hooks/useHeights';
+import useScrollTo from './hooks/useScrollTo';
+import useDiffItem from './hooks/useDiffItem';
+import useFrameWheel from './hooks/useFrameWheel';
+import useMobileTouchMove from './hooks/useMobileTouchMove';
+import useOriginScroll from './hooks/useOriginScroll';
+var EMPTY_DATA = [];
+var ScrollStyle = {
+  overflowY: 'auto',
+  overflowAnchor: 'none'
+};
+export function RawList(props, ref) {
+  var _props$prefixCls = props.prefixCls,
+      prefixCls = _props$prefixCls === void 0 ? 'virtual-list' : _props$prefixCls,
+      className = props.className,
+      height = props.height,
+      itemHeight = props.itemHeight,
+      _props$fullHeight = props.fullHeight,
+      fullHeight = _props$fullHeight === void 0 ? true : _props$fullHeight,
+      style = props.style,
+      data = props.data,
+      children = props.children,
+      itemKey = props.itemKey,
+      virtual = props.virtual,
+      _props$component = props.component,
+      Component = _props$component === void 0 ? 'div' : _props$component,
+      onScroll = props.onScroll,
+      onVisibleChange = props.onVisibleChange,
+      restProps = __rest(props, ["prefixCls", "className", "height", "itemHeight", "fullHeight", "style", "data", "children", "itemKey", "virtual", "component", "onScroll", "onVisibleChange"]); // ================================= MISC =================================
+
+
+  var useVirtual = !!(virtual !== false && height && itemHeight);
+  var inVirtual = useVirtual && data && itemHeight * data.length > height;
+
+  var _useState = useState(0),
+      _useState2 = _slicedToArray(_useState, 2),
+      scrollTop = _useState2[0],
+      setScrollTop = _useState2[1];
+
+  var _useState3 = useState(false),
+      _useState4 = _slicedToArray(_useState3, 2),
+      scrollMoving = _useState4[0],
+      setScrollMoving = _useState4[1];
+
+  var mergedClassName = classNames(prefixCls, className);
+  var mergedData = data || EMPTY_DATA;
+  var componentRef = useRef();
+  var fillerInnerRef = useRef();
+  var scrollBarRef = useRef(); // Hack on scrollbar to enable flash call
+  // =============================== Item Key ===============================
+
+  var getKey = React.useCallback(function (item) {
+    if (typeof itemKey === 'function') {
+      return itemKey(item);
+    }
+
+    return item === null || item === void 0 ? void 0 : item[itemKey];
+  }, [itemKey]);
+  var sharedConfig = {
+    getKey: getKey
+  }; // ================================ Scroll ================================
+
+  function syncScrollTop(newTop) {
+    setScrollTop(function (origin) {
+      var value;
+
+      if (typeof newTop === 'function') {
+        value = newTop(origin);
+      } else {
+        value = newTop;
+      }
+
+      var alignedTop = keepInRange(value);
+      componentRef.current.scrollTop = alignedTop;
+      return alignedTop;
+    });
+  } // ================================ Legacy ================================
+  // Put ref here since the range is generate by follow
+
+
+  var rangeRef = useRef({
+    start: 0,
+    end: mergedData.length
+  });
+  var diffItemRef = useRef();
+
+  var _useDiffItem = useDiffItem(mergedData, getKey),
+      _useDiffItem2 = _slicedToArray(_useDiffItem, 1),
+      diffItem = _useDiffItem2[0];
+
+  diffItemRef.current = diffItem; // ================================ Height ================================
+
+  var _useHeights = useHeights(getKey, null, null),
+      _useHeights2 = _slicedToArray(_useHeights, 4),
+      setInstanceRef = _useHeights2[0],
+      collectHeight = _useHeights2[1],
+      heights = _useHeights2[2],
+      heightUpdatedMark = _useHeights2[3]; // ========================== Visible Calculation =========================
+
+
+  var _React$useMemo = React.useMemo(function () {
+    var _a;
+
+    if (!useVirtual) {
+      return {
+        scrollHeight: undefined,
+        start: 0,
+        end: mergedData.length - 1,
+        offset: undefined
+      };
+    } // Always use virtual scroll bar in avoid shaking
+
+
+    // Always use virtual scroll bar in avoid shaking
+    if (!inVirtual) {
+      return {
+        scrollHeight: ((_a = fillerInnerRef.current) === null || _a === void 0 ? void 0 : _a.offsetHeight) || 0,
+        start: 0,
+        end: mergedData.length - 1,
+        offset: undefined
+      };
+    }
+
+    var itemTop = 0;
+    var startIndex;
+    var startOffset;
+    var endIndex;
+    var dataLen = mergedData.length;
+
+    for (var i = 0; i < dataLen; i += 1) {
+      var item = mergedData[i];
+      var key = getKey(item);
+      var cacheHeight = heights.get(key);
+      var currentItemBottom = itemTop + (cacheHeight === undefined ? itemHeight : cacheHeight); // Check item top in the range
+
+      // Check item top in the range
+      if (currentItemBottom >= scrollTop && startIndex === undefined) {
+        startIndex = i;
+        startOffset = itemTop;
+      } // Check item bottom in the range. We will render additional one item for motion usage
+
+
+      // Check item bottom in the range. We will render additional one item for motion usage
+      if (currentItemBottom > scrollTop + height && endIndex === undefined) {
+        endIndex = i;
+      }
+
+      itemTop = currentItemBottom;
+    } // Fallback to normal if not match. This code should never reach
+
+    /* istanbul ignore next */
+
+
+    // Fallback to normal if not match. This code should never reach
+
+    /* istanbul ignore next */
+    if (startIndex === undefined) {
+      startIndex = 0;
+      startOffset = 0;
+    }
+
+    if (endIndex === undefined) {
+      endIndex = mergedData.length - 1;
+    } // Give cache to improve scroll experience
+
+
+    // Give cache to improve scroll experience
+    endIndex = Math.min(endIndex + 1, mergedData.length);
+    return {
+      scrollHeight: itemTop,
+      start: startIndex,
+      end: endIndex,
+      offset: startOffset
+    };
+  }, [inVirtual, useVirtual, scrollTop, mergedData, heightUpdatedMark, height]),
+      scrollHeight = _React$useMemo.scrollHeight,
+      start = _React$useMemo.start,
+      end = _React$useMemo.end,
+      offset = _React$useMemo.offset;
+
+  rangeRef.current.start = start;
+  rangeRef.current.end = end; // =============================== In Range ===============================
+
+  var maxScrollHeight = scrollHeight - height;
+  var maxScrollHeightRef = useRef(maxScrollHeight);
+  maxScrollHeightRef.current = maxScrollHeight;
+
+  function keepInRange(newScrollTop) {
+    var newTop = newScrollTop;
+
+    if (!Number.isNaN(maxScrollHeightRef.current)) {
+      newTop = Math.min(newTop, maxScrollHeightRef.current);
+    }
+
+    newTop = Math.max(newTop, 0);
+    return newTop;
+  }
+
+  var isScrollAtTop = scrollTop <= 0;
+  var isScrollAtBottom = scrollTop >= maxScrollHeight;
+  var originScroll = useOriginScroll(isScrollAtTop, isScrollAtBottom); // ================================ Scroll ================================
+
+  function onScrollBar(newScrollTop) {
+    var newTop = newScrollTop;
+    syncScrollTop(newTop);
+  } // When data size reduce. It may trigger native scroll event back to fit scroll position
+
+
+  function onFallbackScroll(e) {
+    var newScrollTop = e.currentTarget.scrollTop;
+
+    if (newScrollTop !== scrollTop) {
+      syncScrollTop(newScrollTop);
+    } // Trigger origin onScroll
+
+
+    onScroll === null || onScroll === void 0 ? void 0 : onScroll(e);
+  } // Since this added in global,should use ref to keep update
+
+
+  var _useFrameWheel = useFrameWheel(useVirtual, isScrollAtTop, isScrollAtBottom, function (offsetY) {
+    syncScrollTop(function (top) {
+      var newTop = top + offsetY;
+      return newTop;
+    });
+  }),
+      _useFrameWheel2 = _slicedToArray(_useFrameWheel, 2),
+      onRawWheel = _useFrameWheel2[0],
+      onFireFoxScroll = _useFrameWheel2[1]; // Mobile touch move
+
+
+  useMobileTouchMove(useVirtual, componentRef, function (deltaY, smoothOffset) {
+    if (originScroll(deltaY, smoothOffset)) {
+      return false;
+    }
+
+    onRawWheel({
+      preventDefault: function preventDefault() {},
+      deltaY: deltaY
+    });
+    return true;
+  });
+  useLayoutEffect(function () {
+    // Firefox only
+    function onMozMousePixelScroll(e) {
+      if (useVirtual) {
+        e.preventDefault();
+      }
+    }
+
+    componentRef.current.addEventListener('wheel', onRawWheel);
+    componentRef.current.addEventListener('DOMMouseScroll', onFireFoxScroll);
+    componentRef.current.addEventListener('MozMousePixelScroll', onMozMousePixelScroll);
+    return function () {
+      componentRef.current.removeEventListener('wheel', onRawWheel);
+      componentRef.current.removeEventListener('DOMMouseScroll', onFireFoxScroll);
+      componentRef.current.removeEventListener('MozMousePixelScroll', onMozMousePixelScroll);
+    };
+  }, [useVirtual]); // ================================= Ref ==================================
+
+  var scrollTo = useScrollTo(componentRef, mergedData, heights, itemHeight, getKey, collectHeight, syncScrollTop, function () {
+    var _a;
+
+    (_a = scrollBarRef.current) === null || _a === void 0 ? void 0 : _a.delayHidden();
+  });
+  React.useImperativeHandle(ref, function () {
+    return {
+      scrollTo: scrollTo
+    };
+  }); // ================================ Effect ================================
+
+  /** We need told outside that some list not rendered */
+
+  useLayoutEffect(function () {
+    if (onVisibleChange) {
+      var renderList = mergedData.slice(start, end + 1);
+      onVisibleChange(renderList, mergedData);
+    }
+  }, [start, end, mergedData]); // ================================ Render ================================
+
+  var listChildren = useChildren(mergedData, start, end, setInstanceRef, children, sharedConfig);
+  var componentStyle = null;
+
+  if (height) {
+    componentStyle = _extends(_defineProperty({}, fullHeight ? 'height' : 'maxHeight', height), ScrollStyle);
+
+    if (useVirtual) {
+      componentStyle.overflowY = 'hidden';
+
+      if (scrollMoving) {
+        componentStyle.pointerEvents = 'none';
+      }
+    }
+  }
+
+  return /*#__PURE__*/React.createElement("div", _extends({
+    style: _extends(_extends({}, style), {
+      position: 'relative'
+    }),
+    className: mergedClassName
+  }, restProps), /*#__PURE__*/React.createElement(Component, {
+    className: "".concat(prefixCls, "-holder"),
+    style: componentStyle,
+    ref: componentRef,
+    onScroll: onFallbackScroll
+  }, /*#__PURE__*/React.createElement(Filler, {
+    prefixCls: prefixCls,
+    height: scrollHeight,
+    offset: offset,
+    ref: fillerInnerRef,
+    onInnerResize: collectHeight
+  }, listChildren)), useVirtual && /*#__PURE__*/React.createElement(ScrollBar, {
+    ref: scrollBarRef,
+    prefixCls: prefixCls,
+    scrollTop: scrollTop,
+    height: height,
+    scrollHeight: scrollHeight,
+    count: mergedData.length,
+    onScroll: onScrollBar,
+    onStartMove: function onStartMove() {
+      setScrollMoving(true);
+    },
+    onStopMove: function onStopMove() {
+      setScrollMoving(false);
+    }
+  }));
+}
+var List = /*#__PURE__*/React.forwardRef(RawList);
+List.displayName = 'List';
+export default List;

package/es/virtual-list/ScrollBar.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="node" />
+import * as React from 'react';
+export interface ScrollBarProps {
+    prefixCls: string;
+    scrollTop: number;
+    scrollHeight: number;
+    height: number;
+    count: number;
+    onScroll: (scrollTop: number) => void;
+    onStartMove: () => void;
+    onStopMove: () => void;
+}
+interface ScrollBarState {
+    dragging: boolean;
+    pageY: number;
+    startTop: number;
+    visible: boolean;
+}
+export default class ScrollBar extends React.Component<ScrollBarProps, ScrollBarState> {
+    moveRaf: number;
+    scrollbarRef: React.RefObject<HTMLDivElement>;
+    thumbRef: React.RefObject<HTMLDivElement>;
+    visibleTimeout: NodeJS.Timeout;
+    state: ScrollBarState;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: ScrollBarProps): void;
+    componentWillUnmount(): void;
+    delayHidden: () => void;
+    onScrollbarTouchStart: (e: TouchEvent) => void;
+    onContainerMouseDown: React.MouseEventHandler;
+    patchEvents: () => void;
+    removeEvents: () => void;
+    onMouseDown: (e: React.MouseEvent | TouchEvent) => void;
+    onMouseMove: (e: MouseEvent | TouchEvent) => void;
+    onMouseUp: () => void;
+    getSpinHeight: () => number;
+    getEnableScrollRange: () => number;
+    getEnableHeightRange: () => number;
+    getTop: () => number;
+    showScroll: () => boolean;
+    render(): JSX.Element;
+}
+export {};