react-native-tree-multi-select 1.2.1 → 1.2.3

package/lefthook.yml

@@ -0,0 +1,17 @@
+pre-commit:
+  parallel: true
+  commands:
+    test:
+      run: yarn test
+    lint:
+      glob: "*.{js,ts,jsx,tsx}"
+      run: yarn lint
+    types:
+      files: git diff --name-only @{push}
+      glob: "*.{js,ts,jsx,tsx}"
+      run: npx tsc --noEmit
+commit-msg:
+  parallel: true
+  commands:
+    commitlint:
+      run: npx commitlint --edit

package/lib/typescript/__mocks__/generateTree.mock.d.ts

@@ -0,0 +1,17 @@
+import { TreeNode, __FlattenedTreeNode__ } from "../types/treeView.types";
+export declare const tree3d2b: {
+    id: string;
+    name: string;
+    children: {
+        id: string;
+        name: string;
+        children: {
+            id: string;
+            name: string;
+        }[];
+    }[];
+}[];
+export declare function generateTree(depth: number, breadth: number, prefix?: string): TreeNode[];
+export declare function generateExpectedFlatTree(nodes: TreeNode[], expandedIds: Set<string>, level?: number): __FlattenedTreeNode__[];
+export declare function createRandomNumberSet(): Set<string>;
+//# sourceMappingURL=generateTree.mock.d.ts.map

package/lib/typescript/__mocks__/generateTree.mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateTree.mock.d.ts","sourceRoot":"","sources":["../../../src/__mocks__/generateTree.mock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAE1E,eAAO,MAAM,QAAQ;;;;;;;;;;;GAqEpB,CAAC;AAEF,wBAAgB,YAAY,CACxB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,MAAM,GAAE,MAAW,GACpB,QAAQ,EAAE,CAiBZ;AAED,wBAAgB,wBAAwB,CACpC,KAAK,EAAE,QAAQ,EAAE,EACjB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,KAAK,GAAE,MAAU,GAClB,qBAAqB,EAAE,CAYzB;AAED,wBAAgB,qBAAqB,gBAUpC"}

package/lib/typescript/__mocks__/zustand.d.ts

@@ -0,0 +1,3 @@
+import { StateCreator } from 'zustand';
+export declare const create: <S>(createState: StateCreator<S>) => any;
+//# sourceMappingURL=zustand.d.ts.map

package/lib/typescript/__mocks__/zustand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zustand.d.ts","sourceRoot":"","sources":["../../../src/__mocks__/zustand.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAQvC,eAAO,MAAM,MAAM,mBAAoB,aAAa,CAAC,CAAC,QAKrD,CAAC"}

package/lib/typescript/__tests__/expandCollapse.helper.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=expandCollapse.helper.test.d.ts.map

package/lib/typescript/__tests__/expandCollapse.helper.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expandCollapse.helper.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/expandCollapse.helper.test.ts"],"names":[],"mappings":""}

package/lib/typescript/__tests__/flattenTree.helper.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=flattenTree.helper.test.d.ts.map

package/lib/typescript/__tests__/flattenTree.helper.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flattenTree.helper.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/flattenTree.helper.test.ts"],"names":[],"mappings":""}

package/lib/typescript/__tests__/initNodeMap.helper.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=initNodeMap.helper.test.d.ts.map

package/lib/typescript/__tests__/initNodeMap.helper.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initNodeMap.helper.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/initNodeMap.helper.test.ts"],"names":[],"mappings":""}

package/lib/typescript/__tests__/search.helper.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=search.helper.test.d.ts.map

package/lib/typescript/__tests__/search.helper.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.helper.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/search.helper.test.ts"],"names":[],"mappings":""}

package/lib/typescript/__tests__/selectAll.helper.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=selectAll.helper.test.d.ts.map

package/lib/typescript/__tests__/selectAll.helper.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectAll.helper.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/selectAll.helper.test.ts"],"names":[],"mappings":""}

package/lib/typescript/__tests__/store.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=store.test.d.ts.map

package/lib/typescript/__tests__/store.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/store.test.ts"],"names":[],"mappings":""}

package/lib/typescript/__tests__/toggleCheckbox.helper.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=toggleCheckbox.helper.test.d.ts.map

package/lib/typescript/__tests__/toggleCheckbox.helper.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toggleCheckbox.helper.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/toggleCheckbox.helper.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-tree-multi-select",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Super-fast Tree view with multi-selection capabilities, using checkboxes and search filtering.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -37,7 +37,8 @@
     "build:android": "cd example/android && ./gradlew assembleDebug --no-daemon --console=plain -PreactNativeArchitectures=arm64-v8a",
     "build:ios": "cd example/ios && pod install && xcodebuild -workspace TreeMultiSelectExample.xcworkspace -scheme TreeMultiSelectExample -configuration Debug -sdk iphonesimulator CC=clang CPLUSPLUS=clang++ LD=clang LDPLUSPLUS=clang++ GCC_OPTIMIZATION_LEVEL=0 GCC_PRECOMPILE_PREFIX_HEADER=YES ASSETCATALOG_COMPILER_OPTIMIZATION=time DEBUG_INFORMATION_FORMAT=dwarf COMPILER_INDEX_STORE_ENABLE=NO",
     "bootstrap": "yarn example && yarn install && yarn example pods",
-    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build"
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build",
+    "generate-changelog": "auto-changelog"
   },
   "keywords": [
     "react-native",
@@ -88,6 +89,7 @@
     "@types/react-native": "0.70.0",
     "@types/react-native-vector-icons": "^6.4.13",
     "@types/react-test-renderer": "^18.0.0",
+    "auto-changelog": "^2.4.0",
     "commitlint": "^17.0.2",
     "del-cli": "^5.0.0",
     "eslint": "^8.4.1",

package/scripts/bootstrap.js

@@ -0,0 +1,29 @@
+const os = require('os');
+const path = require('path');
+const child_process = require('child_process');
+
+const root = path.resolve(__dirname, '..');
+const args = process.argv.slice(2);
+const options = {
+  cwd: process.cwd(),
+  env: process.env,
+  stdio: 'inherit',
+  encoding: 'utf-8',
+};
+
+if (os.type() === 'Windows_NT') {
+  options.shell = true;
+}
+
+let result;
+
+if (process.cwd() !== root || args.length) {
+  // We're not in the root of the project, or additional arguments were passed
+  // In this case, forward the command to `yarn`
+  result = child_process.spawnSync('yarn', args, options);
+} else {
+  // If `yarn` is run without arguments, perform bootstrap
+  result = child_process.spawnSync('yarn', ['bootstrap'], options);
+}
+
+process.exitCode = result.status;

package/src/__mocks__/generateTree.mock.ts

@@ -0,0 +1,125 @@
+import { TreeNode, __FlattenedTreeNode__ } from "../types/treeView.types";
+
+export const tree3d2b = [
+    {
+        "id": "1",
+        "name": "node1",
+        "children": [
+            {
+                "id": "1.1",
+                "name": "node1.1",
+                "children": [
+                    {
+                        "id": "1.1.1",
+                        "name": "node1.1.1"
+                    },
+                    {
+                        "id": "1.1.2",
+                        "name": "node1.1.2"
+                    }
+                ]
+            },
+            {
+                "id": "1.2",
+                "name": "node1.2",
+                "children": [
+                    {
+                        "id": "1.2.1",
+                        "name": "node1.2.1"
+                    },
+                    {
+                        "id": "1.2.2",
+                        "name": "node1.2.2"
+                    }
+                ]
+            }
+        ]
+    },
+    {
+        "id": "2",
+        "name": "node2",
+        "children": [
+            {
+                "id": "2.1",
+                "name": "node2.1",
+                "children": [
+                    {
+                        "id": "2.1.1",
+                        "name": "node2.1.1"
+                    },
+                    {
+                        "id": "2.1.2",
+                        "name": "node2.1.2"
+                    }
+                ]
+            },
+            {
+                "id": "2.2",
+                "name": "node2.2",
+                "children": [
+                    {
+                        "id": "2.2.1",
+                        "name": "node2.2.1"
+                    },
+                    {
+                        "id": "2.2.2",
+                        "name": "node2.2.2"
+                    }
+                ]
+            }
+        ]
+    }
+];
+
+export function generateTree(
+    depth: number,
+    breadth: number,
+    prefix: string = ''
+): TreeNode[] {
+    let nodes: TreeNode[] = [];
+
+    for (let i = 1; i <= breadth; i++) {
+        let node: TreeNode = {
+            id: `${prefix}${i}`,
+            name: `node${prefix}${i}`
+        };
+
+        if (depth > 1) {
+            node.children = generateTree(depth - 1, breadth, `${prefix}${i}.`);
+        }
+
+        nodes.push(node);
+    }
+
+    return nodes;
+}
+
+export function generateExpectedFlatTree(
+    nodes: TreeNode[],
+    expandedIds: Set<string>,
+    level: number = 0
+): __FlattenedTreeNode__[] {
+    let flattened: __FlattenedTreeNode__[] = [];
+    for (let node of nodes) {
+        flattened.push({ ...node, level: level });
+        if (node.children && expandedIds.has(node.id)) {
+            flattened = [
+                ...flattened,
+                ...generateExpectedFlatTree(node.children, expandedIds, level + 1)
+            ];
+        }
+    }
+    return flattened;
+}
+
+export function createRandomNumberSet() {
+    let randomNumbers = new Set<string>();
+
+    while (randomNumbers.size < 10) {
+        // Random number between 0 and 99
+        let randomNumber = Math.floor(Math.random() * 100);
+        randomNumbers.add(randomNumber.toString());
+    }
+
+    return randomNumbers;
+}

package/src/__mocks__/zustand.ts

@@ -0,0 +1,24 @@
+import { act } from '@testing-library/react-native';
+import { StateCreator } from 'zustand';
+
+const { create: actualCreate } = jest.requireActual('zustand');
+
+// a variable to hold reset functions for all stores declared in the app
+const storeResetFns = new Set<() => void>();
+
+// when creating a store, we get its initial state, create a reset function and add it in the set
+export const create = <S>(createState: StateCreator<S>) => {
+    const store = actualCreate(createState);
+    const initialState = store.getState();
+    storeResetFns.add(() => store.setState(initialState, true));
+    return store;
+};
+
+// Reset all stores after each test run
+beforeEach(async () => {
+    await act(() =>
+        storeResetFns.forEach(resetFn => {
+            resetFn();
+        })
+    );
+});

package/src/__tests__/expandCollapse.helper.test.ts

@@ -0,0 +1,189 @@
+jest.mock('zustand');
+
+import { useTreeViewStore } from '../store/treeView.store';
+import { tree3d2b } from "../__mocks__/generateTree.mock";
+import {
+    collapseAll,
+    collapseNodes,
+    expandAll,
+    expandNodes,
+    handleToggleExpand,
+    initializeNodeMaps
+} from '../helpers';
+import { act } from 'react-test-renderer';
+
+describe('handleToggleExpand', () => {
+    beforeEach(() => {
+        useTreeViewStore.setState(useTreeViewStore.getState(), true);
+
+        useTreeViewStore.getState().updateInitialTreeViewData(tree3d2b);
+        initializeNodeMaps(tree3d2b);
+    });
+
+    test('handleToggleExpand correctly toggles the expanded state of a tree node', () => {
+        act(() => {
+            handleToggleExpand('1');
+        });
+
+        // Node '1' should now be expanded
+        let { expanded } = useTreeViewStore.getState();
+        expect(expanded.has('1')).toBeTruthy();
+
+        act(() => {
+            handleToggleExpand('1.2');
+        });
+
+        // Node '1.2' should now be expanded, Node '1'(parent) should remain expanded
+        expanded = useTreeViewStore.getState().expanded;
+        expect(expanded.has('1.2')).toBeTruthy();
+        expect(expanded.has('1')).toBeTruthy();
+
+        act(() => {
+            handleToggleExpand('1');
+            handleToggleExpand('2');
+        });
+
+        // Node '1' and its descendants should now be collapsed but Node '2' should remain expanded
+        expanded = useTreeViewStore.getState().expanded;
+
+        expect(expanded.has('1')).toBeFalsy();
+        expect(expanded.has('1.1')).toBeFalsy();
+        expect(expanded.has('1.2')).toBeFalsy();
+        expect(expanded.has('1.2.1')).toBeFalsy();
+
+        expect(expanded.has('2')).toBeTruthy();
+    });
+});
+
+describe('expandAll', () => {
+    beforeEach(() => {
+        useTreeViewStore.setState(useTreeViewStore.getState(), true);
+
+        // Setup mock tree
+        useTreeViewStore.getState().updateInitialTreeViewData(tree3d2b);
+        initializeNodeMaps(tree3d2b);
+    });
+
+    it('calls expandAll on initial tree(all collapsed)', () => {
+        act(() => {
+            expandAll();
+        });
+
+        const { expanded, nodeMap } = useTreeViewStore.getState();
+
+        // Convert nodeMap.keys() iterator to a Set for comparison
+        const nodeKeys = new Set(nodeMap.keys());
+        expect(expanded).toEqual(nodeKeys);
+    });
+
+    it('expands all node in tree with some nodes which are already expanded', () => {
+        act(() => {
+            handleToggleExpand('1');
+            handleToggleExpand('2');
+            handleToggleExpand('1.1');
+            handleToggleExpand('1.2');
+            handleToggleExpand('1.1');
+
+            expandAll();
+        });
+
+        const { expanded, nodeMap } = useTreeViewStore.getState();
+
+        // Convert nodeMap.keys() iterator to a Set for comparison
+        const nodeKeys = new Set(nodeMap.keys());
+        expect(expanded).toEqual(nodeKeys);
+    });
+});
+
+describe('collapseAll', () => {
+    beforeEach(() => {
+        useTreeViewStore.setState(useTreeViewStore.getState(), true);
+
+        // Setup mock tree
+        useTreeViewStore.getState().updateInitialTreeViewData(tree3d2b);
+        initializeNodeMaps(tree3d2b);
+    });
+
+    it('calls collapseAll on initial tree(all collapsed)', () => {
+        act(() => {
+            collapseAll();
+        });
+
+        const { expanded } = useTreeViewStore.getState();
+        expect(expanded).toEqual(new Set<string>());
+    });
+
+    it('collapses all node in tree with some nodes which are already expanded', () => {
+        act(() => {
+            handleToggleExpand('1');
+            handleToggleExpand('2');
+            handleToggleExpand('1.1');
+            handleToggleExpand('1.2');
+            handleToggleExpand('1.1');
+
+            collapseAll();
+        });
+
+        const { expanded } = useTreeViewStore.getState();
+
+        expect(expanded).toEqual(new Set<string>());
+    });
+});
+
+describe('expandNodes & collapseNodes', () => {
+    beforeEach(() => {
+        useTreeViewStore.setState(useTreeViewStore.getState(), true);
+
+        useTreeViewStore.getState().updateInitialTreeViewData(tree3d2b);
+        initializeNodeMaps(tree3d2b);
+    });
+
+    it('expands and then collapses multiple nodes as needed', () => {
+        act(() => {
+            expandNodes(["1", "2.1", "2.2.2"]);
+        });
+
+        const { expanded: expandedAfterExpandNodes } = useTreeViewStore.getState();
+        // Both nodes and their parents should be expanded
+        expect(expandedAfterExpandNodes.has("1")).toBeTruthy();
+        expect(expandedAfterExpandNodes.has("1.1")).toBeFalsy();
+        expect(expandedAfterExpandNodes.has("1.1.1")).toBeFalsy();
+        expect(expandedAfterExpandNodes.has("1.1.2")).toBeFalsy();
+        expect(expandedAfterExpandNodes.has("1.2")).toBeFalsy();
+        expect(expandedAfterExpandNodes.has("1.2.1")).toBeFalsy();
+        expect(expandedAfterExpandNodes.has("1.2.2")).toBeFalsy();
+
+        expect(expandedAfterExpandNodes.has("2")).toBeTruthy();
+        expect(expandedAfterExpandNodes.has("2.1")).toBeTruthy();
+        expect(expandedAfterExpandNodes.has("2.1.1")).toBeFalsy();
+        expect(expandedAfterExpandNodes.has("2.1.2")).toBeFalsy();
+
+        expect(expandedAfterExpandNodes.has("2.2")).toBeTruthy();
+        expect(expandedAfterExpandNodes.has("2.2.1")).toBeFalsy();
+        expect(expandedAfterExpandNodes.has("2.2.2")).toBeTruthy();
+
+        // Then collapse the same nodes
+        act(() => {
+            collapseNodes(["1", "2.2"]);
+        });
+
+        const { expanded: expandedAfterCollapseNodes } = useTreeViewStore.getState();
+        // Both nodes and their children should be collapsed
+        expect(expandedAfterCollapseNodes.has("1")).toBeFalsy();
+        expect(expandedAfterCollapseNodes.has("1.1")).toBeFalsy();
+        expect(expandedAfterCollapseNodes.has("1.1.1")).toBeFalsy();
+        expect(expandedAfterCollapseNodes.has("1.1.2")).toBeFalsy();
+        expect(expandedAfterCollapseNodes.has("1.2")).toBeFalsy();
+        expect(expandedAfterCollapseNodes.has("1.2.1")).toBeFalsy();
+        expect(expandedAfterCollapseNodes.has("1.2.2")).toBeFalsy();
+
+        expect(expandedAfterCollapseNodes.has("2")).toBeTruthy();
+        expect(expandedAfterCollapseNodes.has("2.1")).toBeTruthy();
+        expect(expandedAfterCollapseNodes.has("2.1.1")).toBeFalsy();
+        expect(expandedAfterCollapseNodes.has("2.1.2")).toBeFalsy();
+
+        expect(expandedAfterCollapseNodes.has("2.2")).toBeFalsy();
+        expect(expandedAfterCollapseNodes.has("2.2.1")).toBeFalsy();
+        expect(expandedAfterCollapseNodes.has("2.2.2")).toBeFalsy();
+    });
+});

package/src/__tests__/flattenTree.helper.test.ts

@@ -0,0 +1,78 @@
+import { getFlattenedTreeData } from "../helpers";
+import { generateExpectedFlatTree, tree3d2b } from "../__mocks__/generateTree.mock";
+import { TreeNode } from "../types/treeView.types";
+
+describe('getFlattenedTreeData', () => {
+    let nodes: TreeNode[];
+    let expandedIds: Set<string>;
+
+    beforeEach(() => {
+        nodes = tree3d2b;
+        expandedIds = new Set<string>();
+    });
+
+    // Hardcoded test
+    test('should correctly flatten a simple tree', () => {
+        const simpleNodes: TreeNode[] = [{
+            id: '1',
+            name: 'node1',
+            children: [
+                {
+                    id: '1.1', name: 'node1.1', children: [
+                        { id: '1.1.1', name: 'node1.1.1' },
+                        { id: '1.1.2', name: 'node1.1.2' },
+                        { id: '1.1.3', name: 'node1.1.3' },
+                    ]
+                },
+                {
+                    id: '1.2', name: 'node1.2', children: [
+                        { id: '1.2.1', name: 'node1.2.1' },
+                        { id: '1.2.2', name: 'node1.2.2' },
+                        { id: '1.2.3', name: 'node1.2.3' },
+                    ]
+                },
+                {
+                    id: '1.3', name: 'node1.3', children: [
+                        { id: '1.3.1', name: 'node1.3.1' },
+                        { id: '1.3.2', name: 'node1.3.2' },
+                        { id: '1.3.3', name: 'node1.3.3' },
+                    ]
+                },
+            ],
+        }];
+        const simpleExpandedIds = new Set(['1', '1.1', '1.2', '1.3']);
+        const result = getFlattenedTreeData(simpleNodes, simpleExpandedIds);
+        expect(result).toEqual([
+            { id: '1', name: 'node1', level: 0, children: simpleNodes?.[0]?.children },
+            { id: '1.1', name: 'node1.1', level: 1, children: simpleNodes?.[0]?.children?.[0]?.children },
+            { id: '1.1.1', name: 'node1.1.1', level: 2 },
+            { id: '1.1.2', name: 'node1.1.2', level: 2 },
+            { id: '1.1.3', name: 'node1.1.3', level: 2 },
+            { id: '1.2', name: 'node1.2', level: 1, children: simpleNodes?.[0]?.children?.[1]?.children },
+            { id: '1.2.1', name: 'node1.2.1', level: 2 },
+            { id: '1.2.2', name: 'node1.2.2', level: 2 },
+            { id: '1.2.3', name: 'node1.2.3', level: 2 },
+            { id: '1.3', name: 'node1.3', level: 1, children: simpleNodes?.[0]?.children?.[2]?.children },
+            { id: '1.3.1', name: 'node1.3.1', level: 2 },
+            { id: '1.3.2', name: 'node1.3.2', level: 2 },
+            { id: '1.3.3', name: 'node1.3.3', level: 2 },
+        ]);
+    });
+
+    // Dynamic test
+    test('should return a flat array of nodes with correct level property', () => {
+        expandedIds.add('1');
+        expandedIds.add('1.1');
+        expandedIds.add('1.2');
+        expandedIds.add('1.3');
+        const result = getFlattenedTreeData(nodes, expandedIds);
+        const expected = generateExpectedFlatTree(nodes, expandedIds);
+        expect(result).toEqual(expected);
+    });
+
+    // Edge case: tree with no expanded nodes
+    test('should return a flat array of root nodes when no nodes are expanded', () => {
+        const result = getFlattenedTreeData(nodes, new Set());
+        expect(result).toEqual(nodes.map(node => ({ ...node, level: 0 })));
+    });
+});

package/src/__tests__/initNodeMap.helper.test.ts

@@ -0,0 +1,46 @@
+jest.mock('zustand');
+
+import { act } from 'react-test-renderer';
+import { useTreeViewStore } from '../store/treeView.store';
+import { TreeNode } from 'src/types/treeView.types';
+import { initializeNodeMaps } from '../helpers';
+
+describe('initNodeMap helper', () => {
+    beforeEach(() => {
+        useTreeViewStore.setState(useTreeViewStore.getState(), true);
+    });
+
+    test('initializeNodeMaps correctly initializes the node maps', () => {
+        const initialData: TreeNode[] = [
+            {
+                id: '1',
+                name: 'Node 1',
+                children: [
+                    { id: '1.1', name: 'Node 1.1' },
+                    { id: '1.2', name: 'Node 1.2', children: [{ id: '1.2.1', name: 'Node 1.2.1' }] },
+                ],
+            },
+            { id: '2', name: 'Node 2' },
+        ];
+
+        act(() => {
+            initializeNodeMaps(initialData);
+        });
+
+        const { nodeMap, childToParentMap } = useTreeViewStore.getState();
+
+        // The nodeMap should contain all nodes, regardless of depth
+        expect(nodeMap.has('1')).toBeTruthy();
+        expect(nodeMap.has('1.1')).toBeTruthy();
+        expect(nodeMap.has('1.2')).toBeTruthy();
+        expect(nodeMap.has('1.2.1')).toBeTruthy();
+        expect(nodeMap.has('2')).toBeTruthy();
+
+        // The childToParentMap should contain all non-root nodes
+        expect(childToParentMap.has('1')).toBeFalsy(); // Root node
+        expect(childToParentMap.get('1.1')).toEqual('1');
+        expect(childToParentMap.get('1.2')).toEqual('1');
+        expect(childToParentMap.get('1.2.1')).toEqual('1.2');
+        expect(childToParentMap.has('2')).toBeFalsy(); // Root node
+    });
+});