semantic-typescript 0.3.7 → 0.4.1

package/dist/hash.js

@@ -0,0 +1,211 @@
+import { isBigInt, isBoolean, isFunction, isHashable, 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));
+masks.set("boolean", BigInt(masks.size));
+masks.set("number", BigInt(masks.size));
+masks.set("bigint", BigInt(masks.size));
+masks.set("symbol", BigInt(masks.size));
+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;
+};
+let primitive = new Map();
+let complex = new WeakMap();
+const handlers = new Map();
+export let register = (type, handler) => {
+    if (isString(type) && isFunction(handler)) {
+        handlers.set(type, handler);
+    }
+};
+export let unregister = (type) => {
+    if (isString(type) && handlers.has(type) && !internal.includes(type)) {
+        handlers.delete(type);
+    }
+};
+register("undefined", (value) => {
+    if (value === (void 0)) {
+        if (primitive.has(value)) {
+            return primitive.get(value) || 0n;
+        }
+        let mask = maskOf("undefined");
+        let result = (0n << 4n) | mask;
+        primitive.set(value, result);
+        return result;
+    }
+    return 0n;
+});
+register("null", (value) => {
+    if (value === null) {
+        if (primitive.has(value)) {
+            return primitive.get(value) || 0n;
+        }
+        let mask = maskOf("null");
+        let result = (0n << 4n) | mask;
+        primitive.set(value, result);
+        return result;
+    }
+    return 0n;
+});
+register("boolean", (value) => {
+    if (isBoolean(value)) {
+        if (primitive.has(value)) {
+            return primitive.get(value) || 0n;
+        }
+        let mask = maskOf("boolean");
+        let result = ((value === true ? 1n : 0n) << 4n) | mask;
+        primitive.set(value, result);
+        return result;
+    }
+    return 0n;
+});
+register("number", (value) => {
+    if (isNumber(value)) {
+        if (primitive.has(value)) {
+            return primitive.get(value) || 0n;
+        }
+        let mask = maskOf("number");
+        let bit = 0xffffffffffffffffn;
+        let buffer = new ArrayBuffer(8);
+        let array = new Float64Array(buffer);
+        array[0] = value;
+        let view = new BigInt64Array(buffer);
+        let result = ((view[0] << 4n) & bit) | mask;
+        primitive.set(value, result);
+        return result;
+    }
+    return 0n;
+});
+register("bigint", (value) => {
+    if (isBigInt(value)) {
+        if (primitive.has(value)) {
+            return primitive.get(value) || 0n;
+        }
+        let mask = maskOf("bigint");
+        let bit = 0xffffffffffffffffn;
+        let result = ((value << 4n) & bit) | mask;
+        primitive.set(value, result);
+        return result;
+    }
+    return 0n;
+});
+register("string", (value) => {
+    if (isString(value)) {
+        if (primitive.has(value)) {
+            return primitive.get(value) || 0n;
+        }
+        let mask = maskOf("string");
+        let bit = 0xffffffffffffffffn;
+        let gap = value.length < 64 ? 1 : Math.ceil(Math.log2(value.length));
+        let result = 0n;
+        for (let i = 0; i < value.length; i += gap) {
+            result = (((result * 33n) & bit) ^ BigInt(value.charCodeAt(i))) + BigInt(i);
+        }
+        result = (result ^ (result >> 32n)) * 0x9e3779b97f4a7c15n;
+        result = (((result ^ (result >> 32n)) << 4n) & bit) | mask;
+        primitive.set(value, result);
+        return result;
+    }
+    return 0n;
+});
+register("symbol", (value) => {
+    if (isSymbol(value)) {
+        if (primitive.has(value)) {
+            return primitive.get(value) || 0n;
+        }
+        let mask = maskOf("symbol");
+        let bit = 0xffffffffffffffffn;
+        let description = (value.description || "") + String(value);
+        let result = 0n;
+        let gap = description.length < 64 ? 1 : Math.ceil(Math.log2(description.length));
+        for (let i = 0; i < description.length; i += gap) {
+            result = (((result * 33n) & bit) ^ BigInt(description.charCodeAt(i))) + BigInt(i);
+        }
+        result = (result ^ (result >> 32n)) * 0x9e3779b97f4a7c15n;
+        result = (((result ^ (result >> 32n)) << 4n) & bit) | mask;
+        primitive.set(value, result);
+        return result;
+    }
+    return 0n;
+});
+register("function", (value) => {
+    if (isFunction(value)) {
+        if (primitive.has(value)) {
+            return primitive.get(value) || 0n;
+        }
+        let mask = maskOf("function");
+        let bit = 0xffffffffffffffffn;
+        let description = (value.name || "") + String(value);
+        let result = 0n;
+        let gap = description.length < 64 ? 1 : Math.ceil(Math.log2(description.length));
+        for (let i = 0; i < description.length; i += gap) {
+            result = (((result * 33n) & bit) ^ BigInt(description.charCodeAt(i))) + BigInt(i);
+        }
+        result = (result ^ (result >> 32n)) * 0x9e3779b97f4a7c15n;
+        result = (((result ^ (result >> 32n)) << 4n) & bit) | mask;
+        primitive.set(value, result);
+        return result;
+    }
+    return 0n;
+});
+register("object", (value) => {
+    if (isObject(value)) {
+        if (complex.has(value)) {
+            return complex.get(value) || 0n;
+        }
+        try {
+            let mask = maskOf("object");
+            let bit = 0xffffffffffffffffn;
+            let result = 0n;
+            useTraverse(value, (key, value, path) => {
+                let keyHashHandler = handlers.get(typeOf(key));
+                let keyHash = keyHashHandler ? keyHashHandler(key) : 0n;
+                let valueHashHandler = handlers.get(typeOf(value));
+                let valueHash = valueHashHandler ? valueHashHandler(value) : 0n;
+                let pathHash = 0n;
+                if (complex.has(path)) {
+                    pathHash = complex.get(path) || 0n;
+                }
+                else {
+                    for (let p of path) {
+                        let pathHashHandler = handlers.get(typeOf(p));
+                        pathHash = (((pathHash << 5n) - pathHash) ^ (pathHashHandler ? pathHashHandler(p) : 0n)) & bit;
+                    }
+                    complex.set(path, pathHash);
+                }
+                result = (((result << 13n) | (result >> 51n)) ^ (keyHash * 0x243f6a8885a308d3n) ^ (valueHash * 0x517cc1b727220a95n) ^ (pathHash * 0x9e3779b97f4a7c15n)) & bit;
+                return true;
+            });
+            result = (result ^ (result >> 32n)) * 0x9e3779b97f4a7c15n;
+            result = (((result ^ (result >> 32n)) << 4n) & bit) | mask;
+            complex.set(value, result);
+            return result;
+        }
+        catch (error) {
+            throw new Error("Uncaught error on hashing object.");
+        }
+    }
+    return 0n;
+});
+;
+export let useHash = (target) => {
+    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) || (() => 0n);
+    return handler(target);
+};

package/dist/hook.d.ts

@@ -1,8 +1,21 @@
-import { type BiPredicate, type DeepPropertyKey, type DeepPropertyValue } from "./utility";
+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 useRandom: <T = number | bigint>(index: T) => T;
-export declare let useTraverse: <T extends object>(t: T, callback: BiPredicate<DeepPropertyKey<T>, DeepPropertyValue<T>>) => void;
+export declare let Useandom: <T = number | bigint>(index: T) => T;
+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)>;
+export interface UseTraverseCallback<T extends object> {
+    (key: UseTraverseKey<T>, value: UseTraverseValue<T>): boolean;
+}
+export interface UseTraversePathCallback<T extends object> {
+    (key: UseTraverseKey<T>, value: UseTraverseValue<T>, path: UseTraversePath<T>): boolean;
+}
+interface UseTraverse {
+    <T extends object>(t: T, callback: UseTraverseCallback<T>): void;
+    <T extends object>(t: T, callback: UseTraversePathCallback<T>): void;
+}
+export declare let useTraverse: UseTraverse;
 export declare let useGenerator: <E>(iterable: Iterable<E>) => Generator<E>;
 interface UseArrange {
     <E>(source: Iterable<E>): Generator<E>;

package/dist/hook.js

@@ -1,6 +1,6 @@
 import { useToArray } from "./collector";
 import { isBigInt, isFunction, isIterable, isNumber, isObject, isPrimitive } from "./guard";
-import { validate } from "./utility";
+import { invalidate, validate } from "./utility";
 export let useCompare = (t1, t2) => {
     if (t1 === t2 || Object.is(t1, t2)) {
         return 0;
@@ -16,7 +16,10 @@ export let useCompare = (t1, t2) => {
             case "boolean":
                 return t1 === t2 ? 0 : (t1 ? 1 : -1);
             case "symbol":
-                return Object.prototype.toString.call(t1).localeCompare(Object.prototype.toString.call(t2));
+                if (t1.description === t2.description) {
+                    return 0;
+                }
+                return (t1.description || "").localeCompare((t2.description) || "");
             case "function":
                 throw new TypeError("Cannot compare functions.");
             case "undefined":
@@ -41,7 +44,7 @@ export let useCompare = (t1, t2) => {
     }
     throw new TypeError("Cannot compare values of different types.");
 };
-export let useRandom = (index) => {
+export let Useandom = (index) => {
     if (isNumber(index)) {
         let x = Number(index);
         let phi = (1 + Math.sqrt(5)) / 2;
@@ -64,15 +67,20 @@ export let useRandom = (index) => {
     }
     throw new TypeError("Invalid input type");
 };
+;
+;
+;
 export let useTraverse = (t, callback) => {
     if (isObject(t)) {
         let seen = new WeakSet();
+        let path = [];
         let traverse = (target) => {
             if (!seen.has(target)) {
                 seen.add(target);
                 let stop = false;
                 let properties = Reflect.ownKeys(target);
                 for (let property of properties) {
+                    path.push(property);
                     let value = Reflect.get(target, property);
                     if (stop) {
                         break;
@@ -82,12 +90,13 @@ export let useTraverse = (t, callback) => {
                             if (isIterable(value)) {
                                 let index = 0;
                                 for (let item of value) {
+                                    path.push(index);
                                     if (validate(item)) {
                                         if (isObject(item)) {
                                             traverse(item);
                                         }
                                         else {
-                                            if (!callback(index, item)) {
+                                            if (!callback(index, item, path)) {
                                                 stop = true;
                                                 break;
                                             }
@@ -96,9 +105,12 @@ export let useTraverse = (t, callback) => {
                                     index++;
                                 }
                             }
+                            else {
+                                traverse(value);
+                            }
                         }
                         else {
-                            if (!callback(property, value)) {
+                            if (!callback(property, value, path)) {
                                 stop = true;
                                 break;
                             }
@@ -166,15 +178,50 @@ export let useArrange = (source, comparator) => {
     return useGenerator([]);
 };
 export let useToNumber = (target) => {
-    if (isNumber(target)) {
-        return target;
+    switch (typeof target) {
+        case "number":
+            return isNumber(target) ? target : 0;
+        case "boolean":
+            return target ? 1 : 0;
+        case "string":
+            let result = Number(target);
+            return isNumber(result) ? result : 0;
+        case "bigint":
+            return Number(target);
+        case "object":
+            if (invalidate(target)) {
+                return 0;
+            }
+            if (Reflect.has(target, Symbol.toPrimitive)) {
+                let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["default"]);
+                return isNumber(resolved) ? resolved : 0;
+            }
+            return 0;
+        default:
+            return 0;
     }
-    let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["default"]);
-    return isNumber(resolved) ? resolved : 0;
 };
 export let useToBigInt = (target) => {
-    if (isBigInt(target)) {
-        return target;
+    switch (typeof target) {
+        case "number":
+            return isNumber(target) ? BigInt(target) : 0n;
+        case "boolean":
+            return target ? 1n : 0n;
+        case "string":
+            let regex = /^[-+]?\d+$/;
+            return regex.test(target) ? BigInt(target) : 0n;
+        case "bigint":
+            return target;
+        case "object":
+            if (invalidate(target)) {
+                return 0n;
+            }
+            if (Reflect.has(target, Symbol.toPrimitive)) {
+                let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["default"]);
+                return isBigInt(resolved) ? resolved : 0n;
+            }
+            return 0n;
+        default:
+            return 0n;
     }
-    return BigInt(useToNumber(target));
 };

package/dist/index.d.ts

@@ -2,9 +2,12 @@ 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";

package/dist/index.js

@@ -2,9 +2,12 @@ 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";

package/dist/map.d.ts

@@ -0,0 +1,72 @@
+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>;
+}