@blackglory/structures
Advanced tools
Readme
Common structures.
npm install --save @blackglory/structures
# or
yarn add @blackglory/structures
class Box<T> {
get [Symbol.toStringTag](): string
constructor(value: T)
get(): T
set(value: T): void
}
function convertConsToArray<T>([value, next]: Cons<T>): T[]
function convertArrayToCons<T>([value, ...next]: T[]): Cons<T>
function sliceArrayLeft<T>(arr: T[], num: number): T[]
function sliceArrayRight<T>(arr: T[], num: number): T[]
function truncateArrayLeft<T>(arr: T[], num: number): void
function truncateArrayRight<T>(arr: T[], num: number): void
type Listener<Args extends unknown[]> = (...args: Args) => void
class Emitter<
EventToArgs extends Record<Event, unknown[]> = Record<
string | number | symbol
, unknown[]
>
, Event extends string | number | symbol = keyof EventToArgs
> {
get [Symbol.toStringTag](): string
on<T extends Event>(event: T, listener: Listener<EventToArgs[T]>): () => void
once<T extends Event>(event: T, listener: Listener<EventToArgs[T]>): () => void
emit<T extends Event>(event: T, ...args: EventToArgs[T]): void
removeAllListeners<T extends Event>(event: T): void
}
type Listener<Args extends unknown[], Yield, Next> = (...args: Args) =>
| void
| Generator<Yield, void, Next>
class GeneratorEmitter<
EventToArgs extends Record<Event, unknown[]> = Record<
string | number | symbol
, unknown[]
>
, Event extends string | number | symbol = keyof EventToArgs
, Yield = unknown
, Next = unknown
> {
get [Symbol.toStringTag](): string
on<T extends Event>(
event: T
, listener: Listener<EventToArgs[T], Yield, Next>
): () => void
once<T extends Event>(
event: T
, listener: Listener<EventToArgs[T], Yield, Next>
): () => void
emit<T extends Event>(
event: T
, ...args: EventToArgs[T]
): Generator<Yield, void, Next>
removeAllListeners<T extends Event>(event: T): void
}
type Listener<Args extends unknown[], Yield, Next> = (...args: Args) =>
| void
| Generator<Yield, void, Next>
| AsyncGenerator<Yield, void, Next>
class AsyncGeneratorEmitter<
EventToArgs extends Record<Event, unknown[]> = Record<
string | number | symbol
, unknown[]
>
, Event extends string | number | symbol = keyof EventToArgs
, Yield = unknown
, Next = unknown
> {
get [Symbol.toStringTag](): string
on<T extends Event>(event: T
, listener: Listener<EventToArgs[T], Yield, Next>
): () => void
once<T extends Event>(
event: T
, listener: Listener<EventToArgs[T], Yield, Next>
): () => void
emit<T extends Event>(
event: T
, ...args: EventToArgs[T]
): AsyncGenerator<Yield, void, Next>
removeAllListeners<T extends Event>(event: T): void
}
class BigMap<K, V> implements Iterable<[K, V]> {
get [Symbol.toStringTag](): string
get size(): number
set(key: K, value: V): void
has(key: K): boolean
get(key: K): V | undefined
delete(key: K): boolean
clear(): void
entries(): IterableIterator<[K, V]>
keys(): IterableIterator<K>
values(): IterableIterator<V>
}
The Map that supports unlimited elements.
Note that BigMap cannot preserve the insertion order of elements.
// Map
const map = new Map()
for (let i = 0; i < 100_000_000; i++) {
map.set(i, null) // RangeError
}
console.log('Never')
// BigMap
const { BigMap } = require('.')
const map = new BigMap()
for (let i = 0; i < 100_000_000; i++) {
map.set(i, null)
}
console.log('Done')
class BigSet<T> implements Iterable<T> {
get [Symbol.toStringTag]: string
get size(): number
add(value: T): this
has(value: T): boolean
delete(value: T): boolean
clear(): void
values(): IterableIterator<T>
}
The Set that supports unlimited elements.
Note that BigSet cannot preserve the insertion order of elements.
// Set
const set = new Set()
for (let i = 0; i < 100_000_000; i++) {
set.add(i) // RangeError
}
console.log('Never')
// BigSet
const set = new BigSet()
for (let i = 0; i < 100_000_000; i++) {
set.add(i)
}
console.log('Done')
class HashMap<K, V, Hash = unknown> {
get [Symbol.toStringTag](): string
get size(): number
constructor(hash: (key: K) => Hash)
set(key: K, value: V): this
has(key: K): boolean
get(key: K): V | undefined
delete(key: K): boolean
clear(): void
}
class HashSet<V, Hash = unknown> implements Iterable<V> {
get [Symbol.toStringTag](): string
get size(): number
[Symbol.iterator](): IterableIterator<V>
constructor(hash: (value: V) => Hash)
add(value: V): this
delete(value: V): boolean
has(value: V): boolean
clear(): void
values(): IterableIterator<V>
}
class LRUMap<K, V> {
get [Symbol.toStringTag](): string
get size(): number
constructor(limit: number)
set(key: K, value: V): this
has(key: K): boolean
get(key: K): V | undefined
delete(key: K): boolean
clear(): void
}
class ExpirableMap<K, V> {
get[Symbol.toStringTag](): string
get size(): number
constructor()
set(key: K, value: V, timeToLive?: number = Infinity): this
has(key: K): boolean
get(key: K): V | undefined
delete(key: K): boolean
clear(): void
}
class TLRUMap<K, V> {
get[Symbol.toStringTag](): string
get size(): number
constructor(limit: number)
set(key: K, value: V, timeToLive?: number = Infinity): this
has(key: K): boolean
get(key: K): V | undefined
delete(key: K): boolean
clear(): void
}
class Queue<T> {
get [Symbol.toStringTag](): string
get size(): number
empty(): void
enqueue(...items: T[]): void
dequeue(): T | undefined
remove(item: T): void
}
class TrieMap<K extends Iterable<T>, V, T = unknown> {
get [Symbol.toStringTag](): string
keys(): IterableIterator<T[]>
values(): IterableIterator<V>
entries(): IterableIterator<[key: T[], value: V]>
set(key: K, value: V): this
has(key: K): boolean
get(key: K): V | undefined
delete(key: K): boolean
}
Note that you might expect this data structure to be more space efficient than BigMap, but it doesn't.
In V8, it can only store about 80% of data of BigMap.
class StringTrieMap<T> {
get [Symbol.toStringTag](): string
keys(): IterableIterator<string>
values(): IterableIterator<T>
entries(): IterableIterator<[key: string, value: T]>
set(key: string, value: T): this
has(key: string): boolean
get(key: string): T | undefined
delete(key: string): boolean
}
Note that you might expect this data structure to be more space efficient than BigMap, but it doesn't.
In V8, it can only store about 80% of data of BigMap.
class RadixTree<K extends Iterable<T>, V, T = unknown> {
get [Symbol.toStringTag](): string
entries(): IterableIterator<[key: T[], value: V]>
keys(): IterableIterator<T[]>
values(): IterableIterator<V>
set(key: K, value: V): this
has(key: K): boolean
get(key: K): V | undefined
delete(key: K): boolean
}
Note that you might expect this data structure to be more space efficient than BigMap, but it doesn't.
In V8, it can only store about 80% of data of BigMap.
class StringRadixTree<T> {
get [Symbol.toStringTag](): string
keys(): IterableIterator<string>
values(): IterableIterator<T>
entries(): IterableIterator<[key: string, value: T]>
set(key: string, value: T): this
has(key: string): boolean
get(key: string): T | undefined
delete(key: string): boolean
}
Note that you might expect this data structure to be more space efficient than BigMap, but it doesn't.
In V8, it can only store about 80% of data of BigMap.
class SparseSet implements Iterable<number> {
get [Symbol.toStringTag](): string
get [Symbol.iterator](): IterableIterator<number>
get size(): number
constructor(array?: number[])
values(): IterableIterator<number>
has(value: number): boolean
add(value: number): void
delete(value: number): boolean
clear(): void
}
Note that SparseSet is not faster than JavaScript's built-in Set in many cases.
class SparseMap<T> {
get [Symbol.toStringTag](): string
get size(): number
/**
* `SparseMap` cannot respond to any operations on the internal array,
* you must ensure that indexes accessed are less than the length of `SparseMap`.
*
* Keys do not correspond to indexes of the array.
*/
get internalArray(): T[]
entries(): IterableIterator<[key: number, value: T]>
keys(): IterableIterator<number>
values(): IterableIterator<T>
getInternalIndexOfKey(key: number): number | undefined
has(key: number): boolean
get(key: number): T | undefined
set(key: number, value: T): void
delete(key: number): void
clear(): void
}
class DynamicTypedArray<T extends TypedArrayConstructor> {
get [Symbol.toStringTag](): string
get BYTES_PER_ELEMENT(): number
get capacity(): number
get length(): number
readonly growthFactor: number
/**
* `DynamicTypedArray` cannot respond to any operations on the internal array,
* you must ensure that indexes accessed are less than the length of `DynamicTypedArray`.
*/
get internalTypedArray(): TypedArrayOfConstructor<T>
constructor(
typedArrayConstructor: T
, options?: {
capacity?: number = 0
growthFactor?: number = 1.5
}
)
set(index: number, value: number): void
setValues(index: number, values: TypedArrayOfConstructor<T>): void
get(index: number): number | undefined
push(...values: number[]): void
pop(): number | undefined
clear(): void
sort(compare?: (a: number, b: number) => number): void
}
class TypedSparseSet<T extends UnsignedTypedArrayConstructor> {
get [Symbol.toStringTag](): string
get [Symbol.iterator](): IterableIterator<number>
get size(): number
constructor(array: DynamicTypedArray<T>)
values(): IterableIterator<number>
has(value: number): boolean
add(value: number): void
delete(value: number): boolean
clear(): void
}
class TypedSparseMap<T extends TypedArrayConstructor> {
get [Symbol.toStringTag](): string
get size(): number
/**
* `SparseMap` cannot respond to any operations on the internal array,
* you must ensure that indexes accessed are less than the length of `SparseMap`.
*
* Keys do not correspond to indexes of the array.
*/
get internalTypedArray(): TypedArrayOfConstructor<T>
constructor(array: DynamicTypedArray<T>)
entries(): IterableIterator<[key: number, value: number]>
keys(): IterableIterator<number>
values(): IterableIterator<number>
getInternalIndexOfKey(key: number): number | undefined
has(key: number): boolean
get(key: number): T | undefined
set(key: number, value: number): void
delete(key: number): void
clear(): void
}
class SortedSet<T> {
get [Symbol.toStringTag](): string
[Symbol.iterator](): IterableIterator<T>
constructor(compare: (a: T, b: T) => number)
values(): IterableIterator<T>
has(value: T): boolean
add(value: T): void
delete(value: T): void
}
class BitSet {
get [Symbol.toStringTag](): string
get size(): number
[Symbol.iterator](): IterableIterator<number>
constructor(bitsPerElement: number = 8)
values(): IterableIterator<number>
has(value: number): boolean
add(value: number): boolean
delete(value: number): boolean
clear(): void
}
Due to the length of arrays supported by JavaScript,
BitSet cannot support very large values.
class TypedBitSet<T extends UnsignedTypedArrayConstructor> {
get [Symbol.toStringTag](): string
get size(): number
[Symbol.iterator](): IterableIterator<number>
constructor(array: DynamicTypedArray<T>)
values(): IterableIterator<number>
has(value: number): boolean
add(value: number): boolean
delete(value: number): boolean
clear(): void
}
Due to the length of arrays supported by JavaScript,
TypedBitSit cannot support very large values.
FAQs
Common structures.
The npm package @blackglory/structures receives a total of 916 weekly downloads. As such, @blackglory/structures popularity was classified as not popular.
We found that @blackglory/structures demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Tea.xyz, a crypto project aimed at rewarding open source contributions, is once again facing backlash due to an influx of spam packages flooding public package registries.
Security News
As cyber threats become more autonomous, AI-powered defenses are crucial for businesses to stay ahead of attackers who can exploit software vulnerabilities at scale.
Security News
UnitedHealth Group disclosed that the ransomware attack on Change Healthcare compromised protected health information for millions in the U.S., with estimated costs to the company expected to reach $1 billion.