@reltio/components 1.4.2091 → 1.4.2093

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/package.json +2 -2
  2. package/ReactSortableTree/ReactSortableTree.test.d.ts +0 -1
  3. package/ReactSortableTree/ReactSortableTree.test.js +0 -473
  4. package/cjs/ReactSortableTree/ReactSortableTree.test.d.ts +0 -1
  5. package/cjs/ReactSortableTree/ReactSortableTree.test.js +0 -501
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@reltio/components",
3
- "version": "1.4.2091",
3
+ "version": "1.4.2093",
4
4
  "license": "SEE LICENSE IN LICENSE FILE",
5
5
  "main": "./cjs/index.js",
6
6
  "module": "./index.js",
@@ -11,7 +11,7 @@
11
11
  "@fluentui/react-context-selector": "^9.1.26",
12
12
  "@googlemaps/markerclusterer": "^2.5.3",
13
13
  "@react-sigma/core": "3.4.0",
14
- "@reltio/mdm-sdk": "^1.4.1930",
14
+ "@reltio/mdm-sdk": "^1.4.1931",
15
15
  "@vis.gl/react-google-maps": "^1.3.0",
16
16
  "d3-cloud": "^1.2.5",
17
17
  "d3-geo": "^2.0.1",
package/ReactSortableTree/ReactSortableTree.test.d.ts DELETED
@@ -1 +0,0 @@
1
- export {};
package/ReactSortableTree/ReactSortableTree.test.js DELETED
@@ -1,473 +0,0 @@
1
- var __extends = (this && this.__extends) || (function () {
2
- var extendStatics = function (d, b) {
3
- extendStatics = Object.setPrototypeOf ||
4
- ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
5
- function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
6
- return extendStatics(d, b);
7
- };
8
- return function (d, b) {
9
- if (typeof b !== "function" && b !== null)
10
- throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
11
- extendStatics(d, b);
12
- function __() { this.constructor = d; }
13
- d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
14
- };
15
- })();
16
- var __assign = (this && this.__assign) || function () {
17
- __assign = Object.assign || function(t) {
18
- for (var s, i = 1, n = arguments.length; i < n; i++) {
19
- s = arguments[i];
20
- for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
21
- t[p] = s[p];
22
- }
23
- return t;
24
- };
25
- return __assign.apply(this, arguments);
26
- };
27
- var __rest = (this && this.__rest) || function (s, e) {
28
- var t = {};
29
- for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
30
- t[p] = s[p];
31
- if (s != null && typeof Object.getOwnPropertySymbols === "function")
32
- for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
33
- if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
34
- t[p[i]] = s[p[i]];
35
- }
36
- return t;
37
- };
38
- import React, { Component } from 'react';
39
- import { act } from 'react-dom/test-utils';
40
- import PropTypes from 'prop-types';
41
- import { mount } from 'enzyme';
42
- import { List } from 'react-virtualized';
43
- import { DndProvider, DndContext } from 'react-dnd';
44
- import TestBackend from 'react-dnd-test-backend';
45
- import HTML5Backend from 'react-dnd-html5-backend';
46
- import TouchBackend from 'react-dnd-touch-backend';
47
- import SortableTree from './ReactSortableTree';
48
- import { TreeNode } from './components/TreeNode';
49
- import { NodeRendererDefault as DefaultNodeRenderer } from './components/NodeRendererDefault';
50
- var SortableTreeWithDndTestBackend = function (_a) {
51
- var _b = _a.dndManagerRef, dndManagerRef = _b === void 0 ? { current: null } : _b, treeProps = __rest(_a, ["dndManagerRef"]);
52
- return (React.createElement(DndProvider, { backend: TestBackend },
53
- React.createElement(DndContext.Consumer, null, function (_a) {
54
- var dragDropManager = _a.dragDropManager;
55
- dndManagerRef.current = dragDropManager;
56
- }),
57
- React.createElement(SortableTree, __assign({}, treeProps))));
58
- };
59
- SortableTreeWithDndTestBackend.propTypes = {
60
- dndManagerRef: PropTypes.object,
61
- treeProps: PropTypes.shape({
62
- current: PropTypes.object
63
- })
64
- };
65
- jest.mock('frontend-collective-react-dnd-scrollzone', function () { return (__assign(__assign({}, jest.requireActual('frontend-collective-react-dnd-scrollzone')), { createScrollingComponent: function (component) { return component; } })); });
66
- describe('<SortableTree />', function () {
67
- beforeAll(function () {
68
- jest.useFakeTimers();
69
- });
70
- it('loads using SortableTree second case', function () {
71
- var onDragStateChanged = jest.fn();
72
- var treeData = [{ title: 'a' }, { title: 'b' }];
73
- var manager = null;
74
- var wrapper = mount(React.createElement(DndProvider, { backend: TestBackend },
75
- React.createElement(DndContext.Consumer, null, function (_a) {
76
- var dragDropManager = _a.dragDropManager;
77
- manager = dragDropManager;
78
- }),
79
- React.createElement(SortableTree, { treeData: treeData, onDragStateChanged: onDragStateChanged, onChange: function () { } })));
80
- // Obtain a reference to the backend
81
- var backend = manager.getBackend();
82
- // Retrieve our DnD-wrapped node component type
83
- var wrappedNodeType = wrapper.find('ReactSortableTree').instance().nodeContentRenderer;
84
- // And get the first such component
85
- var nodeInstance = wrapper.find(wrappedNodeType).first().instance();
86
- backend.simulateBeginDrag([nodeInstance.getHandlerId()]);
87
- expect(onDragStateChanged).toHaveBeenCalledWith({
88
- isDragging: true,
89
- draggedNode: treeData[0]
90
- });
91
- backend.simulateEndDrag([nodeInstance.getHandlerId()]);
92
- expect(onDragStateChanged).toHaveBeenCalledWith({
93
- isDragging: false,
94
- draggedNode: null
95
- });
96
- expect(onDragStateChanged).toHaveBeenCalledTimes(2);
97
- });
98
- describe('dnd behaviour', function () {
99
- var getReactSortableTreeInstance = function (wrapper) { return wrapper.find('ReactSortableTree').instance(); };
100
- beforeEach(function () {
101
- jest.spyOn(window, 'requestAnimationFrame').mockImplementation(function (cb) { return cb(); });
102
- });
103
- it('should suppress errors for nonexistent nodes when the drag-and-drop.', function () {
104
- var onDragStateChanged = jest.fn();
105
- var treeData = [
106
- {
107
- title: 'a',
108
- expanded: true,
109
- children: [
110
- {
111
- title: 'a.0',
112
- expanded: false,
113
- children: [
114
- {
115
- title: 'a.0.0',
116
- expanded: false,
117
- children: [
118
- {
119
- title: 'a.0.0.1'
120
- }
121
- ]
122
- }
123
- ]
124
- }
125
- ]
126
- },
127
- { title: 'b' }
128
- ];
129
- var manager = { current: null };
130
- var defaultTreeProps = {
131
- onDragStateChanged: onDragStateChanged,
132
- onChange: function () { }
133
- };
134
- var wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, __assign({ dndManagerRef: manager, treeData: treeData }, defaultTreeProps)));
135
- var backend = manager.current.getBackend();
136
- var monitor = manager.current.getMonitor();
137
- var sourceNodeType = wrapper.find('ReactSortableTree').instance().nodeContentRenderer;
138
- var targetNodeType = wrapper.find('ReactSortableTree').instance().treeNodeRenderer;
139
- var getLastNodeHandlerId = function () { return wrapper.find(targetNodeType).last().instance().getHandlerId(); };
140
- var sourceNodeInstance = wrapper.find(sourceNodeType).last().instance();
141
- act(function () {
142
- backend.simulateBeginDrag([sourceNodeInstance.getHandlerId()]);
143
- });
144
- wrapper.update();
145
- jest.spyOn(monitor, 'getDifferenceFromInitialOffset').mockReturnValue({ x: 300 });
146
- act(function () {
147
- backend.simulateHover([wrapper.find(targetNodeType).at(1).instance().getHandlerId()]);
148
- });
149
- wrapper.update();
150
- act(function () {
151
- backend.simulateHover([getLastNodeHandlerId()]);
152
- });
153
- wrapper.update();
154
- act(function () {
155
- backend.simulateHover([getLastNodeHandlerId()]);
156
- });
157
- wrapper.update();
158
- wrapper.setProps({
159
- treeProps: __assign({ treeData: [
160
- {
161
- title: 'a',
162
- expanded: true,
163
- children: [
164
- {
165
- title: 'a.0',
166
- expanded: false
167
- }
168
- ]
169
- },
170
- { title: 'b' }
171
- ] }, defaultTreeProps)
172
- });
173
- backend.simulateEndDrag([sourceNodeInstance.getHandlerId()]);
174
- });
175
- it('should call hover handler once', function () {
176
- jest.spyOn(window, 'requestAnimationFrame').mockImplementation(function (cb) { return setTimeout(cb, 1); });
177
- var onDragStateChanged = jest.fn();
178
- var treeData = [{ title: 'a' }, { title: 'b' }];
179
- var manager = { current: null };
180
- var defaultTreeProps = {
181
- onDragStateChanged: onDragStateChanged,
182
- onChange: function () { }
183
- };
184
- var wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, __assign({ dndManagerRef: manager, treeData: treeData }, defaultTreeProps)));
185
- var backend = manager.current.getBackend();
186
- var monitor = manager.current.getMonitor();
187
- var treeInstance = getReactSortableTreeInstance(wrapper);
188
- var sourceNodeType = treeInstance.nodeContentRenderer;
189
- var targetNodeType = treeInstance.treeNodeRenderer;
190
- var dragHoverSpy = jest.spyOn(treeInstance, 'dragHover');
191
- var sourceNodeInstance = wrapper.find(sourceNodeType).last().instance();
192
- act(function () {
193
- backend.simulateBeginDrag([sourceNodeInstance.getHandlerId()]);
194
- });
195
- wrapper.update();
196
- jest.spyOn(monitor, 'getDifferenceFromInitialOffset').mockReturnValue({ x: 300 });
197
- expect(dragHoverSpy).toHaveBeenCalledTimes(0);
198
- act(function () {
199
- backend.simulateHover([wrapper.find(targetNodeType).last().instance().getHandlerId()]);
200
- });
201
- act(function () {
202
- backend.simulateHover([wrapper.find(targetNodeType).last().instance().getHandlerId()]);
203
- });
204
- expect(dragHoverSpy).toHaveBeenCalledTimes(0);
205
- jest.runAllTimers();
206
- expect(dragHoverSpy).toHaveBeenCalledTimes(1);
207
- act(function () {
208
- backend.simulateEndDrag();
209
- });
210
- });
211
- it('should cancel hover handler after end drag', function () {
212
- jest.spyOn(window, 'requestAnimationFrame').mockImplementation(function (cb) { return setTimeout(cb, 1); });
213
- jest.spyOn(window, 'cancelAnimationFrame').mockImplementation(function (id) { return clearTimeout(id); });
214
- var onDragStateChanged = jest.fn();
215
- var treeData = [{ title: 'a' }, { title: 'b' }];
216
- var manager = { current: null };
217
- var defaultTreeProps = {
218
- onDragStateChanged: onDragStateChanged,
219
- onChange: function () { }
220
- };
221
- var wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, __assign({ dndManagerRef: manager, treeData: treeData }, defaultTreeProps)));
222
- var backend = manager.current.getBackend();
223
- var monitor = manager.current.getMonitor();
224
- var treeInstance = getReactSortableTreeInstance(wrapper);
225
- var sourceNodeType = treeInstance.nodeContentRenderer;
226
- var targetNodeType = treeInstance.treeNodeRenderer;
227
- var dragHoverSpy = jest.spyOn(treeInstance, 'dragHover');
228
- var sourceNodeInstance = wrapper.find(sourceNodeType).last().instance();
229
- act(function () {
230
- backend.simulateBeginDrag([sourceNodeInstance.getHandlerId()]);
231
- });
232
- wrapper.update();
233
- jest.spyOn(monitor, 'getDifferenceFromInitialOffset').mockReturnValue({ x: 300 });
234
- expect(dragHoverSpy).toHaveBeenCalledTimes(0);
235
- act(function () {
236
- backend.simulateHover([wrapper.find(targetNodeType).last().instance().getHandlerId()]);
237
- });
238
- act(function () {
239
- backend.simulateHover([wrapper.find(targetNodeType).last().instance().getHandlerId()]);
240
- });
241
- expect(dragHoverSpy).toHaveBeenCalledTimes(0);
242
- act(function () {
243
- backend.simulateDrop();
244
- backend.simulateEndDrag();
245
- });
246
- expect(dragHoverSpy).toHaveBeenCalledTimes(0);
247
- jest.runAllTimers();
248
- expect(dragHoverSpy).toHaveBeenCalledTimes(0);
249
- });
250
- });
251
- it('should render nodes for flat data', function () {
252
- var wrapper;
253
- // No nodes
254
- wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [], onChange: function () { } }));
255
- expect(wrapper.find(TreeNode).length).toEqual(0);
256
- // Single node
257
- wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{}], onChange: function () { } }));
258
- expect(wrapper.find(TreeNode).length).toEqual(1);
259
- // Two nodes
260
- wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{}, {}], onChange: function () { } }));
261
- expect(wrapper.find(TreeNode).length).toEqual(2);
262
- });
263
- it('should render nodes for nested, expanded data', function () {
264
- var wrapper;
265
- // Single Nested
266
- wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{ expanded: true, children: [{}] }], onChange: function () { } }));
267
- expect(wrapper.find(TreeNode).length).toEqual(2);
268
- // Double Nested
269
- wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{ expanded: true, children: [{ expanded: true, children: [{}] }] }], onChange: function () { } }));
270
- expect(wrapper.find(TreeNode).length).toEqual(3);
271
- // 2x Double Nested Siblings
272
- wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [
273
- { expanded: true, children: [{ expanded: true, children: [{}] }] },
274
- { expanded: true, children: [{ expanded: true, children: [{}] }] }
275
- ], onChange: function () { } }));
276
- expect(wrapper.find(TreeNode).length).toEqual(6);
277
- });
278
- it('should render nodes for nested, collapsed data', function () {
279
- var wrapper;
280
- // Single Nested
281
- wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{ expanded: false, children: [{}] }], onChange: function () { } }));
282
- expect(wrapper.find(TreeNode).length).toEqual(1);
283
- // Double Nested
284
- wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{ expanded: false, children: [{ expanded: false, children: [{}] }] }], onChange: function () { } }));
285
- expect(wrapper.find(TreeNode).length).toEqual(1);
286
- // 2x Double Nested Siblings, top level of first expanded
287
- wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [
288
- { expanded: true, children: [{ expanded: false, children: [{}] }] },
289
- { expanded: false, children: [{ expanded: false, children: [{}] }] }
290
- ], onChange: function () { } }));
291
- expect(wrapper.find(TreeNode).length).toEqual(3);
292
- });
293
- it('should reveal hidden nodes when visibility toggled', function () {
294
- var wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a', children: [{ title: 'b' }] }], onChange: function (treeData) { return wrapper.setProps({ treeData: treeData }); } }));
295
- // Check nodes in collapsed state
296
- expect(wrapper.find(TreeNode).length).toEqual(1);
297
- // Expand node and check for the existence of the revealed child
298
- wrapper.find('.rst__expandButton').first().simulate('click');
299
- expect(wrapper.find(TreeNode).length).toEqual(2);
300
- // Collapse node and make sure the child has been hidden
301
- wrapper.find('.rst__collapseButton').first().simulate('click');
302
- expect(wrapper.find(TreeNode).length).toEqual(1);
303
- });
304
- it('should change outer wrapper style via `style` and `className` props', function () {
305
- var wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a' }], onChange: function () { }, style: { borderWidth: 42 }, className: "extra-classy" }));
306
- expect(wrapper.find('.rst__tree').prop('style').borderWidth).toBe(42);
307
- expect(wrapper.find('.rst__tree')).toHaveClassName('extra-classy');
308
- });
309
- it('should change style of scroll container with `innerStyle` prop', function () {
310
- var wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a' }], onChange: function () { }, innerStyle: { borderWidth: 42 } }));
311
- expect(wrapper.find(List).first().prop('style').borderWidth).toBe(42);
312
- });
313
- it('should change height according to rowHeight prop', function () {
314
- var wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a' }, { title: 'b', extraHeight: 2 }], onChange: function () { }, rowHeight: 12 }));
315
- // Works with static value
316
- expect(wrapper.find(TreeNode).first().prop('style').height).toBe(12);
317
- // Works with function callback
318
- wrapper.setProps({ rowHeight: function (_a) {
319
- var node = _a.node;
320
- return 42 + (node.extraHeight || 0);
321
- } });
322
- expect(wrapper.find(TreeNode).first().prop('style').height).toBe(42);
323
- expect(wrapper.find(TreeNode).last().prop('style').height).toBe(44);
324
- });
325
- it('should toggle virtualization according to isVirtualized prop', function () {
326
- var virtualized = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a' }, { title: 'b' }], onChange: function () { }, isVirtualized: true }));
327
- expect(virtualized.find(List).length).toEqual(1);
328
- var notVirtualized = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a' }, { title: 'b' }], onChange: function () { }, isVirtualized: false }));
329
- expect(notVirtualized.find(List).length).toEqual(0);
330
- });
331
- it('should change scaffold width according to scaffoldBlockPxWidth prop', function () {
332
- var wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a' }], onChange: function () { }, scaffoldBlockPxWidth: 12 }));
333
- expect(wrapper.find('.rst__lineBlock').prop('style').width).toBe(12);
334
- });
335
- it('should pass props to the node renderer from `generateNodeProps`', function () {
336
- var title = 42;
337
- var wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: title }], onChange: function () { }, generateNodeProps: function (_a) {
338
- var node = _a.node;
339
- return ({ buttons: [node.title] });
340
- } }));
341
- expect(wrapper.find(DefaultNodeRenderer)).toHaveProp('buttons', [title]);
342
- });
343
- it('should call the callback in `onVisibilityToggle` when visibility toggled', function () {
344
- var out = null;
345
- var wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a', children: [{ title: 'b' }] }], onChange: function (treeData) { return wrapper.setProps({ treeData: treeData }); }, onVisibilityToggle: function (_a) {
346
- var expanded = _a.expanded;
347
- out = expanded ? 'expanded' : 'collapsed';
348
- } }));
349
- wrapper.find('.rst__expandButton').first().simulate('click');
350
- expect(out).toEqual('expanded');
351
- wrapper.find('.rst__collapseButton').first().simulate('click');
352
- expect(out).toEqual('collapsed');
353
- });
354
- it('should render with a custom `nodeContentRenderer`', function () {
355
- var FakeNode = /** @class */ (function (_super) {
356
- __extends(FakeNode, _super);
357
- function FakeNode() {
358
- return _super !== null && _super.apply(this, arguments) || this;
359
- }
360
- FakeNode.prototype.render = function () {
361
- return React.createElement("div", null, this.props.node.title);
362
- };
363
- return FakeNode;
364
- }(Component));
365
- FakeNode.propTypes = {
366
- node: PropTypes.shape({ title: PropTypes.string }).isRequired
367
- };
368
- var wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a' }], onChange: function () { }, nodeContentRenderer: FakeNode }));
369
- expect(wrapper.find(FakeNode).length).toEqual(1);
370
- });
371
- it('search should call searchFinishCallback', function () {
372
- var searchFinishCallback = jest.fn();
373
- mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a', children: [{ title: 'b' }] }], searchQuery: "b", searchFocusOffset: 0, searchFinishCallback: searchFinishCallback, onChange: function () { } }));
374
- expect(searchFinishCallback).toHaveBeenCalledWith([
375
- // Node should be found expanded
376
- { node: { title: 'b' }, path: [0, 1], treeIndex: 1 }
377
- ]);
378
- });
379
- it('search should expand all matches and seek out the focus offset', function () {
380
- var wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [
381
- { title: 'a', children: [{ title: 'b' }] },
382
- { title: 'a', children: [{ title: 'be' }] }
383
- ], searchQuery: "b", onChange: function () { } }));
384
- var tree = wrapper.find('ReactSortableTree').instance();
385
- expect(tree.state.searchMatches).toEqual([
386
- { node: { title: 'b' }, path: [0, 1], treeIndex: 1 },
387
- { node: { title: 'be' }, path: [2, 3], treeIndex: 3 }
388
- ]);
389
- expect(tree.state.searchFocusTreeIndex).toEqual(null);
390
- wrapper.setProps({ searchFocusOffset: 0 });
391
- expect(tree.state.searchFocusTreeIndex).toEqual(1);
392
- wrapper.setProps({ searchFocusOffset: 1 });
393
- // As the empty `onChange` we use here doesn't actually change
394
- // the tree, the expansion of all nodes doesn't get preserved
395
- // after the first mount, and this change in searchFocusOffset
396
- // only triggers the opening of a single path.
397
- // Therefore it's 2 instead of 3.
398
- expect(tree.state.searchFocusTreeIndex).toEqual(2);
399
- });
400
- it('search onlyExpandSearchedNodes should collapse all nodes except matches', function () {
401
- var wrapper = mount(React.createElement(SortableTreeWithDndTestBackend, { treeData: [
402
- {
403
- title: 'a',
404
- children: [{ title: 'b', children: [{ title: 'c' }] }]
405
- },
406
- {
407
- title: 'b',
408
- children: [{ title: 'd', children: [{ title: 'be' }] }]
409
- },
410
- {
411
- title: 'c',
412
- children: [{ title: 'f', children: [{ title: 'dd' }] }]
413
- }
414
- ], onChange: function (treeData) { return wrapper.setProps({ treeData: treeData }); }, onlyExpandSearchedNodes: true }));
415
- wrapper.setProps({ searchQuery: 'be' });
416
- expect(wrapper.prop('treeData')).toEqual([
417
- {
418
- title: 'a',
419
- children: [
420
- {
421
- title: 'b',
422
- children: [
423
- {
424
- title: 'c',
425
- expanded: false
426
- }
427
- ],
428
- expanded: false
429
- }
430
- ],
431
- expanded: false
432
- },
433
- {
434
- title: 'b',
435
- children: [
436
- {
437
- title: 'd',
438
- children: [
439
- {
440
- title: 'be',
441
- expanded: false
442
- }
443
- ],
444
- expanded: true
445
- }
446
- ],
447
- expanded: true
448
- },
449
- {
450
- title: 'c',
451
- children: [
452
- {
453
- title: 'f',
454
- children: [
455
- {
456
- title: 'dd',
457
- expanded: false
458
- }
459
- ],
460
- expanded: false
461
- }
462
- ],
463
- expanded: false
464
- }
465
- ]);
466
- });
467
- it('should work with different dnd backends', function () {
468
- expect(mount(React.createElement(DndProvider, { backend: HTML5Backend },
469
- React.createElement(SortableTree, { treeData: [{ title: 'a' }], onChange: function () { } })))).toBeDefined();
470
- expect(mount(React.createElement(DndProvider, { backend: TouchBackend },
471
- React.createElement(SortableTree, { treeData: [{ title: 'a' }], onChange: function () { } })))).toBeDefined();
472
- });
473
- });
package/cjs/ReactSortableTree/ReactSortableTree.test.d.ts DELETED
@@ -1 +0,0 @@
1
- export {};
package/cjs/ReactSortableTree/ReactSortableTree.test.js DELETED
@@ -1,501 +0,0 @@
1
- "use strict";
2
- var __extends = (this && this.__extends) || (function () {
3
- var extendStatics = function (d, b) {
4
- extendStatics = Object.setPrototypeOf ||
5
- ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
6
- function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
7
- return extendStatics(d, b);
8
- };
9
- return function (d, b) {
10
- if (typeof b !== "function" && b !== null)
11
- throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
12
- extendStatics(d, b);
13
- function __() { this.constructor = d; }
14
- d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
15
- };
16
- })();
17
- var __assign = (this && this.__assign) || function () {
18
- __assign = Object.assign || function(t) {
19
- for (var s, i = 1, n = arguments.length; i < n; i++) {
20
- s = arguments[i];
21
- for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
22
- t[p] = s[p];
23
- }
24
- return t;
25
- };
26
- return __assign.apply(this, arguments);
27
- };
28
- var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
29
- if (k2 === undefined) k2 = k;
30
- var desc = Object.getOwnPropertyDescriptor(m, k);
31
- if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
32
- desc = { enumerable: true, get: function() { return m[k]; } };
33
- }
34
- Object.defineProperty(o, k2, desc);
35
- }) : (function(o, m, k, k2) {
36
- if (k2 === undefined) k2 = k;
37
- o[k2] = m[k];
38
- }));
39
- var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
40
- Object.defineProperty(o, "default", { enumerable: true, value: v });
41
- }) : function(o, v) {
42
- o["default"] = v;
43
- });
44
- var __importStar = (this && this.__importStar) || function (mod) {
45
- if (mod && mod.__esModule) return mod;
46
- var result = {};
47
- if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
48
- __setModuleDefault(result, mod);
49
- return result;
50
- };
51
- var __rest = (this && this.__rest) || function (s, e) {
52
- var t = {};
53
- for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
54
- t[p] = s[p];
55
- if (s != null && typeof Object.getOwnPropertySymbols === "function")
56
- for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
57
- if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
58
- t[p[i]] = s[p[i]];
59
- }
60
- return t;
61
- };
62
- var __importDefault = (this && this.__importDefault) || function (mod) {
63
- return (mod && mod.__esModule) ? mod : { "default": mod };
64
- };
65
- Object.defineProperty(exports, "__esModule", { value: true });
66
- var react_1 = __importStar(require("react"));
67
- var test_utils_1 = require("react-dom/test-utils");
68
- var prop_types_1 = __importDefault(require("prop-types"));
69
- var enzyme_1 = require("enzyme");
70
- var react_virtualized_1 = require("react-virtualized");
71
- var react_dnd_1 = require("react-dnd");
72
- var react_dnd_test_backend_1 = __importDefault(require("react-dnd-test-backend"));
73
- var react_dnd_html5_backend_1 = __importDefault(require("react-dnd-html5-backend"));
74
- var react_dnd_touch_backend_1 = __importDefault(require("react-dnd-touch-backend"));
75
- var ReactSortableTree_1 = __importDefault(require("./ReactSortableTree"));
76
- var TreeNode_1 = require("./components/TreeNode");
77
- var NodeRendererDefault_1 = require("./components/NodeRendererDefault");
78
- var SortableTreeWithDndTestBackend = function (_a) {
79
- var _b = _a.dndManagerRef, dndManagerRef = _b === void 0 ? { current: null } : _b, treeProps = __rest(_a, ["dndManagerRef"]);
80
- return (react_1.default.createElement(react_dnd_1.DndProvider, { backend: react_dnd_test_backend_1.default },
81
- react_1.default.createElement(react_dnd_1.DndContext.Consumer, null, function (_a) {
82
- var dragDropManager = _a.dragDropManager;
83
- dndManagerRef.current = dragDropManager;
84
- }),
85
- react_1.default.createElement(ReactSortableTree_1.default, __assign({}, treeProps))));
86
- };
87
- SortableTreeWithDndTestBackend.propTypes = {
88
- dndManagerRef: prop_types_1.default.object,
89
- treeProps: prop_types_1.default.shape({
90
- current: prop_types_1.default.object
91
- })
92
- };
93
- jest.mock('frontend-collective-react-dnd-scrollzone', function () { return (__assign(__assign({}, jest.requireActual('frontend-collective-react-dnd-scrollzone')), { createScrollingComponent: function (component) { return component; } })); });
94
- describe('<SortableTree />', function () {
95
- beforeAll(function () {
96
- jest.useFakeTimers();
97
- });
98
- it('loads using SortableTree second case', function () {
99
- var onDragStateChanged = jest.fn();
100
- var treeData = [{ title: 'a' }, { title: 'b' }];
101
- var manager = null;
102
- var wrapper = (0, enzyme_1.mount)(react_1.default.createElement(react_dnd_1.DndProvider, { backend: react_dnd_test_backend_1.default },
103
- react_1.default.createElement(react_dnd_1.DndContext.Consumer, null, function (_a) {
104
- var dragDropManager = _a.dragDropManager;
105
- manager = dragDropManager;
106
- }),
107
- react_1.default.createElement(ReactSortableTree_1.default, { treeData: treeData, onDragStateChanged: onDragStateChanged, onChange: function () { } })));
108
- // Obtain a reference to the backend
109
- var backend = manager.getBackend();
110
- // Retrieve our DnD-wrapped node component type
111
- var wrappedNodeType = wrapper.find('ReactSortableTree').instance().nodeContentRenderer;
112
- // And get the first such component
113
- var nodeInstance = wrapper.find(wrappedNodeType).first().instance();
114
- backend.simulateBeginDrag([nodeInstance.getHandlerId()]);
115
- expect(onDragStateChanged).toHaveBeenCalledWith({
116
- isDragging: true,
117
- draggedNode: treeData[0]
118
- });
119
- backend.simulateEndDrag([nodeInstance.getHandlerId()]);
120
- expect(onDragStateChanged).toHaveBeenCalledWith({
121
- isDragging: false,
122
- draggedNode: null
123
- });
124
- expect(onDragStateChanged).toHaveBeenCalledTimes(2);
125
- });
126
- describe('dnd behaviour', function () {
127
- var getReactSortableTreeInstance = function (wrapper) { return wrapper.find('ReactSortableTree').instance(); };
128
- beforeEach(function () {
129
- jest.spyOn(window, 'requestAnimationFrame').mockImplementation(function (cb) { return cb(); });
130
- });
131
- it('should suppress errors for nonexistent nodes when the drag-and-drop.', function () {
132
- var onDragStateChanged = jest.fn();
133
- var treeData = [
134
- {
135
- title: 'a',
136
- expanded: true,
137
- children: [
138
- {
139
- title: 'a.0',
140
- expanded: false,
141
- children: [
142
- {
143
- title: 'a.0.0',
144
- expanded: false,
145
- children: [
146
- {
147
- title: 'a.0.0.1'
148
- }
149
- ]
150
- }
151
- ]
152
- }
153
- ]
154
- },
155
- { title: 'b' }
156
- ];
157
- var manager = { current: null };
158
- var defaultTreeProps = {
159
- onDragStateChanged: onDragStateChanged,
160
- onChange: function () { }
161
- };
162
- var wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, __assign({ dndManagerRef: manager, treeData: treeData }, defaultTreeProps)));
163
- var backend = manager.current.getBackend();
164
- var monitor = manager.current.getMonitor();
165
- var sourceNodeType = wrapper.find('ReactSortableTree').instance().nodeContentRenderer;
166
- var targetNodeType = wrapper.find('ReactSortableTree').instance().treeNodeRenderer;
167
- var getLastNodeHandlerId = function () { return wrapper.find(targetNodeType).last().instance().getHandlerId(); };
168
- var sourceNodeInstance = wrapper.find(sourceNodeType).last().instance();
169
- (0, test_utils_1.act)(function () {
170
- backend.simulateBeginDrag([sourceNodeInstance.getHandlerId()]);
171
- });
172
- wrapper.update();
173
- jest.spyOn(monitor, 'getDifferenceFromInitialOffset').mockReturnValue({ x: 300 });
174
- (0, test_utils_1.act)(function () {
175
- backend.simulateHover([wrapper.find(targetNodeType).at(1).instance().getHandlerId()]);
176
- });
177
- wrapper.update();
178
- (0, test_utils_1.act)(function () {
179
- backend.simulateHover([getLastNodeHandlerId()]);
180
- });
181
- wrapper.update();
182
- (0, test_utils_1.act)(function () {
183
- backend.simulateHover([getLastNodeHandlerId()]);
184
- });
185
- wrapper.update();
186
- wrapper.setProps({
187
- treeProps: __assign({ treeData: [
188
- {
189
- title: 'a',
190
- expanded: true,
191
- children: [
192
- {
193
- title: 'a.0',
194
- expanded: false
195
- }
196
- ]
197
- },
198
- { title: 'b' }
199
- ] }, defaultTreeProps)
200
- });
201
- backend.simulateEndDrag([sourceNodeInstance.getHandlerId()]);
202
- });
203
- it('should call hover handler once', function () {
204
- jest.spyOn(window, 'requestAnimationFrame').mockImplementation(function (cb) { return setTimeout(cb, 1); });
205
- var onDragStateChanged = jest.fn();
206
- var treeData = [{ title: 'a' }, { title: 'b' }];
207
- var manager = { current: null };
208
- var defaultTreeProps = {
209
- onDragStateChanged: onDragStateChanged,
210
- onChange: function () { }
211
- };
212
- var wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, __assign({ dndManagerRef: manager, treeData: treeData }, defaultTreeProps)));
213
- var backend = manager.current.getBackend();
214
- var monitor = manager.current.getMonitor();
215
- var treeInstance = getReactSortableTreeInstance(wrapper);
216
- var sourceNodeType = treeInstance.nodeContentRenderer;
217
- var targetNodeType = treeInstance.treeNodeRenderer;
218
- var dragHoverSpy = jest.spyOn(treeInstance, 'dragHover');
219
- var sourceNodeInstance = wrapper.find(sourceNodeType).last().instance();
220
- (0, test_utils_1.act)(function () {
221
- backend.simulateBeginDrag([sourceNodeInstance.getHandlerId()]);
222
- });
223
- wrapper.update();
224
- jest.spyOn(monitor, 'getDifferenceFromInitialOffset').mockReturnValue({ x: 300 });
225
- expect(dragHoverSpy).toHaveBeenCalledTimes(0);
226
- (0, test_utils_1.act)(function () {
227
- backend.simulateHover([wrapper.find(targetNodeType).last().instance().getHandlerId()]);
228
- });
229
- (0, test_utils_1.act)(function () {
230
- backend.simulateHover([wrapper.find(targetNodeType).last().instance().getHandlerId()]);
231
- });
232
- expect(dragHoverSpy).toHaveBeenCalledTimes(0);
233
- jest.runAllTimers();
234
- expect(dragHoverSpy).toHaveBeenCalledTimes(1);
235
- (0, test_utils_1.act)(function () {
236
- backend.simulateEndDrag();
237
- });
238
- });
239
- it('should cancel hover handler after end drag', function () {
240
- jest.spyOn(window, 'requestAnimationFrame').mockImplementation(function (cb) { return setTimeout(cb, 1); });
241
- jest.spyOn(window, 'cancelAnimationFrame').mockImplementation(function (id) { return clearTimeout(id); });
242
- var onDragStateChanged = jest.fn();
243
- var treeData = [{ title: 'a' }, { title: 'b' }];
244
- var manager = { current: null };
245
- var defaultTreeProps = {
246
- onDragStateChanged: onDragStateChanged,
247
- onChange: function () { }
248
- };
249
- var wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, __assign({ dndManagerRef: manager, treeData: treeData }, defaultTreeProps)));
250
- var backend = manager.current.getBackend();
251
- var monitor = manager.current.getMonitor();
252
- var treeInstance = getReactSortableTreeInstance(wrapper);
253
- var sourceNodeType = treeInstance.nodeContentRenderer;
254
- var targetNodeType = treeInstance.treeNodeRenderer;
255
- var dragHoverSpy = jest.spyOn(treeInstance, 'dragHover');
256
- var sourceNodeInstance = wrapper.find(sourceNodeType).last().instance();
257
- (0, test_utils_1.act)(function () {
258
- backend.simulateBeginDrag([sourceNodeInstance.getHandlerId()]);
259
- });
260
- wrapper.update();
261
- jest.spyOn(monitor, 'getDifferenceFromInitialOffset').mockReturnValue({ x: 300 });
262
- expect(dragHoverSpy).toHaveBeenCalledTimes(0);
263
- (0, test_utils_1.act)(function () {
264
- backend.simulateHover([wrapper.find(targetNodeType).last().instance().getHandlerId()]);
265
- });
266
- (0, test_utils_1.act)(function () {
267
- backend.simulateHover([wrapper.find(targetNodeType).last().instance().getHandlerId()]);
268
- });
269
- expect(dragHoverSpy).toHaveBeenCalledTimes(0);
270
- (0, test_utils_1.act)(function () {
271
- backend.simulateDrop();
272
- backend.simulateEndDrag();
273
- });
274
- expect(dragHoverSpy).toHaveBeenCalledTimes(0);
275
- jest.runAllTimers();
276
- expect(dragHoverSpy).toHaveBeenCalledTimes(0);
277
- });
278
- });
279
- it('should render nodes for flat data', function () {
280
- var wrapper;
281
- // No nodes
282
- wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [], onChange: function () { } }));
283
- expect(wrapper.find(TreeNode_1.TreeNode).length).toEqual(0);
284
- // Single node
285
- wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{}], onChange: function () { } }));
286
- expect(wrapper.find(TreeNode_1.TreeNode).length).toEqual(1);
287
- // Two nodes
288
- wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{}, {}], onChange: function () { } }));
289
- expect(wrapper.find(TreeNode_1.TreeNode).length).toEqual(2);
290
- });
291
- it('should render nodes for nested, expanded data', function () {
292
- var wrapper;
293
- // Single Nested
294
- wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{ expanded: true, children: [{}] }], onChange: function () { } }));
295
- expect(wrapper.find(TreeNode_1.TreeNode).length).toEqual(2);
296
- // Double Nested
297
- wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{ expanded: true, children: [{ expanded: true, children: [{}] }] }], onChange: function () { } }));
298
- expect(wrapper.find(TreeNode_1.TreeNode).length).toEqual(3);
299
- // 2x Double Nested Siblings
300
- wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [
301
- { expanded: true, children: [{ expanded: true, children: [{}] }] },
302
- { expanded: true, children: [{ expanded: true, children: [{}] }] }
303
- ], onChange: function () { } }));
304
- expect(wrapper.find(TreeNode_1.TreeNode).length).toEqual(6);
305
- });
306
- it('should render nodes for nested, collapsed data', function () {
307
- var wrapper;
308
- // Single Nested
309
- wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{ expanded: false, children: [{}] }], onChange: function () { } }));
310
- expect(wrapper.find(TreeNode_1.TreeNode).length).toEqual(1);
311
- // Double Nested
312
- wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{ expanded: false, children: [{ expanded: false, children: [{}] }] }], onChange: function () { } }));
313
- expect(wrapper.find(TreeNode_1.TreeNode).length).toEqual(1);
314
- // 2x Double Nested Siblings, top level of first expanded
315
- wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [
316
- { expanded: true, children: [{ expanded: false, children: [{}] }] },
317
- { expanded: false, children: [{ expanded: false, children: [{}] }] }
318
- ], onChange: function () { } }));
319
- expect(wrapper.find(TreeNode_1.TreeNode).length).toEqual(3);
320
- });
321
- it('should reveal hidden nodes when visibility toggled', function () {
322
- var wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a', children: [{ title: 'b' }] }], onChange: function (treeData) { return wrapper.setProps({ treeData: treeData }); } }));
323
- // Check nodes in collapsed state
324
- expect(wrapper.find(TreeNode_1.TreeNode).length).toEqual(1);
325
- // Expand node and check for the existence of the revealed child
326
- wrapper.find('.rst__expandButton').first().simulate('click');
327
- expect(wrapper.find(TreeNode_1.TreeNode).length).toEqual(2);
328
- // Collapse node and make sure the child has been hidden
329
- wrapper.find('.rst__collapseButton').first().simulate('click');
330
- expect(wrapper.find(TreeNode_1.TreeNode).length).toEqual(1);
331
- });
332
- it('should change outer wrapper style via `style` and `className` props', function () {
333
- var wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a' }], onChange: function () { }, style: { borderWidth: 42 }, className: "extra-classy" }));
334
- expect(wrapper.find('.rst__tree').prop('style').borderWidth).toBe(42);
335
- expect(wrapper.find('.rst__tree')).toHaveClassName('extra-classy');
336
- });
337
- it('should change style of scroll container with `innerStyle` prop', function () {
338
- var wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a' }], onChange: function () { }, innerStyle: { borderWidth: 42 } }));
339
- expect(wrapper.find(react_virtualized_1.List).first().prop('style').borderWidth).toBe(42);
340
- });
341
- it('should change height according to rowHeight prop', function () {
342
- var wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a' }, { title: 'b', extraHeight: 2 }], onChange: function () { }, rowHeight: 12 }));
343
- // Works with static value
344
- expect(wrapper.find(TreeNode_1.TreeNode).first().prop('style').height).toBe(12);
345
- // Works with function callback
346
- wrapper.setProps({ rowHeight: function (_a) {
347
- var node = _a.node;
348
- return 42 + (node.extraHeight || 0);
349
- } });
350
- expect(wrapper.find(TreeNode_1.TreeNode).first().prop('style').height).toBe(42);
351
- expect(wrapper.find(TreeNode_1.TreeNode).last().prop('style').height).toBe(44);
352
- });
353
- it('should toggle virtualization according to isVirtualized prop', function () {
354
- var virtualized = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a' }, { title: 'b' }], onChange: function () { }, isVirtualized: true }));
355
- expect(virtualized.find(react_virtualized_1.List).length).toEqual(1);
356
- var notVirtualized = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a' }, { title: 'b' }], onChange: function () { }, isVirtualized: false }));
357
- expect(notVirtualized.find(react_virtualized_1.List).length).toEqual(0);
358
- });
359
- it('should change scaffold width according to scaffoldBlockPxWidth prop', function () {
360
- var wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a' }], onChange: function () { }, scaffoldBlockPxWidth: 12 }));
361
- expect(wrapper.find('.rst__lineBlock').prop('style').width).toBe(12);
362
- });
363
- it('should pass props to the node renderer from `generateNodeProps`', function () {
364
- var title = 42;
365
- var wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: title }], onChange: function () { }, generateNodeProps: function (_a) {
366
- var node = _a.node;
367
- return ({ buttons: [node.title] });
368
- } }));
369
- expect(wrapper.find(NodeRendererDefault_1.NodeRendererDefault)).toHaveProp('buttons', [title]);
370
- });
371
- it('should call the callback in `onVisibilityToggle` when visibility toggled', function () {
372
- var out = null;
373
- var wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a', children: [{ title: 'b' }] }], onChange: function (treeData) { return wrapper.setProps({ treeData: treeData }); }, onVisibilityToggle: function (_a) {
374
- var expanded = _a.expanded;
375
- out = expanded ? 'expanded' : 'collapsed';
376
- } }));
377
- wrapper.find('.rst__expandButton').first().simulate('click');
378
- expect(out).toEqual('expanded');
379
- wrapper.find('.rst__collapseButton').first().simulate('click');
380
- expect(out).toEqual('collapsed');
381
- });
382
- it('should render with a custom `nodeContentRenderer`', function () {
383
- var FakeNode = /** @class */ (function (_super) {
384
- __extends(FakeNode, _super);
385
- function FakeNode() {
386
- return _super !== null && _super.apply(this, arguments) || this;
387
- }
388
- FakeNode.prototype.render = function () {
389
- return react_1.default.createElement("div", null, this.props.node.title);
390
- };
391
- return FakeNode;
392
- }(react_1.Component));
393
- FakeNode.propTypes = {
394
- node: prop_types_1.default.shape({ title: prop_types_1.default.string }).isRequired
395
- };
396
- var wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a' }], onChange: function () { }, nodeContentRenderer: FakeNode }));
397
- expect(wrapper.find(FakeNode).length).toEqual(1);
398
- });
399
- it('search should call searchFinishCallback', function () {
400
- var searchFinishCallback = jest.fn();
401
- (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [{ title: 'a', children: [{ title: 'b' }] }], searchQuery: "b", searchFocusOffset: 0, searchFinishCallback: searchFinishCallback, onChange: function () { } }));
402
- expect(searchFinishCallback).toHaveBeenCalledWith([
403
- // Node should be found expanded
404
- { node: { title: 'b' }, path: [0, 1], treeIndex: 1 }
405
- ]);
406
- });
407
- it('search should expand all matches and seek out the focus offset', function () {
408
- var wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [
409
- { title: 'a', children: [{ title: 'b' }] },
410
- { title: 'a', children: [{ title: 'be' }] }
411
- ], searchQuery: "b", onChange: function () { } }));
412
- var tree = wrapper.find('ReactSortableTree').instance();
413
- expect(tree.state.searchMatches).toEqual([
414
- { node: { title: 'b' }, path: [0, 1], treeIndex: 1 },
415
- { node: { title: 'be' }, path: [2, 3], treeIndex: 3 }
416
- ]);
417
- expect(tree.state.searchFocusTreeIndex).toEqual(null);
418
- wrapper.setProps({ searchFocusOffset: 0 });
419
- expect(tree.state.searchFocusTreeIndex).toEqual(1);
420
- wrapper.setProps({ searchFocusOffset: 1 });
421
- // As the empty `onChange` we use here doesn't actually change
422
- // the tree, the expansion of all nodes doesn't get preserved
423
- // after the first mount, and this change in searchFocusOffset
424
- // only triggers the opening of a single path.
425
- // Therefore it's 2 instead of 3.
426
- expect(tree.state.searchFocusTreeIndex).toEqual(2);
427
- });
428
- it('search onlyExpandSearchedNodes should collapse all nodes except matches', function () {
429
- var wrapper = (0, enzyme_1.mount)(react_1.default.createElement(SortableTreeWithDndTestBackend, { treeData: [
430
- {
431
- title: 'a',
432
- children: [{ title: 'b', children: [{ title: 'c' }] }]
433
- },
434
- {
435
- title: 'b',
436
- children: [{ title: 'd', children: [{ title: 'be' }] }]
437
- },
438
- {
439
- title: 'c',
440
- children: [{ title: 'f', children: [{ title: 'dd' }] }]
441
- }
442
- ], onChange: function (treeData) { return wrapper.setProps({ treeData: treeData }); }, onlyExpandSearchedNodes: true }));
443
- wrapper.setProps({ searchQuery: 'be' });
444
- expect(wrapper.prop('treeData')).toEqual([
445
- {
446
- title: 'a',
447
- children: [
448
- {
449
- title: 'b',
450
- children: [
451
- {
452
- title: 'c',
453
- expanded: false
454
- }
455
- ],
456
- expanded: false
457
- }
458
- ],
459
- expanded: false
460
- },
461
- {
462
- title: 'b',
463
- children: [
464
- {
465
- title: 'd',
466
- children: [
467
- {
468
- title: 'be',
469
- expanded: false
470
- }
471
- ],
472
- expanded: true
473
- }
474
- ],
475
- expanded: true
476
- },
477
- {
478
- title: 'c',
479
- children: [
480
- {
481
- title: 'f',
482
- children: [
483
- {
484
- title: 'dd',
485
- expanded: false
486
- }
487
- ],
488
- expanded: false
489
- }
490
- ],
491
- expanded: false
492
- }
493
- ]);
494
- });
495
- it('should work with different dnd backends', function () {
496
- expect((0, enzyme_1.mount)(react_1.default.createElement(react_dnd_1.DndProvider, { backend: react_dnd_html5_backend_1.default },
497
- react_1.default.createElement(ReactSortableTree_1.default, { treeData: [{ title: 'a' }], onChange: function () { } })))).toBeDefined();
498
- expect((0, enzyme_1.mount)(react_1.default.createElement(react_dnd_1.DndProvider, { backend: react_dnd_touch_backend_1.default },
499
- react_1.default.createElement(ReactSortableTree_1.default, { treeData: [{ title: 'a' }], onChange: function () { } })))).toBeDefined();
500
- });
501
- });