@miaskiewicz/turbo-dom 0.1.40 → 0.1.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miaskiewicz/turbo-dom",
-  "version": "0.1.40",
+  "version": "0.1.42",
   "description": "Faster, more spec-correct DOM for test runners — native html5ever (Rust/WASM) parser + lazy copy-on-write DOM. A drop-in-style alternative to jsdom/happy-dom for vitest & jest.",
   "license": "MIT",
   "main": "index.js",

package/src/runtime/events.mjs

@@ -106,12 +106,6 @@ export const TouchEvent = makeTyped('TouchEvent');
 export const DragEvent = makeTyped('DragEvent');
 export const ProgressEvent = makeTyped('ProgressEvent');
 
-function normalizeOptions(options) {
-  if (typeof options === 'boolean') return { capture: options, once: false, passive: false };
-  options = options || {};
-  return { capture: !!options.capture, once: !!options.once, passive: !!options.passive };
-}
-
 // ---- shadow DOM event support ----
 // Duck-typed (ShadowRoot sets `__isShadowRoot`/`host`) to avoid a dom.mjs import
 // cycle. NONE of this runs unless the document has a shadow root attached — the
@@ -149,22 +143,28 @@ export class EventTarget {
 
   addEventListener(type, callback, options) {
     if (callback == null) return;
-    const o = normalizeOptions(options);
+    // Inlined option parsing — avoids a throwaway normalizeOptions object AND a
+    // per-call .some() closure on this hot path (React attaches many listeners
+    // at mount). Boolean options → capture; object → capture/once/passive.
+    let capture = false, once = false, passive = false;
+    if (typeof options === 'boolean') capture = options;
+    else if (options) { capture = !!options.capture; once = !!options.once; passive = !!options.passive; }
     if (!this.__listeners) this.__listeners = new Map();
     let list = this.__listeners.get(type);
     if (!list) { list = []; this.__listeners.set(type, list); }
     // dedupe on (callback, capture) per spec
-    if (list.some((l) => l.callback === callback && l.capture === o.capture)) return;
-    list.push({ callback, capture: o.capture, once: o.once, passive: o.passive });
+    for (let i = 0; i < list.length; i++) if (list[i].callback === callback && list[i].capture === capture) return;
+    list.push({ callback, capture, once, passive });
   }
 
   removeEventListener(type, callback, options) {
     if (!this.__listeners) return;
-    const o = normalizeOptions(options);
+    const capture = typeof options === 'boolean' ? options : !!(options && options.capture);
     const list = this.__listeners.get(type);
     if (!list) return;
-    const i = list.findIndex((l) => l.callback === callback && l.capture === o.capture);
-    if (i !== -1) list.splice(i, 1);
+    for (let i = 0; i < list.length; i++) {
+      if (list[i].callback === callback && list[i].capture === capture) { list.splice(i, 1); return; }
+    }
   }
 
   // Build the event path: target up through ancestors to the root.
@@ -238,8 +238,13 @@ export class EventTarget {
         event.target = retarget(target, node);
         if (relatedTarget != null) event.relatedTarget = retarget(relatedTarget, node);
       }
-      // snapshot — listeners added during dispatch don't fire this round
-      for (const l of list.slice()) {
+      // snapshot — listeners added during dispatch don't fire this round. Skip the
+      // slice alloc for the single-listener case (common React-delegated one): a
+      // 1-element, length-captured iteration can't be disturbed by an add/remove in
+      // that one call. Multi-listener keeps the slice (concurrent-mutation guard).
+      const snap = list.length === 1 ? list : list.slice();
+      for (let k = 0, len = snap.length; k < len; k++) {
+        const l = snap[k];
         if (phase === PHASE_CAPTURING && !l.capture) continue;
         if (phase === PHASE_BUBBLING && l.capture) continue;
         if (l.once) {