semantic-typescript 0.3.8 → 0.5.0

package/dist/factory.d.ts

@@ -1,49 +1,37 @@
 import { Semantic } from "./semantic";
-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;
+import type { BiFunctional, BiPredicate, Functional, Predicate, Supplier, TriFunctional, Generator } from "./utility";
+export declare let animationFrame: Functional<number, Semantic<number>> & BiFunctional<number, number, Semantic<number>>;
 interface Attribute<T> {
     key: keyof T;
     value: T[keyof T];
 }
 export declare let attribute: <T extends object>(target: T) => Semantic<Attribute<T>>;
-interface BlobFunction {
-    (blob: Blob): Semantic<Uint8Array>;
-    (blob: Blob, chunk: bigint): Semantic<Uint8Array>;
-}
-export declare let blob: BlobFunction;
+export declare let blob: Functional<Blob, Semantic<Uint8Array>> & BiFunctional<Blob, bigint, Semantic<Uint8Array>>;
 export declare let empty: <E>() => Semantic<E>;
-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 {
+type KeyOfEventMap<T extends Window | Document | HTMLElement> = T extends Window ? keyof WindowEventMap : (T extends Document ? keyof DocumentEventMap : (T extends HTMLElement ? keyof HTMLElementEventMap : never));
+type ValueOfEventMap<T extends Window | Document | HTMLElement, K extends KeyOfEventMap<T>> = T extends Window ? (K extends keyof WindowEventMap ? WindowEventMap[K] : never) : (T extends Document ? (K extends keyof DocumentEventMap ? DocumentEventMap[K] : never) : (T extends HTMLElement ? (K extends keyof HTMLElementEventMap ? HTMLElementEventMap[K] : never) : never));
+interface EventFunction {
+    <E extends Window, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: K): Semantic<V>;
+    <E extends Window, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: Iterable<K>): Semantic<V>;
+    <E extends Document, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: K): Semantic<V>;
+    <E extends Document, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: Iterable<K>): Semantic<V>;
+    <E extends Document, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: Iterable<K>): Semantic<V>;
+    <E extends HTMLElement, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: K): Semantic<V>;
+    <E extends HTMLElement, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: Iterable<K>): Semantic<V>;
+    <E extends HTMLElement, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: Iterable<E>, key: K): Semantic<V>;
+    <E extends HTMLElement, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: Iterable<E>, key: Iterable<K>): Semantic<V>;
+}
+export declare let event: EventFunction;
+export declare let fill: (<E>(element: E, count: bigint) => Semantic<E>) & (<E>(supplier: Supplier<E>, count: bigint) => Semantic<E>);
+export interface From {
     <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 from: From;
+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>>;
 export declare let iterate: <E>(generator: Generator<E>) => Semantic<E>;
 export declare let promise: (<T>(promise: Promise<T>) => Semantic<T>);
-interface RangeFunction {
-    (start: number, end: number): Semantic<number>;
-    (start: number, end: number, step: number): Semantic<number>;
-}
-export declare let range: RangeFunction;
+export declare let range: BiFunctional<number, number, Semantic<number>> & TriFunctional<number, number, number, Semantic<number>>;
 export declare let websocket: Functional<WebSocket, Semantic<MessageEvent | CloseEvent | Event>>;
 export {};

package/dist/factory.js

@@ -1,8 +1,7 @@
-import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise, isAsyncIterable } from "./guard";
+import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise, isAsyncIterable, isWindow, isString, isDocument } 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.");
@@ -57,7 +56,6 @@ export let attribute = (target) => {
     }
     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)) {
@@ -132,6 +130,163 @@ export let empty = () => {
     return new Semantic(() => { });
 };
 ;
+export let event = (argument1, argument2) => {
+    if (isWindow(argument1)) {
+        let target = argument1;
+        if (isString(argument2)) {
+            let key = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    let listener = (event) => {
+                        if (interrupt(event, index)) {
+                            target.removeEventListener(key, listener);
+                        }
+                        else {
+                            accept(event, index);
+                            index++;
+                        }
+                    };
+                    target.addEventListener(key, listener);
+                }
+                catch (error) {
+                    throw new Error("Uncaught error as creating event semantic.");
+                }
+            });
+        }
+        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)) {
+                                    target.removeEventListener(key, listener);
+                                }
+                                else {
+                                    accept(event, index);
+                                    index++;
+                                }
+                            };
+                            target.addEventListener(key, listener);
+                        }
+                    }
+                }
+                catch (error) {
+                    throw new Error("Uncaught error as creating event semantic.");
+                }
+            });
+        }
+    }
+    if (isDocument(argument1)) {
+        let target = argument1;
+        if (isString(argument2)) {
+            let key = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    let listener = (event) => {
+                        if (interrupt(event, index)) {
+                            target.removeEventListener(key, listener);
+                        }
+                        else {
+                            accept(event, index);
+                            index++;
+                        }
+                    };
+                    target.addEventListener(key, listener);
+                }
+                catch (error) {
+                    throw new Error("Uncaught error as creating event semantic.");
+                }
+            });
+        }
+        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)) {
+                                    target.removeEventListener(key, listener);
+                                }
+                                else {
+                                    accept(event, index);
+                                    index++;
+                                }
+                            };
+                            target.addEventListener(key, listener);
+                        }
+                    }
+                }
+                catch (error) {
+                    throw new Error("Uncaught error as creating event semantic.");
+                }
+            });
+        }
+    }
+    if (isIterable(argument1)) {
+        let targets = argument1;
+        if (isString(argument2)) {
+            let key = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    for (let target of targets) {
+                        if (isObject(target) && isFunction(Reflect.get(target, "addEventListener"))) {
+                            let listener = (event) => {
+                                if (interrupt(event, index)) {
+                                    target.removeEventListener(key, listener);
+                                }
+                                else {
+                                    accept(event, index);
+                                }
+                            };
+                            target.addEventListener(key, listener);
+                        }
+                    }
+                }
+                catch (error) {
+                    throw new Error("Uncaught error as creating event semantic.");
+                }
+            });
+        }
+        if (isIterable(argument2)) {
+            let keys = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    for (let target of targets) {
+                        if (isObject(target) && isFunction(Reflect.get(target, "addEventListener"))) {
+                            for (let key of keys) {
+                                if (isString(key)) {
+                                    let listener = (event) => {
+                                        if (interrupt(event, index)) {
+                                            target.removeEventListener(key, listener);
+                                        }
+                                        else {
+                                            accept(event, index);
+                                            index++;
+                                        }
+                                    };
+                                    target.addEventListener(key, listener);
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    throw new Error("Uncaught error as creating event semantic.");
+                }
+            });
+        }
+    }
+    throw new TypeError("Invalid arguments.");
+};
 export let fill = (element, count) => {
     if (validate(element) && count > 0n) {
         return new Semantic((accept, interrupt) => {
@@ -189,72 +344,13 @@ export let from = (iterable) => {
     }
     throw new TypeError("Invalid arguments");
 };
-;
-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;
+export let generate = (supplier, interrupt) => {
+    if (isFunction(supplier) && isFunction(interrupt)) {
         return new Semantic((accept, interrupt) => {
             try {
                 let index = 0n;
                 while (true) {
-                    if (interrupt(element, index) || shutdown(element, index)) {
-                        break;
-                    }
-                    accept(element, 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) {
+                    let element = supplier();
                     if (interrupt(element, index)) {
                         break;
                     }
@@ -267,9 +363,8 @@ export let generate = (argument1, argument2) => {
             }
         });
     }
-    throw new TypeError("Invalid arguments.");
+    throw new TypeError("Invalid arguments");
 };
-;
 export let interval = (period, delay = 0) => {
     if (period > 0 && delay >= 0) {
         return new Semantic((accept, interrupt) => {
@@ -341,7 +436,6 @@ 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.");

package/dist/guard.d.ts

@@ -1,30 +1,45 @@
-import type { Collectable, OrderedCollectable, UnorderedCollectable } from "./collectable";
+import type { Collectable, OrderedCollectable, Statistics, UnorderedCollectable, WindowCollectable } from "./collectable";
 import type { Collector } from "./collector";
+import type { HashMap, SemanticMap } from "./map";
+import type { BinaryNode, LinearNode, Node } from "./node";
+import type { Optional } from "./optional";
 import type { Semantic } from "./semantic";
-import type { Statistics } from "./statistics";
-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;
-export declare let isFunction: (t: unknown) => t is Function;
-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 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 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>;
+import type { HashSet } from "./set";
+import type { AsyncFunction, MaybePrimitive, Primitive } from "./utility";
+export declare let isBoolean: (target: unknown) => target is boolean;
+export declare let isString: (target: unknown) => target is string;
+export declare let isNumber: (target: unknown) => target is number;
+export declare let isFunction: (target: unknown) => target is Function;
+export declare let isObject: (target: unknown) => target is object;
+export declare let isSymbol: (target: unknown) => target is symbol;
+export declare let isBigInt: (target: unknown) => target is bigint;
+export declare let isPrimitive: (target: MaybePrimitive<unknown>) => target is Primitive;
+export declare let isAsyncIterable: (target: unknown) => target is Iterable<unknown>;
+export declare let isIterable: (target: unknown) => target is Iterable<unknown>;
+export declare let isSemantic: (target: unknown) => target is Semantic<unknown>;
+export declare let isCollector: (target: unknown) => target is Collector<unknown, unknown, unknown>;
+export declare let isCollectable: (target: unknown) => target is Collectable<unknown>;
+export declare let isOrderedCollectable: (target: unknown) => target is OrderedCollectable<unknown>;
+export declare let isWindowCollectable: (target: unknown) => target is WindowCollectable<unknown>;
+export declare let isUnorderedCollectable: (target: unknown) => target is UnorderedCollectable<unknown>;
+export declare let isStatistics: (target: unknown) => target is Statistics<unknown, number | bigint>;
+export declare let isNumericStatistics: (target: unknown) => target is Statistics<unknown, number | bigint>;
+export declare let isBigIntStatistics: (target: unknown) => target is Statistics<unknown, number | bigint>;
+export declare let isSemanticMap: (target: unknown) => target is SemanticMap<unknown, unknown>;
+export declare let isHashMap: (target: unknown) => target is HashMap<unknown, unknown>;
+export declare let isHashSet: (target: unknown) => target is HashSet<unknown>;
+export declare let isNode: (target: unknown) => target is Node<unknown, any>;
+export declare let isLinearNode: (target: unknown) => target is LinearNode<unknown>;
+export declare let isBinaryNode: (target: unknown) => target is BinaryNode<unknown, any>;
+export declare let isRedBlackNode: (target: unknown) => target is BinaryNode<unknown, any>;
+export declare let isTree: (target: unknown) => target is Node<unknown, any>;
+export declare let isBinaryTree: (target: unknown) => target is Node<unknown, any>;
+export declare let isRedBlackTree: (target: unknown) => target is Node<unknown, any>;
+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;