acud 0.0.60

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

@@ -0,0 +1,69 @@
+import { useRef } from 'react';
+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;
+      var beforeTxt = value.substring(0, start);
+      var afterTxt = value.substring(end);
+      selectionRef.current = {
+        start: start,
+        end: end,
+        value: value,
+        beforeTxt: beforeTxt,
+        afterTxt: afterTxt
+      };
+    } catch (e) {// Fix error in Chrome:
+      // Failed to read the 'selectionStart' property from 'HTMLInputElement'
+      // http://stackoverflow.com/q/21177489/3040605
+    }
+  }
+  /**
+   * Restore logic:
+   *  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;
+        var startPos = value.length;
+
+        if (value.endsWith(afterTxt)) {
+          startPos = value.length - selectionRef.current.afterTxt.length;
+        } else if (value.startsWith(beforeTxt)) {
+          startPos = beforeTxt.length;
+        } 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.d.ts

@@ -0,0 +1,5 @@
+declare const _default: () => (callback: () => void) => void;
+/**
+ * Always trigger latest once when call multiple time
+ */
+export default _default;

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

@@ -0,0 +1,23 @@
+import { useRef, useEffect } from 'react';
+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;
+  }, []);
+  return function (callback) {
+    cleanUp();
+    idRef.current = raf(function () {
+      callback();
+    });
+  };
+});

package/es/input-number/src/hooks/useLayoutEffect.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare const useLayoutEffect: typeof React.useEffect;

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

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import canUseDom from "rc-util/es/Dom/canUseDom";
+export var useLayoutEffect = canUseDom() ? React.useLayoutEffect : React.useEffect;

package/es/input-number/src/hooks/useUpdateEffect.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Work as `componentDidUpdate`
+ */
+export default function useUpdateEffect(callback: () => void | (() => void), condition: any[]): void;

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

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { useLayoutEffect } from './useLayoutEffect';
+/**
+ * Work as `componentDidUpdate`
+ */
+
+export default function useUpdateEffect(callback, condition) {
+  var initRef = React.useRef(false);
+  useLayoutEffect(function () {
+    if (!initRef.current) {
+      initRef.current = true;
+      return undefined;
+    }
+
+    return callback();
+  }, condition);
+}

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

@@ -0,0 +1,3 @@
+import InputNumber, { InputNumberProps } from './InputNumber';
+export { InputNumberProps };
+export default InputNumber;

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

@@ -0,0 +1,2 @@
+import InputNumber from './InputNumber';
+export default InputNumber;

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

@@ -0,0 +1,75 @@
+export declare type ValueType = string | number;
+export interface DecimalClass {
+    add: (value: ValueType) => DecimalClass;
+    isEmpty: () => boolean;
+    isNaN: () => boolean;
+    isInvalidate: () => boolean;
+    toNumber: () => number;
+    /**
+     * Parse value as string. Will return empty string if `isInvalidate`.
+     * You can set `safe=false` to get origin string content.
+     */
+    toString: (safe?: boolean) => string;
+    equals: (target: DecimalClass) => boolean;
+    lessEquals: (target: DecimalClass) => boolean;
+    negate: () => DecimalClass;
+}
+/**
+ * We can remove this when IE not support anymore
+ */
+export declare class NumberDecimal implements DecimalClass {
+    origin: string;
+    number: number;
+    empty: boolean;
+    constructor(value: ValueType);
+    negate(): NumberDecimal;
+    add(value: ValueType): NumberDecimal;
+    isEmpty(): boolean;
+    isNaN(): boolean;
+    isInvalidate(): boolean;
+    equals(target: DecimalClass): boolean;
+    lessEquals(target: DecimalClass): boolean;
+    toNumber(): number;
+    toString(safe?: boolean): string;
+}
+export declare class BigIntDecimal implements DecimalClass {
+    origin: string;
+    negative: boolean;
+    integer: bigint;
+    decimal: bigint;
+    /** BigInt will convert `0009` to `9`. We need record the len of decimal */
+    decimalLen: number;
+    empty: boolean;
+    nan: boolean;
+    constructor(value: string | number);
+    private getMark;
+    private getIntegerStr;
+    private getDecimalStr;
+    /**
+     * Align BigIntDecimal with same decimal length. e.g. 12.3 + 5 = 1230000
+     * This is used for add function only.
+     */
+    private alignDecimal;
+    negate(): BigIntDecimal;
+    add(value: ValueType): BigIntDecimal;
+    isEmpty(): boolean;
+    isNaN(): boolean;
+    isInvalidate(): boolean;
+    equals(target: DecimalClass): boolean;
+    lessEquals(target: DecimalClass): boolean;
+    toNumber(): number;
+    toString(safe?: boolean): string;
+}
+export default function getMiniDecimal(value: ValueType): DecimalClass;
+/**
+ * round up an unsigned number str, like: 1.4 -> 2, 1.5 -> 2
+ */
+export declare function roundUpUnsignedDecimal(numStr: string, precision: number): any;
+/**
+ * round up an unsigned number str, like: 1.4 -> 1, 1.5 -> 1
+ */
+export declare function roundDownUnsignedDecimal(numStr: string, precision: number): string;
+/**
+ * Align the logic of toFixed to around like 1.5 => 2
+ */
+export declare function toFixed(numStr: string, separatorStr: string, precision?: number): any;

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

@@ -0,0 +1,333 @@
+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() {
+      return new NumberDecimal(-this.toNumber());
+    }
+  }, {
+    key: "add",
+    value: function add(value) {
+      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
+
+      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));
+    }
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return this.empty;
+    }
+  }, {
+    key: "isNaN",
+    value: function isNaN() {
+      return Number.isNaN(this.number);
+    }
+  }, {
+    key: "isInvalidate",
+    value: function isInvalidate() {
+      return this.isEmpty() || this.isNaN();
+    }
+  }, {
+    key: "equals",
+    value: function equals(target) {
+      return this.toNumber() === (target === null || target === void 0 ? void 0 : target.toNumber());
+    }
+  }, {
+    key: "lessEquals",
+    value: function lessEquals(target) {
+      return this.add(target.negate().toString()).toNumber() <= 0;
+    }
+  }, {
+    key: "toNumber",
+    value: function toNumber() {
+      return this.number;
+    }
+  }, {
+    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
+
+    if (value === '-') {
+      this.nan = true;
+      return;
+    }
+
+    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;
+      var numbers = trimRet.trimStr.split('.');
+      this.integer = BigInt(numbers[0]);
+      var decimalStr = numbers[1] || '0';
+      this.decimal = BigInt(decimalStr);
+      this.decimalLen = decimalStr.length;
+    } else {
+      this.nan = true;
+    }
+  }
+
+  _createClass(BigIntDecimal, [{
+    key: "getMark",
+    value: function getMark() {
+      return this.negative ? '-' : '';
+    }
+  }, {
+    key: "getIntegerStr",
+    value: function getIntegerStr() {
+      return this.integer.toString();
+    }
+  }, {
+    key: "getDecimalStr",
+    value: function getDecimalStr() {
+      return this.decimal.toString().padStart(this.decimalLen, '0');
+    }
+    /**
+     * 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) {
+      var str = "".concat(this.getMark()).concat(this.getIntegerStr()).concat(this.getDecimalStr().padEnd(decimalLength, '0'));
+      return BigInt(str);
+    }
+  }, {
+    key: "negate",
+    value: function negate() {
+      var clone = new BigIntDecimal(this.toString());
+      clone.negative = !clone.negative;
+      return clone;
+    }
+  }, {
+    key: "add",
+    value: function add(value) {
+      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 _trimNumber = trimNumber(valueStr),
+          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)));
+    }
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return this.empty;
+    }
+  }, {
+    key: "isNaN",
+    value: function isNaN() {
+      return this.nan;
+    }
+  }, {
+    key: "isInvalidate",
+    value: function isInvalidate() {
+      return this.isEmpty() || this.isNaN();
+    }
+  }, {
+    key: "equals",
+    value: function equals(target) {
+      return this.toString() === (target === null || target === void 0 ? void 0 : target.toString());
+    }
+  }, {
+    key: "lessEquals",
+    value: function lessEquals(target) {
+      return this.add(target.negate().toString()).toNumber() <= 0;
+    }
+  }, {
+    key: "toNumber",
+    value: function toNumber() {
+      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) {
+  // We use BigInt here.
+  // Will fallback to Number if not support.
+  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;
+
+  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;
+
+  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;
+
+  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.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Format string number to readable number
+ */
+export declare function trimNumber(numStr: string): {
+    negative: boolean;
+    negativeStr: string;
+    trimStr: string;
+    integerStr: string;
+    decimalStr: string;
+    fullStr: string;
+};
+export declare function isE(number: string | number): boolean;
+/**
+ * [Legacy] Convert 1e-9 to 0.000000001.
+ * This may lose some precision if user really want 1e-9.
+ */
+export declare function getNumberPrecision(number: string | number): number;
+/**
+ * Convert number (includes scientific notation) to -xxx.yyy format
+ */
+export declare function num2str(number: number): string;
+export declare function validateNumber(num: string | number): boolean;

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

@@ -0,0 +1,103 @@
+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`
+  .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,
+    negativeStr: negativeStr,
+    trimStr: trimStr,
+    integerStr: integerStr,
+    decimalStr: decimalStr,
+    fullStr: "".concat(negativeStr).concat(trimStr)
+  };
+}
+export function isE(number) {
+  var str = String(number);
+  return !Number.isNaN(Number(str)) && str.includes('e');
+}
+/**
+ * [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
+
+
+  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
+    || /^\s*-?\.\d+\s*$/.test(num)
+  );
+}

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

@@ -0,0 +1 @@
+export declare function supportBigInt(): boolean;

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

@@ -0,0 +1,3 @@
+export function supportBigInt() {
+  return typeof BigInt === 'function';
+}

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

@@ -0,0 +1,2 @@
+import '../../style/index.css';
+import './index.css';