semantic-typescript 0.3.8 → 0.4.1

package/dist/guard.js

@@ -1,121 +1,139 @@
-import { BigIntStatisticsSymbol, CollectableSymbol, CollectorsSymbol, NumericStatisticsSymbol, OrderedCollectableSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol, WindowCollectableSymbol } from "./symbol";
-export let isBoolean = (t) => {
-    return typeof t === "boolean";
+import { BigIntStatisticsSymbol, CollectableSymbol, CollectorsSymbol, HashableSymbol, NumericStatisticsSymbol, OrderedCollectableSymbol, SemanticMapSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol, WindowCollectableSymbol } from "./symbol";
+export let isBoolean = (target) => {
+    return typeof target === "boolean";
 };
-export let isString = (t) => {
-    return typeof t === "string";
+export let isString = (target) => {
+    return typeof target === "string";
 };
-export let isNumber = (t) => {
-    return typeof t === "number" && !Number.isNaN(t) && Number.isFinite(t);
+export let isNumber = (target) => {
+    return typeof target === "number" && !Number.isNaN(target) && Number.isFinite(target);
 };
-export let isFunction = (t) => {
-    return typeof t === "function";
+export let isFunction = (target) => {
+    return typeof target === "function";
 };
-export let isObject = (t) => {
-    return typeof t === "object" && t !== null;
+export let isObject = (target) => {
+    return typeof target === "object" && target !== null;
 };
-export let isSymbol = (t) => {
-    return typeof t === "symbol";
+export let isSymbol = (target) => {
+    return typeof target === "symbol";
 };
-export let isBigInt = (t) => {
-    return typeof t === "bigint";
+export let isBigInt = (target) => {
+    return typeof target === "bigint";
 };
-export let isPrimitive = (t) => {
-    return isBoolean(t) || isString(t) || isNumber(t) || isSymbol(t) || isBigInt(t) || isFunction(t);
+export let isPrimitive = (target) => {
+    return isBoolean(target) || isString(target) || isNumber(target) || isSymbol(target) || isBigInt(target) || isFunction(target);
 };
-export let isAsyncIterable = (t) => {
-    if (isObject(t)) {
-        return isFunction(Reflect.get(t, Symbol.asyncIterator));
+export let isAsyncIterable = (target) => {
+    if (isObject(target)) {
+        return isFunction(Reflect.get(target, Symbol.asyncIterator));
     }
     return false;
 };
-export let isIterable = (t) => {
-    if (isObject(t)) {
-        return isFunction(Reflect.get(t, Symbol.iterator));
+export let isIterable = (target) => {
+    if (isObject(target)) {
+        return isFunction(Reflect.get(target, Symbol.iterator));
     }
     return false;
 };
-export let isSemantic = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "Semantic") === SemanticSymbol;
+export let isSemantic = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "Semantic") === SemanticSymbol;
     }
     return false;
 };
-export let isCollector = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "Collector") === CollectorsSymbol;
+export let isCollector = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "Collector") === CollectorsSymbol;
     }
     return false;
 };
-export let isCollectable = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "Collectable") === CollectableSymbol;
+export let isCollectable = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "Collectable") === CollectableSymbol;
     }
     return false;
 };
-export let isOrderedCollectable = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "OrderedCollectable") === OrderedCollectableSymbol;
+export let isOrderedCollectable = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "OrderedCollectable") === OrderedCollectableSymbol;
     }
     return false;
 };
-export let isWindowCollectable = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "WindowCollectable") === WindowCollectableSymbol;
+export let isWindowCollectable = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "WindowCollectable") === WindowCollectableSymbol;
     }
     return false;
 };
-export let isUnorderedCollectable = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "UnorderedCollectable") === UnorderedCollectableSymbol;
+export let isUnorderedCollectable = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "UnorderedCollectable") === UnorderedCollectableSymbol;
     }
     return false;
 };
-export let isStatistics = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "Statistics") === StatisticsSymbol;
+export let isStatistics = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "Statistics") === StatisticsSymbol;
     }
     return false;
 };
-export let isNumericStatistics = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "NumericStatistics") === NumericStatisticsSymbol;
+export let isNumericStatistics = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "NumericStatistics") === NumericStatisticsSymbol;
     }
     return false;
 };
-export let isBigIntStatistics = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "BigIntStatistics") === BigIntStatisticsSymbol;
+export let isBigIntStatistics = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "BigIntStatistics") === BigIntStatisticsSymbol;
     }
     return false;
 };
-export let isPromise = (t) => {
-    if (isObject(t)) {
-        return isFunction(Reflect.get(t, "then")) && isFunction(Reflect.get(t, "catch"));
+export let isSemanticMap = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "SemanticMap") === SemanticMapSymbol;
     }
     return false;
 };
-export let isGenerator = (t) => {
-    if (isFunction(t)) {
-        return t.length === 2;
+export let isHashable = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, HashableSymbol) === HashableSymbol;
     }
     return false;
 };
-export let isAsyncFunction = (t) => {
-    if (isFunction(t)) {
-        return Reflect.get(t, Symbol.toStringTag) === "AsyncFunction";
+export let isHashMap = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "HashMap") === SemanticMapSymbol;
     }
     return false;
 };
-export let isGeneratorFunction = (t) => {
-    if (isFunction(t)) {
-        return Reflect.get(t, Symbol.toStringTag) === "GeneratorFunction";
+export let isHashSet = (target) => {
+    if (isObject(target)) {
+        return false;
     }
     return false;
 };
-export let isAsyncGeneratorFunction = (t) => {
-    if (isFunction(t)) {
-        return Reflect.get(t, Symbol.toStringTag) === "AsyncGeneratorFunction";
+export let isPromise = (target) => {
+    if (isObject(target)) {
+        return isFunction(Reflect.get(target, "then")) && isFunction(Reflect.get(target, "catch"));
+    }
+    return false;
+};
+export let isAsyncFunction = (target) => {
+    if (isFunction(target)) {
+        return Reflect.get(target, Symbol.toStringTag) === "AsyncFunction" && target.constructor.name === "AsyncFunction";
+    }
+    return false;
+};
+export let isGeneratorFunction = (target) => {
+    if (isObject(target)) {
+        return isFunction(target) && Reflect.get(target, "constructor").name === "GeneratorFunction";
+    }
+    return false;
+};
+export let isAsyncGeneratorFunction = (target) => {
+    if (isObject(target)) {
+        return isFunction(target) && Reflect.get(target, "constructor").name === "AsyncGeneratorFunction";
     }
     return false;
 };

package/dist/hash.d.ts

@@ -0,0 +1,14 @@
+import { type Type } from "./utility";
+export interface Hashable {
+}
+export declare let maskOf: (type: Type) => bigint;
+interface Handler<T> {
+    (value: T): bigint;
+}
+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;
+}
+export declare let useHash: UseHash;
+export {};

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>;
@@ -13,5 +26,4 @@ interface UseArrange {
 export declare let useArrange: UseArrange;
 export declare let useToNumber: <T = unknown>(target: T) => number;
 export declare let useToBigInt: <T = unknown>(target: T) => bigint;
-export declare let useFunction: <T extends ((...args: any[]) => any)>(target: T) => T;
 export {};

package/dist/hook.js

@@ -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;
                             }
@@ -172,7 +184,7 @@ export let useToNumber = (target) => {
         case "boolean":
             return target ? 1 : 0;
         case "string":
-            let result = Number(target.trim());
+            let result = Number(target);
             return isNumber(result) ? result : 0;
         case "bigint":
             return Number(target);
@@ -180,9 +192,6 @@ export let useToNumber = (target) => {
             if (invalidate(target)) {
                 return 0;
             }
-            if (target instanceof Date) {
-                return target.getTime();
-            }
             if (Reflect.has(target, Symbol.toPrimitive)) {
                 let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["default"]);
                 return isNumber(resolved) ? resolved : 0;
@@ -200,7 +209,7 @@ export let useToBigInt = (target) => {
             return target ? 1n : 0n;
         case "string":
             let regex = /^[-+]?\d+$/;
-            return regex.test(target) ? BigInt(target.trim()) : 0n;
+            return regex.test(target) ? BigInt(target) : 0n;
         case "bigint":
             return target;
         case "object":
@@ -209,15 +218,10 @@ export let useToBigInt = (target) => {
             }
             if (Reflect.has(target, Symbol.toPrimitive)) {
                 let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["default"]);
-                return isBigInt(resolved) ? resolved : BigInt(useToNumber(resolved));
+                return isBigInt(resolved) ? resolved : 0n;
             }
             return 0n;
         default:
             return 0n;
     }
 };
-export let useFunction = (target) => {
-    return Object.freeze((...args) => {
-        return target(...args);
-    });
-};

package/dist/index.d.ts

@@ -2,9 +2,13 @@ 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

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