@lynx-js/react 0.106.2 → 0.106.4

package/runtime/src/lynx/calledByNative.ts

@@ -40,6 +40,8 @@ function ssrHydrate(info: string) {
     throw new Error('SSR Hydration Failed! Please check if the SSR content loaded successfully!');
   }
 
+  resetJSReady();
+  setupPage(nativePage);
   const refsMap = __GetTemplateParts(nativePage);
 
   const { __opcodes, __root_values } = JSON.parse(info);

package/runtime/src/lynx/tt.ts

@@ -8,6 +8,8 @@ import { LifecycleConstant, NativeUpdateDataType } from '../lifecycleConstant.js
 import { PerformanceTimingKeys, beginPipeline, markTiming } from './performance.js';
 import { BackgroundSnapshotInstance, hydrate } from '../backgroundSnapshot.js';
 import { destroyBackground } from '../lifecycle/destroy.js';
+import { delayedEvents, delayedPublishEvent } from '../lifecycle/event/delayEvents.js';
+import { delayLifecycleEvent, delayedLifecycleEvents } from '../lifecycle/event/delayLifecycleEvents.js';
 import { commitPatchUpdate, genCommitTaskId, globalCommitTaskMap } from '../lifecycle/patch/commit.js';
 import { reloadBackground } from '../lifecycle/reload.js';
 import { renderBackground } from '../lifecycle/render.js';
@@ -69,7 +71,7 @@ export function runWithForce(cb: () => void): void {
 function injectTt(): void {
   // @ts-ignore
   const tt = lynxCoreInject.tt;
-  tt.OnLifecycleEvent = OnLifecycleEvent;
+  tt.OnLifecycleEvent = onLifecycleEvent;
   tt.publishEvent = delayedPublishEvent;
   tt.publicComponentEvent = delayedPublicComponentEvent;
   tt.callDestroyLifetimeFun = () => {
@@ -84,20 +86,31 @@ function injectTt(): void {
   };
 }
 
-let delayedLifecycleEvents: [type: string, data: any][];
-async function OnLifecycleEvent([type, data]: [string, any]) {
+function onLifecycleEvent([type, data]: [string, any]) {
   const hasRootRendered = CHILDREN in __root;
   // never called `render(<App/>, __root)`
   // happens if user call `root.render()` async
   if (!hasRootRendered) {
-    delayedLifecycleEvents ??= [];
-    delayedLifecycleEvents.push([type, data]);
+    delayLifecycleEvent(type, data);
     return;
   }
 
   if (__PROFILE__) {
     console.profile(`OnLifecycleEvent::${type}`);
   }
+
+  try {
+    void onLifecycleEventImpl(type, data);
+  } catch (e) {
+    lynx.reportError(e as Error);
+  }
+
+  if (__PROFILE__) {
+    console.profileEnd();
+  }
+}
+
+async function onLifecycleEventImpl(type: string, data: any): Promise<void> {
   switch (type) {
     case LifecycleConstant.firstScreen: {
       const { root: lepusSide, refPatch, jsReadyEventIdSwap } = data;
@@ -118,6 +131,8 @@ async function OnLifecycleEvent([type, data]: [string, any]) {
       }
       markTiming(PerformanceTimingKeys.diff_vdom_end);
 
+      // TODO: It seems `delayedEvents` and `delayedLifecycleEvents` should be merged into one array to ensure the proper order of events.
+      flushDelayedLifecycleEvents();
       if (delayedEvents) {
         delayedEvents.forEach((args) => {
           const [handlerName, data] = args;
@@ -131,6 +146,7 @@ async function OnLifecycleEvent([type, data]: [string, any]) {
         });
         delayedEvents.length = 0;
       }
+
       lynxCoreInject.tt.publishEvent = publishEvent;
       lynxCoreInject.tt.publicComponentEvent = publicComponentEvent;
 
@@ -177,19 +193,12 @@ async function OnLifecycleEvent([type, data]: [string, any]) {
       break;
     }
   }
-  if (__PROFILE__) {
-    console.profileEnd();
-  }
 }
 
 function flushDelayedLifecycleEvents(): void {
   if (delayedLifecycleEvents) {
     delayedLifecycleEvents.forEach((e) => {
-      try {
-        OnLifecycleEvent(e);
-      } catch (e) {
-        lynx.reportError(e as Error);
-      }
+      onLifecycleEvent(e);
     });
     delayedLifecycleEvents.length = 0;
   }
@@ -214,12 +223,6 @@ function publicComponentEvent(_componentId: string, handlerName: string, data: u
   publishEvent(handlerName, data);
 }
 
-let delayedEvents: [handlerName: string, data: unknown][];
-function delayedPublishEvent(handlerName: string, data: unknown) {
-  delayedEvents ??= [];
-  delayedEvents.push([handlerName, data]);
-}
-
 function delayedPublicComponentEvent(_componentId: string, handlerName: string, data: unknown) {
   delayedPublishEvent(handlerName, data);
 }
@@ -258,4 +261,4 @@ function updateCardData(newData: Record<string, any>, options?: Record<string, a
   lynxCoreInject.tt.GlobalEventEmitter.emit('onDataChanged');
 }
 
-export { injectTt, flushDelayedLifecycleEvents, delayedLifecycleEvents };
+export { injectTt, flushDelayedLifecycleEvents };

package/runtime/src/lynx-api.ts

@@ -87,12 +87,13 @@ export const root: Root = {
     } else {
       __root.__jsx = jsx;
       renderBackground(jsx, __root as any);
-      if (__FIRST_SCREEN_SYNC_TIMING__ === 'immediately') {}
-      else {
+      if (__FIRST_SCREEN_SYNC_TIMING__ === 'immediately') {
+        // This is for cases where `root.render()` is called asynchronously,
+        // `firstScreen` message might have been reached.
+        flushDelayedLifecycleEvents();
+      } else {
         lynx.getNativeApp().callLepusMethod(LifecycleConstant.jsReady, {});
       }
-
-      flushDelayedLifecycleEvents();
     }
   },
   registerDataProcessors: (dataProcessorDefinition: DataProcessorDefinition): void => {

package/runtime/src/snapshot.ts

@@ -38,6 +38,11 @@ export function setupPage(page: FiberElement): void {
   __pageId = __GetElementUniqueID(page);
 }
 
+export function clearPage(): void {
+  __page = undefined as unknown as FiberElement;
+  __pageId = 0;
+}
+
 export const snapshotManager: {
   values: Map<string, Snapshot>;
 } = {

package/runtime/src/worklet/hmr.ts

@@ -1,26 +1,30 @@
 // 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 { SnapshotOperation, __globalSnapshotPatch } from '../lifecycle/patch/snapshotPatch.js';
+// import { __globalSnapshotPatch } from '../lifecycle/patch/snapshotPatch.js';
 
-const workletHashSet: Set<string> = /* @__PURE__ */ new Set();
+// const workletHashSet: Set<string> = /* @__PURE__ */ new Set();
 
+/* v8 ignore start */
 /**
  * @internal
  */
-function registerWorkletOnBackground(_type: string, hash: string, fn: Function) {
-  if (workletHashSet.has(hash)) {
-    return;
-  }
-  workletHashSet.add(hash);
-  if (__globalSnapshotPatch) {
-    __globalSnapshotPatch.push(
-      SnapshotOperation.DEV_ONLY_RegisterWorklet,
-      hash,
-      // We use `Function.prototype.toString` to serialize the function for Lepus.
-      fn.toString(),
-    );
-  }
+// disable hmr until bugs are fixed
+// TODO: re-enable hmr or change a way to impl it; also need to fix the test case DEV_ONLY_RegisterWorklet
+function registerWorkletOnBackground(_type: string, _hash: string, _fn: Function) {
+  // if (workletHashSet.has(hash)) {
+  //   return;
+  // }
+  // workletHashSet.add(hash);
+  // if (__globalSnapshotPatch) {
+  //   __globalSnapshotPatch.push(
+  //     SnapshotOperation.DEV_ONLY_RegisterWorklet,
+  //     hash,
+  //     // We use `Function.prototype.toString` to serialize the function for Lepus.
+  //     fn.toString(),
+  //   );
+  // }
 }
+/* v8 ignore stop */
 
 export { registerWorkletOnBackground };