@lynx-js/react 0.109.2 → 0.110.0

package/runtime/src/snapshot/ref.ts

@@ -3,21 +3,18 @@
 // LICENSE file in the root directory of this source tree.
 import type { Element, Worklet, WorkletRefImpl } from '@lynx-js/react/worklet-runtime/bindings';
 
-import { nextCommitTaskId } from '../lifecycle/patch/commit.js';
-import { SnapshotInstance, backgroundSnapshotInstanceManager } from '../snapshot.js';
+import type { SnapshotInstance } from '../snapshot.js';
 import { workletUnRef } from './workletRef.js';
+import { RefProxy } from '../lifecycle/ref/delay.js';
 
-let globalRefPatch: Record<string, number | null> = {};
-const globalRefsToRemove: Map</* commitId */ number, Map</* sign */ string, /* ref */ any>> = /* @__PURE__ */ new Map();
-const globalRefsToSet: Map</* commitId */ number, Record<string, number>> = /* @__PURE__ */ new Map();
-let nextRefId = 1;
+const refsToClear: Ref[] = [];
+const refsToApply: (Ref | [snapshotInstanceId: number, expIndex: number])[] = [];
 
-function unref(snapshot: SnapshotInstance, recursive: boolean): void {
-  snapshot.__ref_set?.forEach(v => {
-    globalRefPatch[v] = null;
-  });
-  snapshot.__ref_set?.clear();
+type Ref = (((ref: RefProxy) => () => void) | { current: RefProxy | null }) & {
+  _unmount?: () => void;
+};
 
+function unref(snapshot: SnapshotInstance, recursive: boolean): void {
   snapshot.__worklet_ref_set?.forEach(v => {
     if (v) {
       workletUnRef(v as Worklet | WorkletRefImpl<Element>);
@@ -32,91 +29,65 @@ function unref(snapshot: SnapshotInstance, recursive: boolean): void {
   }
 }
 
-function applyRef(ref: any, value: any) {
-  // TODO: ref: exceptions thrown in user functions should be able to be caught by an Error Boundary
-  if (typeof ref == 'function') {
-    const hasRefUnmount = typeof ref._unmount == 'function';
-    if (hasRefUnmount) {
-      // @ts-ignore TS doesn't like moving narrowing checks into variables
-      ref._unmount();
-    }
+// This function is modified from preact source code.
+function applyRef(ref: Ref, value: null | [snapshotInstanceId: number, expIndex: number]): void {
+  const newRef = value && new RefProxy(value);
 
-    if (!hasRefUnmount || value != null) {
-      // Store the cleanup function on the function
-      // instance object itself to avoid shape
-      // transitioning vnode
-      ref._unmount = ref(value);
-    }
-  } else ref.current = value;
-}
+  try {
+    if (typeof ref == 'function') {
+      const hasRefUnmount = typeof ref._unmount == 'function';
+      if (hasRefUnmount) {
+        ref._unmount!();
+      }
 
-function updateBackgroundRefs(commitId: number): void {
-  const oldRefMap = globalRefsToRemove.get(commitId);
-  if (oldRefMap) {
-    globalRefsToRemove.delete(commitId);
-    for (const ref of oldRefMap.values()) {
-      applyRef(ref, null);
-    }
-  }
-  const newRefMap = globalRefsToSet.get(commitId);
-  if (newRefMap) {
-    globalRefsToSet.delete(commitId);
-    for (const sign in newRefMap) {
-      const ref = backgroundSnapshotInstanceManager.getValueBySign(sign);
-      if (ref) {
-        // TODO: ref: support __REF_FIRE_IMMEDIATELY__
-        const v = newRefMap[sign] && lynx.createSelectorQuery().selectUniqueID(newRefMap[sign]);
-        applyRef(ref, v);
+      if (!hasRefUnmount || newRef != null) {
+        // Store the cleanup function on the function
+        // instance object itself to avoid shape
+        // transitioning vnode
+        ref._unmount = ref(newRef!);
       }
-    }
+    } else ref.current = newRef;
+    /* v8 ignore start */
+  } catch (e) {
+    lynx.reportError(e as Error);
   }
+  /* v8 ignore stop */
 }
 
 function updateRef(
   snapshot: SnapshotInstance,
   expIndex: number,
-  oldValue: any,
+  oldValue: string | null,
   elementIndex: number,
-  spreadKey: string,
 ): void {
-  const value = snapshot.__values![expIndex];
+  const value: unknown = snapshot.__values![expIndex];
   let ref;
-  if (!value) {
-    ref = undefined;
-  } else if (typeof value === 'string') {
+  if (typeof value === 'string') {
     ref = value;
   } else {
-    ref = `${snapshot.__id}:${expIndex}:${spreadKey}`;
+    ref = `react-ref-${snapshot.__id}-${expIndex}`;
   }
 
   snapshot.__values![expIndex] = ref;
-  if (snapshot.__elements && ref) {
-    __SetAttribute(snapshot.__elements[elementIndex]!, 'has-react-ref', true);
-    const uid = __GetElementUniqueID(snapshot.__elements[elementIndex]!);
-    globalRefPatch[ref] = uid;
-    snapshot.__ref_set ??= new Set();
-    snapshot.__ref_set.add(ref);
-  }
-  if (oldValue !== ref) {
-    snapshot.__ref_set?.delete(oldValue);
+  if (snapshot.__elements && oldValue !== ref) {
+    if (oldValue) {
+      __SetAttribute(snapshot.__elements[elementIndex]!, oldValue, undefined);
+    }
+    if (ref) {
+      __SetAttribute(snapshot.__elements[elementIndex]!, ref, 1);
+    }
   }
 }
 
-function takeGlobalRefPatchMap(): Record<string, number | null> {
-  const patch = globalRefPatch;
-  globalRefPatch = {};
-  return patch;
-}
-
-function transformRef(ref: unknown): Function | (object & Record<'current', unknown>) | null | undefined {
+function transformRef(ref: unknown): Ref | null | undefined {
   if (ref === undefined || ref === null) {
     return ref;
   }
   if (typeof ref === 'function' || (typeof ref === 'object' && 'current' in ref)) {
     if ('__ref' in ref) {
-      return ref;
+      return ref as Ref;
     }
-    return Object.defineProperty(ref, '__ref', { value: nextRefId++ });
+    return Object.defineProperty(ref, '__ref', { value: 1 }) as Ref;
   }
   throw new Error(
     `Elements' "ref" property should be a function, or an object created `
@@ -124,25 +95,44 @@ function transformRef(ref: unknown): Function | (object & Record<'current', unkn
   );
 }
 
-function markRefToRemove(sign: string, ref: unknown): void {
-  if (!ref) {
+function applyQueuedRefs(): void {
+  try {
+    for (const ref of refsToClear) {
+      applyRef(ref, null);
+    }
+    for (let i = 0; i < refsToApply.length; i += 2) {
+      const ref = refsToApply[i] as Ref;
+      const value = refsToApply[i + 1] as [snapshotInstanceId: number, expIndex: number] | null;
+      applyRef(ref, value);
+    }
+  } finally {
+    clearQueuedRefs();
+  }
+}
+
+function queueRefAttrUpdate(
+  oldRef: Ref | null | undefined,
+  newRef: Ref | null | undefined,
+  snapshotInstanceId: number,
+  expIndex: number,
+): void {
+  if (oldRef === newRef) {
     return;
   }
-  let oldRefs = globalRefsToRemove.get(nextCommitTaskId);
-  if (!oldRefs) {
-    oldRefs = new Map();
-    globalRefsToRemove.set(nextCommitTaskId, oldRefs);
+  if (oldRef) {
+    refsToClear.push(oldRef);
+  }
+  if (newRef) {
+    refsToApply.push(newRef, [snapshotInstanceId, expIndex]);
   }
-  oldRefs.set(sign, ref);
 }
 
-export {
-  globalRefsToRemove,
-  globalRefsToSet,
-  markRefToRemove,
-  takeGlobalRefPatchMap,
-  transformRef,
-  unref,
-  updateBackgroundRefs,
-  updateRef,
-};
+function clearQueuedRefs(): void {
+  refsToClear.length = 0;
+  refsToApply.length = 0;
+}
+
+/**
+ * @internal
+ */
+export { queueRefAttrUpdate, updateRef, unref, transformRef, applyRef, applyQueuedRefs, clearQueuedRefs, type Ref };

package/runtime/src/snapshot/spread.ts

@@ -93,7 +93,6 @@ function updateSpread(snapshot: SnapshotInstance, index: number, oldValue: any,
       } else if (key.startsWith('data-')) {
         // collected below
       } else if (key === 'ref') {
-        snapshot.__ref_set ??= new Set();
         const fakeSnapshot = {
           __values: {
             get [index]() {
@@ -106,9 +105,8 @@ function updateSpread(snapshot: SnapshotInstance, index: number, oldValue: any,
           },
           __id: snapshot.__id,
           __elements: snapshot.__elements,
-          __ref_set: snapshot.__ref_set,
         } as SnapshotInstance;
-        updateRef(fakeSnapshot, index, oldValue[key], elementIndex, key);
+        updateRef(fakeSnapshot, index, oldValue[key], elementIndex);
       } else if (key.endsWith(':ref')) {
         snapshot.__worklet_ref_set ??= new Set();
         const fakeSnapshot = {
@@ -189,7 +187,6 @@ function updateSpread(snapshot: SnapshotInstance, index: number, oldValue: any,
       } else if (key.startsWith('data-')) {
         // collected below
       } else if (key === 'ref') {
-        snapshot.__ref_set ??= new Set();
         const fakeSnapshot = {
           __values: {
             get [index]() {
@@ -202,9 +199,8 @@ function updateSpread(snapshot: SnapshotInstance, index: number, oldValue: any,
           },
           __id: snapshot.__id,
           __elements: snapshot.__elements,
-          __ref_set: snapshot.__ref_set,
         } as SnapshotInstance;
-        updateRef(fakeSnapshot, index, oldValue[key], elementIndex, key);
+        updateRef(fakeSnapshot, index, oldValue[key], elementIndex);
       } else if (key.endsWith(':ref')) {
         snapshot.__worklet_ref_set ??= new Set();
         const fakeSnapshot = {
@@ -284,8 +280,12 @@ function transformSpread(
       value ??= '';
       result['className'] = value;
     } else if (key === 'ref') {
-      // @ts-ignore
-      result[key] = transformRef(value)?.__ref;
+      if (__LEPUS__) {
+        result[key] = value ? 1 : undefined;
+      } else {
+        // @ts-ignore
+        result[key] = transformRef(value)?.__ref;
+      }
     } else if (typeof value === 'function') {
       result[key] = `${snapshot.__id}:${index}:${key}`;
     } else {

package/runtime/src/snapshot/workletRef.ts

@@ -1,12 +1,34 @@
 // Copyright 2024 The Lynx Authors. All rights reserved.
 // Licensed under the Apache License Version 2.0 that can be found in the
 // LICENSE file in the root directory of this source tree.
-import { runWorkletCtx, updateWorkletRef as update } from '@lynx-js/react/worklet-runtime/bindings';
+
+import { onWorkletCtxUpdate, runWorkletCtx, updateWorkletRef as update } from '@lynx-js/react/worklet-runtime/bindings';
 import type { Element, Worklet, WorkletRefImpl } from '@lynx-js/react/worklet-runtime/bindings';
 
+import { isMainThreadHydrationFinished } from '../lifecycle/patch/isMainThreadHydrationFinished.js';
 import type { SnapshotInstance } from '../snapshot.js';
 
-function workletUnRef(value: Worklet | WorkletRefImpl<Element>): void {
+let mtRefQueue: (WorkletRefImpl<Element> | Worklet | Element)[] = [];
+
+export function applyRefQueue(): void {
+  const queue = mtRefQueue;
+  mtRefQueue = [];
+  for (let i = 0; i < queue.length; i += 2) {
+    const worklet = queue[i] as Worklet | WorkletRefImpl<Element>;
+    const element = queue[i + 1] as Element;
+    if ('_wvid' in worklet) {
+      update(worklet as WorkletRefImpl<Element>, element);
+    } else if ('_wkltId' in worklet) {
+      worklet._unmount = runWorkletCtx(worklet, [{ elementRefptr: element }]) as () => void;
+    }
+  }
+}
+
+function addToRefQueue(worklet: Worklet | WorkletRefImpl<Element>, element: Element): void {
+  mtRefQueue.push(worklet, element);
+}
+
+export function workletUnRef(value: Worklet | WorkletRefImpl<Element>): void {
   if ('_wvid' in value) {
     update(value as WorkletRefImpl<Element>, null);
   } else if ('_wkltId' in value) {
@@ -18,7 +40,7 @@ function workletUnRef(value: Worklet | WorkletRefImpl<Element>): void {
   }
 }
 
-function updateWorkletRef(
+export function updateWorkletRef(
   snapshot: SnapshotInstance,
   expIndex: number,
   oldValue: WorkletRefImpl<Element> | Worklet | undefined,
@@ -38,11 +60,17 @@ function updateWorkletRef(
   if (value === null || value === undefined) {
     // do nothing
   } else if (value._wvid) {
-    update(value as WorkletRefImpl<Element>, snapshot.__elements[elementIndex]!);
+    const element = snapshot.__elements[elementIndex]! as Element;
+    addToRefQueue(value as Worklet, element);
   } else if ((value as Worklet)._wkltId) {
-    (value as Worklet)._unmount = runWorkletCtx(value as Worklet, [{
-      elementRefptr: (snapshot.__elements[elementIndex]!) as any,
-    }]) as () => void;
+    const element = snapshot.__elements[elementIndex]! as Element;
+    onWorkletCtxUpdate(
+      value as Worklet,
+      oldValue as Worklet | undefined,
+      !isMainThreadHydrationFinished,
+      element,
+    );
+    addToRefQueue(value as Worklet, element);
     /* v8 ignore next 3 */
   } else if (value._type === '__LEPUS__' || (value as Worklet)._lepusWorkletHash) {
     // for pre-0.99 compatibility
@@ -58,5 +86,3 @@ function updateWorkletRef(
   // Add an arbitrary attribute to avoid this element being layout-only
   __SetAttribute(snapshot.__elements[elementIndex]!, 'has-react-ref', true);
 }
-
-export { updateWorkletRef, workletUnRef };

package/runtime/src/snapshot.ts

@@ -39,7 +39,7 @@ export const enum DynamicPartType {
  * A snapshot definition that contains all the information needed to create and update elements
  * This is generated at compile time through static analysis of the JSX
  */
-interface Snapshot {
+export interface Snapshot {
   create: null | ((ctx: SnapshotInstance) => FiberElement[]);
   update: null | ((ctx: SnapshotInstance, index: number, oldValue: any) => void)[];
   slot: [DynamicPartType, number][];
@@ -47,6 +47,7 @@ interface Snapshot {
   isListHolder?: boolean;
   cssId?: number | undefined;
   entryName?: string | undefined;
+  refAndSpreadIndexes?: number[] | null;
 }
 
 export let __page: FiberElement;
@@ -166,7 +167,7 @@ export const backgroundSnapshotInstanceManager: {
     if (!res || (res.length != 2 && res.length != 3)) {
       throw new Error('Invalid ctx format: ' + str);
     }
-    let id = Number(res[0]);
+    const id = Number(res[0]);
     const expIndex = Number(res[1]);
     const ctx = this.values.get(id);
     if (!ctx) {
@@ -190,8 +191,9 @@ export function createSnapshot(
   create: Snapshot['create'] | null,
   update: Snapshot['update'] | null,
   slot: Snapshot['slot'],
-  cssId?: number,
-  entryName?: string,
+  cssId: number | undefined,
+  entryName: string | undefined,
+  refAndSpreadIndexes: number[] | null,
 ): string {
   if (
     __DEV__ && __JS__
@@ -221,7 +223,7 @@ export function createSnapshot(
 
   uniqID = entryUniqID(uniqID, entryName);
 
-  const s: Snapshot = { create, update, slot, cssId, entryName };
+  const s: Snapshot = { create, update, slot, cssId, entryName, refAndSpreadIndexes };
   snapshotManager.values.set(uniqID, s);
   if (slot && slot[0] && slot[0][0] === DynamicPartType.ListChildren) {
     s.isListHolder = true;
@@ -268,12 +270,15 @@ export class SnapshotInstance {
   __element_root?: FiberElement | undefined;
   __values?: any[] | undefined;
   __current_slot_index = 0;
-  __ref_set?: Set<string>;
   __worklet_ref_set?: Set<WorkletRefImpl<any> | Worklet>;
   __listItemPlatformInfo?: any;
 
   constructor(public type: string, id?: number) {
     this.__snapshot_def = snapshotManager.values.get(type)!;
+    // Suspense uses 'div'
+    if (!this.__snapshot_def && type !== 'div') {
+      throw new Error('Snapshot not found: ' + type);
+    }
 
     id ||= snapshotInstanceManager.nextId -= 1;
     this.__id = id;
@@ -291,15 +296,15 @@ export class SnapshotInstance {
       //   CSS Scope is removed(We only need to call `__SetCSSId` when there is `entryName`)
       //   Or an old bundle(`__SetCSSId` is called in `create`), we skip calling `__SetCSSId`
       if (entryName !== DEFAULT_ENTRY_NAME && entryName !== undefined) {
-        __SetCSSId(this.__elements!, DEFAULT_CSS_ID, entryName);
+        __SetCSSId(this.__elements, DEFAULT_CSS_ID, entryName);
       }
     } else {
       // cssId !== undefined
       if (entryName !== DEFAULT_ENTRY_NAME && entryName !== undefined) {
         // For lazy bundle, we need add `entryName` to the third params
-        __SetCSSId(this.__elements!, cssId, entryName);
+        __SetCSSId(this.__elements, cssId, entryName);
       } else {
-        __SetCSSId(this.__elements!, cssId);
+        __SetCSSId(this.__elements, cssId);
       }
     }
 
@@ -388,6 +393,14 @@ export class SnapshotInstance {
     return a;
   }
 
+  tearDown(): void {
+    traverseSnapshotInstance(this, v => {
+      v.__parent = null;
+      v.__previousSibling = null;
+      v.__nextSibling = null;
+    });
+  }
+
   // onCreate?: () => void;
   // onAttach?: () => void;
   // onDetach?: () => void;
@@ -539,26 +552,22 @@ export class SnapshotInstance {
   }
 
   removeChild(child: SnapshotInstance): void {
-    const r = () => {
-      this.__removeChild(child);
-      traverseSnapshotInstance(child, v => {
-        v.__parent = null;
-        snapshotInstanceManager.values.delete(v.__id);
-      });
-    };
-
     const __snapshot_def = this.__snapshot_def;
     if (__snapshot_def.isListHolder) {
       (__pendingListUpdates.values[this.__id] ??= new ListUpdateInfoRecording(
         this,
       )).onRemoveChild(child);
-      r();
+
+      this.__removeChild(child);
+      traverseSnapshotInstance(child, v => {
+        snapshotInstanceManager.values.delete(v.__id);
+      });
+      // mark this child as deleted
+      child.__id = 0;
       return;
     }
 
-    // TODO: ref: can this be done on the background thread?
     unref(child, true);
-    r();
     if (this.__elements) {
       const [, elementIndex] = __snapshot_def.slot[0]!;
       __RemoveElement(this.__elements[elementIndex]!, child.__element_root!);
@@ -567,6 +576,16 @@ export class SnapshotInstance {
     if (child.__snapshot_def.isListHolder) {
       snapshotDestroyList(child);
     }
+
+    this.__removeChild(child);
+    traverseSnapshotInstance(child, v => {
+      v.__parent = null;
+      v.__previousSibling = null;
+      v.__nextSibling = null;
+      delete v.__elements;
+      delete v.__element_root;
+      snapshotInstanceManager.values.delete(v.__id);
+    });
   }
 
   setAttribute(key: string | number, value: any): void {

package/runtime/src/snapshotInstanceHydrationMap.ts

@@ -0,0 +1,17 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+/**
+ * A map to store hydration states between snapshot instances.
+ * K->V: main thread snapshotInstance IDs -> background snapshotInstance IDs.
+ *
+ * The map is used by the ref system to translate between snapshot instance IDs when
+ * operations need to cross the thread boundary during the commit phase.
+ */
+const hydrationMap: Map<number, number> = new Map();
+
+/**
+ * @internal
+ */
+export { hydrationMap };

package/runtime/src/worklet/workletRef.ts

@@ -54,10 +54,9 @@ abstract class WorkletRef<T> {
       throw new Error('MainThreadRef: value of a MainThreadRef cannot be accessed in the background thread.');
     }
     if (__LEPUS__ && __DEV__) {
-      /* v8 ignore next */
+      /* v8 ignore next 3 */
       throw new Error('MainThreadRef: value of a MainThreadRef cannot be accessed outside of main thread script.');
     }
-    /* v8 ignore next */
     return undefined as T;
   }
 

package/testing-library/dist/env/vitest.js

@@ -149,7 +149,7 @@ const initElementTree = ()=>{
             e.id = id;
         }
         __SetInlineStyles(e, styles) {
-            if ('string' == typeof styles) e.style.cssText = styles;
+            if ('string' == typeof styles) e.setAttributeNS(null, 'style', styles);
             else Object.assign(e.style, styles);
         }
         __AddDataset(e, key, value) {
@@ -357,7 +357,7 @@ function createPolyfills() {
 function injectMainThreadGlobals(target, polyfills) {
     var _globalThis_onInjectMainThreadGlobals, _globalThis;
     __injectElementApi(target);
-    const { performance, JsContext, __LoadLepusChunk } = polyfills || {};
+    const { performance, CoreContext, JsContext, __LoadLepusChunk } = polyfills || {};
     if (void 0 === target) target = globalThis;
     target.__DEV__ = true;
     target.__PROFILE__ = true;
@@ -372,6 +372,7 @@ function injectMainThreadGlobals(target, polyfills) {
     target.globDynamicComponentEntry = '__Card__';
     target.lynx = {
         performance,
+        getCoreContext: ()=>CoreContext,
         getJSContext: ()=>JsContext,
         reportError: (e)=>{
             throw e;
@@ -410,7 +411,7 @@ class NodesRef {
 }
 function injectBackgroundThreadGlobals(target, polyfills) {
     var _globalThis_onInjectBackgroundThreadGlobals, _globalThis;
-    const { app, performance, CoreContext, __LoadLepusChunk } = polyfills || {};
+    const { app, performance, CoreContext, JsContext, __LoadLepusChunk } = polyfills || {};
     if (void 0 === target) target = globalThis;
     target.__DEV__ = true;
     target.__PROFILE__ = true;
@@ -442,6 +443,7 @@ function injectBackgroundThreadGlobals(target, polyfills) {
                 }
             }),
         getCoreContext: ()=>CoreContext,
+        getJSContext: ()=>JsContext,
         getJSModule: (moduleName)=>{
             if ('GlobalEventEmitter' === moduleName) return globalEventEmitter;
             throw new Error(`getJSModule(${moduleName}) not implemented`);

package/testing-library/dist/pure.js

@@ -14413,9 +14413,10 @@ function __webpack_require__(moduleId) {
     };
 })();
 var dom_esm = __webpack_require__("../../../node_modules/.pnpm/@testing-library+dom@10.4.0/node_modules/@testing-library/dom/dist/@testing-library/dom.esm.js");
-let NodesRef = lynx.createSelectorQuery().selectUniqueID(-1).constructor;
+const NodesRef = lynx.createSelectorQuery().selectUniqueID(-1).constructor;
 function getElement(elemOrNodesRef) {
     if (elemOrNodesRef instanceof NodesRef) return __GetElementByUniqueId(Number(elemOrNodesRef._nodeSelectToken.identifier));
+    if ('refAttr' in elemOrNodesRef) return document.querySelector(`[react-ref-${elemOrNodesRef.refAttr[0]}-${elemOrNodesRef.refAttr[1]}]`);
     if (elemOrNodesRef?.constructor?.name === 'HTMLUnknownElement') return elemOrNodesRef;
     throw new Error('Invalid element, got: ' + elemOrNodesRef.constructor?.name);
 }
@@ -14423,7 +14424,7 @@ const fireEvent = (elemOrNodesRef, ...args)=>{
     const isMainThread = __MAIN_THREAD__;
     lynxTestingEnv.switchToBackgroundThread();
     const elem = getElement(elemOrNodesRef);
-    let ans = (0, dom_esm.BX)(elem, ...args);
+    const ans = (0, dom_esm.BX)(elem, ...args);
     if (isMainThread) lynxTestingEnv.switchToMainThread();
     return ans;
 };
@@ -14542,7 +14543,7 @@ Object.keys(eventMap).forEach((key)=>{
         const isMainThread = __MAIN_THREAD__;
         lynxTestingEnv.switchToBackgroundThread();
         const elem = getElement(elemOrNodesRef);
-        const eventType = init?.['eventType'] || 'bindEvent';
+        const eventType = init?.eventType || 'bindEvent';
         init = {
             eventType,
             eventName: key,