semantic-typescript 0.2.6 → 0.2.7

package/dist/factory.d.ts

@@ -1,12 +1,13 @@
 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>>;
 export declare let blob: Functional<Blob, Semantic<Uint8Array>> & BiFunctional<Blob, bigint, Semantic<Uint8Array>>;
 export declare let empty: <E>() => Semantic<E>;
-export declare let event: BiFunctional<HTMLElement, Array<keyof HTMLElementEventMap>, Semantic<Event>>;
 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>>;
 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>>;
 export declare let websocket: Functional<WebSocket, Semantic<MessageEvent | CloseEvent | Event>>;

package/dist/factory.js

@@ -1,7 +1,30 @@
-import { isBigInt, isFunction, isIterable, isNumber } from "./guard";
+import { isBigInt, isFunction, isIterable, isNumber, isPromise } from "./guard";
 import { useCompare } 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;
+                }
+                accept(performance.now(), index);
+            }
+        };
+    });
+};
 export let blob = (blob, chunk = 64n * 1024n) => {
     let size = Number(chunk);
     if (size <= 0 || !Number.isSafeInteger(size)) {
@@ -20,10 +43,10 @@ export let blob = (blob, chunk = 64n * 1024n) => {
         (async () => {
             try {
                 while (!stoppable) {
-                    const { done, value } = await reader.read();
+                    let { done, value } = await reader.read();
                     if (done) {
                         if (offset > 0) {
-                            const element = buffer.subarray(0, offset);
+                            let element = buffer.subarray(0, offset);
                             if (interrupt(element, index)) {
                                 stoppable = true;
                             }
@@ -37,8 +60,8 @@ export let blob = (blob, chunk = 64n * 1024n) => {
                     let chunkData = value;
                     let position = 0;
                     while (position < chunkData.length && !stoppable) {
-                        const space = size - offset;
-                        const toCopy = Math.min(space, chunkData.length - position);
+                        let space = size - offset;
+                        let toCopy = Math.min(space, chunkData.length - position);
                         buffer.set(chunkData.subarray(position, position + toCopy), offset);
                         offset += toCopy;
                         position += toCopy;
@@ -56,7 +79,7 @@ export let blob = (blob, chunk = 64n * 1024n) => {
                 }
             }
             catch (error) {
-                // Handle error
+                console.error(error);
             }
             finally {
                 if (stoppable) {
@@ -70,26 +93,6 @@ export let blob = (blob, chunk = 64n * 1024n) => {
 export let empty = () => {
     return new Semantic(() => { });
 };
-export let event = (element, events) => {
-    if (validate(element) && isIterable(events)) {
-        return new Semantic((accept, interrupt) => {
-            let index = 0n;
-            let stop = false;
-            for (let name of events) {
-                if (!stop) {
-                    element.addEventListener(name, (event) => {
-                        if (interrupt(event, index)) {
-                            stop = true;
-                        }
-                        accept(event, index);
-                        index++;
-                    });
-                }
-            }
-        });
-    }
-    throw new TypeError("Invalid arguments.");
-};
 export let fill = (element, count) => {
     if (validate(element) && count > 0n) {
         return new Semantic((accept, interrupt) => {
@@ -174,6 +177,23 @@ export let iterate = (generator) => {
     }
     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);
+            });
+        });
+    }
+    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.");

package/dist/guard.d.ts

@@ -2,7 +2,7 @@ import type { Collectable, OrderedCollectable, UnorderedCollectable } from "./co
 import type { Collector } from "./collector";
 import type { Semantic } from "./semantic";
 import type { Statistics } from "./statistics";
-import type { MaybePrimitive, Primitive } from "./utility";
+import type { AsyncFunction, MaybePrimitive, Primitive } from "./utility";
 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;
@@ -21,3 +21,5 @@ export declare let isUnorderedCollectable: (t: unknown) => t is UnorderedCollect
 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;

package/dist/guard.js

@@ -83,3 +83,15 @@ export let isBigIntStatistics = (t) => {
     }
     return false;
 };
+export let isPromise = (t) => {
+    if (isObject(t)) {
+        return isFunction(Reflect.get(t, "then")) && isFunction(Reflect.get(t, "catch"));
+    }
+    return false;
+};
+export let isAsync = (t) => {
+    if (isFunction(t)) {
+        return Reflect.get(t, Symbol.toStringTag) === "AsyncFunction" && t.constructor.name === "AsyncFunction";
+    }
+    return false;
+};

package/dist/index.d.ts

@@ -1,10 +1,10 @@
+export * from "./collectable";
+export * from "./collector";
 export * from "./factory";
-export * from "./utility";
-export * from "./symbol";
+export * from "./guard";
 export * from "./hook";
 export * from "./optional";
 export * from "./semantic";
-export * from "./collectable";
+export * from "./symbol";
 export * from "./statistics";
-export * from "./collector";
-export * from "./guard";
+export * from "./utility";

package/dist/index.js

@@ -1,10 +1,10 @@
+export * from "./collectable";
+export * from "./collector";
 export * from "./factory";
-export * from "./utility";
-export * from "./symbol";
+export * from "./guard";
 export * from "./hook";
 export * from "./optional";
 export * from "./semantic";
-export * from "./collectable";
+export * from "./symbol";
 export * from "./statistics";
-export * from "./collector";
-export * from "./guard";
+export * from "./utility";

package/dist/semantic.d.ts

@@ -34,7 +34,7 @@ export declare class Semantic<E> {
     toBigintStatistics(): BigIntStatistics<E>;
     toNumericStatistics(): NumericStatistics<E>;
     toOrdered(): OrderedCollectable<E>;
-    toUnoredered(): UnorderedCollectable<E>;
+    toUnordered(): UnorderedCollectable<E>;
     toWindow(): WindowCollectable<E>;
     translate(offset: number): Semantic<E>;
     translate(offset: bigint): Semantic<E>;

package/dist/semantic.js

@@ -302,7 +302,7 @@ export class Semantic {
     toOrdered() {
         return new OrderedCollectable(this.generator);
     }
-    toUnoredered() {
+    toUnordered() {
         return new UnorderedCollectable(this.generator);
     }
     toWindow() {

package/dist/utility.d.ts

@@ -5,6 +5,7 @@ export declare let validate: <T>(t: MaybeInvalid<T>) => t is T;
 export declare let invalidate: <T>(t: MaybeInvalid<T>) => t is (null | undefined);
 export type Primitive = string | number | boolean | symbol | bigint | Function | ((...args: any[]) => any);
 export type MaybePrimitive<T> = T | Primitive;
+export type AsyncFunction = (...args: any[]) => Promise<unknown>;
 export interface Runnable {
     (): void;
 }

package/package.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/eloyhere"
   },
   "description": "A modern type-safe stream processing library inspired by JavaScript Generator, Java Stream, and MySQL Index. Supports lazy evaluation, async streams, statistics, and IO-like operations.",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "type": "module",
   "readme": "readme.md",
   "main": "dist/index.js",