data-structure-typed 1.15.1 → 1.15.2

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -1,4 +1,5 @@
 export declare class DoublyLinkedListNode<T> {
+    constructor(nodeValue: T);
     protected _val: T;
     get val(): T;
     set val(v: T);
@@ -8,31 +9,30 @@ export declare class DoublyLinkedListNode<T> {
     protected _prev: DoublyLinkedListNode<T> | null;
     get prev(): DoublyLinkedListNode<T> | null;
     set prev(v: DoublyLinkedListNode<T> | null);
-    constructor(nodeValue: T);
 }
 export declare class DoublyLinkedList<T> {
+    constructor();
     protected _first: DoublyLinkedListNode<T> | null;
     get first(): DoublyLinkedListNode<T> | null;
+    protected set first(v: DoublyLinkedListNode<T> | null);
+    protected _last: DoublyLinkedListNode<T> | null;
+    get last(): DoublyLinkedListNode<T> | null;
+    protected set last(v: DoublyLinkedListNode<T> | null);
+    protected _size: number;
+    get size(): number;
+    protected set size(v: number);
     /**
      * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
      */
     getFirst(): DoublyLinkedListNode<T> | null;
-    protected set first(v: DoublyLinkedListNode<T> | null);
-    protected _last: DoublyLinkedListNode<T> | null;
-    get last(): DoublyLinkedListNode<T> | null;
     /**
      * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
      */
     getLast(): DoublyLinkedListNode<T> | null;
-    protected set last(v: DoublyLinkedListNode<T> | null);
-    protected _size: number;
-    get size(): number;
     /**
      * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
      */
     getSize(): number;
-    protected set size(v: number);
-    constructor();
     /**
      * The function adds a new node with a given value to the beginning of a doubly linked list.
      * @param {T} val - The `val` parameter represents the value of the element that you want to add to the beginning of

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -56,12 +56,6 @@ var DoublyLinkedList = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    DoublyLinkedList.prototype.getFirst = function () {
-        return this._first;
-    };
     Object.defineProperty(DoublyLinkedList.prototype, "last", {
         get: function () {
             return this._last;
@@ -72,12 +66,6 @@ var DoublyLinkedList = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    DoublyLinkedList.prototype.getLast = function () {
-        return this._last;
-    };
     Object.defineProperty(DoublyLinkedList.prototype, "size", {
         get: function () {
             return this._size;
@@ -88,6 +76,18 @@ var DoublyLinkedList = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    DoublyLinkedList.prototype.getFirst = function () {
+        return this._first;
+    };
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    DoublyLinkedList.prototype.getLast = function () {
+        return this._last;
+    };
     /**
      * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
      */

package/dist/data-structures/linked-list/singly-linked-list.d.ts

@@ -6,6 +6,7 @@
  * @license MIT License
  */
 export declare class SinglyLinkedListNode<NodeVal = any> {
+    constructor(val: NodeVal, prev?: SinglyLinkedListNode<NodeVal> | null, next?: SinglyLinkedListNode<NodeVal> | null, list?: SinglyLinkedList<NodeVal> | null);
     protected _val: NodeVal;
     get val(): NodeVal;
     set val(value: NodeVal);
@@ -18,7 +19,6 @@ export declare class SinglyLinkedListNode<NodeVal = any> {
     protected _list: SinglyLinkedList<NodeVal> | null;
     get list(): SinglyLinkedList<NodeVal> | null;
     set list(value: SinglyLinkedList<NodeVal> | null);
-    constructor(val: NodeVal, prev?: SinglyLinkedListNode<NodeVal> | null, next?: SinglyLinkedListNode<NodeVal> | null, list?: SinglyLinkedList<NodeVal> | null);
     get index(): number | undefined;
     /**
      * The `insertBefore` function inserts a new node with the given value before the current node in a singly linked list.
@@ -40,6 +40,12 @@ export declare class SinglyLinkedListNode<NodeVal = any> {
     remove(): SinglyLinkedListNode<NodeVal>;
 }
 export declare class SinglyLinkedList<NodeVal = any> {
+    /**
+     * The constructor initializes a linked list with the given arguments as nodes.
+     * @param {NodeVal[]} args - args is a rest parameter that allows the constructor to accept an arbitrary number of
+     * arguments of type NodeVal.
+     */
+    constructor(...args: NodeVal[]);
     protected _head: SinglyLinkedListNode<NodeVal> | null;
     get head(): SinglyLinkedListNode<NodeVal> | null;
     set head(value: SinglyLinkedListNode<NodeVal> | null);
@@ -49,12 +55,6 @@ export declare class SinglyLinkedList<NodeVal = any> {
     protected _size: number;
     get size(): number;
     set size(value: number);
-    /**
-     * The constructor initializes a linked list with the given arguments as nodes.
-     * @param {NodeVal[]} args - args is a rest parameter that allows the constructor to accept an arbitrary number of
-     * arguments of type NodeVal.
-     */
-    constructor(...args: NodeVal[]);
     /**
      * The `from` function in TypeScript creates a new SinglyLinkedList instance from an iterable object.
      * @param iterable - The `iterable` parameter is an object that can be iterated over, such as an array or a string. It

package/dist/data-structures/priority-queue/priority-queue.d.ts

@@ -7,19 +7,15 @@
  */
 import type { PriorityQueueComparator, PriorityQueueDFSOrderPattern, PriorityQueueOptions } from '../types';
 export declare class PriorityQueue<T = number> {
-    protected _nodes: T[];
-    get nodes(): T[];
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getNodes(): T[];
-    protected set nodes(value: T[]);
     /**
      * The constructor initializes a priority queue with the given options, including an array of nodes and a comparator
      * function.
      * @param options - The `options` parameter is an object that contains the following properties:
      */
     constructor(options: PriorityQueueOptions<T>);
+    protected _nodes: T[];
+    get nodes(): T[];
+    protected set nodes(value: T[]);
     get size(): number;
     /**
      * The `heapify` function creates a new PriorityQueue instance and fixes the heap property.
@@ -37,6 +33,10 @@ export declare class PriorityQueue<T = number> {
      * @returns the result of calling the `isValid()` method on a new instance of the `PriorityQueue` class.
      */
     static isPriorityQueueified<T>(options: Omit<PriorityQueueOptions<T>, 'isFix'>): boolean;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getNodes(): T[];
     /**
      * The "add" function adds a node to the heap and ensures that the heap property is maintained.
      * @param {T} node - The parameter "node" is of type T, which means it can be any data type. It represents the node

package/dist/data-structures/priority-queue/priority-queue.js

@@ -67,12 +67,6 @@ var PriorityQueue = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    PriorityQueue.prototype.getNodes = function () {
-        return this._nodes;
-    };
     Object.defineProperty(PriorityQueue.prototype, "size", {
         get: function () {
             return this.nodes.length;
@@ -102,6 +96,12 @@ var PriorityQueue = /** @class */ (function () {
     PriorityQueue.isPriorityQueueified = function (options) {
         return new PriorityQueue(__assign(__assign({}, options), { isFix: true })).isValid();
     };
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    PriorityQueue.prototype.getNodes = function () {
+        return this._nodes;
+    };
     /**
      * The "add" function adds a node to the heap and ensures that the heap property is maintained.
      * @param {T} node - The parameter "node" is of type T, which means it can be any data type. It represents the node

package/dist/data-structures/queue/deque.d.ts

@@ -9,6 +9,7 @@ import { DoublyLinkedList } from '../linked-list';
 export declare class Deque<T> extends DoublyLinkedList<T> {
 }
 export declare class ObjectDeque<T> {
+    constructor(capacity?: number);
     private _nodes;
     get nodes(): {
         [p: number]: T;
@@ -28,7 +29,6 @@ export declare class ObjectDeque<T> {
     private _size;
     get size(): number;
     protected set size(value: number);
-    constructor(capacity?: number);
     addFirst(value: T): void;
     addLast(value: T): void;
     pollFirst(): T | undefined;

package/dist/utils/types/utils.d.ts

@@ -1,6 +1,3 @@
-/**
- * A function that emits a side effect and does not return anything.
- */
 export type ToThunkFn = () => ReturnType<TrlFn>;
 export type Thunk = () => ReturnType<ToThunkFn> & {
     __THUNK__: Symbol;

package/dist/utils/types/utils.js

@@ -1,16 +1,2 @@
 "use strict";
-// export type JSONSerializable = {
-//     [key: string]: any
-// }
 Object.defineProperty(exports, "__esModule", { value: true });
-// export type CaseType =
-//     'camel'
-//     | 'snake'
-//     | 'pascal'
-//     | 'constant'
-//     | 'kebab'
-//     | 'lower'
-//     | 'title'
-//     | 'sentence'
-//     | 'path'
-//     | 'dot';

package/dist/utils/utils.js

@@ -1,6 +1,4 @@
 "use strict";
-// import _ from 'lodash';
-// import type {AnyFunction, CaseType, JSONObject, JSONSerializable} from './types';
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -71,201 +69,6 @@ var uuidV4 = function () {
     });
 };
 exports.uuidV4 = uuidV4;
-// 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));
-//     }
-// };
 var arrayRemove = function (array, predicate) {
     var i = -1, len = array ? array.length : 0;
     var result = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.15.1",
+  "version": "1.15.2",
   "description": "Explore our comprehensive Javascript Data Structure / TypeScript Data Structure Library, meticulously crafted to empower developers with a versatile set of essential data structures. Our library includes a wide range of data structures, such as Binary Tree, AVL Tree, Binary Search Tree (BST), Tree Multiset, Segment Tree, Binary Indexed Tree, Graph, Directed Graph, Undirected Graph, Singly Linked List, Hash, CoordinateSet, CoordinateMap, Heap, Doubly Linked List, Priority Queue, Max Priority Queue, Min Priority Queue, Queue, ObjectDeque, ArrayDeque, Stack, and Trie. Each data structure is thoughtfully designed and implemented using TypeScript to provide efficient, reliable, and easy-to-use solutions for your programming needs. Whether you're optimizing algorithms, managing data, or enhancing performance, our TypeScript Data Structure Library is your go-to resource. Elevate your coding experience with these fundamental building blocks for software development.",
   "main": "dist/index.js",
   "scripts": {
@@ -8,7 +8,7 @@
     "test": "jest",
     "build:docs": "typedoc --out docs ./src",
     "deps:check": "dependency-cruiser src",
-    "build:publish": "npm run test && npm run build && npm run build:docs && npm run publish"
+    "build:publish": "npm run test && npm run build && npm run build:docs && npm publish"
   },
   "repository": {
     "type": "git",
@@ -49,7 +49,6 @@
   "types": "dist/index.d.ts",
   "devDependencies": {
     "@types/jest": "^29.5.3",
-    "@types/lodash": "^4.14.197",
     "@types/node": "^20.4.9",
     "dependency-cruiser": "^13.1.2",
     "jest": "^29.6.2",
@@ -58,6 +57,5 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "lodash": "^4.17.21"
   }
 }