semantic-typescript 0.3.0 → 0.3.7

package/dist/factory.js

@@ -1,5 +1,5 @@
-import { isBigInt, isFunction, isIterable, isNumber, isPromise } from "./guard";
-import { useCompare } from "./hook";
+import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise } from "./guard";
+import { useCompare, useTraverse } from "./hook";
 import { Semantic } from "./semantic";
 import { invalidate, validate } from "./utility";
 export let animationFrame = (period, delay = 0) => {
@@ -7,24 +7,55 @@ 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) => {
+            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)) {
@@ -34,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;
-                            }
-                            else {
-                                accept(buffer, index);
-                                index++;
+                        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;
                             }
-                            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 = () => {
@@ -96,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.");
             }
         });
     }
@@ -110,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.");
             }
         });
     }
@@ -125,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.");
             }
         });
     }
@@ -141,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(() => {
@@ -153,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.");
             }
         });
     }
@@ -173,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 {
@@ -202,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.");
             }
         });
     }
@@ -218,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 BiConsumer, type DeepPropertyKey, type DeepPropertyValue } from "./utility";
+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: BiConsumer<DeepPropertyKey<T>, DeepPropertyValue<T>>) => void;
+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)) {
@@ -69,26 +70,38 @@ export let useTraverse = (t, callback) => {
         let traverse = (target) => {
             if (!seen.has(target)) {
                 seen.add(target);
+                let stop = false;
                 let properties = Reflect.ownKeys(target);
                 for (let property of properties) {
-                    let value = target[property];
+                    let value = Reflect.get(target, property);
+                    if (stop) {
+                        break;
+                    }
                     if (validate(value)) {
                         if (isObject(value)) {
                             if (isIterable(value)) {
+                                let index = 0;
                                 for (let item of value) {
                                     if (validate(item)) {
                                         if (isObject(item)) {
                                             traverse(item);
                                         }
                                         else {
-                                            callback(property, item);
+                                            if (!callback(index, item)) {
+                                                stop = true;
+                                                break;
+                                            }
                                         }
                                     }
+                                    index++;
                                 }
                             }
                         }
                         else {
-                            callback(property, value);
+                            if (!callback(property, value)) {
+                                stop = true;
+                                break;
+                            }
                         }
                     }
                 }
@@ -97,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";