react-sortable-tree-node/dist/SortableTree/utils/tree-data-utils.test.js

react-sortable-tree-node

"use strict";

var _treeDataUtils = require("./tree-data-utils");

function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); }

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

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; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

var keyFromTreeIndex = function keyFromTreeIndex(_ref) {
  var treeIndex = _ref.treeIndex;
  return treeIndex;
};

var keyFromKey = function keyFromKey(_ref2) {
  var node = _ref2.node;
  return node.key;
};

describe('getVisibleNodeCount', function () {
  it('should handle flat data', function () {
    expect((0, _treeDataUtils.getVisibleNodeCount)({
      treeData: [{}, {}]
    })).toEqual(2);
  });
  it('should handle hidden nested data', function () {
    expect((0, _treeDataUtils.getVisibleNodeCount)({
      treeData: [{
        children: [{
          children: [{}, {}]
        }, {
          children: [{}]
        }]
      }, {}]
    })).toEqual(2);
  });
  it('should handle functions', function () {
    expect((0, _treeDataUtils.getVisibleNodeCount)({
      treeData: [{
        expanded: true,
        children: [{
          expanded: true,
          children: [{
            expanded: true,
            children: function children() {
              return {
                key: 1
              };
            }
          }, {}]
        }, {
          children: [{}]
        }]
      }, {}]
    })).toEqual(6);
  });
  it('should handle partially expanded nested data', function () {
    expect((0, _treeDataUtils.getVisibleNodeCount)({
      treeData: [{
        expanded: true,
        children: [{
          expanded: true,
          children: [{}, {}]
        }, {
          children: [{}]
        }]
      }, {}]
    })).toEqual(6);
  });
  it('should handle fully expanded nested data', function () {
    expect((0, _treeDataUtils.getVisibleNodeCount)({
      treeData: [{
        expanded: true,
        children: [{
          expanded: true,
          children: [{}, {}]
        }, {
          expanded: true,
          children: [{}]
        }]
      }, {}]
    })).toEqual(7);
  });
});
describe('getVisibleNodeInfoAtIndex', function () {
  it('should handle empty data', function () {
    expect((0, _treeDataUtils.getVisibleNodeInfoAtIndex)({
      treeData: [],
      index: 1,
      getNodeKey: keyFromTreeIndex
    })).toEqual(null);
    expect((0, _treeDataUtils.getVisibleNodeInfoAtIndex)({
      treeData: null,
      index: 1,
      getNodeKey: keyFromTreeIndex
    })).toEqual(null);
    expect((0, _treeDataUtils.getVisibleNodeInfoAtIndex)({
      treeData: undefined,
      index: 1,
      getNodeKey: keyFromTreeIndex
    })).toEqual(null);
  });
  it('should handle flat data', function () {
    expect((0, _treeDataUtils.getVisibleNodeInfoAtIndex)({
      treeData: [{
        key: 0
      }],
      index: 0,
      getNodeKey: keyFromTreeIndex
    }).node.key).toEqual(0);
    expect((0, _treeDataUtils.getVisibleNodeInfoAtIndex)({
      treeData: [{
        key: 0
      }, {
        key: 1
      }],
      index: 1,
      getNodeKey: keyFromTreeIndex
    }).node.key).toEqual(1);
  });
  it('should handle hidden nested data', function () {
    var result = (0, _treeDataUtils.getVisibleNodeInfoAtIndex)({
      treeData: [{
        key: 0,
        children: [{
          key: 1,
          children: [{
            key: 2
          }, {
            key: 3
          }]
        }, {
          key: 4,
          children: [{
            key: 5
          }]
        }]
      }, {
        key: 6
      }],
      index: 1,
      getNodeKey: keyFromTreeIndex
    });
    expect(result.node.key).toEqual(6);
    expect(result.path).toEqual([1]);
    expect(result.lowerSiblingCounts).toEqual([0]);
  });
  it('should handle partially expanded nested data', function () {
    var result = (0, _treeDataUtils.getVisibleNodeInfoAtIndex)({
      treeData: [{
        expanded: true,
        key: 0,
        children: [{
          key: 1,
          children: [{
            key: 2
          }, {
            key: 3
          }]
        }, {
          expanded: true,
          key: 4,
          children: [{
            key: 5
          }]
        }]
      }, {
        key: 6
      }],
      index: 3,
      getNodeKey: keyFromKey
    });
    expect(result.node.key).toEqual(5);
    expect(result.path).toEqual([0, 4, 5]);
    expect(result.lowerSiblingCounts).toEqual([1, 0, 0]);
  });
  it('should handle fully expanded nested data', function () {
    var result = (0, _treeDataUtils.getVisibleNodeInfoAtIndex)({
      treeData: [{
        expanded: true,
        key: 0,
        children: [{
          expanded: true,
          key: 1,
          children: [{
            key: 2
          }, {
            key: 3
          }]
        }, {
          expanded: true,
          key: 4,
          children: [{
            key: 5
          }]
        }]
      }, {
        key: 6
      }],
      index: 5,
      getNodeKey: keyFromTreeIndex
    });
    expect(result.node.key).toEqual(5);
    expect(result.path).toEqual([0, 4, 5]);
    expect(result.lowerSiblingCounts).toEqual([1, 0, 0]);
  });
  it('should handle an index that is larger than the data', function () {
    expect((0, _treeDataUtils.getVisibleNodeInfoAtIndex)({
      treeData: [{
        expanded: true,
        key: 0,
        children: [{
          expanded: true,
          key: 1,
          children: [{
            key: 2
          }, {
            key: 3
          }]
        }, {
          expanded: true,
          key: 4,
          children: [{
            key: 5
          }]
        }]
      }, {
        key: 6
      }],
      index: 7,
      getNodeKey: keyFromTreeIndex
    })).toEqual(null);
  });
});
describe('getNodeAtPath', function () {
  it('should handle empty data', function () {
    expect((0, _treeDataUtils.getNodeAtPath)({
      treeData: [],
      path: 1,
      getNodeKey: keyFromTreeIndex
    })).toEqual(null);
    expect((0, _treeDataUtils.getNodeAtPath)({
      treeData: null,
      path: 1,
      getNodeKey: keyFromTreeIndex
    })).toEqual(null);
    expect((0, _treeDataUtils.getNodeAtPath)({
      treeData: undefined,
      path: 1,
      getNodeKey: keyFromTreeIndex
    })).toEqual(null);
  });
  it('should handle flat data', function () {
    expect((0, _treeDataUtils.getNodeAtPath)({
      treeData: [{
        key: 0
      }],
      path: [0],
      getNodeKey: keyFromTreeIndex
    }).node.key).toEqual(0);
    expect((0, _treeDataUtils.getNodeAtPath)({
      treeData: [{
        key: 0
      }, {
        key: 1
      }],
      path: [1],
      getNodeKey: keyFromTreeIndex
    }).node.key).toEqual(1);
  });
  it('should handle hidden nested data', function () {
    var result = (0, _treeDataUtils.getNodeAtPath)({
      treeData: [{
        key: 0,
        children: [{
          key: 1,
          children: [{
            key: 2
          }, {
            key: 3
          }]
        }, {
          key: 4,
          children: [{
            key: 5
          }]
        }]
      }, {
        key: 6
      }],
      path: [1],
      getNodeKey: keyFromTreeIndex
    });
    expect(result.node.key).toEqual(6);
  });
  it('should handle partially expanded nested data', function () {
    var result = (0, _treeDataUtils.getNodeAtPath)({
      treeData: [{
        expanded: true,
        key: 0,
        children: [{
          key: 1,
          children: [{
            key: 2
          }, {
            key: 3
          }]
        }, {
          expanded: true,
          key: 4,
          children: [{
            key: 5
          }]
        }]
      }, {
        key: 6
      }],
      path: [0, 4, 5],
      getNodeKey: keyFromKey
    });
    expect(result.node.key).toEqual(5);
  });
  it('should handle fully expanded nested data', function () {
    var result = (0, _treeDataUtils.getNodeAtPath)({
      treeData: [{
        expanded: true,
        key: 0,
        children: [{
          expanded: true,
          key: 1,
          children: [{
            key: 2
          }, {
            key: 3
          }]
        }, {
          expanded: true,
          key: 4,
          children: [{
            key: 5
          }]
        }]
      }, {
        key: 6
      }],
      path: [0, 4, 5],
      getNodeKey: keyFromTreeIndex
    });
    expect(result.node.key).toEqual(5);
  });
  it('should handle an index that is larger than the data', function () {
    expect((0, _treeDataUtils.getNodeAtPath)({
      treeData: [{
        expanded: true,
        key: 0,
        children: [{
          expanded: true,
          key: 1,
          children: [{
            key: 2
          }, {
            key: 3
          }]
        }, {
          expanded: true,
          key: 4,
          children: [{
            key: 5
          }]
        }]
      }, {
        key: 6
      }],
      path: [7],
      getNodeKey: keyFromTreeIndex
    })).toEqual(null);
  });
});
describe('getFlatDataFromTree', function () {
  it('should handle empty data', function () {
    expect((0, _treeDataUtils.getFlatDataFromTree)({
      treeData: [],
      getNodeKey: keyFromTreeIndex
    })).toEqual([]);
    expect((0, _treeDataUtils.getFlatDataFromTree)({
      treeData: null,
      getNodeKey: keyFromTreeIndex
    })).toEqual([]);
    expect((0, _treeDataUtils.getFlatDataFromTree)({
      treeData: undefined,
      getNodeKey: keyFromTreeIndex
    })).toEqual([]);
  });
  it('should handle flat data', function () {
    expect((0, _treeDataUtils.getFlatDataFromTree)({
      ignoreCollapsed: true,
      getNodeKey: keyFromTreeIndex,
      treeData: [{
        key: 0
      }]
    })).toEqual([{
      node: {
        key: 0
      },
      parentNode: null,
      path: [0],
      lowerSiblingCounts: [0],
      treeIndex: 0
    }]);
    expect((0, _treeDataUtils.getFlatDataFromTree)({
      ignoreCollapsed: true,
      treeData: [{
        key: 0
      }, {
        key: 1
      }],
      getNodeKey: keyFromTreeIndex
    })).toEqual([{
      node: {
        key: 0
      },
      parentNode: null,
      path: [0],
      lowerSiblingCounts: [1],
      treeIndex: 0
    }, {
      node: {
        key: 1
      },
      parentNode: null,
      path: [1],
      lowerSiblingCounts: [0],
      treeIndex: 1
    }]);
  });
  it('should handle hidden nested data', function () {
    var treeData = [{
      key: 0,
      children: [{
        key: 1,
        children: [{
          key: 2
        }, {
          key: 3
        }]
      }, {
        key: 4,
        children: [{
          key: 5
        }]
      }]
    }, {
      key: 6
    }];
    expect((0, _treeDataUtils.getFlatDataFromTree)({
      ignoreCollapsed: true,
      getNodeKey: keyFromTreeIndex,
      treeData: treeData
    })).toEqual([{
      node: treeData[0],
      parentNode: null,
      path: [0],
      lowerSiblingCounts: [1],
      treeIndex: 0
    }, {
      node: treeData[1],
      parentNode: null,
      path: [1],
      lowerSiblingCounts: [0],
      treeIndex: 1
    }]);
  });
  it('should handle partially expanded nested data', function () {
    var treeData = [{
      expanded: true,
      key: 0,
      children: [{
        key: 1,
        children: [{
          key: 2
        }, {
          key: 3
        }]
      }, {
        expanded: true,
        key: 4,
        children: [{
          key: 5
        }]
      }]
    }, {
      key: 6
    }];
    expect((0, _treeDataUtils.getFlatDataFromTree)({
      ignoreCollapsed: true,
      getNodeKey: keyFromKey,
      treeData: treeData
    })).toEqual([{
      node: treeData[0],
      parentNode: null,
      path: [0],
      lowerSiblingCounts: [1],
      treeIndex: 0
    }, {
      node: treeData[0].children[0],
      parentNode: treeData[0],
      path: [0, 1],
      lowerSiblingCounts: [1, 1],
      treeIndex: 1
    }, {
      node: treeData[0].children[1],
      parentNode: treeData[0],
      path: [0, 4],
      lowerSiblingCounts: [1, 0],
      treeIndex: 2
    }, {
      node: treeData[0].children[1].children[0],
      parentNode: treeData[0].children[1],
      path: [0, 4, 5],
      lowerSiblingCounts: [1, 0, 0],
      treeIndex: 3
    }, {
      node: treeData[1],
      parentNode: null,
      path: [6],
      lowerSiblingCounts: [0],
      treeIndex: 4
    }]);
  });
  it('should handle fully expanded nested data', function () {
    var treeData = [{
      expanded: true,
      key: 0,
      children: [{
        expanded: true,
        key: 1,
        children: [{
          key: 2
        }, {
          key: 3
        }]
      }, {
        expanded: true,
        key: 4,
        children: [{
          key: 5
        }]
      }]
    }, {
      key: 6
    }];
    expect((0, _treeDataUtils.getFlatDataFromTree)({
      ignoreCollapsed: true,
      treeData: treeData,
      getNodeKey: keyFromTreeIndex
    })).toEqual([{
      node: treeData[0],
      parentNode: null,
      path: [0],
      lowerSiblingCounts: [1],
      treeIndex: 0
    }, {
      node: treeData[0].children[0],
      parentNode: treeData[0],
      path: [0, 1],
      lowerSiblingCounts: [1, 1],
      treeIndex: 1
    }, {
      node: treeData[0].children[0].children[0],
      parentNode: treeData[0].children[0],
      path: [0, 1, 2],
      lowerSiblingCounts: [1, 1, 1],
      treeIndex: 2
    }, {
      node: treeData[0].children[0].children[1],
      parentNode: treeData[0].children[0],
      path: [0, 1, 3],
      lowerSiblingCounts: [1, 1, 0],
      treeIndex: 3
    }, {
      node: treeData[0].children[1],
      parentNode: treeData[0],
      path: [0, 4],
      lowerSiblingCounts: [1, 0],
      treeIndex: 4
    }, {
      node: treeData[0].children[1].children[0],
      parentNode: treeData[0].children[1],
      path: [0, 4, 5],
      lowerSiblingCounts: [1, 0, 0],
      treeIndex: 5
    }, {
      node: treeData[1],
      parentNode: null,
      path: [6],
      lowerSiblingCounts: [0],
      treeIndex: 6
    }]);
  });
});
describe('changeNodeAtPath', function () {
  it('should handle empty data', function () {
    var noChildrenError = new Error('Path referenced children of node with no children.');
    var noNodeError = new Error('No node found at the given path.');
    expect(function () {
      return (0, _treeDataUtils.changeNodeAtPath)({
        treeData: [],
        path: [1],
        newNode: {},
        getNodeKey: keyFromTreeIndex
      });
    }).toThrow(noNodeError);
    expect(function () {
      return (0, _treeDataUtils.changeNodeAtPath)({
        treeData: null,
        path: [1],
        newNode: {},
        getNodeKey: keyFromTreeIndex
      });
    }).toThrow(noChildrenError);
    expect(function () {
      return (0, _treeDataUtils.changeNodeAtPath)({
        treeData: null,
        path: [1, 2],
        newNode: {},
        getNodeKey: keyFromTreeIndex
      });
    }).toThrow(noChildrenError);
    expect(function () {
      return (0, _treeDataUtils.changeNodeAtPath)({
        treeData: undefined,
        path: [1],
        newNode: {},
        getNodeKey: keyFromTreeIndex
      });
    }).toThrow(noChildrenError);
  });
  it('should handle flat data', function () {
    expect((0, _treeDataUtils.changeNodeAtPath)({
      treeData: [{
        key: 0
      }],
      path: [0],
      newNode: {
        key: 1
      },
      getNodeKey: keyFromKey
    })).toEqual([{
      key: 1
    }]);
    expect((0, _treeDataUtils.changeNodeAtPath)({
      treeData: [{
        key: 0
      }, {
        key: 'a'
      }],
      path: ['a'],
      newNode: {
        key: 1
      },
      getNodeKey: keyFromKey
    })).toEqual([{
      key: 0
    }, {
      key: 1
    }]);
  });
  it('should handle nested data', function () {
    var result = (0, _treeDataUtils.changeNodeAtPath)({
      treeData: [{
        expanded: true,
        key: 0,
        children: [{
          key: 'b',
          children: [{
            key: 2
          }, {
            key: 3
          }, {
            key: 'f'
          }]
        }, {
          expanded: true,
          key: 'r',
          children: [{
            key: 5
          }, {
            key: 8
          }, {
            key: 7
          }]
        }]
      }, {
        key: 6
      }],
      path: [0, 2, 5],
      newNode: {
        food: 'pancake'
      },
      getNodeKey: keyFromTreeIndex
    });
    expect(result[0].children[1].children[2].food).toEqual('pancake');
  });
  it('should handle adding children', function () {
    var result = (0, _treeDataUtils.changeNodeAtPath)({
      treeData: [{
        expanded: true,
        key: 0,
        children: [{
          key: 'b',
          children: [{
            key: 2
          }, {
            key: 3
          }, {
            key: 'f'
          }]
        }, {
          expanded: true,
          key: 'r',
          children: [{
            key: 5
          }, {
            key: 8
          }, {
            key: 7
          }]
        }]
      }, {
        key: 6
      }],
      path: [0, 2, 5],
      newNode: function newNode(_ref3) {
        var node = _ref3.node;
        return _objectSpread(_objectSpread({}, node), {}, {
          children: [{
            food: 'pancake'
          }]
        });
      },
      getNodeKey: keyFromTreeIndex
    });
    expect(result[0].children[1].children[2].children[0].food).toEqual('pancake');
  });
  it('should handle adding children to the root', function () {
    expect((0, _treeDataUtils.changeNodeAtPath)({
      treeData: [],
      path: [],
      newNode: function newNode(_ref4) {
        var node = _ref4.node;
        return _objectSpread(_objectSpread({}, node), {}, {
          children: [].concat(_toConsumableArray(node.children), [{
            key: 1
          }])
        });
      },
      getNodeKey: keyFromKey
    })).toEqual([{
      key: 1
    }]);
    expect((0, _treeDataUtils.changeNodeAtPath)({
      treeData: [{
        key: 0
      }],
      path: [],
      newNode: function newNode(_ref5) {
        var node = _ref5.node;
        return _objectSpread(_objectSpread({}, node), {}, {
          children: [].concat(_toConsumableArray(node.children), [{
            key: 1
          }])
        });
      },
      getNodeKey: keyFromKey
    })).toEqual([{
      key: 0
    }, {
      key: 1
    }]);
  });
  it('should delete data when falsey node passed', function () {
    var result = (0, _treeDataUtils.changeNodeAtPath)({
      treeData: [{
        expanded: true,
        key: 'b',
        children: [{
          key: 'f'
        }]
      }, {
        expanded: true,
        key: 'r',
        children: [{
          key: 7
        }]
      }, {
        key: 6
      }],
      path: [2, 3],
      newNode: null,
      getNodeKey: keyFromTreeIndex
    });
    expect(result[1].children.length).toEqual(0);
  });
  it('should delete data on the top level', function () {
    var treeData = [{
      expanded: true,
      key: 'b',
      children: [{
        key: 'f'
      }]
    }, {
      expanded: true,
      key: 'r',
      children: [{
        key: 7
      }]
    }, {
      key: 6
    }];
    var result = (0, _treeDataUtils.changeNodeAtPath)({
      treeData: treeData,
      path: [2],
      newNode: null,
      getNodeKey: keyFromTreeIndex
    });
    expect(result).toEqual([treeData[0], treeData[2]]);
  });
  it('should handle a path that is too long', function () {
    var treeData = [{
      expanded: true,
      key: 0,
      children: [{
        expanded: true,
        key: 1,
        children: [{
          key: 2
        }, {
          key: 3
        }]
      }]
    }];
    expect(function () {
      return (0, _treeDataUtils.changeNodeAtPath)({
        treeData: treeData,
        path: [0, 1, 2, 4],
        newNode: {
          a: 1
        },
        getNodeKey: keyFromKey
      });
    }).toThrow(new Error('Path referenced children of node with no children.'));
  });
  it('should handle a path that does not exist', function () {
    var treeData = [{
      expanded: true,
      key: 0,
      children: [{
        expanded: true,
        key: 1,
        children: [{
          key: 2
        }, {
          key: 3
        }]
      }]
    }];
    expect(function () {
      return (0, _treeDataUtils.changeNodeAtPath)({
        treeData: treeData,
        path: [0, 2],
        newNode: {
          a: 1
        },
        getNodeKey: keyFromKey
      });
    }).toThrowError('No node found at the given path.');
  });
});
describe('addNodeUnderParent', function () {
  it('should handle empty data', function () {
    expect((0, _treeDataUtils.addNodeUnderParent)({
      treeData: [],
      parentKey: null,
      newNode: {},
      getNodeKey: keyFromTreeIndex
    })).toEqual({
      treeData: [{}],
      treeIndex: 0
    });
    expect((0, _treeDataUtils.addNodeUnderParent)({
      treeData: null,
      parentKey: null,
      newNode: {},
      getNodeKey: keyFromTreeIndex
    })).toEqual({
      treeData: [{}],
      treeIndex: 0
    });
    expect((0, _treeDataUtils.addNodeUnderParent)({
      treeData: undefined,
      parentKey: null,
      newNode: {},
      getNodeKey: keyFromTreeIndex
    })).toEqual({
      treeData: [{}],
      treeIndex: 0
    });
  });
  it('should handle a parentPath that does not exist', function () {
    var treeData = [{
      expanded: true,
      key: 0,
      children: [{
        expanded: true,
        key: 1,
        children: [{
          key: 2
        }, {
          key: 3
        }]
      }]
    }];
    expect(function () {
      return (0, _treeDataUtils.addNodeUnderParent)({
        treeData: treeData,
        parentKey: 'fake',
        newNode: {
          a: 1
        },
        getNodeKey: keyFromKey
      });
    }).toThrowError('No node found with the given key.');
  });
  it('should handle flat data', function () {
    // Older sibling of only node
    expect((0, _treeDataUtils.addNodeUnderParent)({
      treeData: [{
        key: 0
      }],
      parentKey: null,
      newNode: {
        key: 1
      },
      getNodeKey: keyFromTreeIndex
    })).toEqual({
      treeData: [{
        key: 0
      }, {
        key: 1
      }],
      treeIndex: 1
    }); // Child of only node

    expect((0, _treeDataUtils.addNodeUnderParent)({
      treeData: [{
        key: 0
      }],
      parentKey: 0,
      newNode: {
        key: 1
      },
      getNodeKey: keyFromTreeIndex
    })).toEqual({
      treeData: [{
        key: 0,
        children: [{
          key: 1
        }]
      }],
      treeIndex: 1
    });
    expect((0, _treeDataUtils.addNodeUnderParent)({
      treeData: [{
        key: 0
      }, {
        key: 'a'
      }],
      parentKey: 'a',
      newNode: {
        key: 1
      },
      getNodeKey: keyFromKey
    })).toEqual({
      treeData: [{
        key: 0
      }, {
        key: 'a',
        children: [{
          key: 1
        }]
      }],
      treeIndex: 2
    });
  }); // Tree looks like this
  //      /\
  //     0  6
  //    / \
  //   1   5
  //  / \
  // 2   3
  //      \
  //       4

  var nestedParams = {
    treeData: [{
      expanded: true,
      key: 0,
      children: [{
        expanded: true,
        key: 1,
        children: [{
          key: 2
        }, {
          expanded: false,
          key: 3,
          children: [{
            key: 4
          }]
        }]
      }, {
        key: 5
      }]
    }, {
      key: 6
    }],
    newNode: {
      key: 'new'
    }
  };
  it('should handle nested data #1', function () {
    var result = (0, _treeDataUtils.addNodeUnderParent)(_objectSpread(_objectSpread({}, nestedParams), {}, {
      parentKey: 0,
      getNodeKey: keyFromKey
    }));
    expect(result.treeData[0].children[2]).toEqual(nestedParams.newNode);
    expect(result.treeIndex).toEqual(5);
  });
  it('should handle nested data #2', function () {
    var result = (0, _treeDataUtils.addNodeUnderParent)(_objectSpread(_objectSpread({}, nestedParams), {}, {
      parentKey: 1,
      getNodeKey: keyFromKey
    }));
    expect(result.treeData[0].children[0].children[2]).toEqual(nestedParams.newNode);
    expect(result.treeIndex).toEqual(4);
  });
  it('should handle nested data #3', function () {
    var result = (0, _treeDataUtils.addNodeUnderParent)(_objectSpread(_objectSpread({}, nestedParams), {}, {
      parentKey: 3,
      getNodeKey: keyFromKey
    }));
    expect(result.treeData[0].children[0].children[1].children[1]).toEqual(nestedParams.newNode);
    expect(result.treeIndex).toEqual(5);
  });
  it('should handle nested data #1 (using tree index as key)', function () {
    var result = (0, _treeDataUtils.addNodeUnderParent)(_objectSpread(_objectSpread({}, nestedParams), {}, {
      parentKey: 0,
      getNodeKey: keyFromTreeIndex
    }));
    expect(result.treeData[0].children[2]).toEqual(nestedParams.newNode);
    expect(result.treeIndex).toEqual(5);
  });
  it('should handle nested data #2 (using tree index as key)', function () {
    var result = (0, _treeDataUtils.addNodeUnderParent)(_objectSpread(_objectSpread({}, nestedParams), {}, {
      parentKey: 1,
      getNodeKey: keyFromTreeIndex
    }));
    expect(result.treeData[0].children[0].children[2]).toEqual(nestedParams.newNode);
    expect(result.treeIndex).toEqual(4);
  });
  it('should handle nested data #3 (using tree index as key)', function () {
    var result = (0, _treeDataUtils.addNodeUnderParent)(_objectSpread(_objectSpread({}, nestedParams), {}, {
      parentKey: 3,
      getNodeKey: keyFromTreeIndex
    }));
    expect(result.treeData[0].children[0].children[1].children[1]).toEqual(nestedParams.newNode);
    expect(result.treeIndex).toEqual(5);
  });
  it('should add new node as last child by default', function () {
    var result = (0, _treeDataUtils.addNodeUnderParent)(_objectSpread(_objectSpread({}, nestedParams), {}, {
      parentKey: 0,
      getNodeKey: keyFromKey
    }));

    var _result$treeData$0$ch = _slicedToArray(result.treeData[0].children, 3),
        existingChild0 = _result$treeData$0$ch[0],
        existingChild1 = _result$treeData$0$ch[1],
        expectedNewNode = _result$treeData$0$ch[2];

    expect(expectedNewNode).toEqual(nestedParams.newNode);
    expect([existingChild0, existingChild1]).toEqual(nestedParams.treeData[0].children);
  });
  it('should add new node as first child if addAsFirstChild is true', function () {
    var result = (0, _treeDataUtils.addNodeUnderParent)(_objectSpread(_objectSpread({}, nestedParams), {}, {
      parentKey: 0,
      getNodeKey: keyFromKey,
      addAsFirstChild: true
    }));

    var _result$treeData$0$ch2 = _toArray(result.treeData[0].children),
        expectedNewNode = _result$treeData$0$ch2[0],
        previousChildren = _result$treeData$0$ch2.slice(1);

    expect(expectedNewNode).toEqual(nestedParams.newNode);
    expect(previousChildren).toEqual(nestedParams.treeData[0].children);
  });
});
describe('insertNode', function () {
  it('should handle empty data', function () {
    expect((0, _treeDataUtils.insertNode)({
      treeData: [],
      depth: 0,
      minimumTreeIndex: 0,
      newNode: {},
      getNodeKey: keyFromTreeIndex
    })).toEqual({
      parentNode: null,
      treeData: [{}],
      treeIndex: 0,
      path: [0]
    });
    expect((0, _treeDataUtils.insertNode)({
      treeData: null,
      depth: 0,
      minimumTreeIndex: 0,
      newNode: {},
      getNodeKey: keyFromTreeIndex
    })).toEqual({
      parentNode: null,
      treeData: [{}],
      treeIndex: 0,
      path: [0]
    });
    expect((0, _treeDataUtils.insertNode)({
      treeData: undefined,
      depth: 0,
      minimumTreeIndex: 0,
      newNode: {},
      getNodeKey: keyFromTreeIndex
    })).toEqual({
      parentNode: null,
      treeData: [{}],
      treeIndex: 0,
      path: [0]
    });
  });
  it('should handle a depth that is deeper than any branch in the tree', function () {
    var treeData = [{
      expanded: true,
      key: 0,
      children: [{
        expanded: true,
        key: 1,
        children: [{
          key: 2
        }, {
          key: 3
        }]
      }]
    }];
    expect((0, _treeDataUtils.insertNode)({
      treeData: treeData,
      depth: 4,
      minimumTreeIndex: 0,
      newNode: {
        key: 'new'
      },
      getNodeKey: keyFromKey
    }).treeData[0]).toEqual({
      key: 'new'
    });
  });
  it('should handle a minimumTreeIndex that is too big', function () {
    var treeData = [{
      expanded: true,
      key: 0,
      children: [{
        expanded: true,
        key: 1,
        children: [{
          key: 2
        }, {
          key: 3
        }]
      }]
    }, {
      key: 4
    }];
    var insertResult = (0, _treeDataUtils.insertNode)({
      treeData: treeData,
      depth: 0,
      minimumTreeIndex: 15,
      newNode: {
        key: 'new'
      },
      getNodeKey: keyFromKey
    });
    expect(insertResult.treeData[2]).toEqual({
      key: 'new'
    });
    expect(insertResult.treeIndex).toEqual(5);
    expect(insertResult.path).toEqual(['new']);
    insertResult = (0, _treeDataUtils.insertNode)({
      treeData: treeData,
      depth: 2,
      minimumTreeIndex: 15,
      newNode: {
        key: 'new'
      },
      getNodeKey: keyFromKey
    });
    expect(insertResult.treeData[1].children[0]).toEqual({
      key: 'new'
    });
    expect(insertResult.treeIndex).toEqual(5);
    expect(insertResult.path).toEqual([4, 'new']);
  });
  it('should handle flat data (before)', function () {
    expect((0, _treeDataUtils.insertNode)({
      treeData: [{
        key: 0
      }],
      depth: 0,
      minimumTreeIndex: 0,
      newNode: {
        key: 1
      },
      getNodeKey: keyFromKey
    })).toEqual({
      parentNode: null,
      treeData: [{
        key: 1
      }, {
        key: 0
      }],
      treeIndex: 0,
      path: [1]
    });
  });
  it('should handle flat data (after)', function () {
    expect((0, _treeDataUtils.insertNode)({
      treeData: [{
        key: 0
      }],
      depth: 0,
      minimumTreeIndex: 1,
      newNode: {
        key: 1
      },
      getNodeKey: keyFromKey
    })).toEqual({
      parentNode: null,
      treeData: [{
        key: 0
      }, {
        key: 1
      }],
      treeIndex: 1,
      path: [1]
    });
  });
  it('should handle flat data (child)', function () {
    expect((0, _treeDataUtils.insertNode)({
      treeData: [{
        key: 0
      }],
      depth: 1,
      minimumTreeIndex: 1,
      newNode: {
        key: 1
      },
      getNodeKey: keyFromKey
    })).toEqual({
      parentNode: {
        key: 0,
        children: [{
          key: 1
        }]
      },
      treeData: [{
        key: 0,
        children: [{
          key: 1
        }]
      }],
      treeIndex: 1,
      path: [0, 1]
    });
  }); // Tree looks like this
  //      /\
  //     0  6
  //    / \
  //   1   5
  //  / \
  // 2   3
  //      \
  //       4

  var nestedParams = {
    treeData: [// Depth 0
    {
      expanded: true,
      key: 0,
      children: [// Depth 1
      {
        expanded: true,
        key: 1,
        children: [// Depth 2
        {
          key: 2
        }, {
          expanded: false,
          key: 3,
          children: [// Depth 3
          {
            key: 4
          }]
        }, {
          key: 5
        }]
      }, {
        key: 6
      }]
    }, {
      key: 7
    }],
    newNode: {
      key: 'new'
    },
    getNodeKey: keyFromKey
  };
  it('should handle nested data #1', function () {
    var result = (0, _treeDataUtils.insertNode)(_objectSpread(_objectSpread({}, nestedParams), {}, {
      depth: 1,
      minimumTreeIndex: 4
    }));
    expect(result.treeData[0].children[1]).toEqual(nestedParams.newNode);
    expect(result.treeIndex).toEqual(5);
    expect(result.path).toEqual([0, 'new']);
  });
  it('should handle nested data #2', function () {
    var result = (0, _treeDataUtils.insertNode)(_objectSpread(_objectSpread({}, nestedParams), {}, {
      depth: 2,
      ignoreCollapsed: true,
      minimumTreeIndex: 5
    }));
    expect(result.treeData[0].children[0].children[3]).toEqual(nestedParams.newNode);
    expect(result.treeIndex).toEqual(5);
    expect(result.path).toEqual([0, 1, 'new']);
    result = (0, _treeDataUtils.insertNode)(_objectSpread(_objectSpread({}, nestedParams), {}, {
      depth: 2,
      ignoreCollapsed: false,
      minimumTreeIndex: 5
    }));
    expect(result.treeData[0].children[0].children[2]).toEqual(nestedParams.newNode);
    expect(result.treeIndex).toEqual(5);
    expect(result.path).toEqual([0, 1, 'new']);
  });
  it('should handle nested data #3', function () {
    var result = (0, _treeDataUtils.insertNode)(_objectSpread(_objectSpread({}, nestedParams), {}, {
      depth: 3,
      minimumTreeIndex: 3
    }));
    expect(result.treeData[0].children[0].children[0].children[0]).toEqual(nestedParams.newNode);
    expect(result.treeIndex).toEqual(3);
    expect(result.path).toEqual([0, 1, 2, 'new']);
  });
  it('should handle nested data #4', function () {
    expect((0, _treeDataUtils.insertNode)({
      treeData: [{
        key: 0,
        expanded: true,
        children: [{
          key: 1
        }]
      }, {
        key: 2
      }],
      newNode: {
        key: 'new'
      },
      depth: 1,
      minimumTreeIndex: 3,
      getNodeKey: keyFromTreeIndex
    })).toEqual({
      parentNode: {
        key: 2,
        children: [{
          key: 'new'
        }]
      },
      treeData: [{
        key: 0,
        expanded: true,
        children: [{
          key: 1
        }]
      }, {
        key: 2,
        children: [{
          key: 'new'
        }]
      }],
      treeIndex: 3,
      path: [2, 3]
    });
  });
  it('should work with a preceding node with children #1', function () {
    expect((0, _treeDataUtils.insertNode)({
      treeData: [{
        children: [{}]
      }, {
        expanded: true,
        children: [{}, {}]
      }],
      newNode: {
        key: 'new'
      },
      depth: 1,
      minimumTreeIndex: 3,
      getNodeKey: keyFromTreeIndex
    })).toEqual({
      parentNode: {
        expanded: true,
        children: [{}, {
          key: 'new'
        }, {}]
      },
      treeData: [{
        children: [{}]
      }, {
        expanded: true,
        children: [{}, {
          key: 'new'
        }, {}]
      }],
      treeIndex: 3,
      path: [1, 3]
    });
  });
  it('should work with a preceding node with children #2', function () {
    expect((0, _treeDataUtils.insertNode)({
      treeData: [{
        children: [{}]
      }, {
        expanded: true,
        children: [{}, {}]
      }],
      newNode: {
        key: 'new'
      },
      depth: 2,
      minimumTreeIndex: 4,
      getNodeKey: keyFromTreeIndex
    })).toEqual({
      parentNode: {
        children: [{
          key: 'new'
        }]
      },
      treeData: [{
        children: [{}]
      }, {
        expanded: true,
        children: [{}, {
          children: [{
            key: 'new'
          }]
        }]
      }],
      treeIndex: 4,
      path: [1, 3, 4]
    });
  });
  it('should work with a preceding node with children #3', function () {
    expect((0, _treeDataUtils.insertNode)({
      treeData: [{
        children: [{}, {}, {}, {}]
      }, {
        expanded: true,
        children: [{}, {}]
      }],
      newNode: {
        key: 'new'
      },
      depth: 2,
      minimumTreeIndex: 4,
      getNodeKey: keyFromTreeIndex
    })).toEqual({
      parentNode: {
        children: [{
          key: 'new'
        }]
      },
      treeData: [{
        children: [{}, {}, {}, {}]
      }, {
        expanded: true,
        children: [{}, {
          children: [{
            key: 'new'
          }]
        }]
      }],
      treeIndex: 4,
      path: [1, 3, 4]
    });
  });
  it('should work with nodes with an empty children array', function () {
    expect((0, _treeDataUtils.insertNode)({
      treeData: [{
        expanded: true,
        children: [{
          expanded: true,
          children: [{
            children: []
          }]
        }]
      }],
      newNode: {
        key: 'new'
      },
      depth: 2,
      minimumTreeIndex: 2,
      getNodeKey: keyFromTreeIndex
    })).toEqual({
      parentNode: {
        expanded: true,
        children: [{
          key: 'new'
        }, {
          children: []
        }]
      },
      treeData: [{
        expanded: true,
        children: [{
          expanded: true,
          children: [{
            key: 'new'
          }, {
            children: []
          }]
        }]
      }],
      treeIndex: 2,
      path: [0, 1, 2]
    });
  });
});
describe('walk', function () {
  it('should handle empty data', function () {
    [[], null, undefined].forEach(function (treeData) {
      expect(function () {
        return (0, _treeDataUtils.walk)({
          treeData: treeData,
          getNodeKey: keyFromTreeIndex,
          callback: function callback() {
            throw new Error('callback ran');
          }
        });
      }).not.toThrow();
    });
  });
  it('should handle flat and nested data', function () {
    [{
      treeData: [{}],
      expected: 1
    }, {
      treeData: [{}, {}],
      expected: 2
    }, {
      treeData: [{}, {
        children: [{}]
      }, {}],
      expected: 3
    }, {
      treeData: [{}, {
        children: [{}]
      }, {}],
      ignoreCollapsed: false,
      expected: 4
    }].forEach(function (_ref6) {
      var treeData = _ref6.treeData,
          expected = _ref6.expected,
          _ref6$ignoreCollapsed = _ref6.ignoreCollapsed,
          ignoreCollapsed = _ref6$ignoreCollapsed === void 0 ? true : _ref6$ignoreCollapsed;
      var callCount = 0;
      (0, _treeDataUtils.walk)({
        treeData: treeData,
        ignoreCollapsed: ignoreCollapsed,
        getNodeKey: keyFromTreeIndex,
        callback: function callback() {
          callCount += 1;
        }
      });
      expect(callCount).toEqual(expected);
    });
  });
  it('should return correct params', function () {
    var paths = [[0], [1], [1, 2], [3]];
    var counter = 0;
    (0, _treeDataUtils.walk)({
      treeData: [{}, {
        children: [{}]
      }, {}],
      ignoreCollapsed: false,
      getNodeKey: keyFromTreeIndex,
      callback: function callback(_ref7) {
        var treeIndex = _ref7.treeIndex,
            path = _ref7.path;
        expect(treeIndex).toEqual(counter);
        expect(path).toEqual(paths[treeIndex]);
        counter += 1;
      }
    });
  });
  it('should cut walk short when false is returned', function () {
    var treeData = [{
      expanded: true,
      key: 0,
      children: [{
        key: 2
      }, {
        key: 3
      }]
    }, {
      key: 6
    }];
    expect(function () {
      return (0, _treeDataUtils.walk)({
        treeData: treeData,
        getNodeKey: keyFromTreeIndex,
        callback: function callback(_ref8) {
          var node = _ref8.node;

          if (node.key === 2) {
            // Cut walk short with false
            return false;
          } else if (node.key === 3) {
            throw new Error('walk not terminated by false');
          }

          return true;
        }
      });
    }).not.toThrow();
  });
  it('can get parents while walking', function () {
    var treeData = [{
      key: 1,
      children: [{
        key: 12,
        children: [{
          key: 3
        }]
      }, {
        key: 4
      }]
    }, {
      key: 5
    }];
    var results = [];
    (0, _treeDataUtils.walk)({
      treeData: treeData,
      getNodeKey: keyFromTreeIndex,
      ignoreCollapsed: false,
      callback: function callback(_ref9) {
        var parentNode = _ref9.parentNode;
        results.push(parentNode ? parentNode.key : null);
      }
    });
    expect(results).toEqual([null, 1, 12, 1, null]);
  });
});
describe('getTreeFromFlatData', function () {
  var rootKey = -1;
  var argDefaults = {
    rootKey: rootKey,
    getKey: function getKey(node) {
      return node.key;
    },
    getParentKey: function getParentKey(node) {
      return node.parentKey;
    }
  };

  var checkFunction = function checkFunction(_ref10) {
    var flatData = _ref10.flatData,
        expected = _ref10.expected;
    expect((0, _treeDataUtils.getTreeFromFlatData)(_objectSpread(_objectSpread({}, argDefaults), {}, {
      flatData: flatData
    }))).toEqual(expected);
  };

  it('should handle empty data', function () {
    [{
      flatData: [],
      expected: []
    }, {
      flatData: null,
      expected: []
    }, {
      flatData: undefined,
      expected: []
    }].forEach(checkFunction);
  });
  it('should handle [depth == 1] data', function () {
    [{
      flatData: [{
        key: 1,
        parentKey: rootKey
      }, {
        key: 2,
        parentKey: rootKey
      }],
      expected: [{
        key: 1,
        parentKey: rootKey
      }, {
        key: 2,
        parentKey: rootKey
      }]
    }, {
      flatData: [{
        key: '1',
        parentKey: rootKey
      }, {
        key: '2',
        parentKey: rootKey
      }],
      expected: [{
        key: '1',
        parentKey: rootKey
      }, {
        key: '2',
        parentKey: rootKey
      }]
    }].forEach(checkFunction);
  });
  it('should handle [depth == 2] data', function () {
    [{
      flatData: [{
        key: 1,
        parentKey: rootKey
      }, {
        key: 2,
        parentKey: 1
      }],
      expected: [{
        key: 1,
        parentKey: rootKey,
        children: [{
          key: 2,
          parentKey: 1
        }]
      }]
    }, {
      flatData: [{
        key: '1',
        parentKey: rootKey
      }, {
        key: '2',
        parentKey: '1'
      }],
      expected: [{
        key: '1',
        parentKey: rootKey,
        children: [{
          key: '2',
          parentKey: '1'
        }]
      }]
    }].forEach(checkFunction);
  });
  it('should handle [depth > 2] nested data', function () {
    [{
      flatData: [{
        key: 3,
        parentKey: 2
      }, {
        key: 1,
        parentKey: rootKey
      }, {
        key: 2,
        parentKey: 1
      }],
      expected: [{
        key: 1,
        parentKey: rootKey,
        children: [{
          key: 2,
          parentKey: 1,
          children: [{
            key: 3,
            parentKey: 2
          }]
        }]
      }]
    }, {
      flatData: [{
        key: 4,
        parentKey: 2
      }, {
        key: 3,
        parentKey: 2
      }, {
        key: 7,
        parentKey: rootKey
      }, {
        key: 1,
        parentKey: rootKey
      }, {
        key: 2,
        parentKey: 1
      }, {
        key: 6,
        parentKey: 1
      }],
      expected: [{
        key: 7,
        parentKey: rootKey
      }, {
        key: 1,
        parentKey: rootKey,
        children: [{
          key: 2,
          parentKey: 1,
          children: [{
            key: 4,
            parentKey: 2
          }, {
            key: 3,
            parentKey: 2
          }]
        }, {
          key: 6,
          parentKey: 1
        }]
      }]
    }].forEach(checkFunction);
  });
});
describe('map', function () {
  var checkFunction = function checkFunction(_ref11) {
    var treeData = _ref11.treeData,
        getNodeKey = _ref11.getNodeKey,
        callback = _ref11.callback,
        ignoreCollapsed = _ref11.ignoreCollapsed,
        expected = _ref11.expected;
    expect((0, _treeDataUtils.map)({
      treeData: treeData,
      getNodeKey: getNodeKey,
      callback: callback,
      ignoreCollapsed: ignoreCollapsed
    })).toEqual(expected);
  };

  it('should handle empty data', function () {
    [{
      treeData: [],
      getNodeKey: keyFromKey,
      callback: function callback(_ref12) {
        var node = _ref12.node;
        return node;
      },
      expected: []
    }, {
      treeData: null,
      getNodeKey: keyFromKey,
      callback: function callback(_ref13) {
        var node = _ref13.node;
        return node;
      },
      expected: []
    }, {
      treeData: undefined,
      getNodeKey: keyFromKey,
      callback: function callback(_ref14) {
        var node = _ref14.node;
        return node;
      },
      expected: []
    }].forEach(checkFunction);
  });
  it('can return tree as-is', function () {
    [{
      getNodeKey: keyFromKey,
      callback: function callback(_ref15) {
        var node = _ref15.node;
        return node;
      },
      treeData: [{
        key: 1
      }, {
        key: 2
      }],
      expected: [{
        key: 1
      }, {
        key: 2
      }]
    }, {
      getNodeKey: keyFromKey,
      callback: function callback(_ref16) {
        var node = _ref16.node;
        return node;
      },
      treeData: [{
        key: 1,
        children: [{
          key: 2
        }]
      }],
      expected: [{
        key: 1,
        children: [{
          key: 2
        }]
      }]
    }, {
      getNodeKey: keyFromKey,
      callback: function callback(_ref17) {
        var node = _ref17.node;
        return node;
      },
      treeData: [{
        key: 1,
        children: [{
          key: 12,
          children: [{
            key: 3
          }]
        }, {
          key: 4
        }]
      }, {
        key: 5
      }],
      expected: [{
        key: 1,
        children: [{
          key: 12,
          children: [{
            key: 3
          }]
        }, {
          key: 4
        }]
      }, {
        key: 5
      }]
    }].forEach(checkFunction);
  });
  it('can truncate part of the tree', function () {
    [{
      getNodeKey: keyFromKey,
      callback: function callback(_ref18) {
        var node = _ref18.node;
        return node.key === 1 ? _objectSpread(_objectSpread({}, node), {}, {
          children: []
        }) : node;
      },
      treeData: [{
        key: 1,
        children: [{
          key: 12,
          children: [{
            key: 3
          }]
        }, {
          key: 4
        }]
      }, {
        key: 5
      }],
      expected: [{
        key: 1,
        children: []
      }, {
        key: 5
      }]
    }].forEach(checkFunction);
  });
  it('can get parents', function () {
    checkFunction({
      getNodeKey: keyFromKey,
      callback: function callback(_ref19) {
        var node = _ref19.node,
            parentNode = _ref19.parentNode;
        return _objectSpread(_objectSpread({}, node), {}, {
          parentKey: parentNode ? parentNode.key : null
        });
      },
      ignoreCollapsed: false,
      treeData: [{
        key: 1,
        children: [{
          key: 12,
          children: [{
            key: 3
          }]
        }, {
          key: 4
        }]
      }, {
        key: 5
      }],
      expected: [{
        key: 1,
        parentKey: null,
        children: [{
          key: 12,
          parentKey: 1,
          children: [{
            key: 3,
            parentKey: 12
          }]
        }, {
          key: 4,