@highstate/designer 0.4.5 → 0.4.6

package/.output/server/node_modules/@szmarczak/http-timer/dist/source/index.js

@@ -1,126 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const defer_to_connect_1 = require("defer-to-connect");
-const util_1 = require("util");
-const nodejsMajorVersion = Number(process.versions.node.split('.')[0]);
-const timer = (request) => {
-    if (request.timings) {
-        return request.timings;
-    }
-    const timings = {
-        start: Date.now(),
-        socket: undefined,
-        lookup: undefined,
-        connect: undefined,
-        secureConnect: undefined,
-        upload: undefined,
-        response: undefined,
-        end: undefined,
-        error: undefined,
-        abort: undefined,
-        phases: {
-            wait: undefined,
-            dns: undefined,
-            tcp: undefined,
-            tls: undefined,
-            request: undefined,
-            firstByte: undefined,
-            download: undefined,
-            total: undefined
-        }
-    };
-    request.timings = timings;
-    const handleError = (origin) => {
-        const emit = origin.emit.bind(origin);
-        origin.emit = (event, ...args) => {
-            // Catches the `error` event
-            if (event === 'error') {
-                timings.error = Date.now();
-                timings.phases.total = timings.error - timings.start;
-                origin.emit = emit;
-            }
-            // Saves the original behavior
-            return emit(event, ...args);
-        };
-    };
-    handleError(request);
-    const onAbort = () => {
-        timings.abort = Date.now();
-        // Let the `end` response event be responsible for setting the total phase,
-        // unless the Node.js major version is >= 13.
-        if (!timings.response || nodejsMajorVersion >= 13) {
-            timings.phases.total = Date.now() - timings.start;
-        }
-    };
-    request.prependOnceListener('abort', onAbort);
-    const onSocket = (socket) => {
-        timings.socket = Date.now();
-        timings.phases.wait = timings.socket - timings.start;
-        if (util_1.types.isProxy(socket)) {
-            return;
-        }
-        const lookupListener = () => {
-            timings.lookup = Date.now();
-            timings.phases.dns = timings.lookup - timings.socket;
-        };
-        socket.prependOnceListener('lookup', lookupListener);
-        defer_to_connect_1.default(socket, {
-            connect: () => {
-                timings.connect = Date.now();
-                if (timings.lookup === undefined) {
-                    socket.removeListener('lookup', lookupListener);
-                    timings.lookup = timings.connect;
-                    timings.phases.dns = timings.lookup - timings.socket;
-                }
-                timings.phases.tcp = timings.connect - timings.lookup;
-                // This callback is called before flushing any data,
-                // so we don't need to set `timings.phases.request` here.
-            },
-            secureConnect: () => {
-                timings.secureConnect = Date.now();
-                timings.phases.tls = timings.secureConnect - timings.connect;
-            }
-        });
-    };
-    if (request.socket) {
-        onSocket(request.socket);
-    }
-    else {
-        request.prependOnceListener('socket', onSocket);
-    }
-    const onUpload = () => {
-        var _a;
-        timings.upload = Date.now();
-        timings.phases.request = timings.upload - ((_a = timings.secureConnect) !== null && _a !== void 0 ? _a : timings.connect);
-    };
-    const writableFinished = () => {
-        if (typeof request.writableFinished === 'boolean') {
-            return request.writableFinished;
-        }
-        // Node.js doesn't have `request.writableFinished` property
-        return request.finished && request.outputSize === 0 && (!request.socket || request.socket.writableLength === 0);
-    };
-    if (writableFinished()) {
-        onUpload();
-    }
-    else {
-        request.prependOnceListener('finish', onUpload);
-    }
-    request.prependOnceListener('response', (response) => {
-        timings.response = Date.now();
-        timings.phases.firstByte = timings.response - timings.upload;
-        response.timings = timings;
-        handleError(response);
-        response.prependOnceListener('end', () => {
-            timings.end = Date.now();
-            timings.phases.download = timings.end - timings.response;
-            timings.phases.total = timings.end - timings.start;
-        });
-        response.prependOnceListener('aborted', onAbort);
-    });
-    return timings;
-};
-exports.default = timer;
-// For CommonJS default export support
-module.exports = timer;
-module.exports.default = timer;

package/.output/server/node_modules/@szmarczak/http-timer/package.json

@@ -1,72 +0,0 @@
-{
-  "name": "@szmarczak/http-timer",
-  "version": "4.0.6",
-  "description": "Timings for HTTP requests",
-  "main": "dist/source",
-  "engines": {
-    "node": ">=10"
-  },
-  "scripts": {
-    "test": "xo && tsc --noEmit && nyc ava",
-    "build": "del-cli dist && tsc",
-    "prepare": "npm run build",
-    "coveralls": "nyc report --reporter=text-lcov | coveralls"
-  },
-  "files": [
-    "dist/source"
-  ],
-  "keywords": [
-    "http",
-    "https",
-    "timer",
-    "timings"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/szmarczak/http-timer.git"
-  },
-  "author": "Szymon Marczak",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/szmarczak/http-timer/issues"
-  },
-  "homepage": "https://github.com/szmarczak/http-timer#readme",
-  "dependencies": {
-    "defer-to-connect": "^2.0.0"
-  },
-  "devDependencies": {
-    "@ava/typescript": "^2.0.0",
-    "@sindresorhus/tsconfig": "^1.0.2",
-    "@types/node": "^16.3.1",
-    "ava": "^3.15.0",
-    "coveralls": "^3.1.1",
-    "del-cli": "^3.0.1",
-    "http2-wrapper": "^2.0.7",
-    "nyc": "^15.1.0",
-    "p-event": "^4.2.0",
-    "typescript": "^4.3.5",
-    "xo": "^0.39.1"
-  },
-  "types": "dist/source",
-  "nyc": {
-    "extension": [
-      ".ts"
-    ],
-    "exclude": [
-      "**/tests/**"
-    ]
-  },
-  "xo": {
-    "rules": {
-      "@typescript-eslint/no-non-null-assertion": "off"
-    }
-  },
-  "ava": {
-    "typescript": {
-      "compile": false,
-      "rewritePaths": {
-        "tests/": "dist/tests/"
-      }
-    }
-  }
-}

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

@@ -1,420 +0,0 @@
-'use strict'
-
-const combineErrors = require('maybe-combine-errors')
-const ModuleError = require('module-error')
-const { getOptions, emptyOptions, noop } = require('./lib/common')
-const { prefixDescendantKey, isDescendant } = require('./lib/prefixes')
-const { PrewriteBatch } = require('./lib/prewrite-batch')
-
-const kStatus = Symbol('status')
-const kPublicOperations = Symbol('publicOperations')
-const kLegacyOperations = Symbol('legacyOperations')
-const kPrivateOperations = Symbol('privateOperations')
-const kClosePromise = Symbol('closePromise')
-const kLength = Symbol('length')
-const kPrewriteRun = Symbol('prewriteRun')
-const kPrewriteBatch = Symbol('prewriteBatch')
-const kPrewriteData = Symbol('prewriteData')
-const kAddMode = Symbol('addMode')
-
-class AbstractChainedBatch {
-  constructor (db, options) {
-    if (typeof db !== 'object' || db === null) {
-      const hint = db === null ? 'null' : typeof db
-      throw new TypeError(`The first argument must be an abstract-level database, received ${hint}`)
-    }
-
-    const enableWriteEvent = db.listenerCount('write') > 0
-    const enablePrewriteHook = !db.hooks.prewrite.noop
-
-    // Operations for write event. We can skip populating this array (and cloning of
-    // operations, which is the expensive part) if there are 0 write event listeners.
-    this[kPublicOperations] = enableWriteEvent ? [] : null
-
-    // Operations for legacy batch event. If user opted-in to write event or prewrite
-    // hook, skip legacy batch event. We can't skip the batch event based on listener
-    // count, because a listener may be added between put() or del() and write().
-    this[kLegacyOperations] = enableWriteEvent || enablePrewriteHook ? null : []
-
-    this[kLength] = 0
-    this[kStatus] = 'open'
-    this[kClosePromise] = null
-    this[kAddMode] = getOptions(options, emptyOptions).add === true
-
-    if (enablePrewriteHook) {
-      // Use separate arrays to collect operations added by hook functions, because
-      // we wait to apply those until write(). Store these arrays in PrewriteData which
-      // exists to separate internal data from the public PrewriteBatch interface.
-      const data = new PrewriteData([], enableWriteEvent ? [] : null)
-
-      this[kPrewriteData] = data
-      this[kPrewriteBatch] = new PrewriteBatch(db, data[kPrivateOperations], data[kPublicOperations])
-      this[kPrewriteRun] = db.hooks.prewrite.run // TODO: document why
-    } else {
-      this[kPrewriteData] = null
-      this[kPrewriteBatch] = null
-      this[kPrewriteRun] = null
-    }
-
-    this.db = db
-    this.db.attachResource(this)
-  }
-
-  get length () {
-    if (this[kPrewriteData] !== null) {
-      return this[kLength] + this[kPrewriteData].length
-    } else {
-      return this[kLength]
-    }
-  }
-
-  put (key, value, options) {
-    assertStatus(this)
-    options = getOptions(options, emptyOptions)
-
-    const delegated = options.sublevel != null
-    const db = delegated ? options.sublevel : this.db
-    const original = options
-    const keyError = db._checkKey(key)
-    const valueError = db._checkValue(value)
-
-    if (keyError != null) throw keyError
-    if (valueError != null) throw valueError
-
-    // Avoid spread operator because of https://bugs.chromium.org/p/chromium/issues/detail?id=1204540
-    const op = Object.assign({}, options, {
-      type: 'put',
-      key,
-      value,
-      keyEncoding: db.keyEncoding(options.keyEncoding),
-      valueEncoding: db.valueEncoding(options.valueEncoding)
-    })
-
-    if (this[kPrewriteRun] !== null) {
-      try {
-        // Note: we could have chosen to recurse here so that prewriteBatch.put() would
-        // call this.put(). But then operations added by hook functions would be inserted
-        // before rather than after user operations. Instead we process those operations
-        // lazily in write(). This does hurt the only performance benefit benefit of a
-        // chained batch though, which is that it avoids blocking the event loop with
-        // more than one operation at a time. On the other hand, if operations added by
-        // hook functions are adjacent (i.e. sorted) committing them should be faster.
-        this[kPrewriteRun](op, this[kPrewriteBatch])
-
-        // Normalize encodings again in case they were modified
-        op.keyEncoding = db.keyEncoding(op.keyEncoding)
-        op.valueEncoding = db.valueEncoding(op.valueEncoding)
-      } catch (err) {
-        throw new ModuleError('The prewrite hook failed on batch.put()', {
-          code: 'LEVEL_HOOK_ERROR',
-          cause: err
-        })
-      }
-    }
-
-    // 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
-
-    const valueEncoding = op.valueEncoding
-    const encodedValue = valueEncoding.encode(op.value)
-    const valueFormat = valueEncoding.format
-
-    // Only prefix once
-    if (delegated && !siblings) {
-      op.sublevel = null
-    }
-
-    // If the sublevel is not a descendant then we shouldn't emit events
-    if (this[kPublicOperations] !== null && !siblings) {
-      // Clone op before we mutate it for the private API
-      const publicOperation = Object.assign({}, op)
-      publicOperation.encodedKey = encodedKey
-      publicOperation.encodedValue = encodedValue
-
-      if (delegated) {
-        // Ensure emitted data makes sense in the context of this db
-        publicOperation.key = encodedKey
-        publicOperation.value = encodedValue
-        publicOperation.keyEncoding = this.db.keyEncoding(keyFormat)
-        publicOperation.valueEncoding = this.db.valueEncoding(valueFormat)
-      }
-
-      this[kPublicOperations].push(publicOperation)
-    } else if (this[kLegacyOperations] !== null && !siblings) {
-      const legacyOperation = Object.assign({}, original)
-
-      legacyOperation.type = 'put'
-      legacyOperation.key = key
-      legacyOperation.value = value
-
-      this[kLegacyOperations].push(legacyOperation)
-    }
-
-    // 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.value = encodedValue
-    op.keyEncoding = keyFormat
-    op.valueEncoding = valueFormat
-
-    if (this[kAddMode]) {
-      this._add(op)
-    } else {
-      // This "operation as options" trick avoids further cloning
-      this._put(op.key, encodedValue, op)
-    }
-
-    // Increment only on success
-    this[kLength]++
-    return this
-  }
-
-  _put (key, value, options) {}
-
-  del (key, options) {
-    assertStatus(this)
-    options = getOptions(options, emptyOptions)
-
-    const delegated = options.sublevel != null
-    const db = delegated ? options.sublevel : this.db
-    const original = options
-    const keyError = db._checkKey(key)
-
-    if (keyError != null) throw keyError
-
-    // Avoid spread operator because of https://bugs.chromium.org/p/chromium/issues/detail?id=1204540
-    const op = Object.assign({}, options, {
-      type: 'del',
-      key,
-      keyEncoding: db.keyEncoding(options.keyEncoding)
-    })
-
-    if (this[kPrewriteRun] !== null) {
-      try {
-        this[kPrewriteRun](op, this[kPrewriteBatch])
-
-        // Normalize encoding again in case it was modified
-        op.keyEncoding = db.keyEncoding(op.keyEncoding)
-      } catch (err) {
-        throw new ModuleError('The prewrite hook failed on batch.del()', {
-          code: 'LEVEL_HOOK_ERROR',
-          cause: err
-        })
-      }
-    }
-
-    // Encode data for private API
-    const keyEncoding = op.keyEncoding
-    const preencodedKey = keyEncoding.encode(op.key)
-    const keyFormat = keyEncoding.format
-    const encodedKey = delegated ? prefixDescendantKey(preencodedKey, keyFormat, db, this.db) : preencodedKey
-
-    // Prevent double prefixing
-    if (delegated) op.sublevel = null
-
-    if (this[kPublicOperations] !== null) {
-      // Clone op before we mutate it for the private API
-      const publicOperation = Object.assign({}, 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[kPublicOperations].push(publicOperation)
-    } else if (this[kLegacyOperations] !== null) {
-      const legacyOperation = Object.assign({}, original)
-
-      legacyOperation.type = 'del'
-      legacyOperation.key = key
-
-      this[kLegacyOperations].push(legacyOperation)
-    }
-
-    op.key = this.db.prefixKey(encodedKey, keyFormat, true)
-    op.keyEncoding = keyFormat
-
-    if (this[kAddMode]) {
-      this._add(op)
-    } else {
-      // This "operation as options" trick avoids further cloning
-      this._del(op.key, op)
-    }
-
-    // Increment only on success
-    this[kLength]++
-    return this
-  }
-
-  _del (key, options) {}
-
-  _add (op) {}
-
-  clear () {
-    assertStatus(this)
-    this._clear()
-
-    if (this[kPublicOperations] !== null) this[kPublicOperations] = []
-    if (this[kLegacyOperations] !== null) this[kLegacyOperations] = []
-    if (this[kPrewriteData] !== null) this[kPrewriteData].clear()
-
-    this[kLength] = 0
-    return this
-  }
-
-  _clear () {}
-
-  async write (options) {
-    assertStatus(this)
-    options = getOptions(options)
-
-    if (this[kLength] === 0) {
-      return this.close()
-    } else {
-      this[kStatus] = 'writing'
-
-      // Prepare promise in case close() is called in the mean time
-      const close = prepareClose(this)
-
-      try {
-        // Process operations added by prewrite hook functions
-        if (this[kPrewriteData] !== null) {
-          const publicOperations = this[kPrewriteData][kPublicOperations]
-          const privateOperations = this[kPrewriteData][kPrivateOperations]
-          const length = this[kPrewriteData].length
-
-          for (let i = 0; i < length; i++) {
-            const op = privateOperations[i]
-
-            // We can _add(), _put() or _del() even though status is now 'writing' because
-            // status isn't exposed to the private API, so there's no difference in state
-            // from that perspective, unless an implementation overrides the public write()
-            // method at its own risk.
-            if (this[kAddMode]) {
-              this._add(op)
-            } else if (op.type === 'put') {
-              this._put(op.key, op.value, op)
-            } else {
-              this._del(op.key, op)
-            }
-          }
-
-          if (publicOperations !== null && length !== 0) {
-            this[kPublicOperations] = this[kPublicOperations].concat(publicOperations)
-          }
-        }
-
-        await this._write(options)
-      } catch (err) {
-        close()
-
-        try {
-          await this[kClosePromise]
-        } catch (closeErr) {
-          // eslint-disable-next-line no-ex-assign
-          err = combineErrors([err, closeErr])
-        }
-
-        throw err
-      }
-
-      close()
-
-      // Emit after initiating the closing, because event may trigger a
-      // db close which in turn triggers (idempotently) closing this batch.
-      if (this[kPublicOperations] !== null) {
-        this.db.emit('write', this[kPublicOperations])
-      } else if (this[kLegacyOperations] !== null) {
-        this.db.emit('batch', this[kLegacyOperations])
-      }
-
-      return this[kClosePromise]
-    }
-  }
-
-  async _write (options) {}
-
-  async close () {
-    if (this[kClosePromise] !== null) {
-      // First caller of close() or write() is responsible for error
-      return this[kClosePromise].catch(noop)
-    } else {
-      // Wrap promise to avoid race issues on recursive calls
-      prepareClose(this)()
-      return this[kClosePromise]
-    }
-  }
-
-  async _close () {}
-}
-
-const prepareClose = function (batch) {
-  let close
-
-  batch[kClosePromise] = new Promise((resolve, reject) => {
-    close = () => {
-      privateClose(batch).then(resolve, reject)
-    }
-  })
-
-  return close
-}
-
-const privateClose = async function (batch) {
-  batch[kStatus] = 'closing'
-  await batch._close()
-  batch.db.detachResource(batch)
-}
-
-class PrewriteData {
-  constructor (privateOperations, publicOperations) {
-    this[kPrivateOperations] = privateOperations
-    this[kPublicOperations] = publicOperations
-  }
-
-  get length () {
-    return this[kPrivateOperations].length
-  }
-
-  clear () {
-    // Clear operation arrays if present.
-    for (const k of [kPublicOperations, kPrivateOperations]) {
-      const ops = this[k]
-
-      if (ops !== null) {
-        // Keep array alive because PrewriteBatch has a reference to it
-        ops.splice(0, ops.length)
-      }
-    }
-  }
-}
-
-const assertStatus = function (batch) {
-  if (batch[kStatus] !== 'open') {
-    throw new ModuleError('Batch is not open: cannot change operations after write() or close()', {
-      code: 'LEVEL_BATCH_NOT_OPEN'
-    })
-  }
-
-  // Can technically be removed, because it's no longer possible to call db.batch() when
-  // status is not 'open', and db.close() closes the batch. Keep for now, in case of
-  // unforseen userland behaviors.
-  if (batch.db.status !== 'open') {
-    /* istanbul ignore next */
-    throw new ModuleError('Database is not open', {
-      code: 'LEVEL_DATABASE_NOT_OPEN'
-    })
-  }
-}
-
-exports.AbstractChainedBatch = AbstractChainedBatch