@lynx-js/web-core 0.11.0 → 0.13.0

package/CHANGELOG.md

@@ -1,5 +1,84 @@
 # @lynx-js/web-core
 
+## 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.
+
+- fix(web): css selector not work for selectors with combinator and pseudo-class on WEB ([#608](https://github.com/lynx-family/lynx-stack/pull/608))
+
+  like `.parent > :not([hidden]) ~ :not([hidden])`
+
+  you will need to upgrade your `react-rsbuild-plugin` to fix this issue
+
+- 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-worker-runtime@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
+
+### Minor Changes
+
+- feat: improve compatibility for chrome 108 & support linear-gradient for nested x-text ([#590](https://github.com/lynx-family/lynx-stack/pull/590))
+
+  **This is a breaking change**
+
+  - Please upgrade your `@lynx-js/web-elements` to >=0.6.0
+  - Please upgrade your `@lynx-js/web-core` to >=0.12.0
+  - The compiled lynx template json won't be impacted.
+
+  On chrome 108, the `-webkit-background-clip:text` cannot be computed by a `var(--css-var-value-text)`
+
+  Therefore we move the logic into style transformation logic.
+
+  Now the following status is supported
+
+  ```
+  <text style="color:linear-gradient()">
+    <text>
+    <text>
+  </text>
+  ```
+
+### Patch Changes
+
+- feat: allow user to implement custom template load function ([#587](https://github.com/lynx-family/lynx-stack/pull/587))
+
+  ```js
+  lynxView.customTemplateLoader = (url) => {
+    return (await (await fetch(url, {
+      method: 'GET',
+    })).json());
+  };
+  ```
+
+- feat: support mts event with target methods ([#564](https://github.com/lynx-family/lynx-stack/pull/564))
+
+  After this commit, developers are allowed to invoke `event.target.setStyleProperty` in mts handler
+
+- fix: crash on removing a id attribute ([#582](https://github.com/lynx-family/lynx-stack/pull/582))
+
+- Updated dependencies [[`f1ca29b`](https://github.com/lynx-family/lynx-stack/commit/f1ca29bd766377dd46583f15e1e75bca447699cd)]:
+  - @lynx-js/web-worker-runtime@0.12.0
+  - @lynx-js/web-constants@0.12.0
+  - @lynx-js/web-worker-rpc@0.12.0
+
 ## 0.11.0
 
 ### Minor Changes

package/dist/apis/LynxView.d.ts

@@ -1,4 +1,4 @@
-import { type Cloneable, type NapiModulesCall, type NapiModulesMap, type NativeModulesCall, type NativeModulesMap, type UpdateDataType } from '@lynx-js/web-constants';
+import { type Cloneable, type LynxTemplate, type NapiModulesCall, type NapiModulesMap, type NativeModulesCall, type NativeModulesMap, type UpdateDataType } from '@lynx-js/web-constants';
 export type INapiModulesCall = (name: string, data: any, moduleName: string, lynxView: LynxView, dispatchNapiModules: (data: Cloneable) => void) => Promise<{
     data: unknown;
     transfer?: Transferable[];
@@ -22,6 +22,8 @@ export type INapiModulesCall = (name: string, data: any, moduleName: string, lyn
  * @property {INapiModulesCall} onNapiModulesCall [optional] the NapiModule value handler.
  * @property {"false" | "true" | null} injectHeadLinks [optional] @default true set it to "false" to disable injecting the <link href="" ref="stylesheet"> styles into shadowroot
  * @property {number} lynxGroupId [optional] (attribute: "lynx-group-id") the background shared context id, which is used to share webworker between different lynx cards
+ * @property {"all-on-ui" | "multi-thread"} threadStrategy [optional] @default "multi-thread" (attribute: "thread-strategy") controls the thread strategy for current lynx view
+ * @property {(string)=>Promise<LynxTemplate>} customTemplateLoader [optional] the custom template loader, which is used to load the template
  *
  * @event error lynx card fired an error
  *
@@ -138,10 +140,22 @@ export declare class LynxView extends HTMLElement {
      * @private
      */
     attributeChangedCallback(name: string, oldValue: string, newValue: string): void;
+    /**
+     * @param
+     * @property
+     */
+    get threadStrategy(): 'all-on-ui' | 'multi-thread';
+    set threadStrategy(val: 'all-on-ui' | 'multi-thread');
     /**
      * @private
      */
     disconnectedCallback(): void;
+    /**
+     * @public
+     * allow user to customize the template loader
+     * @param url the url of the template
+     */
+    customTemplateLoader?: (url: string) => Promise<LynxTemplate>;
     /**
      * @private
      */

package/dist/apis/LynxView.js

@@ -20,6 +20,8 @@ import { inShadowRootStyles } from './inShadowRootStyles.js';
  * @property {INapiModulesCall} onNapiModulesCall [optional] the NapiModule value handler.
  * @property {"false" | "true" | null} injectHeadLinks [optional] @default true set it to "false" to disable injecting the <link href="" ref="stylesheet"> styles into shadowroot
  * @property {number} lynxGroupId [optional] (attribute: "lynx-group-id") the background shared context id, which is used to share webworker between different lynx cards
+ * @property {"all-on-ui" | "multi-thread"} threadStrategy [optional] @default "multi-thread" (attribute: "thread-strategy") controls the thread strategy for current lynx view
+ * @property {(string)=>Promise<LynxTemplate>} customTemplateLoader [optional] the custom template loader, which is used to load the template
  *
  * @event error lynx card fired an error
  *
@@ -242,6 +244,22 @@ export class LynxView extends HTMLElement {
             }
         }
     }
+    /**
+     * @param
+     * @property
+     */
+    get threadStrategy() {
+        // @ts-expect-error
+        return this.getAttribute('thread-strategy');
+    }
+    set threadStrategy(val) {
+        if (val) {
+            this.setAttribute('thread-strategy', val);
+        }
+        else {
+            this.removeAttribute('thread-strategy');
+        }
+    }
     /**
      * @private
      */
@@ -252,6 +270,12 @@ export class LynxView extends HTMLElement {
             this.shadowRoot.innerHTML = '';
         }
     }
+    /**
+     * @public
+     * allow user to customize the template loader
+     * @param url the url of the template
+     */
+    customTemplateLoader;
     /**
      * @private the flag to group all changes into one render operation
      */
@@ -281,7 +305,9 @@ export class LynxView extends HTMLElement {
                         this.attachShadow({ mode: 'open' });
                     }
                     const lynxGroupId = this.lynxGroupId;
+                    const threadStrategy = (this.threadStrategy ?? 'multi-thread');
                     const lynxView = createLynxView({
+                        threadStrategy,
                         tagMap,
                         shadowRoot: this.shadowRoot,
                         templateUrl: this.#url,
@@ -308,6 +334,7 @@ export class LynxView extends HTMLElement {
                             onError: () => {
                                 this.dispatchEvent(new CustomEvent('error', {}));
                             },
+                            customTemplateLoader: this.customTemplateLoader,
                         },
                     });
                     this.#instance = lynxView;

package/dist/apis/createLynxView.d.ts

@@ -1,16 +1,17 @@
 import type { Cloneable, NapiModulesMap, NativeModulesMap, sendGlobalEventEndpoint, UpdateDataType } from '@lynx-js/web-constants';
-import { startUIThread } from '../uiThread/startUIThread.js';
+import { type StartUIThreadCallbacks } from '../uiThread/startUIThread.js';
 import type { RpcCallType } from '@lynx-js/web-worker-rpc';
 export interface LynxViewConfigs {
     templateUrl: string;
     initData: Cloneable;
     globalProps: Cloneable;
     shadowRoot: ShadowRoot;
-    callbacks: Parameters<typeof startUIThread>[4];
+    callbacks: StartUIThreadCallbacks;
     nativeModulesMap: NativeModulesMap;
     napiModulesMap: NapiModulesMap;
     tagMap: Record<string, string>;
     lynxGroupId: number | undefined;
+    threadStrategy: 'all-on-ui' | 'multi-thread';
 }
 export interface LynxView {
     updateData(data: Cloneable, updateDataType: UpdateDataType, callback?: () => void): void;

package/dist/apis/createLynxView.js

@@ -1,16 +1,18 @@
 // 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 { startUIThread } from '../uiThread/startUIThread.js';
+import { startUIThread, } from '../uiThread/startUIThread.js';
 export function createLynxView(configs) {
-    const { shadowRoot, callbacks, templateUrl, globalProps, initData, nativeModulesMap, napiModulesMap, tagMap, lynxGroupId, } = configs;
+    const { shadowRoot, callbacks, templateUrl, globalProps, initData, nativeModulesMap, napiModulesMap, tagMap, lynxGroupId, threadStrategy = 'multi-thread', } = configs;
     return startUIThread(templateUrl, {
         tagMap,
         initData,
         globalProps,
         nativeModulesMap,
         napiModulesMap,
-        browserConfig: {},
-    }, shadowRoot, lynxGroupId, callbacks);
+        browserConfig: {
+            pixelRatio: window.devicePixelRatio,
+        },
+    }, shadowRoot, lynxGroupId, threadStrategy, callbacks);
 }
 //# sourceMappingURL=createLynxView.js.map

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export { createLynxView } from './apis/createLynxView.js';
 export { LynxView } from './apis/LynxView.js';
+export type { LynxTemplate } from '@lynx-js/web-constants';

package/dist/uiThread/bootWorkers.d.ts

@@ -4,5 +4,5 @@ interface LynxViewRpc {
     backgroundRpc: Rpc;
     terminateWorkers: () => void;
 }
-export declare function bootWorkers(lynxGroupId: number | undefined): LynxViewRpc;
+export declare function bootWorkers(lynxGroupId: number | undefined, allOnUI?: boolean): LynxViewRpc;
 export {};

package/dist/uiThread/bootWorkers.js

@@ -5,9 +5,15 @@ import { Rpc } from '@lynx-js/web-worker-rpc';
 const backgroundWorkerContextCount = [];
 const contextIdToBackgroundWorker = [];
 let preHeatedMainWorker = createMainWorker();
-export function bootWorkers(lynxGroupId) {
-    const curMainWorker = preHeatedMainWorker;
-    preHeatedMainWorker = createMainWorker();
+export function bootWorkers(lynxGroupId, allOnUI) {
+    let curMainWorker;
+    if (allOnUI) {
+        curMainWorker = createUIChannel();
+    }
+    else {
+        curMainWorker = preHeatedMainWorker;
+        preHeatedMainWorker = createMainWorker();
+    }
     const curBackgroundWorker = createBackgroundWorker(lynxGroupId, curMainWorker.channelMainThreadWithBackground);
     if (lynxGroupId !== undefined) {
         if (backgroundWorkerContextCount[lynxGroupId]) {
@@ -21,7 +27,7 @@ export function bootWorkers(lynxGroupId) {
         mainThreadRpc: curMainWorker.mainThreadRpc,
         backgroundRpc: curBackgroundWorker.backgroundRpc,
         terminateWorkers: () => {
-            curMainWorker.mainThreadWorker.terminate();
+            curMainWorker.mainThreadWorker?.terminate();
             if (lynxGroupId === undefined) {
                 curBackgroundWorker.backgroundThreadWorker.terminate();
             }
@@ -33,6 +39,14 @@ export function bootWorkers(lynxGroupId) {
         },
     };
 }
+function createUIChannel() {
+    const channelMainThreadWithBackground = new MessageChannel();
+    const mainThreadRpc = new Rpc(channelMainThreadWithBackground.port1, 'main-to-bg');
+    return {
+        mainThreadRpc,
+        channelMainThreadWithBackground,
+    };
+}
 function createMainWorker() {
     const channelToMainThread = new MessageChannel();
     const channelMainThreadWithBackground = new MessageChannel();
@@ -41,7 +55,6 @@ function createMainWorker() {
         mode: 'main',
         toUIThread: channelToMainThread.port2,
         toPeerThread: channelMainThreadWithBackground.port1,
-        pixelRatio: window.devicePixelRatio,
     };
     mainThreadWorker.postMessage(mainThreadMessage, [
         channelToMainThread.port2,
@@ -69,7 +82,6 @@ function createBackgroundWorker(lynxGroupId, channelMainThreadWithBackground) {
         mode: 'background',
         toUIThread: channelToBackground.port2,
         toPeerThread: channelMainThreadWithBackground.port2,
-        pixelRatio: window.devicePixelRatio,
     };
     backgroundThreadWorker.postMessage(backgroundThreadMessage, [
         channelToBackground.port2,

package/dist/uiThread/createRenderAllOnUI.d.ts

@@ -0,0 +1,8 @@
+import type { MainThreadStartConfigs } from '@lynx-js/web-constants';
+import { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function createRenderAllOnUI(mainToBackgroundRpc: Rpc, shadowRoot: ShadowRoot, markTimingInternal: (timingKey: string, pipelineId?: string, timeStamp?: number) => void, callbacks: {
+    onError?: () => void;
+}): {
+    start: (configs: MainThreadStartConfigs) => Promise<void>;
+    updateDataMainThread: (args_0: import("@lynx-js/web-constants").Cloneable, args_1: Record<string, string>) => Promise<void>;
+};

package/dist/uiThread/createRenderAllOnUI.js

@@ -0,0 +1,26 @@
+import { Rpc } from '@lynx-js/web-worker-rpc';
+const { loadMainThread, } = await import('@lynx-js/web-mainthread-apis');
+export function createRenderAllOnUI(mainToBackgroundRpc, shadowRoot, markTimingInternal, callbacks) {
+    if (!globalThis.module) {
+        Object.assign(globalThis, { module: {} });
+    }
+    const docu = Object.assign(shadowRoot, {
+        createElement: document.createElement.bind(document),
+    });
+    const { startMainThread } = loadMainThread(mainToBackgroundRpc, docu, () => { }, markTimingInternal, () => {
+        callbacks.onError?.();
+    });
+    let runtime;
+    const start = async (configs) => {
+        const mainThreadRuntime = startMainThread(configs);
+        runtime = await mainThreadRuntime;
+    };
+    const updateDataMainThread = async (...args) => {
+        runtime.updatePage?.(...args);
+    };
+    return {
+        start,
+        updateDataMainThread,
+    };
+}
+//# sourceMappingURL=createRenderAllOnUI.js.map

package/dist/uiThread/createRenderMultiThread.d.ts

@@ -0,0 +1,7 @@
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function createRenderMultiThread(mainThreadRpc: Rpc, shadowRoot: ShadowRoot, callbacks: {
+    onError?: () => void;
+}): {
+    start: (args_0: import("@lynx-js/web-constants").MainThreadStartConfigs) => void;
+    updateDataMainThread: (args_0: import("@lynx-js/web-constants").Cloneable, args_1: Record<string, string>) => Promise<void>;
+};

package/dist/uiThread/createRenderMultiThread.js

@@ -0,0 +1,16 @@
+import { mainThreadStartEndpoint, updateDataEndpoint, } from '@lynx-js/web-constants';
+import { registerReportErrorHandler } from './crossThreadHandlers/registerReportErrorHandler.js';
+import { registerFlushElementTreeHandler } from './crossThreadHandlers/registerFlushElementTreeHandler.js';
+export function createRenderMultiThread(mainThreadRpc, shadowRoot, callbacks) {
+    registerReportErrorHandler(mainThreadRpc, callbacks.onError);
+    registerFlushElementTreeHandler(mainThreadRpc, {
+        shadowRoot,
+    });
+    const start = mainThreadRpc.createCall(mainThreadStartEndpoint);
+    const updateDataMainThread = mainThreadRpc.createCall(updateDataEndpoint);
+    return {
+        start,
+        updateDataMainThread,
+    };
+}
+//# sourceMappingURL=createRenderMultiThread.js.map

package/dist/uiThread/crossThreadHandlers/createUpdateData.d.ts

@@ -1,3 +1,4 @@
-import type { Rpc } from '@lynx-js/web-worker-rpc';
+import type { RpcCallType } from '@lynx-js/web-worker-rpc';
 import type { LynxView } from '../../apis/createLynxView.js';
-export declare function createUpdateData(mainThreadRpc: Rpc, backgroundRpc: Rpc): LynxView['updateData'];
+import { updateDataEndpoint } from '@lynx-js/web-constants';
+export declare function createUpdateData(updateDataMainThread: RpcCallType<typeof updateDataEndpoint>, updateDataBackground: RpcCallType<typeof updateDataEndpoint>): LynxView['updateData'];

package/dist/uiThread/crossThreadHandlers/createUpdateData.js

@@ -2,12 +2,12 @@
 // 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 createUpdateData(mainThreadRpc, backgroundRpc) {
+export function createUpdateData(updateDataMainThread, updateDataBackground) {
     return (data, _updateDataType, callback) => {
         Promise.all([
             // There is no need to process options for now, as they have default values.
-            mainThreadRpc.invoke(updateDataEndpoint, [data, {}]),
-            backgroundRpc.invoke(updateDataEndpoint, [data, {}]),
+            updateDataMainThread(data, {}),
+            updateDataBackground(data, {}),
         ]).then(() => callback?.());
     };
 }

package/dist/uiThread/startBackground.d.ts

@@ -0,0 +1,10 @@
+import { type NapiModulesCall, type NativeModulesCall } from '@lynx-js/web-constants';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function startBackground(backgroundRpc: Rpc, shadowRoot: ShadowRoot, callbacks: {
+    nativeModulesCall: NativeModulesCall;
+    napiModulesCall: NapiModulesCall;
+}): {
+    sendGlobalEvent: (args_0: string, args_1: import("@lynx-js/web-constants").Cloneable[] | undefined) => void;
+    markTiming: (timingKey: string, pipelineId: string | undefined, timeStamp: number) => void;
+    updateDataBackground: (args_0: import("@lynx-js/web-constants").Cloneable, args_1: Record<string, string>) => Promise<void>;
+};

package/dist/uiThread/startBackground.js

@@ -0,0 +1,26 @@
+import { markTimingEndpoint, sendGlobalEventEndpoint, updateDataEndpoint, } from '@lynx-js/web-constants';
+import { registerInvokeUIMethodHandler } from './crossThreadHandlers/registerInvokeUIMethodHandler.js';
+import { registerNativePropsHandler } from './crossThreadHandlers/registerSetNativePropsHandler.js';
+import { registerNativeModulesCallHandler } from './crossThreadHandlers/registerNativeModulesCallHandler.js';
+import { registerTriggerComponentEventHandler } from './crossThreadHandlers/registerTriggerComponentEventHandler.js';
+import { registerSelectComponentHandler } from './crossThreadHandlers/registerSelectComponentHandler.js';
+import { registerNapiModulesCallHandler } from './crossThreadHandlers/registerNapiModulesCallHandler.js';
+import { registerDispatchLynxViewEventHandler } from './crossThreadHandlers/registerDispatchLynxViewEventHandler.js';
+export function startBackground(backgroundRpc, shadowRoot, callbacks) {
+    registerInvokeUIMethodHandler(backgroundRpc, shadowRoot);
+    registerNativePropsHandler(backgroundRpc, shadowRoot);
+    registerTriggerComponentEventHandler(backgroundRpc, shadowRoot);
+    registerSelectComponentHandler(backgroundRpc, shadowRoot);
+    registerNativeModulesCallHandler(backgroundRpc, callbacks.nativeModulesCall);
+    registerNapiModulesCallHandler(backgroundRpc, callbacks.napiModulesCall);
+    registerDispatchLynxViewEventHandler(backgroundRpc, shadowRoot);
+    const sendGlobalEvent = backgroundRpc.createCall(sendGlobalEventEndpoint);
+    const markTiming = backgroundRpc.createCall(markTimingEndpoint);
+    const updateDataBackground = backgroundRpc.createCall(updateDataEndpoint);
+    return {
+        sendGlobalEvent,
+        markTiming,
+        updateDataBackground,
+    };
+}
+//# sourceMappingURL=startBackground.js.map

package/dist/uiThread/startUIThread.d.ts

@@ -1,7 +1,9 @@
 import type { LynxView } from '../apis/createLynxView.js';
-import { type MainThreadStartConfigs, type NapiModulesCall, type NativeModulesCall } from '@lynx-js/web-constants';
-export declare function startUIThread(templateUrl: string, configs: Omit<MainThreadStartConfigs, 'template'>, shadowRoot: ShadowRoot, lynxGroupId: number | undefined, callbacks: {
+import { type LynxTemplate, type MainThreadStartConfigs, type NapiModulesCall, type NativeModulesCall } from '@lynx-js/web-constants';
+export type StartUIThreadCallbacks = {
     nativeModulesCall: NativeModulesCall;
     napiModulesCall: NapiModulesCall;
     onError?: () => void;
-}): LynxView;
+    customTemplateLoader?: (url: string) => Promise<LynxTemplate>;
+};
+export declare function startUIThread(templateUrl: string, configs: Omit<MainThreadStartConfigs, 'template'>, shadowRoot: ShadowRoot, lynxGroupId: number | undefined, threadStrategy: 'all-on-ui' | 'multi-thread', callbacks: StartUIThreadCallbacks): LynxView;

package/dist/uiThread/startUIThread.js

@@ -1,56 +1,40 @@
 // 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 { registerInvokeUIMethodHandler } from './crossThreadHandlers/registerInvokeUIMethodHandler.js';
-import { registerNativePropsHandler } from './crossThreadHandlers/registerSetNativePropsHandler.js';
-import { registerNativeModulesCallHandler } from './crossThreadHandlers/registerNativeModulesCallHandler.js';
 import { bootWorkers } from './bootWorkers.js';
-import { registerReportErrorHandler } from './crossThreadHandlers/registerReportErrorHandler.js';
-import { registerFlushElementTreeHandler } from './crossThreadHandlers/registerFlushElementTreeHandler.js';
 import { createDispose } from './crossThreadHandlers/createDispose.js';
-import { registerTriggerComponentEventHandler } from './crossThreadHandlers/registerTriggerComponentEventHandler.js';
-import { registerSelectComponentHandler } from './crossThreadHandlers/registerSelectComponentHandler.js';
-import { mainThreadStartEndpoint, markTimingEndpoint, sendGlobalEventEndpoint, } from '@lynx-js/web-constants';
+import {} from '@lynx-js/web-constants';
 import { loadTemplate } from '../utils/loadTemplate.js';
 import { createUpdateData } from './crossThreadHandlers/createUpdateData.js';
-import { registerNapiModulesCallHandler } from './crossThreadHandlers/registerNapiModulesCallHandler.js';
-import { registerDispatchLynxViewEventHandler } from './crossThreadHandlers/registerDispatchLynxViewEventHandler.js';
-export function startUIThread(templateUrl, configs, shadowRoot, lynxGroupId, callbacks) {
+import { startBackground } from './startBackground.js';
+import { createRenderMultiThread } from './createRenderMultiThread.js';
+import { createRenderAllOnUI } from './createRenderAllOnUI.js';
+export function startUIThread(templateUrl, configs, shadowRoot, lynxGroupId, threadStrategy, callbacks) {
     const createLynxStartTiming = performance.now() + performance.timeOrigin;
-    const { nativeModulesMap, napiModulesMap } = configs;
-    const { mainThreadRpc, backgroundRpc, terminateWorkers, } = bootWorkers(lynxGroupId);
-    const sendGlobalEvent = backgroundRpc.createCall(sendGlobalEventEndpoint);
-    const mainThreadStart = mainThreadRpc.createCall(mainThreadStartEndpoint);
-    const markTiming = backgroundRpc.createCall(markTimingEndpoint);
+    const allOnUI = threadStrategy === 'all-on-ui';
+    const { mainThreadRpc, backgroundRpc, terminateWorkers, } = bootWorkers(lynxGroupId, allOnUI);
+    const { markTiming, sendGlobalEvent, updateDataBackground } = startBackground(backgroundRpc, shadowRoot, callbacks);
     const markTimingInternal = (timingKey, pipelineId, timeStamp) => {
         if (!timeStamp)
             timeStamp = performance.now() + performance.timeOrigin;
         markTiming(timingKey, pipelineId, timeStamp);
     };
+    const { start, updateDataMainThread } = allOnUI
+        ? createRenderAllOnUI(
+        /* main-to-bg rpc*/ mainThreadRpc, shadowRoot, markTimingInternal, callbacks)
+        : createRenderMultiThread(
+        /* main-to-ui rpc*/ mainThreadRpc, shadowRoot, callbacks);
     markTimingInternal('create_lynx_start', undefined, createLynxStartTiming);
     markTimingInternal('load_template_start');
-    loadTemplate(templateUrl).then((template) => {
+    loadTemplate(templateUrl, callbacks.customTemplateLoader).then((template) => {
         markTimingInternal('load_template_end');
-        mainThreadStart({
+        start({
             ...configs,
             template,
-            nativeModulesMap,
-            napiModulesMap,
         });
     });
-    registerReportErrorHandler(mainThreadRpc, callbacks.onError);
-    registerDispatchLynxViewEventHandler(backgroundRpc, shadowRoot);
-    registerFlushElementTreeHandler(mainThreadRpc, {
-        shadowRoot,
-    });
-    registerInvokeUIMethodHandler(backgroundRpc, shadowRoot);
-    registerNativePropsHandler(backgroundRpc, shadowRoot);
-    registerTriggerComponentEventHandler(backgroundRpc, shadowRoot);
-    registerSelectComponentHandler(backgroundRpc, shadowRoot);
-    registerNativeModulesCallHandler(backgroundRpc, callbacks.nativeModulesCall);
-    registerNapiModulesCallHandler(backgroundRpc, callbacks.napiModulesCall);
     return {
-        updateData: createUpdateData(mainThreadRpc, backgroundRpc),
+        updateData: createUpdateData(updateDataMainThread, updateDataBackground),
         dispose: createDispose(backgroundRpc, terminateWorkers),
         sendGlobalEvent,
     };

package/dist/utils/loadTemplate.d.ts

@@ -1,2 +1,2 @@
 import { type LynxTemplate } from '@lynx-js/web-constants';
-export declare function loadTemplate(url: string): Promise<LynxTemplate>;
+export declare function loadTemplate(url: string, customTemplateLoader?: (url: string) => Promise<LynxTemplate>): Promise<LynxTemplate>;

package/dist/utils/loadTemplate.js

@@ -82,24 +82,28 @@ const mainThreadInjectVars = [
     '__OnLifecycleEvent',
     '__FlushElementTree',
     '__LoadLepusChunk',
+    'SystemInfo',
 ];
 const backgroundInjectVars = [
     'NativeModules',
     'globalThis',
     'lynx',
     'lynxCoreInject',
+    'SystemInfo',
 ];
 const backgroundInjectWithBind = [
     'Card',
     'Component',
 ];
-export async function loadTemplate(url) {
+export async function loadTemplate(url, customTemplateLoader) {
     const cachedTemplate = TemplateCache[url];
     if (cachedTemplate)
         return cachedTemplate;
-    const template = (await (await fetch(url, {
-        method: 'GET',
-    })).json());
+    const template = customTemplateLoader
+        ? await customTemplateLoader(url)
+        : (await (await fetch(url, {
+            method: 'GET',
+        })).json());
     const decodedTemplate = {
         ...template,
         lepusCode: generateJavascriptUrl(template.lepusCode, mainThreadInjectVars, [], globalMuteableVars),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lynx-js/web-core",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "private": false,
   "description": "",
   "keywords": [],
@@ -24,17 +24,18 @@
     "**/*.css"
   ],
   "dependencies": {
-    "@lynx-js/offscreen-document": "0.0.0",
-    "@lynx-js/web-constants": "0.11.0",
-    "@lynx-js/web-worker-rpc": "0.11.0",
-    "@lynx-js/web-worker-runtime": "0.11.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",
+    "@lynx-js/web-worker-runtime": "0.13.0"
   },
   "devDependencies": {
     "@lynx-js/lynx-core": "0.1.2",
-    "@lynx-js/web-elements": "0.5.4"
+    "@lynx-js/web-elements": "0.7.0"
   },
   "peerDependencies": {
     "@lynx-js/lynx-core": "0.1.2",
-    "@lynx-js/web-elements": ">=0.3.1"
+    "@lynx-js/web-elements": ">=0.6.0"
   }
 }

package/dist/types/LynxExposureModule.d.ts

@@ -1,4 +0,0 @@
-export interface LynxExposureModule {
-    resumeExposure: () => void;
-    stopExposure: () => void;
-}

package/dist/types/LynxExposureModule.js

@@ -1,5 +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.
-export {};
-//# sourceMappingURL=LynxExposureModule.js.map