semantic-typescript 0.4.1 → 0.5.3

package/dist/guard.js

@@ -1,4 +1,4 @@
-import { BigIntStatisticsSymbol, CollectableSymbol, CollectorsSymbol, HashableSymbol, NumericStatisticsSymbol, OrderedCollectableSymbol, SemanticMapSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol, WindowCollectableSymbol } from "./symbol";
+import { BigIntStatisticsSymbol, CollectableSymbol, CollectorsSymbol, NumericStatisticsSymbol, OptionalSymbol, OrderedCollectableSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol, WindowCollectableSymbol } from "./symbol";
 export let isBoolean = (target) => {
     return typeof target === "boolean";
 };
@@ -89,51 +89,52 @@ export let isBigIntStatistics = (target) => {
     }
     return false;
 };
-export let isSemanticMap = (target) => {
+export let isOptional = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "SemanticMap") === SemanticMapSymbol;
+        return Reflect.get(target, "Optional") === OptionalSymbol;
     }
     return false;
 };
-export let isHashable = (target) => {
+export let isPromise = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, HashableSymbol) === HashableSymbol;
+        return isFunction(Reflect.get(target, "then")) && isFunction(Reflect.get(target, "catch"));
     }
     return false;
 };
-export let isHashMap = (target) => {
-    if (isObject(target)) {
-        return Reflect.get(target, "HashMap") === SemanticMapSymbol;
+export let isAsyncFunction = (target) => {
+    if (isFunction(target)) {
+        return Reflect.get(target, Symbol.toStringTag) === "AsyncFunction" && target.constructor.name === "AsyncFunction";
     }
     return false;
 };
-export let isHashSet = (target) => {
+export let isGeneratorFunction = (target) => {
     if (isObject(target)) {
-        return false;
+        return isFunction(target) && Reflect.get(target, "constructor").name === "GeneratorFunction";
     }
     return false;
 };
-export let isPromise = (target) => {
+export let isAsyncGeneratorFunction = (target) => {
     if (isObject(target)) {
-        return isFunction(Reflect.get(target, "then")) && isFunction(Reflect.get(target, "catch"));
+        return isFunction(target) && Reflect.get(target, "constructor").name === "AsyncGeneratorFunction";
     }
     return false;
 };
-export let isAsyncFunction = (target) => {
-    if (isFunction(target)) {
-        return Reflect.get(target, Symbol.toStringTag) === "AsyncFunction" && target.constructor.name === "AsyncFunction";
+export let isWindow = (target) => {
+    if (isObject(target) && isObject(Reflect.get(target, "window"))) {
+        return Object.prototype.toString.call(Reflect.get(target, "window")) === "[object Window]";
     }
     return false;
 };
-export let isGeneratorFunction = (target) => {
-    if (isObject(target)) {
-        return isFunction(target) && Reflect.get(target, "constructor").name === "GeneratorFunction";
+export let isDocument = (target) => {
+    if (isObject(target) && isObject(Reflect.get(target, "document"))) {
+        return Object.prototype.toString.call(Reflect.get(target, "document")) === "[object HTMLDocument]";
     }
     return false;
 };
-export let isAsyncGeneratorFunction = (target) => {
+export let isHTMLElemet = (target) => {
     if (isObject(target)) {
-        return isFunction(target) && Reflect.get(target, "constructor").name === "AsyncGeneratorFunction";
+        let regex = /^\[object HTML\w+Element\]$/;
+        return regex.test(Object.prototype.toString.call(target));
     }
     return false;
 };

package/dist/hash.d.ts

@@ -1,6 +1,4 @@
 import { type Type } from "./utility";
-export interface Hashable {
-}
 export declare let maskOf: (type: Type) => bigint;
 interface Handler<T> {
     (value: T): bigint;
@@ -9,6 +7,7 @@ export declare let register: <T>(type: Type, handler: Handler<T>) => void;
 export declare let unregister: (type: Type) => void;
 interface UseHash {
     <T = unknown>(target: T): bigint;
+    (...value: Array<unknown>): bigint;
 }
 export declare let useHash: UseHash;
 export {};

package/dist/hash.js

@@ -1,8 +1,6 @@
-import { isBigInt, isBoolean, isFunction, isHashable, isNumber, isObject, isString, isSymbol } from "./guard";
+import { isBigInt, isBoolean, isFunction, isNumber, isObject, isString, isSymbol } from "./guard";
 import { useTraverse } from "./hook";
-import { HashableSymbol } from "./symbol";
 import { typeOf } from "./utility";
-;
 const masks = new Map();
 masks.set("undefined", BigInt(masks.size));
 masks.set("null", BigInt(masks.size));
@@ -14,7 +12,6 @@ masks.set("string", BigInt(masks.size));
 masks.set("function", BigInt(masks.size));
 masks.set("object", BigInt(masks.size));
 Object.freeze(masks);
-const internal = Object.freeze(Array.from(masks.keys()));
 export let maskOf = (type) => {
     return masks.get(type) || masks.get("object") || 0n;
 };
@@ -27,7 +24,8 @@ export let register = (type, handler) => {
     }
 };
 export let unregister = (type) => {
-    if (isString(type) && handlers.has(type) && !internal.includes(type)) {
+    let whiteList = ["undefined", "null", "boolean", "number", "bigint", "symbol", "string", "function", "object"];
+    if (isString(type) && handlers.has(type) && !whiteList.includes(type)) {
         handlers.delete(type);
     }
 };
@@ -196,16 +194,12 @@ register("object", (value) => {
     return 0n;
 });
 ;
-export let useHash = (target) => {
+export let useHash = (...value) => {
+    let target = value.length === 1 ? value[0] : value;
     let type = typeOf(target);
-    if (type === "object" && isHashable(target)) {
-        if (complex.has(target)) {
-            return complex.get(target) || 0n;
-        }
-        let hash = Reflect.get(target, HashableSymbol)();
-        complex.set(target, hash);
-        return hash;
+    let handler = handlers.get(type);
+    if (handler) {
+        return handler(target);
     }
-    let handler = handlers.get(type) || (() => 0n);
-    return handler(target);
+    return 0n;
 };

package/dist/hook.d.ts

@@ -1,7 +1,11 @@
 import { type DeepPropertyKey, type DeepPropertyValue } from "./utility";
 import type { Comparator, Generator } from "./utility";
 export declare let useCompare: <T>(t1: T, t2: T) => number;
-export declare let Useandom: <T = number | bigint>(index: T) => T;
+interface UseRandom {
+    <N extends number | bigint>(start: N): N extends number ? number : (N extends bigint ? bigint : never);
+    <N extends number | bigint>(start: N, end: N): N;
+}
+export declare let useRandom: UseRandom;
 export type UseTraverseKey<T extends object> = DeepPropertyKey<T> & (symbol | string | number);
 export type UseTraverseValue<T extends object> = DeepPropertyValue<T>;
 export type UseTraversePath<T extends object> = Array<UseTraverseKey<T> & (symbol | string | number)>;

package/dist/hook.js

@@ -44,28 +44,81 @@ export let useCompare = (t1, t2) => {
     }
     throw new TypeError("Cannot compare values of different types.");
 };
-export let Useandom = (index) => {
-    if (isNumber(index)) {
-        let x = Number(index);
-        let phi = (1 + Math.sqrt(5)) / 2;
-        let vanDerCorput = (base, n) => {
-            let result = 0;
-            let f = 1 / base;
-            let i = n;
-            while (i > 0) {
-                result += (i % base) * f;
-                i = Math.floor(i / base);
-                f = f / base;
+;
+export let useRandom = (start, end) => {
+    let getRandomBits = () => {
+        let random = Math.random();
+        let full = random * 0x10000000000000;
+        let high = Math.floor(full / 0x100000000);
+        let low = Math.floor(full) & 0xFFFFFFFF;
+        return [high, low];
+    };
+    let getRandomBigInt = () => {
+        let [h1, l1] = getRandomBits();
+        let [h2, l2] = getRandomBits();
+        let [h3, l3] = getRandomBits();
+        return ((BigInt(h1) << 84n) | (BigInt(l1) << 52n) | (BigInt(h2) << 32n) | (BigInt(l2) << 3n) | (BigInt(h3) << 116n)) | (BigInt(l3) << 80n);
+    };
+    if (isNumber(start)) {
+        let seed = Math.random();
+        if (isNumber(end)) {
+            let minimum = Math.min(start, end);
+            let maximum = Math.max(start, end);
+            let range = maximum - minimum;
+            return (minimum + seed * range);
+        }
+        else {
+            return Math.exp(-seed);
+        }
+    }
+    if (isBigInt(start)) {
+        let randomBigInt = getRandomBigInt();
+        if (isBigInt(end)) {
+            let minimum = start < end ? start : end;
+            let maximum = start < end ? end : start;
+            let range = maximum - minimum;
+            if (range === 0n) {
+                return minimum;
+            }
+            let mask = range;
+            mask |= mask >> 1n;
+            mask |= mask >> 2n;
+            mask |= mask >> 4n;
+            mask |= mask >> 8n;
+            mask |= mask >> 16n;
+            mask |= mask >> 32n;
+            mask |= mask >> 64n;
+            let result;
+            do {
+                let raw = randomBigInt & mask;
+                result = raw;
+                result ^= result >> 17n;
+                result *= 0xed5ad4bbn;
+                result ^= result >> 11n;
+                result *= 0xac4c1b51n;
+                result ^= result >> 15n;
+                result *= 0x31848babn;
+                result ^= result >> 14n;
+            } while (result >= range);
+            return (minimum + result);
+        }
+        else {
+            let seed = Math.random();
+            let expValue = Math.exp(-seed);
+            let normalized = expValue / Math.E;
+            let [high, low] = getRandomBits();
+            let adjusted = BigInt(Math.floor(normalized * 0xFFFFFFFF)) << 32n;
+            let result = (adjusted | BigInt(low)) ^ BigInt(high);
+            if (start <= 0n) {
+                return 0n;
+            }
+            if (result >= start) {
+                result = result % start;
             }
             return result;
-        };
-        let h = vanDerCorput(2, x) + vanDerCorput(3, x);
-        let golden = (x * phi) % 1;
-        let lcg = (1103515245 * x + 12345) % 2147483648;
-        let mixed = (h * 0.5 + golden * 0.3 + lcg / 2147483648 * 0.2);
-        return (mixed * 1000000);
+        }
     }
-    throw new TypeError("Invalid input type");
+    throw new TypeError("Invalid arguments.");
 };
 ;
 ;

package/dist/index.d.ts

@@ -1,14 +1,8 @@
-export * from "./collectable";
 export * from "./collector";
 export * from "./factory";
 export * from "./guard";
-export * from "./hash";
 export * from "./hook";
-export * from "./map";
 export * from "./optional";
 export * from "./semantic";
-export * from "./set";
 export * from "./symbol";
-export * from "./statistics";
 export * from "./utility";
-export * from "./window";

package/dist/index.js

@@ -1,14 +1,8 @@
-export * from "./collectable";
 export * from "./collector";
 export * from "./factory";
 export * from "./guard";
-export * from "./hash";
 export * from "./hook";
-export * from "./map";
 export * from "./optional";
 export * from "./semantic";
-export * from "./set";
 export * from "./symbol";
-export * from "./statistics";
 export * from "./utility";
-export * from "./window";

package/dist/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/main.js

@@ -0,0 +1,4 @@
+import { useWindow } from 'semantic-typescript';
+useWindow("click").toEvent().forEach((event, index) => {
+    console.log(event.type + `第${index}次触发`);
+});

package/dist/map.d.ts

@@ -70,3 +70,7 @@ export declare class HashMap<K, V> extends AbstractSemanticMap<K, V> {
     set(key: K, value: V): this;
     values(): IterableIterator<V>;
 }
+export declare class TreeMap<K, V> {
+    key: K;
+    value: V;
+}

package/dist/map.js

@@ -83,9 +83,6 @@ export class AbstractSemanticMap {
     [Symbol.toStringTag] = "SemanticMap";
 }
 ;
-Object.freeze(AbstractSemanticMap);
-Object.freeze(AbstractSemanticMap.prototype);
-Object.freeze(Object.getPrototypeOf(AbstractSemanticMap));
 export class HashMap extends AbstractSemanticMap {
     buckets = new Map();
     threashold;
@@ -242,6 +239,7 @@ export class HashMap extends AbstractSemanticMap {
     }
 }
 ;
-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 {};