semantic-typescript 0.5.3 → 0.7.0

package/dist/guard.d.ts

@@ -1,7 +1,8 @@
-import type { Collectable, OrderedCollectable, Statistics, UnorderedCollectable, WindowCollectable } from "./semantic";
-import type { Collector } from "./collector";
+import type { AsynchronousCollector } from "./asynchronous/collector";
+import type { AsynchronousBigIntStatistics, AsynchronousNumericStatistics, AsynchronousOrderedCollectable, AsynchronousSemantic, AsynchronousStatistics, AsynchronousUnorderedCollectable, AsynchronousWindowCollectable } from "./asynchronous/semantic";
 import type { Optional } from "./optional";
-import type { Semantic } from "./semantic";
+import type { SynchronousCollector } from "./synchronous/collector";
+import type { SynchronousBigIntStatistics, SynchronousNumericStatistics, SynchronousOrderedCollectable, SynchronousSemantic, SynchronousStatistics, SynchronousUnorderedCollectable, SynchronousWindowCollectable } from "./synchronous/semantic";
 import type { AsyncFunction, MaybePrimitive, Primitive } from "./utility";
 export declare let isBoolean: (target: unknown) => target is boolean;
 export declare let isString: (target: unknown) => target is string;
@@ -11,18 +12,27 @@ 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 isAsyncIterable: (target: unknown) => target is AsyncIterable<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 isOptional: <T>(target: unknown) => target is Optional<T>;
+export declare let isAsynchronousSemantic: (target: unknown) => target is AsynchronousSemantic<unknown>;
+export declare let isSynchronousSemantic: (target: unknown) => target is SynchronousSemantic<unknown>;
+export declare let isAsynchronousCollectable: (target: unknown) => target is AsynchronousSemantic<unknown>;
+export declare let isSynchronousCollectable: (target: unknown) => target is SynchronousSemantic<unknown>;
+export declare let isAsynchronousOrderedCollectable: (target: unknown) => target is AsynchronousOrderedCollectable<unknown>;
+export declare let isSynchronousOrderedCollectable: (target: unknown) => target is SynchronousOrderedCollectable<unknown>;
+export declare let isAsynchronousUnorderedCollectable: (target: unknown) => target is AsynchronousUnorderedCollectable<unknown>;
+export declare let isSynchronousUnorderedCollectable: (target: unknown) => target is SynchronousUnorderedCollectable<unknown>;
+export declare let isAsynchronousStatistics: (target: unknown) => target is AsynchronousStatistics<unknown, number | bigint>;
+export declare let isSynchronousStatistics: (target: unknown) => target is SynchronousStatistics<unknown, number | bigint>;
+export declare let isAsynchronousBigIntStatistics: (target: unknown) => target is AsynchronousBigIntStatistics<unknown>;
+export declare let isSynchronousBigIntStatistics: (target: unknown) => target is SynchronousBigIntStatistics<unknown>;
+export declare let isAsynchronousNumericStatistics: (target: unknown) => target is AsynchronousNumericStatistics<unknown>;
+export declare let isSynchronousNumericStatistics: (target: unknown) => target is SynchronousNumericStatistics<unknown>;
+export declare let isAsynchronousWindowCollectable: (target: unknown) => target is AsynchronousWindowCollectable<unknown>;
+export declare let isSynchronousWindowCollectable: (target: unknown) => target is SynchronousWindowCollectable<unknown>;
+export declare let isSynchronousCollector: (target: unknown) => target is SynchronousCollector<unknown, unknown, unknown>;
+export declare let isAsynchronousCollector: (target: unknown) => target is AsynchronousCollector<unknown, unknown, unknown>;
+export declare let isOptional: (target: unknown) => target is Optional<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>;

package/dist/guard.js

@@ -1,4 +1,4 @@
-import { BigIntStatisticsSymbol, CollectableSymbol, CollectorsSymbol, NumericStatisticsSymbol, OptionalSymbol, OrderedCollectableSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol, WindowCollectableSymbol } from "./symbol";
+import { AsynchronousBigIntStatisticsSymbol, AsynchronousCollectorSymbol, AsynchronousNumericStatisticsSymbol, AsynchronousOrderedCollectableSymbol, AsynchronousSemanticSymbol, AsynchronousStatisticsSymbol, AsynchronousUnorderedCollectableSymbol, AsynchronousWindowCollectableSymbol, OptionalSymbol, SynchronousBigIntStatisticsSymbol, SynchronousCollectorSymbol, SynchronousNumericStatisticsSymbol, SynchronousOrderedCollectableSymbol, SynchronousSemanticSymbol, SynchronousStatisticsSymbol, SynchronousUnorderedCollectableSymbol, SynchronousWindowCollectableSymbol } from "./symbol";
 export let isBoolean = (target) => {
     return typeof target === "boolean";
 };
@@ -35,57 +35,111 @@ export let isIterable = (target) => {
     }
     return false;
 };
-export let isSemantic = (target) => {
+export let isAsynchronousSemantic = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "Semantic") === SemanticSymbol;
+        return Reflect.get(target, "AsynchronousSemantic") === AsynchronousSemanticSymbol;
     }
     return false;
 };
-export let isCollector = (target) => {
+export let isSynchronousSemantic = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "Collector") === CollectorsSymbol;
+        return Reflect.get(target, "SynchronousSemantic") === SynchronousSemanticSymbol;
     }
     return false;
 };
-export let isCollectable = (target) => {
+export let isAsynchronousCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "Collectable") === CollectableSymbol;
+        return Reflect.get(target, "AsynchronousCollectable") === AsynchronousSemanticSymbol || isAsynchronousSemantic(target) || isAsynchronousOrderedCollectable(target) || isAsynchronousUnorderedCollectable(target) || isAsynchronousStatistics(target) || isAsynchronousNumericStatistics(target) || isAsynchronousBigIntStatistics(target) || isAsynchronousWindowCollectable(target);
     }
     return false;
 };
-export let isOrderedCollectable = (target) => {
+export let isSynchronousCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "OrderedCollectable") === OrderedCollectableSymbol;
+        return Reflect.get(target, "SynchronousCollectable") === SynchronousSemanticSymbol || isSynchronousSemantic(target) || isSynchronousOrderedCollectable(target) || isSynchronousUnorderedCollectable(target) || isSynchronousStatistics(target) || isSynchronousNumericStatistics(target) || isSynchronousBigIntStatistics(target) || isSynchronousWindowCollectable(target);
     }
     return false;
 };
-export let isWindowCollectable = (target) => {
+export let isAsynchronousOrderedCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "WindowCollectable") === WindowCollectableSymbol;
+        return Reflect.get(target, "AsynchronousOrderedCollectable") === AsynchronousOrderedCollectableSymbol;
     }
     return false;
 };
-export let isUnorderedCollectable = (target) => {
+export let isSynchronousOrderedCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "UnorderedCollectable") === UnorderedCollectableSymbol;
+        return Reflect.get(target, "SynchronousOrderedCollectable") === SynchronousOrderedCollectableSymbol;
     }
     return false;
 };
-export let isStatistics = (target) => {
+export let isAsynchronousUnorderedCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "Statistics") === StatisticsSymbol;
+        return Reflect.get(target, "AsynchronousUnorderedCollectable") === AsynchronousUnorderedCollectableSymbol;
     }
     return false;
 };
-export let isNumericStatistics = (target) => {
+export let isSynchronousUnorderedCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "NumericStatistics") === NumericStatisticsSymbol;
+        return Reflect.get(target, "SynchronousUnorderedCollectable") === SynchronousUnorderedCollectableSymbol;
     }
     return false;
 };
-export let isBigIntStatistics = (target) => {
+export let isAsynchronousStatistics = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "BigIntStatistics") === BigIntStatisticsSymbol;
+        return Reflect.get(target, "AsynchronousStatistics") === AsynchronousStatisticsSymbol;
+    }
+    return false;
+};
+export let isSynchronousStatistics = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "SynchronousStatistics") === SynchronousStatisticsSymbol;
+    }
+    return false;
+};
+export let isAsynchronousBigIntStatistics = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "AsynchronousBigIntStatistics") === AsynchronousBigIntStatisticsSymbol;
+    }
+    return false;
+};
+export let isSynchronousBigIntStatistics = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "SynchronousBigIntStatistics") === SynchronousBigIntStatisticsSymbol;
+    }
+    return false;
+};
+export let isAsynchronousNumericStatistics = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "AsynchronousBigIntStatistics") === AsynchronousNumericStatisticsSymbol;
+    }
+    return false;
+};
+export let isSynchronousNumericStatistics = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "AsynchronousNumericStatistics") === SynchronousNumericStatisticsSymbol;
+    }
+    return false;
+};
+export let isAsynchronousWindowCollectable = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "AsynchronousWindowCollectable") === AsynchronousWindowCollectableSymbol;
+    }
+    return false;
+};
+export let isSynchronousWindowCollectable = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "SynchronousWindowCollectable") === SynchronousWindowCollectableSymbol;
+    }
+    return false;
+};
+export let isSynchronousCollector = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "SynchronousCollector") === SynchronousCollectorSymbol;
+    }
+    return false;
+};
+export let isAsynchronousCollector = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "AsynchronousCollector") === AsynchronousCollectorSymbol;
     }
     return false;
 };

package/dist/hook.d.ts

@@ -1,5 +1,5 @@
 import { type DeepPropertyKey, type DeepPropertyValue } from "./utility";
-import type { Comparator, Generator } from "./utility";
+import type { BiFunctional, Comparator, SynchronousGenerator } from "./utility";
 export declare let useCompare: <T>(t1: T, t2: T) => number;
 interface UseRandom {
     <N extends number | bigint>(start: N): N extends number ? number : (N extends bigint ? bigint : never);
@@ -20,14 +20,19 @@ interface UseTraverse {
     <T extends object>(t: T, callback: UseTraversePathCallback<T>): void;
 }
 export declare let useTraverse: UseTraverse;
-export declare let useGenerator: <E>(iterable: Iterable<E>) => Generator<E>;
+export declare let useGenerator: <E>(iterable: Iterable<E>) => SynchronousGenerator<E>;
 interface UseArrange {
-    <E>(source: Iterable<E>): Generator<E>;
-    <E>(source: Iterable<E>, comparator: Comparator<E>): Generator<E>;
-    <E>(source: Generator<E>): Generator<E>;
-    <E>(source: Generator<E>, comparator: Comparator<E>): Generator<E>;
+    <E>(source: Iterable<E>): SynchronousGenerator<E>;
+    <E>(source: Iterable<E>, comparator: Comparator<E>): SynchronousGenerator<E>;
+    <E>(source: SynchronousGenerator<E>): SynchronousGenerator<E>;
+    <E>(source: SynchronousGenerator<E>, comparator: Comparator<E>): SynchronousGenerator<E>;
 }
 export declare let useArrange: UseArrange;
 export declare let useToNumber: <T = unknown>(target: T) => number;
 export declare let useToBigInt: <T = unknown>(target: T) => bigint;
+interface UseStringify {
+    <T extends object>(target: T): string;
+    <T extends object, K extends DeepPropertyKey<T>, V extends DeepPropertyValue<T>>(target: T, callback: BiFunctional<K, V, string>): string;
+}
+export declare let useStringify: UseStringify;
 export {};

package/dist/hook.js

@@ -1,4 +1,4 @@
-import { useToArray } from "./collector";
+import { useSynchronousToArray } from "./synchronous/collector";
 import { isBigInt, isFunction, isIterable, isNumber, isObject, isPrimitive } from "./guard";
 import { invalidate, validate } from "./utility";
 export let useCompare = (t1, t2) => {
@@ -210,7 +210,7 @@ export let useArrange = (source, comparator) => {
         }
     }
     else if (isFunction(source)) {
-        let collector = useToArray();
+        let collector = useSynchronousToArray();
         let buffer = collector.collect(source);
         if (validate(comparator) && isFunction(comparator)) {
             return useGenerator(buffer.sort(comparator));
@@ -246,7 +246,7 @@ export let useToNumber = (target) => {
                 return 0;
             }
             if (Reflect.has(target, Symbol.toPrimitive)) {
-                let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["default"]);
+                let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["number"]);
                 return isNumber(resolved) ? resolved : 0;
             }
             return 0;
@@ -257,7 +257,7 @@ export let useToNumber = (target) => {
 export let useToBigInt = (target) => {
     switch (typeof target) {
         case "number":
-            return isNumber(target) ? BigInt(target) : 0n;
+            return isNumber(target) ? BigInt(Math.floor(target)) : 0n;
         case "boolean":
             return target ? 1n : 0n;
         case "string":
@@ -270,7 +270,7 @@ export let useToBigInt = (target) => {
                 return 0n;
             }
             if (Reflect.has(target, Symbol.toPrimitive)) {
-                let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["default"]);
+                let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["bigint"]);
                 return isBigInt(resolved) ? resolved : 0n;
             }
             return 0n;
@@ -278,3 +278,20 @@ export let useToBigInt = (target) => {
             return 0n;
     }
 };
+;
+export let useStringify = (target, callback) => {
+    let seen = new WeakSet();
+    let resolve = isFunction(callback) ? callback : (_key, value) => {
+        return JSON.stringify(value);
+    };
+    return JSON.stringify(target, (key, value) => {
+        if (isObject(value)) {
+            if (seen.has(value)) {
+                return (void 0);
+            }
+            seen.add(value);
+            return resolve(key, value);
+        }
+        return resolve(key, value);
+    });
+};

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export * from "./collector";
+export * from "./asynchronous/collector";
+export * from "./synchronous/collector";
 export * from "./factory";
 export * from "./guard";
 export * from "./hook";
 export * from "./optional";
-export * from "./semantic";
 export * from "./symbol";
 export * from "./utility";

package/dist/index.js

@@ -1,8 +1,8 @@
-export * from "./collector";
+export * from "./asynchronous/collector";
+export * from "./synchronous/collector";
 export * from "./factory";
 export * from "./guard";
 export * from "./hook";
 export * from "./optional";
-export * from "./semantic";
 export * from "./symbol";
 export * from "./utility";

package/dist/main.js

@@ -1,4 +1,6 @@
-import { useWindow } from 'semantic-typescript';
-useWindow("click").toEvent().forEach((event, index) => {
-    console.log(event.type + `第${index}次触发`);
-});
+import { useHTMLElement } from "./factory";
+let input = document.createElement("input");
+input.type = "text";
+input.placeholder = "Enter your name";
+document.body.appendChild(input);
+useHTMLElement(input, ["click", "change"]).peek(console.log).limit(5).toUnordered().log();

package/dist/optional.d.ts

@@ -1,4 +1,4 @@
-import type { Semantic } from "./semantic";
+import type { SynchronousSemantic } from "./synchronous/semantic";
 import { type Consumer, type Functional, type MaybeInvalid, type Predicate, type Runnable, type Valid } from "./utility";
 export declare class Optional<T> {
     protected value: MaybeInvalid<T>;
@@ -15,7 +15,7 @@ export declare class Optional<T> {
     flat(mapper: Functional<T, Optional<T>>): Optional<T>;
     flatMap<R>(mapper: Functional<T, Optional<R>>): Optional<R>;
     orElse(other: MaybeInvalid<T>): MaybeInvalid<T>;
-    semantic(): Semantic<T>;
+    semantic(): SynchronousSemantic<T>;
     static empty<T>(): Optional<T>;
     static of<T>(value: MaybeInvalid<T>): Optional<T>;
     static ofNullable<T>(value?: MaybeInvalid<T>): Optional<T>;

package/dist/symbol.d.ts

@@ -1,11 +1,20 @@
 export declare let OptionalSymbol: symbol;
-export declare let SemanticSymbol: symbol;
-export declare let CollectorsSymbol: symbol;
-export declare let CollectableSymbol: symbol;
-export declare let OrderedCollectableSymbol: symbol;
-export declare let WindowCollectableSymbol: symbol;
-export declare let StatisticsSymbol: symbol;
-export declare let NumericStatisticsSymbol: symbol;
-export declare let BigIntStatisticsSymbol: symbol;
-export declare let AsyncCollectableSymbol: symbol;
-export declare let UnorderedCollectableSymbol: symbol;
+export declare let AsynchronousSemanticSymbol: symbol;
+export declare let SynchronousSemanticSymbol: symbol;
+export declare let AsynchronousCollectorSymbol: symbol;
+export declare let SynchronousCollectorSymbol: symbol;
+export declare let DispatchCollectableSymbol: symbol;
+export declare let AsynchronousCollectableSymbol: symbol;
+export declare let SynchronousCollectableSymbol: symbol;
+export declare let AsynchronousOrderedCollectableSymbol: symbol;
+export declare let SynchronousOrderedCollectableSymbol: symbol;
+export declare let AsynchronousUnorderedCollectableSymbol: symbol;
+export declare let SynchronousUnorderedCollectableSymbol: symbol;
+export declare let AsynchronousWindowCollectableSymbol: symbol;
+export declare let SynchronousWindowCollectableSymbol: symbol;
+export declare let AsynchronousStatisticsSymbol: symbol;
+export declare let SynchronousStatisticsSymbol: symbol;
+export declare let AsynchronousNumericStatisticsSymbol: symbol;
+export declare let SynchronousNumericStatisticsSymbol: symbol;
+export declare let AsynchronousBigIntStatisticsSymbol: symbol;
+export declare let SynchronousBigIntStatisticsSymbol: symbol;

package/dist/symbol.js

@@ -1,11 +1,20 @@
 export let OptionalSymbol = Symbol.for("Optional");
-export let SemanticSymbol = Symbol.for("Semantic");
-export let CollectorsSymbol = Symbol.for("Collector");
-export let CollectableSymbol = Symbol.for("Collectable");
-export let OrderedCollectableSymbol = Symbol.for("OrderedCollectable");
-export let WindowCollectableSymbol = Symbol.for("WindowCollectable");
-export let StatisticsSymbol = Symbol.for("Statistics");
-export let NumericStatisticsSymbol = Symbol.for("NumericStatistics");
-export let BigIntStatisticsSymbol = Symbol.for("BigIntStatistics");
-export let AsyncCollectableSymbol = Symbol.for("AsyncCollectable");
-export let UnorderedCollectableSymbol = Symbol.for("UnorderedCollectable");
+export let AsynchronousSemanticSymbol = Symbol.for("AsynchronousSemantic");
+export let SynchronousSemanticSymbol = Symbol.for("SynchronousSemantic");
+export let AsynchronousCollectorSymbol = Symbol.for("AsynchronousCollector");
+export let SynchronousCollectorSymbol = Symbol.for("SynchronousCollector");
+export let DispatchCollectableSymbol = Symbol.for("DispatchCollectable");
+export let AsynchronousCollectableSymbol = Symbol.for("AsynchronousCollectable");
+export let SynchronousCollectableSymbol = Symbol.for("SynchronousCollectable");
+export let AsynchronousOrderedCollectableSymbol = Symbol.for("OrderedAsynchronousCollectable");
+export let SynchronousOrderedCollectableSymbol = Symbol.for("OrderedSynchronousCollectable");
+export let AsynchronousUnorderedCollectableSymbol = Symbol.for("AsynchronousUnorderedCollectable");
+export let SynchronousUnorderedCollectableSymbol = Symbol.for("SynchronousUnorderedCollectable");
+export let AsynchronousWindowCollectableSymbol = Symbol.for("AsynchronousWindowCollectable");
+export let SynchronousWindowCollectableSymbol = Symbol.for("SynchronousWindowCollectable");
+export let AsynchronousStatisticsSymbol = Symbol.for("AsynchronousStatistics");
+export let SynchronousStatisticsSymbol = Symbol.for("AsynchronousStatistics");
+export let AsynchronousNumericStatisticsSymbol = Symbol.for("AsynchronousNumericStatistics");
+export let SynchronousNumericStatisticsSymbol = Symbol.for("SynchronousNumericStatisticsSymbol");
+export let AsynchronousBigIntStatisticsSymbol = Symbol.for("AsynchronousBigIntStatistics");
+export let SynchronousBigIntStatisticsSymbol = Symbol.for("SynchronousBigIntStatisticsSymbol");