semantic-typescript 0.3.3 → 0.3.8

package/dist/factory.d.ts

@@ -1,19 +1,49 @@
 import { Semantic } from "./semantic";
-import type { BiFunctional, BiPredicate, Functional, Predicate, Supplier, TriFunctional, Generator } from "./utility";
-export declare let animationFrame: Functional<number, Semantic<number>> & BiFunctional<number, number, Semantic<number>>;
+import type { BiPredicate, Functional, Predicate, Supplier, Generator } from "./utility";
+interface AnimationFrameFunction {
+    (period: number): Semantic<number>;
+    (period: number, delay: number): Semantic<number>;
+}
+export declare let animationFrame: AnimationFrameFunction;
 interface Attribute<T> {
     key: keyof T;
     value: T[keyof T];
 }
 export declare let attribute: <T extends object>(target: T) => Semantic<Attribute<T>>;
-export declare let blob: Functional<Blob, Semantic<Uint8Array>> & BiFunctional<Blob, bigint, Semantic<Uint8Array>>;
+interface BlobFunction {
+    (blob: Blob): Semantic<Uint8Array>;
+    (blob: Blob, chunk: bigint): Semantic<Uint8Array>;
+}
+export declare let blob: BlobFunction;
 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 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>>;
+interface FillFunction {
+    <E>(element: E, count: bigint): Semantic<E>;
+    <E>(supplier: Supplier<E>, count: bigint): Semantic<E>;
+}
+export declare let fill: FillFunction;
+export interface FromFunction {
+    <E>(iterable: Iterable<E>): Semantic<E>;
+    <E>(iterable: AsyncIterable<E>): Semantic<E>;
+}
+export declare let from: FromFunction;
+interface GenerateFunction {
+    <E>(supplier: Supplier<E>, count: bigint): Semantic<E>;
+    <E>(element: E, count: bigint): Semantic<E>;
+    <E>(supplier: Supplier<E>, interrupt: Predicate<E>): Semantic<E>;
+    <E>(supplier: Supplier<E>, interrupt: BiPredicate<E, bigint>): Semantic<E>;
+}
+export declare let generate: GenerateFunction;
+interface IntervalFunction {
+    (period: number): Semantic<number>;
+    (period: number, delay: number): Semantic<number>;
+}
+export declare let interval: IntervalFunction;
 export declare let iterate: <E>(generator: Generator<E>) => Semantic<E>;
 export declare let promise: (<T>(promise: Promise<T>) => Semantic<T>);
-export declare let range: BiFunctional<number, number, Semantic<number>> & TriFunctional<number, number, number, Semantic<number>>;
+interface RangeFunction {
+    (start: number, end: number): Semantic<number>;
+    (start: number, end: number, step: number): Semantic<number>;
+}
+export declare let range: RangeFunction;
 export declare let websocket: Functional<WebSocket, Semantic<MessageEvent | CloseEvent | Event>>;
 export {};

package/dist/factory.js

@@ -1,51 +1,63 @@
-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";
+;
 export let animationFrame = (period, delay = 0) => {
     if (period <= 0 || !Number.isFinite(period) || delay < 0 || !Number.isFinite(delay)) {
         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.");
 };
+;
 export let blob = (blob, chunk = 64n * 1024n) => {
     let size = Number(chunk);
     if (size <= 0 || !Number.isSafeInteger(size)) {
@@ -55,115 +67,228 @@ 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 = () => {
     return new Semantic(() => { });
 };
+;
 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.");
             }
         });
     }
     throw new TypeError("Invalid arguments.");
 };
+;
 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.");
+            }
+        });
+    }
+    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) => {
-    if (isFunction(supplier) && isFunction(interrupt)) {
+;
+export let generate = (argument1, argument2) => {
+    if (isFunction(argument1)) {
+        if (isFunction(argument2)) {
+            let shutdown = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    while (true) {
+                        if (interrupt(argument1(), index) || shutdown(argument1(), index)) {
+                            break;
+                        }
+                        accept(argument1(), index);
+                        index++;
+                    }
+                }
+                catch (error) {
+                    throw new Error("Uncaught error as creating generate semantic.");
+                }
+            });
+        }
+        if (isBigInt(argument2)) {
+            let limit = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    while (index < limit) {
+                        if (interrupt(argument1(), index)) {
+                            break;
+                        }
+                        accept(argument1(), index);
+                        index++;
+                    }
+                }
+                catch (error) {
+                    throw new Error("Uncaught error as creating generate semantic.");
+                }
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    let element = argument1;
+    if (isFunction(argument2)) {
+        let shutdown = argument2;
         return new Semantic((accept, interrupt) => {
-            let index = 0n;
-            while (true) {
-                let element = supplier();
-                if (interrupt(element, index)) {
-                    break;
+            try {
+                let index = 0n;
+                while (true) {
+                    if (interrupt(element, index) || shutdown(element, index)) {
+                        break;
+                    }
+                    accept(element, index);
+                    index++;
                 }
-                accept(element, index);
-                index++;
+            }
+            catch (error) {
+                throw new Error("Uncaught error as creating generate semantic.");
             }
         });
     }
-    throw new TypeError("Invalid arguments");
+    if (isBigInt(argument2)) {
+        let limit = argument2;
+        return new Semantic((accept, interrupt) => {
+            try {
+                let index = 0n;
+                while (index < limit) {
+                    if (interrupt(element, index)) {
+                        break;
+                    }
+                    accept(element, index);
+                    index++;
+                }
+            }
+            catch (error) {
+                throw new Error("Uncaught error as creating generate semantic.");
+            }
+        });
+    }
+    throw new TypeError("Invalid arguments.");
 };
+;
 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 +299,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,27 +310,38 @@ 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 {
         throw new TypeError("Invalid arguments.");
     }
 };
+;
 export let range = (start, end, step = 1) => {
     if ((!isNumber(step) && !isBigInt(step)) || (isNumber(step) && useCompare(step, 0) === 0) || (isBigInt(step) && useCompare(step, 0n) === 0)) {
         throw new TypeError("Step must be numeric and cannot be zero.");
@@ -223,12 +350,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 +371,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

@@ -2,7 +2,8 @@ import type { Collectable, OrderedCollectable, UnorderedCollectable } from "./co
 import type { Collector } from "./collector";
 import type { Semantic } from "./semantic";
 import type { Statistics } from "./statistics";
-import type { AsyncFunction, MaybePrimitive, Primitive } from "./utility";
+import type { AsyncFunction, Generator, MaybePrimitive, Primitive } from "./utility";
+import type { WindowCollectable } from "./window";
 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;
@@ -11,15 +12,19 @@ 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 isAsyncIterable: (t: unknown) => t is Iterable<unknown>;
 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 isWindowCollectable: (t: unknown) => t is WindowCollectable<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 isAsync: (t: unknown) => t is AsyncFunction;
+export declare let isGenerator: (t: unknown) => t is Generator<unknown>;
+export declare let isAsyncFunction: (t: unknown) => t is AsyncFunction;
+export declare let isGeneratorFunction: (t: unknown) => t is globalThis.Generator<unknown, unknown, unknown>;
+export declare let isAsyncGeneratorFunction: (t: unknown) => t is globalThis.AsyncGenerator<unknown, unknown, unknown>;