semantic-typescript 0.3.8 → 0.5.0

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/dist/utility.d.ts

@@ -1,9 +1,13 @@
 export type Invalid<T> = T extends null | undefined ? T : never;
 export type Valid<T> = T extends null | undefined ? never : T;
 export type MaybeInvalid<T> = T | null | undefined;
+export type MaybeUndefined<T> = T | undefined;
+export type MaybeNull<T> = T | null;
 export declare let validate: <T>(t: MaybeInvalid<T>) => t is T;
 export declare let invalidate: <T>(t: MaybeInvalid<T>) => t is (null | undefined);
-export type Primitive = string | number | boolean | symbol | bigint | Function | ((...args: any[]) => any);
+export type Type = "undefined" | "null" | "boolean" | "number" | "bigint" | "symbol" | "string" | "function" | "object";
+export declare let typeOf: <T>(t: T) => Type;
+export type Primitive = null | undefined | string | number | boolean | symbol | bigint | Function | ((...args: any[]) => any);
 export type MaybePrimitive<T> = T | Primitive;
 export type AsyncFunction = (...args: any[]) => Promise<unknown>;
 export type DeepPropertyKey<T extends object> = {
@@ -12,6 +16,9 @@ export type DeepPropertyKey<T extends object> = {
 export type DeepPropertyValue<T extends object> = {
     [K in keyof T]: T[K] extends object ? DeepPropertyValue<T[K]> : T[K];
 };
+export interface Constructor<T> {
+    new (...args: any[]): T;
+}
 export interface Runnable {
     (): void;
 }

package/dist/utility.js

@@ -4,6 +4,15 @@ export let validate = (t) => {
 export let invalidate = (t) => {
     return t === null || t === (void 0);
 };
+export let typeOf = (t) => {
+    if (typeof t === "object") {
+        if (t === null) {
+            return "null";
+        }
+        return "object";
+    }
+    return typeof t;
+};
 ;
 ;
 ;

package/dist/window.js

@@ -7,11 +7,13 @@ export class WindowCollectable extends OrderedCollectable {
     WindowCollectable = WindowCollectableSymbol;
     constructor(parameter, comparator = useCompare) {
         super(parameter, comparator);
-        Object.defineProperty(this, "WindowCollectable", {
-            value: WindowCollectableSymbol,
-            enumerable: false,
-            writable: false,
-            configurable: false
+        Object.defineProperties(this, {
+            "WindowCollectable": {
+                value: WindowCollectableSymbol,
+                writable: false,
+                enumerable: false,
+                configurable: false
+            }
         });
         Object.freeze(this);
     }

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.3.8",
+  "version": "0.5.0",
   "type": "module",
   "readme": "readme.md",
   "main": "dist/index.js",
@@ -52,10 +52,6 @@
   },
   "scripts": {
     "build": "tsc",
-    "dev": "vite",
     "prepublishOnly": "npm run build"
-  },
-  "devDependencies": {
-    "typescript": "~5.9.3"
   }
 }