nolo-cli 0.108.0-alpha.2 → 0.108.0

package/node_modules/abstract-level/lib/default-kv-iterator.js

@@ -0,0 +1,74 @@
+'use strict'
+
+const { AbstractKeyIterator, AbstractValueIterator } = require('../abstract-iterator')
+
+const kIterator = Symbol('iterator')
+const kHandleOne = Symbol('handleOne')
+const kHandleMany = Symbol('handleMany')
+
+class DefaultKeyIterator extends AbstractKeyIterator {
+  constructor (db, options) {
+    super(db, options)
+
+    this[kIterator] = db.iterator({ ...options, keys: true, values: false })
+  }
+
+  [kHandleOne] (entry) {
+    return entry[0]
+  }
+
+  [kHandleMany] (entries) {
+    for (let i = 0; i < entries.length; i++) {
+      entries[i] = entries[i][0]
+    }
+  }
+}
+
+class DefaultValueIterator extends AbstractValueIterator {
+  constructor (db, options) {
+    super(db, options)
+
+    this[kIterator] = db.iterator({ ...options, keys: false, values: true })
+  }
+
+  [kHandleOne] (entry) {
+    return entry[1]
+  }
+
+  [kHandleMany] (entries) {
+    for (let i = 0; i < entries.length; i++) {
+      entries[i] = entries[i][1]
+    }
+  }
+}
+
+for (const Iterator of [DefaultKeyIterator, DefaultValueIterator]) {
+  Iterator.prototype._next = async function () {
+    const entry = await this[kIterator].next()
+    return entry === undefined ? entry : this[kHandleOne](entry)
+  }
+
+  Iterator.prototype._nextv = async function (size, options) {
+    const entries = await this[kIterator].nextv(size, options)
+    this[kHandleMany](entries)
+    return entries
+  }
+
+  Iterator.prototype._all = async function (options) {
+    const entries = await this[kIterator].all(options)
+    this[kHandleMany](entries)
+    return entries
+  }
+
+  Iterator.prototype._seek = function (target, options) {
+    this[kIterator].seek(target, options)
+  }
+
+  Iterator.prototype._close = async function () {
+    return this[kIterator].close()
+  }
+}
+
+// Internal utilities, should be typed as AbstractKeyIterator and AbstractValueIterator
+exports.DefaultKeyIterator = DefaultKeyIterator
+exports.DefaultValueIterator = DefaultValueIterator

package/node_modules/abstract-level/lib/deferred-iterator.js

@@ -0,0 +1,110 @@
+'use strict'
+
+const { AbstractIterator, AbstractKeyIterator, AbstractValueIterator } = require('../abstract-iterator')
+const ModuleError = require('module-error')
+
+const kNut = Symbol('nut')
+const kUndefer = Symbol('undefer')
+const kFactory = Symbol('factory')
+const kSignalOptions = Symbol('signalOptions')
+
+class DeferredIterator extends AbstractIterator {
+  constructor (db, options) {
+    super(db, options)
+
+    this[kNut] = null
+    this[kFactory] = () => db.iterator(options)
+    this[kSignalOptions] = { signal: options.signal }
+
+    this.db.defer(() => this[kUndefer](), this[kSignalOptions])
+  }
+}
+
+class DeferredKeyIterator extends AbstractKeyIterator {
+  constructor (db, options) {
+    super(db, options)
+
+    this[kNut] = null
+    this[kFactory] = () => db.keys(options)
+    this[kSignalOptions] = { signal: options.signal }
+
+    this.db.defer(() => this[kUndefer](), this[kSignalOptions])
+  }
+}
+
+class DeferredValueIterator extends AbstractValueIterator {
+  constructor (db, options) {
+    super(db, options)
+
+    this[kNut] = null
+    this[kFactory] = () => db.values(options)
+    this[kSignalOptions] = { signal: options.signal }
+
+    this.db.defer(() => this[kUndefer](), this[kSignalOptions])
+  }
+}
+
+for (const Iterator of [DeferredIterator, DeferredKeyIterator, DeferredValueIterator]) {
+  Iterator.prototype[kUndefer] = function () {
+    if (this.db.status === 'open') {
+      this[kNut] = this[kFactory]()
+    }
+  }
+
+  Iterator.prototype._next = async function () {
+    if (this[kNut] !== null) {
+      return this[kNut].next()
+    } else if (this.db.status === 'opening') {
+      return this.db.deferAsync(() => this._next(), this[kSignalOptions])
+    } else {
+      throw new ModuleError('Iterator is not open: cannot call next() after close()', {
+        code: 'LEVEL_ITERATOR_NOT_OPEN'
+      })
+    }
+  }
+
+  Iterator.prototype._nextv = async function (size, options) {
+    if (this[kNut] !== null) {
+      return this[kNut].nextv(size, options)
+    } else if (this.db.status === 'opening') {
+      return this.db.deferAsync(() => this._nextv(size, options), this[kSignalOptions])
+    } else {
+      throw new ModuleError('Iterator is not open: cannot call nextv() after close()', {
+        code: 'LEVEL_ITERATOR_NOT_OPEN'
+      })
+    }
+  }
+
+  Iterator.prototype._all = async function (options) {
+    if (this[kNut] !== null) {
+      return this[kNut].all()
+    } else if (this.db.status === 'opening') {
+      return this.db.deferAsync(() => this._all(options), this[kSignalOptions])
+    } else {
+      throw new ModuleError('Iterator is not open: cannot call all() after close()', {
+        code: 'LEVEL_ITERATOR_NOT_OPEN'
+      })
+    }
+  }
+
+  Iterator.prototype._seek = function (target, options) {
+    if (this[kNut] !== null) {
+      // TODO: explain why we need _seek() rather than seek() here
+      this[kNut]._seek(target, options)
+    } else if (this.db.status === 'opening') {
+      this.db.defer(() => this._seek(target, options), this[kSignalOptions])
+    }
+  }
+
+  Iterator.prototype._close = async function () {
+    if (this[kNut] !== null) {
+      return this[kNut].close()
+    } else if (this.db.status === 'opening') {
+      return this.db.deferAsync(() => this._close())
+    }
+  }
+}
+
+exports.DeferredIterator = DeferredIterator
+exports.DeferredKeyIterator = DeferredKeyIterator
+exports.DeferredValueIterator = DeferredValueIterator

package/node_modules/abstract-level/lib/deferred-queue.js

@@ -0,0 +1,84 @@
+'use strict'
+
+const { getOptions, emptyOptions } = require('./common')
+const { AbortError } = require('./errors')
+
+class DeferredOperation {
+  constructor (fn, signal) {
+    this.fn = fn
+    this.signal = signal
+  }
+}
+
+class DeferredQueue {
+  #operations
+  #signals
+
+  constructor () {
+    this.#operations = []
+    this.#signals = new Set()
+  }
+
+  add (fn, options) {
+    options = getOptions(options, emptyOptions)
+    const signal = options.signal
+
+    if (signal == null) {
+      this.#operations.push(new DeferredOperation(fn, null))
+      return
+    }
+
+    if (signal.aborted) {
+      // Note that this is called in the same tick
+      fn(new AbortError())
+      return
+    }
+
+    if (!this.#signals.has(signal)) {
+      this.#signals.add(signal)
+      signal.addEventListener('abort', this.#handleAbort, { once: true })
+    }
+
+    this.#operations.push(new DeferredOperation(fn, signal))
+  }
+
+  drain () {
+    const operations = this.#operations
+    const signals = this.#signals
+
+    this.#operations = []
+    this.#signals = new Set()
+
+    for (const signal of signals) {
+      signal.removeEventListener('abort', this.#handleAbort)
+    }
+
+    for (const operation of operations) {
+      operation.fn.call(null)
+    }
+  }
+
+  #handleAbort = (ev) => {
+    const signal = ev.target
+    const err = new AbortError()
+    const aborted = []
+
+    // TODO: optimize
+    this.#operations = this.#operations.filter(function (operation) {
+      if (operation.signal !== null && operation.signal === signal) {
+        aborted.push(operation)
+        return false
+      } else {
+        return true
+      }
+    })
+
+    this.#signals.delete(signal)
+
+    for (const operation of aborted) {
+      operation.fn.call(null, err)
+    }
+  }
+}
+
+exports.DeferredQueue = DeferredQueue

package/node_modules/abstract-level/lib/errors.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const ModuleError = require('module-error')
+
+class AbortError extends ModuleError {
+  constructor (cause) {
+    super('Operation has been aborted', {
+      code: 'LEVEL_ABORTED',
+      cause
+    })
+  }
+
+  // Set name to AbortError for web compatibility. See:
+  // https://dom.spec.whatwg.org/#aborting-ongoing-activities
+  // https://github.com/nodejs/node/pull/35911#discussion_r515779306
+  get name () {
+    return 'AbortError'
+  }
+}
+
+exports.AbortError = AbortError

package/node_modules/abstract-level/lib/event-monitor.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const { deprecate } = require('./common')
+
+exports.EventMonitor = class EventMonitor {
+  constructor (emitter) {
+    // Track whether listeners are present, because checking
+    // a boolean is faster than checking listenerCount().
+    this.write = false
+
+    const beforeAdded = (name) => {
+      if (name === 'write') {
+        this.write = true
+      }
+
+      if (name === 'put' || name === 'del' || name === 'batch') {
+        deprecate(`The '${name}' event has been removed in favor of 'write'`)
+      }
+    }
+
+    const afterRemoved = (name) => {
+      if (name === 'write') {
+        this.write = emitter.listenerCount('write') > 0
+      }
+    }
+
+    emitter.on('newListener', beforeAdded)
+    emitter.on('removeListener', afterRemoved)
+  }
+}

package/node_modules/abstract-level/lib/hooks.js

@@ -0,0 +1,78 @@
+'use strict'
+
+const { noop } = require('./common')
+
+class DatabaseHooks {
+  constructor () {
+    this.postopen = new Hook({ async: true })
+    this.prewrite = new Hook({ async: false })
+    this.newsub = new Hook({ async: false })
+  }
+}
+
+class Hook {
+  #functions = new Set()
+  #isAsync
+
+  constructor (options) {
+    this.#isAsync = options.async
+
+    // Offer a fast way to check if hook functions are present. We could also expose a
+    // size getter, which would be slower, or check it by hook.run !== noop, which would
+    // not allow userland to do the same check.
+    this.noop = true
+    this.run = this.#runner()
+  }
+
+  add (fn) {
+    // Validate now rather than in asynchronous code paths
+    assertFunction(fn)
+    this.#functions.add(fn)
+    this.noop = false
+    this.run = this.#runner()
+  }
+
+  delete (fn) {
+    assertFunction(fn)
+    this.#functions.delete(fn)
+    this.noop = this.#functions.size === 0
+    this.run = this.#runner()
+  }
+
+  #runner () {
+    if (this.noop) {
+      return noop
+    } else if (this.#functions.size === 1) {
+      const [fn] = this.#functions
+      return fn
+    } else if (this.#isAsync) {
+      // The run function should not reference hook, so that consumers like chained batch
+      // and db.open() can save a reference to hook.run and safely assume it won't change
+      // during their lifetime or async work.
+      const run = async function (functions, ...args) {
+        for (const fn of functions) {
+          await fn(...args)
+        }
+      }
+
+      return run.bind(null, Array.from(this.#functions))
+    } else {
+      const run = function (functions, ...args) {
+        for (const fn of functions) {
+          fn(...args)
+        }
+      }
+
+      return run.bind(null, Array.from(this.#functions))
+    }
+  }
+}
+
+const assertFunction = function (fn) {
+  if (typeof fn !== 'function') {
+    const hint = fn === null ? 'null' : typeof fn
+    throw new TypeError(`The first argument must be a function, received ${hint}`)
+  }
+}
+
+exports.DatabaseHooks = DatabaseHooks

package/node_modules/abstract-level/lib/prefixes.js

@@ -0,0 +1,21 @@
+'use strict'
+
+exports.prefixDescendantKey = function (key, keyFormat, descendant, ancestor) {
+  while (descendant !== null && descendant !== ancestor) {
+    key = descendant.prefixKey(key, keyFormat, true)
+    descendant = descendant.parent
+  }
+
+  return key
+}
+
+// Check if db is a descendant of ancestor
+// TODO: optimize, when used alongside prefixDescendantKey
+// which means we visit parents twice.
+exports.isDescendant = function (db, ancestor) {
+  while (true) {
+    if (db.parent == null) return false
+    if (db.parent === ancestor) return true
+    db = db.parent
+  }
+}

package/node_modules/abstract-level/lib/prewrite-batch.js

@@ -0,0 +1,96 @@
+'use strict'
+
+const { prefixDescendantKey, isDescendant } = require('./prefixes')
+
+// An interface for prewrite hook functions to add operations
+class PrewriteBatch {
+  #db
+  #privateOperations
+  #publicOperations
+
+  constructor (db, privateOperations, publicOperations) {
+    this.#db = db
+
+    // Note: if for db.batch([]), these arrays include input operations (or empty slots
+    // for them) but if for chained batch then it does not. Small implementation detail.
+    this.#privateOperations = privateOperations
+    this.#publicOperations = publicOperations
+  }
+
+  add (op) {
+    const isPut = op.type === 'put'
+    const delegated = op.sublevel != null
+    const db = delegated ? op.sublevel : this.#db
+
+    db._assertValidKey(op.key)
+    op.keyEncoding = db.keyEncoding(op.keyEncoding)
+
+    if (isPut) {
+      db._assertValidValue(op.value)
+      op.valueEncoding = db.valueEncoding(op.valueEncoding)
+    } else if (op.type !== 'del') {
+      throw new TypeError("A batch operation must have a type property that is 'put' or 'del'")
+    }
+
+    // Encode data for private API
+    const keyEncoding = op.keyEncoding
+    const preencodedKey = keyEncoding.encode(op.key)
+    const keyFormat = keyEncoding.format
+
+    // If the sublevel is not a descendant then forward that option to the parent db
+    // so that we don't erroneously add our own prefix to the key of the operation.
+    const siblings = delegated && !isDescendant(op.sublevel, this.#db) && op.sublevel !== this.#db
+    const encodedKey = delegated && !siblings
+      ? prefixDescendantKey(preencodedKey, keyFormat, db, this.#db)
+      : preencodedKey
+
+    // Only prefix once
+    if (delegated && !siblings) {
+      op.sublevel = null
+    }
+
+    let publicOperation = null
+
+    // If the sublevel is not a descendant then we shouldn't emit events
+    if (this.#publicOperations !== null && !siblings) {
+      // Clone op before we mutate it for the private API
+      publicOperation = { ...op }
+      publicOperation.encodedKey = encodedKey
+
+      if (delegated) {
+        // Ensure emitted data makes sense in the context of this.#db
+        publicOperation.key = encodedKey
+        publicOperation.keyEncoding = this.#db.keyEncoding(keyFormat)
+      }
+
+      this.#publicOperations.push(publicOperation)
+    }
+
+    // If we're forwarding the sublevel option then don't prefix the key yet
+    op.key = siblings ? encodedKey : this.#db.prefixKey(encodedKey, keyFormat, true)
+    op.keyEncoding = keyFormat
+
+    if (isPut) {
+      const valueEncoding = op.valueEncoding
+      const encodedValue = valueEncoding.encode(op.value)
+      const valueFormat = valueEncoding.format
+
+      op.value = encodedValue
+      op.valueEncoding = valueFormat
+
+      if (publicOperation !== null) {
+        publicOperation.encodedValue = encodedValue
+
+        if (delegated) {
+          publicOperation.value = encodedValue
+          publicOperation.valueEncoding = this.#db.valueEncoding(valueFormat)
+        }
+      }
+    }
+
+    this.#privateOperations.push(op)
+    return this
+  }
+}
+
+exports.PrewriteBatch = PrewriteBatch

package/node_modules/abstract-level/lib/range-options.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const hasOwnProperty = Object.prototype.hasOwnProperty
+const rangeOptions = new Set(['lt', 'lte', 'gt', 'gte'])
+
+module.exports = function (options, keyEncoding) {
+  const result = {}
+
+  for (const k in options) {
+    if (!hasOwnProperty.call(options, k)) continue
+    if (k === 'keyEncoding' || k === 'valueEncoding') continue
+
+    if (rangeOptions.has(k)) {
+      // Note that we don't reject nullish and empty options here. While
+      // those types are invalid as keys, they are valid as range options.
+      result[k] = keyEncoding.encode(options[k])
+    } else {
+      result[k] = options[k]
+    }
+  }
+
+  result.reverse = !!result.reverse
+  result.limit = Number.isInteger(result.limit) && result.limit >= 0 ? result.limit : -1
+
+  return result
+}

package/node_modules/abstract-level/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "abstract-level",
+  "version": "3.1.1",
+  "description": "Abstract class for a lexicographically sorted key-value database",
+  "license": "MIT",
+  "main": "index.js",
+  "types": "./index.d.ts",
+  "scripts": {
+    "test": "eslint && hallmark && (nyc -s node test/self.js | tap-arc) && nyc report",
+    "test-pessimistic": "node test/self.js | tap-arc -pv",
+    "test-browsers": "airtap --coverage test/self.js",
+    "test-electron": "airtap -p electron --coverage test/self.js | tap-arc",
+    "coverage": "nyc report -r lcovonly"
+  },
+  "files": [
+    "abstract-chained-batch.js",
+    "abstract-iterator.js",
+    "abstract-level.js",
+    "abstract-snapshot.js",
+    "index.js",
+    "index.d.ts",
+    "lib",
+    "test",
+    "types",
+    "CHANGELOG.md",
+    "UPGRADING.md"
+  ],
+  "dependencies": {
+    "buffer": "^6.0.3",
+    "is-buffer": "^2.0.5",
+    "level-supports": "^6.2.0",
+    "level-transcoder": "^1.0.1",
+    "maybe-combine-errors": "^1.0.0",
+    "module-error": "^1.0.1"
+  },
+  "devDependencies": {
+    "@babel/preset-env": "^7.28.3",
+    "@types/node": "^24.6.0",
+    "@voxpelli/tsconfig": "^16.1.0",
+    "airtap": "^5.0.0",
+    "airtap-electron": "^1.0.0",
+    "airtap-playwright": "^1.0.1",
+    "babelify": "^10.0.0",
+    "electron": "^33.2.1",
+    "eslint": "^9.36.0",
+    "hallmark": "^5.0.1",
+    "neostandard": "^0.12.2",
+    "nyc": "^17.1.0",
+    "tap-arc": "^1.3.2",
+    "tape": "^5.9.0",
+    "typescript": "^5.9.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Level/abstract-level.git"
+  },
+  "homepage": "https://github.com/Level/abstract-level",
+  "keywords": [
+    "abstract-level",
+    "level",
+    "leveldb"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}