@qsxy/element-plus-react 1.0.2 → 2.0.0

package/dist/Util/easings.d.ts

@@ -0,0 +1 @@
+export declare function easeInOutCubic(t: number, b: number, c: number, d: number): number;

package/dist/Util/easings.js

@@ -0,0 +1,8 @@
+export function easeInOutCubic(t, b, c, d) {
+  var cc = c - b;
+  t /= d / 2;
+  if (t < 1) {
+    return cc / 2 * t * t * t + b;
+  }
+  return cc / 2 * ((t -= 2) * t * t + 2) + b;
+}

package/dist/Util/error.d.ts

@@ -0,0 +1,3 @@
+export declare function throwError(scope: string, m: string): never;
+export declare function debugWarn(err: Error): void;
+export declare function debugWarn(scope: string, message: string): void;

package/dist/Util/error.js

@@ -0,0 +1,39 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeFunction(fn) { try { return Function.toString.call(fn).indexOf("[native code]") !== -1; } catch (e) { return typeof fn === "function"; } }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import { isString } from "./base";
+var ElementPlusError = /*#__PURE__*/function (_Error) {
+  _inherits(ElementPlusError, _Error);
+  var _super = _createSuper(ElementPlusError);
+  function ElementPlusError(m) {
+    var _this;
+    _classCallCheck(this, ElementPlusError);
+    _this = _super.call(this, m);
+    _this.name = 'ElementPlusError';
+    return _this;
+  }
+  return _createClass(ElementPlusError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+export function throwError(scope, m) {
+  throw new ElementPlusError("[".concat(scope, "] ").concat(m));
+}
+export function debugWarn(scope, message) {
+  if (process.env.NODE_ENV !== 'production') {
+    var error = isString(scope) ? new ElementPlusError("[".concat(scope, "] ").concat(message)) : scope;
+    // eslint-disable-next-line no-console
+    console.warn(error);
+  }
+}

package/dist/Util/icons.d.ts

@@ -0,0 +1,2 @@
+import { IconProps } from '../Icon/typings';
+export declare const ValidateComponentsMap: Record<'validating' | 'success' | 'error', IconProps>;

package/dist/Util/icons.js

@@ -0,0 +1,15 @@
+export var ValidateComponentsMap = {
+  validating: {
+    name: 'loader',
+    prefix: 'far',
+    spin: true
+  },
+  success: {
+    name: 'circle-check',
+    prefix: 'fal'
+  },
+  error: {
+    name: 'circle-xmark',
+    prefix: 'fal'
+  }
+};

package/dist/Util/index.d.ts

@@ -1,6 +1,10 @@
-export * from './Math';
-export { default as PopupManager } from './PopupManager';
 export * from './base';
+export * from './error';
 export * from './genFileId';
+export * from './Math';
+export { default as PopupManager } from './PopupManager';
+export * from './position';
+export * from './raf';
+export * from './scroll';
 export { default as shallowEqual } from './shallowEqual';
 export * from './treeUtils';

package/dist/Util/index.js

@@ -1,6 +1,10 @@
-export * from "./Math";
-export { default as PopupManager } from "./PopupManager";
 export * from "./base";
+export * from "./error";
 export * from "./genFileId";
+export * from "./Math";
+export { default as PopupManager } from "./PopupManager";
+export * from "./position";
+export * from "./raf";
+export * from "./scroll";
 export { default as shallowEqual } from "./shallowEqual";
 export * from "./treeUtils";

package/dist/Util/position.d.ts

@@ -0,0 +1,9 @@
+export declare const isInContainer: (el?: Element, container?: Element | Window) => boolean;
+/** 获取元素到容器顶部的偏移距离 */
+export declare const getOffsetTop: (el: HTMLElement) => number;
+/** 获取目标元素到滚动容器顶部的距离 */
+export declare const getOffsetTopDistance: (el: HTMLElement, containerEl: HTMLElement) => number;
+export declare const getClientXY: (event: MouseEvent | TouchEvent) => {
+    clientX: number;
+    clientY: number;
+};

package/dist/Util/position.js

@@ -0,0 +1,53 @@
+import { isClient } from "./raf";
+export var isInContainer = function isInContainer(el, container) {
+  if (!isClient || !el || !container) {
+    return false;
+  }
+  var elRect = el.getBoundingClientRect();
+  var containerRect;
+  if (container instanceof Element) {
+    containerRect = container.getBoundingClientRect();
+  } else {
+    containerRect = {
+      top: 0,
+      right: window.innerWidth,
+      bottom: window.innerHeight,
+      left: 0
+    };
+  }
+  return elRect.top < containerRect.bottom && elRect.bottom > containerRect.top && elRect.right > containerRect.left && elRect.left < containerRect.right;
+};
+
+/** 获取元素到容器顶部的偏移距离 */
+export var getOffsetTop = function getOffsetTop(el) {
+  var offset = 0;
+  var parent = el;
+  while (parent) {
+    offset += parent.offsetTop;
+    parent = parent.offsetParent;
+  }
+  return offset;
+};
+
+/** 获取目标元素到滚动容器顶部的距离 */
+export var getOffsetTopDistance = function getOffsetTopDistance(el, containerEl) {
+  return Math.abs(getOffsetTop(el) - getOffsetTop(containerEl));
+};
+export var getClientXY = function getClientXY(event) {
+  var clientX;
+  var clientY;
+  if (event.type === 'touchend') {
+    clientY = event.changedTouches[0].clientY;
+    clientX = event.changedTouches[0].clientX;
+  } else if (event.type.startsWith('touch')) {
+    clientY = event.touches[0].clientY;
+    clientX = event.touches[0].clientX;
+  } else {
+    clientY = event.clientY;
+    clientX = event.clientX;
+  }
+  return {
+    clientX: clientX,
+    clientY: clientY
+  };
+};

package/dist/Util/raf.d.ts

@@ -0,0 +1,4 @@
+export declare const isClient: boolean;
+export declare const rAF: (fn: () => void) => number;
+export declare const cAF: (handle: number) => void;
+export declare const isFirefox: () => boolean;

package/dist/Util/raf.js

@@ -0,0 +1,10 @@
+export var isClient = typeof window !== 'undefined' && typeof document !== 'undefined';
+export var rAF = function rAF(fn) {
+  return isClient ? window.requestAnimationFrame(fn) : setTimeout(fn, 16);
+};
+export var cAF = function cAF(handle) {
+  return isClient ? window.cancelAnimationFrame(handle) : clearTimeout(handle);
+};
+export var isFirefox = function isFirefox() {
+  return isClient && /firefox/i.test(window.navigator.userAgent);
+};

package/dist/Util/scroll.d.ts

@@ -0,0 +1,9 @@
+export declare const getScrollBarWidth: (namespace: string) => number;
+/** 判断是否 window 对象 */
+export declare const isWindow: (el: unknown) => el is Window;
+/** 获取滚动元素 */
+export declare const getScrollElement: (target: HTMLElement, container: HTMLElement | Window) => HTMLElement;
+/** 获取 scrollTop */
+export declare const getScrollTop: (container: HTMLElement | Window) => number;
+/** 动画滚动 */
+export declare const animateScrollTo: (container: HTMLElement | Window, from: number, to: number, duration: number, callback?: () => void) => (() => void);

package/dist/Util/scroll.js

@@ -0,0 +1,72 @@
+import { isFunction } from "./base";
+import { easeInOutCubic } from "./easings";
+import { cAF, rAF } from "./raf";
+var scrollBarWidth;
+export var getScrollBarWidth = function getScrollBarWidth(namespace) {
+  var _outer$parentNode;
+  if (scrollBarWidth !== undefined) {
+    return scrollBarWidth;
+  }
+  var outer = document.createElement('div');
+  outer.className = "".concat(namespace, "-scrollbar__wrap");
+  outer.style.visibility = 'hidden';
+  outer.style.width = '100px';
+  outer.style.position = 'absolute';
+  outer.style.top = '-9999px';
+  document.body.appendChild(outer);
+  var widthNoScroll = outer.offsetWidth;
+  outer.style.overflow = 'scroll';
+  var inner = document.createElement('div');
+  inner.style.width = '100%';
+  outer.appendChild(inner);
+  var widthWithScroll = inner.offsetWidth;
+  (_outer$parentNode = outer.parentNode) === null || _outer$parentNode === void 0 || _outer$parentNode.removeChild(outer);
+  scrollBarWidth = widthNoScroll - widthWithScroll;
+  return scrollBarWidth;
+};
+
+/** 判断是否 window 对象 */
+export var isWindow = function isWindow(el) {
+  return el === window;
+};
+
+/** 获取滚动元素 */
+export var getScrollElement = function getScrollElement(target, container) {
+  if (isWindow(container)) {
+    return target.ownerDocument.documentElement;
+  }
+  return container;
+};
+
+/** 获取 scrollTop */
+export var getScrollTop = function getScrollTop(container) {
+  if (isWindow(container)) {
+    return window.scrollY;
+  }
+  return container.scrollTop;
+};
+
+/** 动画滚动 */
+export var animateScrollTo = function animateScrollTo(container, from, to, duration, callback) {
+  var startTime = Date.now();
+  var handle;
+  var scroll = function scroll() {
+    var timestamp = Date.now();
+    var time = timestamp - startTime;
+    var nextScrollTop = easeInOutCubic(time > duration ? duration : time, from, to, duration);
+    if (isWindow(container)) {
+      container.scrollTo(window.pageXOffset, nextScrollTop);
+    } else {
+      container.scrollTop = nextScrollTop;
+    }
+    if (time < duration) {
+      handle = rAF(scroll);
+    } else if (isFunction(callback)) {
+      callback();
+    }
+  };
+  scroll();
+  return function () {
+    handle && cAF(handle);
+  };
+};

package/dist/Util/throttleByRaf.d.ts

@@ -0,0 +1,4 @@
+export declare function throttleByRaf(cb: (...args: any[]) => void): {
+    (...args: any[]): void;
+    cancel(): void;
+};

package/dist/Util/throttleByRaf.js

@@ -0,0 +1,21 @@
+import { cAF, rAF } from "./raf";
+export function throttleByRaf(cb) {
+  var timer = 0;
+  var throttle = function throttle() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    if (timer) {
+      cAF(timer);
+    }
+    timer = rAF(function () {
+      cb.apply(void 0, args);
+      timer = 0;
+    });
+  };
+  throttle.cancel = function () {
+    cAF(timer);
+    timer = 0;
+  };
+  return throttle;
+}

package/dist/VirtualList/builders/build-grid.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { VirtualizedGridProps } from '../props';
+import { GridConstructorProps, GridExposes } from '../types';
+declare const createGrid: ({ name, clearCache, getColumnPosition, getColumnStartIndexForOffset, getColumnStopIndexForStartIndex, getEstimatedTotalHeight, getEstimatedTotalWidth, getColumnOffset, getRowOffset, getRowPosition, getRowStartIndexForOffset, getRowStopIndexForStartIndex, initCache, validateProps, }: GridConstructorProps<VirtualizedGridProps>) => React.ForwardRefExoticComponent<VirtualizedGridProps & React.RefAttributes<GridExposes>>;
+export default createGrid;