@exodus/test-bundler 1.0.0-rc.1

package/modules/http.cjs

@@ -0,0 +1,119 @@
+const STATUS_CODES = {
+  100: 'Continue',
+  101: 'Switching Protocols',
+  102: 'Processing',
+  103: 'Early Hints',
+  200: 'OK',
+  201: 'Created',
+  202: 'Accepted',
+  203: 'Non-Authoritative Information',
+  204: 'No Content',
+  205: 'Reset Content',
+  206: 'Partial Content',
+  207: 'Multi-Status',
+  208: 'Already Reported',
+  226: 'IM Used',
+  300: 'Multiple Choices',
+  301: 'Moved Permanently',
+  302: 'Found',
+  303: 'See Other',
+  304: 'Not Modified',
+  305: 'Use Proxy',
+  307: 'Temporary Redirect',
+  308: 'Permanent Redirect',
+  400: 'Bad Request',
+  401: 'Unauthorized',
+  402: 'Payment Required',
+  403: 'Forbidden',
+  404: 'Not Found',
+  405: 'Method Not Allowed',
+  406: 'Not Acceptable',
+  407: 'Proxy Authentication Required',
+  408: 'Request Timeout',
+  409: 'Conflict',
+  410: 'Gone',
+  411: 'Length Required',
+  412: 'Precondition Failed',
+  413: 'Payload Too Large',
+  414: 'URI Too Long',
+  415: 'Unsupported Media Type',
+  416: 'Range Not Satisfiable',
+  417: 'Expectation Failed',
+  418: "I'm a Teapot",
+  421: 'Misdirected Request',
+  422: 'Unprocessable Entity',
+  423: 'Locked',
+  424: 'Failed Dependency',
+  425: 'Too Early',
+  426: 'Upgrade Required',
+  428: 'Precondition Required',
+  429: 'Too Many Requests',
+  431: 'Request Header Fields Too Large',
+  451: 'Unavailable For Legal Reasons',
+  500: 'Internal Server Error',
+  501: 'Not Implemented',
+  502: 'Bad Gateway',
+  503: 'Service Unavailable',
+  504: 'Gateway Timeout',
+  505: 'HTTP Version Not Supported',
+  506: 'Variant Also Negotiates',
+  507: 'Insufficient Storage',
+  508: 'Loop Detected',
+  509: 'Bandwidth Limit Exceeded',
+  510: 'Not Extended',
+  511: 'Network Authentication Required',
+}
+
+// prettier-ignore
+const METHODS = [
+  'ACL',        'BIND',        'CHECKOUT',
+  'CONNECT',    'COPY',        'DELETE',
+  'GET',        'HEAD',        'LINK',
+  'LOCK',       'M-SEARCH',    'MERGE',
+  'MKACTIVITY', 'MKCALENDAR',  'MKCOL',
+  'MOVE',       'NOTIFY',      'OPTIONS',
+  'PATCH',      'POST',        'PROPFIND',
+  'PROPPATCH',  'PURGE',       'PUT',
+  'QUERY',      'REBIND',      'REPORT',
+  'SEARCH',     'SOURCE',      'SUBSCRIBE',
+  'TRACE',      'UNBIND',      'UNLINK',
+  'UNLOCK',     'UNSUBSCRIBE'
+]
+
+const keys = [
+  '_connectionListener',
+  'Agent',
+  'ClientRequest',
+  'IncomingMessage',
+  'OutgoingMessage',
+  'Server',
+  'ServerResponse',
+  'createServer',
+  'validateHeaderName',
+  'validateHeaderValue',
+  'get',
+  'request',
+  'setMaxIdleHTTPParsers',
+]
+
+const makeMethod = (key) => {
+  // Not an arrow as some methods are constructors and can be called with new
+  return function () {
+    throw new Error(`http(s).${key} unsupported in bundled mode`)
+  }
+}
+
+module.exports = {
+  METHODS,
+  STATUS_CODES,
+  ...Object.fromEntries(keys.map((key) => [key, makeMethod(key)])),
+  get maxHeaderSize() {
+    return 16_384
+  },
+  get globalAgent() {
+    throw new Error('http.globalAgent unsupported in bundled mode')
+  },
+  set globalAgent(value) {
+    throw new Error('http.globalAgent unsupported in bundled mode')
+  },
+}

package/modules/https.cjs

@@ -0,0 +1,11 @@
+const { Agent, Server, createServer, get, request } = require('./http.cjs')
+const inherited = { Agent, Server, createServer, get, request }
+module.exports = {
+  ...inherited,
+  get globalAgent() {
+    throw new Error('https.globalAgent unsupported in bundled mode')
+  },
+  set globalAgent(value) {
+    throw new Error('https.globalAgent unsupported in bundled mode')
+  },
+}

package/modules/jest-message-util.js

@@ -0,0 +1,5 @@
+// Used in expect toThrowMatchers
+// TODO: figure out if a better impl is actually needed
+
+export const formatStackTrace = (stack) => stack
+export const separateMessageFromStack = (content) => ({ stack: content })

package/modules/jest-util.js

@@ -0,0 +1,22 @@
+// APIs used in expect()
+
+export const isPromise = (x) => Boolean(x && x.then && x.catch && x.finally)
+
+var NUMS = [
+  'zero',
+  'one',
+  'two',
+  'three',
+  'four',
+  'five',
+  'six',
+  'seven',
+  'eight',
+  'nine',
+  'ten',
+  'eleven',
+  'twelve',
+  'thirteen',
+]
+
+export const pluralize = (word, count) => `${NUMS[count] || count} ${word}${count === 1 ? '' : 's'}`

package/modules/module.cjs

@@ -0,0 +1,16 @@
+const ids = 'Module,SourceMap,builtinModules,findSourceMap,globalPaths,isBuiltin,runMain'.split(',')
+
+const makeMethod = (key) => {
+  // Not an arrow as there are classes that can be called with new
+  return function () {
+    throw new Error(`module.${key} unsupported in bundled mode`)
+  }
+}
+
+const createRequire = (filename) => (file) => {
+  const clean = file.replace(/^node:/, '')
+  if (globalThis.EXODUS_TEST_MOCK_BUILTINS?.has(clean)) return EXODUS_TEST_MOCK_BUILTINS.get(clean) // eslint-disable-line no-undef
+  throw new Error(`module.createRequire is unsupported in bundled mode (origin: ${filename})`)
+}
+
+module.exports = { ...Object.fromEntries(ids.map((key) => [key, makeMethod(key)])), createRequire }

package/modules/node-buffer.cjs

@@ -0,0 +1,3 @@
+// For node.js Buffers to have the same ref / be fast
+const { Buffer, Blob, File } = globalThis
+module.exports = { Buffer, Blob, File, INSPECT_MAX_BYTES: 50, kMaxLength: 2 ** 31 - 1 }

package/modules/text-encoding-utf.cjs

@@ -0,0 +1,90 @@
+// Adapted from https://github.com/ExodusMovement/text-encoding-utf8
+
+/* eslint-disable unicorn/prefer-set-has, unicorn/text-encoding-identifier-case */
+
+const UTF8 = 'utf-8'
+const UTF16LE = 'utf-16le'
+
+// https://encoding.spec.whatwg.org/#names-and-labels
+const UTF8alias = ['utf8', 'unicode-1-1-utf-8', 'unicode11utf8', 'unicode20utf8', 'x-unicode20utf8']
+const UTF16LEalias = ['utf-16', 'ucs-2', 'unicode', 'unicodefeff', 'iso-10646-ucs-2', 'csunicode'] // but not utf16
+
+const normalizeEncoding = (encoding) => {
+  const lower = encoding.toLowerCase()
+  if (UTF8 === lower || UTF16LE === lower) return lower // fast path
+  if (UTF8alias.includes(lower)) return UTF8
+  if (UTF16LEalias.includes(lower)) return UTF16LE
+  return lower
+}
+
+const defineFinal = (obj, key, value) => Object.defineProperty(obj, key, { value, writable: false })
+
+const assertUTF8 = (encoding) => {
+  if (encoding !== UTF8) throw new Error('only utf-8 is supported')
+}
+
+const assertUTF8orUTF16LE = (enc) => {
+  // We don't include ascii because it's an alias to windows-1252 in TextDecoder and differs from Buffer ascii
+  // We don't include utf-16be because it's not supported by buffer package
+  if (enc !== UTF8 && enc !== UTF16LE) throw new Error('only utf-8 and utf-16le are supported')
+}
+
+const assertBufferSource = (buf) => {
+  if (buf instanceof ArrayBuffer || ArrayBuffer.isView(buf)) return
+  if (globalThis.SharedArrayBuffer && buf instanceof globalThis.SharedArrayBuffer) return
+  throw new Error('argument must be a SharedArrayBuffer, ArrayBuffer or ArrayBufferView')
+}
+
+// encoding argument is non-standard but catches usage of 'text-encoding' npm package API
+// Standard TextEncoder constructor doesn't have any arguments at all and is always utf-8
+function TextEncoder(encoding = UTF8) {
+  encoding = normalizeEncoding(encoding)
+  assertUTF8(encoding)
+  defineFinal(this, 'encoding', encoding)
+}
+
+TextEncoder.prototype.encode = function (str) {
+  const buf = Buffer.from(str)
+  return new Uint8Array(buf.buffer, buf.byteOffset, buf.length)
+}
+
+TextEncoder.prototype.encodeInto = function () {
+  throw new Error('not supported')
+}
+
+function TextDecoder(encoding = UTF8, options = {}) {
+  encoding = normalizeEncoding(encoding)
+  assertUTF8orUTF16LE(encoding)
+
+  const { fatal = false, ignoreBOM = false, stream = false } = options
+  if (ignoreBOM !== false) throw new Error('option "ignoreBOM" is not supported')
+  if (stream !== false) throw new Error('option "stream" is not supported')
+
+  // see: https://github.com/inexorabletash/text-encoding/blob/master/lib/encoding.js#L1049
+  defineFinal(this, 'encoding', encoding)
+  defineFinal(this, 'fatal', fatal)
+  defineFinal(this, 'ignoreBOM', ignoreBOM)
+}
+
+// Note: https://npmjs.com/package/buffer has a bug
+// Buffer.from([0xf0, 0x90, 0x80]).toString().length should be 1, but it is 3 in https://npmjs.com/package/buffer
+// Buffer.from([0xf0, 0x80, 0x80]).toString().length should be 3, see https://github.com/nodejs/node/issues/16894
+TextDecoder.prototype.decode = function (buf) {
+  if (buf === undefined) return ''
+  assertBufferSource(buf)
+  if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)
+  const res = buf.toString(this.encoding)
+  if (this.fatal && res.includes('\uFFFD')) {
+    // We have a replacement symbol, recheck if output matches input
+    const reconstructed = Buffer.from(res, this.encoding)
+    if (Buffer.compare(buf, reconstructed) !== 0) {
+      const err = new TypeError('The encoded data was not valid for encoding utf-8')
+      err.code = 'ERR_ENCODING_INVALID_ENCODED_DATA'
+      throw err
+    }
+  }
+
+  return res
+}
+
+module.exports = { TextEncoder, TextDecoder }

package/modules/tty.cjs

@@ -0,0 +1,10 @@
+module.exports = {
+  isatty: () => false,
+  // Not arrows as those are classes and can be called with new
+  ReadStream() {
+    throw new Error('tty.ReadStream unsupported in bundled mode')
+  },
+  WriteStream() {
+    throw new Error('tty.WriteStream unsupported in bundled mode')
+  },
+}

package/modules/url.cjs

@@ -0,0 +1,32 @@
+const urlLib = require('url/url.js')
+
+function pathToFileURL(path) {
+  const url = urlLib.format({ protocol: 'file:', pathname: path, slashes: true })
+  return globalThis.URL ? new globalThis.URL(url) : urlLib.parse(url)
+}
+
+function fileURLToPath(url, options) {
+  if (options?.windows) throw new Error('Windows mode not supported')
+  if (typeof url === 'string') {
+    url = urlLib.parse(url)
+    if (!url) throw new Error('Failed to parse URL')
+  } else if (!globalThis.URL || !(url instanceof globalThis.URL)) {
+    throw new Error('Input is not an URL')
+  }
+
+  if (url.protocol !== 'file:' || url.host !== '') throw new Error('Input is not a file URL')
+  const path = url.pathname
+  for (let n = 0; n < path.length; n++) {
+    if (path[n] !== '%' && path[n + 1] === '2' && (path.codePointAt(n + 2) | 0x20) === 102) {
+      throw new Error('must not include encoded / characters')
+    }
+  }
+
+  return path
+}
+
+module.exports = { ...urlLib, pathToFileURL, fileURLToPath }
+
+for (const name of ['URL', 'URLSearchParams']) {
+  Object.defineProperty(module.exports, name, { get: () => globalThis[name], enumerable: true })
+}

package/modules/util-format.cjs

@@ -0,0 +1,48 @@
+const { inspect: inspectOrig, isString, isNull, isObject } = require('util/util.js') // dep
+
+// Print errors without square brackets
+const trim = (x) => x.trim()
+const validLine = (x) => x && x !== '@'
+const padLine = (line) => `    ${line}`
+const pad = (stack) => stack.split('\n').map(trim).filter(validLine).map(padLine).join('\n')
+const err2str = (e) => (e.stack?.startsWith(`${e}\n`) ? e.stack : `${e}\n${pad(e.stack)}`.trimEnd())
+const inspect = (obj, opts) => (obj instanceof Error ? err2str(obj) : inspectOrig(obj, opts))
+
+// Patched impl from require('util'), added %i
+const formatRegExp = /%[%dijs]/g
+module.exports = function (f, ...args) {
+  if (!isString(f)) return [f, ...args].map((x) => inspect(x)).join(' ')
+
+  let i = 0
+  let str = String(f).replace(formatRegExp, function (x) {
+    if (x === '%%') return '%'
+    if (i >= args.length) return x
+    switch (x) {
+      case '%s':
+        return String(args[i++])
+      case '%d':
+        return Number(args[i++])
+      case '%i':
+        return `${parseInt(args[i++])}`
+      case '%j':
+        try {
+          return JSON.stringify(args[i++])
+        } catch {
+          return '[Circular]'
+        }
+
+      default:
+        return x
+    }
+  })
+
+  for (var x = args[i]; i < args.length; x = args[++i]) {
+    if (isNull(x) || !isObject(x)) {
+      str += ' ' + x
+    } else {
+      str += ' ' + inspect(x)
+    }
+  }
+
+  return str
+}

package/modules/util.cjs

@@ -0,0 +1,4 @@
+const util = require('util/util.js')
+const format = require('./util-format.cjs')
+const { TextEncoder, TextDecoder } = globalThis
+module.exports = { ...util, format, TextEncoder, TextDecoder }

package/modules/ws.cjs

@@ -0,0 +1,20 @@
+// Should not be an arrow function as might be used as a constructor
+const sub = function () {
+  throw new Error('module unsupported in bundled form: ws')
+}
+
+class WebSocket {
+  constructor() {
+    throw new Error('module unsupported in bundled form: ws')
+  }
+
+  static CONNECTING = 0
+  static OPEN = 1
+  static CLOSING = 2
+  static CLOSED = 3
+  static Server = sub
+  static Receiver = sub
+  static Sender = sub
+}
+
+module.exports = WebSocket

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@exodus/test-bundler",
+  "version": "1.0.0-rc.1",
+  "author": "Exodus Movement, Inc.",
+  "description": "Test bundler for @exodus/test for barebone and browser engines",
+  "homepage": "https://github.com/ExodusMovement/test",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ExodusMovement/test.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ExodusMovement/tests/issues"
+  },
+  "keywords": [
+    "exodus-test",
+    "@exodus/test",
+    "test",
+    "node-test"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    "./bundle": "./bundle.js"
+  },
+  "prettier": "@exodus/prettier",
+  "files": [
+    "babel-worker.cjs",
+    "bundle.js",
+    "modules/empty/function-throw.cjs",
+    "modules/empty/module-throw.cjs",
+    "modules/ansi-styles.cjs",
+    "modules/assert-strict.cjs",
+    "modules/child_process.cjs",
+    "modules/cluster.cjs",
+    "modules/crypto.cjs",
+    "modules/fs.cjs",
+    "modules/fs-promises.cjs",
+    "modules/http.cjs",
+    "modules/https.cjs",
+    "modules/globals.cjs",
+    "modules/globals.node.cjs",
+    "modules/jest-message-util.js",
+    "modules/jest-util.js",
+    "modules/module.cjs",
+    "modules/node-buffer.cjs",
+    "modules/text-encoding-utf.cjs",
+    "modules/tty.cjs",
+    "modules/url.cjs",
+    "modules/util.cjs",
+    "modules/util-format.cjs",
+    "modules/ws.cjs",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "@ungap/url-search-params": "^0.2.2",
+    "assert": "^2.1.0",
+    "browserify-zlib": "^0.2.0",
+    "buffer": "^6.0.3",
+    "constants-browserify": "^1.0.0",
+    "esbuild": "~0.25.4",
+    "events": "^3.3.0",
+    "os-browserify": "^0.3.0",
+    "path-browserify": "^1.0.1",
+    "querystring-es3": "^0.2.1",
+    "stream-browserify": "^3.0.0",
+    "timers-browserify": "^2.0.12",
+    "url": "^0.11.0",
+    "util": "^0.12.5"
+  },
+  "optionalDependencies": {
+    "@babel/core": "^7.0.0",
+    "@babel/plugin-syntax-import-attributes": "^7.0.0",
+    "@babel/plugin-syntax-typescript": "^7.0.0",
+    "@babel/plugin-transform-block-scoping": "^7.0.0",
+    "@babel/plugin-transform-class-properties": "^7.0.0",
+    "@babel/plugin-transform-classes": "^7.0.0",
+    "@babel/plugin-transform-private-methods": "^7.0.0",
+    "crypto-browserify": "^3.12.0",
+    "flow-remove-types": "^2.242.0"
+  }
+}