@lynx-js/web-worker-runtime 0.9.1 → 0.10.1

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # @lynx-js/web-worker-runtime
 
+## 0.10.1
+
+### Patch Changes
+
+- feat: onNapiModulesCall function add new param: `dispatchNapiModules`, napiModulesMap val add new param: `handleDispatch`. ([#414](https://github.com/lynx-family/lynx-stack/pull/414))
+
+  Now you can use them to actively communicate to napiModules (background thread) in onNapiModulesCall (ui thread).
+
+- Updated dependencies [[`1af3b60`](https://github.com/lynx-family/lynx-stack/commit/1af3b6052ab27f98bf0e4d1b0ec9f7d9e88e0afc)]:
+  - @lynx-js/web-constants@0.10.1
+  - @lynx-js/web-mainthread-apis@0.10.1
+  - @lynx-js/web-worker-rpc@0.10.1
+
+## 0.10.0
+
+### Minor Changes
+
+- feat: rewrite the main thread Element PAPIs ([#343](https://github.com/lynx-family/lynx-stack/pull/343))
+
+  In this commit we've rewritten the main thread apis.
+
+  The most highlighted change is that
+
+  - Before this commit we send events directly to bts
+  - After this change, we send events to mts then send them to bts with some data combined.
+
+### Patch Changes
+
+- Updated dependencies [[`2a8ddf3`](https://github.com/lynx-family/lynx-stack/commit/2a8ddf3fb2a2fc5ed9b44184e30847aaf74fd1f4), [`3a8dabd`](https://github.com/lynx-family/lynx-stack/commit/3a8dabd877084c15db1404c912dd8a19c7a0fc59), [`878050a`](https://github.com/lynx-family/lynx-stack/commit/878050aaa3d9eb534848cab1dd0d4a2096a0a940), [`a521759`](https://github.com/lynx-family/lynx-stack/commit/a5217592f5aebea4b17860e729d523ecabb5f691), [`890c6c5`](https://github.com/lynx-family/lynx-stack/commit/890c6c51470c82104abb1049681f55e5d97cf9d6)]:
+  - @lynx-js/web-mainthread-apis@0.10.0
+  - @lynx-js/web-constants@0.10.0
+  - @lynx-js/web-worker-rpc@0.10.0
+
 ## 0.9.1
 
 ### Patch Changes

package/dist/backgroundThread/background-apis/createNapiLoader.js

@@ -1,11 +1,13 @@
 // Copyright 2023 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 { napiModulesCallEndpoint, } from '@lynx-js/web-constants';
+import { dispatchNapiModuleEndpoint, napiModulesCallEndpoint, } from '@lynx-js/web-constants';
 export const createNapiLoader = async (rpc, napiModulesMap) => {
     const napiModulesCall = rpc.createCall(napiModulesCallEndpoint);
     const napiModules = {};
-    await Promise.all(Object.entries(napiModulesMap).map(([moduleName, moduleStr]) => import(/* webpackIgnore: true */ moduleStr).then(module => napiModules[moduleName] = module?.default?.(napiModules, (name, data) => napiModulesCall(name, data, moduleName)))));
+    await Promise.all(Object.entries(napiModulesMap).map(([moduleName, moduleStr]) => import(/* webpackIgnore: true */ moduleStr).then(module => napiModules[moduleName] = module?.default?.(napiModules, (name, data) => napiModulesCall(name, data, moduleName), (func) => {
+        rpc.registerHandler(dispatchNapiModuleEndpoint, (data) => func(data));
+    }))));
     return {
         load(moduleName) {
             return napiModules[moduleName];

package/dist/backgroundThread/background-apis/createNativeApp.d.ts

@@ -1,9 +1,10 @@
 import type { Rpc } from '@lynx-js/web-worker-rpc';
 import { type LynxTemplate, type NativeApp, type NativeModulesMap } from '@lynx-js/web-constants';
+import type { TimingSystem } from './createTimingSystem.js';
 export declare function createNativeApp(config: {
     template: LynxTemplate;
     uiThreadRpc: Rpc;
     mainThreadRpc: Rpc;
-    markTimingInternal: (timingKey: string, pipelineId?: string) => void;
     nativeModulesMap: NativeModulesMap;
+    timingSystem: TimingSystem;
 }): Promise<NativeApp>;

package/dist/backgroundThread/background-apis/createNativeApp.js

@@ -7,14 +7,13 @@ import { createNativeModules } from './createNativeModules.js';
 import { registerUpdateDataHandler } from './crossThreadHandlers/registerUpdateDataHandler.js';
 import { registerPublishEventHandler } from './crossThreadHandlers/registerPublishEventHandler.js';
 import { createPerformanceApis } from './createPerformanceApis.js';
-import { registerPostTimingResultHandler } from './crossThreadHandlers/registerPostTimingResultHandler.js';
 import { registerOnNativeAppReadyHandler } from './crossThreadHandlers/registerOnNativeAppReadyHandler.js';
 import { registerSendGlobalEventHandler } from './crossThreadHandlers/registerSendGlobalEvent.js';
 import { createJSObjectDestructionObserver } from './crossThreadHandlers/createJSObjectDestructionObserver.js';
 let nativeAppCount = 0;
 export async function createNativeApp(config) {
-    const { mainThreadRpc, uiThreadRpc, markTimingInternal, template, nativeModulesMap, } = config;
-    const { performanceApis, pipelineIdToTimingFlags } = createPerformanceApis(markTimingInternal);
+    const { mainThreadRpc, uiThreadRpc, template, nativeModulesMap, timingSystem, } = config;
+    const performanceApis = createPerformanceApis(timingSystem);
     const callLepusMethod = mainThreadRpc.createCallbackify(callLepusMethodEndpoint, 2);
     const setNativeProps = uiThreadRpc.createCall(setNativePropsEndpoint);
     const triggerComponentEvent = uiThreadRpc.createCall(triggerComponentEventEndpoint);
@@ -26,7 +25,7 @@ export async function createNativeApp(config) {
         setInterval: setInterval,
         clearTimeout: clearTimeout,
         clearInterval: clearInterval,
-        nativeModuleProxy: await createNativeModules(uiThreadRpc, nativeModulesMap),
+        nativeModuleProxy: await createNativeModules(uiThreadRpc, mainThreadRpc, nativeModulesMap),
         loadScriptAsync: function (sourceURL, callback) {
             const mainfestUrl = template.manifest[`/${sourceURL}`];
             if (mainfestUrl)
@@ -68,13 +67,13 @@ export async function createNativeApp(config) {
         invokeUIMethod: createInvokeUIMethod(uiThreadRpc),
         setCard(tt) {
             registerOnLifecycleEventHandler(mainThreadRpc, tt);
-            registerPublicComponentEventHandler(uiThreadRpc, tt);
-            registerPublishEventHandler(uiThreadRpc, tt);
-            registerGlobalExposureEventHandler(uiThreadRpc, tt);
+            registerPublicComponentEventHandler(mainThreadRpc, tt);
+            registerPublishEventHandler(mainThreadRpc, tt);
+            registerGlobalExposureEventHandler(mainThreadRpc, tt);
             registerUpdateDataHandler(uiThreadRpc, tt);
-            registerPostTimingResultHandler(uiThreadRpc, tt, pipelineIdToTimingFlags);
             registerOnNativeAppReadyHandler(uiThreadRpc, tt);
             registerSendGlobalEventHandler(uiThreadRpc, tt);
+            timingSystem.registerGlobalEmitter(tt.GlobalEventEmitter);
         },
         triggerComponentEvent,
         selectComponent,

package/dist/backgroundThread/background-apis/createNativeModules.d.ts

@@ -1,3 +1,3 @@
 import { type NativeModulesMap } from '@lynx-js/web-constants';
 import type { Rpc } from '@lynx-js/web-worker-rpc';
-export declare function createNativeModules(rpc: Rpc, nativeModulesMap: NativeModulesMap): Promise<Record<string, any>>;
+export declare function createNativeModules(uiThreadRpc: Rpc, mainThreadRpc: Rpc, nativeModulesMap: NativeModulesMap): Promise<Record<string, any>>;

package/dist/backgroundThread/background-apis/createNativeModules.js

@@ -1,10 +1,10 @@
 // Copyright 2023 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 { nativeModulesCallEndpoint, switchExposureService, } from '@lynx-js/web-constants';
-export async function createNativeModules(rpc, nativeModulesMap) {
-    const switchExposure = rpc.createCall(switchExposureService);
-    const nativeModulesCall = rpc.createCall(nativeModulesCallEndpoint);
+import { nativeModulesCallEndpoint, switchExposureServiceEndpoint, } from '@lynx-js/web-constants';
+export async function createNativeModules(uiThreadRpc, mainThreadRpc, nativeModulesMap) {
+    const switchExposure = mainThreadRpc.createCall(switchExposureServiceEndpoint);
+    const nativeModulesCall = uiThreadRpc.createCall(nativeModulesCallEndpoint);
     const lynxExposureModule = {
         resumeExposure() {
             switchExposure(true, true);

package/dist/backgroundThread/background-apis/createPerformanceApis.d.ts

@@ -1,5 +1,3 @@
 import type { NativeApp } from '@lynx-js/web-constants';
-export declare function createPerformanceApis(markTimingInternal: (timingKey: string, pipelineId: string) => void): {
-    performanceApis: Pick<NativeApp, 'generatePipelineOptions' | 'onPipelineStart' | 'markPipelineTiming' | 'bindPipelineIdWithTimingFlag'>;
-    pipelineIdToTimingFlags: Map<string, string[]>;
-};
+import type { TimingSystem } from './createTimingSystem.js';
+export declare function createPerformanceApis(timingSystem: TimingSystem): Pick<NativeApp, 'generatePipelineOptions' | 'onPipelineStart' | 'markPipelineTiming' | 'bindPipelineIdWithTimingFlag'>;

package/dist/backgroundThread/background-apis/createPerformanceApis.js

@@ -1,9 +1,8 @@
 // Copyright 2023 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.
-export function createPerformanceApis(markTimingInternal) {
+export function createPerformanceApis(timingSystem) {
     let inc = 0;
-    const pipelineIdToTimingFlags = new Map();
     const performanceApis = {
         generatePipelineOptions: () => {
             const newPipelineId = `_pipeline_` + (inc++);
@@ -16,19 +15,16 @@ export function createPerformanceApis(markTimingInternal) {
             // Do nothing
         },
         markPipelineTiming: function (pipelineId, timingKey) {
-            markTimingInternal(timingKey, pipelineId);
+            timingSystem.markTimingInternal(timingKey, pipelineId);
         },
         bindPipelineIdWithTimingFlag: function (pipelineId, timingFlag) {
-            if (!pipelineIdToTimingFlags.has(pipelineId)) {
-                pipelineIdToTimingFlags.set(pipelineId, []);
+            if (!timingSystem.pipelineIdToTimingFlags.has(pipelineId)) {
+                timingSystem.pipelineIdToTimingFlags.set(pipelineId, []);
             }
-            const timingFlags = pipelineIdToTimingFlags.get(pipelineId);
+            const timingFlags = timingSystem.pipelineIdToTimingFlags.get(pipelineId);
             timingFlags.push(timingFlag);
         },
     };
-    return {
-        performanceApis,
-        pipelineIdToTimingFlags,
-    };
+    return performanceApis;
 }
 //# sourceMappingURL=createPerformanceApis.js.map

package/dist/backgroundThread/background-apis/createTimingSystem.d.ts

@@ -0,0 +1,8 @@
+import { type EventEmitter } from '@lynx-js/web-constants';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export type TimingSystem = {
+    registerGlobalEmitter: (globalEventEmitter: EventEmitter) => void;
+    markTimingInternal: (timingKey: string, pipelineId?: string) => void;
+    pipelineIdToTimingFlags: Map<string, string[]>;
+};
+export declare function createTimingSystem(mainThreadRpc: Rpc, backgroundThreadRpc: Rpc): TimingSystem;

package/dist/backgroundThread/background-apis/createTimingSystem.js

@@ -0,0 +1,84 @@
+// Copyright 2023 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 { dispatchLynxViewEventEndpoint, markTimingEndpoint, postTimingFlagsEndpoint, } from '@lynx-js/web-constants';
+const ListenerKeys = {
+    onSetup: 'lynx.performance.timing.onSetup',
+    onUpdate: 'lynx.performance.timing.onUpdate',
+};
+export function createTimingSystem(mainThreadRpc, backgroundThreadRpc) {
+    let isFp = true;
+    const setupTiming = {};
+    const pipelineIdToTiming = new Map();
+    const pipelineIdToTimingFlags = new Map();
+    const dispatchLynxViewEvent = backgroundThreadRpc.createCall(dispatchLynxViewEventEndpoint);
+    let commonTimingFlags = [];
+    function markTimingInternal(timingKey, pipelineId, timeStamp) {
+        if (!timeStamp)
+            timeStamp = performance.now() + performance.timeOrigin;
+        if (!pipelineId) {
+            setupTiming[timingKey] = timeStamp;
+            return;
+        }
+        if (!pipelineIdToTiming.has(pipelineId)) {
+            pipelineIdToTiming.set(pipelineId, {});
+        }
+        const timingInfo = pipelineIdToTiming.get(pipelineId);
+        timingInfo[timingKey] = timeStamp;
+    }
+    const registerGlobalEmitter = (globalEventEmitter) => {
+        mainThreadRpc.registerHandler(postTimingFlagsEndpoint, (timingFlags, pipelineId) => {
+            if (!pipelineId) {
+                commonTimingFlags = commonTimingFlags.concat(timingFlags);
+            }
+            else
+                timingFlags = timingFlags.concat(commonTimingFlags);
+            if (isFp) {
+                const timingInfo = {
+                    extra_timing: {},
+                    setup_timing: setupTiming,
+                    update_timings: {},
+                    metrics: {},
+                    has_reload: false,
+                    thread_strategy: 0,
+                    url: '',
+                };
+                globalEventEmitter.emit(ListenerKeys.onSetup, [timingInfo]);
+                dispatchLynxViewEvent('timing', setupTiming);
+            }
+            else {
+                const timings = (pipelineId ? pipelineIdToTiming.get(pipelineId) : undefined) ?? {};
+                const flags = [
+                    ...timingFlags,
+                    ...(pipelineIdToTimingFlags.get(pipelineId) ?? []),
+                ];
+                const timingInfo = {
+                    extra_timing: {},
+                    setup_timing: {},
+                    update_timings: Object.fromEntries([...flags].map(flag => [flag, timings])),
+                    metrics: {},
+                    has_reload: false,
+                    thread_strategy: 0,
+                    url: '',
+                };
+                globalEventEmitter.emit(ListenerKeys.onUpdate, [timingInfo]);
+                dispatchLynxViewEvent('timing', timings);
+            }
+            if (pipelineId) {
+                pipelineIdToTimingFlags.delete(pipelineId);
+                pipelineIdToTiming.delete(pipelineId);
+            }
+            if (isFp) {
+                isFp = false;
+            }
+        });
+    };
+    mainThreadRpc.registerHandler(markTimingEndpoint, markTimingInternal);
+    backgroundThreadRpc.registerHandler(markTimingEndpoint, markTimingInternal);
+    return {
+        markTimingInternal,
+        registerGlobalEmitter,
+        pipelineIdToTimingFlags,
+    };
+}
+//# sourceMappingURL=createTimingSystem.js.map

package/dist/backgroundThread/background-apis/startBackgroundThread.js

@@ -5,23 +5,23 @@ import { Rpc } from '@lynx-js/web-worker-rpc';
 import { createBackgroundLynx } from './createBackgroundLynx.js';
 import { createNativeApp } from './createNativeApp.js';
 import { registerDisposeHandler } from './crossThreadHandlers/registerDisposeHandler.js';
-import { createMarkTimingInternal } from './crossThreadHandlers/createBackgroundMarkTimingInternal.js';
 import { BackgroundThreadStartEndpoint } from '@lynx-js/web-constants';
 import { createNapiLoader } from './createNapiLoader.js';
+import { createTimingSystem } from './createTimingSystem.js';
 const lynxCore = import(
 /* webpackMode: "eager" */ '@lynx-js/lynx-core/web');
 export function startBackgroundThread(uiThreadPort, mainThreadPort) {
     const uiThreadRpc = new Rpc(uiThreadPort, 'bg-to-ui');
     const mainThreadRpc = new Rpc(mainThreadPort, 'bg-to-main');
-    const markTimingInternal = createMarkTimingInternal(uiThreadRpc);
-    markTimingInternal('load_core_start');
+    const timingSystem = createTimingSystem(mainThreadRpc, uiThreadRpc);
+    timingSystem.markTimingInternal('load_core_start');
     mainThreadRpc.registerHandler(BackgroundThreadStartEndpoint, async (config) => {
-        markTimingInternal('load_core_end');
+        timingSystem.markTimingInternal('load_core_end');
         const nativeApp = await createNativeApp({
             ...config,
             uiThreadRpc,
             mainThreadRpc,
-            markTimingInternal,
+            timingSystem,
         });
         globalThis['napiLoaderOnRT' + nativeApp.id] =
             await createNapiLoader(uiThreadRpc, config.napiModulesMap);

package/dist/mainThread/crossThreadHandlers/createMainthreadMarkTimingInternal.js

@@ -1,10 +1,10 @@
 // Copyright 2023 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 { postTimingInfoFromMainThread } from '@lynx-js/web-constants';
+import { markTimingEndpoint } from '@lynx-js/web-constants';
 export function createMarkTimingInternal(uiThreadRpc) {
     return (timingKey, pipelineId) => {
-        uiThreadRpc.invoke(postTimingInfoFromMainThread, [
+        uiThreadRpc.invoke(markTimingEndpoint, [
             timingKey,
             pipelineId,
             performance.now() + performance.timeOrigin,

package/dist/mainThread/startMainThread.js

@@ -1,21 +1,27 @@
 // Copyright 2023 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 { BackgroundThreadStartEndpoint, mainThreadChunkReadyEndpoint, mainThreadStartEndpoint, onLifecycleEventEndpoint, flushElementTreeEndpoint, reportErrorEndpoint, } from '@lynx-js/web-constants';
+import { BackgroundThreadStartEndpoint, mainThreadChunkReadyEndpoint, mainThreadStartEndpoint, onLifecycleEventEndpoint, flushElementTreeEndpoint, reportErrorEndpoint, publishEventEndpoint, publicComponentEventEndpoint, postExposureEndpoint, postOffscreenEventEndpoint, switchExposureServiceEndpoint, postTimingFlagsEndpoint, } from '@lynx-js/web-constants';
 import { Rpc } from '@lynx-js/web-worker-rpc';
-import { MainThreadRuntime } from '@lynx-js/web-mainthread-apis';
+import { MainThreadRuntime, switchExposureService, } from '@lynx-js/web-mainthread-apis';
 import { registerCallLepusMethodHandler } from './crossThreadHandlers/registerCallLepusMethodHandler.js';
-import { registerPostMainThreadEventHandler } from './crossThreadHandlers/registerPostMainThreadEventHandler.js';
 import { registerGetCustomSectionHandler } from './crossThreadHandlers/registerGetCustomSectionHandler.js';
 import { createMarkTimingInternal } from './crossThreadHandlers/createMainthreadMarkTimingInternal.js';
 import { registerUpdateDataHandler } from './crossThreadHandlers/registerUpdateDataHandler.js';
+import { OffscreenDocument } from '@lynx-js/offscreen-document/webworker';
+import { _onEvent, } from '@lynx-js/offscreen-document/webworker';
 export function startMainThread(uiThreadPort, backgroundThreadPort) {
     const uiThreadRpc = new Rpc(uiThreadPort, 'main-to-ui');
     const backgroundThreadRpc = new Rpc(backgroundThreadPort, 'main-to-bg');
-    const markTimingInternal = createMarkTimingInternal(uiThreadRpc);
+    const markTimingInternal = createMarkTimingInternal(backgroundThreadRpc);
+    const postTimingFlags = backgroundThreadRpc.createCall(postTimingFlagsEndpoint);
     const backgroundStart = backgroundThreadRpc.createCall(BackgroundThreadStartEndpoint);
     const __OnLifecycleEvent = backgroundThreadRpc.createCall(onLifecycleEventEndpoint);
+    const publishEvent = backgroundThreadRpc.createCall(publishEventEndpoint);
+    const publicComponentEvent = backgroundThreadRpc.createCall(publicComponentEventEndpoint);
+    const postExposure = backgroundThreadRpc.createCall(postExposureEndpoint);
     const mainThreadChunkReady = uiThreadRpc.createCall(mainThreadChunkReadyEndpoint);
+    let operations = [];
     const flushElementTree = uiThreadRpc.createCall(flushElementTreeEndpoint);
     const reportError = uiThreadRpc.createCall(reportErrorEndpoint);
     markTimingInternal('lepus_excute_start');
@@ -26,6 +32,12 @@ export function startMainThread(uiThreadPort, backgroundThreadPort) {
         await import(
         /* webpackIgnore: true */ template.lepusCode.root);
         const entry = globalThis.module.exports;
+        const docu = new OffscreenDocument({
+            onCommit: (currentOperations) => {
+                operations = currentOperations;
+            },
+        });
+        uiThreadRpc.registerHandler(postOffscreenEventEndpoint, docu[_onEvent]);
         const runtime = new MainThreadRuntime({
             tagMap,
             browserConfig,
@@ -34,18 +46,19 @@ export function startMainThread(uiThreadPort, backgroundThreadPort) {
             pageConfig,
             styleInfo,
             lepusCode,
+            docu,
             callbacks: {
                 mainChunkReady: function () {
-                    mainThreadChunkReady({ pageConfig });
+                    mainThreadChunkReady();
                     markTimingInternal('data_processor_start');
                     const initData = runtime.processData
                         ? runtime.processData(config.initData)
                         : config.initData;
                     markTimingInternal('data_processor_end');
                     registerCallLepusMethodHandler(backgroundThreadRpc, runtime);
-                    registerPostMainThreadEventHandler(uiThreadRpc);
                     registerGetCustomSectionHandler(backgroundThreadRpc, customSections);
                     registerUpdateDataHandler(uiThreadRpc, runtime);
+                    backgroundThreadRpc.registerHandler(switchExposureServiceEndpoint, runtime[switchExposureService]);
                     backgroundStart({
                         initData,
                         globalProps,
@@ -58,7 +71,18 @@ export function startMainThread(uiThreadPort, backgroundThreadPort) {
                     runtime.renderPage(initData);
                     runtime.__FlushElementTree(undefined, {});
                 },
-                flushElementTree,
+                flushElementTree: async (options, timingFlags) => {
+                    const pipelineId = options?.pipelineOptions?.pipelineID;
+                    markTimingInternal('dispatch_start', pipelineId);
+                    docu.commit();
+                    markTimingInternal('layout_start', pipelineId);
+                    markTimingInternal('ui_operation_flush_start', pipelineId);
+                    await flushElementTree(operations);
+                    markTimingInternal('ui_operation_flush_end', pipelineId);
+                    markTimingInternal('layout_end', pipelineId);
+                    markTimingInternal('dispatch_end', pipelineId);
+                    postTimingFlags(timingFlags, pipelineId);
+                },
                 _ReportError: reportError,
                 __OnLifecycleEvent,
                 /**
@@ -67,6 +91,9 @@ export function startMainThread(uiThreadPort, backgroundThreadPort) {
                  * But our markTimingInternal is (timingFlag:string, pipelineId?:string, timeStamp?:number) => void
                  */
                 markTiming: (a, b) => markTimingInternal(b, a),
+                publishEvent,
+                publicComponentEvent,
+                postExposure,
             },
         }).globalThis;
         markTimingInternal('decode_end');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lynx-js/web-worker-runtime",
-  "version": "0.9.1",
+  "version": "0.10.1",
   "private": false,
   "description": "",
   "keywords": [],
@@ -22,9 +22,10 @@
     "README.md"
   ],
   "dependencies": {
-    "@lynx-js/web-constants": "0.9.1",
-    "@lynx-js/web-worker-rpc": "0.9.1",
-    "@lynx-js/web-mainthread-apis": "0.9.1"
+    "@lynx-js/offscreen-document": "0.0.0",
+    "@lynx-js/web-constants": "0.10.1",
+    "@lynx-js/web-mainthread-apis": "0.10.1",
+    "@lynx-js/web-worker-rpc": "0.10.1"
   },
   "devDependencies": {
     "@lynx-js/lynx-core": "0.1.0"

package/dist/backgroundThread/background-apis/crossThreadHandlers/createBackgroundMarkTimingInternal.d.ts

@@ -1,2 +0,0 @@
-import type { Rpc } from '@lynx-js/web-worker-rpc';
-export declare function createMarkTimingInternal(backgroundRpc: Rpc): (timingKey: string, pipelineId?: string) => void;

package/dist/backgroundThread/background-apis/crossThreadHandlers/createBackgroundMarkTimingInternal.js

@@ -1,14 +0,0 @@
-// Copyright 2023 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 { postTimingInfoFromBackgroundThread } from '@lynx-js/web-constants';
-export function createMarkTimingInternal(backgroundRpc) {
-    return (timingKey, pipelineId) => {
-        backgroundRpc.invoke(postTimingInfoFromBackgroundThread, [
-            timingKey,
-            pipelineId,
-            performance.now() + performance.timeOrigin,
-        ]);
-    };
-}
-//# sourceMappingURL=createBackgroundMarkTimingInternal.js.map

package/dist/backgroundThread/background-apis/crossThreadHandlers/registerPostTimingResultHandler.d.ts

@@ -1,3 +0,0 @@
-import { type NativeTTObject } from '@lynx-js/web-constants';
-import type { Rpc } from '@lynx-js/web-worker-rpc';
-export declare function registerPostTimingResultHandler(uiThreadRpc: Rpc, tt: NativeTTObject, pipelineIdToTimingFlags: Map<string, string[]>): void;

package/dist/backgroundThread/background-apis/crossThreadHandlers/registerPostTimingResultHandler.js

@@ -1,46 +0,0 @@
-// Copyright 2023 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 { postTimingResult, } from '@lynx-js/web-constants';
-const ListenerKeys = {
-    onSetup: 'lynx.performance.timing.onSetup',
-    onUpdate: 'lynx.performance.timing.onUpdate',
-};
-export function registerPostTimingResultHandler(uiThreadRpc, tt, pipelineIdToTimingFlags) {
-    let setupTimingSaved = {};
-    uiThreadRpc.registerHandler(postTimingResult, (pipelineId, updateTimingStamps, timingFlags, setupTimingStamps) => {
-        if (setupTimingStamps) {
-            setupTimingSaved = setupTimingStamps;
-            const timingInfo = {
-                extra_timing: {},
-                setup_timing: setupTimingStamps,
-                update_timings: {},
-                metrics: {},
-                has_reload: false,
-                thread_strategy: 0,
-                url: '',
-            };
-            tt.GlobalEventEmitter.emit(ListenerKeys.onSetup, [timingInfo]);
-        }
-        else {
-            const flags = [
-                ...timingFlags,
-                ...(pipelineIdToTimingFlags.get(pipelineId) ?? []),
-            ];
-            const timingInfo = {
-                extra_timing: {},
-                setup_timing: setupTimingSaved,
-                update_timings: Object.fromEntries([...flags].map(flag => [flag, updateTimingStamps])),
-                metrics: {},
-                has_reload: false,
-                thread_strategy: 0,
-                url: '',
-            };
-            tt.GlobalEventEmitter.emit(ListenerKeys.onUpdate, [timingInfo]);
-        }
-        if (pipelineId) {
-            pipelineIdToTimingFlags.delete(pipelineId);
-        }
-    });
-}
-//# sourceMappingURL=registerPostTimingResultHandler.js.map

package/dist/mainThread/crossThreadHandlers/registerPostMainThreadEventHandler.d.ts

@@ -1,2 +0,0 @@
-import type { Rpc } from '@lynx-js/web-worker-rpc';
-export declare function registerPostMainThreadEventHandler(rpc: Rpc): void;

package/dist/mainThread/crossThreadHandlers/registerPostMainThreadEventHandler.js

@@ -1,8 +0,0 @@
-import { ElementThreadElement } from '@lynx-js/web-mainthread-apis';
-import { postMainThreadEvent } from '@lynx-js/web-constants';
-export function registerPostMainThreadEventHandler(rpc) {
-    rpc.registerHandler(postMainThreadEvent, (event) => {
-        ElementThreadElement.receiveEvent(event);
-    });
-}
-//# sourceMappingURL=registerPostMainThreadEventHandler.js.map