@naturalcycles/js-lib 14.69.4 → 14.71.0

package/src/promise/pMap.ts

@@ -7,8 +7,7 @@ Improvements:
 - Compatible with pProps (that had typings issues)
  */
 
-import { ErrorMode } from '..'
-import { AsyncMapper } from '../types'
+import { AbortableAsyncMapper, END, ErrorMode, SKIP } from '..'
 import { AggregatedError } from './AggregatedError'
 
 export interface PMapOptions {
@@ -57,37 +56,38 @@ export interface PMapOptions {
  */
 export async function pMap<IN, OUT>(
   iterable: Iterable<IN | PromiseLike<IN>>,
-  mapper: AsyncMapper<IN, OUT>,
+  mapper: AbortableAsyncMapper<IN, OUT>,
   opt: PMapOptions = {},
 ): Promise<OUT[]> {
   return new Promise<OUT[]>((resolve, reject) => {
     const { concurrency = Number.POSITIVE_INFINITY, errorMode = ErrorMode.THROW_IMMEDIATELY } = opt
 
-    const ret: OUT[] = []
+    const ret: (OUT | typeof SKIP)[] = []
     const iterator = iterable[Symbol.iterator]()
     const errors: Error[] = []
-    let isRejected = false
+    let isSettled = false
     let isIterableDone = false
     let resolvingCount = 0
     let currentIndex = 0
 
-    const next = () => {
-      if (isRejected) {
+    const next = (skipped = false) => {
+      if (isSettled) {
         return
       }
 
       const nextItem = iterator.next()
       const i = currentIndex
-      currentIndex++
+      if (!skipped) currentIndex++
 
       if (nextItem.done) {
         isIterableDone = true
 
         if (resolvingCount === 0) {
+          const r = ret.filter(r => r !== SKIP) as OUT[]
           if (errors.length && errorMode === ErrorMode.THROW_AGGREGATED) {
-            reject(new AggregatedError(errors, ret))
+            reject(new AggregatedError(errors, r))
           } else {
-            resolve(ret)
+            resolve(r)
           }
         }
 
@@ -100,13 +100,18 @@ export async function pMap<IN, OUT>(
         .then(async element => await mapper(element, i))
         .then(
           value => {
+            if (value === END) {
+              isSettled = true
+              return resolve(ret.filter(r => r !== SKIP) as OUT[])
+            }
+
             ret[i] = value
             resolvingCount--
             next()
           },
           err => {
             if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
-              isRejected = true
+              isSettled = true
               reject(err)
             } else {
               errors.push(err)

package/src/promise/pProps.ts

@@ -10,6 +10,9 @@ Improvements:
 
 import { pMap, PMapOptions } from './pMap'
 
+// todo: remove when eslint starts to know about Awaited
+/* eslint-disable no-undef */
+
 /**
  * Promise.all for Object instead of Array.
  * Supports concurrency.
@@ -17,13 +20,9 @@ import { pMap, PMapOptions } from './pMap'
 export async function pProps<T>(
   input: { [K in keyof T]: T[K] | Promise<T[K]> },
   opt?: PMapOptions,
-): Promise<T> {
+): Promise<{ [K in keyof T]: Awaited<T[K]> }> {
+  const r = {} as { [K in keyof T]: Awaited<T[K]> }
   const keys = Object.keys(input) as (keyof T)[]
-  const values = await pMap(Object.values(input), r => r, opt)
-
-  const r = {} as T
-  values.forEach((v, i) => {
-    r[keys[i]!] = v
-  })
+  await pMap(Object.values(input), (v, i) => (r[keys[i]!] = v), opt)
   return r
 }

package/src/seq/seq.ts

@@ -0,0 +1,143 @@
+import { AbortableMapper, AbortablePredicate, 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 Seq<T> implements Iterable<T> {
+  private constructor(initialValue: T | typeof END, private nextFn: AbortableMapper<T, T>) {
+    this.currentValue = initialValue
+  }
+
+  [Symbol.iterator](): Iterator<T> {
+    return {
+      next: () => {
+        const value = this.next()
+        return value === END ? { done: true, value: undefined } : { value }
+      },
+    }
+  }
+
+  static create<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Seq<T> {
+    return new Seq(initialValue, nextFn)
+  }
+
+  static range(minIncl: number, maxExcl: number, step = 1): Seq<number> {
+    const max = maxExcl - step
+    return new Seq(minIncl, n => (n < max ? n + step : END))
+  }
+
+  static from<T>(a: Iterable<T>): Seq<T> {
+    const it = a[Symbol.iterator]()
+    const v = it.next()
+    if (v.done) return new Seq<any>(END, () => {})
+
+    return new Seq(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, () => {})
+  }
+
+  private currentValue: T | typeof END
+  private sentInitialValue = false
+  private i = -1
+
+  next(): 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 = 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: AbortablePredicate<T>): T | undefined {
+    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: AbortablePredicate<T>): boolean {
+    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: AbortablePredicate<T>): boolean {
+    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(): T[] {
+    const a: T[] = []
+
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const v = this.next()
+      if (v === END) return a
+      a.push(v)
+    }
+  }
+}
+
+/**
+ * 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)
+}

package/src/string/json.util.ts

@@ -1,3 +1,6 @@
+// const possibleJsonStartTokens = ['{', '[', '"']
+const DETECT_JSON = /^\s*[{["\-\d]/
+
 /**
  * Attempts to parse object as JSON.
  * Returns original object if JSON parse failed (silently).
@@ -6,7 +9,8 @@ export function _jsonParseIfPossible(
   obj: any,
   reviver?: (this: any, key: string, value: any) => any,
 ): any {
-  if (typeof obj === 'string' && obj) {
+  // Optimization: only try to parse if it looks like JSON: starts with a json possible character
+  if (typeof obj === 'string' && obj && DETECT_JSON.test(obj)) {
     try {
       return JSON.parse(obj, reviver)
     } catch {}

package/src/typeFest.ts

@@ -151,38 +151,6 @@ export type Merge<FirstType, SecondType> = Simplify<Merge_<FirstType, SecondType
  */
 export type Promisable<T> = T | PromiseLike<T>
 
-/**
- Returns the type that is wrapped inside a `Promise` type.
- If the type is a nested Promise, it is unwrapped recursively until a non-Promise type is obtained.
- If the type is not a `Promise`, the type itself is returned.
-
- @example
- ```
- import {PromiseValue} from 'type-fest';
-
- type AsyncData = Promise<string>;
- let asyncData: PromiseValue<AsyncData> = Promise.resolve('ABC');
-
- type Data = PromiseValue<AsyncData>;
- let data: Data = await asyncData;
-
- // Here's an example that shows how this type reacts to non-Promise types.
- type SyncData = PromiseValue<string>;
- let syncData: SyncData = getSyncData();
-
- // Here's an example that shows how this type reacts to recursive Promise types.
- type RecursiveAsyncData = Promise<Promise<string> >;
- let recursiveAsyncData: PromiseValue<RecursiveAsyncData> = Promise.resolve(Promise.resolve('ABC'));
- ```
-
- @category Utilities
- */
-export type PromiseValue<PromiseType, Otherwise = PromiseType> = PromiseType extends Promise<
-  infer Value
->
-  ? { 0: PromiseValue<Value>; 1: Value }[PromiseType extends Promise<unknown> ? 0 : 1]
-  : Otherwise
-
 /**
  Extract the keys from a type where the value type of the key extends the given `Condition`.
  Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.

package/src/types.ts

@@ -1,4 +1,4 @@
-import { Merge } from './typeFest'
+import { Merge, Promisable } from './typeFest'
 
 /**
  * Map from String to String (or <T>).
@@ -45,6 +45,16 @@ export interface AnyObjectWithId extends AnyObject, ObjectWithId {}
  */
 export type AnyFunction = (...args: any[]) => any
 
+/**
+ * Symbol to indicate END of Sequence.
+ */
+export const END = Symbol('END')
+
+/**
+ * Symbol to indicate SKIP of item (e.g in AbortableMapper)
+ */
+export const SKIP = Symbol('SKIP')
+
 /**
  * Function which is called for every item in `input`. Expected to return a `Promise` or value.
  */
@@ -62,6 +72,17 @@ export const _noop = (..._args: any[]): undefined => undefined
 export type Predicate<T> = (item: T, index: number) => boolean
 export type AsyncPredicate<T> = (item: T, index: number) => boolean | PromiseLike<boolean>
 
+export type AbortablePredicate<T> = (item: T, i: number) => boolean | typeof END
+export type AbortableAsyncPredicate<T> = (item: T, i: number) => Promisable<boolean | typeof END>
+export type AbortableMapper<IN = any, OUT = any> = (
+  input: IN,
+  i: number,
+) => OUT | typeof SKIP | typeof END
+export type AbortableAsyncMapper<IN = any, OUT = any> = (
+  input: IN,
+  i: number,
+) => Promisable<OUT | typeof SKIP | typeof END>
+
 export const _passthroughPredicate: Predicate<any> = () => true
 export const _passNothingPredicate: Predicate<any> = () => false