semantic-typescript 0.3.3 → 0.3.7

package/dist/factory.js

@@ -7,41 +7,51 @@ export let animationFrame = (period, delay = 0) => {
         throw new TypeError("Period must be positive finite number and delay must be non-negative finite number.");
     }
     return new Semantic((accept, interrupt) => {
-        let start = performance.now();
-        let index = 0n;
-        let animate = () => {
-            if (performance.now() - start >= delay) {
-                requestAnimationFrame(animate);
-            }
-            else if (performance.now() - start < period) {
-                requestAnimationFrame(animate);
-            }
-            else {
-                if (interrupt(start, index)) {
-                    return;
+        try {
+            let start = performance.now();
+            let index = 0n;
+            let animate = () => {
+                if (performance.now() - start >= delay) {
+                    requestAnimationFrame(animate);
                 }
-                accept(performance.now(), index);
-            }
-        };
+                else if (performance.now() - start < period) {
+                    requestAnimationFrame(animate);
+                }
+                else {
+                    if (interrupt(start, index)) {
+                        return;
+                    }
+                    accept(performance.now(), index);
+                }
+            };
+        }
+        catch (error) {
+            throw new Error("Uncaught error as creating animation frame semantic.");
+        }
     });
 };
 ;
 export let attribute = (target) => {
     if (isObject(target)) {
         return new Semantic((accept, interrupt) => {
-            let index = 0n;
-            useTraverse(target, (key, value) => {
-                let attribute = {
-                    key: key,
-                    value: value
-                };
-                if (interrupt(attribute, index)) {
-                    return false;
-                }
-                accept(attribute, index);
-                index++;
-                return true;
-            });
+            try {
+                let index = 0n;
+                useTraverse(target, (key, value) => {
+                    let attribute = {
+                        key: key,
+                        value: value
+                    };
+                    if (interrupt(attribute, index)) {
+                        return false;
+                    }
+                    accept(attribute, index);
+                    index++;
+                    return true;
+                });
+            }
+            catch (error) {
+                throw new Error("Uncaught error as creating attribute semantic.");
+            }
         });
     }
     throw new TypeError("Target must be an object.");
@@ -55,60 +65,65 @@ export let blob = (blob, chunk = 64n * 1024n) => {
         throw new TypeError("Blob is invalid.");
     }
     return new Semantic((accept, interrupt) => {
-        let index = 0n;
-        let stoppable = false;
-        let stream = blob.stream();
-        let reader = stream.getReader();
-        let buffer = new Uint8Array(size);
-        let offset = 0;
-        (async () => {
-            try {
-                while (!stoppable) {
-                    let { done, value } = await reader.read();
-                    if (done) {
-                        if (offset > 0) {
-                            let element = buffer.subarray(0, offset);
-                            if (interrupt(element, index)) {
-                                stoppable = true;
-                            }
-                            else {
-                                accept(element, index);
-                                index++;
+        try {
+            let index = 0n;
+            let stoppable = false;
+            let stream = blob.stream();
+            let reader = stream.getReader();
+            let buffer = new Uint8Array(size);
+            let offset = 0;
+            (async () => {
+                try {
+                    while (!stoppable) {
+                        let { done, value } = await reader.read();
+                        if (done) {
+                            if (offset > 0) {
+                                let element = buffer.subarray(0, offset);
+                                if (interrupt(element, index)) {
+                                    stoppable = true;
+                                }
+                                else {
+                                    accept(element, index);
+                                    index++;
+                                }
                             }
+                            break;
                         }
-                        break;
-                    }
-                    let chunkData = value;
-                    let position = 0;
-                    while (position < chunkData.length && !stoppable) {
-                        let space = size - offset;
-                        let toCopy = Math.min(space, chunkData.length - position);
-                        buffer.set(chunkData.subarray(position, position + toCopy), offset);
-                        offset += toCopy;
-                        position += toCopy;
-                        if (offset === size) {
-                            if (interrupt(buffer, index)) {
-                                stoppable = true;
+                        let chunkData = value;
+                        let position = 0;
+                        while (position < chunkData.length && !stoppable) {
+                            let space = size - offset;
+                            let toCopy = Math.min(space, chunkData.length - position);
+                            buffer.set(chunkData.subarray(position, position + toCopy), offset);
+                            offset += toCopy;
+                            position += toCopy;
+                            if (offset === size) {
+                                if (interrupt(buffer, index)) {
+                                    stoppable = true;
+                                }
+                                else {
+                                    accept(buffer, index);
+                                    index++;
+                                }
+                                offset = 0;
                             }
-                            else {
-                                accept(buffer, index);
-                                index++;
-                            }
-                            offset = 0;
                         }
                     }
                 }
-            }
-            catch (error) {
-                console.error(error);
-            }
-            finally {
-                if (stoppable) {
-                    await reader.cancel();
+                catch (error) {
+                    console.error(error);
                 }
-                reader.releaseLock();
-            }
-        })();
+                finally {
+                    if (stoppable) {
+                        await reader.cancel();
+                    }
+                    reader.releaseLock();
+                }
+            })();
+        }
+        catch (error) {
+            throw new Error("Uncaught error as creating blob semantic.");
+        }
     });
 };
 export let empty = () => {
@@ -117,12 +132,17 @@ export let empty = () => {
 export let fill = (element, count) => {
     if (validate(element) && count > 0n) {
         return new Semantic((accept, interrupt) => {
-            for (let i = 0n; i < count; i++) {
-                let item = isFunction(element) ? element() : element;
-                if (interrupt(item, i)) {
-                    break;
+            try {
+                for (let i = 0n; i < count; i++) {
+                    let item = isFunction(element) ? element() : element;
+                    if (interrupt(item, i)) {
+                        break;
+                    }
+                    accept(item, i);
                 }
-                accept(item, i);
+            }
+            catch (error) {
+                throw new Error("Uncaught error as creating fill semantic.");
             }
         });
     }
@@ -131,13 +151,18 @@ export let fill = (element, count) => {
 export let from = (iterable) => {
     if (isIterable(iterable)) {
         return new Semantic((accept, interrupt) => {
-            let index = 0n;
-            for (let element of iterable) {
-                if (interrupt(element, index)) {
-                    break;
+            try {
+                let index = 0n;
+                for (let element of iterable) {
+                    if (interrupt(element, index)) {
+                        break;
+                    }
+                    accept(element, index);
+                    index++;
                 }
-                accept(element, index);
-                index++;
+            }
+            catch (error) {
+                throw new Error("Uncaught error as creating from semantic.");
             }
         });
     }
@@ -146,14 +171,19 @@ export let from = (iterable) => {
 export let generate = (supplier, interrupt) => {
     if (isFunction(supplier) && isFunction(interrupt)) {
         return new Semantic((accept, interrupt) => {
-            let index = 0n;
-            while (true) {
-                let element = supplier();
-                if (interrupt(element, index)) {
-                    break;
+            try {
+                let index = 0n;
+                while (true) {
+                    let element = supplier();
+                    if (interrupt(element, index)) {
+                        break;
+                    }
+                    accept(element, index);
+                    index++;
                 }
-                accept(element, index);
-                index++;
+            }
+            catch (error) {
+                throw new Error("Uncaught error as creating generate semantic.");
             }
         });
     }
@@ -162,8 +192,22 @@ export let generate = (supplier, interrupt) => {
 export let interval = (period, delay = 0) => {
     if (period > 0 && delay >= 0) {
         return new Semantic((accept, interrupt) => {
-            if (delay > 0) {
-                setTimeout(() => {
+            try {
+                if (delay > 0) {
+                    setTimeout(() => {
+                        let count = 0;
+                        let index = 0n;
+                        let timer = setInterval(() => {
+                            if (interrupt(count, index)) {
+                                clearInterval(timer);
+                            }
+                            accept(count, BigInt(index));
+                            index++;
+                            count += period;
+                        }, period);
+                    }, delay);
+                }
+                else {
                     let count = 0;
                     let index = 0n;
                     let timer = setInterval(() => {
@@ -174,19 +218,10 @@ export let interval = (period, delay = 0) => {
                         index++;
                         count += period;
                     }, period);
-                }, delay);
+                }
             }
-            else {
-                let count = 0;
-                let index = 0n;
-                let timer = setInterval(() => {
-                    if (interrupt(count, index)) {
-                        clearInterval(timer);
-                    }
-                    accept(count, BigInt(index));
-                    index++;
-                    count += period;
-                }, period);
+            catch (error) {
+                throw new Error("Uncaught error as creating interval semantic.");
             }
         });
     }
@@ -194,21 +229,31 @@ export let interval = (period, delay = 0) => {
 };
 export let iterate = (generator) => {
     if (isFunction(generator)) {
-        return new Semantic(generator);
+        try {
+            return new Semantic(generator);
+        }
+        catch (error) {
+            throw new Error("Uncaught error as creating iterate semantic.");
+        }
     }
     throw new TypeError("Invalid arguments.");
 };
 export let promise = (promise) => {
     if (isPromise(promise)) {
         return new Semantic((accept, interrupt) => {
-            promise.then((value) => {
-                if (interrupt(value, 0n)) {
-                    return;
-                }
-                accept(value, 0n);
-            }).catch((error) => {
-                console.error(error);
-            });
+            try {
+                promise.then((value) => {
+                    if (interrupt(value, 0n)) {
+                        return;
+                    }
+                    accept(value, 0n);
+                }).catch((error) => {
+                    console.error(error);
+                });
+            }
+            catch (error) {
+                throw new Error("Uncaught error as creating promise semantic.");
+            }
         });
     }
     else {
@@ -223,12 +268,17 @@ export let range = (start, end, step = 1) => {
         let minimum = start, maximum = end, limit = Number(step);
         let condition = limit > 0 ? (i) => i < maximum : (i) => i > maximum;
         return new Semantic((accept, interrupt) => {
-            for (let i = minimum; condition(i); i += limit) {
-                let value = i;
-                if (interrupt(value, BigInt(i))) {
-                    break;
+            try {
+                for (let i = minimum; condition(i); i += limit) {
+                    let value = i;
+                    if (interrupt(value, BigInt(i))) {
+                        break;
+                    }
+                    accept(value, BigInt(i));
                 }
-                accept(value, BigInt(i));
+            }
+            catch (error) {
+                throw new Error("Uncaught error as creating range semantic.");
             }
         });
     }
@@ -239,43 +289,48 @@ export let websocket = (websocket) => {
         throw new TypeError("WebSocket is invalid.");
     }
     return new Semantic((accept, interrupt) => {
-        let index = 0n;
-        let stop = false;
-        websocket.addEventListener("open", (event) => {
-            if (stop || interrupt(event, index)) {
-                stop = true;
-            }
-            else {
-                accept(event, index);
-                index++;
-            }
-        });
-        websocket.addEventListener("message", (event) => {
-            if (stop || interrupt(event, index)) {
-                stop = true;
-            }
-            else {
-                accept(event, index);
-                index++;
-            }
-        });
-        websocket.addEventListener("error", (event) => {
-            if (stop || interrupt(event, index)) {
-                stop = true;
-            }
-            else {
-                accept(event, index);
-                index++;
-            }
-        });
-        websocket.addEventListener("close", (event) => {
-            if (stop || interrupt(event, index)) {
-                stop = true;
-            }
-            else {
-                accept(event, index);
-                index++;
-            }
-        });
+        try {
+            let index = 0n;
+            let stop = false;
+            websocket.addEventListener("open", (event) => {
+                if (stop || interrupt(event, index)) {
+                    stop = true;
+                }
+                else {
+                    accept(event, index);
+                    index++;
+                }
+            });
+            websocket.addEventListener("message", (event) => {
+                if (stop || interrupt(event, index)) {
+                    stop = true;
+                }
+                else {
+                    accept(event, index);
+                    index++;
+                }
+            });
+            websocket.addEventListener("error", (event) => {
+                if (stop || interrupt(event, index)) {
+                    stop = true;
+                }
+                else {
+                    accept(event, index);
+                    index++;
+                }
+            });
+            websocket.addEventListener("close", (event) => {
+                if (stop || interrupt(event, index)) {
+                    stop = true;
+                }
+                else {
+                    accept(event, index);
+                    index++;
+                }
+            });
+        }
+        catch (error) {
+            throw new Error("Uncaught error as creating websocket semantic.");
+        }
     });
 };

package/dist/guard.d.ts

@@ -22,4 +22,6 @@ export declare let isStatistics: (t: unknown) => t is Statistics<unknown, number
 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 isAsync: (t: unknown) => t is AsyncFunction;
+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>;

package/dist/guard.js

@@ -6,7 +6,7 @@ export let isString = (t) => {
     return typeof t === "string";
 };
 export let isNumber = (t) => {
-    return typeof t === "number";
+    return typeof t === "number" && !Number.isNaN(t) && Number.isFinite(t);
 };
 export let isFunction = (t) => {
     return typeof t === "function";
@@ -89,9 +89,21 @@ export let isPromise = (t) => {
     }
     return false;
 };
-export let isAsync = (t) => {
+export let isAsyncFunction = (t) => {
     if (isFunction(t)) {
         return Reflect.get(t, Symbol.toStringTag) === "AsyncFunction" && t.constructor.name === "AsyncFunction";
     }
     return false;
 };
+export let isGeneratorFunction = (t) => {
+    if (isObject(t)) {
+        return isFunction(t) && Reflect.get(t, "constructor").name === "GeneratorFunction";
+    }
+    return false;
+};
+export let isAsyncGeneratorFunction = (t) => {
+    if (isObject(t)) {
+        return isFunction(t) && Reflect.get(t, "constructor").name === "AsyncGeneratorFunction";
+    }
+    return false;
+};

package/dist/hook.d.ts

@@ -1,4 +1,16 @@
 import { type BiPredicate, 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 useGenerator: <E>(iterable: Iterable<E>) => Generator<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>;
+}
+export declare let useArrange: UseArrange;
+export declare let useToNumber: <T = unknown>(target: T) => number;
+export declare let useToBigInt: <T = unknown>(target: T) => bigint;
+export {};

package/dist/hook.js

@@ -1,4 +1,5 @@
-import { isFunction, isIterable, isNumber, isObject, isPrimitive } from "./guard";
+import { useToArray } from "./collector";
+import { isBigInt, isFunction, isIterable, isNumber, isObject, isPrimitive } from "./guard";
 import { validate } from "./utility";
 export let useCompare = (t1, t2) => {
     if (t1 === t2 || Object.is(t1, t2)) {
@@ -109,3 +110,71 @@ export let useTraverse = (t, callback) => {
         traverse(t);
     }
 };
+export let useGenerator = (iterable) => {
+    if (isIterable(iterable)) {
+        return (accept, interrupt) => {
+            let index = 0n;
+            for (let element of iterable) {
+                if (interrupt(element, index)) {
+                    break;
+                }
+                accept(element, index);
+            }
+        };
+    }
+    return () => { };
+};
+;
+export let useArrange = (source, comparator) => {
+    if (isIterable(source)) {
+        let buffer = [...source];
+        if (validate(comparator) && isFunction(comparator)) {
+            return useGenerator(buffer.sort(comparator));
+        }
+        else {
+            return useGenerator(buffer.map((element, index) => {
+                return {
+                    element: element,
+                    index: BigInt(((index % buffer.length) + buffer.length) % buffer.length)
+                };
+            }).sort((a, b) => {
+                return Number(a.index - b.index);
+            }).map((indexed) => {
+                return indexed.element;
+            }));
+        }
+    }
+    else if (isFunction(source)) {
+        let collector = useToArray();
+        let buffer = collector.collect(source);
+        if (validate(comparator) && isFunction(comparator)) {
+            return useGenerator(buffer.sort(comparator));
+        }
+        else {
+            return useGenerator(buffer.map((element, index) => {
+                return {
+                    element: element,
+                    index: BigInt(((index % buffer.length) + buffer.length) % buffer.length)
+                };
+            }).sort((a, b) => {
+                return Number(a.index - b.index);
+            }).map((indexed) => {
+                return indexed.element;
+            }));
+        }
+    }
+    return useGenerator([]);
+};
+export let useToNumber = (target) => {
+    if (isNumber(target)) {
+        return target;
+    }
+    let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["default"]);
+    return isNumber(resolved) ? resolved : 0;
+};
+export let useToBigInt = (target) => {
+    if (isBigInt(target)) {
+        return target;
+    }
+    return BigInt(useToNumber(target));
+};

package/dist/index.d.ts

@@ -8,3 +8,4 @@ export * from "./semantic";
 export * from "./symbol";
 export * from "./statistics";
 export * from "./utility";
+export * from "./window";

package/dist/index.js

@@ -8,3 +8,4 @@ export * from "./semantic";
 export * from "./symbol";
 export * from "./statistics";
 export * from "./utility";
+export * from "./window";

package/dist/semantic.d.ts

@@ -1,7 +1,8 @@
-import { Collectable, OrderedCollectable, UnorderedCollectable, WindowCollectable } from "./collectable";
+import { Collectable, OrderedCollectable, UnorderedCollectable } from "./collectable";
 import { BigIntStatistics, NumericStatistics } from "./statistics";
 import { type Predicate } from "./utility";
 import type { Generator, Functional, BiFunctional, Consumer, BiConsumer, Comparator } from "./utility";
+import { WindowCollectable } from "./window";
 export declare class Semantic<E> {
     protected generator: Generator<E>;
     protected readonly Semantic: Symbol;
@@ -40,8 +41,3 @@ export declare class Semantic<E> {
     translate(offset: bigint): Semantic<E>;
     translate(translator: BiFunctional<E, bigint, bigint>): Semantic<E>;
 }
-export interface UseTransform {
-    <E, R>(generator: Generator<E>, mapper: Functional<E, R>): Generator<R>;
-    <E, R>(generator: Generator<E>, mapper: BiFunctional<E, bigint, R>): Generator<R>;
-}
-export declare let useTransform: UseTransform;