@jointhedots/gear 1.0.21 → 1.1.5

package/browser-modules/stream.js

@@ -0,0 +1,323 @@
+// Browser polyfill for node:stream module
+// Provides basic EventEmitter-based stream implementations
+
+import { EventEmitter } from './events.js'
+
+export class Stream extends EventEmitter {
+   constructor(options) {
+      super()
+      this.readable = false
+      this.writable = false
+   }
+
+   pipe(dest, options) {
+      return dest
+   }
+}
+
+export class Readable extends Stream {
+   constructor(options = {}) {
+      super()
+      this.readable = true
+      this._readableState = {
+         flowing: null,
+         ended: false,
+         endEmitted: false,
+         reading: false,
+         destroyed: false,
+         objectMode: options.objectMode || false,
+         highWaterMark: options.highWaterMark || 16384,
+         buffer: [],
+         length: 0,
+      }
+   }
+
+   read(size) {
+      return null
+   }
+
+   _read(size) {
+      // Override in subclass
+   }
+
+   push(chunk, encoding) {
+      if (chunk === null) {
+         this._readableState.ended = true
+         this.emit('end')
+         return false
+      }
+      this._readableState.buffer.push(chunk)
+      this.emit('data', chunk)
+      return true
+   }
+
+   unshift(chunk) {
+      this._readableState.buffer.unshift(chunk)
+   }
+
+   pause() {
+      this._readableState.flowing = false
+      return this
+   }
+
+   resume() {
+      this._readableState.flowing = true
+      return this
+   }
+
+   isPaused() {
+      return this._readableState.flowing === false
+   }
+
+   pipe(dest, options) {
+      this.on('data', (chunk) => {
+         dest.write(chunk)
+      })
+      this.on('end', () => {
+         if (!options || options.end !== false) {
+            dest.end()
+         }
+      })
+      return dest
+   }
+
+   destroy(err) {
+      this._readableState.destroyed = true
+      if (err) this.emit('error', err)
+      this.emit('close')
+      return this
+   }
+
+   [Symbol.asyncIterator]() {
+      const self = this
+      return {
+         async next() {
+            return new Promise((resolve) => {
+               const onData = (chunk) => {
+                  self.removeListener('data', onData)
+                  self.removeListener('end', onEnd)
+                  resolve({ value: chunk, done: false })
+               }
+               const onEnd = () => {
+                  self.removeListener('data', onData)
+                  self.removeListener('end', onEnd)
+                  resolve({ value: undefined, done: true })
+               }
+               self.once('data', onData)
+               self.once('end', onEnd)
+            })
+         }
+      }
+   }
+}
+
+export class Writable extends Stream {
+   constructor(options = {}) {
+      super()
+      this.writable = true
+      this._writableState = {
+         ended: false,
+         finished: false,
+         destroyed: false,
+         objectMode: options.objectMode || false,
+         highWaterMark: options.highWaterMark || 16384,
+         needDrain: false,
+         writing: false,
+         corked: 0,
+         bufferProcessing: false,
+         buffer: [],
+      }
+   }
+
+   write(chunk, encoding, callback) {
+      if (typeof encoding === 'function') {
+         callback = encoding
+         encoding = 'utf8'
+      }
+      this._write(chunk, encoding, callback || (() => {}))
+      return true
+   }
+
+   _write(chunk, encoding, callback) {
+      // Override in subclass
+      callback()
+   }
+
+   end(chunk, encoding, callback) {
+      if (typeof chunk === 'function') {
+         callback = chunk
+         chunk = null
+      } else if (typeof encoding === 'function') {
+         callback = encoding
+         encoding = null
+      }
+      if (chunk != null) {
+         this.write(chunk, encoding)
+      }
+      this._writableState.ended = true
+      this._writableState.finished = true
+      this.emit('finish')
+      if (callback) callback()
+      return this
+   }
+
+   cork() {
+      this._writableState.corked++
+   }
+
+   uncork() {
+      if (this._writableState.corked > 0) {
+         this._writableState.corked--
+      }
+   }
+
+   destroy(err) {
+      this._writableState.destroyed = true
+      if (err) this.emit('error', err)
+      this.emit('close')
+      return this
+   }
+
+   setDefaultEncoding(encoding) {
+      this._defaultEncoding = encoding
+      return this
+   }
+}
+
+export class Duplex extends Readable {
+   constructor(options = {}) {
+      super(options)
+      Writable.call(this, options)
+      this.writable = true
+      this._writableState = {
+         ended: false,
+         finished: false,
+         destroyed: false,
+         objectMode: options.objectMode || false,
+         highWaterMark: options.highWaterMark || 16384,
+         needDrain: false,
+         writing: false,
+         corked: 0,
+         bufferProcessing: false,
+         buffer: [],
+      }
+   }
+}
+
+// Mix in Writable methods
+Object.assign(Duplex.prototype, Writable.prototype)
+
+export class Transform extends Duplex {
+   constructor(options = {}) {
+      super(options)
+      this._transformState = {
+         transforming: false,
+         writecb: null,
+         writechunk: null,
+      }
+   }
+
+   _transform(chunk, encoding, callback) {
+      // Override in subclass
+      callback(null, chunk)
+   }
+
+   _flush(callback) {
+      callback()
+   }
+
+   _write(chunk, encoding, callback) {
+      this._transform(chunk, encoding, (err, data) => {
+         if (err) {
+            callback(err)
+            return
+         }
+         if (data != null) {
+            this.push(data)
+         }
+         callback()
+      })
+   }
+}
+
+export class PassThrough extends Transform {
+   constructor(options) {
+      super(options)
+   }
+
+   _transform(chunk, encoding, callback) {
+      callback(null, chunk)
+   }
+}
+
+// Utility functions
+export function finished(stream, options, callback) {
+   if (typeof options === 'function') {
+      callback = options
+      options = {}
+   }
+   options = options || {}
+
+   const onFinish = () => {
+      cleanup()
+      callback()
+   }
+   const onError = (err) => {
+      cleanup()
+      callback(err)
+   }
+   const cleanup = () => {
+      stream.removeListener('finish', onFinish)
+      stream.removeListener('end', onFinish)
+      stream.removeListener('error', onError)
+      stream.removeListener('close', onFinish)
+   }
+
+   stream.on('finish', onFinish)
+   stream.on('end', onFinish)
+   stream.on('error', onError)
+   stream.on('close', onFinish)
+
+   return cleanup
+}
+
+export function pipeline(...args) {
+   const callback = args.pop()
+   const streams = args
+
+   if (streams.length < 2) {
+      throw new Error('pipeline requires at least 2 streams')
+   }
+
+   let error
+   const destroys = streams.map((stream, i) => {
+      const isLast = i === streams.length - 1
+      const isSource = i === 0
+
+      return (err) => {
+         if (err) error = err
+         if (!isSource) stream.destroy()
+         if (isLast && callback) callback(error)
+      }
+   })
+
+   streams.reduce((prev, curr, i) => {
+      prev.pipe(curr)
+      prev.on('error', destroys[i])
+      return curr
+   })
+
+   return streams[streams.length - 1]
+}
+
+// Default export
+export default {
+   Stream,
+   Readable,
+   Writable,
+   Duplex,
+   Transform,
+   PassThrough,
+   finished,
+   pipeline,
+}

package/browser-modules/util.js

@@ -0,0 +1,170 @@
+// Custom util polyfill with stripVTControlCharacters
+
+// stripVTControlCharacters - removes ANSI escape sequences
+const ansiRegex = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g
+
+export function stripVTControlCharacters(str) {
+   if (typeof str !== 'string') {
+      throw new TypeError('The "str" argument must be of type string')
+   }
+   return str.replace(ansiRegex, '')
+}
+
+// Common util functions
+export function inherits(ctor, superCtor) {
+   ctor.super_ = superCtor
+   ctor.prototype = Object.create(superCtor.prototype, {
+      constructor: { value: ctor, enumerable: false, writable: true, configurable: true }
+   })
+}
+
+export function deprecate(fn, msg) {
+   let warned = false
+   return function (...args) {
+      if (!warned) {
+         console.warn(msg)
+         warned = true
+      }
+      return fn.apply(this, args)
+   }
+}
+
+export function debuglog(section) {
+   return function () { }
+}
+
+export function inspect(obj, opts) {
+   return JSON.stringify(obj, null, 2)
+}
+
+export function format(f, ...args) {
+   if (typeof f !== 'string') {
+      return args.map(a => inspect(a)).join(' ')
+   }
+   let i = 0
+   return f.replace(/%[sdjifoO%]/g, (x) => {
+      if (x === '%%') return '%'
+      if (i >= args.length) return x
+      const arg = args[i++]
+      switch (x) {
+         case '%s': return String(arg)
+         case '%d': return Number(arg)
+         case '%i': return parseInt(arg, 10)
+         case '%j': return JSON.stringify(arg)
+         case '%f': return parseFloat(arg)
+         case '%o':
+         case '%O': return inspect(arg)
+         default: return x
+      }
+   })
+}
+
+export function formatWithOptions(opts, f, ...args) {
+   return format(f, ...args)
+}
+
+export const isArray = Array.isArray
+export const isBoolean = (v) => typeof v === 'boolean'
+export const isNull = (v) => v === null
+export const isNullOrUndefined = (v) => v == null
+export const isNumber = (v) => typeof v === 'number'
+export const isString = (v) => typeof v === 'string'
+export const isSymbol = (v) => typeof v === 'symbol'
+export const isUndefined = (v) => v === undefined
+export const isObject = (v) => typeof v === 'object' && v !== null
+export const isFunction = (v) => typeof v === 'function'
+export const isRegExp = (v) => v instanceof RegExp
+export const isDate = (v) => v instanceof Date
+export const isError = (v) => v instanceof Error
+export const isPrimitive = (v) => v === null || (typeof v !== 'object' && typeof v !== 'function')
+export const isBuffer = (v) => typeof Buffer !== 'undefined' && Buffer.isBuffer(v)
+
+export function callbackify(fn) {
+   return function (...args) {
+      const callback = args.pop()
+      Promise.resolve(fn(...args)).then(
+         (result) => callback(null, result),
+         (err) => callback(err)
+      )
+   }
+}
+
+export function promisify(fn) {
+   return function (...args) {
+      return new Promise((resolve, reject) => {
+         fn(...args, (err, result) => {
+            if (err) reject(err)
+            else resolve(result)
+         })
+      })
+   }
+}
+
+export const types = {
+   isAnyArrayBuffer: (v) => v instanceof ArrayBuffer || v instanceof SharedArrayBuffer,
+   isArrayBuffer: (v) => v instanceof ArrayBuffer,
+   isArrayBufferView: (v) => ArrayBuffer.isView(v),
+   isAsyncFunction: (v) => v?.constructor?.name === 'AsyncFunction',
+   isBigInt64Array: (v) => v instanceof BigInt64Array,
+   isBigUint64Array: (v) => v instanceof BigUint64Array,
+   isDataView: (v) => v instanceof DataView,
+   isDate: (v) => v instanceof Date,
+   isFloat32Array: (v) => v instanceof Float32Array,
+   isFloat64Array: (v) => v instanceof Float64Array,
+   isGeneratorFunction: (v) => v?.constructor?.name === 'GeneratorFunction',
+   isInt8Array: (v) => v instanceof Int8Array,
+   isInt16Array: (v) => v instanceof Int16Array,
+   isInt32Array: (v) => v instanceof Int32Array,
+   isMap: (v) => v instanceof Map,
+   isMapIterator: (v) => v?.[Symbol.toStringTag] === 'Map Iterator',
+   isPromise: (v) => v instanceof Promise,
+   isRegExp: (v) => v instanceof RegExp,
+   isSet: (v) => v instanceof Set,
+   isSetIterator: (v) => v?.[Symbol.toStringTag] === 'Set Iterator',
+   isSharedArrayBuffer: (v) => v instanceof SharedArrayBuffer,
+   isTypedArray: (v) => ArrayBuffer.isView(v) && !(v instanceof DataView),
+   isUint8Array: (v) => v instanceof Uint8Array,
+   isUint8ClampedArray: (v) => v instanceof Uint8ClampedArray,
+   isUint16Array: (v) => v instanceof Uint16Array,
+   isUint32Array: (v) => v instanceof Uint32Array,
+   isWeakMap: (v) => v instanceof WeakMap,
+   isWeakSet: (v) => v instanceof WeakSet,
+}
+
+export class TextEncoder {
+   encode(str) { return new globalThis.TextEncoder().encode(str) }
+}
+
+export class TextDecoder {
+   decode(buf) { return new globalThis.TextDecoder().decode(buf) }
+}
+
+export default {
+   stripVTControlCharacters,
+   inherits,
+   deprecate,
+   debuglog,
+   inspect,
+   format,
+   formatWithOptions,
+   isArray,
+   isBoolean,
+   isNull,
+   isNullOrUndefined,
+   isNumber,
+   isString,
+   isSymbol,
+   isUndefined,
+   isObject,
+   isFunction,
+   isRegExp,
+   isDate,
+   isError,
+   isPrimitive,
+   isBuffer,
+   callbackify,
+   promisify,
+   types,
+   TextEncoder,
+   TextDecoder,
+}

package/browser-modules/worker_threads.js

@@ -0,0 +1,85 @@
+// Browser polyfill for worker_threads module
+// worker_threads is not fully available in browser environments
+// This provides stubs that throw meaningful errors or return appropriate defaults
+
+class NotSupportedError extends Error {
+   constructor(method) {
+      super(`worker_threads.${method}() is not supported in browser environments`)
+      this.name = 'NotSupportedError'
+      this.code = 'ERR_NOT_SUPPORTED'
+   }
+}
+
+// In browsers, we're always on the main thread
+export const isMainThread = true
+
+// No parent port in main thread
+export const parentPort = null
+
+// No worker data in main thread
+export const workerData = null
+
+// Thread ID (main thread is 0)
+export const threadId = 0
+
+// Resource limits (not applicable in browser)
+export const resourceLimits = {}
+
+// SHARE_ENV symbol
+export const SHARE_ENV = Symbol.for('nodejs.worker_threads.SHARE_ENV')
+
+// MessageChannel is available natively in browsers
+export const MessageChannel = globalThis.MessageChannel
+
+// MessagePort is available natively in browsers
+export const MessagePort = globalThis.MessagePort
+
+// BroadcastChannel is available natively in browsers
+export const BroadcastChannel = globalThis.BroadcastChannel
+
+// Worker class - stub that throws
+export class Worker {
+   constructor(filename, options) {
+      throw new NotSupportedError('Worker')
+   }
+}
+
+// Functions that are not supported
+export function markAsUntransferable(object) {
+   // No-op in browser
+}
+
+export function moveMessagePortToContext(port, contextifiedSandbox) {
+   throw new NotSupportedError('moveMessagePortToContext')
+}
+
+export function receiveMessageOnPort(port) {
+   throw new NotSupportedError('receiveMessageOnPort')
+}
+
+export function getEnvironmentData(key) {
+   return undefined
+}
+
+export function setEnvironmentData(key, value) {
+   // No-op in browser
+}
+
+// Default export with all named exports
+export default {
+   isMainThread,
+   parentPort,
+   workerData,
+   threadId,
+   resourceLimits,
+   SHARE_ENV,
+   MessageChannel,
+   MessagePort,
+   BroadcastChannel,
+   Worker,
+   markAsUntransferable,
+   moveMessagePortToContext,
+   receiveMessageOnPort,
+   getEnvironmentData,
+   setEnvironmentData,
+}