@lynx-js/react 0.105.1 → 0.106.0

package/runtime/src/lifecycle/{patchUpdate.ts → patch/commit.ts}

@@ -1,31 +1,27 @@
 // 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 { options } from 'preact';
 import type { VNode } from 'preact';
+import { options } from 'preact';
 import type { Component } from 'preact/compat';
 
-import { clearDelayedWorklets, updateWorkletRefInitValueChanges } from '@lynx-js/react/worklet-runtime/bindings';
-
-import { LifecycleConstant } from '../lifecycleConstant.js';
-import { __pendingListUpdates } from '../list.js';
-import { runDelayedUnmounts, takeDelayedUnmounts } from './delayUnmount.js';
-import { getReloadVersion } from './pass.js';
+import type { SnapshotPatch } from './snapshotPatch.js';
+import { takeGlobalSnapshotPatch } from './snapshotPatch.js';
+import { LifecycleConstant } from '../../lifecycleConstant.js';
 import {
   PerformanceTimingKeys,
   globalPipelineOptions,
   markTiming,
   markTimingLegacy,
   setPipeline,
-} from '../lynx/performance.js';
-import { CATCH_ERROR, COMMIT, RENDER_CALLBACKS, VNODE } from '../renderToOpcodes/constants.js';
-import { takeGlobalRefPatchMap, updateBackgroundRefs } from '../snapshot/ref.js';
-import { __page, backgroundSnapshotInstanceManager } from '../snapshot.js';
-import { takeGlobalSnapshotPatch } from '../snapshotPatch.js';
-import type { SnapshotPatch } from '../snapshotPatch.js';
-import { snapshotPatchApply } from '../snapshotPatchApply.js';
-import { isEmptyObject } from '../utils.js';
-import { takeWorkletRefInitValuePatch } from '../worklet/workletRefPool.js';
+} from '../../lynx/performance.js';
+import { CATCH_ERROR, COMMIT, RENDER_CALLBACKS, VNODE } from '../../renderToOpcodes/constants.js';
+import { updateBackgroundRefs } from '../../snapshot/ref.js';
+import { backgroundSnapshotInstanceManager } from '../../snapshot.js';
+import { isEmptyObject } from '../../utils.js';
+import { takeWorkletRefInitValuePatch } from '../../worklet/workletRefPool.js';
+import { runDelayedUnmounts, takeDelayedUnmounts } from '../delayUnmount.js';
+import { getReloadVersion } from '../pass.js';
 
 let globalFlushOptions: FlushOptions = {};
 
@@ -34,77 +30,56 @@ let nextCommitTaskId = 1;
 
 let globalBackgroundSnapshotInstancesToRemove: number[] = [];
 
+let patchesToCommit: Patch[] = [];
+
 interface Patch {
+  id: number;
   snapshotPatch?: SnapshotPatch;
   workletRefInitValuePatch?: [id: number, value: unknown][];
+}
+
+interface PatchList {
+  patchList: Patch[];
   flushOptions?: FlushOptions;
 }
 
 interface PatchOptions {
-  commitTaskId: number;
   pipelineOptions?: PipelineOptions;
-  reloadVersion?: number;
+  reloadVersion: number;
   isHydration?: boolean;
 }
 
-function injectUpdatePatch(): void {
-  function updatePatch(
-    { data, patchOptions }: {
-      data: string;
-      patchOptions: PatchOptions;
+function replaceCommitHook(): void {
+  // use our own `options.debounceRendering` to insert a timing flag before render
+  type DebounceRendering = (f: () => void) => void;
+  const injectDebounceRendering = (debounceRendering: DebounceRendering): DebounceRendering => {
+    return (f: () => void) => {
+      debounceRendering(() => {
+        f();
+        void commitToMainThread();
+      });
+    };
+  };
+  const defaultDebounceRendering = options.debounceRendering?.bind(options)
+    ?? (Promise.prototype.then.bind(Promise.resolve()) as DebounceRendering);
+  let _debounceRendering = injectDebounceRendering(defaultDebounceRendering);
+  Object.defineProperty(options, 'debounceRendering', {
+    get() {
+      return _debounceRendering;
     },
-  ): void {
-    if ((patchOptions.reloadVersion ?? 0) < getReloadVersion()) {
-      return;
-    }
-
-    setPipeline(patchOptions.pipelineOptions);
-    markTiming(PerformanceTimingKeys.parse_changes_start);
-    let { snapshotPatch, workletRefInitValuePatch, flushOptions } = JSON.parse(data) as Patch;
-    markTiming(PerformanceTimingKeys.parse_changes_end);
-
-    markTiming(PerformanceTimingKeys.patch_changes_start);
-    updateWorkletRefInitValueChanges(workletRefInitValuePatch);
-    __pendingListUpdates.clear();
-    if (snapshotPatch) {
-      snapshotPatchApply(snapshotPatch);
-    }
-    __pendingListUpdates.flush();
-    // console.debug('********** Lepus updatePatch:');
-    // printSnapshotInstance(snapshotInstanceManager.values.get(-1)!);
-
-    commitMainThreadPatchUpdate(patchOptions.commitTaskId);
-    if (patchOptions.isHydration) {
-      clearDelayedWorklets();
-    }
-    markTiming(PerformanceTimingKeys.patch_changes_end);
-    flushOptions ||= {};
-    if (patchOptions.pipelineOptions) {
-      flushOptions.pipelineOptions = patchOptions.pipelineOptions;
-    }
-    // TODO: triggerDataUpdated?
-    __FlushElementTree(__page, flushOptions);
-  }
-
-  Object.assign(globalThis, { [LifecycleConstant.patchUpdate]: updatePatch });
-}
+    set(debounceRendering: DebounceRendering) {
+      _debounceRendering = injectDebounceRendering(debounceRendering);
+    },
+  });
 
-function replaceCommitHook(): void {
   const oldCommit = options[COMMIT];
-  options[COMMIT] = async (vnode: VNode, commitQueue: any[]) => {
+  const commit = async (vnode: VNode, commitQueue: any[]) => {
     if (__LEPUS__) {
       // for testing only
       commitQueue.length = 0;
       return;
     }
-
-    markTimingLegacy(PerformanceTimingKeys.update_diff_vdom_end);
-    markTiming(PerformanceTimingKeys.diff_vdom_end);
-    markTiming(PerformanceTimingKeys.pack_changes_start);
-    if (__PROFILE__) {
-      console.profile('commitChanges');
-    }
-    const renderCallbacks = commitQueue.map(component => {
+    const renderCallbacks = commitQueue.map((component: Component<any>) => {
       const ret = {
         component,
         [RENDER_CALLBACKS]: component[RENDER_CALLBACKS],
@@ -130,7 +105,7 @@ function replaceCommitHook(): void {
             cb.call(wrapper.component);
           });
         } catch (e) {
-          options[CATCH_ERROR](e, wrapper[VNODE]);
+          options[CATCH_ERROR](e, wrapper[VNODE]!);
         }
       });
       if (backgroundSnapshotInstancesToRemove.length) {
@@ -143,50 +118,75 @@ function replaceCommitHook(): void {
     });
 
     const snapshotPatch = takeGlobalSnapshotPatch();
-    const flushOptions = globalFlushOptions;
     const workletRefInitValuePatch = takeWorkletRefInitValuePatch();
-    globalFlushOptions = {};
     if (!snapshotPatch && workletRefInitValuePatch.length === 0) {
       // before hydration, skip patch
-      if (__PROFILE__) {
-        console.profileEnd();
-      }
       return;
     }
 
-    const patch: Patch = {};
+    const patch: Patch = {
+      id: commitTaskId,
+    };
     // TODO: check all fields in `flushOptions` from runtime3
     if (snapshotPatch?.length) {
       patch.snapshotPatch = snapshotPatch;
     }
-    if (!isEmptyObject(flushOptions)) {
-      patch.flushOptions = flushOptions;
-    }
     if (workletRefInitValuePatch.length) {
       patch.workletRefInitValuePatch = workletRefInitValuePatch;
     }
-    await commitPatchUpdate(patch, { commitTaskId });
 
-    const commitTask = globalCommitTaskMap.get(commitTaskId);
+    patchesToCommit.push(patch);
+  };
+  options[COMMIT] = commit as ((...args: Parameters<typeof commit>) => void);
+}
+
+async function commitToMainThread(): Promise<void> {
+  if (patchesToCommit.length === 0) {
+    return;
+  }
+
+  markTimingLegacy(PerformanceTimingKeys.update_diff_vdom_end);
+  markTiming(PerformanceTimingKeys.diff_vdom_end);
+
+  const flushOptions = globalFlushOptions;
+  globalFlushOptions = {};
+
+  const patchList: PatchList = {
+    patchList: patchesToCommit,
+  };
+  patchesToCommit = [];
+
+  if (!isEmptyObject(flushOptions)) {
+    patchList.flushOptions = flushOptions;
+  }
+
+  await commitPatchUpdate(patchList, {});
+
+  for (const patch of patchList.patchList) {
+    const commitTask = globalCommitTaskMap.get(patch.id);
     if (commitTask) {
       commitTask();
-      globalCommitTaskMap.delete(commitTaskId);
+      globalCommitTaskMap.delete(patch.id);
     }
-  };
+  }
 }
 
-function commitPatchUpdate(data: Patch, patchOptions: PatchOptions): Promise<void> {
+function commitPatchUpdate(patchList: PatchList, patchOptions: Omit<PatchOptions, 'reloadVersion'>): Promise<void> {
   return new Promise(resolve => {
     // console.debug('********** JS update:');
     // printSnapshotInstance(
     //   (backgroundSnapshotInstanceManager.values.get(1) || backgroundSnapshotInstanceManager.values.get(-1))!,
     // );
-    // console.debug('commitPatchUpdate: ', JSON.stringify(data));
+    // console.debug('commitPatchUpdate: ', JSON.stringify(patchList));
+    if (__PROFILE__) {
+      console.profile('commitChanges');
+    }
+    markTiming(PerformanceTimingKeys.pack_changes_start);
     const obj: {
       data: string;
       patchOptions: PatchOptions;
     } = {
-      data: JSON.stringify(data),
+      data: JSON.stringify(patchList),
       patchOptions: {
         ...patchOptions,
         reloadVersion: getReloadVersion(),
@@ -197,20 +197,13 @@ function commitPatchUpdate(data: Patch, patchOptions: PatchOptions): Promise<voi
       obj.patchOptions.pipelineOptions = globalPipelineOptions;
       setPipeline(undefined);
     }
+    lynx.getNativeApp().callLepusMethod(LifecycleConstant.patchUpdate, obj, resolve);
     if (__PROFILE__) {
       console.profileEnd();
     }
-    lynx.getNativeApp().callLepusMethod(LifecycleConstant.patchUpdate, obj, resolve);
   });
 }
 
-function commitMainThreadPatchUpdate(commitTaskId?: number): void {
-  const refPatch = takeGlobalRefPatchMap();
-  if (!isEmptyObject(refPatch)) {
-    __OnLifecycleEvent([LifecycleConstant.ref, { commitTaskId, refPatch: JSON.stringify(refPatch) }]);
-  }
-}
-
 function genCommitTaskId(): number {
   return nextCommitTaskId++;
 }
@@ -219,7 +212,7 @@ function replaceRequestAnimationFrame(): void {
   // to make afterPaintEffects run faster
   const resolvedPromise = Promise.resolve();
   options.requestAnimationFrame = (cb: () => void) => {
-    resolvedPromise.then(cb);
+    void resolvedPromise.then(cb);
   };
 }
 
@@ -227,14 +220,15 @@ function replaceRequestAnimationFrame(): void {
  * @internal
  */
 export {
-  injectUpdatePatch,
   commitPatchUpdate,
-  replaceCommitHook,
+  commitToMainThread,
   genCommitTaskId,
-  commitMainThreadPatchUpdate,
-  replaceRequestAnimationFrame,
-  globalFlushOptions,
-  globalCommitTaskMap,
   globalBackgroundSnapshotInstancesToRemove,
+  globalCommitTaskMap,
+  globalFlushOptions,
   nextCommitTaskId,
+  replaceCommitHook,
+  replaceRequestAnimationFrame,
+  type PatchOptions,
+  type PatchList,
 };

package/runtime/src/{snapshotPatchApply.ts → lifecycle/patch/snapshotPatchApply.ts}

@@ -1,9 +1,9 @@
 // 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 { createSnapshot, SnapshotInstance, snapshotInstanceManager, snapshotManager } from './snapshot.js';
 import type { SnapshotPatch } from './snapshotPatch.js';
 import { SnapshotOperation } from './snapshotPatch.js';
+import { SnapshotInstance, createSnapshot, snapshotInstanceManager, snapshotManager } from '../../snapshot.js';
 
 function reportCtxNotFound(): void {
   lynx.reportError(new Error(`snapshotPatchApply failed: ctx not found`));
@@ -25,7 +25,7 @@ export function snapshotPatchApply(snapshotPatch: SnapshotPatch): void {
         const beforeId = snapshotPatch[++i];
         const parent = snapshotInstanceManager.values.get(parentId);
         const child = snapshotInstanceManager.values.get(childId);
-        const existingNode = snapshotInstanceManager.values.get(beforeId!);
+        const existingNode = snapshotInstanceManager.values.get(beforeId);
         if (!parent || !child) {
           reportCtxNotFound();
         } else {

package/runtime/src/lifecycle/patch/updateMainThread.ts

@@ -0,0 +1,71 @@
+// 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 { clearDelayedWorklets, updateWorkletRefInitValueChanges } from '@lynx-js/react/worklet-runtime/bindings';
+
+import type { PatchList, PatchOptions } from './commit.js';
+import { snapshotPatchApply } from './snapshotPatchApply.js';
+import { LifecycleConstant } from '../../lifecycleConstant.js';
+import { __pendingListUpdates } from '../../list.js';
+import { PerformanceTimingKeys, markTiming, setPipeline } from '../../lynx/performance.js';
+import { takeGlobalRefPatchMap } from '../../snapshot/ref.js';
+import { __page } from '../../snapshot.js';
+import { isEmptyObject } from '../../utils.js';
+import { getReloadVersion } from '../pass.js';
+
+function updateMainThread(
+  { data, patchOptions }: {
+    data: string;
+    patchOptions: PatchOptions;
+  },
+): void {
+  if ((patchOptions.reloadVersion) < getReloadVersion()) {
+    return;
+  }
+
+  setPipeline(patchOptions.pipelineOptions);
+  markTiming(PerformanceTimingKeys.parse_changes_start);
+  const { patchList, flushOptions = {} } = JSON.parse(data) as PatchList;
+
+  markTiming(PerformanceTimingKeys.parse_changes_end);
+  markTiming(PerformanceTimingKeys.patch_changes_start);
+
+  for (const { snapshotPatch, workletRefInitValuePatch, id } of patchList) {
+    updateWorkletRefInitValueChanges(workletRefInitValuePatch);
+    __pendingListUpdates.clear();
+    if (snapshotPatch) {
+      snapshotPatchApply(snapshotPatch);
+    }
+    __pendingListUpdates.flush();
+    // console.debug('********** Lepus updatePatch:');
+    // printSnapshotInstance(snapshotInstanceManager.values.get(-1)!);
+
+    commitMainThreadPatchUpdate(id);
+  }
+  markTiming(PerformanceTimingKeys.patch_changes_end);
+  if (patchOptions.isHydration) {
+    clearDelayedWorklets();
+  }
+  if (patchOptions.pipelineOptions) {
+    flushOptions.pipelineOptions = patchOptions.pipelineOptions;
+  }
+  // TODO: triggerDataUpdated?
+  __FlushElementTree(__page, flushOptions);
+}
+
+function injectUpdateMainThread(): void {
+  Object.assign(globalThis, { [LifecycleConstant.patchUpdate]: updateMainThread });
+}
+
+function commitMainThreadPatchUpdate(commitTaskId?: number): void {
+  const refPatch = takeGlobalRefPatchMap();
+  if (!isEmptyObject(refPatch)) {
+    __OnLifecycleEvent([LifecycleConstant.ref, { commitTaskId, refPatch: JSON.stringify(refPatch) }]);
+  }
+}
+
+/**
+ * @internal
+ */
+export { commitMainThreadPatchUpdate, injectUpdateMainThread };

package/runtime/src/lifecycle/reload.ts

@@ -1,19 +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.
-import { render } from 'preact';
-
 import { __root, setRoot } from '../root.js';
 import { SnapshotInstance, __page, snapshotInstanceManager } from '../snapshot.js';
 import { isEmptyObject } from '../utils.js';
 import { destroyBackground } from './destroy.js';
 import { increaseReloadVersion } from './pass.js';
-import { renderMainThread } from './render.js';
+import { renderBackground, renderMainThread } from './render.js';
 import { hydrate } from '../hydrate.js';
 import { LifecycleConstant } from '../lifecycleConstant.js';
 import { __pendingListUpdates } from '../list.js';
 import { takeGlobalRefPatchMap } from '../snapshot/ref.js';
-import { deinitGlobalSnapshotPatch } from '../snapshotPatch.js';
+import { deinitGlobalSnapshotPatch } from './patch/snapshotPatch.js';
 import { destroyWorklet } from '../worklet/destroy.js';
 
 function reloadMainThread(data: any, options: UpdatePageOption): void {
@@ -71,7 +69,7 @@ function reloadBackground(updateData: Record<string, any>): void {
   // COW when modify `lynx.__initData` to make sure Provider & Consumer works
   lynx.__initData = Object.assign({}, lynx.__initData, updateData);
 
-  render(__root.__jsx, __root as any);
+  renderBackground(__root.__jsx, __root as any);
 
   if (__PROFILE__) {
     console.profileEnd();

package/runtime/src/lifecycle/render.ts

@@ -2,11 +2,12 @@
 // 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 { render } from 'preact';
+import type { ComponentChild, ContainerNode } from 'preact';
 
 import { renderOpcodesInto } from '../opcodes.js';
 import { render as renderToString } from '../renderToOpcodes/index.js';
 import { __root } from '../root.js';
-// @ts-ignore
+import { commitToMainThread } from './patch/commit.js';
 
 function renderMainThread(): void {
   /* v8 ignore start */
@@ -24,7 +25,7 @@ function renderMainThread(): void {
       // @ts-ignore
       opcodes = renderToString(__root.__jsx);
     } catch (e) {
-      lynx.reportError(e);
+      lynx.reportError(e as Error);
       opcodes = [];
     } finally {
       if (__PROFILE__) {
@@ -36,6 +37,9 @@ function renderMainThread(): void {
       console.profile('renderOpcodesInto');
     }
     renderOpcodesInto(opcodes, __root as any);
+    if (__ENABLE_SSR__) {
+      __root.__opcodes = opcodes;
+    }
     if (__PROFILE__) {
       console.profileEnd();
     }
@@ -43,4 +47,9 @@ function renderMainThread(): void {
   /* v8 ignore stop */
 }
 
-export { renderMainThread };
+function renderBackground(vnode: ComponentChild, parent: ContainerNode): void {
+  render(vnode, parent);
+  void commitToMainThread();
+}
+
+export { renderMainThread, renderBackground };

package/runtime/src/list.ts

@@ -2,7 +2,7 @@
 // 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 { commitMainThreadPatchUpdate } from './lifecycle/patchUpdate.js';
+import { commitMainThreadPatchUpdate } from './lifecycle/patch/updateMainThread.js';
 import type { SnapshotInstance } from './snapshot.js';
 
 export interface ListUpdateInfo {
@@ -223,8 +223,17 @@ export const __pendingListUpdates = {
   },
 };
 
-const gSignMap: Record<number, Map<number, SnapshotInstance>> = {};
-const gRecycleMap: Record<number, Map<string, Map<number, SnapshotInstance>>> = {};
+export const gSignMap: Record<number, Map<number, SnapshotInstance>> = {};
+export const gRecycleMap: Record<number, Map<string, Map<number, SnapshotInstance>>> = {};
+
+export function clearListGlobal(): void {
+  for (const key in gSignMap) {
+    delete gSignMap[key];
+  }
+  for (const key in gRecycleMap) {
+    delete gRecycleMap[key];
+  }
+}
 
 export function componentAtIndexFactory(ctx: SnapshotInstance[]): ComponentAtIndexCallback {
   const componentAtIndex = (

package/runtime/src/lynx/calledByNative.ts

@@ -13,8 +13,51 @@ import { renderMainThread } from '../lifecycle/render.js';
 import { hydrate } from '../hydrate.js';
 import { markTiming, PerformanceTimingKeys, setPipeline } from './performance.js';
 import { __pendingListUpdates } from '../list.js';
+import { ssrHydrateByOpcodes } from '../opcodes.js';
+
+function ssrEncode() {
+  const { __opcodes } = __root;
+  delete __root.__opcodes;
+
+  const oldToJSON = SnapshotInstance.prototype.toJSON;
+  SnapshotInstance.prototype.toJSON = function(this: SnapshotInstance): any {
+    return [
+      this.type,
+      this.__id,
+      this.__elements,
+    ];
+  };
+
+  try {
+    return JSON.stringify({ __opcodes, __root_values: __root.__values });
+  } finally {
+    SnapshotInstance.prototype.toJSON = oldToJSON;
+  }
+}
+
+function ssrHydrate(info: string) {
+  const nativePage = __GetPageElement();
+  if (!nativePage) {
+    throw new Error('SSR Hydration Failed! Please check if the SSR content loaded successfully!');
+  }
+
+  const refsMap = __GetTemplateParts(nativePage);
+
+  const { __opcodes, __root_values } = JSON.parse(info);
+  __root_values && __root.setAttribute('values', __root_values);
+  ssrHydrateByOpcodes(__opcodes, __root as SnapshotInstance, refsMap);
+
+  (__root as SnapshotInstance).__elements = [nativePage];
+  (__root as SnapshotInstance).__element_root = nativePage;
+}
 
 function injectCalledByNative(): void {
+  if (process.env['NODE_ENV'] !== 'test') {
+    if (__FIRST_SCREEN_SYNC_TIMING__ !== 'jsReady' && __ENABLE_SSR__) {
+      throw new Error('`firstScreenSyncTiming` must be `jsReady` when SSR is enabled');
+    }
+  }
+
   const calledByNative: LynxCallByNative = {
     renderPage,
     updatePage,
@@ -23,9 +66,13 @@ function injectCalledByNative(): void {
       return null;
     },
     removeComponents: function(): void {},
+    ...(__ENABLE_SSR__ ? { ssrEncode, ssrHydrate } : {}),
   };
 
   Object.assign(globalThis, calledByNative);
+  Object.assign(globalThis, {
+    [LifecycleConstant.jsReady]: jsReady,
+  });
 }
 
 function renderPage(data: any): void {
@@ -46,10 +93,6 @@ function renderPage(data: any): void {
 
   if (__FIRST_SCREEN_SYNC_TIMING__ === 'immediately') {
     jsReady();
-  } else {
-    Object.assign(globalThis, {
-      [LifecycleConstant.jsReady]: jsReady,
-    });
   }
 }
 

package/runtime/src/lynx/component.ts

@@ -4,7 +4,7 @@
 import { Component } from 'preact';
 
 import { PerfSpecificKey, PerformanceTimingKeys, markTimingLegacy } from './performance.js';
-import { globalFlushOptions } from '../lifecycle/patchUpdate.js';
+import { globalFlushOptions } from '../lifecycle/patch/commit.js';
 import { NEXT_STATE } from '../renderToOpcodes/constants.js';
 
 if (__JS__) {
@@ -91,7 +91,7 @@ if (__JS__) {
 
   __Component.prototype.GlobalEventEmitter = lynxCoreInject.tt.GlobalEventEmitter;
 
-  __Component.prototype.createSelectorQuery = function(...args: any[]) {
+  __Component.prototype.createSelectorQuery = function() {
     if (!__DISABLE_CREATE_SELECTOR_QUERY_INCOMPATIBLE_WARNING__) {
       lynx.reportError(
         new Error(
@@ -99,7 +99,7 @@ if (__JS__) {
         ),
       );
     }
-    return lynx.createSelectorQuery(...args);
+    return lynx.createSelectorQuery();
   };
 
   const oldSetState = __Component.prototype.setState;

package/runtime/src/lynx/dynamic-js.ts

@@ -12,12 +12,11 @@ export function loadDynamicJS<T>(url: string): Promise<T> {
     return Promise.reject();
   }
   return new Promise((resolve, reject) => {
-    // @ts-ignore
-    lynx.requireModuleAsync(url, (err, data) => {
+    lynx.requireModuleAsync<T>(url, (err, data) => {
       if (err) {
         reject(err);
       } else {
-        resolve(data);
+        resolve(data as T);
       }
     });
   });

package/runtime/src/lynx/env.ts

@@ -94,8 +94,8 @@ export function setupLynxEnv(): void {
           }
         }
 
-        if (processorName) {
-        } else {
+        if (processorName) {}
+        else {
           hasDefaultDataProcessorExecuted = true;
         }
 

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

@@ -96,7 +96,7 @@ export function loadLazyBundle<
       if (typeof lynx.QueryComponent === 'function') {
         lynx.QueryComponent(source, callback);
       } else {
-        lynx.getNativeLynx().QueryComponent(source, callback);
+        lynx.getNativeLynx().QueryComponent!(source, callback);
       }
     });
   }

package/runtime/src/lynx/performance.ts

@@ -3,8 +3,9 @@
 // LICENSE file in the root directory of this source tree.
 import { options } from 'preact';
 import type { VNode } from 'preact';
+
 import { DIFF } from '../renderToOpcodes/constants.js';
-import { __globalSnapshotPatch } from '../snapshotPatch.js';
+import { __globalSnapshotPatch } from '../lifecycle/patch/snapshotPatch.js';
 
 enum PerformanceTimingKeys {
   update_set_state_trigger,
@@ -61,7 +62,7 @@ function markTimingLegacy(key: PerformanceTimingKeys, timingFlag_?: string): voi
       break;
     }
   }
-  lynx.getNativeApp().markTiming?.(timingFlag, PerformanceTimingKeys[key]);
+  lynx.getNativeApp().markTiming?.(timingFlag!, PerformanceTimingKeys[key]);
 }
 
 function beginPipeline(needTimestamps: boolean, timingFlag?: string): void {