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

package/cjs/utils/objects.js

@@ -0,0 +1,277 @@
+"use strict";
+
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.symbol.description.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.entries = exports.deepSet = exports.deepRemove = exports.deepMerge = exports.deepHas = exports.deepGet = void 0;
+exports.filterProps = filterProps;
+exports.objectValues = void 0;
+exports.pathGenerator = pathGenerator;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.array.index-of.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.string.includes.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.array.splice.js");
+var _is = require("./is");
+var _flat = require("./flat");
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var PATH_MODE = {
+  loose: '?',
+  strict: '!',
+  insert: '^',
+  append: '$'
+};
+function filterProps(obj) {
+  var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  if (!(0, _is.isObject)(obj)) return obj;
+  if (typeof props === 'function') {
+    var prediction = props;
+    props = [];
+    Object.keys(obj).forEach(function (k) {
+      if (prediction(obj[k])) props.push(k);
+    });
+  }
+  var newObj = {};
+  props.forEach(function (k) {
+    newObj[k] = obj[k];
+  });
+  return newObj;
+}
+
+// Object.values()
+var objectValues = function objectValues(obj) {
+  if (!obj) return [];
+  return Object.keys(obj).map(function (k) {
+    return obj[k];
+  });
+};
+
+// object only, not handle array.
+exports.objectValues = objectValues;
+var deepMerge = function deepMerge() {
+  var target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var source = arguments.length > 1 ? arguments[1] : undefined;
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var clone = options.clone,
+    removeUndefined = options.removeUndefined,
+    skipUndefined = options.skipUndefined;
+  if (!(0, _is.isMergeable)(source)) return source;
+  var dest = {};
+  if ((0, _is.isMergeable)(target)) {
+    Object.keys(target).forEach(function (k) {
+      dest[k] = clone ? deepMerge({}, target[k], options) : target[k];
+      if (removeUndefined && dest[k] === undefined) delete dest[k];
+    });
+  }
+  Object.keys(source).forEach(function (k) {
+    if ((0, _is.isMergeable)(source[k]) && (0, _is.isMergeable)(target[k])) {
+      dest[k] = deepMerge(target[k], source[k], options);
+    } else {
+      if (skipUndefined && source[k] === undefined) return;
+      dest[k] = deepMerge({}, source[k], options);
+      if (removeUndefined && dest[k] === undefined) delete dest[k];
+    }
+  });
+  return dest;
+};
+exports.deepMerge = deepMerge;
+function pathGenerator(raw) {
+  var path = (0, _flat.insertPoint)(raw);
+  var reg = /^\[(\d+)\]$/;
+  var pathModeValues = objectValues(PATH_MODE);
+  var index = 0;
+  var last = 0;
+  var prop = '';
+  var results = [];
+  while (index >= 0) {
+    index = path.indexOf('.', last);
+    prop = path.substring(last, index === -1 ? undefined : index);
+    var mode = void 0;
+    var lastChar = prop.charAt(prop.length - 1);
+    if (pathModeValues.includes(lastChar)) {
+      mode = lastChar;
+      prop = prop.substring(0, prop.length - 1);
+    }
+
+    // array index
+    var match = reg.exec(prop);
+    // eslint-disable-next-line
+    if (match) prop = parseInt(match[1], 10);
+    last = index + 1;
+    results.push([prop, index === -1 ? undefined : path.substring(last), mode]);
+  }
+  return results;
+}
+var deepSet = function deepSet(target, path, value) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  if (!(0, _is.isObject)(target)) throw new Error('Target must be an object.');
+  if (typeof path !== 'string') throw new Error('Path must be a string.');
+  var removeUndefined = options.removeUndefined,
+    skipUndefined = options.skipUndefined;
+  var mergeOptions = {
+    clone: true,
+    removeUndefined: removeUndefined,
+    skipUndefined: skipUndefined
+  };
+
+  // empty root
+  if (path === '') {
+    var dest = deepMerge(target, value, mergeOptions);
+    Object.keys(dest).forEach(function (k) {
+      target[k] = dest[k];
+    });
+    return target;
+  }
+  var current = target;
+  var _iterator = _createForOfIteratorHelper(pathGenerator(path)),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = (0, _slicedToArray2.default)(_step.value, 3),
+        _prop = _step$value[0],
+        next = _step$value[1],
+        mode = _step$value[2];
+      if (next) {
+        var nextIsArray = /^\[\d+\]/.test(next);
+        if (!current[_prop]) current[_prop] = nextIsArray ? [] : {};
+        if (nextIsArray && !Array.isArray(current[_prop])) {
+          throw new Error("Path ".concat(path, " expect an array."));
+        } else if (Array.isArray(current[_prop]) && !nextIsArray) {
+          throw new Error("Path ".concat(path, " is an array, expect an object."));
+        }
+        current = current[_prop];
+        continue;
+      }
+      if (options.forceSet) {
+        current[_prop] = value;
+      } else if (mode === PATH_MODE.insert) {
+        current.splice(_prop, 0, value);
+      } else if (mode === PATH_MODE.append) {
+        current.splice(_prop + 1, 0, value);
+      } else {
+        if (skipUndefined && value === undefined) break;
+        current[_prop] = (0, _is.isMergeable)(current[_prop]) && (0, _is.isMergeable)(value) ? deepMerge(current[_prop], value, mergeOptions) : value;
+      }
+      if (removeUndefined && value === undefined) delete current[_prop];
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return target;
+};
+exports.deepSet = deepSet;
+var deepGet = function deepGet(target, path) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (!(0, _is.isObject)(target)) throw new Error('Target must be an object.');
+  if (typeof path !== 'string') throw new Error('Path must be a string.');
+
+  // empty root
+  if (path === '') return target;
+  var defaultValue = options.defaultValue,
+    strictMode = options.strictMode;
+  var current = target;
+  var _iterator2 = _createForOfIteratorHelper(pathGenerator(path)),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _step2$value = (0, _slicedToArray2.default)(_step2.value, 3),
+        _prop2 = _step2$value[0],
+        mode = _step2$value[2];
+      var isStrict = mode === PATH_MODE.strict || strictMode && defaultValue === undefined && mode !== PATH_MODE.loose;
+      if (current != null && hasOwnProperty.call(current, _prop2)) {
+        current = current[_prop2];
+      } else if (isStrict) {
+        throw new Error("Path ".concat(path, " is not exist."));
+      } else {
+        current = defaultValue;
+        break;
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return current;
+};
+exports.deepGet = deepGet;
+var deepRemove = function deepRemove(target, path) {
+  if (!(0, _is.isObject)(target)) throw new Error('Target must be an object.');
+  if (typeof path !== 'string' || !path) throw new Error('Path must be a string.');
+  var current = target;
+  var nextIsArray = false;
+  var _iterator3 = _createForOfIteratorHelper(pathGenerator(path)),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _step3$value = (0, _slicedToArray2.default)(_step3.value, 2),
+        _prop3 = _step3$value[0],
+        next = _step3$value[1];
+      if (current == null || !hasOwnProperty.call(current, _prop3)) {
+        break;
+      }
+      if (next) {
+        current = current[_prop3];
+        nextIsArray = /^\[\d+\]/.test(next);
+      } else if ((0, _is.isObject)(current)) {
+        if (nextIsArray) throw new Error('Target is an object, expect array');
+        delete current[_prop3];
+      } else {
+        if (!nextIsArray) {
+          throw new Error('Target is an array, expect object');
+        }
+        current.splice(_prop3, 1);
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return target;
+};
+exports.deepRemove = deepRemove;
+var deepHas = function deepHas(target, path) {
+  if (!(0, _is.isObject)(target)) throw new Error('Target must be an object.');
+  if (typeof path !== 'string') throw new Error('Path must be a string.');
+  if (path === '') return true;
+  var current = target;
+  var _iterator4 = _createForOfIteratorHelper(pathGenerator(path)),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var _step4$value = (0, _slicedToArray2.default)(_step4.value, 2),
+        _prop4 = _step4$value[0];
+      if (!current || !hasOwnProperty.call(current, _prop4)) return false;
+      current = current[_prop4];
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  return true;
+};
+exports.deepHas = deepHas;
+var entries = function entries(obj) {
+  if (!obj) return [];
+  var keys = Object.keys(obj);
+  return keys.map(function (key) {
+    return [key, obj[key]];
+  });
+};
+exports.entries = entries;

package/cjs/utils/shallowEqual.d.ts

@@ -0,0 +1,7 @@
+interface Column {
+    group?: any;
+    width?: number | string;
+}
+export declare function compareColumns(columns1?: Column[], columns2?: Column[]): boolean;
+export default function (objA: any, objB?: any, options?: {}): boolean;
+export {};

package/cjs/utils/shallowEqual.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compareColumns = compareColumns;
+exports.default = _default;
+require("core-js/modules/es.array.sort.js");
+require("core-js/modules/es.array.index-of.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.string.includes.js");
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _deepEql = _interopRequireDefault(require("deep-eql"));
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function is(x, y) {
+  if (x === y) {
+    return x !== 0 || y !== 0 || 1 / x === 1 / y;
+  }
+  // eslint-disable-next-line
+  return x !== x && y !== y;
+}
+function getOption(options, key) {
+  if (!options[key]) return [];
+  var val = options[key];
+  return Array.isArray(val) ? val : [val];
+}
+function compareColumns(columns1, columns2) {
+  if (!columns1 || !columns2) return true;
+  if (columns1.length !== columns2.length) return false;
+  var simpleCompare = columns1.every(function (c, i) {
+    return c.width === columns2[i].width || Number.isNaN(c.width) && Number.isNaN(columns2[i].width);
+  });
+  if (!simpleCompare) return false;
+  var complexCompare = columns1.every(function (c, i) {
+    if (Array.isArray(c.group) && Array.isArray(columns2[i].group)) return c.group.every(function (d, index) {
+      return d === columns2[i].group[index];
+    });
+    return c.group === columns2[i].group;
+  });
+  return complexCompare;
+}
+function _default(objA, objB) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (is(objA, objB)) {
+    return true;
+  }
+  if ((0, _typeof2.default)(objA) !== 'object' || objA === null || (0, _typeof2.default)(objB) !== 'object' || objB === null) {
+    return false;
+  }
+  var keysA = Object.keys(objA);
+  var keysB = Object.keys(objB);
+  var skip = getOption(options, 'skip');
+  var deep = getOption(options, 'deep');
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  keysA.sort(function (a, b) {
+    return deep.indexOf(a) - deep.indexOf(b);
+  });
+
+  // Test for A's keys different from B.
+  for (var i = 0; i < keysA.length; i++) {
+    var k = keysA[i];
+    if (skip.includes(k)) continue;
+    if (!hasOwnProperty.call(objB, k) || !is(objA[k], objB[k])) {
+      if (objA[k] instanceof Error && objB[k] instanceof Error) {
+        if (objA[k].message !== objB[k].message) return false;
+        continue;
+      }
+      if (deep.includes(k)) {
+        if (!(0, _deepEql.default)(objA[k], objB[k])) return false;
+      } else {
+        return false;
+      }
+    }
+  }
+  return true;
+}

package/cjs/utils/strings.d.ts

@@ -0,0 +1,7 @@
+export declare function capitalize(str: string): string;
+export declare function substitute(str: string | Function, obj: {
+    [x: string]: any;
+}): any;
+export declare function removeProtocol(url: string): string;
+export declare function getRTLPosition(position: string): string;
+export declare function getDirectionIconName(mode?: string, double?: boolean): "AngleDoubleRight" | "AngleRight" | "AngleDoubleLeft" | "AngleLeft";

package/cjs/utils/strings.js

@@ -0,0 +1,84 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.capitalize = capitalize;
+exports.getDirectionIconName = getDirectionIconName;
+exports.getRTLPosition = getRTLPosition;
+exports.removeProtocol = removeProtocol;
+exports.substitute = substitute;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.array.index-of.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.replace.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/web.url.js");
+require("core-js/modules/web.url-search-params.js");
+function capitalize(str) {
+  if (typeof str !== 'string') {
+    console.error(new Error('str should be a string'));
+  }
+  return str && str[0].toUpperCase() + str.slice(1);
+}
+function substitute(str, obj) {
+  if (typeof str === 'string') {
+    if (str.indexOf('{') < 0) {
+      return str;
+    }
+    return str.replace(/\\?\{([^{}]+)\}/g, function (match, name) {
+      if (match.charAt(0) === '\\') {
+        return match.slice(1);
+      }
+      return obj[name] === null || obj[name] === undefined ? '' : obj[name];
+    });
+  }
+  if (typeof str === 'function') {
+    var val = str(obj);
+    if (val === obj && (0, _typeof2.default)(val) === 'object') {
+      val = Object.assign({}, obj);
+    }
+    return val;
+  }
+  return '';
+}
+function removeProtocol(url) {
+  if (url.indexOf('http') !== 0) return url;
+  try {
+    var _URL = new URL(url),
+      href = _URL.href,
+      protocol = _URL.protocol;
+    return href.slice(protocol.length);
+  } catch (error) {
+    return url;
+  }
+}
+function getRTLPosition(position) {
+  if (!position) return position;
+  // position.replace('left', 'right').replace('right', 'left')
+  if (position.indexOf('left') !== -1) {
+    return position.replace('left', 'right');
+  }
+  if (position.indexOf('right') !== -1) {
+    return position.replace('right', 'left');
+  }
+  return position;
+}
+function getDirectionIconName() {
+  var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'left';
+  var double = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var rtl = true;
+  if (mode === 'left') {
+    if (rtl) {
+      return double ? 'AngleDoubleRight' : 'AngleRight';
+    }
+    return double ? 'AngleDoubleLeft' : 'AngleLeft';
+  }
+  if (rtl) {
+    return double ? 'AngleDoubleLeft' : 'AngleLeft';
+  }
+  return double ? 'AngleDoubleRight' : 'AngleRight';
+}

package/cjs/utils/tree.d.ts

@@ -0,0 +1,14 @@
+declare type ExpandKeys = (string | number)[];
+interface Conf {
+    advanced?: boolean;
+}
+export declare const getFilterTree: <T, K extends Function>(treeNodes: T[] | undefined, filterFunc: (data: T) => boolean, filterExpandKeys: ExpandKeys | undefined, keyFunc: K, childrenKey: keyof T | undefined, showHitDescendants: boolean, firstMatchNode?: ((node: T) => void) | undefined, { advanced }?: Conf) => (T | null)[];
+export declare const getFlattenTree: <T>(data: T[], childrenKey?: keyof T, wide?: boolean) => T[][];
+declare type FilterDatum<T> = {
+    data: T[];
+    childrenKey: string;
+    getKey: (node: T) => string;
+    getDataById: (id: string) => T;
+};
+export declare const mergeFilteredTree: (filterDatum: FilterDatum<any>, rawDatum: FilterDatum<any>, tiledId: string[]) => any[];
+export {};

package/cjs/utils/tree.js

@@ -0,0 +1,93 @@
+"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.mergeFilteredTree = exports.getFlattenTree = exports.getFilterTree = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.index-of.js");
+var _immer = require("immer");
+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; }
+var getFilterTree = function getFilterTree(treeNodes, filterFunc, filterExpandKeys, keyFunc) {
+  var childrenKey = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'children';
+  var showHitDescendants = arguments.length > 5 ? arguments[5] : undefined;
+  var firstMatchNode = arguments.length > 6 ? arguments[6] : undefined;
+  var _ref = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : {},
+    advanced = _ref.advanced;
+  var mapFilteredNodeToData = function mapFilteredNodeToData(node) {
+    if (!node) return null;
+    var match = false;
+    if (filterFunc(node)) {
+      if (firstMatchNode) firstMatchNode(node);
+      match = true;
+    }
+    var children = (node[childrenKey] || []).map(mapFilteredNodeToData).filter(function (n) {
+      return n;
+    });
+    if (children.length || match) {
+      var key = keyFunc(node);
+      if (filterExpandKeys && children.length > 0) filterExpandKeys.push(key);
+      if (!node[childrenKey]) return node;
+      var childNodes = showHitDescendants && match ? node[childrenKey] || [] : children;
+      if (advanced && match && children.length > 0) childNodes = children;
+      return _objectSpread(_objectSpread({}, node), {}, (0, _defineProperty2.default)({}, childrenKey, childNodes));
+    }
+    return null;
+  };
+  return treeNodes.map(mapFilteredNodeToData).filter(function (node) {
+    return node;
+  });
+};
+exports.getFilterTree = getFilterTree;
+var getFlattenTree = function getFlattenTree(data) {
+  var childrenKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'children';
+  var wide = arguments.length > 2 ? arguments[2] : undefined;
+  var arr = [];
+  var flatten = function flatten(list, path) {
+    list.forEach(function (item) {
+      var children = item[childrenKey];
+      if (children && children.length > 0) {
+        var clonedPath = (0, _toConsumableArray2.default)(path);
+        clonedPath.push(item);
+        if (wide) arr.push(clonedPath);
+        flatten(children, clonedPath);
+      } else {
+        arr.push([].concat((0, _toConsumableArray2.default)(path), [item]));
+      }
+    });
+  };
+  flatten(data, []);
+  return arr;
+};
+exports.getFlattenTree = getFlattenTree;
+var mergeFilteredTree = function mergeFilteredTree(filterDatum, rawDatum, tiledId) {
+  var filterData = filterDatum.data;
+  var childrenKey = filterDatum.childrenKey;
+  if (tiledId.length === 0) return filterData;
+  var recursion = function recursion(node) {
+    var nodeKey = filterDatum.getKey(node);
+    if (tiledId.indexOf(nodeKey) >= 0) {
+      node[childrenKey] = (0, _clone.deepClone)(rawDatum.getDataById(nodeKey)[childrenKey] || []);
+    } else {
+      var item = filterDatum.getDataById(nodeKey);
+      if (item && item[childrenKey]) {
+        node[childrenKey] = (0, _clone.deepClone)(item[childrenKey] || []);
+      }
+    }
+    var children = node[childrenKey] || [];
+    children.map(recursion);
+  };
+  return (0, _immer.produce)(filterData, function (draft) {
+    draft.map(recursion);
+  });
+};
+exports.mergeFilteredTree = mergeFilteredTree;

package/cjs/utils/validate/isJson.d.ts

@@ -0,0 +1 @@
+export default function (value: unknown): boolean;

package/cjs/utils/validate/isJson.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.replace.js");
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+function _default(value) {
+  if ((0, _typeof2.default)(value) === 'object') return true;
+
+  // In the second stage, we run the text against
+  // regular expressions that look for non-JSON patterns. We are especially
+  // concerned with '()' and 'new' because they can cause invocation, and '='
+  // because it can cause mutation. But just to be safe, we want to reject all
+  // unexpected forms.
+
+  // We split the second stage into 4 regexp operations in order to work around
+  // crippling inefficiencies in IE's and Safari's regexp engines. First we
+  // replace all backslash pairs with '@' (a non-JSON character). Second, we
+  // replace all simple value tokens with ']' characters. Third, we delete all
+  // open brackets that follow a colon or comma or that begin the text. Finally,
+  // we look to see that the remaining characters are only whitespace or ']' or
+  // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
+
+  // eslint-disable-next-line
+  if (typeof value === 'string') {
+    if (/^[\],:{}\s]*$/.test(value.replace(/\\["\\\/bfnrtu]/g, '@').replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
+      try {
+        JSON.parse(value);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+}