@lynx-js/react 0.109.2 → 0.110.1

package/runtime/src/snapshot/spread.ts

@@ -9,10 +9,11 @@
  * optimized attribute updates at compile time, avoiding runtime object spreads.
  */
 
-import type { Worklet } from '@lynx-js/react/worklet-runtime/bindings';
+import type { Element, Worklet, WorkletRefImpl } from '@lynx-js/react/worklet-runtime/bindings';
 
-import { BackgroundSnapshotInstance } from '../backgroundSnapshot.js';
-import { ListUpdateInfoRecording, __pendingListUpdates } from '../list.js';
+import type { BackgroundSnapshotInstance } from '../backgroundSnapshot.js';
+import { ListUpdateInfoRecording } from '../listUpdateInfo.js';
+import { __pendingListUpdates } from '../pendingListUpdates.js';
 import { SnapshotInstance } from '../snapshot.js';
 import { isDirectOrDeepEqual, isEmptyObject, pick } from '../utils.js';
 import { updateEvent } from './event.js';
@@ -22,6 +23,7 @@ import { transformRef, updateRef } from './ref.js';
 import { updateWorkletEvent } from './workletEvent.js';
 import { updateWorkletRef } from './workletRef.js';
 
+// eslint-disable-next-line regexp/no-unused-capturing-group
 const eventRegExp = /^(([A-Za-z-]*):)?(bind|catch|capture-bind|capture-catch|global-bind)([A-Za-z]+)$/;
 const eventTypeMap: Record<string, string> = {
   bind: 'bindEvent',
@@ -38,12 +40,16 @@ const noFlattenAttributes = /* @__PURE__ */ new Set<string>([
   'exposure-id',
 ]);
 
-function updateSpread(snapshot: SnapshotInstance, index: number, oldValue: any, elementIndex: number): void {
+function updateSpread(
+  snapshot: SnapshotInstance,
+  index: number,
+  oldValue: Record<string, unknown> | undefined | null,
+  elementIndex: number,
+): void {
   oldValue ??= {};
-  let newValue: Record<string, any> = snapshot.__values![index]; // compiler guarantee this must be an object;
+  let newValue: Record<string, unknown> = snapshot.__values![index] as Record<string, unknown>; // compiler guarantee this must be an object;
 
-  // @ts-ignore
-  const list = snapshot.__parent;
+  const list = snapshot.parentNode;
   if (list?.__snapshot_def.isListHolder) {
     const oldPlatformInfo = pick(oldValue, platformInfoAttributes);
     const platformInfo = pick(newValue, platformInfoAttributes);
@@ -79,21 +85,20 @@ function updateSpread(snapshot: SnapshotInstance, index: number, oldValue: any,
     snapshot.__values![index] = newValue;
   }
 
-  const dataset: Record<string, any> = {};
+  const dataset: Record<string, unknown> = {};
   let match: RegExpMatchArray | null = null;
   for (const key in newValue) {
     const v = newValue[key];
     if (v !== oldValue[key]) {
       if (key === 'className') {
-        __SetClasses(snapshot.__elements[elementIndex]!, v);
+        __SetClasses(snapshot.__elements[elementIndex]!, v as string);
       } else if (key === 'style') {
-        __SetInlineStyles(snapshot.__elements[elementIndex]!, v);
+        __SetInlineStyles(snapshot.__elements[elementIndex]!, v as string);
       } else if (key === 'id') {
-        __SetID(snapshot.__elements[elementIndex]!, v);
+        __SetID(snapshot.__elements[elementIndex]!, v as string);
       } else if (key.startsWith('data-')) {
         // collected below
       } else if (key === 'ref') {
-        snapshot.__ref_set ??= new Set();
         const fakeSnapshot = {
           __values: {
             get [index]() {
@@ -106,9 +111,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] as string | null, elementIndex);
       } else if (key.endsWith(':ref')) {
         snapshot.__worklet_ref_set ??= new Set();
         const fakeSnapshot = {
@@ -121,7 +125,13 @@ function updateSpread(snapshot: SnapshotInstance, index: number, oldValue: any,
           __elements: snapshot.__elements,
           __worklet_ref_set: snapshot.__worklet_ref_set,
         } as SnapshotInstance;
-        updateWorkletRef(fakeSnapshot, index, oldValue[key], elementIndex, key.slice(0, -4));
+        updateWorkletRef(
+          fakeSnapshot,
+          index,
+          oldValue[key] as WorkletRefImpl<Element> | Worklet | null | undefined,
+          elementIndex,
+          key.slice(0, -4),
+        );
       } else if (key.endsWith(':gesture')) {
         const workletType = key.slice(0, -8);
         const fakeSnapshot = {
@@ -189,7 +199,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 +211,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] as string | null, elementIndex);
       } else if (key.endsWith(':ref')) {
         snapshot.__worklet_ref_set ??= new Set();
         const fakeSnapshot = {
@@ -217,7 +225,13 @@ function updateSpread(snapshot: SnapshotInstance, index: number, oldValue: any,
           __elements: snapshot.__elements,
           __worklet_ref_set: snapshot.__worklet_ref_set,
         } as SnapshotInstance;
-        updateWorkletRef(fakeSnapshot, index, oldValue[key], elementIndex, key.slice(0, -4));
+        updateWorkletRef(
+          fakeSnapshot,
+          index,
+          oldValue[key] as WorkletRefImpl<Element> | Worklet | null | undefined,
+          elementIndex,
+          key.slice(0, -4),
+        );
       } else if (key.endsWith(':gesture')) {
         const workletType = key.slice(0, -8);
         const fakeSnapshot = {
@@ -247,7 +261,15 @@ function updateSpread(snapshot: SnapshotInstance, index: number, oldValue: any,
           __elements: snapshot.__elements,
         } as SnapshotInstance;
         if (workletType) {
-          updateWorkletEvent(fakeSnapshot, index, oldValue[key], elementIndex, workletType, eventType, eventName);
+          updateWorkletEvent(
+            fakeSnapshot,
+            index,
+            oldValue[key] as Worklet,
+            elementIndex,
+            workletType,
+            eventType,
+            eventName,
+          );
         } else {
           updateEvent(fakeSnapshot, index, oldValue[key], elementIndex, eventType, eventName, key);
         }
@@ -284,8 +306,11 @@ 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 {
+        result[key] = transformRef(value)?.__ref;
+      }
     } else if (typeof value === 'function') {
       result[key] = `${snapshot.__id}:${index}:${key}`;
     } else {

package/runtime/src/snapshot/workletEvent.ts

@@ -4,8 +4,8 @@
 import { onWorkletCtxUpdate } from '@lynx-js/react/worklet-runtime/bindings';
 import type { Worklet } from '@lynx-js/react/worklet-runtime/bindings';
 
-import { SnapshotInstance } from '../snapshot.js';
 import { isMainThreadHydrationFinished } from '../lifecycle/patch/isMainThreadHydrationFinished.js';
+import { SnapshotInstance } from '../snapshot.js';
 
 function updateWorkletEvent(
   snapshot: SnapshotInstance,

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,10 +40,10 @@ function workletUnRef(value: Worklet | WorkletRefImpl<Element>): void {
   }
 }
 
-function updateWorkletRef(
+export function updateWorkletRef(
   snapshot: SnapshotInstance,
   expIndex: number,
-  oldValue: WorkletRefImpl<Element> | Worklet | undefined,
+  oldValue: WorkletRefImpl<Element> | Worklet | null | undefined,
   elementIndex: number,
   _workletType: string,
 ): void {
@@ -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

@@ -18,28 +18,19 @@ import type { Worklet, WorkletRefImpl } from '@lynx-js/react/worklet-runtime/bin
 
 import type { BackgroundSnapshotInstance } from './backgroundSnapshot.js';
 import { SnapshotOperation, __globalSnapshotPatch } from './lifecycle/patch/snapshotPatch.js';
-import { ListUpdateInfoRecording, __pendingListUpdates, snapshotDestroyList } from './list.js';
+import { ListUpdateInfoRecording } from './listUpdateInfo.js';
+import { __pendingListUpdates } from './pendingListUpdates.js';
+import { DynamicPartType } from './snapshot/dynamicPartType.js';
+import { snapshotDestroyList } from './snapshot/list.js';
+import type { PlatformInfo } from './snapshot/platformInfo.js';
 import { unref } from './snapshot/ref.js';
 import { isDirectOrDeepEqual } from './utils.js';
 
-/**
- * Types of dynamic parts that can be updated in a snapshot
- * These are determined at compile time through static analysis
- */
-export const enum DynamicPartType {
-  Attr = 0, // Regular attribute updates
-  Spread, // Spread operator in JSX
-  Slot, // Slot for component children
-  Children, // Regular children updates
-  ListChildren, // List/array children updates
-  MultiChildren, // Multiple children updates (compat layer)
-}
-
 /**
  * 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 +38,7 @@ interface Snapshot {
   isListHolder?: boolean;
   cssId?: number | undefined;
   entryName?: string | undefined;
+  refAndSpreadIndexes?: number[] | null;
 }
 
 export let __page: FiberElement;
@@ -166,7 +158,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) {
@@ -174,7 +166,7 @@ export const backgroundSnapshotInstanceManager: {
     }
     const spreadKey = res[2];
     if (spreadKey) {
-      return ctx.__values![expIndex][spreadKey];
+      return (ctx.__values![expIndex] as { [spreadKey]: unknown })[spreadKey];
     } else {
       return ctx.__values![expIndex];
     }
@@ -190,8 +182,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 +214,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;
@@ -266,16 +259,19 @@ export class SnapshotInstance {
   __snapshot_def: Snapshot;
   __elements?: FiberElement[] | undefined;
   __element_root?: FiberElement | undefined;
-  __values?: any[] | undefined;
+  __values?: unknown[] | undefined;
   __current_slot_index = 0;
-  __ref_set?: Set<string>;
   __worklet_ref_set?: Set<WorkletRefImpl<any> | Worklet>;
-  __listItemPlatformInfo?: any;
+  __listItemPlatformInfo?: PlatformInfo;
 
   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;
+    id ??= snapshotInstanceManager.nextId -= 1;
     this.__id = id;
     snapshotInstanceManager.values.set(id, this);
   }
@@ -291,15 +287,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 +384,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 +543,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,26 +567,30 @@ 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 {
-    const helper = (index: number, oldValue: any, newValue: any) => {
-      if (isDirectOrDeepEqual(oldValue, newValue)) {}
-      else {
-        this.__snapshot_def.update![index]!(this, index, oldValue);
-      }
-    };
-
     if (key === 'values') {
       const oldValues = this.__values;
-      this.__values = value;
+      const values = value as unknown[];
+      this.__values = values;
       if (oldValues) {
-        for (let index = 0; index < value.length; index++) {
-          helper(index, oldValues[index], value[index]);
+        for (let index = 0; index < values.length; index++) {
+          this.callUpdateIfNotDirectOrDeepEqual(index, oldValues[index], values[index]);
         }
       } else {
-        for (let index = 0; index < value.length; index++) {
-          helper(index, undefined, value[index]);
+        for (let index = 0; index < values.length; index++) {
+          this.callUpdateIfNotDirectOrDeepEqual(index, undefined, values[index]);
         }
       }
       return;
@@ -594,7 +598,7 @@ export class SnapshotInstance {
 
     const index = typeof key === 'string' ? Number(key.slice(2)) : key;
     this.__values ??= [];
-    helper(index, this.__values[index], this.__values[index] = value);
+    this.callUpdateIfNotDirectOrDeepEqual(index, this.__values[index], this.__values[index] = value);
   }
 
   toJSON(): Omit<SerializedSnapshotInstance, 'children'> & { children: SnapshotInstance[] | undefined } {
@@ -605,4 +609,11 @@ export class SnapshotInstance {
       children: this.__firstChild ? this.childNodes : undefined,
     };
   }
+
+  callUpdateIfNotDirectOrDeepEqual(index: number, oldValue: any, newValue: any): void {
+    if (isDirectOrDeepEqual(oldValue, newValue)) {}
+    else {
+      this.__snapshot_def.update![index]!(this, index, oldValue);
+    }
+  }
 }

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<number, number>();
+
+/**
+ * @internal
+ */
+export { hydrationMap };

package/runtime/src/utils.ts

@@ -14,7 +14,7 @@ export function isDirectOrDeepEqual(a: any, b: any): boolean {
 }
 
 export function isEmptyObject(obj?: object): obj is Record<string, never> {
-  for (var _ in obj) return false;
+  for (const _ in obj) return false;
   return true;
 }
 
@@ -25,11 +25,11 @@ export function isSdkVersionGt(major: number, minor: number): boolean {
 }
 
 export function pick<T extends object, K extends keyof T>(obj: T, keys: Iterable<K>): Pick<T, K> {
-  const result: any = {};
+  const result: Partial<Pick<T, K>> = {};
   for (const key of keys) {
     if (key in obj) {
       result[key] = obj[key];
     }
   }
-  return result;
+  return result as Pick<T, K>;
 }

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

@@ -1,5 +1,5 @@
 import { builtinEnvironments } from "vitest/environments";
-import external_events_default from "events";
+import events from "events";
 function util_define(object, properties) {
     for (const name of Object.getOwnPropertyNames(properties)){
         const propDesc = Object.getOwnPropertyDescriptor(properties, name);
@@ -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) {
@@ -321,7 +321,7 @@ function createPolyfills() {
             ]);
         }
     };
-    const ee = new external_events_default();
+    const ee = new events();
     ee.dispatchEvent = ({ type, data })=>{
         const isMainThread = __MAIN_THREAD__;
         lynxTestingEnv.switchToBackgroundThread();
@@ -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;
@@ -427,7 +428,7 @@ function injectBackgroundThreadGlobals(target, polyfills) {
             updateData: {}
         }
     };
-    const globalEventEmitter = new external_events_default();
+    const globalEventEmitter = new events();
     globalEventEmitter.trigger = globalEventEmitter.emit;
     globalEventEmitter.toggle = globalEventEmitter.emit;
     target.lynx = {
@@ -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,