shineout 3.0.0-alpha.2 → 3.0.0-alpha.21

package/cjs/utils/dom/element.js

@@ -0,0 +1,243 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addResizeObserver = void 0;
+exports.copyBoundingClientRect = copyBoundingClientRect;
+exports.cssSupport = cssSupport;
+exports.dispatchEvent = dispatchEvent;
+exports.focusElement = void 0;
+exports.getCursorOffset = getCursorOffset;
+exports.getParent = getParent;
+exports.preventPasteFile = exports.parsePxToNumber = void 0;
+exports.wrapSpan = wrapSpan;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.string.replace.js");
+var _react = _interopRequireDefault(require("react"));
+var _func = require("../func");
+var _jsxRuntime = require("react/jsx-runtime");
+var _this = void 0;
+if (typeof window !== "undefined") {
+  if (window.Element && !window.Element.prototype.matches) {
+    var proto = Element.prototype;
+    proto.matches = proto.matchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector || proto.oMatchesSelector || proto.webkitMatchesSelector;
+  }
+}
+function getParent(el, target) {
+  if (!target) {
+    return null;
+  }
+  var temp = el;
+  while (temp) {
+    if (typeof target === 'string') {
+      if (temp.matches && temp.matches(target)) {
+        return temp;
+      }
+    } else if (temp === target) {
+      return temp;
+    }
+    temp = temp.parentElement;
+  }
+  return null;
+}
+var isTwoCNChar = function isTwoCNChar(str) {
+  return /^[\u4e00-\u9fa5]{2}$/.test(str);
+};
+var SPACE = ' ';
+function wrapSpan(children) {
+  var insertSpace = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (!children) return children;
+  return _react.default.Children.map(children, function (item) {
+    if (typeof item === 'string') {
+      if (insertSpace && isTwoCNChar(item)) return /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+        children: item.split('').join(SPACE)
+      });
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+        children: item
+      });
+    }
+    return item;
+  });
+}
+function dispatchEvent(form, name, detail) {
+  if (!form) return;
+  var event;
+  if (CustomEvent) {
+    event = new CustomEvent(name, {
+      bubbles: false,
+      cancelable: true,
+      detail: detail
+    });
+  } else {
+    event = document.createEvent('HTMLEvents');
+    event.initEvent(name, true, true);
+  }
+  form.dispatchEvent(event);
+}
+function cssSupport(attr, value) {
+  var element = document.createElement('div');
+  if (attr in element.style) {
+    if (attr !== 'length' && attr !== 'parentRule') {
+      var attrs = element.style[attr];
+      element.style[attr] = value;
+    }
+    return element.style[attr] === value;
+  }
+  return false;
+}
+function copyBoundingClientRect(el) {
+  if (!el) return null;
+  var rect = el.getBoundingClientRect();
+  return {
+    top: rect.top,
+    right: rect.right,
+    bottom: rect.bottom,
+    left: rect.left,
+    width: rect.width,
+    height: rect.height,
+    x: rect.x,
+    y: rect.y
+  };
+}
+function getCursorOffset(length) {
+  if (window.getSelection) {
+    return window.getSelection().anchorOffset;
+  }
+  if (document.selection) {
+    var range = document.selection.createRange();
+    range.moveStart('character', -length);
+    return range.text.length;
+  }
+  return null;
+}
+function end(element) {
+  if (!element) return;
+  element.focus();
+  if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {
+    element.selectionStart = -1;
+    return;
+  }
+  if (window.getSelection) {
+    var range = window.getSelection();
+    if (range) {
+      range.selectAllChildren(element);
+      range.collapseToEnd();
+    }
+  } else if (document.selection) {
+    var _range = document.selection.createRange();
+    _range.moveToElementText(element);
+    _range.collapse(false);
+    _range.select();
+  }
+}
+function select(element) {
+  if (element && element.innerText && element.innerText.length === 0) {
+    element.focus();
+    return;
+  }
+  if (window.getSelection && document.createRange) {
+    if (element) element.focus();
+    var range = document.createRange();
+    if (element) range.selectNodeContents(element);
+    var sel = window.getSelection();
+    if (sel) {
+      sel.removeAllRanges();
+      sel.addRange(range);
+    }
+  } else if (document.selection) {
+    var _range2 = document.selection.createRange();
+    _range2.moveToElementText(element);
+    _range2.select();
+  }
+}
+var focusElement = {
+  select: select,
+  end: end,
+  wrapSpan: wrapSpan,
+  copyBoundingClientRect: copyBoundingClientRect
+};
+exports.focusElement = focusElement;
+var preventPasteFile = function preventPasteFile(e, beforeHandler) {
+  var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+    _ref$noLineBreak = _ref.noLineBreak,
+    noLineBreak = _ref$noLineBreak === void 0 ? true : _ref$noLineBreak,
+    _ref$convertBr = _ref.convertBr,
+    convertBr = _ref$convertBr === void 0 ? ' ' : _ref$convertBr;
+  var text = (e.clipboardData || window.clipboardData).getData('text/plain');
+  // 删除复制的换行符号
+  if (noLineBreak && text) {
+    if (typeof convertBr === 'function') {
+      text = convertBr(text).replace(/([\t\n\f\r\v])+/g, ' ');
+    } else {
+      text = text.replace(/([\t\n\f\r\v])+/g, convertBr);
+    }
+  }
+  e.preventDefault();
+  if (beforeHandler) {
+    beforeHandler(text);
+  }
+  document.execCommand('insertText', false, text);
+};
+exports.preventPasteFile = preventPasteFile;
+var parsePxToNumber = function parsePxToNumber(str) {
+  return Number(str.replace(/\s+|px/gi, ''));
+};
+exports.parsePxToNumber = parsePxToNumber;
+var addResizeObserver = function addResizeObserver(el, handler) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var direction = options.direction,
+    timer = options.timer;
+  var _throttle = (0, _func.throttle)(handler, timer),
+    _throttle2 = (0, _slicedToArray2.default)(_throttle, 2),
+    throttleHandler = _throttle2[0],
+    cleanTimer = _throttle2[1];
+  var h = throttleHandler;
+  var lastWidth;
+  var lastHeight;
+  if (window.ResizeObserver) {
+    if (direction) {
+      lastWidth = el.clientWidth;
+      lastHeight = el.clientHeight;
+      h = function h(entry) {
+        var _entry$0$contentRect = entry[0].contentRect,
+          width = _entry$0$contentRect.width,
+          height = _entry$0$contentRect.height;
+        if (width && direction === 'x') {
+          if (lastWidth !== width) {
+            throttleHandler(entry);
+          }
+        } else if (direction === 'y') {
+          if (height && lastHeight !== height) {
+            throttleHandler(entry);
+          }
+        } else if (width && height) {
+          throttleHandler(entry, {
+            x: lastWidth !== width,
+            y: lastHeight !== height
+          });
+        }
+        lastWidth = width;
+        lastHeight = height;
+      };
+    }
+    var observer = new ResizeObserver(h);
+    observer.observe(el);
+    return function () {
+      if (observer) {
+        observer.disconnect();
+      }
+      cleanTimer(_this);
+      observer = null;
+    };
+  }
+  window.addEventListener('resize', throttleHandler);
+  return function () {
+    window.removeEventListener('resize', handler);
+    cleanTimer();
+  };
+};
+exports.addResizeObserver = addResizeObserver;

package/cjs/utils/dom/normalizeWheel.d.ts

@@ -0,0 +1,14 @@
+interface OldWheelEvent extends WheelEvent {
+    axis?: number;
+    wheelDelta?: number;
+    wheelDeltaY?: number;
+    wheelDeltaX?: number;
+    HORIZONTAL_AXIS?: number;
+}
+export default function (event: OldWheelEvent): {
+    spinX: number;
+    spinY: number;
+    pixelX: number;
+    pixelY: number;
+};
+export {};

package/cjs/utils/dom/normalizeWheel.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var PIXEL_STEP = 10;
+var LINE_HEIGHT = 40;
+var PAGE_HEIGHT = 800;
+var DELTA_LENGTH = 120;
+
+// wheelDeltaX, wheelDelta, and wheelDeltaZ have all been removed as they is a deprecated properties on WheelEvents
+// https://github.com/Microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#typescript-32
+
+function _default(event) {
+  var sX = 0;
+  var sY = 0;
+  var pX = 0;
+  var pY = 0;
+  if ('detail' in event) {
+    sY = event.detail;
+  }
+  if ('wheelDelta' in event && event.wheelDelta) {
+    sY = -event.wheelDelta / DELTA_LENGTH;
+  }
+  if ('wheelDeltaY' in event && event.wheelDeltaY) {
+    sY = -event.wheelDeltaY / DELTA_LENGTH;
+  }
+  if ('wheelDeltaX' in event && event.wheelDeltaX) {
+    sX = -event.wheelDeltaX / DELTA_LENGTH;
+  }
+  if ('axis' in event && event.axis === event.HORIZONTAL_AXIS) {
+    sX = sY;
+    sY = 0;
+  }
+  pX = sX * PIXEL_STEP;
+  pY = sY * PIXEL_STEP;
+  if ('deltaY' in event) {
+    pY = event.deltaY;
+  }
+  if ('deltaX' in event) {
+    pX = event.deltaX;
+  }
+  if ((pX || pY) && event.deltaMode) {
+    if (event.deltaMode === 1) {
+      pX *= LINE_HEIGHT;
+      pY *= LINE_HEIGHT;
+    } else {
+      pX *= PAGE_HEIGHT;
+      pY *= PAGE_HEIGHT;
+    }
+  }
+  if (pX && !sX) {
+    sX = pX < 1 ? -1 : 1;
+  }
+  if (pY && !sY) {
+    sY = pY < 1 ? -1 : 1;
+  }
+  return {
+    spinX: sX,
+    spinY: sY,
+    pixelX: pX,
+    pixelY: pY
+  };
+}

package/cjs/utils/dom/popover.d.ts

@@ -0,0 +1 @@
+export declare const getPosition: (position: string, el: HTMLElement, container?: HTMLElement | undefined) => string;

package/cjs/utils/dom/popover.js

@@ -0,0 +1,89 @@
+"use strict";
+
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPosition = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _document = require("./document");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var posKeys = ['left', 'top', 'bottom', 'right'];
+var getPosition = function getPosition(position, el) {
+  var container = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : document.body;
+  var rect = el.getBoundingClientRect();
+  var containerRect = {
+    top: 0,
+    left: 0,
+    bottom: 0,
+    right: 0
+  };
+  if (container.tagName === 'BODY') container = undefined;
+  if (container) containerRect = container.getBoundingClientRect();
+  var scrollTop = container ? 0 : _document.docScroll.top;
+  var scrollLeft = container ? 0 : _document.docScroll.left;
+  var pos = {};
+  switch (position) {
+    case 'top-left':
+      pos.left = scrollLeft + rect.left - containerRect.left;
+      pos.top = scrollTop + rect.top - containerRect.top;
+      break;
+    case 'top':
+      pos.left = scrollLeft + rect.left - containerRect.left + rect.width / 2;
+      pos.top = scrollTop + rect.top - containerRect.top;
+      break;
+    case 'top-right':
+      pos.right = (containerRect.right || _document.docSize.width) - rect.right - scrollLeft;
+      pos.top = scrollTop + rect.top - containerRect.top;
+      break;
+    case 'left-top':
+      pos.left = scrollLeft + rect.left - containerRect.left;
+      pos.top = scrollTop + rect.top - containerRect.top;
+      break;
+    case 'left':
+      pos.left = scrollLeft + rect.left - containerRect.left;
+      pos.top = scrollTop + rect.top - containerRect.top + rect.height / 2;
+      break;
+    case 'left-bottom':
+      pos.left = scrollLeft + rect.left - containerRect.left;
+      pos.top = scrollTop + rect.bottom - containerRect.bottom;
+      break;
+    case 'right-top':
+      pos.left = scrollLeft + rect.left - containerRect.left + rect.width;
+      pos.top = scrollTop + rect.top - containerRect.top;
+      break;
+    case 'right':
+      pos.left = scrollLeft + rect.left - containerRect.left + rect.width;
+      pos.top = scrollTop + rect.top - containerRect.top + rect.height / 2;
+      break;
+    case 'right-bottom':
+      pos.left = scrollLeft + rect.left - containerRect.left + rect.width;
+      pos.top = scrollTop + rect.bottom - containerRect.bottom;
+      break;
+    case 'bottom-left':
+      pos.left = scrollLeft + rect.left - containerRect.left;
+      pos.top = scrollTop + rect.top - containerRect.top + rect.height;
+      break;
+    case 'bottom':
+      pos.left = scrollLeft + rect.left - containerRect.left + rect.width / 2;
+      pos.top = scrollTop + rect.top - containerRect.top + rect.height;
+      break;
+    case 'bottom-right':
+      pos.right = (containerRect.right || _document.docSize.width) - rect.right - scrollLeft;
+      pos.top = scrollTop + rect.top - containerRect.top + rect.height;
+      break;
+    case 'cover':
+      pos.left = scrollLeft + rect.left - containerRect.left;
+      pos.top = scrollTop + rect.top - containerRect.top;
+      break;
+    default:
+  }
+  return posKeys.reduce(function (data, key) {
+    return _objectSpread(_objectSpread({}, data), {}, (0, _defineProperty2.default)({}, key, typeof pos[key] === 'number' ? "".concat(Math.round(pos[key]), "px") : 'auto'));
+  }, {});
+};
+exports.getPosition = getPosition;

package/cjs/utils/dom/ready.d.ts

@@ -0,0 +1 @@
+export default function (callback: (...args: any) => void): void;

package/cjs/utils/dom/ready.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+function _default(callback) {
+  if (!callback) return;
+  if (document.readyState !== 'loading') callback();else {
+    document.addEventListener('DOMContentLoaded', callback);
+  }
+}

package/cjs/utils/flat.d.ts

@@ -0,0 +1,25 @@
+export declare function insertPoint(name: string): string;
+declare type Result = {
+    [x: string]: unknown;
+};
+export declare function flatten(data: Result, skipArray?: boolean): Result;
+export declare function unflatten<T extends {}>(rawdata: T): {
+    [name: string]: any;
+};
+declare type insertObject = {
+    [x: string]: unknown;
+};
+export declare function insertValue(obj: insertObject, name: string, index: number, value: any): void;
+declare type SpliceValue = {
+    [x: string]: [];
+};
+export declare function spliceValue(obj: SpliceValue, name: keyof SpliceValue & string, index: number): void;
+declare type Source = {
+    [x: string]: any;
+};
+export declare const getSthByName: (name: keyof Source & string, source: Source) => any;
+export declare const removeSthByName: (name: string, source: {
+    [x: string]: any;
+}) => void;
+export declare const flattenArray: <T>(arr1: any[]) => T[];
+export {};

package/cjs/utils/flat.js

@@ -0,0 +1,182 @@
+"use strict";
+
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.flatten = flatten;
+exports.getSthByName = exports.flattenArray = void 0;
+exports.insertPoint = insertPoint;
+exports.insertValue = insertValue;
+exports.removeSthByName = void 0;
+exports.spliceValue = spliceValue;
+exports.unflatten = unflatten;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.replace.js");
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/es.array.sort.js");
+require("core-js/modules/es.array.index-of.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.regexp.constructor.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/es.array.splice.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.array.reduce.js");
+var _is = require("./is");
+var _clone = require("./clone");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function insertPoint(name) {
+  var reg = /(\[\d+\])/gi;
+  return name.replace(reg, function (s, m, i) {
+    return s.replace(m, i === 0 ? m : ".".concat(m));
+  });
+}
+function flatten(data, skipArray) {
+  if ((0, _is.isEmpty)(data)) return data;
+  var result = {};
+  function recurse(cur, prop) {
+    if (Object(cur) !== cur || typeof cur === 'function' || cur instanceof Date || cur instanceof Error || skipArray && Array.isArray(cur)) {
+      if (!(cur === undefined && /\[\d+\]$/.test(prop))) {
+        result[prop] = cur;
+      }
+    } else if (Array.isArray(cur)) {
+      if (cur.length === 0) {
+        result[prop] = [];
+      } else {
+        for (var i = 0, l = cur.length; i < l; i++) {
+          recurse(cur[i], prop ? "".concat(prop, "[").concat(i, "]") : "[".concat(i, "]"));
+        }
+      }
+    } else {
+      var empty = true;
+      if ((0, _typeof2.default)(cur) === 'object') {
+        // eslint-disable-next-line
+        for (var p in cur) {
+          empty = false;
+          recurse(cur[p], prop ? "".concat(prop, ".").concat(p) : p);
+        }
+        if (empty) {
+          result[prop] = {};
+        }
+      }
+    }
+  }
+  recurse(data, '');
+  return result;
+}
+function unflatten(rawdata) {
+  if (Object(rawdata) !== rawdata || (0, _is.isEmpty)(rawdata) || Array.isArray(rawdata)) {
+    return rawdata;
+  }
+  var data = _objectSpread({}, rawdata);
+  var result = {};
+  // let { cur, prop, idx, last, temp, match } = {}
+  var cur;
+  var prop;
+  var idx;
+  var last;
+  var temp;
+  var match;
+
+  // eslint-disable-next-line
+  Object.keys(data).sort().forEach(function (p) {
+    var pathWithPoint = insertPoint(p);
+    cur = result;
+    prop = '';
+    last = 0;
+    do {
+      idx = pathWithPoint.indexOf('.', last);
+      temp = pathWithPoint.substring(last, idx !== -1 ? idx : undefined);
+      match = /^\[(\d+)\]$/.exec(temp);
+      cur = cur[prop] || (cur[prop] = match ? [] : {});
+      prop = match ? match[1] : temp;
+      last = idx + 1;
+    } while (idx >= 0);
+    cur[prop] = (0, _clone.deepClone)(data[p]);
+  });
+  return result[''];
+}
+function insertValue(obj, name, index, value) {
+  Object.keys(obj).filter(function (n) {
+    return n.indexOf("".concat(name, "[")) === 0;
+  }).sort().reverse().forEach(function (n) {
+    // const reg = new RegExp(`${name}\\[(\\d+)\\]`)
+    var reg = new RegExp("".concat(name.replace(/\[/g, '\\[').replace(/\]/g, '\\]'), "\\[(\\d+)\\]"));
+    var match = reg.exec(n);
+    var i = parseInt(match[1], 10);
+    if (i < index) return;
+    var newName = n.replace(reg, "".concat(name, "[").concat(i + 1, "]"));
+    if (obj[n]) obj[newName] = obj[n];
+    delete obj[n];
+  });
+  var newValue = flatten((0, _defineProperty2.default)({}, "".concat(name, "[").concat(index, "]"), value));
+  Object.keys(newValue).forEach(function (k) {
+    if (newValue[k] !== undefined) obj[k] = newValue[k];
+  });
+}
+function spliceValue(obj, name, index) {
+  var names = Object.keys(obj).filter(function (n) {
+    return n === name || n.indexOf("".concat(name, "[")) === 0;
+  }).sort();
+  names.forEach(function (n) {
+    if (n === name && !Array.isArray(obj[name])) return;
+    if (n === name) {
+      obj[name].splice(index, 1);
+      return;
+    }
+    var reg = new RegExp("".concat(name.replace(/\[/g, '\\[').replace(/\]/g, '\\]'), "\\[(\\d+)\\]"));
+    var match = reg.exec(n);
+    var i = parseInt(match[1], 10);
+    if (i < index) return;
+    if (i === index) {
+      delete obj[n];
+      return;
+    }
+    var newName = n.replace(reg, "".concat(name, "[").concat(i - 1, "]"));
+    obj[newName] = obj[n];
+    delete obj[n];
+  });
+}
+var isNameWithPath = function isNameWithPath(name, path) {
+  if (name.indexOf(path) !== 0) return false;
+  var remain = name.replace(path, '')[0];
+  return [undefined, '[', '.'].includes(remain);
+};
+var getSthByName = function getSthByName(name, source) {
+  if (source[name]) return source[name];
+  var result = unflatten(source);
+  name = insertPoint(name);
+  name.split('.').forEach(function (n) {
+    var match = /^\[(\d+)\]$/.exec(n);
+    // eslint-disable-next-line
+    if (match) n = match[1];
+    if (result) result = result[n];else result = undefined;
+  });
+
+  // get from form-error
+  if (!result && (0, _is.isObject)(source[''])) result = source[''][name];
+  return result;
+};
+exports.getSthByName = getSthByName;
+var removeSthByName = function removeSthByName(name, source) {
+  var match = /(.*)\[(\d+)\]$/.exec(name);
+  if (match) {
+    spliceValue(source, match[1], parseInt(match[2], 10));
+  } else {
+    Object.keys(source).forEach(function (n) {
+      if (isNameWithPath(n, name)) delete source[n];
+    });
+  }
+};
+exports.removeSthByName = removeSthByName;
+var flattenArray = function flattenArray(arr1) {
+  return arr1.reduce(function (acc, val) {
+    return Array.isArray(val) ? acc.concat(flattenArray(val)) : acc.concat(val);
+  }, []);
+};
+exports.flattenArray = flattenArray;

package/cjs/utils/func.d.ts

@@ -0,0 +1,25 @@
+/**
+ * from redux.compose https://github.com/reactjs/redux/blob/master/src/compose.js
+ * Composes single-argument functions from right to left. The rightmost
+ * function can take multiple arguments as it provides the signature for
+ * the resulting composite function.
+ *
+ * @param {...Function} funcs The functions to compose.
+ * @returns {Function} A function obtained by composing the argument functions
+ * from right to left. For example, compose(f, g, h) is identical to doing
+ * (...args) => f(g(h(...args))).
+ */
+declare type AnyFunction = (...args: any) => any;
+export { compose } from './compose';
+export * from './curry';
+export declare function curry<U extends AnyFunction>(f: U, ...args: any): any;
+export declare function empty(e: {
+    preventDefault: () => void;
+}): void;
+export declare function memoize<T extends Function>(fn: T & {
+    cache?: {
+        [name: string]: any;
+    };
+}): (key: string) => any;
+export declare function createFunc(func?: Function | string): Function;
+export declare const throttle: (func: Function, timer?: number) => Function[];