@nxtedition/lib 26.8.8 → 27.0.0

package/rxjs/combineMap.test.js

@@ -1,199 +0,0 @@
-import { test } from 'node:test'
-import combineMap from './combineMap.js'
-import * as rxjs from 'rxjs'
-
-test('combineMap sync', (t) => {
-  t.plan(1, { wait: true })
-  rxjs
-    .of([1, 2, 3])
-    .pipe(combineMap((val) => rxjs.of(val * 2)))
-    .subscribe((val) => {
-      t.assert.deepStrictEqual(val, [2, 4, 6])
-    })
-})
-
-test('combineMap async', (t) => {
-  t.plan(1, { wait: true })
-  rxjs
-    .of([1, 2, 3])
-    .pipe(combineMap(async (val) => val * 2))
-    .subscribe((val) => {
-      t.assert.deepStrictEqual(val, [2, 4, 6])
-    })
-})
-
-test('combineMap empty', (t) => {
-  t.plan(1, { wait: true })
-  rxjs
-    .of([])
-    .pipe(combineMap((val) => rxjs.of(val * 2)))
-    .subscribe((val) => {
-      t.assert.deepStrictEqual(val, [])
-    })
-})
-
-test('combineMap throw in resolver', (t) => {
-  t.plan(1, { wait: true })
-  const _err = new Error('asd')
-  rxjs
-    .of([1, 2, 3])
-    .pipe(
-      combineMap((val) => {
-        throw _err
-      }),
-    )
-    .subscribe({
-      error: (err) => {
-        t.assert.strictEqual(err, _err)
-      },
-    })
-})
-
-test('combineMap throw in source', (t) => {
-  t.plan(1, { wait: true })
-  const _err = new Error('asd')
-  rxjs
-    .throwError(() => _err)
-    .pipe(combineMap((val) => rxjs.of(val)))
-    .subscribe({
-      error: (err) => {
-        t.assert.strictEqual(err, _err)
-      },
-    })
-})
-
-test('combineMap bad resolve', (t) => {
-  t.plan(1, { wait: true })
-  rxjs
-    .of([1])
-    .pipe(combineMap((val) => val))
-    .subscribe({
-      error: () => {
-        t.assert.ok(true)
-      },
-    })
-})
-
-test('combineMap no change no tick', (t) => {
-  t.plan(1, { wait: true })
-  rxjs
-    .concat(
-      rxjs.timer(10).pipe(rxjs.map(() => [1, 2, 3])),
-      rxjs.timer(10).pipe(rxjs.map(() => [1, 2, 3])),
-    )
-    .pipe(combineMap((val) => rxjs.of(val * 2)))
-    .subscribe(() => {
-      t.assert.ok(true)
-    })
-})
-
-test('combineMap combine in single tick', (t) => {
-  t.plan(2, { wait: true })
-  rxjs
-    .concat(
-      rxjs.timer(10).pipe(rxjs.map(() => [1, 2, 3])),
-      rxjs.timer(10).pipe(rxjs.map(() => [4, 5, 6])),
-    )
-    .pipe(combineMap((val) => rxjs.from([val * 2, val * 2])))
-    .subscribe(() => {
-      t.assert.ok(true)
-    })
-})
-
-test('combineLatest completion', (t) => {
-  t.plan(1, { wait: true })
-  rxjs.combineLatest([1, 2, 3].map((x) => rxjs.of(x))).subscribe({
-    complete: () => {
-      t.assert.ok(true)
-    },
-  })
-})
-
-test('combineMap completion', (t) => {
-  t.plan(1, { wait: true })
-  rxjs
-    .of([1, 2, 3])
-    .pipe(combineMap((x) => rxjs.of(x)))
-    .subscribe({
-      complete: () => {
-        t.assert.ok(true)
-      },
-    })
-})
-
-test('combineLatest no completion', (t) => {
-  t.plan(1, { wait: true })
-  const subscription = rxjs
-    .combineLatest([1, 2, 3].map((x) => rxjs.timer(0, 1e3).pipe(rxjs.map(() => x))))
-    .subscribe({
-      next: () => {
-        t.assert.ok(true)
-      },
-      complete: () => {
-        t.assert.fail()
-      },
-    })
-  t.after(() => subscription.unsubscribe())
-})
-
-test('combineMap no completion', (t) => {
-  t.plan(1, { wait: true })
-  const subscription = rxjs
-    .of([1, 2, 3])
-    .pipe(combineMap((x) => rxjs.timer(0, 1e3).pipe(rxjs.map(() => x))))
-    .subscribe({
-      next: () => {
-        t.assert.ok(true)
-      },
-      complete: () => {
-        t.assert.fail()
-      },
-    })
-  t.after(() => subscription.unsubscribe())
-})
-
-test('combineLatest no value', (t) => {
-  t.plan(1, { wait: true })
-  rxjs.combineLatest([1, 2, 3].map((x) => rxjs.EMPTY)).subscribe({
-    complete: () => {
-      t.assert.ok(true)
-    },
-  })
-})
-
-test('combineMap no value', (t) => {
-  t.plan(1, { wait: true })
-  rxjs
-    .of([1, 2, 3])
-    .pipe(combineMap((x) => rxjs.EMPTY))
-    .subscribe({
-      complete: () => {
-        t.assert.ok(true)
-      },
-    })
-})
-
-test('combineMap object keys removed', (t) => {
-  t.plan(3, { wait: true })
-  const a = {}
-  const b = {}
-  const c = {}
-
-  let i = 0
-  rxjs
-    .concat(rxjs.of([a, b, c]), rxjs.of([a, b]).pipe(rxjs.delay(10)))
-    .pipe(combineMap((x) => rxjs.of(x)))
-    .subscribe({
-      next: (value) => {
-        if (i === 0) {
-          t.assert.deepStrictEqual(value, [a, b, c])
-        } else if (i === 1) {
-          t.assert.deepStrictEqual(value, [a, b])
-        }
-        i++
-      },
-      complete: () => {
-        t.assert.ok(true)
-      },
-    })
-})

package/rxjs/firstValueFrom.d.ts

@@ -1,12 +0,0 @@
-import { Observable } from 'rxjs'
-
-interface FirstValueFromConfig<T> {
-  signal?: AbortSignal
-  timeout?: number
-  defaultValue?: T
-}
-
-export default function firstValueFrom<T>(
-  source: Observable<T>,
-  config?: FirstValueFromConfig<T>,
-): Promise<T>

package/rxjs/firstValueFrom.js

@@ -1,18 +0,0 @@
-import * as rxjs from 'rxjs'
-import withAbortSignal from './withAbortSignal.js'
-
-export default function firstValueFrom(x$, config) {
-  const hasConfig = config && typeof config === 'object'
-  const signal = hasConfig ? config.signal : undefined
-  const timeout = hasConfig ? config.timeout : undefined
-
-  if (signal) {
-    x$ = x$.pipe(withAbortSignal(signal))
-  }
-
-  if (timeout) {
-    x$ = x$.pipe(rxjs.timeout(timeout))
-  }
-
-  return rxjs.firstValueFrom(x$, config)
-}

package/rxjs/lastValueFrom.js

@@ -1,14 +0,0 @@
-import { EMPTY, fromEvent, takeUntil, throwIfEmpty, last } from 'rxjs'
-import { AbortError } from '../errors'
-
-export default function lastValueFrom(x$, config) {
-  const hasConfig = config && typeof config === 'object'
-  const signal = hasConfig ? config.signal : undefined
-
-  if (signal) {
-    x$ = signal.aborted ? EMPTY : x$.pipe(takeUntil(fromEvent(signal, 'abort')))
-    x$ = x$.pipe(throwIfEmpty(() => new AbortError()))
-  }
-
-  return x$.pipe(last(hasConfig ? config.defaultValue : undefined)).toPromise()
-}

package/rxjs/retry.js

@@ -1,112 +0,0 @@
-import { operate } from 'rxjs/internal/util/lift'
-import { createOperatorSubscriber } from 'rxjs/internal/operators/OperatorSubscriber'
-import { identity, timer } from 'rxjs'
-import { innerFrom } from 'rxjs/internal/observable/innerFrom'
-
-// This is from https://github.com/ReactiveX/rxjs/blob/7.x/src/internal/operators/retry.ts
-// But with some custom code added to emit a value on each retry attempt.
-// The default delay function is also changed to use exponential backoff, capped at 1 minute.
-//
-// It uses internals from rxjs, but otherwise the code would have to be modified more heavily.
-
-const DEFAULT_DELAY = (err, retryCount) => {
-  return timer(Math.min(2 ** (retryCount - 1) * 1000, 60_000))
-}
-
-export function retry(configOrCount) {
-  let config
-  if (configOrCount && typeof configOrCount === 'object') {
-    config = configOrCount
-  } else {
-    config = {
-      count: configOrCount,
-    }
-  }
-  const { count = Infinity, delay = DEFAULT_DELAY, resetOnSuccess = false, emitOnRetry } = config
-
-  return count <= 0
-    ? identity
-    : operate((source, subscriber) => {
-        let soFar = 0
-        let innerSub
-        const subscribeForRetry = () => {
-          let syncUnsub = false
-          innerSub = source.subscribe(
-            createOperatorSubscriber(
-              subscriber,
-              (value) => {
-                // If we're resetting on success
-                if (resetOnSuccess) {
-                  soFar = 0
-                }
-                subscriber.next(value)
-              },
-              // Completions are passed through to consumer.
-              undefined,
-              (err) => {
-                if (soFar++ < count) {
-                  // We are still under our retry count
-                  const resub = () => {
-                    if (innerSub) {
-                      innerSub.unsubscribe()
-                      innerSub = null
-                      subscribeForRetry()
-                    } else {
-                      syncUnsub = true
-                    }
-                  }
-
-                  // ------- START CUSTOM CODE -------
-                  if (emitOnRetry) {
-                    try {
-                      subscriber.next(emitOnRetry(err, soFar))
-                    } catch (e) {
-                      subscriber.error(e)
-                      return
-                    }
-                  }
-                  // ------- END CUSTOM CODE -------
-
-                  if (delay != null) {
-                    // The user specified a retry delay.
-                    // They gave us a number, use a timer, otherwise, it's a function,
-                    // and we're going to call it to get a notifier.
-                    const notifier =
-                      typeof delay === 'number' ? timer(delay) : innerFrom(delay(err, soFar))
-                    const notifierSubscriber = createOperatorSubscriber(
-                      subscriber,
-                      () => {
-                        // After we get the first notification, we
-                        // unsubscribe from the notifier, because we don't want anymore
-                        // and we resubscribe to the source.
-                        notifierSubscriber.unsubscribe()
-                        resub()
-                      },
-                      () => {
-                        // The notifier completed without emitting.
-                        // The author is telling us they want to complete.
-                        subscriber.complete()
-                      },
-                    )
-                    notifier.subscribe(notifierSubscriber)
-                  } else {
-                    // There was no notifier given. Just resub immediately.
-                    resub()
-                  }
-                } else {
-                  // We're past our maximum number of retries.
-                  // Just send along the error.
-                  subscriber.error(err)
-                }
-              },
-            ),
-          )
-          if (syncUnsub) {
-            innerSub.unsubscribe()
-            innerSub = null
-            subscribeForRetry()
-          }
-        }
-        subscribeForRetry()
-      })
-}

package/rxjs/withAbortSignal.js

@@ -1,31 +0,0 @@
-import { Observable } from 'rxjs'
-import { AbortError } from '../errors.js'
-
-function withAbortSignalImpl(signal) {
-  return new Observable((o) => {
-    o.add(this.subscribe(o))
-
-    if (!signal) {
-      return
-    }
-
-    const onAbort = () => {
-      o.error(signal.reason ?? new AbortError())
-    }
-
-    if (signal.aborted) {
-      onAbort()
-    } else {
-      signal.addEventListener('abort', onAbort)
-      o.add(() => {
-        signal.removeEventListener('abort', onAbort)
-      })
-    }
-  })
-}
-
-Observable.prototype.withAbortSignal = withAbortSignalImpl
-
-export default function withAbortSignal(signal) {
-  return (o) => withAbortSignalImpl.call(o, signal)
-}