data-structure-typed 1.15.1 → 1.15.2

package/src/utils/utils.ts

@@ -1,6 +1,3 @@
-// import _ from 'lodash';
-// import type {AnyFunction, CaseType, JSONObject, JSONSerializable} from './types';
-
 export const uuidV4 = function () {
     return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
         const r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
@@ -8,215 +5,6 @@ export const uuidV4 = function () {
     });
 };
 
-// export const isObject = (object: string | JSONObject | boolean | AnyFunction | number) => object != null && typeof object === 'object';
-
-// export const deepObjectStrictEqual = (object1: JSONSerializable, object2: JSONSerializable) => {
-//     const keys1 = Object.keys(object1);
-//     const keys2 = Object.keys(object2);
-//     if (keys1.length !== keys2.length) {
-//         return false;
-//     }
-//     for (const key of keys1) {
-//         const val1 = object1[key];
-//         const val2 = object2[key];
-//         const areObjects = isObject(val1) && isObject(val2);
-//         if (
-//             areObjects && !deepObjectStrictEqual(val1, val2) ||
-//             !areObjects && val1 !== val2
-//         ) {
-//             return false;
-//         }
-//     }
-//     return true;
-// };
-
-// export class StringUtil {
-//     // camelCase
-//     static toCamelCase(str: string) {
-//         return _.camelCase(str);
-//     }
-//
-//     // snake_case
-//     static toSnakeCase(str: string) {
-//         return _.snakeCase(str);
-//     }
-//
-//     // PascalCase
-//     static toPascalCase(str: string) {
-//         return _.startCase(_.camelCase(str)).replace(/ /g, '');
-//     }
-//
-//     // CONSTANT_CASE
-//     static toConstantCase(str: string) {
-//         return _.upperCase(str).replace(/ /g, '_');
-//     }
-//
-//     // kebab-case
-//     static toKebabCase(str: string) {
-//         return _.kebabCase(str);
-//     }
-//
-//     // lowercase
-//     static toLowerCase(str: string) {
-//         return _.lowerCase(str).replace(/ /g, '');
-//     }
-//
-//     // Title Case
-//     static toTitleCase(str: string) {
-//         return _.startCase(_.camelCase(str));
-//     }
-//
-//     // Sentence case
-//     static toSentenceCase(str: string) {
-//         return _.upperFirst(_.lowerCase(str));
-//     }
-//
-//     // path/case
-//     static toPathCase(str: string) {
-//         return _.lowerCase(str).replace(/ /g, '/');
-//     }
-//
-//     // dot.case
-//     static toDotCase(str: string) {
-//         return _.lowerCase(str).replace(/ /g, '.');
-//     }
-// }
-
-
-// export const deepKeysConvert = (obj: any, toType?: CaseType): any => {
-//     const _toType = toType || 'snake';
-//     if (Array.isArray(obj)) {
-//         return obj.map(v => deepKeysConvert(v, _toType));
-//     } else if (obj !== null && obj.constructor === Object) {
-//         return Object.keys(obj).reduce(
-//             (result, key) => {
-//                 let newKey = '';
-//                 switch (_toType) {
-//                     case 'camel':
-//                         newKey = StringUtil.toCamelCase(key);
-//                         break;
-//                     case 'snake':
-//                         newKey = StringUtil.toSnakeCase(key);
-//                         break;
-//                     case 'pascal':
-//                         newKey = StringUtil.toPascalCase(key);
-//                         break;
-//                     case 'constant':
-//                         newKey = StringUtil.toConstantCase(key);
-//                         break;
-//                     case 'kebab':
-//                         newKey = StringUtil.toKebabCase(key);
-//                         break;
-//                     case 'lower':
-//                         newKey = StringUtil.toLowerCase(key);
-//                         break;
-//                     case 'title':
-//                         newKey = StringUtil.toTitleCase(key);
-//                         break;
-//                     case 'sentence':
-//                         newKey = StringUtil.toSentenceCase(key);
-//                         break;
-//                     case 'path':
-//                         newKey = StringUtil.toPathCase(key);
-//                         break;
-//                     case 'dot':
-//                         newKey = StringUtil.toDotCase(key);
-//                         break;
-//                     default:
-//                         newKey = StringUtil.toDotCase(key);
-//                         break;
-//                 }
-//                 return {
-//                     ...result,
-//                     [newKey]: deepKeysConvert(obj[key], _toType),
-//                 };
-//             },
-//             {},
-//         );
-//     }
-//     return obj;
-// };
-
-// export const deepRemoveByKey = (obj: any, keysToBeRemoved: string[]) => {
-//     const result = _.transform(obj, function (result: JSONSerializable, value: any, key: string) {
-//         if (_.isObject(value)) {
-//             value = deepRemoveByKey(value, keysToBeRemoved);
-//         }
-//         if (!keysToBeRemoved.includes(key)) {
-//             _.isArray(obj) ? result.push(value) : result[key] = value;
-//         }
-//     });
-//     return result as typeof obj;
-// };
-
-// export const deepRenameKeys = (obj: JSONSerializable, keysMap: { [key in string]: string }) => {
-//     return _.transform(obj, function (result: JSONSerializable, value: any, key: string | number) {
-//         const currentKey = keysMap[key] || key;
-//         result[currentKey] = _.isObject(value) ? deepRenameKeys(value, keysMap) : value;
-//     });
-// };
-
-// export const deepReplaceValues = (obj: JSONSerializable, keyReducerMap: { [key in string]: (item: JSONSerializable) => any }) => {
-//     const newObject = _.clone(obj) as JSONSerializable;
-//     _.each(obj, (val: any, key: string) => {
-//         for (const item in keyReducerMap) {
-//             if (key === item) {
-//                 newObject[key] = keyReducerMap[item](newObject);
-//             } else if (typeof (val) === 'object' || val instanceof Array) {
-//                 newObject[key] = deepReplaceValues(val, keyReducerMap);
-//             }
-//         }
-//     });
-//     return newObject;
-// };
-
-// TODO determine depth and pass root node as a param through callback
-// export const deepAdd = (obj: JSONSerializable, keyReducerMap: { [key in string]: (item: JSONSerializable) => any }, isItemRootParent?: boolean) => {
-//     const newObject = _.clone(obj) as JSONObject | [];
-//     if (_.isObject(newObject) && !_.isArray(newObject)) {
-//         for (const item in keyReducerMap) {
-//             newObject[item] = keyReducerMap[item](newObject);
-//         }
-//     }
-//     _.each(obj, (val: any, key: string | number) => {
-//         if (_.isObject(val)) {
-//             for (const item in keyReducerMap) {
-//                 // @ts-ignore
-//                 newObject[key] = deepAdd(val, keyReducerMap, isItemRootParent);
-//             }
-//         }
-//     });
-//     return newObject;
-// };
-
-// const styleString = (color: string) => `color: ${color}; font-weight: bold`;
-
-// const styleHeader = (header: string) => `%c[${header}]`;
-
-// export const bunnyConsole = {
-//     log: (headerLog = 'bunny', ...args: any[]) => {
-//         return console.log(styleHeader(headerLog), styleString('black'), ...args);
-//     },
-//     warn: (headerLog = 'bunny', ...args: any[]) => {
-//         return console.warn(styleHeader(headerLog), styleString('orange'), ...args);
-//     },
-//     error: (headerLog = 'bunny', ...args: any[]) => {
-//         return console.error(styleHeader(headerLog), styleString('red'), ...args);
-//     }
-// };
-
-// export const timeStart = () => {
-//     return performance ? performance.now() : new Date().getTime();
-// };
-
-// export const timeEnd = (startTime: number, headerLog?: string, consoleConditionFn?: (timeSpent: number) => boolean) => {
-//     const timeSpent = (performance ? performance.now() : new Date().getTime()) - startTime;
-//     const isPassCondition = consoleConditionFn ? consoleConditionFn(timeSpent) : true;
-//     if (isPassCondition) {
-//         bunnyConsole.log(headerLog ? headerLog : 'time spent', timeSpent.toFixed(2));
-//     }
-// };
-
 export const arrayRemove = function <T>(array: T[], predicate: (item: T, index: number, array: T[]) => boolean): T[] {
     let i = -1, len = array ? array.length : 0;
     const result = [];

package/tests/unit/data-structures/binary-tree/bst.test.ts

@@ -1,35 +1,40 @@
 import {BST, BSTNode} from '../../../../src';
 
-describe('bst-case6', () => {
+describe('BST Case6', () => {
     it('should perform various operations on a Binary Search Tree', () => {
-        const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
 
         const tree = new BST();
-
         expect(tree).toBeInstanceOf(BST);
 
-        tree.addMany(arr);
-
+        const values = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+        tree.addMany(values);
         expect(tree.root).toBeInstanceOf(BSTNode);
+
         if (tree.root) expect(tree.root.id).toBe(11);
+
         expect(tree.count).toBe(16);
+
         expect(tree.has(6)).toBe(true);
 
         const node6 = tree.get(6);
         expect(node6 && tree.getHeight(node6)).toBe(2);
         expect(node6 && tree.getDepth(node6)).toBe(3);
-        const getNodeById = tree.get(10, 'id');
-        expect(getNodeById?.id).toBe(10);
 
-        const getNodesByCount = tree.getNodes(1, 'count');
-        expect(getNodesByCount.length).toBe(16);
+        const nodeId10 = tree.get(10, 'id');
+        expect(nodeId10?.id).toBe(10);
+
+        const nodeVal9 = tree.get(9, 'val');
+        expect(nodeVal9?.id).toBe(9);
+
+        const nodesByCount1 = tree.getNodes(1, 'count');
+        expect(nodesByCount1.length).toBe(16);
 
-        const getMinNodeByRoot = tree.getLeftMost();
-        expect(getMinNodeByRoot?.id).toBe(1);
+        const leftMost = tree.getLeftMost();
+        expect(leftMost?.id).toBe(1);
 
         const node15 = tree.get(15);
-        const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
-        expect(getMinNodeBySpecificNode?.id).toBe(12);
+        const minNodeBySpecificNode = node15 && tree.getLeftMost(node15);
+        expect(minNodeBySpecificNode?.id).toBe(12);
 
         const subTreeSum = node15 && tree.subTreeSum(node15);
         expect(subTreeSum).toBe(70);
@@ -43,30 +48,33 @@ describe('bst-case6', () => {
             expect(subTreeAdd).toBeDefined();
         }
 
-
         const node11 = tree.get(11);
         expect(node11).toBeInstanceOf(BSTNode);
         if (node11 instanceof BSTNode) {
-            const allGreaterNodesAdd = tree.allGreaterNodesAdd(node11, 2, 'count');
-            expect(allGreaterNodesAdd).toBeDefined();
+            const allGreaterNodesAdded = tree.allGreaterNodesAdd(node11, 2, 'count');
+            expect(allGreaterNodesAdded).toBeDefined();
         }
 
-        const dfs = tree.DFS('in', 'node');
-        expect(dfs[0].id).toBe(1);
-        expect(dfs[dfs.length - 1].id).toBe(16);
+        const dfsInorderNodes = tree.DFS('in', 'node');
+        expect(dfsInorderNodes[0].id).toBe(1);
+        expect(dfsInorderNodes[dfsInorderNodes.length - 1].id).toBe(16);
 
         tree.balance();
-        const bfs = tree.BFS('node');
         expect(tree.isBalanced()).toBe(true);
-        expect(bfs[0].id).toBe(8);
-        expect(bfs[bfs.length - 1].id).toBe(16);
+
+        const bfsNodesAfterBalanced = tree.BFS('node');
+        expect(bfsNodesAfterBalanced[0].id).toBe(8);
+        expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].id).toBe(16);
 
         const removed11 = tree.remove(11, true);
         expect(removed11).toBeInstanceOf(Array);
         expect(removed11[0]).toBeDefined();
         expect(removed11[0].deleted).toBeDefined();
+
         if (removed11[0].deleted) expect(removed11[0].deleted.id).toBe(11);
+
         expect(tree.isAVLBalanced()).toBe(true);
+
         expect(node15 && tree.getHeight(node15)).toBe(2);
 
         const removed1 = tree.remove(1, true);
@@ -76,6 +84,7 @@ describe('bst-case6', () => {
         if (removed1[0].deleted) expect(removed1[0].deleted.id).toBe(1);
 
         expect(tree.isAVLBalanced()).toBe(true);
+
         expect(tree.getHeight()).toBe(4);
 
         const removed4 = tree.remove(4, true);
@@ -170,16 +179,16 @@ describe('bst-case6', () => {
         expect(tree.getHeight()).toBe(2);
 
 
-        expect(!tree.isAVLBalanced()).toBe(true);
+        expect(tree.isAVLBalanced()).toBe(false);
 
-        const lastBFSIds = tree.BFS();
-        expect(lastBFSIds[0]).toBe(2);
-        expect(lastBFSIds[1]).toBe(12);
-        expect(lastBFSIds[2]).toBe(16);
+        const bfsIDs = tree.BFS();
+        expect(bfsIDs[0]).toBe(2);
+        expect(bfsIDs[1]).toBe(12);
+        expect(bfsIDs[2]).toBe(16);
 
-        const lastBFSNodes = tree.BFS('node');
-        expect(lastBFSNodes[0].id).toBe(2);
-        expect(lastBFSNodes[1].id).toBe(12);
-        expect(lastBFSNodes[2].id).toBe(16);
+        const bfsNodes = tree.BFS('node');
+        expect(bfsNodes[0].id).toBe(2);
+        expect(bfsNodes[1].id).toBe(12);
+        expect(bfsNodes[2].id).toBe(16);
     });
 });

package/tests/unit/data-structures/graph/directed-graph.test.ts

@@ -1,29 +1,5 @@
 import {DirectedEdge, DirectedGraph, DirectedVertex, VertexId} from '../../../../src';
 
-class MyVertex extends DirectedVertex {
-    data: string;
-
-    constructor(id: VertexId, data: string) {
-        super(id);
-        this.data = data;
-    }
-}
-
-class MyEdge extends DirectedEdge {
-    data: string;
-
-    constructor(v1: VertexId, v2: VertexId, weight: number, data: string) {
-        super(v1, v2, weight);
-        this.data = data;
-    }
-}
-
-class MyGraph<V extends MyVertex, E extends MyEdge> extends DirectedGraph<V, E> {
-    constructor() {
-        super();
-    }
-}
-
 describe('DirectedGraph Test1', () => {
     let graph: DirectedGraph<DirectedVertex, DirectedEdge>;
 
@@ -69,10 +45,7 @@ describe('DirectedGraph Test1', () => {
         expect(graph.hasEdge('A', 'B')).toBe(false);
     });
 
-    // Add more test cases for other methods...
-
     it('should perform topological sort', () => {
-        // Create a graph with vertices and edges
         const vertexA = new DirectedVertex('A');
         const vertexB = new DirectedVertex('B');
         const vertexC = new DirectedVertex('C');
@@ -85,17 +58,43 @@ describe('DirectedGraph Test1', () => {
         graph.addEdge(edgeAB);
         graph.addEdge(edgeBC);
 
-        // Perform topological sort
         const topologicalOrder = graph.topologicalSort();
-
         if (topologicalOrder) expect(topologicalOrder.map(v => v.id)).toEqual(['A', 'B', 'C']);
-
     });
-
-    // Add more test cases for other methods...
 });
 
 
+class MyVertex extends DirectedVertex {
+    private _data: string;
+    get data(): string {
+        return this._data;
+    }
+    set data(value: string) {
+        this._data = value;
+    }
+
+    constructor(id: VertexId, data: string) {
+        super(id);
+        this._data = data;
+    }
+}
+
+class MyEdge extends DirectedEdge {
+    private _data: string;
+    get data(): string {
+        return this._data;
+    }
+    set data(value: string) {
+        this._data = value;
+    }
+
+    constructor(v1: VertexId, v2: VertexId, weight: number, data: string) {
+        super(v1, v2, weight);
+        this._data = data;
+    }
+}
+
+
 describe('DirectedGraph Test2 operations', () => {
     const myGraph = new DirectedGraph<MyVertex, MyEdge>();
 
@@ -223,8 +222,6 @@ describe('DirectedGraph Test3', () => {
         expect(myGraph.getEdge(2, 1)).toBeTruthy();
         expect(myGraph.getEdge(1, '100')).toBeFalsy();
 
-        // Add the rest of your assertions here...
-
         myGraph.removeEdgeBetween(1, 2);
         expect(myGraph.getEdge(1, 2)).toBeFalsy();