@douyinfe/semi-foundation 2.28.0-beta.0 → 2.28.0

package/lib/es/utils/keyCode.js

@@ -0,0 +1,534 @@
+/**
+ * @ignore
+ * some key-codes definition and utils from closure-library
+ */
+const keyCode = {
+  /**
+   * MAC_ENTER
+   */
+  MAC_ENTER: 3,
+
+  /**
+   * BACKSPACE
+   */
+  BACKSPACE: 8,
+
+  /**
+   * TAB
+   */
+  TAB: 9,
+
+  /**
+   * NUMLOCK on FF/Safari Mac
+   */
+  NUM_CENTER: 12,
+
+  /**
+   * ENTER
+   */
+  ENTER: 13,
+
+  /**
+   * SHIFT
+   */
+  SHIFT: 16,
+
+  /**
+   * CTRL
+   */
+  CTRL: 17,
+
+  /**
+   * ALT
+   */
+  ALT: 18,
+
+  /**
+   * PAUSE
+   */
+  PAUSE: 19,
+
+  /**
+   * CAPS_LOCK
+   */
+  CAPS_LOCK: 20,
+
+  /**
+   * ESC
+   */
+  ESC: 27,
+
+  /**
+   * SPACE
+   */
+  SPACE: 32,
+
+  /**
+   * PAGE_UP
+   */
+  PAGE_UP: 33,
+
+  /**
+   * PAGE_DOWN
+   */
+  PAGE_DOWN: 34,
+
+  /**
+   * END
+   */
+  END: 35,
+
+  /**
+   * HOME
+   */
+  HOME: 36,
+
+  /**
+   * LEFT
+   */
+  LEFT: 37,
+
+  /**
+   * UP
+   */
+  UP: 38,
+
+  /**
+   * RIGHT
+   */
+  RIGHT: 39,
+
+  /**
+   * DOWN
+   */
+  DOWN: 40,
+
+  /**
+   * PRINT_SCREEN
+   */
+  PRINT_SCREEN: 44,
+
+  /**
+   * INSERT
+   */
+  INSERT: 45,
+
+  /**
+   * DELETE
+   */
+  DELETE: 46,
+
+  /**
+   * ZERO
+   */
+  ZERO: 48,
+
+  /**
+   * ONE
+   */
+  ONE: 49,
+
+  /**
+   * TWO
+   */
+  TWO: 50,
+
+  /**
+   * THREE
+   */
+  THREE: 51,
+
+  /**
+   * FOUR
+   */
+  FOUR: 52,
+
+  /**
+   * FIVE
+   */
+  FIVE: 53,
+
+  /**
+   * SIX
+   */
+  SIX: 54,
+
+  /**
+   * SEVEN
+   */
+  SEVEN: 55,
+
+  /**
+   * EIGHT
+   */
+  EIGHT: 56,
+
+  /**
+   * NINE
+   */
+  NINE: 57,
+
+  /**
+   * QUESTION_MARK
+   */
+  QUESTION_MARK: 63,
+
+  /**
+   * A
+   */
+  A: 65,
+
+  /**
+   * B
+   */
+  B: 66,
+
+  /**
+   * C
+   */
+  C: 67,
+
+  /**
+   * D
+   */
+  D: 68,
+
+  /**
+   * E
+   */
+  E: 69,
+
+  /**
+   * F
+   */
+  F: 70,
+
+  /**
+   * G
+   */
+  G: 71,
+
+  /**
+   * H
+   */
+  H: 72,
+
+  /**
+   * I
+   */
+  I: 73,
+
+  /**
+   * J
+   */
+  J: 74,
+
+  /**
+   * K
+   */
+  K: 75,
+
+  /**
+   * L
+   */
+  L: 76,
+
+  /**
+   * M
+   */
+  M: 77,
+
+  /**
+   * N
+   */
+  N: 78,
+
+  /**
+   * O
+   */
+  O: 79,
+
+  /**
+   * P
+   */
+  P: 80,
+
+  /**
+   * Q
+   */
+  Q: 81,
+
+  /**
+   * R
+   */
+  R: 82,
+
+  /**
+   * S
+   */
+  S: 83,
+
+  /**
+   * T
+   */
+  T: 84,
+
+  /**
+   * U
+   */
+  U: 85,
+
+  /**
+   * V
+   */
+  V: 86,
+
+  /**
+   * W
+   */
+  W: 87,
+
+  /**
+   * X
+   */
+  X: 88,
+
+  /**
+   * Y
+   */
+  Y: 89,
+
+  /**
+   * Z
+   */
+  Z: 90,
+
+  /**
+   * META
+   */
+  META: 91,
+
+  /**
+   * WIN_KEY_RIGHT
+   */
+  WIN_KEY_RIGHT: 92,
+
+  /**
+   * CONTEXT_MENU
+   */
+  CONTEXT_MENU: 93,
+
+  /**
+   * NUM_ZERO
+   */
+  NUM_ZERO: 96,
+
+  /**
+   * NUM_ONE
+   */
+  NUM_ONE: 97,
+
+  /**
+   * NUM_TWO
+   */
+  NUM_TWO: 98,
+
+  /**
+   * NUM_THREE
+   */
+  NUM_THREE: 99,
+
+  /**
+   * NUM_FOUR
+   */
+  NUM_FOUR: 100,
+
+  /**
+   * NUM_FIVE
+   */
+  NUM_FIVE: 101,
+
+  /**
+   * NUM_SIX
+   */
+  NUM_SIX: 102,
+
+  /**
+   * NUM_SEVEN
+   */
+  NUM_SEVEN: 103,
+
+  /**
+   * NUM_EIGHT
+   */
+  NUM_EIGHT: 104,
+
+  /**
+   * NUM_NINE
+   */
+  NUM_NINE: 105,
+
+  /**
+   * NUM_MULTIPLY
+   */
+  NUM_MULTIPLY: 106,
+
+  /**
+   * NUM_PLUS
+   */
+  NUM_PLUS: 107,
+
+  /**
+   * NUM_MINUS
+   */
+  NUM_MINUS: 109,
+
+  /**
+   * NUM_PERIOD
+   */
+  NUM_PERIOD: 110,
+
+  /**
+   * NUM_DIVISION
+   */
+  NUM_DIVISION: 111,
+
+  /**
+   * F1
+   */
+  F1: 112,
+
+  /**
+   * F2
+   */
+  F2: 113,
+
+  /**
+   * F3
+   */
+  F3: 114,
+
+  /**
+   * F4
+   */
+  F4: 115,
+
+  /**
+   * F5
+   */
+  F5: 116,
+
+  /**
+   * F6
+   */
+  F6: 117,
+
+  /**
+   * F7
+   */
+  F7: 118,
+
+  /**
+   * F8
+   */
+  F8: 119,
+
+  /**
+   * F9
+   */
+  F9: 120,
+
+  /**
+   * F10
+   */
+  F10: 121,
+
+  /**
+   * F11
+   */
+  F11: 122,
+
+  /**
+   * F12
+   */
+  F12: 123,
+
+  /**
+   * NUMLOCK
+   */
+  NUMLOCK: 144,
+
+  /**
+   * SEMICOLON
+   */
+  SEMICOLON: 186,
+
+  /**
+   * DASH
+   */
+  DASH: 189,
+
+  /**
+   * EQUALS
+   */
+  EQUALS: 187,
+
+  /**
+   * COMMA
+   */
+  COMMA: 188,
+
+  /**
+   * PERIOD
+   */
+  PERIOD: 190,
+
+  /**
+   * SLASH
+   */
+  SLASH: 191,
+
+  /**
+   * APOSTROPHE
+   */
+  APOSTROPHE: 192,
+
+  /**
+   * SINGLE_QUOTE
+   */
+  SINGLE_QUOTE: 222,
+
+  /**
+   * OPEN_SQUARE_BRACKET
+   */
+  OPEN_SQUARE_BRACKET: 219,
+
+  /**
+   * BACKSLASH
+   */
+  BACKSLASH: 220,
+
+  /**
+   * CLOSE_SQUARE_BRACKET
+   */
+  CLOSE_SQUARE_BRACKET: 221,
+
+  /**
+   * WIN_KEY
+   */
+  WIN_KEY: 224,
+
+  /**
+   * MAC_FF_META
+   */
+  MAC_FF_META: 224,
+
+  /**
+   * WIN_IME
+   */
+  WIN_IME: 229
+};
+export const ENTER_KEY = 'Enter';
+export const TAB_KEY = 'Tab';
+export const ESC_KEY = 'Escape';
+export default keyCode;

package/lib/es/utils/log.d.ts

@@ -0,0 +1,2 @@
+declare const log: (text: any, ...rest: any[]) => void;
+export default log;

package/lib/es/utils/log.js

@@ -0,0 +1,13 @@
+import _get from "lodash/get";
+
+const log = function (text) {
+  if (_get(process, 'env.NODE_ENV') === 'development') {
+    for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      rest[_key - 1] = arguments[_key];
+    }
+
+    console.log(text, ...rest);
+  }
+};
+
+export default log;

package/lib/es/utils/number.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Solve the problem of js addition accuracy
+ * e.g.
+ *  0.1 + 0.2 => 0.30000000000000004
+ *  plus(0.1, 0.2) => 0.3
+ * @param {Number} num1
+ * @param {Number} num2
+ */
+export declare function plus(num1: number, num2: number): number;
+export declare function minus(num1: number, num2: number): number;

package/lib/es/utils/number.js

@@ -0,0 +1,17 @@
+/**
+ * Solve the problem of js addition accuracy
+ * e.g.
+ *  0.1 + 0.2 => 0.30000000000000004
+ *  plus(0.1, 0.2) => 0.3
+ * @param {Number} num1
+ * @param {Number} num2
+ */
+export function plus(num1, num2) {
+  const num1Digits = (num1.toString().split('.')[1] || '').length;
+  const num2Digits = (num2.toString().split('.')[1] || '').length;
+  const baseNum = Math.pow(10, Math.max(num1Digits, num2Digits));
+  return (num1 * baseNum + num2 * baseNum) / baseNum;
+}
+export function minus(num1, num2) {
+  return plus(num1, -num2);
+}

package/lib/es/utils/object.d.ts

@@ -0,0 +1,17 @@
+declare type Many<T> = T | ReadonlyArray<T>;
+declare type PropertyName = string | number | symbol;
+declare type PropertyPath = Many<PropertyName>;
+declare type ObjectType = Record<string, any>;
+export declare function empty(object: ObjectType): boolean;
+export declare function get(object: ObjectType, path: PropertyPath): any;
+export declare function remove(object: ObjectType, path: PropertyPath): void;
+export declare function set(object: any, path: PropertyPath, value: any, allowEmpty?: boolean): any;
+export declare function has(object: ObjectType, path: PropertyPath): boolean;
+/**
+ * set static properties from `srcObj` to `obj`
+ * @param {object|Function} obj
+ * @param {object|Function} srcObj
+ * @returns {object|Function}
+ */
+export declare function forwardStatics<T extends ObjectType | ((...arg: any) => any)>(obj: T, srcObj: ObjectType | ((...arg: any) => any)): T;
+export {};

package/lib/es/utils/object.js

@@ -0,0 +1,138 @@
+import _isObject from "lodash/isObject";
+import _isNumber from "lodash/isNumber";
+import _values from "lodash/values";
+import _unset from "lodash/unset";
+import _toPath from "lodash/toPath";
+import _has from "lodash/has";
+import _set from "lodash/set";
+import _get from "lodash/get";
+
+const pathToArrayElem = path => {
+  const pathArray = _toPath(path); // internal-issues:673
+
+
+  const justNumber = _isNumber(path) && pathArray.length === 1;
+  return justNumber ? false : Number.isInteger(+pathArray[pathArray.length - 1]);
+};
+
+function isEmptyObject(target) {
+  /**
+   *  var a = {};
+   *  var b = { c: undefined }
+   *  var d = {
+   *      e: function(){},
+   *      f: Symbol(''),
+   *  }
+   *  the result of JSON.stringify(a/b/d) are same: '{}'
+   *  We can use the above features to remove keys with empty values in Form
+   *  But we cannot use JSON.stringify() directly, because if the input parameter of JSON.stringify includes fiberNode, it will cause an TypeError: 'Converting circular structure to JSON'
+   *  So we have to mock it's behavior, also, the form value cannot have Symbol or function type, it can be ignored
+   */
+  if (!_isObject(target)) {
+    return false;
+  } else {
+    const valuesOfTarget = _values(target); // values(a)  ->   []
+    // values(b)  ->   [undefined]
+
+
+    if (!valuesOfTarget.length) {
+      return true; // like target: {}
+    } else {
+      return valuesOfTarget.every(item => typeof item === 'undefined');
+    }
+  }
+}
+
+function cleanup(obj, path) {
+  let pull = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+
+  if (path.length === 0) {
+    return;
+  }
+
+  const target = _get(obj, path); // remove undefined from array
+  // if (Array.isArray(target) && pull) {
+  //     // only remove undefined form array from right to left
+  //     // Remove undefined from right to left
+  //     let lastIndex = findLastIndex(target, item => !isUndefined(item));
+  //     lodashRemove(target, (value, index, array) => index > lastIndex);
+  // }
+  // Delete object if its empty
+  // eslint-disable-next-line
+
+
+  if (Array.isArray(target) && target.every(e => e == null)) {
+    _unset(obj, path);
+  } else if (isEmptyObject(target)) {
+    _unset(obj, path);
+  } // Recur
+
+
+  cleanup(obj, path.slice(0, path.length - 1), pull);
+}
+
+export function empty(object) {
+  return _values(object).length === 0;
+}
+export function get(object, path) {
+  return _get(object, path);
+}
+export function remove(object, path) {
+  _unset(object, path); // a.b => [a, b]
+  // arr[11].a => [arr, 11, a]
+
+
+  let pathArray = _toPath(path);
+
+  pathArray = pathArray.slice(0, pathArray.length - 1);
+  cleanup(object, pathArray, false);
+}
+export function set(object, path, value, allowEmpty) {
+  if (allowEmpty) {
+    return _set(object, path, value);
+  }
+
+  if (value !== undefined) {
+    return _set(object, path, value);
+  } else {
+    // If the path is to an array leaf then we want to set to undefined
+    // 将数组的叶子节点置为undefined时，例如 a.b[0]  a.b[1]  a.b[99]
+    if (pathToArrayElem(path) && get(object, path) !== undefined) {
+      _set(object, path, undefined);
+
+      let pathArray = _toPath(path);
+
+      pathArray = pathArray.slice(0, pathArray.length - 1);
+      cleanup(object, pathArray, false);
+    } else if (!pathToArrayElem(path) && get(object, path) !== undefined) {
+      // Only delete the field if it needs to be deleted and its not a path to an array ( array leaf )
+      // eg:
+
+      /*
+          When the non-array leaf node is set to undefined
+          for example: a.b.c
+      */
+      remove(object, path);
+    }
+  }
+}
+export function has(object, path) {
+  return _has(object, path);
+}
+/**
+ * set static properties from `srcObj` to `obj`
+ * @param {object|Function} obj
+ * @param {object|Function} srcObj
+ * @returns {object|Function}
+ */
+
+export function forwardStatics(obj, srcObj) {
+  if (obj && (typeof obj === 'function' || typeof obj === 'object') && srcObj && (typeof srcObj === 'function' || typeof srcObj === 'object')) {
+    Object.entries(srcObj).forEach(_ref => {
+      let [key, value] = _ref;
+      obj[key] = value;
+    });
+  }
+
+  return obj;
+}