semantic-typescript 0.2.5 → 0.2.6

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

@@ -2,6 +2,7 @@ import { Semantic } from "./semantic";
 import type { BiFunctional, BiPredicate, Functional, Predicate, Supplier, TriFunctional, Generator } from "./utility";
 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>);

package/dist/factory.js

@@ -4,8 +4,8 @@ import { Semantic } from "./semantic";
 import { invalidate, validate } from "./utility";
 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 +17,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) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        if (offset > 0) {
+                            const 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) {
+                        const space = size - offset;
+                        const 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,44 +49,47 @@ 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) {
+                // Handle error
+            }
+            finally {
+                if (stoppable) {
+                    await reader.cancel();
                 }
-            }).catch((error) => {
                 reader.releaseLock();
-                throw error;
-            });
-        };
-        read(reader).catch(() => {
-            reader.releaseLock();
-        });
+            }
+        })();
     });
 };
 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) => {

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,8 +31,8 @@ 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>;
     toWindow(): WindowCollectable<E>;

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.6",
   "type": "module",
   "readme": "readme.md",
   "main": "dist/index.js",