@highstate/designer 0.4.5 → 0.5.0

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

@@ -1,8 +0,0 @@
-'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

@@ -1,122 +0,0 @@
-'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

@@ -1,269 +0,0 @@
-'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

@@ -1,33 +0,0 @@
-'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

@@ -1,29 +0,0 @@
-'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

@@ -1,74 +0,0 @@
-'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

@@ -1,110 +0,0 @@
-'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