@naturalcycles/js-lib 14.191.0 → 14.192.0

package/dist/seq/seq.d.ts

@@ -1,54 +0,0 @@
-import type { AbortableAsyncMapper, AbortableAsyncPredicate, AbortableMapper, AbortablePredicate } from '../types';
-import { END } from '../types';
-/**
- * Inspired by Kotlin Sequences.
- * Similar to arrays, but with lazy evaluation, abortable.
- * Can be useful when it's not feasible/performant to create an array of values to iterate upfront
- * (e.g to construct 1000 Dayjs instances only to find that 2 of them were needed).
- *
- * @experimental
- */
-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>): 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;
-    next(): T | typeof END;
-    find(predicate: AbortablePredicate<T>): T | undefined;
-    some(predicate: AbortablePredicate<T>): boolean;
-    every(predicate: AbortablePredicate<T>): boolean;
-    toArray(): T[];
-    forEach(fn: (v: T, i: number) => void): void;
-}
-/**
- * Convenience function to create a Sequence.
- */
-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,257 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncSequence = exports._seq = exports.Sequence = void 0;
-const types_1 = require("../types");
-/**
- * Inspired by Kotlin Sequences.
- * Similar to arrays, but with lazy evaluation, abortable.
- * Can be useful when it's not feasible/performant to create an array of values to iterate upfront
- * (e.g to construct 1000 Dayjs instances only to find that 2 of them were needed).
- *
- * @experimental
- */
-class Sequence {
-    constructor(initialValue, nextFn) {
-        this.nextFn = nextFn;
-        this.sentInitialValue = false;
-        this.i = -1;
-        this.currentValue = initialValue;
-    }
-    [Symbol.iterator]() {
-        return {
-            next: () => {
-                const value = this.next();
-                return value === types_1.END ? { done: true, value: undefined } : { value };
-            },
-        };
-    }
-    static create(initialValue, nextFn) {
-        return new Sequence(initialValue, nextFn);
-    }
-    static range(minIncl, maxExcl, step = 1) {
-        const max = maxExcl - step;
-        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 Sequence(types_1.END, () => { });
-        return new Sequence(v.value, () => {
-            const v = it.next();
-            if (v.done)
-                return types_1.END;
-            return v.value;
-        });
-    }
-    static empty() {
-        return new Sequence(types_1.END, () => { });
-    }
-    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 = this.nextFn(this.currentValue, this.i);
-        }
-        // console.log(`_seq`, v)
-        if (v === types_1.SKIP)
-            return this.next();
-        return (this.currentValue = v);
-    }
-    // Chainable functions - return another (chained) Sequence
-    // map<OUT>(mapper: Mapper<T, OUT | typeof SKIP | typeof END>): Seq<OUT> {
-    //   if (this.currentValue === END) return this as any
-    //
-    //   // Iterate until first valid value, to have as `initialValue` of the new Sequence
-    //   let v: OUT | typeof SKIP | typeof END
-    //
-    //   while (true) {
-    //     v = mapper(this.currentValue, ++this.i)
-    //     if (v === SKIP) continue
-    //     if (v === END) return this as any
-    //   }
-    //
-    //   return new Seq<OUT>(v as OUT, (current, i) => {
-    //     const v = mapper(current, i)
-    //
-    //   })
-    // }
-    // Final functions - return final value, not a chained sequence
-    find(predicate) {
-        do {
-            const v = this.next();
-            if (v === types_1.END)
-                return; // not found, end of sequence
-            const r = predicate(v, this.i);
-            if (r === types_1.END)
-                return;
-            if (r)
-                return v;
-            // otherwise proceed
-        } while (true); // eslint-disable-line no-constant-condition
-    }
-    some(predicate) {
-        do {
-            const v = this.next();
-            if (v === types_1.END)
-                return false;
-            const r = predicate(v, this.i);
-            if (r === types_1.END)
-                return false;
-            if (r)
-                return true;
-        } while (true); // eslint-disable-line no-constant-condition
-    }
-    every(predicate) {
-        do {
-            const v = this.next();
-            if (v === types_1.END)
-                return true;
-            const r = predicate(v, this.i);
-            if (r === types_1.END)
-                return true;
-            if (!r)
-                return false;
-        } while (true); // eslint-disable-line no-constant-condition
-    }
-    toArray() {
-        const a = [];
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            const v = this.next();
-            if (v === types_1.END)
-                return a;
-            a.push(v);
-        }
-    }
-    forEach(fn) {
-        let i = -1;
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            const v = this.next();
-            if (v === types_1.END)
-                return;
-            fn(v, ++i);
-        }
-    }
-}
-exports.Sequence = Sequence;
-/**
- * Convenience function to create a Sequence.
- */
-function _seq(initialValue, nextFn) {
-    return Sequence.create(initialValue, nextFn);
-}
-exports._seq = _seq;
-/**
- * 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,251 +0,0 @@
-import { END, SKIP } from '../types';
-/**
- * Inspired by Kotlin Sequences.
- * Similar to arrays, but with lazy evaluation, abortable.
- * Can be useful when it's not feasible/performant to create an array of values to iterate upfront
- * (e.g to construct 1000 Dayjs instances only to find that 2 of them were needed).
- *
- * @experimental
- */
-export class Sequence {
-    constructor(initialValue, nextFn) {
-        this.nextFn = nextFn;
-        this.sentInitialValue = false;
-        this.i = -1;
-        this.currentValue = initialValue;
-    }
-    [Symbol.iterator]() {
-        return {
-            next: () => {
-                const value = this.next();
-                return value === END ? { done: true, value: undefined } : { value };
-            },
-        };
-    }
-    static create(initialValue, nextFn) {
-        return new Sequence(initialValue, nextFn);
-    }
-    static range(minIncl, maxExcl, step = 1) {
-        const max = maxExcl - step;
-        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 Sequence(END, () => { });
-        return new Sequence(v.value, () => {
-            const v = it.next();
-            if (v.done)
-                return END;
-            return v.value;
-        });
-    }
-    static empty() {
-        return new Sequence(END, () => { });
-    }
-    next() {
-        if (this.currentValue === END)
-            return END;
-        this.i++;
-        let v;
-        if (!this.sentInitialValue) {
-            this.sentInitialValue = true;
-            v = this.currentValue;
-        }
-        else {
-            v = this.nextFn(this.currentValue, this.i);
-        }
-        // console.log(`_seq`, v)
-        if (v === SKIP)
-            return this.next();
-        return (this.currentValue = v);
-    }
-    // Chainable functions - return another (chained) Sequence
-    // map<OUT>(mapper: Mapper<T, OUT | typeof SKIP | typeof END>): Seq<OUT> {
-    //   if (this.currentValue === END) return this as any
-    //
-    //   // Iterate until first valid value, to have as `initialValue` of the new Sequence
-    //   let v: OUT | typeof SKIP | typeof END
-    //
-    //   while (true) {
-    //     v = mapper(this.currentValue, ++this.i)
-    //     if (v === SKIP) continue
-    //     if (v === END) return this as any
-    //   }
-    //
-    //   return new Seq<OUT>(v as OUT, (current, i) => {
-    //     const v = mapper(current, i)
-    //
-    //   })
-    // }
-    // Final functions - return final value, not a chained sequence
-    find(predicate) {
-        do {
-            const v = this.next();
-            if (v === END)
-                return; // not found, end of sequence
-            const r = predicate(v, this.i);
-            if (r === END)
-                return;
-            if (r)
-                return v;
-            // otherwise proceed
-        } while (true); // eslint-disable-line no-constant-condition
-    }
-    some(predicate) {
-        do {
-            const v = this.next();
-            if (v === END)
-                return false;
-            const r = predicate(v, this.i);
-            if (r === END)
-                return false;
-            if (r)
-                return true;
-        } while (true); // eslint-disable-line no-constant-condition
-    }
-    every(predicate) {
-        do {
-            const v = this.next();
-            if (v === END)
-                return true;
-            const r = predicate(v, this.i);
-            if (r === END)
-                return true;
-            if (!r)
-                return false;
-        } while (true); // eslint-disable-line no-constant-condition
-    }
-    toArray() {
-        const a = [];
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            const v = this.next();
-            if (v === END)
-                return a;
-            a.push(v);
-        }
-    }
-    forEach(fn) {
-        let i = -1;
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            const v = this.next();
-            if (v === END)
-                return;
-            fn(v, ++i);
-        }
-    }
-}
-/**
- * Convenience function to create a Sequence.
- */
-export function _seq(initialValue, nextFn) {
-    return Sequence.create(initialValue, nextFn);
-}
-/**
- * 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);
-        }
-    }
-}