@lynx-js/web-worker-runtime 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @lynx-js/web-worker-runtime
 
+## 0.11.0
+
+### Patch Changes
+
+- feat: support mts event handler (1/n) ([#495](https://github.com/lynx-family/lynx-stack/pull/495))
+
+  now the main-thread:bind handler could be invoked. The params of the handler will be implemented later.
+
+- feat: allow multi lynx-view to share bts worker ([#520](https://github.com/lynx-family/lynx-stack/pull/520))
+
+  Now we allow users to enable so-called "shared-context" feature on the Web Platform.
+
+  Similar to the same feature for Lynx iOS/Android, this feature let multi lynx cards to share one js context.
+
+  The `lynx.getSharedData` and `lynx.setSharedData` are also supported in this commit.
+
+  To enable this feature, set property `lynxGroupId` or attribute `lynx-group-id` before a lynx-view starts rendering. Those card with same context id will share one web worker for the bts scripts.
+
+- Updated dependencies [[`ea42e62`](https://github.com/lynx-family/lynx-stack/commit/ea42e62fbcd5c743132c3e6e7c4851770742d544), [`a0f5ca4`](https://github.com/lynx-family/lynx-stack/commit/a0f5ca4ea0895ccbaa6aa63f449f53a677a1cf73)]:
+  - @lynx-js/web-mainthread-apis@0.11.0
+  - @lynx-js/web-constants@0.11.0
+  - @lynx-js/web-worker-rpc@0.11.0
+
+## 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

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

@@ -1,14 +1,24 @@
-import type { Cloneable, NativeApp } from '@lynx-js/web-constants';
+import { dispatchCoreContextEventEndpoint, type Cloneable, type LynxContextEventTarget, type NativeApp } from '@lynx-js/web-constants';
 import type { Rpc } from '@lynx-js/web-worker-rpc';
 export interface CreateLynxConfig {
     globalProps: unknown;
     customSections: Record<string, Cloneable>;
 }
+export declare class LynxCrossThreadContext extends EventTarget implements LynxContextEventTarget {
+    private _config;
+    constructor(_config: {
+        mainThreadRpc: Rpc;
+        dispatchEventEndpoint: typeof dispatchCoreContextEventEndpoint;
+    });
+    postMessage(...args: any[]): void;
+    dispatchEvent(event: Event): number;
+    __start(): void;
+}
 export declare function createBackgroundLynx(config: CreateLynxConfig, nativeApp: NativeApp, mainThreadRpc: Rpc): {
     __globalProps: unknown;
     getJSModule(_moduleName: string): any;
     getNativeApp(): NativeApp;
-    getCoreContext(): any;
+    getCoreContext(): LynxCrossThreadContext;
     getCustomSectionSync(key: string): Cloneable;
     getCustomSection: (key: string, callback: (object: Cloneable) => void) => void;
 };

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

@@ -1,8 +1,34 @@
 // 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 { dispatchCoreContextEventEndpoint, DispatchEventResult, } from '@lynx-js/web-constants';
 import { createGetCustomSection } from './crossThreadHandlers/createGetCustomSection.js';
+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) {
+        super.dispatchEvent(event);
+        return DispatchEventResult.CanceledBeforeDispatch;
+    }
+    __start() {
+        const { mainThreadRpc, dispatchEventEndpoint } = this._config;
+        mainThreadRpc.registerHandler(dispatchEventEndpoint, (eventType, data) => {
+            this.dispatchEvent(new MessageEvent(eventType, { data: data ?? {} }));
+        });
+    }
+}
 export function createBackgroundLynx(config, nativeApp, mainThreadRpc) {
+    const coreContext = new LynxCrossThreadContext({
+        mainThreadRpc,
+        dispatchEventEndpoint: dispatchCoreContextEventEndpoint,
+    });
     return {
         __globalProps: config.globalProps,
         getJSModule(_moduleName) {
@@ -11,10 +37,7 @@ export function createBackgroundLynx(config, nativeApp, mainThreadRpc) {
             return nativeApp;
         },
         getCoreContext() {
-            return {
-                addInternalEventListener() { },
-                addEventListener() { },
-            };
+            return coreContext;
         },
         getCustomSectionSync(key) {
             return config.customSections[key];

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.js

@@ -1,16 +1,15 @@
 import { callLepusMethodEndpoint, setNativePropsEndpoint, triggerComponentEventEndpoint, selectComponentEndpoint, } from '@lynx-js/web-constants';
 import { createInvokeUIMethod } from './crossThreadHandlers/createInvokeUIMethod.js';
-import { registerOnLifecycleEventHandler } from './crossThreadHandlers/registerOnLifecycleEventHandler.js';
 import { registerPublicComponentEventHandler } from './crossThreadHandlers/registerPublicComponentEventHandler.js';
 import { registerGlobalExposureEventHandler } from './crossThreadHandlers/registerGlobalExposureEventHandler.js';
 import { createNativeModules } from './createNativeModules.js';
 import { registerUpdateDataHandler } from './crossThreadHandlers/registerUpdateDataHandler.js';
 import { registerPublishEventHandler } from './crossThreadHandlers/registerPublishEventHandler.js';
 import { createPerformanceApis } from './createPerformanceApis.js';
-import { registerOnNativeAppReadyHandler } from './crossThreadHandlers/registerOnNativeAppReadyHandler.js';
 import { registerSendGlobalEventHandler } from './crossThreadHandlers/registerSendGlobalEvent.js';
 import { createJSObjectDestructionObserver } from './crossThreadHandlers/createJSObjectDestructionObserver.js';
 let nativeAppCount = 0;
+const sharedData = {};
 export async function createNativeApp(config) {
     const { mainThreadRpc, uiThreadRpc, template, nativeModulesMap, timingSystem, } = config;
     const performanceApis = createPerformanceApis(timingSystem);
@@ -52,6 +51,8 @@ export async function createNativeApp(config) {
             const entry = globalThis.module.exports;
             return {
                 init: (lynxCoreInject) => {
+                    lynxCoreInject.tt.lynxCoreInject = lynxCoreInject;
+                    lynxCoreInject.tt.globalThis ??= lynxCoreInject;
                     return entry?.(lynxCoreInject.tt);
                 },
             };
@@ -66,18 +67,23 @@ export async function createNativeApp(config) {
         setNativeProps,
         invokeUIMethod: createInvokeUIMethod(uiThreadRpc),
         setCard(tt) {
-            registerOnLifecycleEventHandler(mainThreadRpc, tt);
             registerPublicComponentEventHandler(mainThreadRpc, tt);
             registerPublishEventHandler(mainThreadRpc, tt);
             registerGlobalExposureEventHandler(mainThreadRpc, tt);
             registerUpdateDataHandler(uiThreadRpc, tt);
-            registerOnNativeAppReadyHandler(uiThreadRpc, tt);
             registerSendGlobalEventHandler(uiThreadRpc, tt);
             timingSystem.registerGlobalEmitter(tt.GlobalEventEmitter);
+            tt.lynx.getCoreContext().__start();
         },
         triggerComponentEvent,
         selectComponent,
         createJSObjectDestructionObserver: createJSObjectDestructionObserver(),
+        setSharedData(dataKey, dataVal) {
+            sharedData[dataKey] = dataVal;
+        },
+        getSharedData(dataKey) {
+            return sharedData[dataKey];
+        },
     };
     return nativeApp;
 }

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

@@ -1,3 +1,3 @@
 import type { NativeApp } from '@lynx-js/web-constants';
 import type { TimingSystem } from './createTimingSystem.js';
-export declare function createPerformanceApis(timingSystem: TimingSystem): Pick<NativeApp, 'generatePipelineOptions' | 'onPipelineStart' | 'markPipelineTiming' | 'bindPipelineIdWithTimingFlag'>;
+export declare function createPerformanceApis(timingSystem: TimingSystem): Pick<NativeApp, 'generatePipelineOptions' | 'onPipelineStart' | 'markPipelineTiming' | 'bindPipelineIdWithTimingFlag' | 'profileStart' | 'profileEnd'>;

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

@@ -24,6 +24,12 @@ export function createPerformanceApis(timingSystem) {
             const timingFlags = timingSystem.pipelineIdToTimingFlags.get(pipelineId);
             timingFlags.push(timingFlag);
         },
+        profileStart: () => {
+            console.error('NYI: profileStart. This is an issue of lynx-core.');
+        },
+        profileEnd: () => {
+            console.error('NYI: profileEnd. This is an issue of lynx-core.');
+        },
     };
     return performanceApis;
 }

package/dist/index.js

@@ -15,7 +15,7 @@ self.onmessage = (ev) => {
     }
 };
 Object.assign(globalThis, {
-    SystemInfo: { platform: 'web' },
+    SystemInfo: { platform: 'web', lynxSdkVersion: '3.0' },
     module: { exports: null },
 });
 //# sourceMappingURL=index.js.map

package/dist/mainThread/startMainThread.js

@@ -1,7 +1,7 @@
 // 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, publishEventEndpoint, publicComponentEventEndpoint, postExposureEndpoint, postOffscreenEventEndpoint, switchExposureServiceEndpoint, postTimingFlagsEndpoint, } from '@lynx-js/web-constants';
+import { BackgroundThreadStartEndpoint, mainThreadStartEndpoint, flushElementTreeEndpoint, reportErrorEndpoint, publishEventEndpoint, publicComponentEventEndpoint, postExposureEndpoint, postOffscreenEventEndpoint, switchExposureServiceEndpoint, postTimingFlagsEndpoint, dispatchCoreContextEventEndpoint, } 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';
@@ -16,16 +16,16 @@ export function startMainThread(uiThreadPort, backgroundThreadPort) {
     const markTimingInternal = createMarkTimingInternal(backgroundThreadRpc);
     const postTimingFlags = backgroundThreadRpc.createCall(postTimingFlagsEndpoint);
     const backgroundStart = backgroundThreadRpc.createCall(BackgroundThreadStartEndpoint);
-    const __OnLifecycleEvent = backgroundThreadRpc.createCall(onLifecycleEventEndpoint);
+    const dispatchCoreContextEvent = backgroundThreadRpc.createCall(dispatchCoreContextEventEndpoint);
     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');
     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');
@@ -48,8 +48,7 @@ export function startMainThread(uiThreadPort, backgroundThreadPort) {
             lepusCode,
             docu,
             callbacks: {
-                mainChunkReady: function () {
-                    mainThreadChunkReady();
+                mainChunkReady: () => {
                     markTimingInternal('data_processor_start');
                     const initData = runtime.processData
                         ? runtime.processData(config.initData)
@@ -75,6 +74,10 @@ export function startMainThread(uiThreadPort, backgroundThreadPort) {
                     const pipelineId = options?.pipelineOptions?.pipelineID;
                     markTimingInternal('dispatch_start', pipelineId);
                     docu.commit();
+                    if (isFp) {
+                        isFp = false;
+                        dispatchCoreContextEvent('__OnNativeAppReady', undefined);
+                    }
                     markTimingInternal('layout_start', pipelineId);
                     markTimingInternal('ui_operation_flush_start', pipelineId);
                     await flushElementTree(operations);
@@ -84,7 +87,9 @@ export function startMainThread(uiThreadPort, backgroundThreadPort) {
                     postTimingFlags(timingFlags, pipelineId);
                 },
                 _ReportError: reportError,
-                __OnLifecycleEvent,
+                __OnLifecycleEvent: (data) => {
+                    dispatchCoreContextEvent('__OnLifecycleEvent', data);
+                },
                 /**
                  * Note :
                  * The parameter of lynx.performance.markTiming is (pipelineId:string, timingFlag:string)=>void

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lynx-js/web-worker-runtime",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "private": false,
   "description": "",
   "keywords": [],
@@ -23,14 +23,14 @@
   ],
   "dependencies": {
     "@lynx-js/offscreen-document": "0.0.0",
-    "@lynx-js/web-constants": "0.10.0",
-    "@lynx-js/web-mainthread-apis": "0.10.0",
-    "@lynx-js/web-worker-rpc": "0.10.0"
+    "@lynx-js/web-constants": "0.11.0",
+    "@lynx-js/web-mainthread-apis": "0.11.0",
+    "@lynx-js/web-worker-rpc": "0.11.0"
   },
   "devDependencies": {
-    "@lynx-js/lynx-core": "0.1.0"
+    "@lynx-js/lynx-core": "0.1.2"
   },
   "peerDependencies": {
-    "@lynx-js/lynx-core": "0.1.0"
+    "@lynx-js/lynx-core": "0.1.2"
   }
 }

package/dist/backgroundThread/background-apis/crossThreadHandlers/registerOnLifecycleEventHandler.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 registerOnLifecycleEventHandler(rpc: Rpc, tt: NativeTTObject): void;

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

@@ -1,8 +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 { onLifecycleEventEndpoint, } from '@lynx-js/web-constants';
-export function registerOnLifecycleEventHandler(rpc, tt) {
-    rpc.registerHandlerLazy(onLifecycleEventEndpoint, tt, 'OnLifecycleEvent');
-}
-//# sourceMappingURL=registerOnLifecycleEventHandler.js.map

package/dist/backgroundThread/background-apis/crossThreadHandlers/registerOnNativeAppReadyHandler.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 registerOnNativeAppReadyHandler(uiThreadRpc: Rpc, tt: NativeTTObject): void;

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

@@ -1,8 +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 { uiThreadFpReadyEndpoint, } from '@lynx-js/web-constants';
-export function registerOnNativeAppReadyHandler(uiThreadRpc, tt) {
-    uiThreadRpc.registerHandlerLazy(uiThreadFpReadyEndpoint, tt, 'onNativeAppReady');
-}
-//# sourceMappingURL=registerOnNativeAppReadyHandler.js.map