@highstate/designer 0.4.3 → 0.4.5

package/.output/server/node_modules/abstract-level/index.js

@@ -0,0 +1,8 @@
+'use strict'
+
+exports.AbstractLevel = require('./abstract-level').AbstractLevel
+exports.AbstractSublevel = require('./abstract-level').AbstractSublevel
+exports.AbstractIterator = require('./abstract-iterator').AbstractIterator
+exports.AbstractKeyIterator = require('./abstract-iterator').AbstractKeyIterator
+exports.AbstractValueIterator = require('./abstract-iterator').AbstractValueIterator
+exports.AbstractChainedBatch = require('./abstract-chained-batch').AbstractChainedBatch

package/.output/server/node_modules/abstract-level/lib/abstract-sublevel-iterator.js

@@ -0,0 +1,122 @@
+'use strict'
+
+const { AbstractIterator, AbstractKeyIterator, AbstractValueIterator } = require('../abstract-iterator')
+
+const kUnfix = Symbol('unfix')
+const kIterator = Symbol('iterator')
+
+// TODO: unfix natively if db supports it
+class AbstractSublevelIterator extends AbstractIterator {
+  constructor (db, options, iterator, unfix) {
+    super(db, options)
+
+    this[kIterator] = iterator
+    this[kUnfix] = unfix
+  }
+
+  async _next () {
+    const entry = await this[kIterator].next()
+
+    if (entry !== undefined) {
+      const key = entry[0]
+      if (key !== undefined) entry[0] = this[kUnfix](key)
+    }
+
+    return entry
+  }
+
+  async _nextv (size, options) {
+    const entries = await this[kIterator].nextv(size, options)
+    const unfix = this[kUnfix]
+
+    for (const entry of entries) {
+      const key = entry[0]
+      if (key !== undefined) entry[0] = unfix(key)
+    }
+
+    return entries
+  }
+
+  async _all (options) {
+    const entries = await this[kIterator].all(options)
+    const unfix = this[kUnfix]
+
+    for (const entry of entries) {
+      const key = entry[0]
+      if (key !== undefined) entry[0] = unfix(key)
+    }
+
+    return entries
+  }
+}
+
+class AbstractSublevelKeyIterator extends AbstractKeyIterator {
+  constructor (db, options, iterator, unfix) {
+    super(db, options)
+
+    this[kIterator] = iterator
+    this[kUnfix] = unfix
+  }
+
+  async _next () {
+    const key = await this[kIterator].next()
+    return key === undefined ? key : this[kUnfix](key)
+  }
+
+  async _nextv (size, options) {
+    const keys = await this[kIterator].nextv(size, options)
+    const unfix = this[kUnfix]
+
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i]
+      if (key !== undefined) keys[i] = unfix(key)
+    }
+
+    return keys
+  }
+
+  async _all (options) {
+    const keys = await this[kIterator].all(options)
+    const unfix = this[kUnfix]
+
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i]
+      if (key !== undefined) keys[i] = unfix(key)
+    }
+
+    return keys
+  }
+}
+
+class AbstractSublevelValueIterator extends AbstractValueIterator {
+  constructor (db, options, iterator) {
+    super(db, options)
+    this[kIterator] = iterator
+  }
+
+  async _next () {
+    return this[kIterator].next()
+  }
+
+  async _nextv (size, options) {
+    return this[kIterator].nextv(size, options)
+  }
+
+  async _all (options) {
+    return this[kIterator].all(options)
+  }
+}
+
+for (const Iterator of [AbstractSublevelIterator, AbstractSublevelKeyIterator, AbstractSublevelValueIterator]) {
+  Iterator.prototype._seek = function (target, options) {
+    this[kIterator].seek(target, options)
+  }
+
+  Iterator.prototype._close = async function () {
+    return this[kIterator].close()
+  }
+}
+
+exports.AbstractSublevelIterator = AbstractSublevelIterator
+exports.AbstractSublevelKeyIterator = AbstractSublevelKeyIterator
+exports.AbstractSublevelValueIterator = AbstractSublevelValueIterator

package/.output/server/node_modules/abstract-level/lib/abstract-sublevel.js

@@ -0,0 +1,269 @@
+'use strict'
+
+const ModuleError = require('module-error')
+const { Buffer } = require('buffer') || {}
+const {
+  AbstractSublevelIterator,
+  AbstractSublevelKeyIterator,
+  AbstractSublevelValueIterator
+} = require('./abstract-sublevel-iterator')
+
+const kGlobalPrefix = Symbol('prefix')
+const kLocalPrefix = Symbol('localPrefix')
+const kLocalPath = Symbol('localPath')
+const kGlobalPath = Symbol('globalPath')
+const kGlobalUpperBound = Symbol('upperBound')
+const kPrefixRange = Symbol('prefixRange')
+const kRoot = Symbol('root')
+const kParent = Symbol('parent')
+const kUnfix = Symbol('unfix')
+
+const textEncoder = new TextEncoder()
+const defaults = { separator: '!' }
+
+// Wrapped to avoid circular dependency
+module.exports = function ({ AbstractLevel }) {
+  class AbstractSublevel extends AbstractLevel {
+    static defaults (options) {
+      if (options == null) {
+        return defaults
+      } else if (!options.separator) {
+        return { ...options, separator: '!' }
+      } else {
+        return options
+      }
+    }
+
+    // TODO: add autoClose option, which if true, does parent.attachResource(this)
+    constructor (db, name, options) {
+      // Don't forward AbstractSublevel options to AbstractLevel
+      const { separator, manifest, ...forward } = AbstractSublevel.defaults(options)
+      const names = [].concat(name).map(name => trim(name, separator))
+
+      // Reserve one character between separator and name to give us an upper bound
+      const reserved = separator.charCodeAt(0) + 1
+      const root = db[kRoot] || db
+
+      // Keys should sort like ['!a!', '!a!!a!', '!a"', '!aa!', '!b!'].
+      // Use ASCII for consistent length between string, Buffer and Uint8Array
+      if (!names.every(name => textEncoder.encode(name).every(x => x > reserved && x < 127))) {
+        throw new ModuleError(`Sublevel name must use bytes > ${reserved} < ${127}`, {
+          code: 'LEVEL_INVALID_PREFIX'
+        })
+      }
+
+      super(mergeManifests(db, manifest), forward)
+
+      const localPrefix = names.map(name => separator + name + separator).join('')
+      const globalPrefix = (db.prefix || '') + localPrefix
+      const globalUpperBound = globalPrefix.slice(0, -1) + String.fromCharCode(reserved)
+
+      // Most operations are forwarded to the parent database, but clear() and iterators
+      // still forward to the root database - which is older logic and does not yet need
+      // to change, until we add some form of preread or postread hooks.
+      this[kRoot] = root
+      this[kParent] = db
+      this[kLocalPath] = names
+      this[kGlobalPath] = db.prefix ? db.path().concat(names) : names
+      this[kGlobalPrefix] = new MultiFormat(globalPrefix)
+      this[kGlobalUpperBound] = new MultiFormat(globalUpperBound)
+      this[kLocalPrefix] = new MultiFormat(localPrefix)
+      this[kUnfix] = new Unfixer()
+    }
+
+    prefixKey (key, keyFormat, local) {
+      const prefix = local ? this[kLocalPrefix] : this[kGlobalPrefix]
+
+      if (keyFormat === 'utf8') {
+        return prefix.utf8 + key
+      } else if (key.byteLength === 0) {
+        // Fast path for empty key (no copy)
+        return prefix[keyFormat]
+      } else if (keyFormat === 'view') {
+        const view = prefix.view
+        const result = new Uint8Array(view.byteLength + key.byteLength)
+
+        result.set(view, 0)
+        result.set(key, view.byteLength)
+
+        return result
+      } else {
+        const buffer = prefix.buffer
+        return Buffer.concat([buffer, key], buffer.byteLength + key.byteLength)
+      }
+    }
+
+    // Not exposed for now.
+    [kPrefixRange] (range, keyFormat) {
+      if (range.gte !== undefined) {
+        range.gte = this.prefixKey(range.gte, keyFormat, false)
+      } else if (range.gt !== undefined) {
+        range.gt = this.prefixKey(range.gt, keyFormat, false)
+      } else {
+        range.gte = this[kGlobalPrefix][keyFormat]
+      }
+
+      if (range.lte !== undefined) {
+        range.lte = this.prefixKey(range.lte, keyFormat, false)
+      } else if (range.lt !== undefined) {
+        range.lt = this.prefixKey(range.lt, keyFormat, false)
+      } else {
+        range.lte = this[kGlobalUpperBound][keyFormat]
+      }
+    }
+
+    get prefix () {
+      return this[kGlobalPrefix].utf8
+    }
+
+    get db () {
+      return this[kRoot]
+    }
+
+    get parent () {
+      return this[kParent]
+    }
+
+    path (local = false) {
+      return local ? this[kLocalPath] : this[kGlobalPath]
+    }
+
+    async _open (options) {
+      // The parent db must open itself or be (re)opened by the user because
+      // a sublevel should not initiate state changes on the rest of the db.
+      return this[kParent].open({ passive: true })
+    }
+
+    async _put (key, value, options) {
+      return this[kParent].put(key, value, options)
+    }
+
+    async _get (key, options) {
+      return this[kParent].get(key, options)
+    }
+
+    async _getMany (keys, options) {
+      return this[kParent].getMany(keys, options)
+    }
+
+    async _del (key, options) {
+      return this[kParent].del(key, options)
+    }
+
+    async _batch (operations, options) {
+      return this[kParent].batch(operations, options)
+    }
+
+    // TODO: call parent instead of root
+    async _clear (options) {
+      // TODO (refactor): move to AbstractLevel
+      this[kPrefixRange](options, options.keyEncoding)
+      return this[kRoot].clear(options)
+    }
+
+    // TODO: call parent instead of root
+    _iterator (options) {
+      // TODO (refactor): move to AbstractLevel
+      this[kPrefixRange](options, options.keyEncoding)
+      const iterator = this[kRoot].iterator(options)
+      const unfix = this[kUnfix].get(this[kGlobalPrefix].utf8.length, options.keyEncoding)
+      return new AbstractSublevelIterator(this, options, iterator, unfix)
+    }
+
+    _keys (options) {
+      this[kPrefixRange](options, options.keyEncoding)
+      const iterator = this[kRoot].keys(options)
+      const unfix = this[kUnfix].get(this[kGlobalPrefix].utf8.length, options.keyEncoding)
+      return new AbstractSublevelKeyIterator(this, options, iterator, unfix)
+    }
+
+    _values (options) {
+      this[kPrefixRange](options, options.keyEncoding)
+      const iterator = this[kRoot].values(options)
+      return new AbstractSublevelValueIterator(this, options, iterator)
+    }
+  }
+
+  return { AbstractSublevel }
+}
+
+const mergeManifests = function (parent, manifest) {
+  return {
+    // Inherit manifest of parent db
+    ...parent.supports,
+
+    // Disable unsupported features
+    createIfMissing: false,
+    errorIfExists: false,
+
+    // Unset additional events because we're not forwarding them
+    events: {},
+
+    // Unset additional methods (like approximateSize) which we can't support here unless
+    // the AbstractSublevel class is overridden by an implementation of `abstract-level`.
+    additionalMethods: {},
+
+    // Inherit manifest of custom AbstractSublevel subclass. Such a class is not
+    // allowed to override encodings.
+    ...manifest,
+
+    encodings: {
+      utf8: supportsEncoding(parent, 'utf8'),
+      buffer: supportsEncoding(parent, 'buffer'),
+      view: supportsEncoding(parent, 'view')
+    }
+  }
+}
+
+const supportsEncoding = function (parent, encoding) {
+  // Prefer a non-transcoded encoding for optimal performance
+  return parent.supports.encodings[encoding]
+    ? parent.keyEncoding(encoding).name === encoding
+    : false
+}
+
+class MultiFormat {
+  constructor (key) {
+    this.utf8 = key
+    this.view = textEncoder.encode(key)
+    this.buffer = Buffer ? Buffer.from(this.view.buffer, 0, this.view.byteLength) : {}
+  }
+}
+
+class Unfixer {
+  constructor () {
+    this.cache = new Map()
+  }
+
+  get (prefixLength, keyFormat) {
+    let unfix = this.cache.get(keyFormat)
+
+    if (unfix === undefined) {
+      if (keyFormat === 'view') {
+        unfix = function (prefixLength, key) {
+          // Avoid Uint8Array#slice() because it copies
+          return key.subarray(prefixLength)
+        }.bind(null, prefixLength)
+      } else {
+        unfix = function (prefixLength, key) {
+          // Avoid Buffer#subarray() because it's slow
+          return key.slice(prefixLength)
+        }.bind(null, prefixLength)
+      }
+
+      this.cache.set(keyFormat, unfix)
+    }
+
+    return unfix
+  }
+}
+
+const trim = function (str, char) {
+  let start = 0
+  let end = str.length
+
+  while (start < end && str[start] === char) start++
+  while (end > start && str[end - 1] === char) end--
+
+  return str.slice(start, end)
+}

package/.output/server/node_modules/abstract-level/lib/common.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const ModuleError = require('module-error')
+const deprecations = new Set()
+
+exports.getOptions = function (options, def) {
+  if (typeof options === 'object' && options !== null) {
+    return options
+  }
+
+  if (def !== undefined) {
+    return def
+  }
+
+  return {}
+}
+
+exports.emptyOptions = Object.freeze({})
+exports.noop = function () {}
+exports.resolvedPromise = Promise.resolve()
+
+exports.deprecate = function (message) {
+  if (!deprecations.has(message)) {
+    deprecations.add(message)
+
+    // Avoid polyfills
+    const c = globalThis.console
+
+    if (typeof c !== 'undefined' && typeof c.warn === 'function') {
+      c.warn(new ModuleError(message, { code: 'LEVEL_LEGACY' }))
+    }
+  }
+}

package/.output/server/node_modules/abstract-level/lib/default-chained-batch.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const { AbstractChainedBatch } = require('../abstract-chained-batch')
+const kEncoded = Symbol('encoded')
+
+// Functional default for chained batch
+class DefaultChainedBatch extends AbstractChainedBatch {
+  constructor (db) {
+    // Opt-in to _add() instead of _put() and _del()
+    super(db, { add: true })
+    this[kEncoded] = []
+  }
+
+  _add (op) {
+    this[kEncoded].push(op)
+  }
+
+  _clear () {
+    this[kEncoded] = []
+  }
+
+  async _write (options) {
+    // Need to call the private rather than public method, to prevent
+    // recursion, double prefixing, double encoding and double hooks.
+    return this.db._batch(this[kEncoded], options)
+  }
+}
+
+exports.DefaultChainedBatch = DefaultChainedBatch

package/.output/server/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/.output/server/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