semantic-typescript 0.3.8 → 0.5.0

package/dist/map.d.ts

@@ -0,0 +1,76 @@
+import { type BiConsumer, type BiFunctional, type Comparator, type MaybeInvalid, type MaybeUndefined, type Supplier, type TriConsumer } from "./utility";
+export interface Entry<K, V> {
+    key: K;
+    value: V;
+}
+export interface SemanticMap<K, V> extends globalThis.Map<K, V> {
+    clear(): void;
+    compute(key: K, remapping: BiFunctional<K, MaybeInvalid<V>, MaybeInvalid<V>>): MaybeInvalid<V>;
+    computeIfAbsent(key: K, remapping: Supplier<V>): V;
+    computeIfPresent(key: K, remapping: BiFunctional<K, V, MaybeInvalid<V>>): MaybeInvalid<V>;
+    delete(key: K): boolean;
+    entries(): MapIterator<[K, V]>;
+    forEach(consumer: BiConsumer<V, K>): void;
+    forEach(consumer: TriConsumer<V, K, Map<K, V>>): void;
+    get(key: K): MaybeUndefined<V>;
+    get(key: K, defaultValue: V): V;
+    has(key: K): boolean;
+    replace(key: K, value: V): MaybeInvalid<V>;
+    replace(key: K, oldValue: V, newValue: V): boolean;
+    replaceAll(operator: BiFunctional<K, V, MaybeInvalid<V>>): void;
+    set(key: K, value: V): this;
+    size: number;
+    values(): IterableIterator<V>;
+}
+export declare abstract class AbstractSemanticMap<K, V> implements SemanticMap<K, V> {
+    protected internal: bigint;
+    size: number;
+    protected readonly SemanticMap: symbol;
+    constructor();
+    abstract clear(): void;
+    compute(key: K, remapping: BiFunctional<K, MaybeInvalid<V>, MaybeInvalid<V>>): MaybeInvalid<V>;
+    computeIfAbsent(key: K, remapping: Supplier<V>): V;
+    computeIfPresent(key: K, remapping: BiFunctional<K, V, MaybeInvalid<V>>): MaybeInvalid<V>;
+    abstract delete(key: K): boolean;
+    abstract entries(): MapIterator<[K, V]>;
+    forEach(consumer: BiConsumer<V, K>): void;
+    forEach(consumer: TriConsumer<V, K, Map<K, V>>): void;
+    abstract get(key: K): MaybeUndefined<V>;
+    abstract get(key: K, defaultValue: V): V;
+    abstract keys(): MapIterator<K>;
+    has(key: K): boolean;
+    replace(key: K, value: V): MaybeInvalid<V>;
+    replace(key: K, oldValue: V, newValue: V): boolean;
+    replaceAll(operator: BiFunctional<K, V, MaybeInvalid<V>>): void;
+    abstract set(key: K, value: V): this;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    [Symbol.toStringTag]: string;
+    abstract values(): IterableIterator<V>;
+}
+export declare class HashMap<K, V> extends AbstractSemanticMap<K, V> {
+    protected buckets: Map<bigint, Array<Entry<K, V>>>;
+    protected threashold: number;
+    protected comparator: Comparator<K>;
+    protected capacity: number;
+    protected readonly HashMap: symbol;
+    constructor();
+    constructor(comparator: Comparator<K>);
+    constructor(threashold: number, initialCapacity: number);
+    constructor(comparator: Comparator<K>, threashold: number, capacity: number);
+    clear(): void;
+    delete(key: K): boolean;
+    entries(): MapIterator<[K, V]>;
+    has(key: K): boolean;
+    protected hash(key: K): bigint;
+    protected findEntry(key: K, hash: bigint): MaybeInvalid<Entry<K, V>>;
+    get(key: K): MaybeUndefined<V>;
+    get(key: K, defaultValue: V): V;
+    keys(): MapIterator<K>;
+    protected rehash(): void;
+    set(key: K, value: V): this;
+    values(): IterableIterator<V>;
+}
+export declare class TreeMap<K, V> {
+    key: K;
+    value: V;
+}

package/dist/map.js

@@ -0,0 +1,253 @@
+import { isFunction, isNumber } from "./guard";
+import { useHash } from "./hash";
+import { useCompare } from "./hook";
+import { SemanticMapSymbol } from "./symbol";
+import { invalidate, validate } from "./utility";
+;
+;
+export class AbstractSemanticMap {
+    internal = 0n;
+    size = 0;
+    SemanticMap = SemanticMapSymbol;
+    constructor() {
+        Object.defineProperty(this, "SemanticMap", {
+            value: SemanticMapSymbol,
+            enumerable: false,
+            writable: false,
+            configurable: false
+        });
+        Object.freeze(this);
+    }
+    compute(key, remapping) {
+        let value = this.get(key);
+        return remapping(key, value);
+    }
+    computeIfAbsent(key, remapping) {
+        let value = this.get(key);
+        if (invalidate(value)) {
+            return remapping();
+        }
+        return value;
+    }
+    computeIfPresent(key, remapping) {
+        let value = this.get(key);
+        if (validate(value)) {
+            return remapping(key, value);
+        }
+        return value;
+    }
+    forEach(consumer) {
+        for (let entry of this.entries()) {
+            consumer(entry[1], entry[0], this);
+        }
+    }
+    has(key) {
+        return this.get(key) !== undefined;
+    }
+    replace(argument1, argument2, argument3) {
+        if (validate(argument1) && validate(argument2) && validate(argument3)) {
+            let key = argument1;
+            let oldValue = argument2;
+            let newValue = argument3;
+            if (this.get(key) === oldValue) {
+                this.set(key, newValue);
+                return true;
+            }
+            return this.get(key);
+        }
+        if (validate(argument1) && validate(argument2) && invalidate(argument3)) {
+            let key = argument1;
+            let value = argument2;
+            if (this.get(key) === value) {
+                this.delete(key);
+                return true;
+            }
+            return this.get(key);
+        }
+    }
+    replaceAll(operator) {
+        for (let entry of this.entries()) {
+            let key = entry[0];
+            let value = entry[1];
+            let newValue = operator(key, value);
+            if (validate(newValue)) {
+                this.set(key, newValue);
+            }
+            else {
+                this.delete(key);
+            }
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    [Symbol.toStringTag] = "SemanticMap";
+}
+;
+Object.freeze(AbstractSemanticMap);
+Object.freeze(AbstractSemanticMap.prototype);
+Object.freeze(Object.getPrototypeOf(AbstractSemanticMap));
+export class HashMap extends AbstractSemanticMap {
+    buckets = new Map();
+    threashold;
+    comparator;
+    capacity;
+    HashMap = SemanticMapSymbol;
+    constructor(argument1, argument2, argument3) {
+        super();
+        if (isFunction(argument1) && isNumber(argument2) && isNumber(argument3)) {
+            this.comparator = argument1;
+            this.threashold = argument2;
+            this.capacity = argument3;
+        }
+        else if (isFunction(argument1) && isNumber(argument2) && invalidate(argument3)) {
+            this.comparator = argument1;
+            this.threashold = argument2;
+            this.capacity = 16;
+        }
+        else if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            this.comparator = argument1;
+            this.threashold = 0.75;
+            this.capacity = 16;
+        }
+        else {
+            this.comparator = useCompare;
+            this.threashold = 0.75;
+            this.capacity = 16;
+        }
+        this.buckets = new Map();
+        Object.defineProperty(this, "size", {
+            get: () => this.internal,
+            set: (value) => this.internal = isNumber(value) ? BigInt(value) : 0n,
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(this, "HashMap", {
+            value: SemanticMapSymbol,
+            enumerable: false,
+            writable: false,
+            configurable: false
+        });
+        Object.freeze(this);
+    }
+    clear() {
+        this.buckets.clear();
+        this.size = 0;
+    }
+    delete(key) {
+        let hashCode = this.hash(key);
+        let bucket = this.buckets.get(hashCode) || [];
+        if (bucket.length > 0) {
+            for (let index = 0; index < bucket.length; index++) {
+                let entry = bucket[index];
+                if (this.comparator(entry.key, key) === 0) {
+                    bucket.splice(index, 1);
+                    this.size--;
+                    if (bucket.length === 0) {
+                        this.buckets.delete(hashCode);
+                    }
+                    return true;
+                }
+            }
+        }
+        this.buckets.delete(hashCode);
+        return false;
+    }
+    *entries() {
+        for (let bucket of this.buckets.values()) {
+            for (let entry of bucket) {
+                yield [entry.key, entry.value];
+            }
+        }
+    }
+    has(key) {
+        let hashCode = this.hash(key);
+        return validate(this.findEntry(key, hashCode));
+    }
+    hash(key) {
+        return useHash(key);
+    }
+    ;
+    findEntry(key, hash) {
+        let candidates = (this.buckets.get(hash) || []);
+        for (let candidate of candidates) {
+            if (this.comparator(candidate.key, key) === 0) {
+                return candidate;
+            }
+        }
+        return (void 0);
+    }
+    get(argument1, argument2) {
+        if (validate(argument1) && validate(argument2)) {
+            let key = argument1;
+            let defaultValue = argument2;
+            let hashCode = this.hash(key);
+            let entry = this.findEntry(key, hashCode);
+            if (validate(entry)) {
+                return entry.value;
+            }
+            return defaultValue;
+        }
+        let key = argument1;
+        let hashCode = this.hash(key);
+        let entry = this.findEntry(key, hashCode);
+        if (validate(entry)) {
+            return entry.value;
+        }
+        return (void 0);
+    }
+    *keys() {
+        for (let bucket of this.buckets.values()) {
+            for (let entry of bucket) {
+                yield entry.key;
+            }
+        }
+    }
+    rehash() {
+        let oldBuckets = this.buckets;
+        this.buckets = new Map();
+        this.size = 0;
+        for (let bucket of oldBuckets.values()) {
+            for (let entry of bucket) {
+                let hashCode = this.hash(entry.key);
+                let bucket = this.buckets.get(hashCode) || [];
+                bucket.push(entry);
+                this.size++;
+            }
+        }
+    }
+    set(key, value) {
+        let hashCode = this.hash(key);
+        let bucket = this.buckets.get(hashCode) || [];
+        let found = this.findEntry(key, hashCode);
+        if (validate(found)) {
+            found.value = value;
+        }
+        else {
+            bucket.push({
+                key: key,
+                value: value
+            });
+            this.size++;
+            if (this.size > this.capacity * this.threashold) {
+                this.rehash();
+            }
+        }
+        return this;
+    }
+    *values() {
+        for (let bucket of this.buckets.values()) {
+            for (let entry of bucket) {
+                yield entry.value;
+            }
+        }
+    }
+}
+;
+Object.freeze(HashMap);
+Object.freeze(HashMap.prototype);
+Object.freeze(Object.getPrototypeOf(HashMap));
+export class TreeMap {
+    key = (void 0);
+    value = (void 0);
+}

package/dist/node.d.ts

@@ -0,0 +1,182 @@
+import { Optional } from "./optional";
+import { type Comparator } from "./utility";
+export interface Node<E, N extends Node<E, N>> extends Iterable<N> {
+    ancestors(): Iterable<N>;
+    children(): Iterable<N>;
+    descendants(): Iterable<N>;
+    siblings(): Iterable<N>;
+    parent(): Optional<N>;
+    root(): N;
+    previousSibling(): Optional<N>;
+    nextSibling(): Optional<N>;
+    preorder(): Generator<N>;
+    inorder(): Generator<N>;
+    postorder(): Generator<N>;
+    breadthfirst(): Generator<N>;
+    depth(): bigint;
+    height(): bigint;
+    width(): bigint;
+    level(): bigint;
+    isLeaf(): boolean;
+    isRoot(): boolean;
+    [Symbol.iterator](): Iterator<N>;
+}
+export declare abstract class AbstractNode<E, N extends Node<E, N>> implements Node<E, N> {
+    protected readonly Node: symbol;
+    constructor();
+    ancestors(): Iterable<N>;
+    abstract children(): Iterable<N>;
+    descendants(): Iterable<N>;
+    root(): N;
+    siblings(): Iterable<N>;
+    abstract parent(): Optional<N>;
+    previousSibling(): Optional<N>;
+    nextSibling(): Optional<N>;
+    preorder(): Generator<N>;
+    inorder(): Generator<N>;
+    postorder(): Generator<N>;
+    breadthfirst(): Generator<N>;
+    [Symbol.iterator](): Iterator<N>;
+    depth(): bigint;
+    height(): bigint;
+    width(): bigint;
+    level(): bigint;
+    isLeaf(): boolean;
+    isRoot(): boolean;
+}
+export declare class LinearNode<E> extends AbstractNode<E, LinearNode<E>> {
+    protected previous: Optional<LinearNode<E>>;
+    protected next: Optional<LinearNode<E>>;
+    protected element: Optional<E>;
+    protected readonly LinearNode: symbol;
+    constructor(element: E);
+    constructor(element: E, previous: Optional<LinearNode<E>>, next: Optional<LinearNode<E>>);
+    ancestors(): Iterable<LinearNode<E>>;
+    descendants(): Iterable<LinearNode<E>>;
+    root(): LinearNode<E>;
+    siblings(): Iterable<LinearNode<E>>;
+    children(): Iterable<LinearNode<E>>;
+    parent(): Optional<LinearNode<E>>;
+    [Symbol.iterator](): Iterator<LinearNode<E>>;
+    getElement(): Optional<E>;
+    setElement(element: E): void;
+    getPrevious(): Optional<LinearNode<E>>;
+    setPrevious(previous: LinearNode<E>): void;
+    setPrevious(previous: Optional<LinearNode<E>>): void;
+    getNext(): Optional<LinearNode<E>>;
+    setNext(next: LinearNode<E>): void;
+    setNext(next: Optional<LinearNode<E>>): void;
+    linkPrevious(previous: LinearNode<E>): void;
+    unlinkPrevious(): void;
+    linkNext(next: LinearNode<E>): void;
+    unlinkNext(): void;
+}
+export declare abstract class BinaryNode<E, N extends BinaryNode<E, N>> extends AbstractNode<E, N> {
+    BinaryNode: symbol;
+    protected ancestor: Optional<N>;
+    protected left: Optional<N>;
+    protected right: Optional<N>;
+    protected element: Optional<E>;
+    constructor(element: E);
+    constructor(element: E, ancestor: Optional<N>, left: Optional<N>, right: Optional<N>);
+    ancestors(): Iterable<N>;
+    compare(other: N): bigint;
+    compare(other: N, comparator: Comparator<E>): bigint;
+    descendants(): Iterable<N>;
+    abstract identity(): N;
+    root(): N;
+    siblings(): Iterable<N>;
+    children(): Iterable<N>;
+    parent(): Optional<N>;
+    [Symbol.iterator](): Iterator<N>;
+    preorder(): Generator<N>;
+    inorder(): Generator<N>;
+    postorder(): Generator<N>;
+    breadthfirst(): Generator<N>;
+    getElement(): Optional<E>;
+    setElement(element: E): void;
+    getLeft(): Optional<N>;
+    setLeft(left: N): void;
+    setLeft(left: Optional<N>): void;
+    getRight(): Optional<N>;
+    setRight(right: N): void;
+    setRight(right: Optional<N>): void;
+    getAncestor(): Optional<N>;
+    setAncestor(ancestor: N): void;
+    setAncestor(ancestor: Optional<N>): void;
+    linkLeft(left: N): void;
+    unlinkLeft(): Optional<N>;
+    linkRight(right: N): void;
+    unlinkRight(): Optional<N>;
+    isLeftChild(): boolean;
+    isRightChild(): boolean;
+    detach(): void;
+    isBanlanced(): boolean;
+    isFull(): boolean;
+    isComplete(): boolean;
+    isPerfect(): boolean;
+    invert(): void;
+    invert(deep: boolean): void;
+}
+type Color = "RED" | "BLACK";
+export declare class RedBlackNode<E> extends BinaryNode<E, RedBlackNode<E>> {
+    protected readonly RedBlackNode: symbol;
+    protected color: Color;
+    constructor(element: E);
+    constructor(element: E, color: Color);
+    constructor(element: E, color: Color, ancestor: Optional<RedBlackNode<E>>, left: Optional<RedBlackNode<E>>, right: Optional<RedBlackNode<E>>);
+    identity(): RedBlackNode<E>;
+    getElement(): Optional<E>;
+    setElement(element: E): void;
+    getLeft(): Optional<RedBlackNode<E>>;
+    getRight(): Optional<RedBlackNode<E>>;
+    getColor(): Color;
+    setColor(color: Color): void;
+    isRed(): boolean;
+    isBlack(): boolean;
+    turnRed(): void;
+    turnBlack(): void;
+    toggle(): void;
+    compareAndLink(other: RedBlackNode<E>): void;
+    compareAndLink(other: RedBlackNode<E>, comparator: Comparator<E>): void;
+    rotate(): void;
+    rotateLeft(): RedBlackNode<E>;
+    rotateRight(): RedBlackNode<E>;
+    fix(): void;
+    uncle(): Optional<RedBlackNode<E>>;
+    findMinimum(): RedBlackNode<E>;
+    findMaximum(): RedBlackNode<E>;
+}
+export declare class AverageLevelNode<E> extends BinaryNode<E, AverageLevelNode<E>> {
+    constructor(element: E);
+    constructor(element: E, ancestor: Optional<AverageLevelNode<E>>, left: Optional<AverageLevelNode<E>>, right: Optional<AverageLevelNode<E>>);
+    [Symbol.iterator](): Iterator<AverageLevelNode<E>>;
+    identity(): AverageLevelNode<E>;
+    getElement(): Optional<E>;
+    setElement(element: E): void;
+    getLeft(): Optional<AverageLevelNode<E>>;
+    getRight(): Optional<AverageLevelNode<E>>;
+}
+export declare class BinarySearchNode<E> extends AbstractNode<E, BinarySearchNode<E>> {
+    protected left: Optional<BinarySearchNode<E>>;
+    protected right: Optional<BinarySearchNode<E>>;
+    protected element: Optional<E>;
+    constructor(element: E);
+    constructor(element: E, left: Optional<BinarySearchNode<E>>, right: Optional<BinarySearchNode<E>>);
+    ancestors(): Iterable<BinarySearchNode<E>>;
+    descendants(): Iterable<BinarySearchNode<E>>;
+    root(): BinarySearchNode<E>;
+    siblings(): Iterable<BinarySearchNode<E>>;
+    children(): Iterable<BinarySearchNode<E>>;
+    parent(): Optional<BinarySearchNode<E>>;
+    [Symbol.iterator](): Iterator<BinarySearchNode<E>>;
+    inorder(): Generator<BinarySearchNode<E>>;
+    preorder(): Generator<BinarySearchNode<E>>;
+    postorder(): Generator<BinarySearchNode<E>>;
+    breadthfirst(): Generator<BinarySearchNode<E>>;
+    getElement(): Optional<E>;
+    setElement(element: E): void;
+    getLeft(): Optional<BinarySearchNode<E>>;
+    getRight(): Optional<BinarySearchNode<E>>;
+}
+export {};