@lynx-js/web-worker-runtime 0.17.1 → 0.18.0

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # @lynx-js/web-worker-runtime
 
+## 0.18.0
+
+### Patch Changes
+
+- fix: ([#1837](https://github.com/lynx-family/lynx-stack/pull/1837))
+
+  1. `LynxView.updateData()` cannot trigger `dataProcessor`.
+
+  2. **This is a break change:** The second parameter of `LynxView.updateData()` has been changed from `UpdateDataType` to `string`, which is the `processorName` (default is `default` which will use `defaultDataProcessor`). This change is to better align with Native. The current complete type is as follows:
+
+  ```ts
+  LynxView.updateData(data: Cloneable, processorName?: string | undefined, callback?: (() => void) | undefined): void
+  ```
+
+- Updated dependencies [[`77397fd`](https://github.com/lynx-family/lynx-stack/commit/77397fd535cf60556f8f82f7ef8dae8a623d1625), [`7d90ed5`](https://github.com/lynx-family/lynx-stack/commit/7d90ed52a20fd7665a3517507800e7e29426f6f9)]:
+  - @lynx-js/web-constants@0.18.0
+  - @lynx-js/web-mainthread-apis@0.18.0
+  - @lynx-js/web-worker-rpc@0.18.0
+
+## 0.17.2
+
+### Patch Changes
+
+- feat: support load bts chunk from remote address ([#1834](https://github.com/lynx-family/lynx-stack/pull/1834))
+
+  - re-support chunk splitting
+  - support lynx.requireModule with a json file
+  - support lynx.requireModule, lynx.requireModuleAsync with a remote url
+  - support to add a breakpoint in chrome after reloading the web page
+
+- Updated dependencies [[`a35a245`](https://github.com/lynx-family/lynx-stack/commit/a35a2452e5355bda3c475f9a750a86085e0cf56a)]:
+  - @lynx-js/web-constants@0.17.2
+  - @lynx-js/web-mainthread-apis@0.17.2
+  - @lynx-js/web-worker-rpc@0.17.2
+
 ## 0.17.1
 
 ### Patch Changes

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

@@ -0,0 +1,7 @@
+import type { NativeApp, LynxTemplate } from '@lynx-js/web-constants';
+export declare function createChunkLoading(initialTemplate: LynxTemplate): {
+    readScript: NativeApp['readScript'];
+    loadScript: NativeApp['loadScript'];
+    loadScriptAsync: NativeApp['loadScriptAsync'];
+    templateCache: Map<string, LynxTemplate>;
+};

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

@@ -0,0 +1,73 @@
+// 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 createChunkLoading(initialTemplate) {
+    const templateCache = new Map([[
+            '__Card__',
+            initialTemplate,
+        ]]);
+    const readScript = (sourceURL, entryName = '__Card__') => {
+        const jsContentInTemplate = templateCache.get(entryName)
+            ?.manifest[`/${sourceURL}`];
+        if (jsContentInTemplate)
+            return jsContentInTemplate;
+        const xhr = new XMLHttpRequest();
+        xhr.open('GET', sourceURL, false);
+        xhr.send(null);
+        if (xhr.status === 200) {
+            return xhr.responseText;
+        }
+        throw new Error(`Failed to load ${sourceURL}, status: ${xhr.status}`);
+    };
+    const readScriptAsync = async (sourceURL, entryName = '__Card__') => {
+        const jsContentInTemplate = templateCache.get(entryName)
+            ?.manifest[`/${sourceURL}`];
+        if (jsContentInTemplate)
+            return jsContentInTemplate;
+        return new Promise((resolve, reject) => {
+            fetch(sourceURL).then((response) => {
+                if (response.ok) {
+                    response.text().then((text) => resolve(text), reject);
+                }
+                else {
+                    reject(new Error(`Failed to load ${sourceURL}, status: ${response.status}`));
+                }
+            }, reject);
+        });
+    };
+    const createBundleInitReturnObj = (jsContent, fileName) => {
+        const foo = new Function('postMessage', 'module', 'exports', 'lynxCoreInject', 'Card', 'setTimeout', 'setInterval', 'clearInterval', 'clearTimeout', 'NativeModules', 'Component', 'ReactLynx', 'nativeAppId', 'Behavior', 'LynxJSBI', 'lynx', 
+        // BOM API
+        'window', 'document', 'frames', 'location', 'navigator', 'localStorage', 'history', 'Caches', 'screen', 'alert', 'confirm', 'prompt', 'fetch', 'XMLHttpRequest', 'webkit', 'Reporter', 'print', 'global', 
+        // Lynx API
+        'requestAnimationFrame', 'cancelAnimationFrame', [
+            jsContent,
+            '\n//# sourceURL=',
+            fileName,
+        ].join(''));
+        return {
+            init(lynxCoreInject) {
+                const module = { exports: {} };
+                const tt = lynxCoreInject.tt;
+                foo(undefined, module, module.exports, lynxCoreInject, tt.Card, tt.setTimeout, tt.setInterval, tt.clearInterval, tt.clearTimeout, tt.NativeModules, tt.Component, tt.ReactLynx, tt.nativeAppId, tt.Behavior, tt.LynxJSBI, tt.lynx, 
+                // BOM API
+                tt.window, tt.document, tt.frames, tt.location, tt.navigator, tt.localStorage, tt.history, tt.Caches, tt.screen, tt.alert, tt.confirm, tt.prompt, tt.fetch, tt.XMLHttpRequest, tt.webkit, tt.Reporter, tt.print, tt.global, tt.requestAnimationFrame, tt.cancelAnimationFrame);
+                return module.exports;
+            },
+        };
+    };
+    return {
+        readScript,
+        loadScript: (sourceURL, entryName = '__Card__') => {
+            const jsContent = readScript(sourceURL, entryName);
+            return createBundleInitReturnObj(jsContent, `${encodeURIComponent(entryName)}/${sourceURL}`);
+        },
+        loadScriptAsync: async (sourceURL, callback, entryName = '__Card__') => {
+            readScriptAsync(sourceURL, entryName).then((jsContent) => {
+                callback(null, createBundleInitReturnObj(jsContent, `${encodeURIComponent(entryName)}/${sourceURL}`));
+            });
+        },
+        templateCache,
+    };
+}
+//# sourceMappingURL=createChunkLoading.js.map

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

@@ -11,6 +11,7 @@ import { createJSObjectDestructionObserver } from './crossThreadHandlers/createJ
 import { registerUpdateGlobalPropsHandler } from './crossThreadHandlers/registerUpdateGlobalPropsHandler.js';
 import { registerUpdateI18nResource } from './crossThreadHandlers/registerUpdateI18nResource.js';
 import { createGetPathInfo } from './crossThreadHandlers/createGetPathInfo.js';
+import { createChunkLoading } from './createChunkLoading.js';
 let nativeAppCount = 0;
 const sharedData = {};
 export async function createNativeApp(config) {
@@ -22,13 +23,7 @@ export async function createNativeApp(config) {
     const selectComponent = uiThreadRpc.createCallbackify(selectComponentEndpoint, 3);
     const queryComponent = mainThreadRpc.createCall(queryComponentEndpoint);
     const reportError = uiThreadRpc.createCall(reportErrorEndpoint);
-    const createBundleInitReturnObj = () => {
-        const ret = globalThis.module.exports ?? globalThis.__bundle__holder;
-        globalThis.module.exports = null;
-        globalThis.__bundle__holder = null;
-        return ret;
-    };
-    const templateCache = new Map([['__Card__', template]]);
+    const { templateCache, loadScript, loadScriptAsync, readScript } = createChunkLoading(template);
     mainThreadRpc.registerHandler(updateBTSTemplateCacheEndpoint, (url, template) => {
         templateCache.set(url, template);
     });
@@ -42,35 +37,9 @@ export async function createNativeApp(config) {
         clearTimeout: clearTimeout,
         clearInterval: clearInterval,
         nativeModuleProxy: await createNativeModules(uiThreadRpc, mainThreadRpc, nativeModulesMap),
-        loadScriptAsync: function (sourceURL, callback, entryName) {
-            entryName = entryName ?? '__Card__';
-            const manifestUrl = templateCache.get(entryName)
-                ?.manifest[`/${sourceURL}`];
-            if (manifestUrl)
-                sourceURL = manifestUrl;
-            else
-                throw Error(`Cannot find ${sourceURL} in manifest`);
-            globalThis.module.exports = null;
-            globalThis.__bundle__holder = null;
-            import(
-            /* webpackIgnore: true */
-            sourceURL).catch(callback).then(async () => {
-                callback(null, createBundleInitReturnObj());
-            });
-        },
-        loadScript: (sourceURL, entryName) => {
-            entryName = entryName ?? '__Card__';
-            const manifestUrl = templateCache.get(entryName)
-                ?.manifest[`/${sourceURL}`];
-            if (manifestUrl)
-                sourceURL = manifestUrl;
-            else
-                throw Error(`Cannot find ${sourceURL} in manifest`);
-            globalThis.module.exports = null;
-            globalThis.__bundle__holder = null;
-            importScripts(sourceURL);
-            return createBundleInitReturnObj();
-        },
+        readScript,
+        loadScriptAsync,
+        loadScript,
         requestAnimationFrame(cb) {
             return requestAnimationFrame(cb);
         },
@@ -86,7 +55,7 @@ export async function createNativeApp(config) {
             registerPublicComponentEventHandler(mainThreadRpc, tt);
             registerPublishEventHandler(mainThreadRpc, tt);
             registerGlobalExposureEventHandler(mainThreadRpc, tt);
-            registerUpdateDataHandler(uiThreadRpc, tt);
+            registerUpdateDataHandler(mainThreadRpc, tt);
             registerSendGlobalEventHandler(uiThreadRpc, tt);
             registerUpdateGlobalPropsHandler(uiThreadRpc, tt);
             registerUpdateI18nResource(uiThreadRpc, mainThreadRpc, i18nResource, tt);

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

@@ -1,3 +1,2 @@
-import { type MainThreadGlobalThis } from '@lynx-js/web-constants';
 import type { Rpc } from '@lynx-js/web-worker-rpc';
-export declare function registerUpdateDataHandler(rpc: Rpc, runtime: MainThreadGlobalThis): void;
+export declare function registerUpdateDataHandler(mainThreadRpc: Rpc, handleUpdatedData: ReturnType<typeof import('@lynx-js/web-mainthread-apis').prepareMainThreadAPIs>['handleUpdatedData']): void;

package/dist/mainThread/crossThreadHandlers/registerUpdateDataHandler.js

@@ -1,10 +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 { updateDataEndpoint, } from '@lynx-js/web-constants';
-export function registerUpdateDataHandler(rpc, runtime) {
-    rpc.registerHandler(updateDataEndpoint, (...args) => {
-        runtime.updatePage?.(...args);
-    });
+import { updateDataEndpoint } from '@lynx-js/web-constants';
+export function registerUpdateDataHandler(mainThreadRpc, handleUpdatedData) {
+    mainThreadRpc.registerHandler(updateDataEndpoint, (newData, options) => handleUpdatedData(newData, options));
 }
 //# sourceMappingURL=registerUpdateDataHandler.js.map

package/dist/mainThread/startMainThread.js

@@ -61,7 +61,7 @@ export async function startMainThreadWorker(uiThreadPort, backgroundThreadPort)
     uiThreadRpc.registerHandler(postOffscreenEventEndpoint, document[_onEvent]);
     const sendMultiThreadExposureChangedEndpoint = uiThreadRpc.createCall(multiThreadExposureChangedEndpoint);
     const loadTemplate = uiThreadRpc.createCall(loadTemplateMultiThread);
-    const { startMainThread } = prepareMainThreadAPIs(backgroundThreadRpc, document, // rootDom
+    const { startMainThread, handleUpdatedData } = prepareMainThreadAPIs(backgroundThreadRpc, document, // rootDom
     document, mtsRealm, (exposureChangedElementUniqueIds) => {
         document.commit();
         sendMultiThreadExposureChangedEndpoint(exposureChangedElementUniqueIds
@@ -73,7 +73,7 @@ export async function startMainThreadWorker(uiThreadPort, backgroundThreadPort)
     }, loadTemplate);
     uiThreadRpc.registerHandler(mainThreadStartEndpoint, async (config) => {
         await startMainThread(config);
-        registerUpdateDataHandler(uiThreadRpc, globalThis);
+        registerUpdateDataHandler(uiThreadRpc, handleUpdatedData);
     });
     uiThreadRpc.registerHandler(updateI18nResourcesEndpoint, data => {
         i18nResources.setData(data);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lynx-js/web-worker-runtime",
-  "version": "0.17.1",
+  "version": "0.18.0",
   "private": false,
   "description": "",
   "keywords": [],
@@ -23,9 +23,9 @@
   ],
   "dependencies": {
     "@lynx-js/offscreen-document": "0.1.4",
-    "@lynx-js/web-constants": "0.17.1",
-    "@lynx-js/web-mainthread-apis": "0.17.1",
-    "@lynx-js/web-worker-rpc": "0.17.1"
+    "@lynx-js/web-constants": "0.18.0",
+    "@lynx-js/web-mainthread-apis": "0.18.0",
+    "@lynx-js/web-worker-rpc": "0.18.0"
   },
   "devDependencies": {
     "@lynx-js/lynx-core": "0.1.3"