uomtiles 0.1.3 → 0.1.6

package/.output/server/node_modules/undici/lib/api/api-request.js

@@ -1,214 +0,0 @@
-'use strict'
-
-const assert = require('node:assert')
-const { AsyncResource } = require('node:async_hooks')
-const { Readable } = require('./readable')
-const { InvalidArgumentError, RequestAbortedError } = require('../core/errors')
-const util = require('../core/util')
-
-function noop () {}
-
-class RequestHandler extends AsyncResource {
-  constructor (opts, callback) {
-    if (!opts || typeof opts !== 'object') {
-      throw new InvalidArgumentError('invalid opts')
-    }
-
-    const { signal, method, opaque, body, onInfo, responseHeaders, highWaterMark } = opts
-
-    try {
-      if (typeof callback !== 'function') {
-        throw new InvalidArgumentError('invalid callback')
-      }
-
-      if (highWaterMark != null && (!Number.isFinite(highWaterMark) || highWaterMark < 0)) {
-        throw new InvalidArgumentError('invalid highWaterMark')
-      }
-
-      if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') {
-        throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget')
-      }
-
-      if (method === 'CONNECT') {
-        throw new InvalidArgumentError('invalid method')
-      }
-
-      if (onInfo && typeof onInfo !== 'function') {
-        throw new InvalidArgumentError('invalid onInfo callback')
-      }
-
-      super('UNDICI_REQUEST')
-    } catch (err) {
-      if (util.isStream(body)) {
-        util.destroy(body.on('error', noop), err)
-      }
-      throw err
-    }
-
-    this.method = method
-    this.responseHeaders = responseHeaders || null
-    this.opaque = opaque || null
-    this.callback = callback
-    this.res = null
-    this.abort = null
-    this.body = body
-    this.trailers = {}
-    this.context = null
-    this.onInfo = onInfo || null
-    this.highWaterMark = highWaterMark
-    this.reason = null
-    this.removeAbortListener = null
-
-    if (signal?.aborted) {
-      this.reason = signal.reason ?? new RequestAbortedError()
-    } else if (signal) {
-      this.removeAbortListener = util.addAbortListener(signal, () => {
-        this.reason = signal.reason ?? new RequestAbortedError()
-        if (this.res) {
-          util.destroy(this.res.on('error', noop), this.reason)
-        } else if (this.abort) {
-          this.abort(this.reason)
-        }
-      })
-    }
-  }
-
-  onConnect (abort, context) {
-    if (this.reason) {
-      abort(this.reason)
-      return
-    }
-
-    assert(this.callback)
-
-    this.abort = abort
-    this.context = context
-  }
-
-  onHeaders (statusCode, rawHeaders, resume, statusMessage) {
-    const { callback, opaque, abort, context, responseHeaders, highWaterMark } = this
-
-    const headers = responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
-
-    if (statusCode < 200) {
-      if (this.onInfo) {
-        this.onInfo({ statusCode, headers })
-      }
-      return
-    }
-
-    const parsedHeaders = responseHeaders === 'raw' ? util.parseHeaders(rawHeaders) : headers
-    const contentType = parsedHeaders['content-type']
-    const contentLength = parsedHeaders['content-length']
-    const res = new Readable({
-      resume,
-      abort,
-      contentType,
-      contentLength: this.method !== 'HEAD' && contentLength
-        ? Number(contentLength)
-        : null,
-      highWaterMark
-    })
-
-    if (this.removeAbortListener) {
-      res.on('close', this.removeAbortListener)
-      this.removeAbortListener = null
-    }
-
-    this.callback = null
-    this.res = res
-    if (callback !== null) {
-      try {
-        this.runInAsyncScope(callback, null, null, {
-          statusCode,
-          statusText: statusMessage,
-          headers,
-          trailers: this.trailers,
-          opaque,
-          body: res,
-          context
-        })
-      } catch (err) {
-        // If the callback throws synchronously, we need to handle it
-        // Remove reference to res to allow res being garbage collected
-        this.res = null
-
-        // Destroy the response stream
-        util.destroy(res.on('error', noop), err)
-
-        // Use queueMicrotask to re-throw the error so it reaches uncaughtException
-        queueMicrotask(() => {
-          throw err
-        })
-      }
-    }
-  }
-
-  onData (chunk) {
-    return this.res.push(chunk)
-  }
-
-  onComplete (trailers) {
-    util.parseHeaders(trailers, this.trailers)
-    this.res.push(null)
-  }
-
-  onError (err) {
-    const { res, callback, body, opaque } = this
-
-    if (callback) {
-      // TODO: Does this need queueMicrotask?
-      this.callback = null
-      queueMicrotask(() => {
-        this.runInAsyncScope(callback, null, err, { opaque })
-      })
-    }
-
-    if (res) {
-      this.res = null
-      // Ensure all queued handlers are invoked before destroying res.
-      queueMicrotask(() => {
-        util.destroy(res.on('error', noop), err)
-      })
-    }
-
-    if (body) {
-      this.body = null
-
-      if (util.isStream(body)) {
-        body.on('error', noop)
-        util.destroy(body, err)
-      }
-    }
-
-    if (this.removeAbortListener) {
-      this.removeAbortListener()
-      this.removeAbortListener = null
-    }
-  }
-}
-
-function request (opts, callback) {
-  if (callback === undefined) {
-    return new Promise((resolve, reject) => {
-      request.call(this, opts, (err, data) => {
-        return err ? reject(err) : resolve(data)
-      })
-    })
-  }
-
-  try {
-    const handler = new RequestHandler(opts, callback)
-
-    this.dispatch(opts, handler)
-  } catch (err) {
-    if (typeof callback !== 'function') {
-      throw err
-    }
-    const opaque = opts?.opaque
-    queueMicrotask(() => callback(err, { opaque }))
-  }
-}
-
-module.exports = request
-module.exports.RequestHandler = RequestHandler

package/.output/server/node_modules/undici/lib/api/api-stream.js

@@ -1,209 +0,0 @@
-'use strict'
-
-const assert = require('node:assert')
-const { finished } = require('node:stream')
-const { AsyncResource } = require('node:async_hooks')
-const { InvalidArgumentError, InvalidReturnValueError } = require('../core/errors')
-const util = require('../core/util')
-const { addSignal, removeSignal } = require('./abort-signal')
-
-function noop () {}
-
-class StreamHandler extends AsyncResource {
-  constructor (opts, factory, callback) {
-    if (!opts || typeof opts !== 'object') {
-      throw new InvalidArgumentError('invalid opts')
-    }
-
-    const { signal, method, opaque, body, onInfo, responseHeaders } = opts
-
-    try {
-      if (typeof callback !== 'function') {
-        throw new InvalidArgumentError('invalid callback')
-      }
-
-      if (typeof factory !== 'function') {
-        throw new InvalidArgumentError('invalid factory')
-      }
-
-      if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') {
-        throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget')
-      }
-
-      if (method === 'CONNECT') {
-        throw new InvalidArgumentError('invalid method')
-      }
-
-      if (onInfo && typeof onInfo !== 'function') {
-        throw new InvalidArgumentError('invalid onInfo callback')
-      }
-
-      super('UNDICI_STREAM')
-    } catch (err) {
-      if (util.isStream(body)) {
-        util.destroy(body.on('error', noop), err)
-      }
-      throw err
-    }
-
-    this.responseHeaders = responseHeaders || null
-    this.opaque = opaque || null
-    this.factory = factory
-    this.callback = callback
-    this.res = null
-    this.abort = null
-    this.context = null
-    this.trailers = null
-    this.body = body
-    this.onInfo = onInfo || null
-
-    if (util.isStream(body)) {
-      body.on('error', (err) => {
-        this.onError(err)
-      })
-    }
-
-    addSignal(this, signal)
-  }
-
-  onConnect (abort, context) {
-    if (this.reason) {
-      abort(this.reason)
-      return
-    }
-
-    assert(this.callback)
-
-    this.abort = abort
-    this.context = context
-  }
-
-  onHeaders (statusCode, rawHeaders, resume, statusMessage) {
-    const { factory, opaque, context, responseHeaders } = this
-
-    const headers = responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
-
-    if (statusCode < 200) {
-      if (this.onInfo) {
-        this.onInfo({ statusCode, headers })
-      }
-      return
-    }
-
-    this.factory = null
-
-    if (factory === null) {
-      return
-    }
-
-    const res = this.runInAsyncScope(factory, null, {
-      statusCode,
-      headers,
-      opaque,
-      context
-    })
-
-    if (
-      !res ||
-      typeof res.write !== 'function' ||
-      typeof res.end !== 'function' ||
-      typeof res.on !== 'function'
-    ) {
-      throw new InvalidReturnValueError('expected Writable')
-    }
-
-    // TODO: Avoid finished. It registers an unnecessary amount of listeners.
-    finished(res, { readable: false }, (err) => {
-      const { callback, res, opaque, trailers, abort } = this
-
-      this.res = null
-      if (err || !res?.readable) {
-        util.destroy(res, err)
-      }
-
-      this.callback = null
-      this.runInAsyncScope(callback, null, err || null, { opaque, trailers })
-
-      if (err) {
-        abort()
-      }
-    })
-
-    res.on('drain', resume)
-
-    this.res = res
-
-    const needDrain = res.writableNeedDrain !== undefined
-      ? res.writableNeedDrain
-      : res._writableState?.needDrain
-
-    return needDrain !== true
-  }
-
-  onData (chunk) {
-    const { res } = this
-
-    return res ? res.write(chunk) : true
-  }
-
-  onComplete (trailers) {
-    const { res } = this
-
-    removeSignal(this)
-
-    if (!res) {
-      return
-    }
-
-    this.trailers = util.parseHeaders(trailers)
-
-    res.end()
-  }
-
-  onError (err) {
-    const { res, callback, opaque, body } = this
-
-    removeSignal(this)
-
-    this.factory = null
-
-    if (res) {
-      this.res = null
-      util.destroy(res, err)
-    } else if (callback) {
-      this.callback = null
-      queueMicrotask(() => {
-        this.runInAsyncScope(callback, null, err, { opaque })
-      })
-    }
-
-    if (body) {
-      this.body = null
-      util.destroy(body, err)
-    }
-  }
-}
-
-function stream (opts, factory, callback) {
-  if (callback === undefined) {
-    return new Promise((resolve, reject) => {
-      stream.call(this, opts, factory, (err, data) => {
-        return err ? reject(err) : resolve(data)
-      })
-    })
-  }
-
-  try {
-    const handler = new StreamHandler(opts, factory, callback)
-
-    this.dispatch(opts, handler)
-  } catch (err) {
-    if (typeof callback !== 'function') {
-      throw err
-    }
-    const opaque = opts?.opaque
-    queueMicrotask(() => callback(err, { opaque }))
-  }
-}
-
-module.exports = stream

package/.output/server/node_modules/undici/lib/api/api-upgrade.js

@@ -1,111 +0,0 @@
-'use strict'
-
-const { InvalidArgumentError, SocketError } = require('../core/errors')
-const { AsyncResource } = require('node:async_hooks')
-const assert = require('node:assert')
-const util = require('../core/util')
-const { kHTTP2Stream } = require('../core/symbols')
-const { addSignal, removeSignal } = require('./abort-signal')
-
-class UpgradeHandler extends AsyncResource {
-  constructor (opts, callback) {
-    if (!opts || typeof opts !== 'object') {
-      throw new InvalidArgumentError('invalid opts')
-    }
-
-    if (typeof callback !== 'function') {
-      throw new InvalidArgumentError('invalid callback')
-    }
-
-    const { signal, opaque, responseHeaders } = opts
-
-    if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') {
-      throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget')
-    }
-
-    super('UNDICI_UPGRADE')
-
-    this.responseHeaders = responseHeaders || null
-    this.opaque = opaque || null
-    this.callback = callback
-    this.abort = null
-    this.context = null
-
-    addSignal(this, signal)
-  }
-
-  onConnect (abort, context) {
-    if (this.reason) {
-      abort(this.reason)
-      return
-    }
-
-    assert(this.callback)
-
-    this.abort = abort
-    this.context = null
-  }
-
-  onHeaders () {
-    throw new SocketError('bad upgrade', null)
-  }
-
-  onUpgrade (statusCode, rawHeaders, socket) {
-    assert(socket[kHTTP2Stream] === true ? statusCode === 200 : statusCode === 101)
-
-    const { callback, opaque, context } = this
-
-    removeSignal(this)
-
-    this.callback = null
-    const headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
-    this.runInAsyncScope(callback, null, null, {
-      headers,
-      socket,
-      opaque,
-      context
-    })
-  }
-
-  onError (err) {
-    const { callback, opaque } = this
-
-    removeSignal(this)
-
-    if (callback) {
-      this.callback = null
-      queueMicrotask(() => {
-        this.runInAsyncScope(callback, null, err, { opaque })
-      })
-    }
-  }
-}
-
-function upgrade (opts, callback) {
-  if (callback === undefined) {
-    return new Promise((resolve, reject) => {
-      upgrade.call(this, opts, (err, data) => {
-        return err ? reject(err) : resolve(data)
-      })
-    })
-  }
-
-  try {
-    const upgradeHandler = new UpgradeHandler(opts, callback)
-    const upgradeOpts = {
-      ...opts,
-      method: opts.method || 'GET',
-      upgrade: opts.protocol || 'Websocket'
-    }
-
-    this.dispatch(upgradeOpts, upgradeHandler)
-  } catch (err) {
-    if (typeof callback !== 'function') {
-      throw err
-    }
-    const opaque = opts?.opaque
-    queueMicrotask(() => callback(err, { opaque }))
-  }
-}
-
-module.exports = upgrade

package/.output/server/node_modules/undici/lib/api/index.js

@@ -1,7 +0,0 @@
-'use strict'
-
-module.exports.request = require('./api-request')
-module.exports.stream = require('./api-stream')
-module.exports.pipeline = require('./api-pipeline')
-module.exports.upgrade = require('./api-upgrade')
-module.exports.connect = require('./api-connect')