semantic-typescript 0.2.5 → 0.2.7

package/dist/collectable.js

@@ -13,8 +13,8 @@ export class Collectable {
     anyMatch(predicate) {
         return this.collect(() => {
             return false;
-        }, (element) => {
-            return predicate(element);
+        }, (_element, _index, accumulator) => {
+            return accumulator;
         }, (result, element) => {
             return result || predicate(element);
         }, (result) => {
@@ -24,8 +24,8 @@ export class Collectable {
     allMatch(predicate) {
         return this.collect(() => {
             return true;
-        }, (element) => {
-            return !predicate(element);
+        }, (_element, _index, accumulator) => {
+            return !accumulator;
         }, (result, element) => {
             return result && predicate(element);
         }, (result) => {
@@ -69,20 +69,23 @@ export class Collectable {
     }
     findAny() {
         return this.collect(() => {
-            return Optional.ofNullable();
-        }, () => {
-            return true;
+            return Optional.empty();
+        }, (_element, _index, accumulator) => {
+            return accumulator.isPresent();
         }, (result, element) => {
-            return result.isPresent() && Math.random() > 0.5 ? result : Optional.of(element);
+            if (Math.random() < 0.5) {
+                return Optional.of(element);
+            }
+            return result;
         }, (result) => {
             return result;
         });
     }
     findFirst() {
         return this.collect(() => {
-            return Optional.ofNullable();
-        }, () => {
-            return true;
+            return Optional.empty();
+        }, (_element, _index, accumulator) => {
+            return accumulator.isPresent();
         }, (result, element) => {
             return result.isPresent() ? result : Optional.of(element);
         }, (result) => {
@@ -91,9 +94,9 @@ export class Collectable {
     }
     findLast() {
         return this.collect(() => {
-            return Optional.ofNullable();
+            return Optional.empty();
         }, () => {
-            return true;
+            return false;
         }, (result, element) => {
             return result.isPresent() ? result : Optional.of(element);
         }, (result) => {
@@ -206,10 +209,10 @@ export class Collectable {
     nonMatch(predicate) {
         return this.collect(() => {
             return true;
-        }, (element) => {
-            return predicate(element);
+        }, (_element, _index, accumulator) => {
+            return !accumulator;
         }, (result, element) => {
-            return result || predicate(element);
+            return result || !predicate(element);
         }, (result) => {
             return result;
         });

package/dist/collector.d.ts

@@ -13,6 +13,8 @@ export declare class Collector<E, A, R> {
     collect(generator: Generator<E>): R;
     collect(iterable: Iterable<E>): R;
     collect(semantic: Semantic<E>): R;
+    collect(start: number, end: number): R;
+    collect(start: bigint, end: bigint): R;
     static full<E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
     static full<E, A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
     static shortable<E, A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;

package/dist/collector.js

@@ -1,4 +1,4 @@
-import { isFunction, isIterable, isSemantic } from "./guard";
+import { isBigInt, isFunction, isIterable, isNumber, isSemantic } from "./guard";
 import { CollectableSymbol } from "./symbol";
 export class Collector {
     identity;
@@ -17,17 +17,18 @@ export class Collector {
             throw new TypeError("Invalid arguments");
         }
     }
-    collect(parameter) {
+    collect(argument1, argument2) {
         let accumulator = this.identity();
         let count = 0n;
-        if (isFunction(parameter)) {
-            parameter((element, index) => {
+        if (isFunction(argument1)) {
+            let generator = argument1;
+            generator((element, index) => {
                 accumulator = this.accumulator(accumulator, element, index);
                 count++;
             }, (element, index) => this.interrupt(element, index, accumulator));
         }
-        else if (isIterable(parameter)) {
-            let iterable = parameter;
+        else if (isIterable(argument1)) {
+            let iterable = argument1;
             let index = 0n;
             for (let element of iterable) {
                 if (this.interrupt(element, index, accumulator)) {
@@ -38,8 +39,8 @@ export class Collector {
                 index++;
             }
         }
-        else if (isSemantic(parameter)) {
-            let semantic = parameter;
+        else if (isSemantic(argument1)) {
+            let semantic = argument1;
             let generator = Reflect.get(semantic, "generator");
             if (isFunction(generator)) {
                 generator((element, index) => {
@@ -51,6 +52,28 @@ export class Collector {
                 throw new TypeError("Invalid arguments");
             }
         }
+        else if (isNumber(argument1) && isNumber(argument2)) {
+            let start = argument1 < argument2 ? argument1 : argument2;
+            let end = argument1 > argument2 ? argument1 : argument2;
+            for (let i = start; i < end; i++) {
+                if (this.interrupt(i, count, accumulator)) {
+                    break;
+                }
+                accumulator = this.accumulator(accumulator, i, count);
+                count++;
+            }
+        }
+        else if (isBigInt(argument1) && isBigInt(argument2)) {
+            let start = argument1 < argument2 ? argument1 : argument2;
+            let end = argument1 > argument2 ? argument1 : argument2;
+            for (let i = start; i < end; i++) {
+                if (this.interrupt(i, count, accumulator)) {
+                    break;
+                }
+                accumulator = this.accumulator(accumulator, i, count);
+                count++;
+            }
+        }
         return this.finisher(accumulator);
     }
     static full(identity, accumulator, finisher) {

package/dist/factory.d.ts

@@ -1,5 +1,6 @@
 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 fill: (<E>(element: E, count: bigint) => Semantic<E>) & (<E>(supplier: Supplier<E>, count: bigint) => Semantic<E>);
@@ -7,5 +8,6 @@ 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,11 +1,34 @@
-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) {
-        throw new RangeError("Chunk size must be positive.");
+    if (size <= 0 || !Number.isSafeInteger(size)) {
+        throw new RangeError("Chunk size must be a safe positive integer.");
     }
     if (invalidate(blob)) {
         throw new TypeError("Blob is invalid.");
@@ -17,42 +40,31 @@ export let blob = (blob, chunk = 64n * 1024n) => {
         let reader = stream.getReader();
         let buffer = new Uint8Array(size);
         let offset = 0;
-        let read = async (reader) => {
-            if (stoppable) {
-                return reader.cancel().finally(() => reader.releaseLock());
-            }
-            return reader.read().then((result) => {
-                if (result.done) {
-                    if (offset > 0) {
-                        const element = buffer.subarray(0, offset);
-                        if (interrupt(element, index)) {
-                            stoppable = true;
-                        }
-                        else {
-                            accept(element, index);
-                            index++;
+        (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;
                     }
-                    reader.releaseLock();
-                    return;
-                }
-                let chunkData = result.value;
-                let length = chunkData.length;
-                let remaining = size - offset;
-                if (length > remaining) {
-                    buffer.set(chunkData.subarray(0, remaining), offset);
-                    if (interrupt(buffer, index)) {
-                        stoppable = true;
-                    }
-                    else {
-                        accept(buffer, index);
-                        index++;
-                    }
-                    offset = 0;
-                    const leftover = chunkData.subarray(remaining);
-                    if (leftover.length > 0) {
-                        buffer.set(leftover, offset);
-                        offset += leftover.length;
+                    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;
@@ -60,39 +72,22 @@ export let blob = (blob, chunk = 64n * 1024n) => {
                             else {
                                 accept(buffer, index);
                                 index++;
-                                offset = 0;
                             }
-                        }
-                    }
-                }
-                else {
-                    buffer.set(chunkData, offset);
-                    offset += length;
-                    if (offset === size) {
-                        if (interrupt(buffer, index)) {
-                            stoppable = true;
-                        }
-                        else {
-                            accept(buffer, index);
-                            index++;
                             offset = 0;
                         }
                     }
                 }
-                if (!stoppable) {
-                    return read(reader);
-                }
-                else {
-                    return reader.cancel().finally(() => reader.releaseLock());
+            }
+            catch (error) {
+                console.error(error);
+            }
+            finally {
+                if (stoppable) {
+                    await reader.cancel();
                 }
-            }).catch((error) => {
                 reader.releaseLock();
-                throw error;
-            });
-        };
-        read(reader).catch(() => {
-            reader.releaseLock();
-        });
+            }
+        })();
     });
 };
 export let empty = () => {
@@ -182,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

@@ -1,5 +1,5 @@
 import { Collectable, OrderedCollectable, UnorderedCollectable, WindowCollectable } from "./collectable";
-import { type Statistics } from "./statistics";
+import { BigIntStatistics, NumericStatistics } from "./statistics";
 import { type Predicate } from "./utility";
 import type { Generator, Functional, BiFunctional, Consumer, BiConsumer, Comparator } from "./utility";
 export declare class Semantic<E> {
@@ -31,10 +31,10 @@ export declare class Semantic<E> {
     takeWhile(predicate: Predicate<E>): Semantic<E>;
     toCollectable(): Collectable<E>;
     toCollectable<C extends Collectable<E>>(mapper: Functional<Generator<E>, C>): C;
-    toBigintStatistics(): Statistics<E, bigint>;
-    toNumericStatistics(): Statistics<E, number>;
+    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.5",
+  "version": "0.2.7",
   "type": "module",
   "readme": "readme.md",
   "main": "dist/index.js",