acud 1.2.17 → 1.2.18

package/es/input-number/src/hooks/useCursor.js

@@ -4,16 +4,14 @@ import warning from "rc-util/es/warning";
  * Keep input cursor in the correct position if possible.
  * Is this necessary since we have `formatter` which may mass the content?
  */
-
 export default function useCursor(input, focused) {
   var selectionRef = useRef(null);
-
   function recordCursor() {
     // Record position
     try {
       var start = input.selectionStart,
-          end = input.selectionEnd,
-          value = input.value;
+        end = input.selectionEnd,
+        value = input.value;
       var beforeTxt = value.substring(0, start);
       var afterTxt = value.substring(end);
       selectionRef.current = {
@@ -23,7 +21,8 @@ export default function useCursor(input, focused) {
         beforeTxt: beforeTxt,
         afterTxt: afterTxt
       };
-    } catch (e) {// Fix error in Chrome:
+    } catch (e) {
+      // Fix error in Chrome:
       // Failed to read the 'selectionStart' property from 'HTMLInputElement'
       // http://stackoverflow.com/q/21177489/3040605
     }
@@ -33,18 +32,15 @@ export default function useCursor(input, focused) {
    *  1. back string same
    *  2. start string same
    */
-
-
   function restoreCursor() {
     if (input && selectionRef.current && focused) {
       try {
         var value = input.value;
         var _selectionRef$current = selectionRef.current,
-            beforeTxt = _selectionRef$current.beforeTxt,
-            afterTxt = _selectionRef$current.afterTxt,
-            start = _selectionRef$current.start;
+          beforeTxt = _selectionRef$current.beforeTxt,
+          afterTxt = _selectionRef$current.afterTxt,
+          start = _selectionRef$current.start;
         var startPos = value.length;
-
         if (value.endsWith(afterTxt)) {
           startPos = value.length - selectionRef.current.afterTxt.length;
         } else if (value.startsWith(beforeTxt)) {
@@ -52,18 +48,15 @@ export default function useCursor(input, focused) {
         } else {
           var beforeLastChar = beforeTxt[start - 1];
           var newIndex = value.indexOf(beforeLastChar, start - 1);
-
           if (newIndex !== -1) {
             startPos = newIndex + 1;
           }
         }
-
         input.setSelectionRange(startPos, startPos);
       } catch (e) {
         warning(false, "Something warning of cursor restore. Please fire issue about this: ".concat(e.message));
       }
     }
   }
-
   return [recordCursor, restoreCursor];
 }

package/es/input-number/src/hooks/useFrame.js

@@ -3,14 +3,11 @@ import raf from "rc-util/es/raf";
 /**
  * Always trigger latest once when call multiple time
  */
-
 export default (function () {
   var idRef = useRef(0);
-
   var cleanUp = function cleanUp() {
     raf.cancel(idRef.current);
   };
-
   useEffect(function () {
     return cleanUp;
   }, []);

package/es/input-number/src/hooks/useUpdateEffect.js

@@ -3,7 +3,6 @@ import { useLayoutEffect } from './useLayoutEffect';
 /**
  * Work as `componentDidUpdate`
  */
-
 export default function useUpdateEffect(callback, condition) {
   var initRef = React.useRef(false);
   useLayoutEffect(function () {
@@ -11,7 +10,6 @@ export default function useUpdateEffect(callback, condition) {
       initRef.current = true;
       return undefined;
     }
-
     return callback();
   }, condition);
 }

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

@@ -1,4 +1,4 @@
-export declare type ValueType = string | number;
+export type ValueType = string | number;
 export interface DecimalClass {
     add: (value: ValueType) => DecimalClass;
     isEmpty: () => boolean;

package/es/input-number/src/utils/MiniDecimal.js

@@ -1,28 +1,22 @@
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import _createClass from "@babel/runtime/helpers/esm/createClass";
-
 /* eslint-disable max-classes-per-file */
 import { getNumberPrecision, isE, num2str, trimNumber, validateNumber } from './numberUtil';
 import { supportBigInt } from './supportUtil';
 /**
  * We can remove this when IE not support anymore
  */
-
 export var NumberDecimal = /*#__PURE__*/function () {
   function NumberDecimal(value) {
     _classCallCheck(this, NumberDecimal);
-
     this.origin = '';
-
     if (!value && value !== 0 || !String(value).trim()) {
       this.empty = true;
       return;
     }
-
     this.origin = String(value);
     this.number = Number(value);
   }
-
   _createClass(NumberDecimal, [{
     key: "negate",
     value: function negate() {
@@ -34,23 +28,18 @@ export var NumberDecimal = /*#__PURE__*/function () {
       if (this.isInvalidate()) {
         return new NumberDecimal(value);
       }
-
       var target = Number(value);
-
       if (Number.isNaN(target)) {
         return this;
       }
-
-      var number = this.number + target; // [Legacy] Back to safe integer
-
+      var number = this.number + target;
+      // [Legacy] Back to safe integer
       if (number > Number.MAX_SAFE_INTEGER) {
         return new NumberDecimal(Number.MAX_SAFE_INTEGER);
       }
-
       if (number < Number.MIN_SAFE_INTEGER) {
         return new NumberDecimal(Number.MIN_SAFE_INTEGER);
       }
-
       var maxPrecision = Math.max(getNumberPrecision(this.number), getNumberPrecision(target));
       return new NumberDecimal(number.toFixed(maxPrecision));
     }
@@ -88,47 +77,37 @@ export var NumberDecimal = /*#__PURE__*/function () {
     key: "toString",
     value: function toString() {
       var safe = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-
       if (!safe) {
         return this.origin;
       }
-
       if (this.isInvalidate()) {
         return '';
       }
-
       return num2str(this.number);
     }
   }]);
-
   return NumberDecimal;
 }();
 export var BigIntDecimal = /*#__PURE__*/function () {
   function BigIntDecimal(value) {
     _classCallCheck(this, BigIntDecimal);
-
     this.origin = '';
-
     if (!value && value !== 0 || !String(value).trim()) {
       this.empty = true;
       return;
     }
-
-    this.origin = String(value); // Act like Number convert
-
+    this.origin = String(value);
+    // Act like Number convert
     if (value === '-') {
       this.nan = true;
       return;
     }
-
-    var mergedValue = value; // We need convert back to Number since it require `toFixed` to handle this
-
+    var mergedValue = value;
+    // We need convert back to Number since it require `toFixed` to handle this
     if (isE(mergedValue)) {
       mergedValue = Number(mergedValue);
     }
-
     mergedValue = typeof mergedValue === 'string' ? mergedValue : num2str(mergedValue);
-
     if (validateNumber(mergedValue)) {
       var trimRet = trimNumber(mergedValue);
       this.negative = trimRet.negative;
@@ -141,7 +120,6 @@ export var BigIntDecimal = /*#__PURE__*/function () {
       this.nan = true;
     }
   }
-
   _createClass(BigIntDecimal, [{
     key: "getMark",
     value: function getMark() {
@@ -161,7 +139,6 @@ export var BigIntDecimal = /*#__PURE__*/function () {
      * Align BigIntDecimal with same decimal length. e.g. 12.3 + 5 = 1230000
      * This is used for add function only.
      */
-
   }, {
     key: "alignDecimal",
     value: function alignDecimal(decimalLength) {
@@ -181,22 +158,18 @@ export var BigIntDecimal = /*#__PURE__*/function () {
       if (this.isInvalidate()) {
         return new BigIntDecimal(value);
       }
-
       var offset = new BigIntDecimal(value);
-
       if (offset.isInvalidate()) {
         return this;
       }
-
       var maxDecimalLength = Math.max(this.getDecimalStr().length, offset.getDecimalStr().length);
       var myAlignedDecimal = this.alignDecimal(maxDecimalLength);
       var offsetAlignedDecimal = offset.alignDecimal(maxDecimalLength);
-      var valueStr = (myAlignedDecimal + offsetAlignedDecimal).toString(); // We need fill string length back to `maxDecimalLength` to avoid parser failed
-
+      var valueStr = (myAlignedDecimal + offsetAlignedDecimal).toString();
+      // We need fill string length back to `maxDecimalLength` to avoid parser failed
       var _trimNumber = trimNumber(valueStr),
-          negativeStr = _trimNumber.negativeStr,
-          trimStr = _trimNumber.trimStr;
-
+        negativeStr = _trimNumber.negativeStr,
+        trimStr = _trimNumber.trimStr;
       var hydrateValueStr = "".concat(negativeStr).concat(trimStr.padStart(maxDecimalLength + 1, '0'));
       return new BigIntDecimal("".concat(hydrateValueStr.slice(0, -maxDecimalLength), ".").concat(hydrateValueStr.slice(-maxDecimalLength)));
     }
@@ -231,26 +204,21 @@ export var BigIntDecimal = /*#__PURE__*/function () {
       if (this.isNaN()) {
         return NaN;
       }
-
       return Number(this.toString());
     }
   }, {
     key: "toString",
     value: function toString() {
       var safe = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-
       if (!safe) {
         return this.origin;
       }
-
       if (this.isInvalidate()) {
         return '';
       }
-
       return trimNumber("".concat(this.getMark()).concat(this.getIntegerStr(), ".").concat(this.getDecimalStr())).fullStr;
     }
   }]);
-
   return BigIntDecimal;
 }();
 export default function getMiniDecimal(value) {
@@ -259,75 +227,59 @@ export default function getMiniDecimal(value) {
   if (supportBigInt()) {
     return new BigIntDecimal(value);
   }
-
   return new NumberDecimal(value);
 }
 /**
  * round up an unsigned number str, like: 1.4 -> 2, 1.5 -> 2
  */
-
 export function roundUpUnsignedDecimal(numStr, precision) {
   var _trimNumber2 = trimNumber(numStr),
-      integerStr = _trimNumber2.integerStr,
-      decimalStr = _trimNumber2.decimalStr;
-
+    integerStr = _trimNumber2.integerStr,
+    decimalStr = _trimNumber2.decimalStr;
   var advancedDecimal = getMiniDecimal(integerStr + '.' + decimalStr).add("0.".concat('0'.repeat(precision), 5));
   return toFixed(advancedDecimal.toString(), '.', precision);
 }
 /**
  * round up an unsigned number str, like: 1.4 -> 1, 1.5 -> 1
  */
-
 export function roundDownUnsignedDecimal(numStr, precision) {
   var _trimNumber3 = trimNumber(numStr),
-      negativeStr = _trimNumber3.negativeStr,
-      integerStr = _trimNumber3.integerStr,
-      decimalStr = _trimNumber3.decimalStr;
-
+    negativeStr = _trimNumber3.negativeStr,
+    integerStr = _trimNumber3.integerStr,
+    decimalStr = _trimNumber3.decimalStr;
   var numberWithoutDecimal = "".concat(negativeStr).concat(integerStr);
-
   if (precision === 0) {
     return integerStr;
   }
-
   return "".concat(numberWithoutDecimal, ".").concat(decimalStr.padEnd(precision, '0').slice(0, precision));
 }
 /**
  * Align the logic of toFixed to around like 1.5 => 2
  */
-
 export function toFixed(numStr, separatorStr, precision) {
   if (numStr === '') {
     return '';
   }
-
   var _trimNumber4 = trimNumber(numStr),
-      negativeStr = _trimNumber4.negativeStr,
-      integerStr = _trimNumber4.integerStr,
-      decimalStr = _trimNumber4.decimalStr;
-
+    negativeStr = _trimNumber4.negativeStr,
+    integerStr = _trimNumber4.integerStr,
+    decimalStr = _trimNumber4.decimalStr;
   var precisionDecimalStr = "".concat(separatorStr).concat(decimalStr);
   var numberWithoutDecimal = "".concat(negativeStr).concat(integerStr);
-
   if (precision >= 0) {
     // We will get last + 1 number to check if need advanced number
     var advancedNum = Number(decimalStr[precision]);
-
     if (advancedNum >= 5) {
       var advancedDecimal = getMiniDecimal(numStr).add("".concat(negativeStr, "0.").concat('0'.repeat(precision)).concat(10 - advancedNum));
       return toFixed(advancedDecimal.toString(), separatorStr, precision);
     }
-
     if (precision === 0) {
       return numberWithoutDecimal;
     }
-
     return "".concat(numberWithoutDecimal).concat(separatorStr).concat(decimalStr.padEnd(precision, '0').slice(0, precision));
   }
-
   if (precisionDecimalStr === '.0') {
     return numberWithoutDecimal;
   }
-
   return "".concat(numberWithoutDecimal).concat(precisionDecimalStr);
 }

package/es/input-number/src/utils/numberUtil.js

@@ -2,33 +2,29 @@ import { supportBigInt } from './supportUtil';
 /**
  * Format string number to readable number
  */
-
 export function trimNumber(numStr) {
   var str = numStr.trim();
   var negative = str.startsWith('-');
-
   if (negative) {
     str = str.slice(1);
   }
-
-  str = str // Remove decimal 0. `1.000` => `1.`, `1.100` => `1.1`
-  .replace(/(\.\d*[^0])0*$/, '$1') // Remove useless decimal. `1.` => `1`
-  .replace(/\.0*$/, '') // Remove integer 0. `0001` => `1`, 000.1' => `.1`
+  str = str
+  // Remove decimal 0. `1.000` => `1.`, `1.100` => `1.1`
+  .replace(/(\.\d*[^0])0*$/, '$1')
+  // Remove useless decimal. `1.` => `1`
+  .replace(/\.0*$/, '')
+  // Remove integer 0. `0001` => `1`, 000.1' => `.1`
   .replace(/^0+/, '');
-
   if (str.startsWith('.')) {
     str = "0".concat(str);
   }
-
   var trimStr = str || '0';
   var splitNumber = trimStr.split('.');
   var integerStr = splitNumber[0] || '0';
   var decimalStr = splitNumber[1] || '0';
-
   if (integerStr === '0' && decimalStr === '0') {
     negative = false;
   }
-
   var negativeStr = negative ? '-' : '';
   return {
     negative: negative,
@@ -47,57 +43,48 @@ export function isE(number) {
  * [Legacy] Convert 1e-9 to 0.000000001.
  * This may lose some precision if user really want 1e-9.
  */
-
 export function getNumberPrecision(number) {
   var numStr = String(number);
-
   if (isE(number)) {
     var precision = Number(numStr.slice(numStr.indexOf('e-') + 2));
     var decimalMatch = numStr.match(/\.(\d+)/);
-
     if (decimalMatch === null || decimalMatch === void 0 ? void 0 : decimalMatch[1]) {
       precision += decimalMatch[1].length;
     }
-
     return precision;
   }
-
   return numStr.includes('.') && validateNumber(numStr) ? numStr.length - numStr.indexOf('.') - 1 : 0;
 }
 /**
  * Convert number (includes scientific notation) to -xxx.yyy format
  */
-
 export function num2str(number) {
   var numStr = String(number);
-
   if (isE(number)) {
     if (number > Number.MAX_SAFE_INTEGER) {
       return String(supportBigInt() ? BigInt(number).toString() : Number.MAX_SAFE_INTEGER);
     }
-
     if (number < Number.MIN_SAFE_INTEGER) {
       return String(supportBigInt() ? BigInt(number).toString() : Number.MIN_SAFE_INTEGER);
     }
-
     numStr = number.toFixed(getNumberPrecision(numStr));
   }
-
   return trimNumber(numStr).fullStr;
 }
 export function validateNumber(num) {
   if (typeof num === 'number') {
     return !Number.isNaN(num);
-  } // Empty
-
-
+  }
+  // Empty
   if (!num) {
     return false;
   }
-
-  return (// Normal type: 11.28
-    /^\s*-?\d+(\.\d+)?\s*$/.test(num) // Pre-number: 1.
-    || /^\s*-?\d+\.\s*$/.test(num) // Post-number: .1
+  return (
+    // Normal type: 11.28
+    /^\s*-?\d+(\.\d+)?\s*$/.test(num)
+    // Pre-number: 1.
+    || /^\s*-?\d+\.\s*$/.test(num)
+    // Post-number: .1
     || /^\s*-?\.\d+\s*$/.test(num)
   );
 }

package/es/layout/Sider.d.ts

@@ -3,8 +3,8 @@ export interface SiderContextProps {
     siderCollapsed?: boolean;
 }
 export declare const SiderContext: React.Context<SiderContextProps>;
-export declare type CollapseType = 'clickTrigger' | 'responsive';
-export declare type SiderTheme = 'light' | 'dark';
+export type CollapseType = 'clickTrigger' | 'responsive';
+export type SiderTheme = 'light' | 'dark';
 export interface SiderProps extends React.HTMLAttributes<HTMLDivElement> {
     prefixCls?: string;
     collapsible?: boolean;