graph-typed 1.44.1 → 1.45.1

package/src/data-structures/heap/heap.ts

@@ -5,10 +5,10 @@
  * @license MIT License
  */
 
-import type {Comparator, DFSOrderPattern} from '../../types';
+import type { Comparator, DFSOrderPattern } from '../../types';
 
 export class Heap<E = any> {
-  constructor(options: {comparator: Comparator<E>; nodes?: E[]}) {
+  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
     this._comparator = options.comparator;
     if (options.nodes && options.nodes.length > 0) {
       this._nodes = options.nodes;
@@ -48,7 +48,7 @@ export class Heap<E = any> {
    * @returns A new Heap instance.
    * @param options
    */
-  static heapify<E>(options: {nodes: E[]; comparator: Comparator<E>}): Heap<E> {
+  static heapify<E>(options: { nodes: E[]; comparator: Comparator<E> }): Heap<E> {
     return new Heap<E>(options);
   }
 
@@ -265,7 +265,7 @@ export class Heap<E = any> {
    * @returns A new Heap instance containing the same elements.
    */
   clone(): Heap<E> {
-    const clonedHeap = new Heap<E>({comparator: this.comparator});
+    const clonedHeap = new Heap<E>({ comparator: this.comparator });
     clonedHeap._nodes = [...this.nodes];
     return clonedHeap;
   }
@@ -741,7 +741,10 @@ export class FibonacciHeap<E> {
   protected consolidate(): void {
     const A: (FibonacciHeapNode<E> | undefined)[] = new Array(this.size);
     const nodes = this.consumeLinkedList(this.root);
-    let x: FibonacciHeapNode<E> | undefined, y: FibonacciHeapNode<E> | undefined, d: number, t: FibonacciHeapNode<E> | undefined;
+    let x: FibonacciHeapNode<E> | undefined,
+      y: FibonacciHeapNode<E> | undefined,
+      d: number,
+      t: FibonacciHeapNode<E> | undefined;
 
     for (const node of nodes) {
       x = node;

package/src/data-structures/heap/max-heap.ts

@@ -6,12 +6,12 @@
  * @license MIT License
  */
 
-import {Heap} from './heap';
-import type {Comparator} from '../../types';
+import { Heap } from './heap';
+import type { Comparator } from '../../types';
 
 export class MaxHeap<E = any> extends Heap<E> {
   constructor(
-    options: {comparator: Comparator<E>; nodes?: E[]} = {
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

package/src/data-structures/heap/min-heap.ts

@@ -6,12 +6,12 @@
  * @license MIT License
  */
 
-import {Heap} from './heap';
-import type {Comparator} from '../../types';
+import { Heap } from './heap';
+import type { Comparator } from '../../types';
 
 export class MinHeap<E = any> extends Heap<E> {
   constructor(
-    options: {comparator: Comparator<E>; nodes?: E[]} = {
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -826,7 +826,7 @@ export class DoublyLinkedList<E = any> {
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */
-  *[Symbol.iterator]() {
+  * [Symbol.iterator]() {
     let current = this.head;
 
     while (current) {

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -773,7 +773,7 @@ export class SinglyLinkedList<E = any> {
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */
-  *[Symbol.iterator]() {
+  * [Symbol.iterator]() {
     let current = this.head;
 
     while (current) {

package/src/data-structures/matrix/matrix.ts

@@ -14,8 +14,8 @@ export class MatrixNTI2D<V = any> {
    * given initial value or 0 if not provided.
    * @param options - An object containing the following properties:
    */
-  constructor(options: {row: number; col: number; initialVal?: V}) {
-    const {row, col, initialVal} = options;
+  constructor(options: { row: number; col: number; initialVal?: V }) {
+    const { row, col, initialVal } = options;
     this._matrix = new Array(row).fill(undefined).map(() => new Array(col).fill(initialVal || 0));
   }
 

package/src/data-structures/matrix/matrix2d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import {Vector2D} from './vector2d';
+import { Vector2D } from './vector2d';
 
 export class Matrix2D {
   protected readonly _matrix: number[][];

package/src/data-structures/matrix/navigator.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {Direction, NavigatorParams, Turning} from '../../types';
+import type { Direction, NavigatorParams, Turning } from '../../types';
 
 export class Character {
   direction: Direction;
@@ -37,7 +37,7 @@ export class Navigator<T = number> {
    * in the matrix.
    * @param  - - `matrix`: a 2D array representing the grid or map
    */
-  constructor({matrix, turning, onMove, init: {cur, charDir, VISITED}}: NavigatorParams<T>) {
+  constructor({ matrix, turning, onMove, init: { cur, charDir, VISITED } }: NavigatorParams<T>) {
     this._matrix = matrix;
     this._cur = cur;
     this._character = new Character(charDir, turning);
@@ -53,7 +53,7 @@ export class Navigator<T = number> {
    */
   start() {
     while (this.check(this._character.direction) || this.check(this._character.turn().direction)) {
-      const {direction} = this._character;
+      const { direction } = this._character;
       if (this.check(direction)) {
         this.move(direction);
       } else if (this.check(this._character.turn().direction)) {

package/src/data-structures/matrix/vector2d.ts

@@ -10,7 +10,8 @@ export class Vector2D {
     public x: number = 0,
     public y: number = 0,
     public w: number = 1 // needed for matrix multiplication
-  ) {}
+  ) {
+  }
 
   /**
    * The function checks if the x and y values of a point are both zero.

package/src/data-structures/priority-queue/max-priority-queue.ts

@@ -5,12 +5,12 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import {PriorityQueue} from './priority-queue';
-import type {Comparator} from '../../types';
+import { PriorityQueue } from './priority-queue';
+import type { Comparator } from '../../types';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    options: {comparator: Comparator<E>; nodes?: E[]} = {
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

package/src/data-structures/priority-queue/min-priority-queue.ts

@@ -5,12 +5,12 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import {PriorityQueue} from './priority-queue';
-import type {Comparator} from '../../types';
+import { PriorityQueue } from './priority-queue';
+import type { Comparator } from '../../types';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    options: {comparator: Comparator<E>; nodes?: E[]} = {
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

package/src/data-structures/priority-queue/priority-queue.ts

@@ -6,11 +6,11 @@
  * @license MIT License
  */
 
-import {Heap} from '../heap';
-import {Comparator} from '../../types';
+import { Heap } from '../heap';
+import { Comparator } from '../../types';
 
 export class PriorityQueue<E = any> extends Heap<E> {
-  constructor(options: {comparator: Comparator<E>; nodes?: E[]}) {
+  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
     super(options);
   }
 }

package/src/data-structures/queue/deque.ts

@@ -5,11 +5,12 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import {DoublyLinkedList} from '../linked-list';
+import { DoublyLinkedList } from '../linked-list';
 
 // O(n) time complexity of obtaining the value
 // O(1) time complexity of adding at the beginning and the end
-export class Deque<E = any> extends DoublyLinkedList<E> {}
+export class Deque<E = any> extends DoublyLinkedList<E> {
+}
 
 // O(1) time complexity of obtaining the value
 // O(n) time complexity of adding at the beginning and the end
@@ -19,9 +20,9 @@ export class ObjectDeque<E = number> {
     if (capacity !== undefined) this._capacity = capacity;
   }
 
-  protected _nodes: {[key: number]: E} = {};
+  protected _nodes: { [key: number]: E } = {};
 
-  get nodes(): {[p: number]: E} {
+  get nodes(): { [p: number]: E } {
     return this._nodes;
   }
 

package/src/data-structures/queue/queue.ts

@@ -3,7 +3,7 @@
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-import {SinglyLinkedList} from '../linked-list';
+import { SinglyLinkedList } from '../linked-list';
 
 export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
   /**
@@ -300,7 +300,7 @@ export class Queue<E = any> {
     return new Queue(this.nodes.slice(this.offset));
   }
 
-  *[Symbol.iterator]() {
+  * [Symbol.iterator]() {
     for (const item of this.nodes) {
       yield item;
     }

package/src/data-structures/tree/tree.ts

@@ -27,7 +27,7 @@ export class TreeNode<V = any> {
         if (level > maxDepth) {
           maxDepth = level;
         }
-        const {children} = node;
+        const { children } = node;
         if (children) {
           for (let i = 0, len = children.length; i < len; i++) {
             bfs(children[i], level + 1);

package/src/data-structures/trie/trie.ts

@@ -164,7 +164,7 @@ export class Trie {
         if (level > maxDepth) {
           maxDepth = level;
         }
-        const {children} = node;
+        const { children } = node;
         if (children) {
           for (const child of children.entries()) {
             bfs(child[1], level + 1);

package/src/interfaces/binary-tree.ts

@@ -1,5 +1,5 @@
-import {BinaryTreeNode} from '../data-structures';
-import {BinaryTreeNodeNested, BiTreeDeleteResult, BTNCallback, BTNKey} from '../types';
+import { BinaryTreeNode } from '../data-structures';
+import { BinaryTreeNodeNested, BiTreeDeleteResult, BTNCallback, BTNKey } from '../types';
 
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>> {
   createNode(key: BTNKey, value?: N['value']): N;

package/src/interfaces/graph.ts

@@ -1,4 +1,4 @@
-import {VertexKey} from '../types';
+import { VertexKey } from '../types';
 
 export interface IGraph<V, E, VO, EO> {
   createVertex(key: VertexKey, value?: V): VO;

package/src/types/data-structures/binary-tree/avl-tree.ts

@@ -1,5 +1,5 @@
-import {AVLTreeNode} from '../../../data-structures';
-import {BSTOptions} from './bst';
+import { AVLTreeNode } from '../../../data-structures';
+import { BSTOptions } from './bst';
 
 export type AVLTreeNodeNested<T> = AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 export type AVLTreeOptions = BSTOptions & {};

package/src/types/data-structures/binary-tree/binary-tree.ts

@@ -1,4 +1,4 @@
-import {BinaryTreeNode} from '../../../data-structures';
+import { BinaryTreeNode } from '../../../data-structures';
 
 /**
  * Enum representing different loop types.

package/src/types/data-structures/binary-tree/bst.ts

@@ -1,5 +1,5 @@
-import {BSTNode} from '../../../data-structures';
-import type {BinaryTreeOptions, BTNKey} from './binary-tree';
+import { BSTNode } from '../../../data-structures';
+import type { BinaryTreeOptions, BTNKey } from './binary-tree';
 
 export type BSTComparator = (a: BTNKey, b: BTNKey) => number;
 

package/src/types/data-structures/binary-tree/rb-tree.ts

@@ -1,5 +1,5 @@
-import {RedBlackTreeNode} from '../../../data-structures';
-import {BSTOptions} from "./bst";
+import { RedBlackTreeNode } from '../../../data-structures';
+import { BSTOptions } from "./bst";
 
 export enum RBTNColor { RED = 1, BLACK = 0}
 

package/src/types/data-structures/binary-tree/tree-multimap.ts

@@ -1,5 +1,5 @@
-import {TreeMultimapNode} from '../../../data-structures';
-import {AVLTreeOptions} from './avl-tree';
+import { TreeMultimapNode } from '../../../data-structures';
+import { AVLTreeOptions } from './avl-tree';
 
 export type TreeMultimapNodeNested<T> = TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 

package/src/types/data-structures/hash/hash-map.ts

@@ -1 +1,17 @@
-export {};
+export const enum IterateDirection {
+  DEFAULT = 0,
+  REVERSE = 1
+}
+
+export type HashMapOptions<T> = {
+  sizeFunction?: number | (() => number);
+  fixedLength?: number;
+  forEach: (callback: (el: T) => void) => void;
+};
+
+export type HashMapLinkedNode<K, V> = {
+  key: K;
+  value: V;
+  next: HashMapLinkedNode<K, V>;
+  prev: HashMapLinkedNode<K, V>;
+};

package/src/types/data-structures/hash/index.ts

@@ -1 +1,8 @@
+export * from './coordinate-map';
+export * from './coordinate-set';
+export * from './hash-map';
+export * from './hash-table';
+export * from './tree-map';
+export * from './tree-set';
+
 export type HashFunction<K> = (key: K) => number;

package/src/types/data-structures/matrix/navigator.ts

@@ -1,6 +1,6 @@
 export type Direction = 'up' | 'right' | 'down' | 'left';
 
-export type Turning = {[key in Direction]: Direction};
+export type Turning = { [key in Direction]: Direction };
 
 export type NavigatorParams<T = any> = {
   matrix: T[][];

package/src/types/utils/utils.ts

@@ -1,5 +1,5 @@
 export type ToThunkFn = () => ReturnType<TrlFn>;
-export type Thunk = () => ReturnType<ToThunkFn> & {__THUNK__: symbol};
+export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: symbol };
 export type TrlFn = (...args: any[]) => any;
 export type TrlAsyncFn = (...args: any[]) => any;
 

package/src/types/utils/validate-type.ts

@@ -1,6 +1,6 @@
-export type KeyValueObject = {[key: string]: any};
+export type KeyValueObject = { [key: string]: any };
 
-export type KeyValueObjectWithKey = {[key: string]: any; key: string | number | symbol};
+export type KeyValueObjectWithKey = { [key: string]: any; key: string | number | symbol };
 
 export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
 
@@ -16,6 +16,20 @@ export type ObjectWithNumberKey = {
   key: number;
 };
 
-export type RestrictValByKey = NonNumberNonObjectButDefined | ObjectWithoutKey | ObjectWithNonNumberKey | ObjectWithNumberKey;
+export type RestrictValByKey =
+  | NonNumberNonObjectButDefined
+  | ObjectWithoutKey
+  | ObjectWithNonNumberKey
+  | ObjectWithNumberKey;
 
-export type DummyAny = string | number | boolean | null | undefined | object | symbol | void | ((...args: []) => any) | never;
+export type DummyAny =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined
+  | object
+  | symbol
+  | void
+  | ((...args: []) => any)
+  | never;

package/src/utils/utils.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {Thunk, ToThunkFn, TrlAsyncFn, TrlFn} from '../types';
+import type { Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from '../types';
 
 export const uuidV4 = function () {
   return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
@@ -57,7 +57,7 @@ export const trampoline = (fn: TrlFn) => {
 
       return result;
     },
-    {cont}
+    { cont }
   );
 };
 
@@ -74,7 +74,7 @@ export const trampolineAsync = (fn: TrlAsyncFn) => {
 
       return result;
     },
-    {cont}
+    { cont }
   );
 };
 
@@ -84,3 +84,16 @@ export const getMSB = (value: number): number => {
   }
   return 1 << (31 - Math.clz32(value));
 };
+
+export const rangeCheck = (index: number, min: number, max: number, message = 'Index out of bounds.'): void => {
+  if (index < min || index > max) throw new RangeError(message);
+};
+
+export const throwRangeError = (message = 'The value is off-limits.'): void => {
+  throw new RangeError(message);
+};
+
+export const isObjOrFunc = (input: unknown): input is Record<string, unknown> | ((...args: any[]) => any) => {
+  const inputType = typeof input;
+  return (inputType === 'object' && input !== null) || inputType === 'function';
+};