@gabrielrufino/cube 1.0.57 → 1.0.61

package/build/Array/index.d.ts

@@ -1,7 +1,7 @@
 import DataStructure from '../DataStructure';
 import IArray from './IArray';
 export default class Array<T = number> extends DataStructure<T> implements IArray<T> {
-    constructor(...inputs: T[]);
+    constructor(...inputs: Readonly<T[]>);
     insertInLastPosition(element: T): T;
     insertInFirstPosition(element: T): T;
     insertInPosition(position: number, element: T): T;

package/build/BinarySearchTree/index.d.ts

@@ -4,7 +4,7 @@ import IBinarySearchTreeData from './IBinarySearchTreeData';
 export default class BinarySearchTree<T = number> implements IBinarySearchTree<T> {
     private _root;
     private _size;
-    constructor({ inputs, lessThanOrEqualTo }?: IBinarySearchNodeOptions<T>);
+    constructor({ inputs, lessThanOrEqualTo }?: Readonly<IBinarySearchNodeOptions<T>>);
     get data(): IBinarySearchTreeData<T>;
     get size(): number;
     get min(): T | null;

package/build/DataStructure/index.d.ts

@@ -1,6 +1,6 @@
 export default abstract class DataStructure<T> {
     protected _data: T[];
-    constructor(inputs: T[]);
+    constructor(inputs: Readonly<T[]>);
     get data(): T[];
     get size(): number;
 }

package/build/Deck/index.d.ts

@@ -1,7 +1,7 @@
 import DataStructure from '../DataStructure';
 import IDeck from './IDeck';
 export default class Deck<T = number> extends DataStructure<T> implements IDeck<T> {
-    constructor(...inputs: T[]);
+    constructor(...inputs: Readonly<T[]>);
     addFront(element: T): T;
     addBack(element: T): T;
     removeFront(): T | undefined;

package/build/Dictionary/index.d.ts

@@ -2,9 +2,9 @@ import IDictionary from './IDictionary';
 import IDictionaryData from './IDictionaryData';
 export default class Dictionary<T = number> implements IDictionary<T> {
     private _data;
-    constructor(inputs?: {
+    constructor(inputs?: Readonly<{
         [key: string]: T;
-    });
+    }>);
     get data(): IDictionaryData<T>;
     get size(): number;
     get isEmpty(): boolean;

package/build/DoublyLinkedList/index.d.ts

@@ -3,7 +3,7 @@ export default class DoublyLinkedList<T = number> implements IDoublyLinkedList<T
     private _head;
     private _tail;
     private _size;
-    constructor(...inputs: T[]);
+    constructor(...inputs: Readonly<T[]>);
     get data(): IDoublyLinkedListItem<T>[];
     get size(): number;
     /**

package/build/Graph/index.d.ts

@@ -3,7 +3,7 @@ import IGraphOptions from './IGraphOptions';
 export default class Graph implements IGraph {
     private _isDirected;
     private _data;
-    constructor({ inputs, isDirected }?: IGraphOptions);
+    constructor({ inputs, isDirected }?: Readonly<IGraphOptions>);
     get isDirected(): boolean;
     get data(): {
         [key: string]: string[];

package/build/HashTable/index.d.ts

@@ -4,7 +4,7 @@ import IHashTableInputs from './IHashTableInputs';
 import IHashTableOptions from './IHashTableOptions';
 export default class HashTable<T = number> implements IHashTable<T> {
     private _data;
-    constructor(inputs?: IHashTableInputs<T>, { maxSize }?: IHashTableOptions);
+    constructor(inputs?: Readonly<IHashTableInputs<T>>, { maxSize }?: IHashTableOptions);
     get data(): IHashTableData<T>;
     get size(): number;
     get maxSize(): number;

package/build/HashTableLinearProbing/index.d.ts

@@ -5,7 +5,7 @@ import IHashTableLinearProbingOptions from './IHashTableLinearProbingOptions';
 export default class HashTableLinearProbing<T = number> implements IHashTableLinearProbing<T> {
     private _maxSize;
     private _data;
-    constructor(inputs?: IHashTableLinearProbingInputs<T>, { maxSize }?: IHashTableLinearProbingOptions);
+    constructor(inputs?: Readonly<IHashTableLinearProbingInputs<T>>, { maxSize }?: IHashTableLinearProbingOptions);
     get data(): {
         [index: number]: HashTableLinearProbingElement<T>;
     };

package/build/HashTableSeparateChaining/index.d.ts

@@ -4,7 +4,7 @@ import IHashTableSeparateChainingData from './IHashTableSeparateChainingData';
 import IHashTableSeparateChainingInputs from './IHashTableSeparateChainingInputs';
 export default class HashTableSeparateChaining<T = number> implements IHashTableSeparateChaining<T> {
     private _data;
-    constructor(inputs?: IHashTableSeparateChainingInputs<T>, { maxSize }?: {
+    constructor(inputs?: Readonly<IHashTableSeparateChainingInputs<T>>, { maxSize }?: {
         maxSize: number;
     });
     get data(): IHashTableSeparateChainingData<T>;

package/build/LinkedList/index.d.ts

@@ -4,7 +4,7 @@ export default class LinkedList<T = number> implements ILinkedList<T> {
     private readonly _FIRST_POSITION;
     private _head;
     private _size;
-    constructor(...inputs: T[]);
+    constructor(...inputs: Readonly<T[]>);
     get data(): {
         value: T;
         next: NonNullable<T> | null;

package/build/MaxHeap/IMaxHeapOptions.d.ts

@@ -1,5 +1,5 @@
 interface IMaxHeapOptions<T> {
     greaterThanOrEqualTo?: (_value1: T, _value2: T) => boolean;
-    inputs?: T[];
+    inputs?: Readonly<T[]>;
 }
 export default IMaxHeapOptions;

package/build/MinHeap/IMinHeapOptions.d.ts

@@ -1,5 +1,5 @@
 interface IMinHeapOptions<T> {
     lessThanOrEqualTo?: (_value1: T, _value2: T) => boolean;
-    inputs?: T[];
+    inputs?: Readonly<T[]>;
 }
 export default IMinHeapOptions;

package/build/Queue/index.d.ts

@@ -1,7 +1,7 @@
 import DataStructure from '../DataStructure';
 import IQueue from './IQueue';
 export default class Queue<T = number> extends DataStructure<T> implements IQueue<T> {
-    constructor(...inputs: T[]);
+    constructor(...inputs: Readonly<T[]>);
     get isEmpty(): boolean;
     enqueue(element: T): T;
     dequeue(): T | undefined;

package/build/Set/index.d.ts

@@ -1,7 +1,7 @@
 import ISet from './ISet';
 export default class Set<T = number> implements ISet<T> {
     private _data;
-    constructor(...inputs: T[]);
+    constructor(...inputs: Readonly<T[]>);
     get data(): T[];
     get size(): number;
     has(element: T): boolean;

package/build/Stack/index.d.ts

@@ -1,7 +1,7 @@
 import DataStructure from '../DataStructure';
 import IStack from './IStack';
 export default class Stack<T = number> extends DataStructure<T> implements IStack<T> {
-    constructor(...inputs: T[]);
+    constructor(...inputs: Readonly<T[]>);
     push(element: T): T;
     pop(): T | undefined;
     peek(): T | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gabrielrufino/cube",
-  "version": "1.0.57",
+  "version": "1.0.61",
   "description": "Data Structures and Algorithms made in Typescript",
   "main": "build/index.js",
   "scripts": {
@@ -35,15 +35,15 @@
     "@stryker-mutator/jest-runner": "^6.3.1",
     "@stryker-mutator/typescript-checker": "^6.3.1",
     "@types/jest": "^28.1.8",
-    "@typescript-eslint/eslint-plugin": "^5.47.0",
-    "@typescript-eslint/parser": "^5.47.0",
+    "@typescript-eslint/eslint-plugin": "^5.50.0",
+    "@typescript-eslint/parser": "^5.50.0",
     "clinic": "^12.0.0",
-    "eslint": "^8.30.0",
+    "eslint": "^8.33.0",
     "eslint-config-xo": "^0.43.1",
     "jest": "^28.1.3",
     "rimraf": "^3.0.2",
     "ts-jest": "^28.0.8",
     "ts-node": "^10.9.1",
-    "typescript": "^4.9.4"
+    "typescript": "^4.9.5"
   }
 }