semantic-typescript 0.4.1 → 0.5.3

package/dist/factory.js

@@ -1,8 +1,10 @@
-import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise, isAsyncIterable } from "./guard";
-import { useCompare, useTraverse } from "./hook";
+import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise, isAsyncIterable, isString, isHTMLElemet } from "./guard";
+import { useCompare, useToBigInt, useToNumber, useTraverse } from "./hook";
+import { Optional } from "./optional";
 import { Semantic } from "./semantic";
 import { invalidate, validate } from "./utility";
-export let animationFrame = (period, delay = 0) => {
+;
+export let useAnimationFrame = (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.");
     }
@@ -26,12 +28,12 @@ export let animationFrame = (period, delay = 0) => {
             };
         }
         catch (error) {
-            throw new Error("Uncaught error as creating animation frame semantic.");
+            console.error(error);
         }
     });
 };
 ;
-export let attribute = (target) => {
+export let useAttribute = (target) => {
     if (isObject(target)) {
         return new Semantic((accept, interrupt) => {
             try {
@@ -50,13 +52,14 @@ export let attribute = (target) => {
                 });
             }
             catch (error) {
-                throw new Error("Uncaught error as creating attribute semantic.");
+                console.error(error);
             }
         });
     }
     throw new TypeError("Target must be an object.");
 };
-export let blob = (blob, chunk = 64n * 1024n) => {
+;
+export let useBlob = (blob, chunk = 64n * 1024n) => {
     let size = Number(chunk);
     if (size <= 0 || !Number.isSafeInteger(size)) {
         throw new RangeError("Chunk size must be a safe positive integer.");
@@ -122,14 +125,268 @@ export let blob = (blob, chunk = 64n * 1024n) => {
             })();
         }
         catch (error) {
-            throw new Error("Uncaught error as creating blob semantic.");
+            console.error(error);
         }
     });
 };
-export let empty = () => {
+;
+export let useDocument = (argument) => {
+    if (isString(argument)) {
+        let key = argument;
+        return new Semantic((accept, interrupt) => {
+            try {
+                let index = 0n;
+                let listener = (event) => {
+                    if (interrupt(event, index)) {
+                        window.document.addEventListener(key, listener);
+                    }
+                    else {
+                        accept(event, index);
+                        index++;
+                    }
+                };
+                window.document.addEventListener(key, listener);
+            }
+            catch (error) {
+                console.error(error);
+            }
+        });
+    }
+    if (isIterable(argument)) {
+        let keys = new Set(argument);
+        return new Semantic((accept, interrupt) => {
+            try {
+                let index = 0n;
+                for (let key of keys) {
+                    if (isString(key)) {
+                        let listener = (event) => {
+                            if (interrupt(event, index)) {
+                                window.document.addEventListener(key, listener);
+                            }
+                            else {
+                                accept(event, index);
+                                index++;
+                            }
+                        };
+                        window.document.addEventListener(key, listener);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(error);
+            }
+        });
+    }
+    throw new TypeError("Argument must be a string or an iterable of strings.");
+};
+;
+export let useHTMLElement = (argument1, argument2) => {
+    if (isString(argument1)) {
+        let selector = argument1;
+        if (isString(argument2)) {
+            let key = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    let elements = window.document.querySelectorAll(selector);
+                    for (let element of elements) {
+                        if (validate(element)) {
+                            let listener = (event) => {
+                                if (interrupt(event, index)) {
+                                    element.removeEventListener(key, listener);
+                                }
+                                else {
+                                    accept(event, index);
+                                    index++;
+                                }
+                            };
+                            element.addEventListener(key, listener);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            });
+        }
+        if (isIterable(argument2)) {
+            let keys = new Set(argument2);
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    let elements = window.document.querySelectorAll(selector);
+                    for (let element of elements) {
+                        for (let key of keys) {
+                            if (isString(key)) {
+                                let listener = (event) => {
+                                    if (interrupt(event, index)) {
+                                        element.removeEventListener(key, listener);
+                                    }
+                                    else {
+                                        accept(event, index);
+                                        index++;
+                                    }
+                                };
+                                element.addEventListener(key, listener);
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            });
+        }
+    }
+    if (isIterable(argument1)) {
+        let elementsOrSelectors = argument1;
+        if (isString(argument2)) {
+            let key = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    for (let elementOrSelector of elementsOrSelectors) {
+                        if (isString(elementOrSelector)) {
+                            let element = window.document.querySelector(elementOrSelector);
+                            if (validate(element)) {
+                                let listener = (event) => {
+                                    if (interrupt(event, index)) {
+                                        element.removeEventListener(key, listener);
+                                    }
+                                    else {
+                                        accept(event, index);
+                                        index++;
+                                    }
+                                };
+                                element.addEventListener(key, listener);
+                            }
+                        }
+                        else if (isHTMLElemet(elementOrSelector)) {
+                            let element = elementOrSelector;
+                            let listener = (event) => {
+                                if (interrupt(event, index)) {
+                                    element.removeEventListener(key, listener);
+                                }
+                                else {
+                                    accept(event, index);
+                                    index++;
+                                }
+                            };
+                            element.addEventListener(key, listener);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            });
+        }
+        if (isIterable(argument2)) {
+            let keys = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    for (let elementOrSelector of elementsOrSelectors) {
+                        if (isString(elementOrSelector)) {
+                            let element = window.document.querySelector(elementOrSelector);
+                            if (validate(element)) {
+                                for (let key of keys) {
+                                    if (isString(key)) {
+                                        let listener = (event) => {
+                                            if (interrupt(event, index)) {
+                                                element.removeEventListener(key, listener);
+                                            }
+                                            else {
+                                                accept(event, index);
+                                                index++;
+                                            }
+                                        };
+                                        element.addEventListener(key, listener);
+                                    }
+                                }
+                            }
+                        }
+                        else if (isHTMLElemet(elementOrSelector)) {
+                            let element = elementOrSelector;
+                            for (let key of keys) {
+                                if (isString(key)) {
+                                    let listener = (event) => {
+                                        if (interrupt(event, index)) {
+                                            element.removeEventListener(key, listener);
+                                        }
+                                        else {
+                                            accept(event, index);
+                                            index++;
+                                        }
+                                    };
+                                    element.addEventListener(key, listener);
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            });
+        }
+    }
+    if (isHTMLElemet(argument1)) {
+        let element = argument1;
+        if (isString(argument2)) {
+            let key = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    let listener = (event) => {
+                        if (interrupt(event, index)) {
+                            element.removeEventListener(key, listener);
+                        }
+                        else {
+                            accept(event, index);
+                            index++;
+                        }
+                    };
+                    element.addEventListener(key, listener);
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            });
+        }
+        if (isIterable(argument2)) {
+            let keys = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    for (let key of keys) {
+                        if (isString(key)) {
+                            let listener = (event) => {
+                                if (interrupt(event, index)) {
+                                    element.removeEventListener(key, listener);
+                                }
+                                else {
+                                    accept(event, index);
+                                    index++;
+                                }
+                            };
+                            element.addEventListener(key, listener);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            });
+        }
+    }
+    throw new TypeError("Invalid arguments.");
+};
+export let useEmpty = () => {
     return new Semantic(() => { });
 };
-export let fill = (element, count) => {
+;
+export let useFill = (element, count) => {
     if (validate(element) && count > 0n) {
         return new Semantic((accept, interrupt) => {
             try {
@@ -142,14 +399,14 @@ export let fill = (element, count) => {
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error as creating fill semantic.");
+                console.error(error);
             }
         });
     }
     throw new TypeError("Invalid arguments.");
 };
 ;
-export let from = (iterable) => {
+export let useFrom = (iterable) => {
     if (isIterable(iterable)) {
         return new Semantic((accept, interrupt) => {
             try {
@@ -163,7 +420,7 @@ export let from = (iterable) => {
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error as creating from semantic.");
+                console.error(error);
             }
         });
     }
@@ -180,13 +437,14 @@ export let from = (iterable) => {
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error as creating from semantic.");
+                console.error(error);
             }
         });
     }
     throw new TypeError("Invalid arguments");
 };
-export let generate = (supplier, interrupt) => {
+;
+export let useGenerate = (supplier, interrupt) => {
     if (isFunction(supplier) && isFunction(interrupt)) {
         return new Semantic((accept, interrupt) => {
             try {
@@ -201,13 +459,14 @@ export let generate = (supplier, interrupt) => {
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error as creating generate semantic.");
+                console.error(error);
             }
         });
     }
     throw new TypeError("Invalid arguments");
 };
-export let interval = (period, delay = 0) => {
+;
+export let useInterval = (period, delay = 0) => {
     if (period > 0 && delay >= 0) {
         return new Semantic((accept, interrupt) => {
             try {
@@ -239,24 +498,24 @@ export let interval = (period, delay = 0) => {
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error as creating interval semantic.");
+                console.error(error);
             }
         });
     }
     throw new TypeError("Invalid arguments.");
 };
-export let iterate = (generator) => {
+export let useIterate = (generator) => {
     if (isFunction(generator)) {
         try {
             return new Semantic(generator);
         }
         catch (error) {
-            throw new Error("Uncaught error as creating iterate semantic.");
+            console.error(error);
         }
     }
     throw new TypeError("Invalid arguments.");
 };
-export let promise = (promise) => {
+export let usePromise = (promise) => {
     if (isPromise(promise)) {
         return new Semantic((accept, interrupt) => {
             try {
@@ -270,7 +529,7 @@ export let promise = (promise) => {
                 });
             }
             catch (error) {
-                throw new Error("Uncaught error as creating promise semantic.");
+                console.error(error);
             }
         });
     }
@@ -278,77 +537,188 @@ export let promise = (promise) => {
         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.");
-    }
-    if (isNumber(start) && isNumber(end)) {
-        let minimum = start, maximum = end, limit = Number(step);
-        let condition = limit > 0 ? (i) => i < maximum : (i) => i > maximum;
+;
+export let useOf = (...target) => {
+    if (Array.isArray(target)) {
         return new Semantic((accept, interrupt) => {
             try {
-                for (let i = minimum; condition(i); i += limit) {
-                    let value = i;
-                    if (interrupt(value, BigInt(i))) {
+                let index = 0n;
+                for (let element of target) {
+                    if (interrupt(element, index)) {
                         break;
                     }
-                    accept(value, BigInt(i));
+                    accept(element, index);
+                    index++;
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error as creating range semantic.");
+                console.error(error);
             }
         });
     }
     throw new TypeError("Invalid arguments.");
 };
-export let websocket = (websocket) => {
-    if (invalidate(websocket)) {
-        throw new TypeError("WebSocket is invalid.");
+;
+export let useRange = (start, end, step = (isNumber(start) && isNumber(end) ? 1 : 1n)) => {
+    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.");
     }
-    return new Semantic((accept, interrupt) => {
-        try {
-            let index = 0n;
-            let stop = false;
-            websocket.addEventListener("open", (event) => {
-                if (stop || interrupt(event, index)) {
-                    stop = true;
-                }
-                else {
-                    accept(event, index);
+    if (isNumber(start) && isNumber(end)) {
+        let trusted = useToNumber(step);
+        return new Semantic((accept, interrupt) => {
+            try {
+                let index = 0n;
+                for (let i = start; i < end; i += trusted) {
+                    if (interrupt(i, index)) {
+                        break;
+                    }
+                    accept(i, index);
                     index++;
                 }
-            });
-            websocket.addEventListener("message", (event) => {
-                if (stop || interrupt(event, index)) {
-                    stop = true;
-                }
-                else {
-                    accept(event, index);
+            }
+            catch (error) {
+                console.error(error);
+            }
+        });
+    }
+    else if (isBigInt(start) && isBigInt(end)) {
+        let trusted = useToBigInt(step);
+        return new Semantic((accept, interrupt) => {
+            try {
+                let index = 0n;
+                for (let i = start; i < end; i += trusted) {
+                    if (interrupt(i, index)) {
+                        break;
+                    }
+                    accept(i, index);
                     index++;
                 }
-            });
-            websocket.addEventListener("error", (event) => {
-                if (stop || interrupt(event, index)) {
-                    stop = true;
+            }
+            catch (error) {
+                console.error(error);
+            }
+        });
+    }
+    throw new TypeError("Invalid arguments.");
+};
+;
+export let useWebSocket = (argument1, argument2) => {
+    if (isObject(argument1) && isFunction(Reflect.get(argument1, "addEventListener"))) {
+        let websocket = argument1;
+        if (isString(argument2)) {
+            let key = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let listener = (event) => {
+                        if (interrupt(event, 0n)) {
+                            websocket.removeEventListener(key, listener);
+                        }
+                        else {
+                            accept(event, 0n);
+                        }
+                    };
+                    websocket.addEventListener(key, listener);
                 }
-                else {
-                    accept(event, index);
-                    index++;
+                catch (error) {
+                    console.error(error);
                 }
             });
-            websocket.addEventListener("close", (event) => {
-                if (stop || interrupt(event, index)) {
-                    stop = true;
+        }
+        else if (isIterable(argument2)) {
+            let keys = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    for (let key of keys) {
+                        if (isString(key)) {
+                            let listener = (event) => {
+                                if (interrupt(event, 0n)) {
+                                    websocket.removeEventListener(key, listener);
+                                }
+                                else {
+                                    accept(event, 0n);
+                                }
+                            };
+                            websocket.addEventListener(key, listener);
+                        }
+                    }
                 }
-                else {
-                    accept(event, index);
-                    index++;
+                catch (error) {
+                    console.error(error);
                 }
             });
         }
-        catch (error) {
-            throw new Error("Uncaught error as creating websocket semantic.");
-        }
-    });
+        let keys = ["open", "message", "close", "error"];
+        return new Semantic((accept, interrupt) => {
+            try {
+                for (let key of keys) {
+                    let listener = (event) => {
+                        if (interrupt(event, 0n)) {
+                            websocket.removeEventListener(key, listener);
+                        }
+                        else {
+                            accept(event, 0n);
+                        }
+                    };
+                    websocket.addEventListener(key, listener);
+                }
+            }
+            catch (error) {
+                console.error(error);
+            }
+        });
+    }
+    throw new TypeError("Invalid arguments.");
+};
+;
+export let useWindow = (argument1) => {
+    if (isString(argument1)) {
+        let key = argument1;
+        return new Semantic((accept, interrupt) => {
+            try {
+                let listener = (event) => {
+                    if (interrupt(event, 0n)) {
+                        window.removeEventListener(key, listener);
+                    }
+                    else {
+                        console.log(event.type, event);
+                        accept(event, 0n);
+                    }
+                };
+                window.addEventListener(key, listener);
+            }
+            catch (error) {
+                console.error(error);
+            }
+        });
+    }
+    else if (isIterable(argument1)) {
+        let keys = new Set(argument1);
+        return new Semantic((accept, interrupt) => {
+            try {
+                let index = 0n;
+                for (let key of keys) {
+                    if (isString(key)) {
+                        let listener = function (event) {
+                            if (interrupt(event, index)) {
+                                console.log("Terminal", performance.now());
+                                window.removeEventListener(key, listener);
+                            }
+                            else {
+                                console.log("accept", performance.now());
+                                accept(event, index);
+                            }
+                        };
+                        index++;
+                        window.addEventListener(key, listener);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(error);
+            }
+        });
+    }
+    throw new TypeError("Invalid arguments.");
 };
+export let useNullable = (target) => Optional.ofNullable(target);
+export let useNonNull = (target) => Optional.ofNonNull(target);

package/dist/guard.d.ts

@@ -1,12 +1,8 @@
-import type { Collectable, OrderedCollectable, UnorderedCollectable } from "./collectable";
+import type { Collectable, OrderedCollectable, Statistics, UnorderedCollectable, WindowCollectable } from "./semantic";
 import type { Collector } from "./collector";
-import type { Hashable } from "./hash";
-import type { HashMap, SemanticMap } from "./map";
+import type { Optional } from "./optional";
 import type { Semantic } from "./semantic";
-import type { HashSet } from "./set";
-import type { Statistics } from "./statistics";
 import type { AsyncFunction, MaybePrimitive, Primitive } from "./utility";
-import type { WindowCollectable } from "./window";
 export declare let isBoolean: (target: unknown) => target is boolean;
 export declare let isString: (target: unknown) => target is string;
 export declare let isNumber: (target: unknown) => target is number;
@@ -26,11 +22,11 @@ export declare let isUnorderedCollectable: (target: unknown) => target is Unorde
 export declare let isStatistics: (target: unknown) => target is Statistics<unknown, number | bigint>;
 export declare let isNumericStatistics: (target: unknown) => target is Statistics<unknown, number | bigint>;
 export declare let isBigIntStatistics: (target: unknown) => target is Statistics<unknown, number | bigint>;
-export declare let isSemanticMap: (target: unknown) => target is SemanticMap<unknown, unknown>;
-export declare let isHashable: (target: unknown) => target is Hashable;
-export declare let isHashMap: (target: unknown) => target is HashMap<unknown, unknown>;
-export declare let isHashSet: (target: unknown) => target is HashSet<unknown>;
+export declare let isOptional: <T>(target: unknown) => target is Optional<T>;
 export declare let isPromise: (target: unknown) => target is Promise<unknown>;
 export declare let isAsyncFunction: (target: unknown) => target is AsyncFunction;
 export declare let isGeneratorFunction: (target: unknown) => target is Generator<unknown, unknown, unknown>;
 export declare let isAsyncGeneratorFunction: (target: unknown) => target is AsyncGenerator<unknown, unknown, unknown>;
+export declare let isWindow: (target: unknown) => target is Window;
+export declare let isDocument: (target: unknown) => target is Document;
+export declare let isHTMLElemet: (target: unknown) => target is HTMLElement;