@naturalcycles/js-lib 14.74.0 → 14.75.0

package/dist/seq/seq.d.ts

@@ -1,4 +1,4 @@
-import { AbortableMapper, AbortablePredicate, END } from '../types';
+import { AbortableAsyncMapper, AbortableAsyncPredicate, AbortableMapper, AbortablePredicate, END } from '../types';
 /**
  * Inspired by Kotlin Sequences.
  * Similar to arrays, but with lazy evaluation, abortable.
@@ -7,14 +7,14 @@ import { AbortableMapper, AbortablePredicate, END } from '../types';
  *
  * @experimental
  */
-export declare class Seq<T> implements Iterable<T> {
+export declare class Sequence<T> implements Iterable<T> {
     private nextFn;
     private constructor();
     [Symbol.iterator](): Iterator<T>;
-    static create<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Seq<T>;
-    static range(minIncl: number, maxExcl: number, step?: number): Seq<number>;
-    static from<T>(a: Iterable<T>): Seq<T>;
-    static empty<T = any>(): Seq<T>;
+    static create<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Sequence<T>;
+    static range(minIncl: number, maxExcl: number, step?: number): Sequence<number>;
+    static from<T>(a: Iterable<T>): Sequence<T>;
+    static empty<T = any>(): Sequence<T>;
     private currentValue;
     private sentInitialValue;
     private i;
@@ -27,4 +27,26 @@ export declare class Seq<T> implements Iterable<T> {
 /**
  * Convenience function to create a Sequence.
  */
-export declare function _seq<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Seq<T>;
+export declare function _seq<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Sequence<T>;
+/**
+ * Experimental.
+ * Feasibility to be proven.
+ *
+ * @experimental
+ */
+export declare class AsyncSequence<T> implements AsyncIterable<T> {
+    private nextFn;
+    private constructor();
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    static create<T>(initialValue: T | typeof END, nextFn: AbortableAsyncMapper<T, T>): AsyncSequence<T>;
+    static from<T>(a: AsyncIterable<T>): Promise<AsyncSequence<T>>;
+    static empty<T = any>(): AsyncSequence<T>;
+    private currentValue;
+    private sentInitialValue;
+    private i;
+    next(): Promise<T | typeof END>;
+    find(predicate: AbortableAsyncPredicate<T>): Promise<T | undefined>;
+    some(predicate: AbortableAsyncPredicate<T>): Promise<boolean>;
+    every(predicate: AbortableAsyncPredicate<T>): Promise<boolean>;
+    toArray(): Promise<T[]>;
+}

package/dist/seq/seq.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._seq = exports.Seq = void 0;
+exports.AsyncSequence = exports._seq = exports.Sequence = void 0;
 const types_1 = require("../types");
 /**
  * Inspired by Kotlin Sequences.
@@ -10,7 +10,7 @@ const types_1 = require("../types");
  *
  * @experimental
  */
-class Seq {
+class Sequence {
     constructor(initialValue, nextFn) {
         this.nextFn = nextFn;
         this.sentInitialValue = false;
@@ -26,18 +26,18 @@ class Seq {
         };
     }
     static create(initialValue, nextFn) {
-        return new Seq(initialValue, nextFn);
+        return new Sequence(initialValue, nextFn);
     }
     static range(minIncl, maxExcl, step = 1) {
         const max = maxExcl - step;
-        return new Seq(minIncl, n => (n < max ? n + step : types_1.END));
+        return new Sequence(minIncl, n => (n < max ? n + step : types_1.END));
     }
     static from(a) {
         const it = a[Symbol.iterator]();
         const v = it.next();
         if (v.done)
-            return new Seq(types_1.END, () => { });
-        return new Seq(v.value, () => {
+            return new Sequence(types_1.END, () => { });
+        return new Sequence(v.value, () => {
             const v = it.next();
             if (v.done)
                 return types_1.END;
@@ -45,7 +45,7 @@ class Seq {
         });
     }
     static empty() {
-        return new Seq(types_1.END, () => { });
+        return new Sequence(types_1.END, () => { });
     }
     next() {
         if (this.currentValue === types_1.END)
@@ -131,11 +131,118 @@ class Seq {
         }
     }
 }
-exports.Seq = Seq;
+exports.Sequence = Sequence;
 /**
  * Convenience function to create a Sequence.
  */
 function _seq(initialValue, nextFn) {
-    return Seq.create(initialValue, nextFn);
+    return Sequence.create(initialValue, nextFn);
 }
 exports._seq = _seq;
+/* eslint-disable no-await-in-loop */
+/**
+ * Experimental.
+ * Feasibility to be proven.
+ *
+ * @experimental
+ */
+class AsyncSequence {
+    constructor(initialValue, nextFn) {
+        this.nextFn = nextFn;
+        this.sentInitialValue = false;
+        this.i = -1;
+        this.currentValue = initialValue;
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => {
+                const value = await this.next();
+                return value === types_1.END ? { done: true, value: undefined } : { value };
+            },
+        };
+    }
+    static create(initialValue, nextFn) {
+        return new AsyncSequence(initialValue, nextFn);
+    }
+    static async from(a) {
+        const it = a[Symbol.asyncIterator]();
+        const v = await it.next();
+        if (v.done)
+            return new AsyncSequence(types_1.END, () => { });
+        return new AsyncSequence(v.value, async () => {
+            const v = await it.next();
+            if (v.done)
+                return types_1.END;
+            return v.value;
+        });
+    }
+    static empty() {
+        return new AsyncSequence(types_1.END, () => { });
+    }
+    async next() {
+        if (this.currentValue === types_1.END)
+            return types_1.END;
+        this.i++;
+        let v;
+        if (!this.sentInitialValue) {
+            this.sentInitialValue = true;
+            v = this.currentValue;
+        }
+        else {
+            v = await this.nextFn(this.currentValue, this.i);
+        }
+        // console.log(`_seq`, v)
+        if (v === types_1.SKIP)
+            return await this.next();
+        return (this.currentValue = v);
+    }
+    // Final functions - return final value, not a chained sequence
+    async find(predicate) {
+        do {
+            const v = await this.next();
+            if (v === types_1.END)
+                return; // not found, end of sequence
+            const r = await predicate(v, this.i);
+            if (r === types_1.END)
+                return;
+            if (r)
+                return v;
+            // otherwise proceed
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async some(predicate) {
+        do {
+            const v = await this.next();
+            if (v === types_1.END)
+                return false;
+            const r = await predicate(v, this.i);
+            if (r === types_1.END)
+                return false;
+            if (r)
+                return true;
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async every(predicate) {
+        do {
+            const v = await this.next();
+            if (v === types_1.END)
+                return true;
+            const r = await predicate(v, this.i);
+            if (r === types_1.END)
+                return true;
+            if (!r)
+                return false;
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async toArray() {
+        const a = [];
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const v = await this.next();
+            if (v === types_1.END)
+                return a;
+            a.push(v);
+        }
+    }
+}
+exports.AsyncSequence = AsyncSequence;

package/dist-esm/seq/seq.js

@@ -1,4 +1,4 @@
-import { END, SKIP } from '../types';
+import { END, SKIP, } from '../types';
 /**
  * Inspired by Kotlin Sequences.
  * Similar to arrays, but with lazy evaluation, abortable.
@@ -7,7 +7,7 @@ import { END, SKIP } from '../types';
  *
  * @experimental
  */
-export class Seq {
+export class Sequence {
     constructor(initialValue, nextFn) {
         this.nextFn = nextFn;
         this.sentInitialValue = false;
@@ -23,18 +23,18 @@ export class Seq {
         };
     }
     static create(initialValue, nextFn) {
-        return new Seq(initialValue, nextFn);
+        return new Sequence(initialValue, nextFn);
     }
     static range(minIncl, maxExcl, step = 1) {
         const max = maxExcl - step;
-        return new Seq(minIncl, n => (n < max ? n + step : END));
+        return new Sequence(minIncl, n => (n < max ? n + step : END));
     }
     static from(a) {
         const it = a[Symbol.iterator]();
         const v = it.next();
         if (v.done)
-            return new Seq(END, () => { });
-        return new Seq(v.value, () => {
+            return new Sequence(END, () => { });
+        return new Sequence(v.value, () => {
             const v = it.next();
             if (v.done)
                 return END;
@@ -42,7 +42,7 @@ export class Seq {
         });
     }
     static empty() {
-        return new Seq(END, () => { });
+        return new Sequence(END, () => { });
     }
     next() {
         if (this.currentValue === END)
@@ -132,5 +132,111 @@ export class Seq {
  * Convenience function to create a Sequence.
  */
 export function _seq(initialValue, nextFn) {
-    return Seq.create(initialValue, nextFn);
+    return Sequence.create(initialValue, nextFn);
+}
+/* eslint-disable no-await-in-loop */
+/**
+ * Experimental.
+ * Feasibility to be proven.
+ *
+ * @experimental
+ */
+export class AsyncSequence {
+    constructor(initialValue, nextFn) {
+        this.nextFn = nextFn;
+        this.sentInitialValue = false;
+        this.i = -1;
+        this.currentValue = initialValue;
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => {
+                const value = await this.next();
+                return value === END ? { done: true, value: undefined } : { value };
+            },
+        };
+    }
+    static create(initialValue, nextFn) {
+        return new AsyncSequence(initialValue, nextFn);
+    }
+    static async from(a) {
+        const it = a[Symbol.asyncIterator]();
+        const v = await it.next();
+        if (v.done)
+            return new AsyncSequence(END, () => { });
+        return new AsyncSequence(v.value, async () => {
+            const v = await it.next();
+            if (v.done)
+                return END;
+            return v.value;
+        });
+    }
+    static empty() {
+        return new AsyncSequence(END, () => { });
+    }
+    async next() {
+        if (this.currentValue === END)
+            return END;
+        this.i++;
+        let v;
+        if (!this.sentInitialValue) {
+            this.sentInitialValue = true;
+            v = this.currentValue;
+        }
+        else {
+            v = await this.nextFn(this.currentValue, this.i);
+        }
+        // console.log(`_seq`, v)
+        if (v === SKIP)
+            return await this.next();
+        return (this.currentValue = v);
+    }
+    // Final functions - return final value, not a chained sequence
+    async find(predicate) {
+        do {
+            const v = await this.next();
+            if (v === END)
+                return; // not found, end of sequence
+            const r = await predicate(v, this.i);
+            if (r === END)
+                return;
+            if (r)
+                return v;
+            // otherwise proceed
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async some(predicate) {
+        do {
+            const v = await this.next();
+            if (v === END)
+                return false;
+            const r = await predicate(v, this.i);
+            if (r === END)
+                return false;
+            if (r)
+                return true;
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async every(predicate) {
+        do {
+            const v = await this.next();
+            if (v === END)
+                return true;
+            const r = await predicate(v, this.i);
+            if (r === END)
+                return true;
+            if (!r)
+                return false;
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async toArray() {
+        const a = [];
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const v = await this.next();
+            if (v === END)
+                return a;
+            a.push(v);
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.74.0",
+  "version": "14.75.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",

package/src/seq/seq.ts

@@ -1,4 +1,11 @@
-import { AbortableMapper, AbortablePredicate, END, SKIP } from '../types'
+import {
+  AbortableAsyncMapper,
+  AbortableAsyncPredicate,
+  AbortableMapper,
+  AbortablePredicate,
+  END,
+  SKIP,
+} from '../types'
 
 /**
  * Inspired by Kotlin Sequences.
@@ -8,7 +15,7 @@ import { AbortableMapper, AbortablePredicate, END, SKIP } from '../types'
  *
  * @experimental
  */
-export class Seq<T> implements Iterable<T> {
+export class Sequence<T> implements Iterable<T> {
   private constructor(initialValue: T | typeof END, private nextFn: AbortableMapper<T, T>) {
     this.currentValue = initialValue
   }
@@ -22,29 +29,29 @@ export class Seq<T> implements Iterable<T> {
     }
   }
 
-  static create<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Seq<T> {
-    return new Seq(initialValue, nextFn)
+  static create<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Sequence<T> {
+    return new Sequence(initialValue, nextFn)
   }
 
-  static range(minIncl: number, maxExcl: number, step = 1): Seq<number> {
+  static range(minIncl: number, maxExcl: number, step = 1): Sequence<number> {
     const max = maxExcl - step
-    return new Seq(minIncl, n => (n < max ? n + step : END))
+    return new Sequence(minIncl, n => (n < max ? n + step : END))
   }
 
-  static from<T>(a: Iterable<T>): Seq<T> {
+  static from<T>(a: Iterable<T>): Sequence<T> {
     const it = a[Symbol.iterator]()
     const v = it.next()
-    if (v.done) return new Seq<any>(END, () => {})
+    if (v.done) return new Sequence<any>(END, () => {})
 
-    return new Seq(v.value, () => {
+    return new Sequence(v.value, () => {
       const v = it.next()
       if (v.done) return END
       return v.value
     })
   }
 
-  static empty<T = any>(): Seq<T> {
-    return new Seq(END as any, () => {})
+  static empty<T = any>(): Sequence<T> {
+    return new Sequence(END as any, () => {})
   }
 
   private currentValue: T | typeof END
@@ -138,6 +145,120 @@ export class Seq<T> implements Iterable<T> {
 /**
  * Convenience function to create a Sequence.
  */
-export function _seq<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Seq<T> {
-  return Seq.create(initialValue, nextFn)
+export function _seq<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Sequence<T> {
+  return Sequence.create(initialValue, nextFn)
+}
+
+/* eslint-disable no-await-in-loop */
+
+/**
+ * Experimental.
+ * Feasibility to be proven.
+ *
+ * @experimental
+ */
+export class AsyncSequence<T> implements AsyncIterable<T> {
+  private constructor(initialValue: T | typeof END, private nextFn: AbortableAsyncMapper<T, T>) {
+    this.currentValue = initialValue
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<T> {
+    return {
+      next: async () => {
+        const value = await this.next()
+        return value === END ? { done: true, value: undefined } : { value }
+      },
+    }
+  }
+
+  static create<T>(
+    initialValue: T | typeof END,
+    nextFn: AbortableAsyncMapper<T, T>,
+  ): AsyncSequence<T> {
+    return new AsyncSequence(initialValue, nextFn)
+  }
+
+  static async from<T>(a: AsyncIterable<T>): Promise<AsyncSequence<T>> {
+    const it = a[Symbol.asyncIterator]()
+    const v = await it.next()
+    if (v.done) return new AsyncSequence<any>(END, () => {})
+
+    return new AsyncSequence(v.value, async () => {
+      const v = await it.next()
+      if (v.done) return END
+      return v.value
+    })
+  }
+
+  static empty<T = any>(): AsyncSequence<T> {
+    return new AsyncSequence(END as any, () => {})
+  }
+
+  private currentValue: T | typeof END
+  private sentInitialValue = false
+  private i = -1
+
+  async next(): Promise<T | typeof END> {
+    if (this.currentValue === END) return END
+
+    this.i++
+
+    let v: T | typeof SKIP | typeof END
+
+    if (!this.sentInitialValue) {
+      this.sentInitialValue = true
+      v = this.currentValue
+    } else {
+      v = await this.nextFn(this.currentValue, this.i)
+    }
+
+    // console.log(`_seq`, v)
+
+    if (v === SKIP) return await this.next()
+
+    return (this.currentValue = v)
+  }
+
+  // Final functions - return final value, not a chained sequence
+  async find(predicate: AbortableAsyncPredicate<T>): Promise<T | undefined> {
+    do {
+      const v = await this.next()
+      if (v === END) return // not found, end of sequence
+      const r = await predicate(v, this.i)
+      if (r === END) return
+      if (r) return v
+      // otherwise proceed
+    } while (true) // eslint-disable-line no-constant-condition
+  }
+
+  async some(predicate: AbortableAsyncPredicate<T>): Promise<boolean> {
+    do {
+      const v = await this.next()
+      if (v === END) return false
+      const r = await predicate(v, this.i)
+      if (r === END) return false
+      if (r) return true
+    } while (true) // eslint-disable-line no-constant-condition
+  }
+
+  async every(predicate: AbortableAsyncPredicate<T>): Promise<boolean> {
+    do {
+      const v = await this.next()
+      if (v === END) return true
+      const r = await predicate(v, this.i)
+      if (r === END) return true
+      if (!r) return false
+    } while (true) // eslint-disable-line no-constant-condition
+  }
+
+  async toArray(): Promise<T[]> {
+    const a: T[] = []
+
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const v = await this.next()
+      if (v === END) return a
+      a.push(v)
+    }
+  }
 }