feat(collections): add new collection APIs, iterator support, and tree serialization utilities

test/test.tree.both.ts

@@ -33,8 +33,119 @@ tap.test('should add other objects in a hierachy', async () => {
   testTree.appendChild(testInstance, testInstance4);
 });
 
+tap.test('hasChildren returns correct value', async () => {
+  expect(testTree.hasChildren(testInstance)).toBeTrue();
+  expect(testTree.hasChildren(testInstance2)).toBeFalse();
+});
+
+tap.test('firstChild and lastChild work', async () => {
+  const first = testTree.firstChild(testInstance);
+  expect(first.hey).toEqual('second');
+  const last = testTree.lastChild(testInstance);
+  expect(last.hey).toEqual('fourth');
+});
+
+tap.test('parent returns correct parent', async () => {
+  const parent = testTree.parent(testInstance2);
+  expect(parent.hey).toEqual('first');
+});
+
+tap.test('nextSibling and previousSibling work', async () => {
+  const next = testTree.nextSibling(testInstance2);
+  expect(next.hey).toEqual('third');
+  const prev = testTree.previousSibling(testInstance3);
+  expect(prev.hey).toEqual('second');
+});
+
+tap.test('childrenCount returns correct count', async () => {
+  expect(testTree.childrenCount(testInstance)).toEqual(3);
+  expect(testTree.childrenCount(testInstance2)).toEqual(0);
+});
+
+tap.test('index returns sibling index', async () => {
+  expect(testTree.index(testInstance2)).toEqual(0);
+  expect(testTree.index(testInstance3)).toEqual(1);
+  expect(testTree.index(testInstance4)).toEqual(2);
+});
+
+tap.test('childrenToArray returns children', async () => {
+  const children = testTree.childrenToArray(testInstance, {});
+  expect(children.length).toEqual(3);
+  expect(children[0].hey).toEqual('second');
+});
+
+tap.test('insertBefore works', async () => {
+  testTree.initialize(testInstance5);
+  testTree.insertBefore(testInstance3, testInstance5);
+  const idx = testTree.index(testInstance5);
+  expect(idx).toEqual(1);
+  expect(testTree.nextSibling(testInstance5).hey).toEqual('third');
+});
+
+tap.test('insertAfter works', async () => {
+  testTree.initialize(testInstance6);
+  testTree.insertAfter(testInstance3, testInstance6);
+  expect(testTree.previousSibling(testInstance6).hey).toEqual('third');
+});
+
+tap.test('remove detaches node', async () => {
+  const countBefore = testTree.childrenCount(testInstance);
+  testTree.remove(testInstance6);
+  expect(testTree.childrenCount(testInstance)).toEqual(countBefore - 1);
+});
+
+tap.test('treeIterator with options works', async () => {
+  const items: TestClass[] = [];
+  for (const item of testTree.treeIterator(testInstance, {})) {
+    items.push(item);
+  }
+  expect(items.length).toBeGreaterThan(1);
+  expect(items[0].hey).toEqual('first');
+});
+
+tap.test('nextSiblingsIterator works (bug was fixed)', async () => {
+  const siblings: TestClass[] = [];
+  for (const item of testTree.nextSiblingsIterator(testInstance2)) {
+    siblings.push(item);
+  }
+  expect(siblings.length).toBeGreaterThan(0);
+});
+
+tap.test('ancestorsIterator works (bug was fixed)', async () => {
+  const ancestors: TestClass[] = [];
+  for (const item of testTree.ancestorsIterator(testInstance2)) {
+    ancestors.push(item);
+  }
+  expect(ancestors.length).toBeGreaterThan(0);
+});
+
 tap.test("should create a JSON object that reflects a tree's hierachy", async () => {
-  const jsonTreet = testTree.toJsonWithHierachy(testInstance);
+  const jsonTree = testTree.toJsonWithHierachy(testInstance);
+  expect(jsonTree).toHaveProperty('data');
+  expect(jsonTree).toHaveProperty('children');
+  expect(jsonTree.data.hey).toEqual('first');
+  expect(jsonTree.children.length).toBeGreaterThan(0);
+});
+
+tap.test('fromJsonWithHierachy rebuilds a tree', async () => {
+  const newTree = new lik.Tree<{ name: string }>();
+  const jsonRoot = {
+    data: { name: 'root' },
+    children: [
+      { data: { name: 'child1' }, children: [] },
+      {
+        data: { name: 'child2' },
+        children: [{ data: { name: 'grandchild' }, children: [] }],
+      },
+    ],
+  };
+  const root = newTree.fromJsonWithHierachy(jsonRoot);
+  expect(root.name).toEqual('root');
+  expect(newTree.hasChildren(root)).toBeTrue();
+  expect(newTree.childrenCount(root)).toEqual(2);
+  const children = newTree.childrenToArray(root, {});
+  expect(children[1].name).toEqual('child2');
+  expect(newTree.hasChildren(children[1])).toBeTrue();
 });
 
 export default tap.start();