semantic-typescript 0.4.1 → 0.5.0

package/dist/optional.d.ts

@@ -12,6 +12,9 @@ export declare class Optional<T> {
     isEmpty(): boolean;
     isPresent(): boolean;
     map<R>(mapper: Functional<T, R>): Optional<R>;
+    flat(mapper: Functional<T, Optional<T>>): Optional<T>;
+    flatMap<R>(mapper: Functional<T, Optional<R>>): Optional<R>;
+    orElse(other: MaybeInvalid<T>): MaybeInvalid<T>;
     semantic(): Semantic<T>;
     static empty<T>(): Optional<T>;
     static of<T>(value: MaybeInvalid<T>): Optional<T>;

package/dist/optional.js

@@ -62,6 +62,24 @@ export class Optional {
         }
         return new Optional(null);
     }
+    flat(mapper) {
+        if (this.isPresent() && isFunction(mapper)) {
+            return mapper(this.value);
+        }
+        return new Optional(null);
+    }
+    flatMap(mapper) {
+        if (this.isPresent() && isFunction(mapper)) {
+            return mapper(this.value);
+        }
+        return new Optional(null);
+    }
+    orElse(other) {
+        if (this.isPresent()) {
+            return this.value;
+        }
+        return other;
+    }
     semantic() {
         if (this.isPresent()) {
             return generate(() => {

package/dist/semantic.d.ts

@@ -1,8 +1,6 @@
-import { Collectable, OrderedCollectable, UnorderedCollectable } from "./collectable";
-import { BigIntStatistics, NumericStatistics } from "./statistics";
+import { BigIntStatistics, Collectable, NumericStatistics, OrderedCollectable, UnorderedCollectable, WindowCollectable } from "./collectable";
 import { type Predicate } from "./utility";
 import type { Generator, Functional, BiFunctional, Consumer, BiConsumer, Comparator, BiPredicate } from "./utility";
-import { WindowCollectable } from "./window";
 export declare class Semantic<E> {
     protected generator: Generator<E>;
     protected readonly Semantic: Symbol;

package/dist/semantic.js

@@ -1,11 +1,9 @@
-import { Collectable, OrderedCollectable, UnorderedCollectable } from "./collectable";
+import { BigIntStatistics, Collectable, NumericStatistics, OrderedCollectable, UnorderedCollectable, WindowCollectable } from "./collectable";
 import { isBigInt, isCollectable, isFunction, isIterable, isNumber, isSemantic } from "./guard";
 import { useHash } from "./hash";
 import { useCompare } from "./hook";
-import { BigIntStatistics, NumericStatistics } from "./statistics";
 import { SemanticSymbol } from "./symbol";
 import { validate } from "./utility";
-import { WindowCollectable } from "./window";
 export class Semantic {
     generator;
     Semantic = SemanticSymbol;
@@ -300,7 +298,7 @@ export class Semantic {
         return new Semantic((accept, interrupt) => {
             try {
                 this.generator((element, index) => {
-                    accept(element, useHash([element, index]));
+                    accept(element, useHash(element, index));
                 }, interrupt);
             }
             catch (error) {

package/dist/set.js

@@ -11,6 +11,7 @@ export class HashSet {
             enumerable: true,
             configurable: true
         });
+        Object.freeze(this);
     }
     add(value) {
         this.map.set(value, true);

package/dist/statistics.js

@@ -1,5 +1,5 @@
 import { OrderedCollectable } from "./collectable";
-import { Collector, useBigIntAverage, useBigIntMedian, useBigIntMode, useBigIntSummate, useBigIntVariance, useFrequency, useNumericAverage, useNumericMedian, useNumericMode, useNumericStandardDeviation, useNumericSummate, useNumericVariance, useToArray } from "./collector";
+import { Collector, useBigIntAverage, useBigIntMedian, useBigIntMode, useBigIntSummate, useBigIntVariance, useFrequency, useNumericAverage, useNumericMedian, useNumericMode, useNumericStandardDeviation, useNumericSummate, useNumericVariance, useToAsyncGeneratorFunction, useToGeneratorFunction } from "./collector";
 import { isFunction } from "./guard";
 import { useCompare, useToBigInt, useToNumber } from "./hook";
 import { StatisticsSymbol, NumericStatisticsSymbol, BigIntStatisticsSymbol } from "./symbol";
@@ -19,7 +19,7 @@ export class Statistics extends OrderedCollectable {
     }
     *[Symbol.iterator]() {
         try {
-            let collector = useToArray();
+            let collector = useToGeneratorFunction();
             yield* collector.collect(this.source());
         }
         catch (error) {
@@ -28,7 +28,7 @@ export class Statistics extends OrderedCollectable {
     }
     async *[Symbol.asyncIterator]() {
         try {
-            let collector = useToArray();
+            let collector = useToAsyncGeneratorFunction();
             yield* collector.collect(this.source());
         }
         catch (error) {
@@ -62,7 +62,7 @@ export class NumericStatistics extends Statistics {
     }
     *[Symbol.iterator]() {
         try {
-            let collector = useToArray();
+            let collector = useToGeneratorFunction();
             yield* collector.collect(this.source());
         }
         catch (error) {
@@ -71,7 +71,7 @@ export class NumericStatistics extends Statistics {
     }
     async *[Symbol.asyncIterator]() {
         try {
-            let collector = useToArray();
+            let collector = useToAsyncGeneratorFunction();
             yield* collector.collect(this.source());
         }
         catch (error) {
@@ -281,7 +281,7 @@ export class BigIntStatistics extends Statistics {
     }
     *[Symbol.iterator]() {
         try {
-            let collector = useToArray();
+            let collector = useToGeneratorFunction();
             yield* collector.collect(this.source());
         }
         catch (error) {
@@ -290,7 +290,7 @@ export class BigIntStatistics extends Statistics {
     }
     async *[Symbol.asyncIterator]() {
         try {
-            let collector = useToArray();
+            let collector = useToAsyncGeneratorFunction();
             yield* collector.collect(this.source());
         }
         catch (error) {

package/dist/symbol.d.ts

@@ -13,6 +13,12 @@ export declare let HashMapSymbol: symbol;
 export declare let HashSetSymbol: symbol;
 export declare let TreeMapSymbol: symbol;
 export declare let TreeSetSymbol: symbol;
+export declare let NodeSymbol: symbol;
+export declare let LinearNodeSymbol: symbol;
 export declare let BinaryNodeSymbol: symbol;
-export declare let ReadBlackNodeSymbol: symbol;
-export declare let HashableSymbol: symbol;
+export declare let RedBlackNodeSymbol: symbol;
+export declare let AverageLevelNodeSymbol: symbol;
+export declare let TreeSymbol: symbol;
+export declare let BinaryTreeSymbol: symbol;
+export declare let RedBlackTreeSymbol: symbol;
+export declare let AVLTreeSymbol: symbol;

package/dist/symbol.js

@@ -13,6 +13,12 @@ export let HashMapSymbol = Symbol.for("HashMap");
 export let HashSetSymbol = Symbol.for("HashSet");
 export let TreeMapSymbol = Symbol.for("TreeMap");
 export let TreeSetSymbol = Symbol.for("TreeSet");
+export let NodeSymbol = Symbol.for("Node");
+export let LinearNodeSymbol = Symbol.for("LinearNode");
 export let BinaryNodeSymbol = Symbol.for("BinaryNode");
-export let ReadBlackNodeSymbol = Symbol.for("BlackAndRedNode");
-export let HashableSymbol = Symbol.for("hashable");
+export let RedBlackNodeSymbol = Symbol.for("RedBlackNode");
+export let AverageLevelNodeSymbol = Symbol.for("AverageLevelNode");
+export let TreeSymbol = Symbol.for("Tree");
+export let BinaryTreeSymbol = Symbol.for("BinaryTree");
+export let RedBlackTreeSymbol = Symbol.for("RedBlackTree");
+export let AVLTreeSymbol = Symbol.for("AVLTree");

package/dist/tree.d.ts

@@ -0,0 +1,82 @@
+import { BinaryNode, RedBlackNode, type Node } from './node';
+import { Optional } from './optional';
+import { type Comparator } from './utility';
+export interface Tree<E, N extends Node<E, N>, T extends Tree<E, N, T>> extends Iterable<E> {
+    root(): Optional<N>;
+    isEmpty(): boolean;
+    size(): bigint;
+    height(): bigint;
+    depth(): bigint;
+    width(): bigint;
+    level(): bigint;
+    add(value: E): void;
+    remove(value: E): void;
+    contains(value: E): boolean;
+    find(value: E): Optional<N>;
+    preorder(): Generator<E>;
+    inorder(): Generator<E>;
+    postorder(): Generator<E>;
+    breadth(): Generator<E>;
+    toArray(): Array<E>;
+    toSet(): Set<E>;
+    sub(node: N): T;
+    prune(node: Node<E, N>): T;
+    merge(other: T): T;
+    [Symbol.iterator](): Iterator<E>;
+}
+export declare abstract class AbstractTree<E, N extends Node<E, N>, T extends Tree<E, N, T>> implements Tree<E, N, T> {
+    protected readonly Tree: symbol;
+    protected internal: bigint;
+    constructor();
+    abstract root(): Optional<N>;
+    isEmpty(): boolean;
+    size(): bigint;
+    abstract add(value: E): void;
+    abstract remove(value: E): void;
+    contains(value: E): boolean;
+    abstract find(value: E): Optional<N>;
+    abstract preorder(): Generator<E>;
+    abstract inorder(): Generator<E>;
+    abstract postorder(): Generator<E>;
+    abstract breadth(): Generator<E>;
+    toArray(): Array<E>;
+    toSet(): Set<E>;
+    abstract sub(node: N): T;
+    abstract prune(node: Node<E, N>): T;
+    abstract merge(other: T): T;
+    height(): bigint;
+    width(): bigint;
+    depth(): bigint;
+    level(): bigint;
+    abstract [Symbol.iterator](): Iterator<E>;
+}
+export declare abstract class BinaryTree<E, N extends BinaryNode<E, N>, T extends BinaryTree<E, N, T>> extends AbstractTree<E, N, T> {
+    protected readonly BinaryTree: symbol;
+    protected first: Optional<N>;
+    constructor();
+    constructor(root: Optional<N>);
+    root(): Optional<N>;
+    find(value: E): Optional<N>;
+    preorder(): Generator<E>;
+    inorder(): Generator<E>;
+    postorder(): Generator<E>;
+    isBalanced(): boolean;
+    isComplete(): boolean;
+    isFull(): boolean;
+    isPerfect(): boolean;
+    [Symbol.iterator](): Iterator<E>;
+}
+export declare class RedBlackTree<E> extends BinaryTree<E, RedBlackNode<E>, RedBlackTree<E>> {
+    protected readonly RedBlackTree: symbol;
+    protected comparator: Comparator<E>;
+    constructor();
+    constructor(root: Optional<RedBlackNode<E>>);
+    constructor(comparator: Comparator<E>);
+    constructor(root: Optional<RedBlackNode<E>>, comparator: Comparator<E>);
+    add(value: E): void;
+    remove(value: E): void;
+    breadth(): Generator<E>;
+    sub(node: RedBlackNode<E>): RedBlackTree<E>;
+    prune(node: Node<E, RedBlackNode<E>>): RedBlackTree<E>;
+    merge(other: RedBlackTree<E>): RedBlackTree<E>;
+}

package/dist/tree.js

@@ -0,0 +1,257 @@
+import { isFunction, isRedBlackNode } from './guard';
+import { useCompare } from './hook';
+import { BinaryNode, RedBlackNode } from './node';
+import { Optional } from './optional';
+import { BinaryTreeSymbol, TreeSymbol } from './symbol';
+import { validate } from './utility';
+export class AbstractTree {
+    Tree = TreeSymbol;
+    internal = 0n;
+    constructor() {
+    }
+    isEmpty() {
+        return this.root().isEmpty();
+    }
+    size() {
+        return this.internal;
+    }
+    contains(value) {
+        return this.find(value).isPresent();
+    }
+    toArray() {
+        return Array.from(this.preorder());
+    }
+    toSet() {
+        return new Set(this.preorder());
+    }
+    height() {
+        let root = this.root();
+        if (root.isPresent()) {
+            return root.get().height();
+        }
+        return 0n;
+    }
+    width() {
+        let root = this.root();
+        if (root.isPresent()) {
+            return root.get().width();
+        }
+        return 0n;
+    }
+    depth() {
+        let root = this.root();
+        if (root.isPresent()) {
+            return root.get().depth();
+        }
+        return 0n;
+    }
+    level() {
+        let root = this.root();
+        if (root.isPresent()) {
+            return root.get().level();
+        }
+        return 0n;
+    }
+}
+;
+export class BinaryTree extends AbstractTree {
+    BinaryTree = BinaryTreeSymbol;
+    first;
+    constructor(root = Optional.empty()) {
+        super();
+        this.first = root;
+    }
+    root() {
+        return this.first;
+    }
+    find(value) {
+        let root = this.root();
+        if (root.isPresent()) {
+            for (let node of root.get().preorder()) {
+                if (node.getElement() === value || Object.is(node.getElement(), value)) {
+                    return Optional.of(node);
+                }
+            }
+        }
+        return Optional.empty();
+    }
+    *preorder() {
+        let root = this.root();
+        if (root.isPresent()) {
+            for (let node of root.get().preorder()) {
+                let element = node.getElement();
+                if (validate(element) && element.isPresent()) {
+                    yield element.get();
+                }
+            }
+        }
+    }
+    *inorder() {
+        let root = this.root();
+        if (root.isPresent()) {
+            for (let node of root.get().inorder()) {
+                let element = node.getElement();
+                if (validate(element) && element.isPresent()) {
+                    yield element.get();
+                }
+            }
+        }
+    }
+    *postorder() {
+        let root = this.root();
+        if (root.isPresent()) {
+            for (let node of root.get().postorder()) {
+                let element = node.getElement();
+                if (validate(element) && element.isPresent()) {
+                    yield element.get();
+                }
+            }
+        }
+    }
+    isBalanced() {
+        let root = this.root();
+        if (root.isPresent()) {
+            return root.get().isBanlanced();
+        }
+        return false;
+    }
+    isComplete() {
+        let root = this.root();
+        if (root.isPresent()) {
+            return root.get().isComplete();
+        }
+        return false;
+    }
+    isFull() {
+        let root = this.root();
+        if (root.isPresent()) {
+            return root.get().isFull();
+        }
+        return false;
+    }
+    isPerfect() {
+        let root = this.root();
+        if (root.isPresent()) {
+            return root.get().isPerfect();
+        }
+        return false;
+    }
+    *[Symbol.iterator]() {
+        yield* this.preorder();
+    }
+}
+;
+export class RedBlackTree extends BinaryTree {
+    RedBlackTree = Symbol("RedBlackTree");
+    comparator;
+    constructor(argument1, argument2) {
+        if (isFunction(argument1)) {
+            super();
+            this.comparator = argument1;
+        }
+        else if (isRedBlackNode(argument1)) {
+            super(argument1);
+            if (isFunction(argument2)) {
+                this.comparator = argument2;
+            }
+            else {
+                this.comparator = useCompare;
+            }
+        }
+        else {
+            throw new TypeError("Invalid arguments.");
+        }
+    }
+    add(value) {
+        let node = new RedBlackNode(value);
+        if (this.first.isEmpty()) {
+            this.first = Optional.of(node);
+        }
+        else {
+            this.first.get().compareAndLink(node);
+        }
+        this.internal++;
+    }
+    remove(value) {
+        let node = this.find(value);
+        if (node.isPresent()) {
+            node.get().detach();
+            node.get().fix();
+            this.internal--;
+        }
+    }
+    *breadth() {
+        let root = this.root();
+        if (root.isPresent()) {
+            let queue = [root.get()];
+            while (queue.length > 0) {
+                let node = queue.shift();
+                let element = node.getElement();
+                if (validate(element) && element.isPresent()) {
+                    yield element.get();
+                }
+                if (validate(node.getLeft()) && node.getRight().isPresent()) {
+                    queue.push(node.getLeft().get());
+                }
+                if (validate(node.getLeft()) && node.getLeft().isPresent()) {
+                    queue.push(node.getLeft().get());
+                }
+            }
+        }
+    }
+    sub(node) {
+        return new RedBlackTree(Optional.of(node));
+    }
+    prune(node) {
+        let tree = new RedBlackTree();
+        let queue = [node];
+        while (queue.length > 0) {
+            let node = queue.shift();
+            let element = node.getElement();
+            if (validate(element) && element.isPresent()) {
+                tree.add(element.get());
+            }
+            if (validate(node.getLeft()) && node.getLeft().isPresent()) {
+                queue.push(node.getLeft().get());
+            }
+            if (validate(node.getRight()) && node.getRight().isPresent()) {
+                queue.push(node.getRight().get());
+            }
+            return tree;
+        }
+        return tree;
+    }
+    merge(other) {
+        let tree = new RedBlackTree();
+        let queue = [this.root().get()];
+        while (queue.length > 0) {
+            let node = queue.shift();
+            let element = node.getElement();
+            if (validate(element) && element.isPresent()) {
+                tree.add(element.get());
+            }
+            if (validate(node.getLeft()) && node.getLeft().isPresent()) {
+                queue.push(node.getLeft().get());
+            }
+            if (validate(node.getRight()) && node.getRight().isPresent()) {
+                queue.push(node.getRight().get());
+            }
+        }
+        queue = [other.root().get()];
+        while (queue.length > 0) {
+            let node = queue.shift();
+            let element = node.getElement();
+            if (validate(element) && element.isPresent()) {
+                tree.add(element.get());
+            }
+            if (validate(node.getLeft()) && node.getLeft().isPresent()) {
+                queue.push(node.getLeft().get());
+            }
+            if (validate(node.getRight()) && node.getRight().isPresent()) {
+                queue.push(node.getRight().get());
+            }
+        }
+        return tree;
+    }
+}
+;

package/package.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/eloyhere"
   },
   "description": "A modern type-safe stream processing library inspired by JavaScript Generator, Java Stream, and MySQL Index. Supports lazy evaluation, async streams, statistics, and IO-like operations.",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "type": "module",
   "readme": "readme.md",
   "main": "dist/index.js",