@naturalcycles/js-lib 14.74.0 → 14.77.0

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
@@ -133,11 +140,135 @@ export class Seq<T> implements Iterable<T> {
       a.push(v)
     }
   }
+
+  forEach(fn: (v: T, i: number) => void): void {
+    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<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)
+    }
+  }
 }

package/src/string/stringifyAny.ts

@@ -76,16 +76,20 @@ export function _stringifyAny(obj: any, opt: StringifyAnyOptions = {}): string {
     // Error or ErrorObject
     //
 
+    // Omit "default" error name as non-informative
+    // UPD: no, it's still important to understand that we're dealing with Error and not just some string
+    // if (obj?.name === 'Error') {
+    //   s = obj.message
+    // }
+    s = [obj.name, obj.message].join(': ')
+
     if (opt.includeErrorStack && obj.stack) {
-      // Stack includes message
-      s = obj.stack
-    } else {
-      // Omit "default" error name as non-informative
-      // UPD: no, it's still important to understand that we're dealing with Error and not just some string
-      // if (obj?.name === 'Error') {
-      //   s = obj.message
-      // }
-      s = [obj.name, obj.message].join(': ')
+      // Here we're using the previously-generated "title line" (e.g "Error: some_message"),
+      // concatenating it with the Stack (but without the title line of the Stack)
+      // This is to fix the rare error (happened with Got) where `err.message` was changed,
+      // but err.stack had "old" err.message
+      // This should "fix" that
+      s = [s, ...obj.stack.split('\n').slice(1)].join('\n')
     }
 
     if (_isErrorObject(obj)) {

package/src/unit/size.util.ts

@@ -1,9 +1,9 @@
 export function _gb(b: number): number {
-  return Math.round(b / (1024 * 1024 * 1024))
+  return Math.round(b / 1024 ** 3)
 }
 
 export function _mb(b: number): number {
-  return Math.round(b / (1024 * 1024))
+  return Math.round(b / 1024 ** 2)
 }
 
 export function _kb(b: number): number {
@@ -14,8 +14,24 @@ export function _kb(b: number): number {
  * Byte size to Human byte size string
  */
 export function _hb(b = 0): string {
-  if (b < 800) return `${Math.round(b)} byte(s)`
-  if (b < 800 * 1024) return `${Math.round(b / 1024)} Kb`
-  if (b < 800 * 1024 * 1024) return `${Math.round(b / 1024 / 1024)} Mb`
-  return `${Math.round(b / 1024 / 1024 / 1024)} Gb`
+  if (b < 1024) return `${Math.round(b)} byte`
+  if (b < 1024 ** 2) return `${(b / 1024).toPrecision(3)} Kb`
+  if (b < 1024 ** 3) return `${(b / 1024 ** 2).toPrecision(3)} Mb`
+  if (b < 1024 ** 4) return `${(b / 1024 ** 3).toPrecision(3)} Gb`
+  if (b < 1024 ** 5) return `${(b / 1024 ** 4).toPrecision(3)} Tb`
+  return `${Math.round(b / 1024 ** 4)} Tb`
+}
+
+/**
+ * hc stands for "human count", similar to "human bytes" `_hb` function.
+ * Helpful to print big numbers, as it adds `K` (kilo), `M` (mega), etc to make
+ * them more readable.
+ */
+export function _hc(c = 0): string {
+  if (c < 10 ** 4) return String(c)
+  if (c < 10 ** 6) return (c / 10 ** 3).toPrecision(3) + ' K'
+  if (c < 10 ** 9) return (c / 10 ** 6).toPrecision(3) + ' M' // million
+  if (c < 10 ** 12) return (c / 10 ** 9).toPrecision(3) + ' B' // billion
+  if (c < 10 ** 15) return (c / 10 ** 12).toPrecision(3) + ' T' // trillion
+  return Math.round(c / 10 ** 12) + ' T'
 }