assui 2.0.2 → 2.0.6

package/es/keep-tab/style/index.d.ts

@@ -0,0 +1,2 @@
+import 'antd/es/tabs/style';
+import 'antd/es/badge/style';

package/es/keep-tab/style/index.js

@@ -0,0 +1,2 @@
+import 'antd/es/tabs/style';
+import 'antd/es/badge/style';

package/es/keep-tab/style/index.less

@@ -0,0 +1,2 @@
+@import '~antd/es/tabs/style/index.less';
+@import '~antd/es/badge/style/index.less';

package/es/number-input/index.d.ts

@@ -1,12 +1,27 @@
-declare type ValueType = string | number;
 export interface NumberInputProps {
-    value?: ValueType;
+    /** 输入框的内容 */
+    value?: string;
+    /** 输入数据的类型 */
     numberType?: 'int' | 'float';
-    precision?: number;
-    formatter?: (value: ValueType) => void;
+    /** 精度，只对float有效 */
+    precision: number;
+    /** 指定输入框展示值的格式 */
+    formatter?: (value: string) => string;
+    /** 指定从 formatter 里转换回数字的方式，和 formatter 搭配使用 */
+    parser?: (value: string) => string;
+    /** 是否允许输入负数 */
     enableMinus?: boolean;
-    onChange?: (value: ValueType) => void;
-    onBlur?: (value: ValueType) => void;
+    /** 变化回调 */
+    onChange?: (value: string) => void;
+    /** 失去焦点回调 */
+    onBlur?: (value: string) => void;
 }
-declare const NumberInput: (props: NumberInputProps) => JSX.Element;
+declare const NumberInput: {
+    (props: NumberInputProps): JSX.Element;
+    defaultProps: {
+        numberType: string;
+        precision: number;
+        enableMinus: boolean;
+    };
+};
 export default NumberInput;

package/es/number-input/index.js

@@ -55,7 +55,7 @@ var __read = this && this.__read || function (o, n) {
 };
 
 import * as React from 'react';
-import Input from 'antd/lib/input';
+import Input from 'antd/es/input';
 import { INT } from './const/numberType';
 import { filterInt, filterFloat } from './utils';
 
@@ -65,15 +65,16 @@ var NumberInput = function NumberInput(props) {
       numberType = props.numberType,
       precision = props.precision,
       formatter = props.formatter,
+      parser = props.parser,
       enableMinus = props.enableMinus,
       onBlur = props.onBlur,
-      restProps = __rest(props, ["value", "onChange", "numberType", "precision", "formatter", "enableMinus", "onBlur"]);
+      restProps = __rest(props, ["value", "onChange", "numberType", "precision", "formatter", "parser", "enableMinus", "onBlur"]);
 
   var _a = __read(React.useState(''), 2),
       number = _a[0],
       setNumber = _a[1];
 
-  var resultValue = (value === 0 ? "" + value : value) || number;
+  var resultValue = value === undefined ? number : value;
 
   var onNumberChange = function onNumberChange(e) {
     var newNumber;
@@ -94,39 +95,49 @@ var NumberInput = function NumberInput(props) {
       });
     }
 
-    if (formatter) {
-      newNumber = formatter(newNumber);
+    if (parser) {
+      newNumber = parser(newNumber);
     }
 
     if (resultValue !== newNumber) {
+      if (value === undefined) {
+        setNumber(newNumber);
+      }
+
       if (onChange) {
         onChange(newNumber);
-      } else {
-        setNumber(newNumber);
       }
     }
   };
 
   var onNumberBlur = function onNumberBlur() {
     if (resultValue === '-' || resultValue === '.') {
+      if (value === undefined) {
+        setNumber('');
+      }
+
       if (onChange) {
         onChange('');
-      } else {
-        setNumber('');
       }
     }
 
     if (onBlur) {
-      onBlur(resultValue);
+      onBlur(resultValue || '');
     }
   };
 
+  var inputValue = formatter ? formatter(resultValue) : resultValue;
   return /*#__PURE__*/React.createElement(Input, __assign({
     type: "text",
-    value: resultValue,
+    value: inputValue,
     onBlur: onNumberBlur,
     onChange: onNumberChange
   }, restProps));
 };
 
+NumberInput.defaultProps = {
+  numberType: INT,
+  precision: 2,
+  enableMinus: false
+};
 export default NumberInput;

package/es/number-input/style/index.d.ts

@@ -1 +1 @@
-import './index.less';
+import 'antd/es/input/style';

package/es/number-input/style/index.js

@@ -1 +1 @@
-import './index.less';
+import 'antd/es/input/style';

package/es/number-input/utils.d.ts

@@ -1,11 +1,10 @@
-export declare const filterInt: ({ value, enableMinus, preValue }: {
-    value: any;
-    enableMinus: any;
-    preValue: any;
-}) => any;
-export declare const filterFloat: ({ value, preValue, precision, enableMinus }: {
-    value: any;
-    preValue: any;
-    precision: any;
-    enableMinus: any;
-}) => any;
+export interface FilterIntType {
+    value: string;
+    enableMinus?: boolean;
+    preValue: string;
+}
+export declare const filterInt: ({ value, enableMinus, preValue }: FilterIntType) => string;
+export interface FilterFloatType extends FilterIntType {
+    precision: number;
+}
+export declare const filterFloat: ({ value, preValue, precision, enableMinus }: FilterFloatType) => string;

package/es/number-input/utils.js

@@ -3,13 +3,13 @@ export var filterInt = function filterInt(_a) {
   var value = _a.value,
       enableMinus = _a.enableMinus,
       preValue = _a.preValue;
-  var nextValue = value.replace(/[^\-\d]/g, '');
+  var nextValue = value.replace(/[^\d\-]/g, '');
 
   if (!enableMinus) {
-    nextValue = value.replace(/[^\d]/g, '');
+    nextValue = value.replace(/\D/g, '');
   }
 
-  var intNumberReg = /^\-?\d+$/;
+  var intNumberReg = /^-?\d+$/;
 
   if (nextValue && nextValue.length > 1 && !intNumberReg.test(nextValue)) {
     return preValue;
@@ -22,18 +22,18 @@ export var filterFloat = function filterFloat(_a) {
       preValue = _a.preValue,
       precision = _a.precision,
       enableMinus = _a.enableMinus;
-  var nextValue = value.replace(/[^\-\d.]/g, '');
-  var matchDecimalPoint = nextValue.match(/[.]/g) || [];
+  var nextValue = value.replace(/[^\d.\-]/g, '');
+  var matchDecimalPoint = nextValue.match(/\./g) || [];
 
   if (matchDecimalPoint.length > 1) {
     return preValue;
   }
 
   if (!enableMinus) {
-    nextValue = value.replace(/[^0-9.]/g, '');
+    nextValue = value.replace(/[^\d.]/g, '');
   }
 
-  var floatNumberReg = /^\-?\d+\.?\d*$/;
+  var floatNumberReg = /^-?\d+\.?\d*$/;
 
   if (nextValue && nextValue.length > 1 && !floatNumberReg.test(nextValue)) {
     return preValue;

package/es/rc-echart/core.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import { EChartsOption } from 'echarts';
+export declare type Opts = {
+    devicePixelRatio?: number;
+    renderer?: 'canvas' | 'svg';
+    width?: number | null | undefined | 'auto';
+    height?: number | null | undefined | 'auto';
+    locale?: string;
+};
+export interface RcEchartPropsType {
+    option: EChartsOption;
+    notMerge?: boolean;
+    lazyUpdate?: boolean;
+    echarts: any;
+    style?: React.CSSProperties;
+    className?: string;
+    theme?: string;
+    onEvents?: Record<string, Function>;
+    opts?: Opts;
+}
+declare const ReactEchartCore: {
+    (props: RcEchartPropsType): JSX.Element;
+    defaultProps: {
+        notMerge: boolean;
+        lazyUpdate: boolean;
+        style: {};
+        className: string;
+        onEvents: {};
+        opts: {};
+    };
+};
+export default ReactEchartCore;

package/es/rc-echart/core.js

@@ -0,0 +1,136 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
+};
+/* eslint-disable no-unused-expressions */
+
+/* eslint-disable no-restricted-syntax */
+
+
+import React, { useRef, useLayoutEffect } from 'react';
+import useMount from 'ahooks/lib/useMount';
+import useUpdateEffect from 'ahooks/lib/useUpdateEffect';
+import classNames from 'classnames';
+import ResizeObserver from 'resize-observer-polyfill';
+
+var ReactEchartCore = function ReactEchartCore(props) {
+  var className = props.className,
+      option = props.option,
+      style = props.style,
+      echarts = props.echarts,
+      notMerge = props.notMerge,
+      lazyUpdate = props.lazyUpdate,
+      onEvents = props.onEvents,
+      opts = props.opts,
+      theme = props.theme;
+  var chartDomRef = useRef();
+  var chartRef = useRef();
+
+  var bindEvents = function bindEvents() {
+    var bindEventFunc = function bindEventFunc(eventName, func) {
+      if (typeof eventName === 'string' && typeof func === 'function') {
+        if (chartRef.current) {
+          chartRef.current.on(eventName, function (param) {
+            func(param, chartRef.current);
+          });
+        }
+      }
+    };
+
+    for (var eventName in onEvents) {
+      if (Object.prototype.hasOwnProperty.call(onEvents, eventName)) {
+        bindEventFunc(eventName, onEvents[eventName]);
+      }
+    }
+  };
+
+  var initEcharts = function initEcharts() {
+    chartRef.current = echarts.init(chartDomRef.current, theme, opts);
+  };
+
+  var renderEchartDom = function renderEchartDom() {
+    if (chartRef.current) {
+      chartRef.current.setOption(option, notMerge, lazyUpdate);
+    }
+  };
+
+  var dispose = function dispose() {
+    if (chartRef.current) {
+      chartRef.current.dispose();
+    }
+  }; // first add
+
+
+  useMount(function () {
+    initEcharts();
+    renderEchartDom();
+    bindEvents();
+  }); // need reBuild
+
+  useUpdateEffect(function () {
+    dispose();
+    renderEchartDom();
+    bindEvents();
+  }, [theme, opts, onEvents]); // need setOption
+
+  useUpdateEffect(function () {
+    renderEchartDom();
+  }, [option, notMerge, lazyUpdate]); // need resize
+
+  var resizeChart = function resizeChart() {
+    if (chartRef.current) {
+      chartRef.current.resize();
+    }
+  };
+
+  useLayoutEffect(function () {
+    var resizeObserver = new ResizeObserver(function () {
+      resizeChart();
+    });
+
+    if (chartDomRef.current) {
+      resizeObserver.observe(chartDomRef.current);
+    }
+
+    return function () {
+      resizeObserver.disconnect();
+    };
+  }, []);
+  useUpdateEffect(function () {
+    resizeChart();
+  }, [style, className]);
+
+  var finallyStyle = __assign({
+    width: '100%',
+    height: '100%'
+  }, style);
+
+  return /*#__PURE__*/React.createElement("div", {
+    ref: function ref(node) {
+      chartDomRef.current = node;
+    },
+    style: finallyStyle,
+    className: classNames('react-echart', className)
+  });
+};
+
+ReactEchartCore.defaultProps = {
+  notMerge: false,
+  lazyUpdate: false,
+  style: {},
+  className: '',
+  onEvents: {},
+  opts: {}
+};
+export default ReactEchartCore;

package/es/rc-echart/index.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import * as echarts from 'echarts';
+export declare type Opts = {
+    devicePixelRatio?: number;
+    renderer?: 'canvas' | 'svg';
+    width?: number | null | undefined | 'auto';
+    height?: number | null | undefined | 'auto';
+    locale?: string;
+};
+export interface RcEchartPropsType {
+    option: echarts.EChartsOption;
+    notMerge?: boolean;
+    lazyUpdate?: boolean;
+    style?: React.CSSProperties;
+    className?: string;
+    theme?: string;
+    onEvents?: Record<string, Function>;
+    opts?: Opts;
+}
+declare const RcEcharts: (props: RcEchartPropsType) => JSX.Element;
+export default RcEcharts;

package/es/rc-echart/index.js

@@ -0,0 +1,27 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
+};
+
+import React from 'react';
+import * as echarts from 'echarts';
+import RcEchartCore from './core';
+
+var RcEcharts = function RcEcharts(props) {
+  return /*#__PURE__*/React.createElement(RcEchartCore, __assign({
+    echarts: echarts
+  }, props));
+};
+
+export default RcEcharts;

package/es/rc-echart/style/index.d.ts

@@ -0,0 +1 @@
+

package/es/rc-motion/demo/CSSMotion.less

@@ -0,0 +1,91 @@
+.grid {
+  display: table;
+
+  > div {
+    display: table-cell;
+    min-width: 350px;
+  }
+}
+
+.demo-block {
+  display: block;
+  height: 300px;
+  width: 300px;
+  background: red;
+  overflow: hidden;
+}
+
+.transition {
+  transition: height 1.3s, opacity 1.3s;
+  // transition: all 5s!important;
+
+  &.transition-appear,
+  &.transition-enter {
+    opacity: 0;
+  }
+
+  &.transition-appear.transition-appear-active,
+  &.transition-enter.transition-enter-active {
+    opacity: 1;
+  }
+
+  &.transition-leave-active {
+    opacity: 0;
+    background: green;
+  }
+}
+
+.animation {
+  animation-duration: 1.3s;
+  animation-fill-mode: both;
+
+  &.animation-appear,
+  &.animation-enter {
+    animation-name: enter;
+    animation-fill-mode: both;
+    animation-play-state: paused;
+  }
+
+  &.animation-appear.animation-appear-active,
+  &.animation-enter.animation-enter-active {
+    animation-name: enter;
+    animation-play-state: running;
+  }
+
+  &.animation-leave {
+    animation-name: leave;
+    animation-fill-mode: both;
+    animation-play-state: paused;
+
+    &.animation-leave-active {
+      animation-name: leave;
+      animation-play-state: running;
+    }
+  }
+}
+
+.hidden {
+  display: none !important;
+}
+
+@keyframes enter {
+  from {
+    transform: scale(0);
+    opacity: 0;
+  }
+  to {
+    transform: scale(1);
+    opacity: 1;
+  }
+}
+
+@keyframes leave {
+  from {
+    transform: scale(1);
+    opacity: 1;
+  }
+  to {
+    transform: scale(0);
+    opacity: 0;
+  }
+}