@jointhedots/gear 1.0.21 → 1.1.5

package/browser-modules/asap-raw.js

@@ -0,0 +1,79 @@
+/**
+ * ESM version of asap/browser-raw.js
+ * This provides a high-priority task queue for browsers.
+ */
+
+// Use the fastest means possible to execute a task in its own turn, with
+// priority over other events including IO, animation, reflow, and redraw
+// events in browsers.
+function rawAsap(task) {
+    if (!queue.length) {
+        requestFlush();
+        flushing = true;
+    }
+    queue[queue.length] = task;
+}
+
+var queue = [];
+var flushing = false;
+var requestFlush;
+var index = 0;
+var capacity = 1024;
+
+function flush() {
+    while (index < queue.length) {
+        var currentIndex = index;
+        index = index + 1;
+        queue[currentIndex].call();
+        if (index > capacity) {
+            for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {
+                queue[scan] = queue[scan + index];
+            }
+            queue.length -= index;
+            index = 0;
+        }
+    }
+    queue.length = 0;
+    index = 0;
+    flushing = false;
+}
+
+var scope = typeof globalThis !== "undefined" ? globalThis : (typeof self !== "undefined" ? self : window);
+var BrowserMutationObserver = scope.MutationObserver || scope.WebKitMutationObserver;
+
+if (typeof BrowserMutationObserver === "function") {
+    requestFlush = makeRequestCallFromMutationObserver(flush);
+} else {
+    requestFlush = makeRequestCallFromTimer(flush);
+}
+
+rawAsap.requestFlush = requestFlush;
+
+function makeRequestCallFromMutationObserver(callback) {
+    var toggle = 1;
+    var observer = new BrowserMutationObserver(callback);
+    var node = document.createTextNode("");
+    observer.observe(node, {characterData: true});
+    return function requestCall() {
+        toggle = -toggle;
+        node.data = toggle;
+    };
+}
+
+function makeRequestCallFromTimer(callback) {
+    return function requestCall() {
+        var timeoutHandle = setTimeout(handleTimer, 0);
+        var intervalHandle = setInterval(handleTimer, 50);
+        function handleTimer() {
+            clearTimeout(timeoutHandle);
+            clearInterval(intervalHandle);
+            callback();
+        }
+    };
+}
+
+// This is for asap.js only
+rawAsap.makeRequestCallFromTimer = makeRequestCallFromTimer;
+
+export default rawAsap;
+export { rawAsap, makeRequestCallFromTimer };

package/browser-modules/asap.js

@@ -0,0 +1,57 @@
+/**
+ * ESM version of asap/browser-asap.js
+ * High-priority task queue with error handling for browsers.
+ */
+
+import rawAsap from "./asap-raw.js";
+
+var freeTasks = [];
+var pendingErrors = [];
+var requestErrorThrow = rawAsap.makeRequestCallFromTimer(throwFirstError);
+
+function throwFirstError() {
+    if (pendingErrors.length) {
+        throw pendingErrors.shift();
+    }
+}
+
+/**
+ * Calls a task as soon as possible after returning, in its own event, with priority
+ * over other events like animation, reflow, and repaint. An error thrown from an
+ * event will not interrupt, nor even substantially slow down the processing of
+ * other events, but will be rather postponed to a lower priority event.
+ * @param {{call}} task A callable object, typically a function that takes no arguments.
+ */
+function asap(task) {
+    var rawTask;
+    if (freeTasks.length) {
+        rawTask = freeTasks.pop();
+    } else {
+        rawTask = new RawTask();
+    }
+    rawTask.task = task;
+    rawAsap(rawTask);
+}
+
+function RawTask() {
+    this.task = null;
+}
+
+RawTask.prototype.call = function () {
+    try {
+        this.task.call();
+    } catch (error) {
+        if (asap.onerror) {
+            asap.onerror(error);
+        } else {
+            pendingErrors.push(error);
+            requestErrorThrow();
+        }
+    } finally {
+        this.task = null;
+        freeTasks[freeTasks.length] = this;
+    }
+};
+
+export default asap;
+export { asap };

package/browser-modules/buffer.js

@@ -2096,4 +2096,6 @@ function BufferBigIntNotDefined() {
 
 globalThis.Buffer = Buffer
 
-export { Buffer, SlowBuffer }
+const isBuffer = Buffer.isBuffer
+
+export { Buffer, SlowBuffer, isBuffer }

package/browser-modules/child_process.js

@@ -0,0 +1,145 @@
+// Browser polyfill for child_process module
+// child_process is not available in browser environments, so we provide stubs
+// that throw meaningful errors when called
+
+class NotSupportedError extends Error {
+   constructor(method) {
+      super(`child_process.${method}() is not supported in browser environments`)
+      this.name = 'NotSupportedError'
+      this.code = 'ERR_NOT_SUPPORTED'
+   }
+}
+
+export function spawn(command, args, options) {
+   throw new NotSupportedError('spawn')
+}
+
+export function spawnSync(command, args, options) {
+   throw new NotSupportedError('spawnSync')
+}
+
+export function exec(command, options, callback) {
+   if (typeof options === 'function') {
+      callback = options
+      options = {}
+   }
+   const error = new NotSupportedError('exec')
+   if (callback) {
+      process.nextTick(() => callback(error, '', ''))
+   }
+   return {
+      stdin: null,
+      stdout: null,
+      stderr: null,
+      kill: () => false,
+      on: () => {},
+      once: () => {},
+      removeListener: () => {},
+   }
+}
+
+export function execSync(command, options) {
+   throw new NotSupportedError('execSync')
+}
+
+export function execFile(file, args, options, callback) {
+   if (typeof args === 'function') {
+      callback = args
+      args = []
+      options = {}
+   } else if (typeof options === 'function') {
+      callback = options
+      options = {}
+   }
+   const error = new NotSupportedError('execFile')
+   if (callback) {
+      process.nextTick(() => callback(error, '', ''))
+   }
+   return {
+      stdin: null,
+      stdout: null,
+      stderr: null,
+      kill: () => false,
+      on: () => {},
+      once: () => {},
+      removeListener: () => {},
+   }
+}
+
+export function execFileSync(file, args, options) {
+   throw new NotSupportedError('execFileSync')
+}
+
+export function fork(modulePath, args, options) {
+   throw new NotSupportedError('fork')
+}
+
+// ChildProcess class stub
+export class ChildProcess {
+   constructor() {
+      this.stdin = null
+      this.stdout = null
+      this.stderr = null
+      this.stdio = [null, null, null]
+      this.killed = false
+      this.pid = undefined
+      this.connected = false
+      this.exitCode = null
+      this.signalCode = null
+   }
+
+   kill(signal) {
+      return false
+   }
+
+   send(message, sendHandle, options, callback) {
+      throw new NotSupportedError('ChildProcess.send')
+   }
+
+   disconnect() {
+      throw new NotSupportedError('ChildProcess.disconnect')
+   }
+
+   ref() {
+      return this
+   }
+
+   unref() {
+      return this
+   }
+
+   on(event, listener) {
+      return this
+   }
+
+   once(event, listener) {
+      return this
+   }
+
+   off(event, listener) {
+      return this
+   }
+
+   removeListener(event, listener) {
+      return this
+   }
+
+   removeAllListeners(event) {
+      return this
+   }
+
+   emit(event, ...args) {
+      return false
+   }
+}
+
+export default {
+   spawn,
+   spawnSync,
+   exec,
+   execSync,
+   execFile,
+   execFileSync,
+   fork,
+   ChildProcess,
+}

package/browser-modules/events.js

@@ -0,0 +1,200 @@
+// Browser polyfill for node:events module
+
+export class EventEmitter {
+   constructor() {
+      this._events = Object.create(null)
+      this._maxListeners = EventEmitter.defaultMaxListeners
+   }
+
+   static defaultMaxListeners = 10
+
+   setMaxListeners(n) {
+      this._maxListeners = n
+      return this
+   }
+
+   getMaxListeners() {
+      return this._maxListeners
+   }
+
+   emit(type, ...args) {
+      const listeners = this._events[type]
+      if (!listeners || listeners.length === 0) {
+         if (type === 'error') {
+            const err = args[0]
+            throw err instanceof Error ? err : new Error('Unhandled error: ' + err)
+         }
+         return false
+      }
+
+      for (const listener of [...listeners]) {
+         listener.apply(this, args)
+      }
+      return true
+   }
+
+   on(type, listener) {
+      return this.addListener(type, listener)
+   }
+
+   addListener(type, listener) {
+      if (typeof listener !== 'function') {
+         throw new TypeError('listener must be a function')
+      }
+      if (!this._events[type]) {
+         this._events[type] = []
+      }
+      this._events[type].push(listener)
+      return this
+   }
+
+   once(type, listener) {
+      if (typeof listener !== 'function') {
+         throw new TypeError('listener must be a function')
+      }
+      const wrapped = (...args) => {
+         this.removeListener(type, wrapped)
+         listener.apply(this, args)
+      }
+      wrapped.listener = listener
+      return this.addListener(type, wrapped)
+   }
+
+   prependListener(type, listener) {
+      if (typeof listener !== 'function') {
+         throw new TypeError('listener must be a function')
+      }
+      if (!this._events[type]) {
+         this._events[type] = []
+      }
+      this._events[type].unshift(listener)
+      return this
+   }
+
+   prependOnceListener(type, listener) {
+      if (typeof listener !== 'function') {
+         throw new TypeError('listener must be a function')
+      }
+      const wrapped = (...args) => {
+         this.removeListener(type, wrapped)
+         listener.apply(this, args)
+      }
+      wrapped.listener = listener
+      return this.prependListener(type, wrapped)
+   }
+
+   off(type, listener) {
+      return this.removeListener(type, listener)
+   }
+
+   removeListener(type, listener) {
+      const listeners = this._events[type]
+      if (!listeners) return this
+
+      const index = listeners.findIndex(
+         (l) => l === listener || l.listener === listener
+      )
+      if (index !== -1) {
+         listeners.splice(index, 1)
+         if (listeners.length === 0) {
+            delete this._events[type]
+         }
+      }
+      return this
+   }
+
+   removeAllListeners(type) {
+      if (type) {
+         delete this._events[type]
+      } else {
+         this._events = Object.create(null)
+      }
+      return this
+   }
+
+   listeners(type) {
+      const listeners = this._events[type]
+      if (!listeners) return []
+      return listeners.map((l) => l.listener || l)
+   }
+
+   rawListeners(type) {
+      return this._events[type] ? [...this._events[type]] : []
+   }
+
+   listenerCount(type) {
+      const listeners = this._events[type]
+      return listeners ? listeners.length : 0
+   }
+
+   eventNames() {
+      return Object.keys(this._events)
+   }
+}
+
+// Static method
+export function once(emitter, name) {
+   return new Promise((resolve, reject) => {
+      const onEvent = (...args) => {
+         emitter.removeListener('error', onError)
+         resolve(args)
+      }
+      const onError = (err) => {
+         emitter.removeListener(name, onEvent)
+         reject(err)
+      }
+      emitter.once(name, onEvent)
+      if (name !== 'error') {
+         emitter.once('error', onError)
+      }
+   })
+}
+
+export function on(emitter, event) {
+   const queue = []
+   let resolve = null
+   let done = false
+
+   const listener = (...args) => {
+      if (resolve) {
+         resolve({ value: args, done: false })
+         resolve = null
+      } else {
+         queue.push(args)
+      }
+   }
+
+   emitter.on(event, listener)
+
+   return {
+      [Symbol.asyncIterator]() {
+         return this
+      },
+      async next() {
+         if (done) {
+            return { value: undefined, done: true }
+         }
+         if (queue.length > 0) {
+            return { value: queue.shift(), done: false }
+         }
+         return new Promise((res) => {
+            resolve = res
+         })
+      },
+      async return() {
+         done = true
+         emitter.removeListener(event, listener)
+         return { value: undefined, done: true }
+      },
+   }
+}
+
+export function getEventListeners(emitter, name) {
+   return emitter.listeners(name)
+}
+
+export function listenerCount(emitter, type) {
+   return emitter.listenerCount(type)
+}
+
+export default EventEmitter

package/browser-modules/side-effects.js

@@ -0,0 +1,8 @@
+// Side effects script that provides Node.js globals for browser environment
+// This file is injected by esbuild to polyfill globals like Buffer
+
+import './process.js'
+import './buffer.js'
+
+// Make Buffer available globally
+globalThis.Buffer = Buffer