data-footstone - npm Package Compare versions

Comparing version 0.1.22 to 0.1.23-beta.1

tscDist/typings/baseType.d.ts

+declare type S = string;
+declare type N = number;
+declare type B = boolean;
+declare type A = any;
+declare type F = Function;
+declare type D = Date;
+export { S, N, B, A, F, D };

tscDist/typings/baseType.js

+export {};

tscDist/typings/chain.d.ts

+import { N, B } from './baseType';
+interface BaseChainElement<T> {
+    value: T;
+    next: BaseChainElement<T> | null;
+}
+interface BaseChain<T> {
+    readonly capacity: N;
+    head: BaseChainElement<T> | null;
+    toArray: () => T[];
+    isValidRange: (p: N) => B;
+}
+interface SingleChainElement<T> {
+    value: T;
+    position: N;
+    next: SingleChainElementOrNull<T>;
+}
+declare type SingleChainElementOrNull<T> = SingleChainElement<T> | null;
+interface SingleChain<T> extends BaseChain<T> {
+    head: SingleChainElementOrNull<T>;
+    length: N;
+    createNode: (v: T, p: N) => SingleChainElement<T>;
+    append: (p: T) => Error | N;
+    insert: (p: T, position: N) => B;
+    removeAt: (position: N) => T | undefined;
+    reverseSelf: () => void;
+    reverse: () => SingleChain<T>;
+    clear: () => void;
+    setPosition: (from: N) => void;
+    slice: (from: N, to: N) => void;
+}
+interface DoublyChainElement<T> {
+    value: T;
+    position: N;
+    next: DoublyChainElement<T> | null;
+    prev: DoublyChainElement<T> | null;
+}
+interface IDoublyChain<T> {
+    head: DoublyChainElement<T> | null;
+    tail: DoublyChainElement<T> | null;
+    length: N;
+    createNode: (v: T, p: N) => DoublyChainElement<T>;
+    append: (p: T) => Error | N;
+    insert: (v: T, p: N) => B;
+    removeAt: (p: N) => T | undefined;
+    toArray: () => T[];
+    clear: () => void;
+    setPosition: (from: N) => void;
+}
+interface SingleCircleChainElement<T> {
+    value: T;
+    position: N;
+    next: SingleCircleChainElement<T> | null;
+}
+interface SingleCircleChain<T> extends Pick<SingleChain<T>, 'length' | 'createNode' | 'append' | 'insert' | 'removeAt' | 'slice'> {
+    head: SingleCircleChainElement<T> | null;
+    tail: SingleCircleChainElement<T> | null;
+}
+interface DoublyCircleChainElement<T> {
+    value: T;
+    position: N;
+    next: DoublyCircleChainElement<T> | null;
+    prev: DoublyCircleChainElement<T> | null;
+}
+interface DoublyCircleChain<T> {
+    createNode: (v: T, p: N) => DoublyCircleChainElement<T>;
+    append: (v: T) => Error | N;
+    insert: (v: T, p: N) => B;
+    removeAt: (p: N) => T | undefined;
+}
+export { BaseChainElement, BaseChain, SingleChainElement, SingleChainElementOrNull, SingleChain, DoublyChainElement, IDoublyChain, SingleCircleChainElement, SingleCircleChain, DoublyCircleChainElement, DoublyCircleChain, };

tscDist/typings/chain.js

+export {};

tscDist/typings/graph.d.ts

+import { F, N, A, S } from './baseType';
+declare type ShortestPathObj<T> = {
+    distance: Map<T, N>;
+    predecessors: Map<T, T>;
+};
+interface Vertex<T> {
+    data: T;
+    inDegree: N;
+    outDegree: N;
+    status: A;
+    dTime: N;
+    fTime: N;
+}
+interface Edge<T> {
+    data: A;
+    start: Vertex<T>;
+    end: Vertex<T>;
+    weight: N;
+    status: A;
+}
+declare type EdgeOrNull<T> = Edge<T> | null;
+interface Graph<T> {
+    vertexMap: Map<T, Vertex<T>>;
+    adjMatrix: Map<T, Map<T, EdgeOrNull<T>>>;
+    adjTable: Map<T, Set<Vertex<T>>>;
+    createVertex: (v: T) => Vertex<T>;
+    createEdge: (a: T, b: T) => Edge<T>;
+    putVertex: (a: T) => void;
+    edgeList: () => Edge<T>[];
+    removeVertex: (a: T) => Vertex<T> | undefined;
+    bfs: (data: T, cb: F) => void;
+    dfs: (data: T, cb: F) => void;
+    shortestPath: (data: T) => ShortestPathObj<T>;
+    getPath: (from: T, to: T) => T[];
+    reset: (p: S) => void;
+}
+interface DirectionGraph<T> extends Graph<T> {
+    putEdge: (a: T, b: T) => void;
+    removeEdge: (a: T, b: T) => Edge<T> | undefined;
+}
+interface UndirectionGraph<T> extends Graph<T> {
+    putEdge: (a: T, b: T) => void;
+    removeEdge: (a: T, b: T) => Edge<T>[];
+}
+export { Vertex, Edge, EdgeOrNull, Graph, DirectionGraph, UndirectionGraph, };

tscDist/typings/graph.js

+export {};

tscDist/typings/hashMap.d.ts

+import { N, A } from './baseType';
+import { SingleChain } from './chain';
+declare type HashMapKind = 'separate' | 'line';
+declare type HashMapHash = 'djb2' | 'loselose';
+interface HashMapBoxItem<G> {
+    key: A;
+    value: G;
+}
+declare type HashMapBox<G> = HashMapBoxItem<G>[];
+declare type HashFn = (p: A) => N;
+interface HashMap<G> {
+    box: SingleChain<G> | HashMapBox<G>;
+    _size: N;
+    kind: HashMapKind;
+    hash: HashMapHash;
+    createNode: (k: A, v: G) => HashMapBoxItem<G>;
+    _put: (k: A, v: G) => N;
+    _hashFn: (k: A) => N;
+    _remove: (k: A) => G;
+    _get: (k: A) => HashMapBoxItem<G> | undefined;
+    put: (k: A, v: G) => N;
+    remove: (k: A) => G;
+    get: (k: A) => G | undefined;
+    hashFn: (k: A) => N;
+    size: () => N;
+}
+export { HashMapKind, HashMapHash, HashMap, HashFn };

tscDist/typings/hashMap.js

+export {};

tscDist/typings/index.d.ts

+import { S, N, B, A, F } from './baseType';
+import { BaseQueue, Queue, PriorityQueueNode, PriorityQueue } from './queue';
+import { PSet } from './pSet';
+import { PMap } from './pMap';
+import { BaseChainElement, BaseChain, SingleChainElement, SingleChainElementOrNull, SingleChain, DoublyChainElement, IDoublyChain, SingleCircleChainElement, SingleCircleChain, DoublyCircleChainElement, DoublyCircleChain } from './chain';
+import { HashMap, HashMapKind, HashMapHash, HashFn } from './hashMap';
+import { Vertex, Edge, EdgeOrNull, Graph, DirectionGraph, UndirectionGraph } from './graph';
+import { Stack } from './stack';
+import { Cache, CacheNode, CacheOption, FifoNode, Fifo, LfuNode, Lfu } from './store';
+import { OrderType } from './sort';
+export { S, N, B, A, F, Stack, BaseQueue, Queue, PriorityQueue, PriorityQueueNode, BaseChainElement, BaseChain, SingleChainElement, SingleChainElementOrNull, SingleChain, DoublyChainElement, IDoublyChain, SingleCircleChain, SingleCircleChainElement, DoublyCircleChain, DoublyCircleChainElement, PSet, PMap, HashMap, HashMapKind, HashMapHash, HashFn, Vertex, Edge, EdgeOrNull, Graph, DirectionGraph, UndirectionGraph, Cache, CacheNode, CacheOption, FifoNode, Fifo, LfuNode, Lfu, OrderType, };

tscDist/typings/index.js

+export {};

tscDist/typings/pMap.d.ts

+import { N, B } from './baseType';
+interface PMap<T, G> {
+    box: Map<T, G>;
+    set: (k: T, v: G) => void;
+    delete: (k: T) => B;
+    has: (k: T) => B;
+    get: (k: T) => G;
+    clear: () => void;
+    size: () => N;
+    keys: () => T[];
+    values: () => G[];
+}
+export { PMap };

tscDist/typings/pMap.js

+export {};

tscDist/typings/pSet.d.ts

+import { N, B } from './baseType';
+interface PSet<T> {
+    box: Set<T>;
+    add: (v: T) => void;
+    delete: (v: T) => B;
+    has: (v: T) => B;
+    clear: () => void;
+    size: () => N;
+    values: () => T[];
+    concat: (...v: PSet<T>[]) => PSet<T>;
+    intersect: (...v: PSet<T>[]) => PSet<T>;
+    diffSet: (...v: PSet<T>[]) => PSet<T>;
+    subSetOf: (v: PSet<T>) => B;
+}
+export { PSet };

tscDist/typings/pSet.js

+export {};

tscDist/typings/queue.d.ts

+import { N, B, A } from './baseType';
+interface BaseQueue {
+    items: A[];
+    readonly capacity: N;
+    getHead: () => A;
+    getTail: () => A;
+    size: () => N;
+    isEmpty: () => B;
+    clear: () => void;
+}
+interface Queue<T> extends BaseQueue {
+    items: T[];
+    enqueue: (p: T) => Error | N;
+    dequeue: () => T;
+    toArray: () => T[];
+    clear: () => void;
+    reverse: () => void;
+    peek: () => T | undefined;
+}
+interface PriorityQueueNode<T> {
+    value: T;
+    position: N;
+    priority: N;
+}
+interface PriorityQueue<T> {
+    items: PriorityQueueNode<T>[];
+    defaultPriority: N;
+    enqueue: (element: T, priority?: N, positionFlag?: B, needSetPosition?: B) => Error | N;
+    dequeue: () => T;
+    highestPriority: () => N | undefined;
+    toArray: () => T[];
+    getHead: () => T;
+    getTail: () => T;
+    size: () => N;
+    isEmpty: () => B;
+    clear: () => void;
+    updatePriorityAt: (p: N, v: N, positionFlag?: B) => B;
+    updateDimension: (v: N) => void;
+    peek: () => T | undefined;
+}
+export { BaseQueue, Queue, PriorityQueueNode, PriorityQueue };

tscDist/typings/queue.js

+export {};

tscDist/typings/sort.d.ts

+declare type OrderType = 'asc' | 'des';
+export { OrderType };

tscDist/typings/sort.js

+export {};

tscDist/typings/stack.d.ts

+import { N, B } from './baseType';
+interface Stack<T> {
+    readonly capacity: N;
+    toArray: () => T[];
+    push: (p: T) => Error | N;
+    pop: () => T;
+    peek: () => T;
+    isEmpty: () => B;
+    clear: () => void;
+    size: () => N;
+}
+export { Stack };

tscDist/typings/stack.js

+export {};

tscDist/typings/store.d.ts

+import { N } from './baseType';
+import { SingleChain, IDoublyChain } from './chain';
+import { DoublyChainElement } from './chain';
+interface CacheNode<K, V> {
+    flushTime: N;
+    key: K;
+    value: V;
+}
+interface CacheOption {
+    size: N;
+    policy: 'lru' | 'fifo';
+    expiration: N;
+    period: N;
+}
+interface Cache<K, V> {
+    get: (k: K) => V | undefined;
+    put: (k: K, v: V) => void;
+    _createNode: (k: K, v: V, f: N) => CacheNode<K, V>;
+    _flush: () => void;
+    _setIntervalFlush: () => void;
+}
+interface FifoNode<K, V> {
+    key: K;
+    value: V;
+}
+interface Fifo<K, V> {
+    capacity: N;
+    chain: SingleChain<FifoNode<K, V>>;
+    _createNode: (k: K, v: V) => FifoNode<K, V>;
+    get: (k: K) => V | undefined;
+    put: (k: K, v: V) => N;
+    size: () => N;
+    keys: () => K[];
+    values: () => V[];
+}
+interface LfuNode<K, V> {
+    key: K;
+    value: V;
+    count: N;
+}
+interface Lfu<K, V> {
+    capacity: N;
+    chain: IDoublyChain<LfuNode<K, V>>;
+    _createNode: (k: K, v: V, c: N) => LfuNode<K, V>;
+    _get: (k: K) => DoublyChainElement<LfuNode<K, V>> | undefined;
+    get: (k: K) => V | undefined;
+    put: (k: K, v: V) => N;
+    size: () => N;
+    keys: () => K[];
+    values: () => V[];
+}
+export { Cache, CacheOption, CacheNode, FifoNode, Fifo, LfuNode, Lfu };

tscDist/typings/store.js

+export {};

tscDist/typings/tree.d.ts

+import { N, B, F } from './baseType';
+interface BinaryTreeNode<T> {
+    value: T;
+    left: BinaryTreeNodeOrNull<T>;
+    right: BinaryTreeNodeOrNull<T>;
+    parent: BinaryTreeNodeOrNull<T>;
+    isRoot: () => B;
+    hasParent: () => B;
+    hasLeft: () => B;
+    hasRight: () => B;
+    hasChild: () => B;
+    hasBothChild: () => B;
+    isLeaf: () => B;
+}
+declare type BinaryTreeNodeOrNull<T> = (BinaryTreeNode<T> | null);
+interface BinaryTree<T> {
+    root: BinaryTreeNodeOrNull<T>;
+    createBTNode: (v: T) => BinaryTreeNode<T>;
+    insertAsLeft: (parent: BinaryTreeNode<T>, current: T) => void;
+    insertAsRight: (parent: BinaryTreeNode<T>, current: T) => void;
+    _preOrderTraverse: (cb: F, node: BinaryTreeNodeOrNull<T>) => void;
+    _inOrderTraverse: (cb: F, node: BinaryTreeNodeOrNull<T>) => void;
+    _postOrderTraverse: (cb: F, node: BinaryTreeNodeOrNull<T>) => void;
+    _levelTraverse: (cb: F, node: BinaryTreeNodeOrNull<T>) => void;
+    isEmpty: () => B;
+    _height: (node: BinaryTreeNodeOrNull<T>, h: N) => N;
+    height: (node: BinaryTreeNodeOrNull<T>) => N;
+    deep: (node: BinaryTreeNodeOrNull<T>) => N;
+    minDeep: () => N;
+    getLevelNode: (p: N) => BinaryTreeNode<T>[];
+    isProper: () => B;
+    vertexCount: () => N;
+    isFull: () => B;
+    isComplete: () => B;
+}
+declare type BinarySearchTreeOrder = 'preOrder' | 'inOrder' | 'postOrder' | 'level';
+interface BinarySearchTreeNode<T> extends BinaryTreeNode<T> {
+    key: N;
+    value: T | null;
+    left: BinarySearchTreeNodeOrNull<T>;
+    right: BinarySearchTreeNodeOrNull<T>;
+    parent: BinarySearchTreeNode<T>;
+    clone: () => BinarySearchTreeNode<T>;
+    'operator<': (otherNode: BinarySearchTreeNode<T>) => B;
+    'operator>': (otherNode: BinarySearchTreeNode<T>) => B;
+    'operator===': (otherNode: BinarySearchTreeNode<T>) => B;
+    'operator!==': (otherNode: BinarySearchTreeNode<T>) => B;
+    isLeft: () => B;
+    isRight: () => B;
+    sibling: () => BinarySearchTreeNodeOrNull<T>;
+    uncle: () => BinarySearchTreeNodeOrNull<T>;
+}
+declare type BinarySearchTreeNodeOrNull<T> = BinarySearchTreeNode<T> | null;
+interface BinarySearchTree<T> extends Pick<BinaryTree<T>, '_preOrderTraverse' | '_inOrderTraverse' | '_postOrderTraverse'> {
+    root: BinarySearchTreeNodeOrNull<T>;
+    createBSTNode: (k: N, v: T) => BinarySearchTreeNode<T>;
+    insertAsLeft: () => Error;
+    insertAsRight: () => Error;
+    insert: (k: N, v: T) => Error | BinarySearchTreeNode<T>;
+    _insertNode: (n0: BinarySearchTreeNode<T>, n1: BinarySearchTreeNode<T>) => void;
+    search: (k: N) => BinarySearchTreeNodeOrNull<T>;
+    traverse: (fn: F, order: BinarySearchTreeOrder) => void;
+    min: () => T | undefined;
+    max: () => T | undefined;
+    findMinNode: (node: BinarySearchTreeNodeOrNull<T>) => BinarySearchTreeNodeOrNull<T>;
+    findMaxNode: (node: BinarySearchTreeNodeOrNull<T>) => BinarySearchTreeNodeOrNull<T>;
+    _remove: (node: BinarySearchTreeNodeOrNull<T>, k: N) => BinarySearchTreeNodeOrNull<T>;
+    remove: (k: N) => void;
+}
+interface AVLTree<T> extends BinarySearchTree<T> {
+    insert: (k: N, v: T) => Error | BinarySearchTreeNode<T>;
+    _insertNode: (n0: BinarySearchTreeNode<T>, n1: BinarySearchTreeNode<T>) => void;
+    _rotationRR: (node: BinarySearchTreeNode<T>) => BinarySearchTreeNode<T>;
+    _rotationLL: (node: BinarySearchTreeNode<T>) => BinarySearchTreeNode<T>;
+    _rotationLR: (node: BinarySearchTreeNode<T>) => BinarySearchTreeNode<T>;
+    _rotationRL: (node: BinarySearchTreeNode<T>) => BinarySearchTreeNode<T>;
+    _connect34: (a: BinarySearchTreeNode<T>, b: BinarySearchTreeNode<T>, c: BinarySearchTreeNode<T>, t0: BinarySearchTreeNodeOrNull<T>, t1: BinarySearchTreeNodeOrNull<T>, t2: BinarySearchTreeNodeOrNull<T>, t3: BinarySearchTreeNodeOrNull<T>) => BinarySearchTreeNode<T>;
+    rotateAt: (v: BinarySearchTreeNode<T>) => BinarySearchTreeNode<T>;
+    remove: (k: N) => B;
+}
+interface RedBackTree<T> extends BinarySearchTree<T> {
+}
+interface SplayTree<T> extends BinarySearchTree<T> {
+    splay: (v: BinarySearchTreeNodeOrNull<T>) => BinarySearchTreeNodeOrNull<T>;
+    searchSplayTreeNode: (k: N) => BinarySearchTreeNodeOrNull<T>;
+    insertSplayTreeNode: (k: N, v: T) => Error | BinarySearchTreeNode<T>;
+}
+interface BTreeNode<T> {
+    nodeList: [];
+    childList: [];
+}
+declare type BTreeNodeOrNull<T> = (BTreeNode<T> | null);
+interface BTree<T> {
+    order: N;
+    searchBTreeNode: (k: N) => BTreeNodeOrNull<T>;
+    insertBTreeNode: (k: N, v: T) => BTreeNode<T>;
+    remove: (k: N) => BTreeNode<T>;
+    resolveOverflow: (n: BTreeNode<T>) => void;
+    resolveUnderflow: (n: BTreeNode<T>) => void;
+}
+export { BinaryTreeNode, BinaryTreeNodeOrNull, BinaryTree, BinarySearchTreeNode, BinarySearchTreeNodeOrNull, BinarySearchTree, AVLTree, SplayTree, RedBackTree, BTreeNode, BTree, };

tscDist/typings/tree.js

+export {};

package.json

 {
   "name": "data-footstone",
-  "version": "0.1.22",
+  "version": "0.1.23-beta.1",
   "description": "data structure",
@@ -9,3 +9,3 @@ "author": "feigebaobei <[e-mail]>",
   "type": "module",
-  "types": "./tscDist/src/typings/index.d.ts",
+  "types": "./tscDist/src/index.d.ts",
   "directories": {
@@ -18,3 +18,3 @@ "lib": "lib",
       "import": "./tscDist/index.js",
-      "types": "./tscDist/src/typings/index.d.ts"
+      "types": "./tscDist/src/index.d.ts"
     }
@@ -21,0 +21,0 @@ },

tscDist/src/chain.d.ts

@@ -1,2 +0,2 @@
-import { BaseChainElement as BCE, BaseChain as BC, SingleChain as SC, SingleChainElementOrNull as SCEON, IDoublyChain as DC, DoublyChainElement as DCE, SingleCircleChain as SCC, SingleCircleChainElement as SCCE, DoublyCircleChain as DCC, N } from './typings';
+import { BaseChainElement as BCE, BaseChain as BC, SingleChain as SC, SingleChainElementOrNull as SCEON, IDoublyChain as DC, DoublyChainElement as DCE, SingleCircleChain as SCC, SingleCircleChainElement as SCCE, DoublyCircleChain as DCC, N } from '../typings';
 declare class BaseChain<T> implements BC<T> {
@@ -3,0 +3,0 @@ head: BCE<T> | SCEON<T>;

tscDist/src/graph.d.ts

@@ -1,2 +0,2 @@
-import { Vertex as V, Edge as E, Graph as G, DirectionGraph as DG, UndirectionGraph as UG, F, S } from './typings';
+import { Vertex as V, Edge as E, Graph as G, DirectionGraph as DG, UndirectionGraph as UG, F, S } from '../typings';
 declare class Graph<T> implements G<T> {
@@ -3,0 +3,0 @@ vertexMap: G<T>['vertexMap'];

tscDist/src/hashMap.d.ts

@@ -1,2 +0,2 @@
-import { HashMap as HM, HashMapKind as HMK, HashMapHash as HMH, HashFn, N, A } from './typings';
+import { HashMap as HM, HashMapKind as HMK, HashMapHash as HMH, HashFn, N, A } from '../typings';
 declare let djb2HashFn: HashFn;
@@ -3,0 +3,0 @@ declare let loseloseHashFn: HashFn;

tscDist/src/helper.d.ts

@@ -1,2 +0,2 @@
-import { S, A } from './typings';
+import { S, A } from '../typings';
 declare let af: {
@@ -3,0 +3,0 @@ <T>(arrayLike: ArrayLike<T>): T[];

tscDist/src/pMap.d.ts

@@ -1,2 +0,2 @@
-import { PMap as FM } from './typings';
+import { PMap as FM } from '../typings';
 declare class PMap<T, G> implements FM<T, G> {
@@ -3,0 +3,0 @@ box: Map<T, G>;

tscDist/src/pSet.d.ts

@@ -1,2 +0,2 @@
-import { PSet as PS } from './typings';
+import { PSet as PS } from '../typings';
 declare class PSet<T> implements PS<T> {
@@ -3,0 +3,0 @@ box: Set<T>;

tscDist/src/queue.d.ts

@@ -1,2 +0,2 @@
-import { BaseQueue as BQ, Queue as Q, PriorityQueue as PQ, PriorityQueueNode as PQE, A, N, B } from './typings';
+import { BaseQueue as BQ, Queue as Q, PriorityQueue as PQ, PriorityQueueNode as PQE, A, N, B } from '../typings';
 declare class BaseQueue implements BQ {
@@ -3,0 +3,0 @@ items: A[];

tscDist/src/search.d.ts

@@ -1,3 +0,3 @@
-import { A } from './typings';
+import { A } from '../typings';
 declare let binarySearch: (arr: A[], item: A) => number;
 export { binarySearch };

tscDist/src/sort.d.ts

@@ -1,2 +0,2 @@
-import { S, A, OrderType } from './typings';
+import { S, A, OrderType } from '../typings';
 declare let bubbleSort: (arr: A[], order?: OrderType) => any[];
@@ -3,0 +3,0 @@ declare let selectSort: (arr: A[], order?: OrderType) => any[];

tscDist/src/stack.d.ts

@@ -1,2 +0,2 @@
-import { Stack as StackI, N } from './typings';
+import { Stack as StackI, N } from '../typings';
 declare class Stack<T> implements StackI<T> {
@@ -3,0 +3,0 @@ items: T[];

tscDist/src/store.d.ts

 import { DoublyChain } from './chain';
-import { DoublyChainElement as DCE, N, FifoNode as FFN, Fifo as FF, SingleChain as SC, IDoublyChain as DC, LfuNode as LN, Lfu as L } from './typings';
+import { DoublyChainElement as DCE, N, FifoNode as FFN, Fifo as FF, SingleChain as SC, IDoublyChain as DC, LfuNode as LN, Lfu as L } from '../typings';
 declare class Fifo<K, V> implements FF<K, V> {
@@ -4,0 +4,0 @@ capacity: N;

No alert changes

Improved metrics

Total package byte prevSize

545665

2.65%

Number of package files

114

26.67%

Lines of code

8738

4.91%

No dependency changes