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

package/CHANGELOG.md

@@ -1,5 +1,76 @@
 # @lynx-js/web-worker-runtime
 
+## 0.9.1
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @lynx-js/web-constants@0.9.1
+  - @lynx-js/web-mainthread-apis@0.9.1
+  - @lynx-js/web-worker-rpc@0.9.1
+
+## 0.9.0
+
+### Minor Changes
+
+- feat: `nativeModulesUrl` of lynx-view is changed to `nativeModulesMap`, and the usage is completely aligned with `napiModulesMap`. ([#220](https://github.com/lynx-family/lynx-stack/pull/220))
+
+  "warning: This is a breaking change."
+
+  `nativeModulesMap` will be a map: key is module-name, value should be a esm url which export default a
+  function with two parameters(you never need to use `this`):
+
+  - `NativeModules`: oriented `NativeModules`, which you can use to call
+    other Native-Modules.
+
+  - `NativeModulesCall`: trigger `onNativeModulesCall`, same as the deprecated `this.nativeModulesCall`.
+
+  example:
+
+  ```js
+  const nativeModulesMap = {
+    CustomModule: URL.createObjectURL(
+      new Blob(
+        [
+          `export default function(NativeModules, NativeModulesCall) {
+      return {
+        async getColor(data, callback) {
+          const color = await NativeModulesCall('getColor', data);
+          callback(color);
+        },
+      }
+    };`,
+        ],
+        { type: 'text/javascript' },
+      ),
+    ),
+  };
+  lynxView.nativeModulesMap = nativeModulesMap;
+  ```
+
+  In addition, we will use Promise.all to load `nativeModules`, which will optimize performance in the case of multiple modules.
+
+- refractor: remove entryId concept ([#217](https://github.com/lynx-family/lynx-stack/pull/217))
+
+  After the PR #198
+  All contents are isolated by a shadowroot.
+  Therefore we don't need to add the entryId selector to avoid the lynx-view's style taking effect on the whole page.
+
+### Patch Changes
+
+- refactor: remove customelement defined detecting logic ([#247](https://github.com/lynx-family/lynx-stack/pull/247))
+
+  Before this commit, for those element with tag without `-`, we always try to detect if the `x-${tagName}` is defined.
+
+  After this commit, we pre-define a map(could be override by the `overrideLynxTagToHTMLTagMap`) to make that transformation for tag name.
+
+  This change is a path to SSR and the MTS support.
+
+- Updated dependencies [[`5b5e090`](https://github.com/lynx-family/lynx-stack/commit/5b5e090fdf0e896f1c38a49bf3ed9889117c4fb8), [`b844e75`](https://github.com/lynx-family/lynx-stack/commit/b844e751f566d924256365d37aec4c86c520ec00), [`53230f0`](https://github.com/lynx-family/lynx-stack/commit/53230f012216f3a627853e11d544e4be175c5b9b), [`6f16827`](https://github.com/lynx-family/lynx-stack/commit/6f16827d1f4d7364870d354fc805a8868c110f1e), [`d2d55ef`](https://github.com/lynx-family/lynx-stack/commit/d2d55ef9fe438c35921d9db0daa40d5228822ecc)]:
+  - @lynx-js/web-constants@0.9.0
+  - @lynx-js/web-mainthread-apis@0.9.0
+  - @lynx-js/web-worker-rpc@0.9.0
+
 ## 0.8.0
 
 ### Minor Changes

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

@@ -4,7 +4,7 @@
 import { napiModulesCallEndpoint, } from '@lynx-js/web-constants';
 export const createNapiLoader = async (rpc, napiModulesMap) => {
     const napiModulesCall = rpc.createCall(napiModulesCallEndpoint);
-    let napiModules = {};
+    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)))));
     return {
         load(moduleName) {

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

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

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

@@ -12,8 +12,8 @@ import { registerOnNativeAppReadyHandler } from './crossThreadHandlers/registerO
 import { registerSendGlobalEventHandler } from './crossThreadHandlers/registerSendGlobalEvent.js';
 import { createJSObjectDestructionObserver } from './crossThreadHandlers/createJSObjectDestructionObserver.js';
 let nativeAppCount = 0;
-export function createNativeApp(config) {
-    const { mainThreadRpc, uiThreadRpc, markTimingInternal, template, customNativeModules, } = config;
+export async function createNativeApp(config) {
+    const { mainThreadRpc, uiThreadRpc, markTimingInternal, template, nativeModulesMap, } = config;
     const { performanceApis, pipelineIdToTimingFlags } = createPerformanceApis(markTimingInternal);
     const callLepusMethod = mainThreadRpc.createCallbackify(callLepusMethodEndpoint, 2);
     const setNativeProps = uiThreadRpc.createCall(setNativePropsEndpoint);
@@ -26,7 +26,7 @@ export function createNativeApp(config) {
         setInterval: setInterval,
         clearTimeout: clearTimeout,
         clearInterval: clearInterval,
-        nativeModuleProxy: createNativeModules(uiThreadRpc, customNativeModules),
+        nativeModuleProxy: await createNativeModules(uiThreadRpc, nativeModulesMap),
         loadScriptAsync: function (sourceURL, callback) {
             const mainfestUrl = template.manifest[`/${sourceURL}`];
             if (mainfestUrl)

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

@@ -1,2 +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, customNativeModules: Record<string, Record<string, any>>): Record<string, any>;
+export declare function createNativeModules(rpc: Rpc, nativeModulesMap: NativeModulesMap): Promise<Record<string, any>>;

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

@@ -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 { nativeModulesCallEndpoint, switchExposureService, } from '@lynx-js/web-constants';
-export function createNativeModules(rpc, customNativeModules) {
+export async function createNativeModules(rpc, nativeModulesMap) {
     const switchExposure = rpc.createCall(switchExposureService);
     const nativeModulesCall = rpc.createCall(nativeModulesCallEndpoint);
     const lynxExposureModule = {
@@ -18,35 +18,13 @@ export function createNativeModules(rpc, customNativeModules) {
             nativeModulesCall(name, data, 'bridge').then(callback);
         },
     };
-    return {
+    const nativeModules = {};
+    const customNativeModules = {};
+    await Promise.all(Object.entries(nativeModulesMap).map(([moduleName, moduleStr]) => import(/* webpackIgnore: true */ moduleStr).then(module => customNativeModules[moduleName] = module?.default?.(nativeModules, (name, data) => nativeModulesCall(name, data, moduleName)))));
+    return Object.assign(nativeModules, {
         bridge: bridgeModule,
         LynxExposureModule: lynxExposureModule,
-        ...recursiveFunctionCallBinder(nativeModulesCall, customNativeModules),
-    };
-}
-function recursiveFunctionCallBinder(nativeModulesCall, customNativeModules) {
-    const newObj = Object.fromEntries(Object.entries(customNativeModules).map(([moduleName, moduleImpl]) => {
-        if (typeof moduleImpl === 'object') {
-            for (const [property, value] of Object.entries(moduleImpl)) {
-                if (typeof value === 'function') {
-                    moduleImpl[property] = bindThisContext({
-                        nativeModulesCall,
-                        moduleName,
-                        func: value,
-                    });
-                }
-            }
-        }
-        return [moduleName, moduleImpl];
-    }));
-    return newObj;
-}
-function bindThisContext({ nativeModulesCall, moduleName, func }) {
-    const context = {
-        nativeModulesCall(name, data) {
-            return nativeModulesCall(name, data, moduleName);
-        },
-    };
-    return func.bind(context);
+        ...customNativeModules,
+    });
 }
 //# sourceMappingURL=createNativeModules.js.map

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

@@ -17,16 +17,11 @@ export function startBackgroundThread(uiThreadPort, mainThreadPort) {
     markTimingInternal('load_core_start');
     mainThreadRpc.registerHandler(BackgroundThreadStartEndpoint, async (config) => {
         markTimingInternal('load_core_end');
-        const customNativeModules = config.nativeModulesUrl
-            ? (await import(
-            /* webpackIgnore: true */ config.nativeModulesUrl))?.default ?? {}
-            : {};
-        const nativeApp = createNativeApp({
+        const nativeApp = await createNativeApp({
             ...config,
             uiThreadRpc,
             mainThreadRpc,
             markTimingInternal,
-            customNativeModules,
         });
         globalThis['napiLoaderOnRT' + nativeApp.id] =
             await createNapiLoader(uiThreadRpc, config.napiModulesMap);

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, } from '@lynx-js/web-constants';
+import { BackgroundThreadStartEndpoint, mainThreadChunkReadyEndpoint, mainThreadStartEndpoint, onLifecycleEventEndpoint, flushElementTreeEndpoint, reportErrorEndpoint, } from '@lynx-js/web-constants';
 import { Rpc } from '@lynx-js/web-worker-rpc';
 import { MainThreadRuntime } from '@lynx-js/web-mainthread-apis';
 import { registerCallLepusMethodHandler } from './crossThreadHandlers/registerCallLepusMethodHandler.js';
@@ -17,16 +17,17 @@ export function startMainThread(uiThreadPort, backgroundThreadPort) {
     const __OnLifecycleEvent = backgroundThreadRpc.createCall(onLifecycleEventEndpoint);
     const mainThreadChunkReady = uiThreadRpc.createCall(mainThreadChunkReadyEndpoint);
     const flushElementTree = uiThreadRpc.createCall(flushElementTreeEndpoint);
+    const reportError = uiThreadRpc.createCall(reportErrorEndpoint);
     markTimingInternal('lepus_excute_start');
     uiThreadRpc.registerHandler(mainThreadStartEndpoint, async (config) => {
-        const { globalProps, template, entryId, browserConfig, nativeModulesUrl, napiModulesMap, } = config;
+        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 runtime = new MainThreadRuntime({
-            entryId,
+            tagMap,
             browserConfig,
             customSections,
             globalProps,
@@ -51,16 +52,14 @@ export function startMainThread(uiThreadPort, backgroundThreadPort) {
                         template,
                         cardType: cardType ?? 'react',
                         customSections: Object.fromEntries(Object.entries(customSections).filter(([, value]) => value.type !== 'lazy').map(([k, v]) => [k, v.content])),
-                        nativeModulesUrl,
+                        nativeModulesMap,
                         napiModulesMap,
                     });
                     runtime.renderPage(initData);
                     runtime.__FlushElementTree(undefined, {});
                 },
                 flushElementTree,
-                _ReportError: function (error, info) {
-                    console.error('main-thread:', error, info);
-                },
+                _ReportError: reportError,
                 __OnLifecycleEvent,
                 /**
                  * Note :

package/package.json

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

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

@@ -1,2 +0,0 @@
-import type { Rpc } from '@lynx-js/web-worker-rpc';
-export declare function createReportError(rpc: Rpc): (error: Error, info?: unknown) => void;

package/dist/mainThread/crossThreadHandlers/createReportError.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 { reportErrorEndpoint } from '@lynx-js/web-constants';
-export function createReportError(rpc) {
-    return (error, info) => {
-        rpc.invoke(reportErrorEndpoint, ['main-thread', error.toString(), info]);
-    };
-}
-//# sourceMappingURL=createReportError.js.map