@lynx-js/react 0.110.0 → 0.111.0

package/runtime/src/listUpdateInfo.ts

@@ -0,0 +1,221 @@
+// Copyright 2025 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 { hydrate } from './hydrate.js';
+import { componentAtIndexFactory, enqueueComponentFactory } from './list.js';
+import type { SnapshotInstance } from './snapshot.js';
+
+export interface ListUpdateInfo {
+  flush(): void;
+  onInsertBefore(
+    newNode: SnapshotInstance,
+    existingNode?: SnapshotInstance,
+  ): void;
+  onRemoveChild(child: SnapshotInstance): void;
+  onSetAttribute(child: SnapshotInstance, attr: any, oldAttr: any): void;
+}
+
+// class ListUpdateInfoDiffing implements ListUpdateInfo {
+//   private oldChildNodes: SnapshotInstance[];
+//   constructor(private list: SnapshotInstance) {
+//     this.oldChildNodes = list.childNodes;
+//   }
+//   flush(): void {
+//     Object.defineProperty(SnapshotInstance.prototype, "key", {
+//       get: function () {
+//         return this.values[0]["item-key"];
+//       },
+//     });
+
+//   }
+//   onInsertBefore(newNode: SnapshotInstance, existingNode?: SnapshotInstance | undefined): void {}
+//   onRemoveChild(child: SnapshotInstance): void {}
+//   onSetAttribute(child: SnapshotInstance, attr: any): void {
+//     throw new Error("Method not implemented.");
+//   }
+// }
+
+interface InsertAction {
+  position: number;
+  type: string;
+}
+
+interface UpdateAction {
+  from: number;
+  to: number;
+  type: string;
+  flush: boolean;
+}
+
+interface ListOperations {
+  insertAction: InsertAction[];
+  removeAction: number[];
+  updateAction: UpdateAction[];
+}
+
+export class ListUpdateInfoRecording implements ListUpdateInfo {
+  constructor(private list: SnapshotInstance) {
+    this.oldChildNodes = list.childNodes;
+    // this.oldChildNodesSet = new Set(this.oldChildNodes);
+  }
+
+  // private __commitAndReset() {
+  //   (this.__pendingAttributes ??= []).push(this.__toAttribute());
+  //   this.oldChildNodes = this.list.childNodes;
+  //   this.oldChildNodesSet = new Set(this.oldChildNodes);
+  //   this.removeChild1.clear();
+  //   this.removeChild2.clear();
+  //   this.insertBefore.clear();
+  //   this.appendChild.length = 0;
+  //   this.platformInfoUpdate.clear();
+  // }
+
+  flush(): void {
+    const elementIndex = this.list.__snapshot_def.slot[0]![1];
+    const listElement = this.list.__elements![elementIndex]!;
+    // this.__pendingAttributes?.forEach(pendingAttribute => {
+    //   __SetAttribute(listElement, "update-list-info", pendingAttribute);
+    //   __FlushElementTree(listElement);
+    // });
+    __SetAttribute(listElement, 'update-list-info', this.__toAttribute());
+    const [componentAtIndex, componentAtIndexes] = componentAtIndexFactory(this.list.childNodes, hydrate);
+    __UpdateListCallbacks(
+      listElement,
+      componentAtIndex,
+      enqueueComponentFactory(),
+      componentAtIndexes,
+    );
+  }
+
+  private oldChildNodes: SnapshotInstance[];
+  // private oldChildNodesSet: Set<SnapshotInstance>;
+  private removeChild = new Set<SnapshotInstance>();
+  private insertBefore = new Map<SnapshotInstance, SnapshotInstance[]>(); // insert V before K
+  private appendChild = [] as SnapshotInstance[];
+  private platformInfoUpdate = new Map<SnapshotInstance, any>();
+
+  onInsertBefore(newNode: SnapshotInstance, existingNode?: SnapshotInstance): void {
+    if (newNode.parentNode) {
+      // if (!this.oldChildNodesSet.has(newNode)) {
+      //   this.__commitAndReset();
+      // }
+      this.removeChild.add(newNode);
+    }
+    if (existingNode) {
+      // if (!this.oldChildNodesSet.has(existingNode)) {
+      //   this.__commitAndReset();
+      // }
+      const newChildren = this.insertBefore.get(existingNode) ?? [];
+      newChildren.push(newNode);
+      this.insertBefore.set(existingNode, newChildren);
+    } else {
+      this.appendChild.push(newNode);
+    }
+  }
+
+  onRemoveChild(child: SnapshotInstance): void {
+    // if (!this.oldChildNodesSet.has(child)) {
+    //   this.__commitAndReset();
+    // }
+    this.removeChild.add(child);
+  }
+
+  onSetAttribute(child: SnapshotInstance, attr: any, _oldAttr: any): void {
+    this.platformInfoUpdate.set(child, attr);
+  }
+
+  private __toAttribute(): ListOperations {
+    const { removeChild, insertBefore, appendChild, platformInfoUpdate } = this;
+
+    const removals: number[] = [];
+    const insertions: InsertAction[] = [];
+    const updates: UpdateAction[] = [];
+
+    let j = 0;
+    for (let i = 0; i < this.oldChildNodes.length; i++, j++) {
+      const child = this.oldChildNodes[i]!;
+      if (platformInfoUpdate.has(child)) {
+        updates.push({
+          ...platformInfoUpdate.get(child),
+          from: +j,
+          to: +j,
+          // no flush
+          flush: false,
+          type: child.type,
+        } as UpdateAction);
+      }
+      if (insertBefore.has(child)) {
+        const children = insertBefore.get(child)!;
+        children.forEach(c => {
+          insertions.push({
+            position: j,
+            type: c.type,
+            ...c.__listItemPlatformInfo,
+          } as InsertAction);
+          j++;
+        });
+      }
+      if (removeChild.has(child)) {
+        removals.push(i);
+        removeChild.delete(child);
+        j--;
+      }
+    }
+    for (let i = 0; i < appendChild.length; i++) {
+      const child = appendChild[i]!;
+      insertions.push({
+        position: j + i,
+        type: child.type,
+        ...child.__listItemPlatformInfo,
+      } as InsertAction);
+    }
+
+    insertions.sort((a, b) => a.position - b.position);
+    removals.sort((a, b) => a - b);
+
+    if (
+      SystemInfo.lynxSdkVersion === '2.14'
+      || SystemInfo.lynxSdkVersion === '2.15'
+      || SystemInfo.lynxSdkVersion === '2.16'
+      || SystemInfo.lynxSdkVersion === '2.17'
+      || SystemInfo.lynxSdkVersion === '2.18'
+    ) {
+      const elementIndex = this.list.__snapshot_def.slot[0]![1];
+      const listElement = this.list.__elements![elementIndex]!;
+
+      // `__GetAttributeByName` is available since Lynx 2.14
+      if (__GetAttributeByName(listElement, 'custom-list-name') === 'list-container') {
+        // `updateAction` must be full (not incremental) when Lynx version <= 2.18 and
+        // when `custom-list-name` is `list-container` (available when Lynx version >= 2.14) is true,
+        updates.length = 0;
+        this.list.childNodes.forEach((child, index) => {
+          updates.push({
+            ...child.__listItemPlatformInfo,
+            from: index,
+            to: index,
+            // no flush
+            flush: false,
+            type: child.type,
+          } as UpdateAction);
+        });
+      }
+    }
+
+    return {
+      insertAction: insertions,
+      removeAction: removals,
+      updateAction: updates,
+    };
+  }
+
+  toJSON(): [ListOperations] {
+    // if (this.__pendingAttributes) {
+    //   return [...this.__pendingAttributes, this.__toAttribute()];
+    // } else {
+    //   return [this.__toAttribute()];
+    // }
+
+    return [this.__toAttribute()] as const;
+  }
+}

package/runtime/src/lynx/calledByNative.ts

@@ -6,13 +6,13 @@ import { isJSReady, jsReady, jsReadyEventIdSwap, resetJSReady } from '../lifecyc
 import { reloadMainThread } from '../lifecycle/reload.js';
 import { renderMainThread } from '../lifecycle/render.js';
 import { LifecycleConstant } from '../lifecycleConstant.js';
-import { __pendingListUpdates } from '../list.js';
 import { ssrHydrateByOpcodes } from '../opcodes.js';
+import { __pendingListUpdates } from '../pendingListUpdates.js';
 import { __root, setRoot } from '../root.js';
+import { applyRefQueue } from '../snapshot/workletRef.js';
 import { SnapshotInstance, __page, setupPage } from '../snapshot.js';
 import { isEmptyObject } from '../utils.js';
-import { PerformanceTimingKeys, markTiming, setPipeline } from './performance.js';
-import { applyRefQueue } from '../snapshot/workletRef.js';
+import { markTiming, setPipeline } from './performance.js';
 
 function ssrEncode() {
   const { __opcodes } = __root;
@@ -116,13 +116,14 @@ function updatePage(data: Record<string, unknown> | undefined, options?: UpdateP
     Object.assign(lynx.__initData, data);
   }
 
+  const flushOptions = options ?? {};
   if (!isJSReady) {
     const oldRoot = __root;
     setRoot(new SnapshotInstance('root'));
     __root.__jsx = oldRoot.__jsx;
 
     setPipeline(options?.pipelineOptions);
-    markTiming(PerformanceTimingKeys.updateDiffVdomStart);
+    markTiming('updateDiffVdomStart');
     {
       __pendingListUpdates.clear();
       renderMainThread();
@@ -138,14 +139,11 @@ function updatePage(data: Record<string, unknown> | undefined, options?: UpdateP
       __pendingListUpdates.flush();
       applyRefQueue();
     }
-    markTiming(PerformanceTimingKeys.updateDiffVdomEnd);
+    flushOptions.triggerDataUpdated = true;
+    markTiming('updateDiffVdomEnd');
   }
 
-  if (options) {
-    __FlushElementTree(__page, options);
-  } else {
-    __FlushElementTree();
-  }
+  __FlushElementTree(__page, flushOptions);
 }
 
 function updateGlobalProps(_data: any, options?: UpdatePageOption): void {

package/runtime/src/lynx/component.ts

@@ -6,23 +6,28 @@
 
 import { Component } from 'preact';
 
-import { PerfSpecificKey, PerformanceTimingKeys, markTimingLegacy } from './performance.js';
+import { PerfSpecificKey, markTimingLegacy } from './performance.js';
 import { globalFlushOptions } from '../lifecycle/patch/commit.js';
 import { NEXT_STATE } from '../renderToOpcodes/constants.js';
 
 if (__JS__) {
-  const __Component = Component as any;
-
-  __Component.prototype._reactAppInstance = lynxCoreInject.tt;
-
-  __Component.prototype.getNodeRef = function(a: string, b?: boolean) {
+  function reportRefDeprecationError(fnName: string, newFnName: string) {
     if (!__DISABLE_CREATE_SELECTOR_QUERY_INCOMPATIBLE_WARNING__) {
       lynx.reportError(
         new Error(
-          'getNodeRef is deprecated and has different behavior in ReactLynx 3.0, please use ref or lynx.createSelectorQuery instead.',
+          `${fnName} is deprecated and has different behavior in ReactLynx 3.0, please use ref or ${newFnName} instead.`,
         ),
       );
     }
+  }
+
+  const __Component = Component as any;
+
+  __Component.prototype._reactAppInstance = lynxCoreInject.tt;
+
+  __Component.prototype.getNodeRef = function(a: string, b?: boolean) {
+    reportRefDeprecationError('getNodeRef', 'lynx.createSelectorQuery');
+
     // @ts-expect-error hack lynx-kernel
     return lynxCoreInject.tt._reactLynx.ReactComponent.prototype.getNodeRef
       .call(
@@ -40,13 +45,8 @@ if (__JS__) {
   };
 
   __Component.prototype.getNodeRefFromRoot = function(a: string) {
-    if (!__DISABLE_CREATE_SELECTOR_QUERY_INCOMPATIBLE_WARNING__) {
-      lynx.reportError(
-        new Error(
-          'getNodeRefFromRoot is deprecated and has different behavior in ReactLynx 3.0, please use ref or lynx.createSelectorQuery instead.',
-        ),
-      );
-    }
+    reportRefDeprecationError('getNodeRefFromRoot', 'lynx.createSelectorQuery');
+
     // @ts-expect-error hack lynx-kernel
     return lynxCoreInject.tt._reactLynx.ReactComponent.prototype
       .getNodeRefFromRoot.call(
@@ -88,26 +88,14 @@ if (__JS__) {
   };
 
   __Component.prototype.getElementById = function(id: string) {
-    if (!__DISABLE_CREATE_SELECTOR_QUERY_INCOMPATIBLE_WARNING__) {
-      lynx.reportError(
-        new Error(
-          'getElementById on component instance is deprecated and has different behavior in ReactLynx 3.0, please use ref or lynx.getElementById instead.',
-        ),
-      );
-    }
+    reportRefDeprecationError('getElementById', 'lynx.getElementById');
     return lynx.getElementById(id);
   };
 
   __Component.prototype.GlobalEventEmitter = lynxCoreInject.tt.GlobalEventEmitter;
 
   __Component.prototype.createSelectorQuery = function() {
-    if (!__DISABLE_CREATE_SELECTOR_QUERY_INCOMPATIBLE_WARNING__) {
-      lynx.reportError(
-        new Error(
-          'createSelectorQuery on component instance is deprecated and has different behavior in ReactLynx 3.0, please use ref or lynx.createSelectorQuery instead.',
-        ),
-      );
-    }
+    reportRefDeprecationError('createSelectorQuery on component instance', 'lynx.createSelectorQuery');
     return lynx.createSelectorQuery();
   };
 
@@ -118,7 +106,7 @@ if (__JS__) {
     const timingFlag = this[NEXT_STATE][PerfSpecificKey];
     if (timingFlag) {
       globalFlushOptions.__lynx_timing_flag = timingFlag;
-      markTimingLegacy(PerformanceTimingKeys.updateSetStateTrigger, timingFlag);
+      markTimingLegacy('updateSetStateTrigger', timingFlag);
       this[NEXT_STATE][PerfSpecificKey] = '';
     }
   };

package/runtime/src/lynx/env.ts

@@ -56,8 +56,7 @@ export function setupLynxEnv(): void {
         let r: InitData | InitDataRaw;
         try {
           if (processorName) {
-            r = dataProcessorDefinition?.dataProcessors?.[processorName]?.(data)
-              ?? data;
+            r = dataProcessorDefinition?.dataProcessors?.[processorName]?.(data) as InitData ?? data;
           } else {
             r = dataProcessorDefinition?.defaultDataProcessor?.(data) ?? data;
           }

package/runtime/src/lynx/lazy-bundle.ts

@@ -33,7 +33,7 @@ export const makeSyncThen = function<T>(result: T): Promise<T>['then'] {
         // Calling `then` and passing a callback is standard behavior
         // but in Lepus runtime the callback will never be called
         // So can be simplified to code below
-        return new Promise(() => {});
+        return ret as Promise<TR1>;
 
         // TODO(hongzhiyuan.hzy): Avoid warning that cannot be turned-off, so the warning is commented
         // lynx.reportError(
@@ -90,27 +90,40 @@ export const loadLazyBundle: <
       r.then = makeSyncThen(result);
       return r;
     } else if (__JS__) {
-      return new Promise((resolve, reject) => {
-        const callback: (result: { code: number; detail: { schema: string } }) => void = result => {
-          const { code, detail } = result;
-          if (code === 0) {
-            const { schema } = detail;
-            const exports = lynxCoreInject.tt.getDynamicComponentExports(schema);
-            // `code === 0` means that the lazy bundle has been successfully parsed. However,
-            // its javascript files may still fail to run, which would prevent the retrieval of the exports object.
-            if (exports) {
-              resolve(exports as T);
-              return;
-            }
+      const resolver = withSyncResolvers<T>();
+
+      const callback: (result: { code: number; detail: { schema: string } }) => void = result => {
+        const { code, detail } = result;
+        if (code === 0) {
+          const { schema } = detail;
+          const exports = lynxCoreInject.tt.getDynamicComponentExports(schema);
+          // `code === 0` means that the lazy bundle has been successfully parsed. However,
+          // its javascript files may still fail to run, which would prevent the retrieval of the exports object.
+          if (exports) {
+            resolver.resolve(exports as T);
+            return;
           }
-          reject(new Error('Lazy bundle load failed: ' + JSON.stringify(result)));
-        };
-        if (typeof lynx.QueryComponent === 'function') {
-          lynx.QueryComponent(source, callback);
-        } else {
-          lynx.getNativeLynx().QueryComponent!(source, callback);
         }
-      });
+        resolver.reject(new Error('Lazy bundle load failed: ' + JSON.stringify(result)));
+      };
+      if (typeof lynx.QueryComponent === 'function') {
+        lynx.QueryComponent(source, callback);
+      } else {
+        lynx.getNativeLynx().QueryComponent!(source, callback);
+      }
+
+      if (resolver.result !== null) {
+        const p = Promise.resolve(resolver.result);
+        p.then = makeSyncThen(resolver.result) as Promise<Awaited<T>>['then'];
+        return p;
+      } else if (resolver.error === null) {
+        return new Promise((_resolve, _reject) => {
+          resolver.resolve = _resolve;
+          resolver.reject = _reject;
+        });
+      } else {
+        return Promise.reject(resolver.error);
+      }
     }
 
     throw new Error('unreachable');
@@ -119,6 +132,28 @@ export const loadLazyBundle: <
   return loadLazyBundle;
 })();
 
+function withSyncResolvers<T>() {
+  'background-only';
+
+  const resolver: {
+    result: T | null;
+    error: Error | null;
+    resolve(result: T): void;
+    reject(error: Error): void;
+  } = {
+    resolve: (result: T): void => {
+      resolver.result = result;
+    },
+    reject: (error: Error): void => {
+      resolver.error = error;
+    },
+    result: null,
+    error: null,
+  };
+
+  return resolver;
+}
+
 /**
  * @internal
  */

package/runtime/src/lynx/performance.ts

@@ -8,24 +8,24 @@ import { __globalSnapshotPatch } from '../lifecycle/patch/snapshotPatch.js';
 import { DIFF } from '../renderToOpcodes/constants.js';
 import { isSdkVersionGt } from '../utils.js';
 
-enum PerformanceTimingKeys {
-  updateSetStateTrigger,
-  updateDiffVdomStart,
-  updateDiffVdomEnd,
+const PerformanceTimingKeys = [
+  'updateSetStateTrigger',
+  'updateDiffVdomStart',
+  'updateDiffVdomEnd',
   // updateSetStateTrigger, updateDiffVdomStart and updateDiffVdomEnd is deprecated
-  diffVdomStart,
-  diffVdomEnd,
-  packChangesStart,
-  packChangesEnd,
-  parseChangesStart,
-  parseChangesEnd,
-  patchChangesStart,
-  patchChangesEnd,
-  hydrateParseSnapshotStart,
-  hydrateParseSnapshotEnd,
-  mtsRenderStart,
-  mtsRenderEnd,
-}
+  'diffVdomStart',
+  'diffVdomEnd',
+  'packChangesStart',
+  'packChangesEnd',
+  'parseChangesStart',
+  'parseChangesEnd',
+  'patchChangesStart',
+  'patchChangesEnd',
+  'hydrateParseSnapshotStart',
+  'hydrateParseSnapshotEnd',
+  'mtsRenderStart',
+  'mtsRenderEnd',
+] as const;
 
 const PerformanceTimingFlags = {
   reactLynxHydrate: 'react_lynx_hydrate',
@@ -51,15 +51,15 @@ let globalPipelineOptions: PipelineOptions | undefined;
 /**
  * @deprecated used by old timing api(setState timing flag)
  */
-function markTimingLegacy(key: PerformanceTimingKeys, timingFlag_?: string): void {
+function markTimingLegacy(key: typeof PerformanceTimingKeys[number], timingFlag_?: string): void {
   switch (key) {
-    case PerformanceTimingKeys.updateSetStateTrigger: {
+    case 'updateSetStateTrigger': {
       shouldMarkDiffVdomStart = true;
       shouldMarkDiffVdomEnd = true;
       timingFlag = timingFlag_;
       break;
     }
-    case PerformanceTimingKeys.updateDiffVdomStart: {
+    case 'updateDiffVdomStart': {
       /* v8 ignore start */
       if (!shouldMarkDiffVdomStart) {
         return;
@@ -68,7 +68,7 @@ function markTimingLegacy(key: PerformanceTimingKeys, timingFlag_?: string): voi
       shouldMarkDiffVdomStart = false;
       break;
     }
-    case PerformanceTimingKeys.updateDiffVdomEnd: {
+    case 'updateDiffVdomEnd': {
       if (!shouldMarkDiffVdomEnd) {
         return;
       }
@@ -76,7 +76,7 @@ function markTimingLegacy(key: PerformanceTimingKeys, timingFlag_?: string): voi
       break;
     }
   }
-  lynx.getNativeApp().markTiming?.(timingFlag!, PerformanceTimingKeys[key]);
+  lynx.getNativeApp().markTiming?.(timingFlag!, key);
 }
 
 function beginPipeline(needTimestamps: boolean, pipelineOrigin: PipelineOrigin, timingFlag?: string): void {
@@ -109,9 +109,9 @@ function setPipeline(pipeline: PipelineOptions | undefined): void {
   globalPipelineOptions = pipeline;
 }
 
-function markTiming(timestampKey: PerformanceTimingKeys, force?: boolean): void {
+function markTiming(timestampKey: typeof PerformanceTimingKeys[number], force?: boolean): void {
   if (globalPipelineOptions && (force || globalPipelineOptions.needTimestamps)) {
-    lynx.performance?._markTiming?.(globalPipelineOptions.pipelineID, PerformanceTimingKeys[timestampKey]);
+    lynx.performance?._markTiming?.(globalPipelineOptions.pipelineID, timestampKey);
   }
 }
 
@@ -122,10 +122,10 @@ function initTimingAPI(): void {
     if (__JS__ && __globalSnapshotPatch) {
       if (!globalPipelineOptions) {
         beginPipeline(false, PipelineOrigins.updateTriggeredByBts);
-        markTiming(PerformanceTimingKeys.diffVdomStart, true);
+        markTiming('diffVdomStart', true);
       }
       if (shouldMarkDiffVdomStart) {
-        markTimingLegacy(PerformanceTimingKeys.updateDiffVdomStart);
+        markTimingLegacy('updateDiffVdomStart');
       }
     }
     oldDiff?.(vnode);
@@ -136,7 +136,6 @@ function initTimingAPI(): void {
  * @internal
  */
 export {
-  PerformanceTimingKeys,
   PerformanceTimingFlags,
   PipelineOrigins,
   PerfSpecificKey,

package/runtime/src/lynx/tt.ts

@@ -5,13 +5,7 @@ import { render } from 'preact';
 
 import { LifecycleConstant, NativeUpdateDataType } from '../lifecycleConstant.js';
 import type { FirstScreenData } from '../lifecycleConstant.js';
-import {
-  PerformanceTimingFlags,
-  PerformanceTimingKeys,
-  PipelineOrigins,
-  beginPipeline,
-  markTiming,
-} from './performance.js';
+import { PerformanceTimingFlags, PipelineOrigins, beginPipeline, markTiming } from './performance.js';
 import { BackgroundSnapshotInstance, hydrate } from '../backgroundSnapshot.js';
 import { runWithForce } from './runWithForce.js';
 import { destroyBackground } from '../lifecycle/destroy.js';
@@ -80,10 +74,10 @@ function onLifecycleEventImpl(type: LifecycleConstant, data: unknown): void {
         console.profile('hydrate');
       }
       beginPipeline(true, PipelineOrigins.reactLynxHydrate, PerformanceTimingFlags.reactLynxHydrate);
-      markTiming(PerformanceTimingKeys.hydrateParseSnapshotStart);
+      markTiming('hydrateParseSnapshotStart');
       const before = JSON.parse(lepusSide) as SerializedSnapshotInstance;
-      markTiming(PerformanceTimingKeys.hydrateParseSnapshotEnd);
-      markTiming(PerformanceTimingKeys.diffVdomStart);
+      markTiming('hydrateParseSnapshotEnd');
+      markTiming('diffVdomStart');
       const snapshotPatch = hydrate(
         before,
         __root as BackgroundSnapshotInstance,
@@ -91,7 +85,7 @@ function onLifecycleEventImpl(type: LifecycleConstant, data: unknown): void {
       if (__PROFILE__) {
         console.profileEnd();
       }
-      markTiming(PerformanceTimingKeys.diffVdomEnd);
+      markTiming('diffVdomEnd');
 
       // TODO: It seems `delayedEvents` and `delayedLifecycleEvents` should be merged into one array to ensure the proper order of events.
       flushDelayedLifecycleEvents();
@@ -141,6 +135,11 @@ function onLifecycleEventImpl(type: LifecycleConstant, data: unknown): void {
       lynx.getJSModule('GlobalEventEmitter').trigger(eventName, params);
       break;
     }
+    case LifecycleConstant.publishEvent: {
+      const { handlerName, data: d } = data as { handlerName: string; data: unknown };
+      lynxCoreInject.tt.publishEvent(handlerName, d);
+      break;
+    }
   }
 }