semantic-typescript 0.3.7 → 0.4.1

package/dist/collector.js

@@ -1,6 +1,8 @@
 import { isBigInt, isBoolean, isCollectable, isFunction, isIterable, isNumber, isObject, isSemantic, isString } from "./guard";
 import { useCompare, useToBigInt, useToNumber } from "./hook";
+import { HashMap } from "./map";
 import { Optional } from "./optional";
+import { HashSet } from "./set";
 import { CollectableSymbol } from "./symbol";
 import { validate, invalidate } from "./utility";
 export class Collector {
@@ -9,12 +11,45 @@ export class Collector {
     accumulator;
     finisher;
     Collector = CollectableSymbol;
-    constructor(identity, interruptor, accumulator, finisher) {
-        if (isFunction(identity) && isFunction(interruptor) && isFunction(accumulator) && isFunction(finisher)) {
+    constructor(identity, interrupt, accumulator, finisher) {
+        if (isFunction(identity) && isFunction(interrupt) && isFunction(accumulator) && isFunction(finisher)) {
             this.identity = identity;
-            this.interrupt = interruptor;
+            this.interrupt = interrupt;
             this.accumulator = accumulator;
             this.finisher = finisher;
+            Object.defineProperties(this, {
+                "identity": {
+                    value: identity,
+                    writable: false,
+                    enumerable: true,
+                    configurable: false
+                },
+                "interrupt": {
+                    value: interrupt,
+                    writable: false,
+                    enumerable: true,
+                    configurable: false
+                },
+                "accumulator": {
+                    value: accumulator,
+                    writable: false,
+                    enumerable: true,
+                    configurable: false
+                },
+                "finisher": {
+                    value: finisher,
+                    writable: false,
+                    enumerable: true,
+                    configurable: false
+                },
+                "Collector": {
+                    value: CollectableSymbol,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
+                }
+            });
+            Object.freeze(this);
         }
         else {
             throw new TypeError("Invalid arguments");
@@ -93,20 +128,22 @@ export class Collector {
     static full(identity, accumulator, finisher) {
         return new Collector(identity, () => false, accumulator, finisher);
     }
-    static shortable(identity, interruptor, accumulator, finisher) {
-        return new Collector(identity, interruptor, accumulator, finisher);
+    static shortable(identity, interrupt, accumulator, finisher) {
+        return new Collector(identity, interrupt, accumulator, finisher);
     }
 }
 ;
+;
 export let useAnyMatch = (predicate) => {
     if (isFunction(predicate)) {
-        return Collector.shortable(() => false, (_element, _index, accumulator) => isBoolean(accumulator) && accumulator, (accumulator, element) => accumulator || predicate(element), (accumulator) => accumulator);
+        return Collector.shortable(() => false, (_element, _index, accumulator) => isBoolean(accumulator) && accumulator, (accumulator, element, index) => accumulator || predicate(element, index), (accumulator) => accumulator);
     }
     throw new TypeError("Predicate must be a function.");
 };
+;
 export let useAllMatch = (predicate) => {
     if (isFunction(predicate)) {
-        return Collector.shortable(() => true, (_element, _index, accumulator) => isBoolean(accumulator) && !accumulator, (accumulator, element) => accumulator && predicate(element), (accumulator) => accumulator);
+        return Collector.shortable(() => true, (_element, _index, accumulator) => isBoolean(accumulator) && !accumulator, (accumulator, element, index) => accumulator && predicate(element, index), (accumulator) => accumulator);
     }
     throw new TypeError("Predicate must be a function.");
 };
@@ -165,6 +202,31 @@ export let useError = (argument1, argument2, argument3) => {
         });
     }
 };
+;
+export let useFindAt = (index) => {
+    let target = useToBigInt(index);
+    if (target < 0n) {
+        return Collector.full(() => [], (accumulator, element) => {
+            accumulator.push(element);
+            return accumulator;
+        }, (accumulator) => {
+            if (accumulator.length === 0) {
+                return Optional.empty();
+            }
+            let limited = (((BigInt(accumulator.length)) % target) + target) % target;
+            return Optional.ofNullable(accumulator[Number(limited)]);
+        });
+    }
+    return Collector.shortable(() => [], (_element, _index, accumulator) => BigInt(accumulator.length) - 1n === target, (accumulator, element) => {
+        accumulator.push(element);
+        return accumulator;
+    }, (accumulator) => {
+        if (accumulator.length === 0) {
+            return Optional.empty();
+        }
+        return Optional.ofNullable(accumulator[Number(target)]);
+    });
+};
 export let useFindFirst = () => {
     return Collector.shortable(() => Optional.empty(), (_element, _index, accumulator) => validate(accumulator) && accumulator.isPresent(), (accumulator, element) => {
         if (validate(accumulator) && accumulator.isPresent()) {
@@ -215,16 +277,18 @@ export let useForEach = (action) => {
     }
     throw new TypeError("Action must be a function.");
 };
+;
 export let useNoneMatch = (predicate) => {
     if (isFunction(predicate)) {
-        return Collector.shortable(() => true, (_element, _index, accumulator) => !accumulator, (accumulator, element) => accumulator && !predicate(element), (accumulator) => !accumulator);
+        return Collector.shortable(() => true, (_element, _index, accumulator) => !accumulator, (accumulator, element, index) => accumulator && !predicate(element, index), (accumulator) => !accumulator);
     }
     throw new TypeError("Predicate must be a function.");
 };
+;
 export let useGroup = (classifier) => {
     if (isFunction(classifier)) {
-        return Collector.full(() => new Map(), (accumulator, element) => {
-            let key = classifier(element);
+        return Collector.full(() => new Map(), (accumulator, element, index) => {
+            let key = classifier(element, index);
             let group = accumulator.get(key) || [];
             group.push(element);
             accumulator.set(key, group);
@@ -235,10 +299,10 @@ export let useGroup = (classifier) => {
 };
 export let useGroupBy = (keyExtractor, valueExtractor) => {
     if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
-        return Collector.full(() => new Map(), (accumulator, element) => {
-            let key = keyExtractor(element);
+        return Collector.full(() => new Map(), (accumulator, element, index) => {
+            let key = keyExtractor(element, index);
             let group = accumulator.get(key) || [];
-            group.push(valueExtractor(element));
+            group.push(valueExtractor(element, index));
             accumulator.set(key, group);
             return accumulator;
         }, (accumulator) => accumulator);
@@ -322,13 +386,14 @@ export let usePartition = (count) => {
     }
     throw new TypeError("Count must be a BigInt.");
 };
+;
 export let usePartitionBy = (classifier) => {
     if (isFunction(classifier)) {
         return Collector.full(() => {
             return [];
-        }, (array, element) => {
-            let index = classifier(element);
-            while (index > BigInt(array.length) - 1n) {
+        }, (array, element, index) => {
+            let resolved = classifier(element, index);
+            while (resolved > BigInt(array.length) - 1n) {
                 array.push([]);
             }
             array[Number(index)].push(element);
@@ -374,11 +439,24 @@ export let useToArray = () => {
         return array;
     }, (array) => array);
 };
+;
 export let useToMap = (keyExtractor, valueExtractor) => {
     if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
-        return Collector.full(() => new Map(), (map, element) => {
-            let key = keyExtractor(element);
-            let value = valueExtractor(element);
+        return Collector.full(() => new Map(), (map, element, index) => {
+            let key = keyExtractor(element, index);
+            let value = valueExtractor(element, index);
+            map.set(key, value);
+            return map;
+        }, (map) => map);
+    }
+    throw new TypeError("Key extractor and value extractor must be functions.");
+};
+;
+export let useToHashMap = (keyExtractor, valueExtractor) => {
+    if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
+        return Collector.full(() => new HashMap(), (map, element, index) => {
+            let key = keyExtractor(element, index);
+            let value = valueExtractor(element, index);
             map.set(key, value);
             return map;
         }, (map) => map);
@@ -391,6 +469,12 @@ export let useToSet = () => {
         return set;
     }, (set) => set);
 };
+export let useToHashSet = () => {
+    return Collector.full(() => new HashSet(), (set, element) => {
+        set.add(element);
+        return set;
+    }, (set) => set);
+};
 ;
 export let useWrite = (argument1, argument2) => {
     if (isObject(argument1)) {

package/dist/factory.d.ts

@@ -9,7 +9,11 @@ export declare let attribute: <T extends object>(target: T) => Semantic<Attribut
 export declare let blob: Functional<Blob, Semantic<Uint8Array>> & BiFunctional<Blob, bigint, Semantic<Uint8Array>>;
 export declare let empty: <E>() => Semantic<E>;
 export declare let fill: (<E>(element: E, count: bigint) => Semantic<E>) & (<E>(supplier: Supplier<E>, count: bigint) => Semantic<E>);
-export declare let from: <E>(iterable: Iterable<E>) => Semantic<E>;
+export interface From {
+    <E>(iterable: Iterable<E>): Semantic<E>;
+    <E>(iterable: AsyncIterable<E>): Semantic<E>;
+}
+export declare let from: From;
 export declare let generate: (<E>(supplier: Supplier<E>, interrupt: Predicate<E>) => Semantic<E>) & (<E>(supplier: Supplier<E>, interrupt: BiPredicate<E, bigint>) => Semantic<E>);
 export declare let interval: Functional<number, Semantic<number>> & BiFunctional<number, number, Semantic<number>>;
 export declare let iterate: <E>(generator: Generator<E>) => Semantic<E>;

package/dist/factory.js

@@ -1,4 +1,4 @@
-import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise } from "./guard";
+import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise, isAsyncIterable } from "./guard";
 import { useCompare, useTraverse } from "./hook";
 import { Semantic } from "./semantic";
 import { invalidate, validate } from "./utility";
@@ -148,6 +148,7 @@ export let fill = (element, count) => {
     }
     throw new TypeError("Invalid arguments.");
 };
+;
 export let from = (iterable) => {
     if (isIterable(iterable)) {
         return new Semantic((accept, interrupt) => {
@@ -166,6 +167,23 @@ export let from = (iterable) => {
             }
         });
     }
+    else if (isAsyncIterable(iterable)) {
+        return new Semantic(async (accept, interrupt) => {
+            try {
+                let index = 0n;
+                for await (let element of iterable) {
+                    if (interrupt(element, index)) {
+                        break;
+                    }
+                    accept(element, index);
+                    index++;
+                }
+            }
+            catch (error) {
+                throw new Error("Uncaught error as creating from semantic.");
+            }
+        });
+    }
     throw new TypeError("Invalid arguments");
 };
 export let generate = (supplier, interrupt) => {

package/dist/guard.d.ts

@@ -1,27 +1,36 @@
 import type { Collectable, OrderedCollectable, UnorderedCollectable } from "./collectable";
 import type { Collector } from "./collector";
+import type { Hashable } from "./hash";
+import type { HashMap, SemanticMap } from "./map";
 import type { Semantic } from "./semantic";
+import type { HashSet } from "./set";
 import type { Statistics } from "./statistics";
 import type { AsyncFunction, MaybePrimitive, Primitive } from "./utility";
-export declare let isBoolean: (t: unknown) => t is boolean;
-export declare let isString: (t: unknown) => t is string;
-export declare let isNumber: (t: unknown) => t is number;
-export declare let isFunction: (t: unknown) => t is Function;
-export declare let isObject: (t: unknown) => t is object;
-export declare let isSymbol: (t: unknown) => t is symbol;
-export declare let isBigInt: (t: unknown) => t is bigint;
-export declare let isPrimitive: (t: MaybePrimitive<unknown>) => t is Primitive;
-export declare let isIterable: (t: unknown) => t is Iterable<unknown>;
-export declare let isSemantic: (t: unknown) => t is Semantic<unknown>;
-export declare let isCollector: (t: unknown) => t is Collector<unknown, unknown, unknown>;
-export declare let isCollectable: (t: unknown) => t is Collectable<unknown>;
-export declare let isOrderedCollectable: (t: unknown) => t is OrderedCollectable<unknown>;
-export declare let isWindowCollectable: (t: unknown) => t is OrderedCollectable<unknown>;
-export declare let isUnorderedCollectable: (t: unknown) => t is UnorderedCollectable<unknown>;
-export declare let isStatistics: (t: unknown) => t is Statistics<unknown, number | bigint>;
-export declare let isNumericStatistics: (t: unknown) => t is Statistics<unknown, number | bigint>;
-export declare let isBigIntStatistics: (t: unknown) => t is Statistics<unknown, number | bigint>;
-export declare let isPromise: (t: unknown) => t is Promise<unknown>;
-export declare let isAsyncFunction: (t: unknown) => t is AsyncFunction;
-export declare let isGeneratorFunction: (t: unknown) => t is Generator<unknown, unknown, unknown>;
-export declare let isAsyncGeneratorFunction: (t: unknown) => t is AsyncGenerator<unknown, unknown, unknown>;
+import type { WindowCollectable } from "./window";
+export declare let isBoolean: (target: unknown) => target is boolean;
+export declare let isString: (target: unknown) => target is string;
+export declare let isNumber: (target: unknown) => target is number;
+export declare let isFunction: (target: unknown) => target is Function;
+export declare let isObject: (target: unknown) => target is object;
+export declare let isSymbol: (target: unknown) => target is symbol;
+export declare let isBigInt: (target: unknown) => target is bigint;
+export declare let isPrimitive: (target: MaybePrimitive<unknown>) => target is Primitive;
+export declare let isAsyncIterable: (target: unknown) => target is Iterable<unknown>;
+export declare let isIterable: (target: unknown) => target is Iterable<unknown>;
+export declare let isSemantic: (target: unknown) => target is Semantic<unknown>;
+export declare let isCollector: (target: unknown) => target is Collector<unknown, unknown, unknown>;
+export declare let isCollectable: (target: unknown) => target is Collectable<unknown>;
+export declare let isOrderedCollectable: (target: unknown) => target is OrderedCollectable<unknown>;
+export declare let isWindowCollectable: (target: unknown) => target is WindowCollectable<unknown>;
+export declare let isUnorderedCollectable: (target: unknown) => target is UnorderedCollectable<unknown>;
+export declare let isStatistics: (target: unknown) => target is Statistics<unknown, number | bigint>;
+export declare let isNumericStatistics: (target: unknown) => target is Statistics<unknown, number | bigint>;
+export declare let isBigIntStatistics: (target: unknown) => target is Statistics<unknown, number | bigint>;
+export declare let isSemanticMap: (target: unknown) => target is SemanticMap<unknown, unknown>;
+export declare let isHashable: (target: unknown) => target is Hashable;
+export declare let isHashMap: (target: unknown) => target is HashMap<unknown, unknown>;
+export declare let isHashSet: (target: unknown) => target is HashSet<unknown>;
+export declare let isPromise: (target: unknown) => target is Promise<unknown>;
+export declare let isAsyncFunction: (target: unknown) => target is AsyncFunction;
+export declare let isGeneratorFunction: (target: unknown) => target is Generator<unknown, unknown, unknown>;
+export declare let isAsyncGeneratorFunction: (target: unknown) => target is AsyncGenerator<unknown, unknown, unknown>;

package/dist/guard.js

@@ -1,109 +1,139 @@
-import { BigIntStatisticsSymbol, CollectableSymbol, CollectorsSymbol, NumericStatisticsSymbol, OrderedCollectableSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol } 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 isIterable = (t) => {
-    if (isObject(t)) {
-        return isFunction(Reflect.get(t, Symbol.iterator));
+export let isAsyncIterable = (target) => {
+    if (isObject(target)) {
+        return isFunction(Reflect.get(target, Symbol.asyncIterator));
     }
     return false;
 };
-export let isSemantic = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "Semantic") === SemanticSymbol;
+export let isIterable = (target) => {
+    if (isObject(target)) {
+        return isFunction(Reflect.get(target, Symbol.iterator));
     }
     return false;
 };
-export let isCollector = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "Collector") === CollectorsSymbol;
+export let isSemantic = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "Semantic") === SemanticSymbol;
     }
     return false;
 };
-export let isCollectable = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "Collectable") === CollectableSymbol;
+export let isCollector = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "Collector") === CollectorsSymbol;
     }
     return false;
 };
-export let isOrderedCollectable = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "OrderedCollectable") === OrderedCollectableSymbol;
+export let isCollectable = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "Collectable") === CollectableSymbol;
     }
     return false;
 };
-export let isWindowCollectable = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "WindowCollectable") === OrderedCollectableSymbol;
+export let isOrderedCollectable = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "OrderedCollectable") === OrderedCollectableSymbol;
     }
     return false;
 };
-export let isUnorderedCollectable = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "UnorderedCollectable") === UnorderedCollectableSymbol;
+export let isWindowCollectable = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "WindowCollectable") === WindowCollectableSymbol;
     }
     return false;
 };
-export let isStatistics = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "Statistics") === StatisticsSymbol;
+export let isUnorderedCollectable = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "UnorderedCollectable") === UnorderedCollectableSymbol;
     }
     return false;
 };
-export let isNumericStatistics = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "NumericStatistics") === NumericStatisticsSymbol;
+export let isStatistics = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "Statistics") === StatisticsSymbol;
     }
     return false;
 };
-export let isBigIntStatistics = (t) => {
-    if (isObject(t)) {
-        return Reflect.get(t, "BigIntStatistics") === BigIntStatisticsSymbol;
+export let isNumericStatistics = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "NumericStatistics") === NumericStatisticsSymbol;
     }
     return false;
 };
-export let isPromise = (t) => {
-    if (isObject(t)) {
-        return isFunction(Reflect.get(t, "then")) && isFunction(Reflect.get(t, "catch"));
+export let isBigIntStatistics = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "BigIntStatistics") === BigIntStatisticsSymbol;
     }
     return false;
 };
-export let isAsyncFunction = (t) => {
-    if (isFunction(t)) {
-        return Reflect.get(t, Symbol.toStringTag) === "AsyncFunction" && t.constructor.name === "AsyncFunction";
+export let isSemanticMap = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "SemanticMap") === SemanticMapSymbol;
     }
     return false;
 };
-export let isGeneratorFunction = (t) => {
-    if (isObject(t)) {
-        return isFunction(t) && Reflect.get(t, "constructor").name === "GeneratorFunction";
+export let isHashable = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, HashableSymbol) === HashableSymbol;
     }
     return false;
 };
-export let isAsyncGeneratorFunction = (t) => {
-    if (isObject(t)) {
-        return isFunction(t) && Reflect.get(t, "constructor").name === "AsyncGeneratorFunction";
+export let isHashMap = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "HashMap") === SemanticMapSymbol;
+    }
+    return false;
+};
+export let isHashSet = (target) => {
+    if (isObject(target)) {
+        return false;
+    }
+    return false;
+};
+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 {};