@nxtedition/lib 26.8.7 → 27.0.0-alpha.0

package/app.js

@@ -21,7 +21,7 @@ import deepstream from '@nxtedition/deepstream.io-client-js'
 import { createLogger } from './logger.js'
 import nconf from 'nconf'
 import { makeCouch } from './couch.js'
-import { makeTemplateCompiler } from './util/template/index.js'
+import { makeTemplateCompiler } from '@nxtedition/template'
 import { makeDeepstream } from './deepstream.js'
 import v8 from 'v8'
 import * as rxjs from 'rxjs'

package/couch.js

@@ -2,7 +2,7 @@ import assert from 'node:assert'
 import stream from 'node:stream'
 import querystring from 'node:querystring'
 import createError from 'http-errors'
-import { makeWeakCache } from './weakCache.js'
+import { makeWeakCache } from '@nxtedition/weak-cache'
 import { defaultDelay as delay } from './http.js'
 import urljoin from 'url-join'
 import { AbortError } from './errors.js'

package/package.json

@@ -1,25 +1,22 @@
 {
   "name": "@nxtedition/lib",
-  "version": "26.8.7",
-  "license": "MIT",
+  "version": "27.0.0-alpha.0",
+  "license": "UNLICENSED",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
   "files": [
     "index.d.ts",
     "hash.js",
     "ass.js",
-    "rxjs/*",
     "util/*",
     "cache.js",
     "fixed-queue.js",
-    "http-client.js",
     "subtract-ranges.js",
     "serializers.js",
     "platform.js",
     "elasticsearch.js",
     "merge-ranges.js",
     "http.js",
-    "s3.js",
     "time.js",
     "mutex.js",
     "deepstream.js",
@@ -33,8 +30,6 @@
     "proxy.js",
     "timers.js",
     "trace.js",
-    "weakCache.js",
-    "weakCache.d.ts",
     "couch.js",
     "couch.d.ts",
     "app.js",
@@ -43,57 +38,34 @@
     "errors.d.ts",
     "worker.js",
     "stream.js",
-    "timeline.js",
     "transcript.js",
     "docker-secrets.js",
     "wordwrap.js",
-    "under-pressure.js",
-    "yield.js"
+    "under-pressure.js"
   ],
   "scripts": {
     "test": "node --test-timeout 60000 --test",
-    "test:types": "tsd",
-    "prepare": "husky"
-  },
-  "lint-staged": {
-    "*.{js,jsx,md,ts}": [
-      "eslint",
-      "prettier --write"
-    ]
-  },
-  "prettier": {
-    "printWidth": 100,
-    "semi": false,
-    "singleQuote": true
+    "test:types": "tsd"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "3.918.0",
     "@elastic/elasticsearch": "^8.17.1",
     "@elastic/transport": "^8.9.3",
     "@nxtedition/nxt-undici": "^6.4.17",
     "@nxtedition/sched": "^1.0.2",
-    "@smithy/node-http-handler": "^4.4.3",
-    "acorn": "^8.15.0",
-    "astring": "^1.9.0",
-    "date-fns": "^4.1.0",
+    "@nxtedition/template": "^1.0.0-alpha.0",
+    "@nxtedition/weak-cache": "^1.0.0-alpha.0",
     "diff": "5.2.0",
     "fast-querystring": "^1.1.2",
-    "hasha": "^7.0.0",
     "http-errors": "^2.0.0",
-    "json5": "^2.2.3",
     "lodash": "^4.17.21",
     "lru-cache": "^11.2.2",
     "mime": "^4.0.7",
     "mitata": "^1.0.34",
-    "moment-timezone": "^0.5.48",
     "nconf": "^0.13.0",
     "object-hash": "^3.0.0",
-    "p-queue": "^9.0.0",
     "pino": "^10.1.0",
     "qs": "^6.14.0",
     "request-target": "^1.0.2",
-    "smpte-timecode": "^1.3.6",
-    "split-string": "^6.0.0",
     "url-join": "^5.0.0",
     "xuid": "^4.1.5",
     "yocto-queue": "^1.2.1"
@@ -103,20 +75,9 @@
     "@types/lodash": "^4.17.20",
     "@types/node": "^24.9.1",
     "canvas": "^3.1.0",
-    "eslint": "^9.38.0",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-config-standard": "^17.0.0",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-n": "^17.23.1",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^7.2.1",
-    "husky": "^9.1.7",
-    "lint-staged": "^16.2.6",
-    "prettier": "^3.6.2",
     "rxjs": "^7.8.2",
     "tsd": "^0.33.0",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.2"
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.6.0",
@@ -124,6 +85,7 @@
     "@nxtedition/deepstream.io-client-js": ">=14.1.0",
     "canvas": "^3.1.0",
     "pino": ">=7.0.0",
-    "rxjs": ">=6.0.0"
-  }
+    "rxjs": "^7.0.0"
+  },
+  "gitHead": "7e4d71a9276d64d7cb8c39eaed681121903e16a4"
 }

package/rxjs/auditMap.js

@@ -1,111 +0,0 @@
-import { Observable, from } from 'rxjs'
-
-function auditMapImpl(project) {
-  return new Observable((o) => {
-    let pendingValue = null
-    let hasPendingValue = false
-    let isComplete = false
-    let abortController = null
-
-    let innerSubscription = null
-    let outerSubscription = null
-
-    function _error(err) {
-      o.error(err)
-    }
-
-    function _innerComplete() {
-      innerSubscription = null
-      abortController = null
-
-      if (hasPendingValue) {
-        const value = pendingValue
-        pendingValue = null
-        hasPendingValue = false
-        _tryNext(value)
-      } else if (isComplete) {
-        o.complete()
-      }
-    }
-
-    function _innerNext(val) {
-      o.next(val)
-    }
-
-    function _drain() {
-      if (!hasPendingValue) {
-        return
-      }
-      const value = pendingValue
-      pendingValue = null
-      hasPendingValue = false
-      return { value }
-    }
-
-    function _tryNext(value) {
-      try {
-        const result = project(value, {
-          get signal() {
-            if (!abortController) {
-              abortController = new AbortController()
-              if (hasPendingValue) {
-                abortController.abort()
-              }
-            }
-            return abortController.signal
-          },
-          _drain,
-        })
-        const observable = typeof result.then === 'function' ? from(result) : result
-        innerSubscription = observable.subscribe({
-          next: _innerNext,
-          error: _error,
-          complete: _innerComplete,
-        })
-        if (innerSubscription && innerSubscription.closed) {
-          innerSubscription = null
-        }
-      } catch (err) {
-        o.error(err)
-      }
-    }
-
-    function _next(value) {
-      if (innerSubscription) {
-        pendingValue = value
-        hasPendingValue = true
-        abortController?.abort()
-      } else {
-        _tryNext(value)
-      }
-    }
-
-    function _complete() {
-      isComplete = true
-      if (!innerSubscription) {
-        o.complete()
-      } else {
-        abortController?.abort()
-      }
-    }
-
-    outerSubscription = this.subscribe({
-      next: _next,
-      error: _error,
-      complete: _complete,
-    })
-
-    return () => {
-      if (innerSubscription) {
-        innerSubscription.unsubscribe()
-      }
-      outerSubscription.unsubscribe()
-    }
-  })
-}
-
-Observable.prototype.auditMap = auditMapImpl
-
-export default function auditMap(project) {
-  return (o) => auditMapImpl.call(o, project)
-}

package/rxjs/auditMap.test.js

@@ -1,64 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert'
-import auditMap from './auditMap.js'
-import * as rxjs from 'rxjs'
-import tp from 'node:timers/promises'
-
-test('auditMap sync', (t) => {
-  t.plan(1, { wait: true })
-  rxjs
-    .of(1, 2, 3)
-    .pipe(
-      auditMap((val) => rxjs.of(val * 2)),
-      rxjs.toArray(),
-    )
-    .subscribe((val) => {
-      t.assert.deepStrictEqual(val, [2, 4, 6])
-    })
-})
-
-test('auditMap async', (t) => {
-  t.plan(1, { wait: true })
-  rxjs
-    .of(1, 2, 3)
-    .pipe(
-      auditMap(async (val) => val * 2),
-      rxjs.toArray(),
-    )
-    .subscribe((val) => {
-      t.assert.deepStrictEqual(val, [2, 6])
-    })
-})
-
-test('auditMap drain', (t) => {
-  t.plan(1, { wait: true })
-  rxjs
-    .of(1, 2, 3)
-    .pipe(
-      auditMap(async (val, { _drain }) => {
-        await tp.setTimeout(1)
-        return _drain()?.value ?? val
-      }),
-      rxjs.toArray(),
-    )
-    .subscribe((val) => {
-      t.assert.deepStrictEqual(val, [3])
-    })
-})
-
-test('auditMap signal', (t) => {
-  t.plan(1, { wait: true })
-  rxjs
-    .of(1, 2, 3)
-    .pipe(
-      auditMap(async (val, { signal }) => {
-        await tp.setTimeout(1)
-        assert.strictEqual(signal.aborted, val === 1)
-        return val
-      }),
-      rxjs.toArray(),
-    )
-    .subscribe((val) => {
-      t.assert.deepStrictEqual(val, [1, 3])
-    })
-})

package/rxjs/combineMap.d.ts

@@ -1,6 +0,0 @@
-import type { ObservableInput, OperatorFunction } from 'rxjs'
-
-export default function combineMap<T, R>(
-  project: (value: T) => ObservableInput<R>,
-  equals?: (a: T, b: T) => boolean,
-): OperatorFunction<T[], R[]>

package/rxjs/combineMap.js

@@ -1,152 +0,0 @@
-import { Observable, from, throwError } from 'rxjs'
-
-const EMPTY = Object.freeze([])
-
-function combineMapImpl(project, equals = (a, b) => a === b) {
-  return new Observable((o) => {
-    let curr = EMPTY
-    let scheduled = false
-    let disposed = false
-    let dirty = false
-    let active = 0
-    let empty = 0
-
-    const _error = (err) => o.error(err)
-
-    function _update() {
-      scheduled = false
-
-      if (empty > 0) {
-        return
-      }
-
-      if (dirty) {
-        dirty = false
-        o.next(curr.map(({ value }) => value))
-      }
-
-      if (active === 0) {
-        o.complete()
-      }
-    }
-
-    function update() {
-      if (!scheduled && !disposed) {
-        scheduled = true
-        queueMicrotask(_update)
-      }
-    }
-
-    active += 1
-    const subscription = this.subscribe({
-      next(keys) {
-        keys = Array.isArray(keys) ? keys : EMPTY
-
-        // TODO (perf): Avoid array allocation & copy if nothing has updated.
-        const prev = curr
-        curr = new Array(keys.length)
-
-        const prevLen = prev.length
-        const currLen = curr.length
-
-        if (currLen !== prevLen || prev === EMPTY) {
-          dirty = true
-        }
-
-        for (let n = 0; n < currLen; ++n) {
-          const key = keys[n]
-
-          if (n < prevLen && prev[n] && equals(prev[n].key, key)) {
-            curr[n] = prev[n]
-            prev[n] = null
-            continue
-          }
-
-          dirty = true
-
-          // TODO (perf): Guess start index based on n, e.g. n - 1 and n + 1 to check if
-          // a key has simply been added or removed.
-          const i = prev.findIndex((entry) => entry && equals(entry.key, key))
-
-          if (i !== -1) {
-            curr[n] = prev[i]
-            prev[i] = null
-          } else {
-            let observable
-            try {
-              observable = from(project(keys[n]))
-            } catch (err) {
-              observable = throwError(() => err)
-            }
-
-            const entry = {
-              key,
-              value: EMPTY,
-              subscription: null,
-            }
-
-            empty += 1
-            entry.subscription = observable.subscribe({
-              next(value) {
-                if (entry.value === EMPTY) {
-                  empty -= 1
-                }
-
-                entry.value = value
-                dirty = true
-
-                update()
-              },
-              error: _error,
-            })
-
-            active += 1
-            entry.subscription.add(() => {
-              active -= 1
-
-              if (entry.value === EMPTY) {
-                empty -= 1
-              }
-
-              update()
-            })
-
-            if (disposed) {
-              entry.subscription.unsubscribe()
-            } else {
-              curr[n] = entry
-            }
-          }
-        }
-
-        // TODO (perf): start from index where prev[n] is not null.
-        for (let n = 0; n < prevLen; n++) {
-          prev[n]?.subscription?.unsubscribe()
-        }
-
-        update()
-      },
-      complete: () => {
-        active -= 1
-        update()
-      },
-      error: _error,
-    })
-
-    return () => {
-      disposed = true
-
-      for (const entry of curr) {
-        entry?.subscription?.unsubscribe()
-      }
-
-      subscription.unsubscribe()
-    }
-  })
-}
-
-Observable.prototype.combineMap = combineMapImpl
-
-export default function combineMap(project, equals) {
-  return (o) => combineMapImpl.call(o, project, equals)
-}

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>