@lynx-js/web-worker-runtime 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @lynx-js/web-worker-runtime
 
+## 0.13.0
+
+### Patch Changes
+
+- refactor: isolate SystemInfo ([#628](https://github.com/lynx-family/lynx-stack/pull/628))
+
+  Never assign `SystemInfo` on worker's self object.
+
+- feat: support thread strategy `all-on-ui` ([#625](https://github.com/lynx-family/lynx-stack/pull/625))
+
+  ```html
+  <lynx-view thread-strategy="all-on-ui"></lynx-view>
+  ```
+
+  This will make the lynx's main-thread run on the UA's main thread.
+
+  Note that the `all-on-ui` does not support the HMR & chunk splitting yet.
+
+- refactor: move mainthread impl into mainthread-api packages ([#622](https://github.com/lynx-family/lynx-stack/pull/622))
+
+- Updated dependencies [[`4ee0465`](https://github.com/lynx-family/lynx-stack/commit/4ee0465f6e5846a0d038b49d2a7c95e87c9e5c77), [`74b5bd1`](https://github.com/lynx-family/lynx-stack/commit/74b5bd15339b70107a7c42525494da46e8f8f6bd), [`06bb78a`](https://github.com/lynx-family/lynx-stack/commit/06bb78a6b93d4a7be7177a6269dd4337852ce90d), [`5a3d9af`](https://github.com/lynx-family/lynx-stack/commit/5a3d9afe52ba639987db124ca35580261e0718b5), [`5269cab`](https://github.com/lynx-family/lynx-stack/commit/5269cabef7609159bdd0dd14a03c5da667907424), [`74b5bd1`](https://github.com/lynx-family/lynx-stack/commit/74b5bd15339b70107a7c42525494da46e8f8f6bd), [`2b069f8`](https://github.com/lynx-family/lynx-stack/commit/2b069f8786c95bdb9ac1f35091f05f7fd3b52225)]:
+  - @lynx-js/web-mainthread-apis@0.13.0
+  - @lynx-js/web-constants@0.13.0
+  - @lynx-js/offscreen-document@0.0.1
+  - @lynx-js/web-worker-rpc@0.13.0
+
 ## 0.12.0
 
 ### Patch Changes

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

@@ -1,6 +1,5 @@
-import { type Cloneable, type NativeApp } from '@lynx-js/web-constants';
+import { LynxCrossThreadContext, type Cloneable, type NativeApp } from '@lynx-js/web-constants';
 import type { Rpc } from '@lynx-js/web-worker-rpc';
-import { LynxCrossThreadContext } from '../../common/LynxCrossThreadContext.js';
 export interface CreateLynxConfig {
     globalProps: unknown;
     customSections: Record<string, Cloneable>;

package/dist/backgroundThread/background-apis/createBackgroundLynx.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.
-import { dispatchCoreContextOnBackgroundEndpoint, dispatchJSContextOnMainThreadEndpoint, } from '@lynx-js/web-constants';
+import { dispatchCoreContextOnBackgroundEndpoint, dispatchJSContextOnMainThreadEndpoint, LynxCrossThreadContext, } from '@lynx-js/web-constants';
 import { createGetCustomSection } from './crossThreadHandlers/createGetCustomSection.js';
-import { LynxCrossThreadContext } from '../../common/LynxCrossThreadContext.js';
 export function createBackgroundLynx(config, nativeApp, mainThreadRpc) {
     const coreContext = new LynxCrossThreadContext({
         rpc: mainThreadRpc,

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

@@ -1,5 +1,5 @@
 import type { Rpc } from '@lynx-js/web-worker-rpc';
-import { type LynxTemplate, type NativeApp, type NativeModulesMap } from '@lynx-js/web-constants';
+import { type LynxTemplate, type NativeApp, type NativeModulesMap, type BrowserConfig } from '@lynx-js/web-constants';
 import type { TimingSystem } from './createTimingSystem.js';
 export declare function createNativeApp(config: {
     template: LynxTemplate;
@@ -7,4 +7,5 @@ export declare function createNativeApp(config: {
     mainThreadRpc: Rpc;
     nativeModulesMap: NativeModulesMap;
     timingSystem: TimingSystem;
+    browserConfig: BrowserConfig;
 }): Promise<NativeApp>;

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

@@ -1,4 +1,4 @@
-import { callLepusMethodEndpoint, setNativePropsEndpoint, triggerComponentEventEndpoint, selectComponentEndpoint, } from '@lynx-js/web-constants';
+import { callLepusMethodEndpoint, setNativePropsEndpoint, triggerComponentEventEndpoint, selectComponentEndpoint, systemInfo, } from '@lynx-js/web-constants';
 import { createInvokeUIMethod } from './crossThreadHandlers/createInvokeUIMethod.js';
 import { registerPublicComponentEventHandler } from './crossThreadHandlers/registerPublicComponentEventHandler.js';
 import { registerGlobalExposureEventHandler } from './crossThreadHandlers/registerGlobalExposureEventHandler.js';
@@ -11,12 +11,26 @@ import { createJSObjectDestructionObserver } from './crossThreadHandlers/createJ
 let nativeAppCount = 0;
 const sharedData = {};
 export async function createNativeApp(config) {
-    const { mainThreadRpc, uiThreadRpc, template, nativeModulesMap, timingSystem, } = config;
+    const { mainThreadRpc, uiThreadRpc, template, nativeModulesMap, timingSystem, browserConfig, } = config;
     const performanceApis = createPerformanceApis(timingSystem);
     const callLepusMethod = mainThreadRpc.createCallbackify(callLepusMethodEndpoint, 2);
     const setNativeProps = uiThreadRpc.createCall(setNativePropsEndpoint);
     const triggerComponentEvent = uiThreadRpc.createCall(triggerComponentEventEndpoint);
     const selectComponent = uiThreadRpc.createCallbackify(selectComponentEndpoint, 3);
+    const createBundleInitReturnObj = () => {
+        const entry = globalThis.module.exports;
+        return {
+            init: (lynxCoreInject) => {
+                lynxCoreInject.tt.lynxCoreInject = lynxCoreInject;
+                lynxCoreInject.tt.globalThis ??= lynxCoreInject;
+                Object.assign(lynxCoreInject.tt, {
+                    SystemInfo: { ...systemInfo, pixelRatio: browserConfig.pixelRatio },
+                });
+                const ret = entry?.(lynxCoreInject.tt);
+                return ret;
+            },
+        };
+    };
     const nativeApp = {
         id: (nativeAppCount++).toString(),
         ...performanceApis,
@@ -32,15 +46,7 @@ export async function createNativeApp(config) {
             import(
             /* webpackIgnore: true */
             sourceURL).catch(callback).then(async () => {
-                callback(null, {
-                    init: (lynxCoreInject) => {
-                        lynxCoreInject.tt.lynxCoreInject = lynxCoreInject;
-                        lynxCoreInject.tt.globalThis ??= lynxCoreInject;
-                        const entry = globalThis.module.exports;
-                        const ret = entry?.(lynxCoreInject.tt);
-                        return ret;
-                    },
-                });
+                callback(null, createBundleInitReturnObj());
             });
         },
         loadScript: (sourceURL) => {
@@ -48,14 +54,7 @@ export async function createNativeApp(config) {
             if (mainfestUrl)
                 sourceURL = mainfestUrl;
             importScripts(sourceURL);
-            const entry = globalThis.module.exports;
-            return {
-                init: (lynxCoreInject) => {
-                    lynxCoreInject.tt.lynxCoreInject = lynxCoreInject;
-                    lynxCoreInject.tt.globalThis ??= lynxCoreInject;
-                    return entry?.(lynxCoreInject.tt);
-                },
-            };
+            return createBundleInitReturnObj();
         },
         requestAnimationFrame(cb) {
             return requestAnimationFrame(cb);

package/dist/index.d.ts

@@ -2,5 +2,4 @@ export interface WorkerStartMessage {
     mode: 'main' | 'background';
     toPeerThread: MessagePort;
     toUIThread: MessagePort;
-    pixelRatio: number;
 }

package/dist/index.js

@@ -4,9 +4,8 @@
 import { startBackgroundThread } from './backgroundThread/index.js';
 import { startMainThread } from './mainThread/startMainThread.js';
 self.onmessage = (ev) => {
-    const { mode, toPeerThread, toUIThread, pixelRatio } = ev
+    const { mode, toPeerThread, toUIThread } = ev
         .data;
-    globalThis.SystemInfo.pixelRatio = pixelRatio;
     if (mode === 'main') {
         startMainThread(toUIThread, toPeerThread);
     }
@@ -15,7 +14,6 @@ self.onmessage = (ev) => {
     }
 };
 Object.assign(globalThis, {
-    SystemInfo: { platform: 'web', lynxSdkVersion: '3.0' },
     module: { exports: null },
 });
 //# sourceMappingURL=index.js.map

package/dist/mainThread/startMainThread.js

@@ -1,121 +1,28 @@
 // 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, mainThreadStartEndpoint, flushElementTreeEndpoint, reportErrorEndpoint, publishEventEndpoint, publicComponentEventEndpoint, postExposureEndpoint, postOffscreenEventEndpoint, switchExposureServiceEndpoint, postTimingFlagsEndpoint, dispatchCoreContextOnBackgroundEndpoint, dispatchJSContextOnMainThreadEndpoint, } from '@lynx-js/web-constants';
+import { flushElementTreeEndpoint, mainThreadStartEndpoint, postOffscreenEventEndpoint, reportErrorEndpoint, } from '@lynx-js/web-constants';
 import { Rpc } from '@lynx-js/web-worker-rpc';
-import { MainThreadRuntime, switchExposureService, } from '@lynx-js/web-mainthread-apis';
-import { registerCallLepusMethodHandler } from './crossThreadHandlers/registerCallLepusMethodHandler.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';
-import { LynxCrossThreadContext } from '../common/LynxCrossThreadContext.js';
+import { _onEvent } from '@lynx-js/offscreen-document/webworker';
+import { registerUpdateDataHandler } from './crossThreadHandlers/registerUpdateDataHandler.js';
+const { loadMainThread } = await import('@lynx-js/web-mainthread-apis');
 export function startMainThread(uiThreadPort, backgroundThreadPort) {
     const uiThreadRpc = new Rpc(uiThreadPort, 'main-to-ui');
     const backgroundThreadRpc = new Rpc(backgroundThreadPort, 'main-to-bg');
     const markTimingInternal = createMarkTimingInternal(backgroundThreadRpc);
-    const postTimingFlags = backgroundThreadRpc.createCall(postTimingFlagsEndpoint);
-    const backgroundStart = backgroundThreadRpc.createCall(BackgroundThreadStartEndpoint);
-    const publishEvent = backgroundThreadRpc.createCall(publishEventEndpoint);
-    const publicComponentEvent = backgroundThreadRpc.createCall(publicComponentEventEndpoint);
-    const postExposure = backgroundThreadRpc.createCall(postExposureEndpoint);
-    let operations = [];
-    const flushElementTree = uiThreadRpc.createCall(flushElementTreeEndpoint);
+    const uiFlush = uiThreadRpc.createCall(flushElementTreeEndpoint);
     const reportError = uiThreadRpc.createCall(reportErrorEndpoint);
-    markTimingInternal('lepus_excute_start');
-    uiThreadRpc.registerHandler(mainThreadStartEndpoint, async (config) => {
-        let isFp = true;
-        const { globalProps, template, browserConfig, nativeModulesMap, napiModulesMap, tagMap, } = config;
-        const { styleInfo, pageConfig, customSections, cardType, lepusCode } = template;
-        markTimingInternal('decode_start');
-        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 jsContext = new LynxCrossThreadContext({
-            rpc: backgroundThreadRpc,
-            receiveEventEndpoint: dispatchJSContextOnMainThreadEndpoint,
-            sendEventEndpoint: dispatchCoreContextOnBackgroundEndpoint,
+    const docu = new OffscreenDocument({
+        onCommit: uiFlush,
+    });
+    uiThreadRpc.registerHandler(postOffscreenEventEndpoint, docu[_onEvent]);
+    const { startMainThread } = loadMainThread(backgroundThreadRpc, docu, docu.commit.bind(docu), markTimingInternal, reportError);
+    uiThreadRpc.registerHandler(mainThreadStartEndpoint, (config) => {
+        startMainThread(config).then((runtime) => {
+            registerUpdateDataHandler(uiThreadRpc, runtime);
         });
-        const runtime = new MainThreadRuntime({
-            jsContext,
-            tagMap,
-            browserConfig,
-            customSections,
-            globalProps,
-            pageConfig,
-            styleInfo,
-            lepusCode,
-            docu,
-            callbacks: {
-                mainChunkReady: () => {
-                    markTimingInternal('data_processor_start');
-                    const initData = runtime.processData
-                        ? runtime.processData(config.initData)
-                        : config.initData;
-                    markTimingInternal('data_processor_end');
-                    registerCallLepusMethodHandler(backgroundThreadRpc, runtime);
-                    registerGetCustomSectionHandler(backgroundThreadRpc, customSections);
-                    registerUpdateDataHandler(uiThreadRpc, runtime);
-                    backgroundThreadRpc.registerHandler(switchExposureServiceEndpoint, runtime[switchExposureService]);
-                    backgroundStart({
-                        initData,
-                        globalProps,
-                        template,
-                        cardType: cardType ?? 'react',
-                        customSections: Object.fromEntries(Object.entries(customSections).filter(([, value]) => value.type !== 'lazy').map(([k, v]) => [k, v.content])),
-                        nativeModulesMap,
-                        napiModulesMap,
-                    });
-                    runtime.renderPage(initData);
-                    runtime.__FlushElementTree(undefined, {});
-                },
-                flushElementTree: async (options, timingFlags) => {
-                    const pipelineId = options?.pipelineOptions?.pipelineID;
-                    markTimingInternal('dispatch_start', pipelineId);
-                    docu.commit();
-                    if (isFp) {
-                        isFp = false;
-                        jsContext.dispatchEvent({
-                            type: '__OnNativeAppReady',
-                            data: undefined,
-                        });
-                    }
-                    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: (data) => {
-                    jsContext.dispatchEvent({
-                        type: '__OnLifecycleEvent',
-                        data,
-                    });
-                },
-                /**
-                 * Note :
-                 * The parameter of lynx.performance.markTiming is (pipelineId:string, timingFlag:string)=>void
-                 * But our markTimingInternal is (timingFlag:string, pipelineId?:string, timeStamp?:number) => void
-                 */
-                markTiming: (a, b) => markTimingInternal(b, a),
-                publishEvent,
-                publicComponentEvent,
-                postExposure,
-            },
-        }).globalThis;
-        markTimingInternal('decode_end');
-        entry(runtime);
-        jsContext.__start(); // start the jsContext after the runtime is created
     });
 }
 //# sourceMappingURL=startMainThread.js.map

package/package.json

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

package/dist/common/LynxCrossThreadContext.d.ts

@@ -1,12 +0,0 @@
-import { type dispatchCoreContextOnBackgroundEndpoint, type LynxContextEventTarget, type Rpc } from '@lynx-js/web-constants';
-export declare class LynxCrossThreadContext extends EventTarget implements LynxContextEventTarget {
-    private _config;
-    constructor(_config: {
-        rpc: Rpc;
-        receiveEventEndpoint: typeof dispatchCoreContextOnBackgroundEndpoint;
-        sendEventEndpoint: typeof dispatchCoreContextOnBackgroundEndpoint;
-    });
-    postMessage(...args: any[]): void;
-    dispatchEvent(event: ContextCrossThreadEvent): 3;
-    __start(): void;
-}

package/dist/common/LynxCrossThreadContext.js

@@ -1,24 +0,0 @@
-import { DispatchEventResult, } from '@lynx-js/web-constants';
-export class LynxCrossThreadContext extends EventTarget {
-    _config;
-    constructor(_config) {
-        super();
-        this._config = _config;
-    }
-    postMessage(...args) {
-        console.error('[lynx-web] postMessage not implemented, args:', ...args);
-    }
-    // @ts-expect-error
-    dispatchEvent(event) {
-        const { rpc, sendEventEndpoint } = this._config;
-        rpc.invoke(sendEventEndpoint, [event]);
-        return DispatchEventResult.CanceledBeforeDispatch;
-    }
-    __start() {
-        const { rpc, receiveEventEndpoint } = this._config;
-        rpc.registerHandler(receiveEventEndpoint, ({ type, data }) => {
-            super.dispatchEvent(new MessageEvent(type, { data: data ?? {} }));
-        });
-    }
-}
-//# sourceMappingURL=LynxCrossThreadContext.js.map

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

@@ -1,3 +0,0 @@
-import type { MainThreadRuntime } from '@lynx-js/web-mainthread-apis';
-import type { Rpc } from '@lynx-js/web-worker-rpc';
-export declare function registerCallLepusMethodHandler(rpc: Rpc, runtime: MainThreadRuntime): void;

package/dist/mainThread/crossThreadHandlers/registerCallLepusMethodHandler.js

@@ -1,10 +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 { callLepusMethodEndpoint } from '@lynx-js/web-constants';
-export function registerCallLepusMethodHandler(rpc, runtime) {
-    rpc.registerHandler(callLepusMethodEndpoint, (methodName, data) => {
-        (runtime[methodName])(data);
-    });
-}
-//# sourceMappingURL=registerCallLepusMethodHandler.js.map

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

@@ -1,3 +0,0 @@
-import type { Rpc } from '@lynx-js/web-worker-rpc';
-import { type LynxTemplate } from '@lynx-js/web-constants';
-export declare function registerGetCustomSectionHandler(rpc: Rpc, customSections: LynxTemplate['customSections']): void;

package/dist/mainThread/crossThreadHandlers/registerGetCustomSectionHandler.js

@@ -1,7 +0,0 @@
-import { getCustomSectionsEndpoint, } from '@lynx-js/web-constants';
-export function registerGetCustomSectionHandler(rpc, customSections) {
-    rpc.registerHandler(getCustomSectionsEndpoint, (key) => {
-        return customSections[key]?.content;
-    });
-}
-//# sourceMappingURL=registerGetCustomSectionHandler.js.map