semantic-typescript 0.6.0 → 0.7.0

package/dist/factory.js

@@ -29,7 +29,7 @@ export let useAnimationFrame = (period, delay = 0) => {
             };
         }
         catch (error) {
-            console.error(error);
+            throw error;
         }
     });
 };
@@ -53,7 +53,7 @@ export let useAttribute = (target) => {
                 });
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
@@ -115,7 +115,7 @@ export let useBlob = (blob, chunk = 64n * 1024n) => {
                     }
                 }
                 catch (error) {
-                    console.error(error);
+                    throw error;
                 }
                 finally {
                     if (stoppable) {
@@ -126,7 +126,7 @@ export let useBlob = (blob, chunk = 64n * 1024n) => {
             })();
         }
         catch (error) {
-            console.error(error);
+            throw error;
         }
     });
 };
@@ -195,6 +195,7 @@ export let useDocument = (argument1, argument2 = {}) => {
             let timeOut = null;
             let index = 0n;
             let activeCount = keys.size;
+            let listeners = new Map();
             let until = new Promise(resolve => {
                 for (let key of keys) {
                     if (!isString(key))
@@ -218,6 +219,10 @@ export let useDocument = (argument1, argument2 = {}) => {
                     let handleEvent = (event, currentKey) => {
                         if (interrupt(event, index)) {
                             window.document.removeEventListener(currentKey, listener);
+                            for (let [k, l] of listeners) {
+                                window.document.removeEventListener(k, l);
+                            }
+                            listeners.clear();
                             if (--activeCount === 0) {
                                 resolve();
                             }
@@ -227,6 +232,7 @@ export let useDocument = (argument1, argument2 = {}) => {
                         index++;
                     };
                     window.document.addEventListener(key, listener);
+                    listeners.set(key, listener);
                 }
             });
             await until;
@@ -255,8 +261,9 @@ export let useHTMLElement = (argument1, argument2, argument3 = {}) => {
                 let until = new Promise((resolve) => {
                     let listener = (event) => {
                         if (debounce > 0) {
-                            if (timeOut)
+                            if (timeOut) {
                                 clearTimeout(timeOut);
+                            }
                             timeOut = setTimeout(() => handle(event), debounce);
                             return;
                         }
@@ -271,8 +278,9 @@ export let useHTMLElement = (argument1, argument2, argument3 = {}) => {
                     let handle = (event) => {
                         if (interrupt(event, index)) {
                             element.removeEventListener(key, listener);
-                            if (timeOut)
+                            if (timeOut) {
                                 clearTimeout(timeOut);
+                            }
                             resolve();
                             return;
                         }
@@ -287,22 +295,25 @@ export let useHTMLElement = (argument1, argument2, argument3 = {}) => {
         if (isIterable(argument2)) {
             let keys = [...new Set(argument2)];
             return new AsynchronousSemantic(async (accept, interrupt) => {
-                let active = keys.length;
                 let index = 0n;
+                let listeners = new Map();
                 let until = new Promise((resolve) => {
                     for (let key of keys) {
                         let listener = (event) => {
                             if (interrupt(event, index)) {
                                 element.removeEventListener(key, listener);
-                                if (--active === 0) {
-                                    resolve();
+                                for (let [k, l] of listeners) {
+                                    element.removeEventListener(k, l);
                                 }
+                                listeners.clear();
+                                resolve();
                                 return;
                             }
                             accept(event, index);
                             index++;
                         };
                         element.addEventListener(key, listener);
+                        listeners.set(key, listener);
                     }
                 });
                 await until;
@@ -315,23 +326,31 @@ export let useHTMLElement = (argument1, argument2, argument3 = {}) => {
         if (isString(argument2)) {
             let key = argument2;
             return new AsynchronousSemantic(async (accept, interrupt) => {
-                let active = elements.length;
                 let index = 0n;
+                let listeners = new WeakMap();
                 let until = new Promise((resolve) => {
                     for (let element of elements) {
                         if (validate(element)) {
                             let listener = (event) => {
                                 if (interrupt(event, index)) {
                                     element.removeEventListener(key, listener);
-                                    if (--active === 0) {
-                                        resolve();
+                                    let map = listeners.get(element);
+                                    if (validate(map)) {
+                                        for (let [k, l] of map) {
+                                            element.removeEventListener(k, l);
+                                        }
+                                        map.clear();
                                     }
+                                    resolve();
                                     return;
                                 }
                                 accept(event, index);
                                 index++;
                             };
                             element.addEventListener(key, listener);
+                            let map = new Map() || new Map();
+                            map.set(key, listener);
+                            listeners.set(element, map);
                         }
                     }
                 });
@@ -341,8 +360,8 @@ export let useHTMLElement = (argument1, argument2, argument3 = {}) => {
         if (isIterable(argument2)) {
             let keys = new Set(argument2);
             return new AsynchronousSemantic(async (accept, interrupt) => {
-                let active = elements.length * keys.size;
                 let index = 0n;
+                let listeners = new Map();
                 let until = new Promise((resolve) => {
                     for (let element of elements) {
                         for (let key of keys) {
@@ -350,15 +369,18 @@ export let useHTMLElement = (argument1, argument2, argument3 = {}) => {
                                 let listener = (event) => {
                                     if (interrupt(event, index)) {
                                         element.removeEventListener(key, listener);
-                                        if (--active === 0) {
-                                            resolve();
+                                        for (let [k, l] of listeners) {
+                                            element.removeEventListener(k, l);
                                         }
+                                        listeners.clear();
+                                        resolve();
                                         return;
                                     }
                                     accept(event, index);
                                     index++;
                                 };
                                 element.addEventListener(key, listener);
+                                listeners.set(key, listener);
                             }
                         }
                     }
@@ -372,7 +394,7 @@ export let useHTMLElement = (argument1, argument2, argument3 = {}) => {
         if (isString(argument2)) {
             let key = argument2;
             return new AsynchronousSemantic(async (accept, interrupt) => {
-                let active = elementsOrSelectors.size;
+                let listeners = new Map();
                 let until = new Promise((resolve) => {
                     for (let elementOrSelector of elementsOrSelectors) {
                         if (validate(elementOrSelector)) {
@@ -381,14 +403,17 @@ export let useHTMLElement = (argument1, argument2, argument3 = {}) => {
                                 let listener = (event) => {
                                     if (interrupt(event, 0n)) {
                                         element.removeEventListener(key, listener);
-                                        if (--active === 0) {
-                                            resolve();
+                                        for (let [k, l] of listeners) {
+                                            element.removeEventListener(k, l);
                                         }
+                                        listeners.clear();
+                                        resolve();
                                         return;
                                     }
                                     accept(event, 0n);
                                 };
                                 element.addEventListener(key, listener);
+                                listeners.set(key, listener);
                             }
                             else if (isString(elementOrSelector)) {
                                 let selector = elementOrSelector;
@@ -398,14 +423,17 @@ export let useHTMLElement = (argument1, argument2, argument3 = {}) => {
                                         let listener = (event) => {
                                             if (interrupt(event, 0n)) {
                                                 element.removeEventListener(key, listener);
-                                                if (--active === 0) {
-                                                    resolve();
+                                                for (let [k, l] of listeners) {
+                                                    element.removeEventListener(k, l);
                                                 }
+                                                listeners.clear();
+                                                resolve();
                                                 return;
                                             }
                                             accept(event, 0n);
                                         };
                                         element.addEventListener(key, listener);
+                                        listeners.set(key, listener);
                                     }
                                 }
                             }
@@ -418,7 +446,7 @@ export let useHTMLElement = (argument1, argument2, argument3 = {}) => {
         if (isIterable(argument2)) {
             let keys = new Set(argument2);
             return new AsynchronousSemantic(async (accept, interrupt) => {
-                let active = elementsOrSelectors.size * keys.size;
+                let listeners = new Map();
                 let until = new Promise((resolve) => {
                     for (let elementOrSelector of elementsOrSelectors) {
                         if (isHTMLElemet(elementOrSelector)) {
@@ -428,14 +456,17 @@ export let useHTMLElement = (argument1, argument2, argument3 = {}) => {
                                     let listener = (event) => {
                                         if (interrupt(event, 0n)) {
                                             element.removeEventListener(key, listener);
-                                            if (--active === 0) {
-                                                resolve();
+                                            for (let [k, l] of listeners) {
+                                                element.removeEventListener(k, l);
                                             }
+                                            listeners.clear();
+                                            resolve();
                                             return;
                                         }
                                         accept(event, 0n);
                                     };
                                     element.addEventListener(key, listener);
+                                    listeners.set(key, listener);
                                 }
                             }
                         }
@@ -447,14 +478,17 @@ export let useHTMLElement = (argument1, argument2, argument3 = {}) => {
                                     let listener = (event) => {
                                         if (interrupt(event, 0n)) {
                                             element.removeEventListener(key, listener);
-                                            if (--active === 0) {
-                                                resolve();
+                                            for (let [k, l] of listeners) {
+                                                element.removeEventListener(k, l);
                                             }
+                                            listeners.clear();
+                                            resolve();
                                             return;
                                         }
                                         accept(event, 0n);
                                     };
                                     element.addEventListener(key, listener);
+                                    listeners.set(key, listener);
                                 }
                             }
                         }
@@ -483,7 +517,7 @@ export let useFill = (element, count) => {
                 }
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
@@ -504,7 +538,7 @@ export let useFrom = (iterable) => {
                 }
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
@@ -521,7 +555,7 @@ export let useFrom = (iterable) => {
                 }
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
@@ -543,7 +577,7 @@ export let useGenerate = (supplier, interrupt) => {
                 }
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
@@ -582,7 +616,7 @@ export let useInterval = (period, delay = 0) => {
                 }
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
@@ -594,7 +628,7 @@ export let useIterate = (generator) => {
             return new SynchronousSemantic(generator);
         }
         catch (error) {
-            console.error(error);
+            throw error;
         }
     }
     throw new TypeError("Invalid arguments.");
@@ -609,11 +643,11 @@ export let usePromise = (promise) => {
                     }
                     accept(value, 0n);
                 }).catch((error) => {
-                    console.error(error);
+                    throw error;
                 });
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
@@ -636,7 +670,7 @@ export let useOf = (...target) => {
                 }
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
@@ -661,7 +695,7 @@ export let useRange = (start, end, step = (isNumber(start) && isNumber(end) ? 1
                 }
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
@@ -679,13 +713,49 @@ export let useRange = (start, end, step = (isNumber(start) && isNumber(end) ? 1
                 }
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
     throw new TypeError("Invalid arguments.");
 };
 ;
+export let useText = (argument1, argument2, argument3) => {
+    if (isString(argument1)) {
+        if (isNumber(argument2) || isBigInt(argument2)) {
+            let start = useToNumber(argument2);
+            if (isNumber(argument3) || isBigInt(argument3)) {
+                let end = useToNumber(argument3);
+                let characters = [...(argument1.substring(start, end))];
+                return new SynchronousSemantic((accept, interrupt) => {
+                    let index = 0n;
+                    for (let character of characters) {
+                        if (interrupt(character, index)) {
+                            break;
+                        }
+                        accept(character, index);
+                        index++;
+                    }
+                });
+            }
+            else {
+                let characters = [...(argument1.substring(start))];
+                return new SynchronousSemantic((accept, interrupt) => {
+                    let index = 0n;
+                    for (let character of characters) {
+                        if (interrupt(character, index)) {
+                            break;
+                        }
+                        accept(character, index);
+                        index++;
+                    }
+                });
+            }
+        }
+    }
+    throw new TypeError("Invalid arguments.");
+};
+;
 ;
 export let useWebSocket = (argument1, argument2, argument3) => {
     let debounce = 0;
@@ -862,6 +932,7 @@ export let useWindow = (argument1, argument2 = {}) => {
             let timeOut = null;
             let index = 0n;
             let activeCount = keys.size;
+            let listeners = new Map();
             let until = new Promise(resolve => {
                 for (let key of keys) {
                     if (!isString(key))
@@ -885,6 +956,10 @@ export let useWindow = (argument1, argument2 = {}) => {
                     let handleEvent = (event, currentKey) => {
                         if (interrupt(event, index)) {
                             window.removeEventListener(currentKey, listener);
+                            for (let [k, l] of listeners) {
+                                window.removeEventListener(k, l);
+                            }
+                            listeners.clear();
                             if (--activeCount === 0) {
                                 resolve();
                             }
@@ -894,6 +969,7 @@ export let useWindow = (argument1, argument2 = {}) => {
                         index++;
                     };
                     window.addEventListener(key, listener);
+                    listeners.set(key, listener);
                 }
             });
             await until;

package/dist/hook.d.ts

@@ -1,5 +1,5 @@
 import { type DeepPropertyKey, type DeepPropertyValue } from "./utility";
-import type { Comparator, SynchronousGenerator } 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);
@@ -30,4 +30,9 @@ 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;
+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

@@ -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/main.d.ts

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

package/dist/main.js

@@ -0,0 +1,6 @@
+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/synchronous/collector.d.ts

@@ -1,5 +1,5 @@
 import { Optional } from "../optional";
-import type { Supplier, Predicate, BiPredicate, TriPredicate, BiFunctional, TriFunctional, Functional, SynchronousGenerator, Comparator, Consumer, BiConsumer } from "../utility";
+import type { BiFunctional, BiPredicate, Functional, Predicate, Supplier, TriFunctional, TriPredicate, Consumer, BiConsumer, Comparator, SynchronousGenerator } from "../utility";
 export declare class SynchronousCollector<E, A, R> {
     protected identity: Supplier<A>;
     protected interrupt: Predicate<E> | BiPredicate<E, bigint> | TriPredicate<E, bigint, A>;
@@ -14,6 +14,10 @@ export declare class SynchronousCollector<E, A, R> {
     collect(iterable: Iterable<E>): R;
     collect(start: number, end: number): R;
     collect(start: bigint, end: bigint): R;
+    getIdentity(): Supplier<A>;
+    getInterrupt(): Predicate<E> | BiPredicate<E, bigint> | TriPredicate<E, bigint, A>;
+    getAccumulator(): BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>;
+    getFinisher(): Functional<A, R>;
     static full<E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
     static full<E, A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
     static shortable<E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
@@ -140,17 +144,17 @@ interface UseSynchronousWrite {
 export declare let useSynchronousWrite: UseSynchronousWrite;
 interface UseSynchronousNumericSummate {
     <E>(): SynchronousCollector<E, number, number>;
-    <E>(mapper: Functional<E, number>): SynchronousCollector<E, number, number>;
+    <E>(mapper: Functional<E, number>): SynchronousCollector<number, number, number>;
 }
 export declare let useSynchronousNumericSummate: UseSynchronousNumericSummate;
 interface UseSynchronousBigIntSummate {
     <E>(): SynchronousCollector<E, bigint, bigint>;
-    <E>(mapper: Functional<E, bigint>): SynchronousCollector<E, bigint, bigint>;
+    <E>(mapper: Functional<E, bigint>): SynchronousCollector<bigint, bigint, bigint>;
 }
 export declare let useSynchronousBigIntSummate: UseSynchronousBigIntSummate;
 interface UseSynchronousNumericAverage {
     <E>(): SynchronousCollector<E, NumericAverageAccumulator, number>;
-    <E>(mapper: Functional<E, number>): SynchronousCollector<E, NumericAverageAccumulator, number>;
+    <E>(mapper: Functional<E, number>): SynchronousCollector<number, NumericAverageAccumulator, number>;
 }
 interface NumericAverageAccumulator {
     summate: number;