@lynx-js/web-core-wasm-canary 0.0.0 → 0.0.1-canary-20260116-ce265e8f

package/binary/encode/encode_debug_bg.wasm.d.ts

@@ -0,0 +1,50 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_decodedstyledata_free: (a: number, b: number) => void;
+export const decodedstyledata_new: (a: any) => [number, number, number];
+export const decodedstyledata_style_content: (a: number) => [number, number];
+export const decodedstyledata_font_face_content: (a: number) => [number, number];
+export const decodedstyledata_query_css_og_declarations_by_css_id: (a: number, b: number, c: number, d: number) => [number, number];
+export const decodedstyledata_decode_into: (a: any, b: number, c: number, d: number) => [number, number, number];
+export const decodedstyledata_encode_from_raw_style_info: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const __wbg_rawelementtemplate_free: (a: number, b: number) => void;
+export const rawelementtemplate_new: () => number;
+export const rawelementtemplate_append_to_root: (a: number, b: number) => void;
+export const rawelementtemplate_create_element: (a: number, b: number, c: number, d: number) => void;
+export const rawelementtemplate_set_attribute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const rawelementtemplate_set_dataset: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const rawelementtemplate_append_child: (a: number, b: number, c: number) => void;
+export const rawelementtemplate_set_cross_thread_event: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+export const rawelementtemplate_set_attribute_slot: (a: number, b: number, c: number, d: number, e: number) => void;
+export const rawelementtemplate_append_element_slot: (a: number, b: number, c: number) => void;
+export const __wbg_operation_free: (a: number, b: number) => void;
+export const __wbg_elementtemplatesection_free: (a: number, b: number) => void;
+export const elementtemplatesection_new: () => number;
+export const elementtemplatesection_from_encoded: (a: any) => [number, number, number];
+export const elementtemplatesection_add_element_template: (a: number, b: number, c: number, d: number) => void;
+export const elementtemplatesection_encode: (a: number) => any;
+export const __wbg_rawstyleinfo_free: (a: number, b: number) => void;
+export const __wbg_rule_free: (a: number, b: number) => void;
+export const __wbg_ruleprelude_free: (a: number, b: number) => void;
+export const __wbg_selector_free: (a: number, b: number) => void;
+export const rawstyleinfo_new: () => number;
+export const rawstyleinfo_append_import: (a: number, b: number, c: number) => void;
+export const rawstyleinfo_push_rule: (a: number, b: number, c: number) => void;
+export const rawstyleinfo_encode: (a: number) => [number, number, number];
+export const rule_new: (a: number, b: number) => [number, number, number];
+export const rule_set_prelude: (a: number, b: number) => void;
+export const rule_push_declaration: (a: number, b: number, c: number, d: number, e: number) => void;
+export const rule_push_rule_children: (a: number, b: number) => void;
+export const ruleprelude_new: () => number;
+export const ruleprelude_push_selector: (a: number, b: number) => void;
+export const selector_new: () => number;
+export const selector_push_one_selector_section: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const __wbg_styleinfodecoder_free: (a: number, b: number) => void;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_start: () => void;

package/binary/encode/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "dependencies": {}
+}

package/css/in_shadow.css

@@ -0,0 +1,10 @@
+@import url("@lynx-js/web-elements/index.css");
+
+[lynx-default-display-linear="false"] * {
+  --lynx-display: flex;
+  --lynx-display-toggle: var(--lynx-display-flex);
+}
+
+[lynx-default-overflow-visible="true"] x-view {
+  overflow: visible;
+}

package/css/index.css

@@ -0,0 +1,119 @@
+/*
+// 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.
+*/
+
+lynx-view {
+  contain: strict;
+  display: none;
+}
+
+lynx-view[width="auto"] {
+  --lynx-view-width: 100%;
+  width: var(--lynx-view-width);
+  inline-size: var(--lynx-view-width);
+}
+
+lynx-view[height="auto"], lynx-view[width="auto"] {
+  contain: content;
+}
+
+lynx-view::part(page) {
+  height: 100%;
+  width: 100%;
+}
+
+@property --lynx-display {
+  syntax: "linear | flex";
+  inherits: false;
+  initial-value: linear;
+}
+@property --lynx-linear-weight-sum {
+  syntax: "<number>";
+  inherits: false;
+  initial-value: 1;
+}
+@property --lynx-linear-weight {
+  syntax: "<number>";
+  inherits: false;
+  initial-value: 0;
+}
+@property --justify-content-column {
+  syntax: "flex-start|flex-end|center|space-between|space-around";
+  inherits: false;
+  initial-value: flex-start;
+}
+@property --justify-content-column-reverse {
+  syntax: "flex-start|flex-end|center|space-between|space-around";
+  inherits: false;
+  initial-value: flex-start;
+}
+@property --justify-content-row {
+  syntax: "flex-start|flex-end|center|space-between|space-around";
+  inherits: false;
+  initial-value: flex-start;
+}
+@property --justify-content-row-reverse {
+  syntax: "flex-start|flex-end|center|space-between|space-around";
+  inherits: false;
+  initial-value: flex-start;
+}
+@property --align-self-row {
+  syntax: "start|end|center|stretch|auto";
+  inherits: false;
+  initial-value: auto;
+}
+@property --align-self-column {
+  syntax: "start|end|center|stretch|auto";
+  inherits: false;
+  initial-value: auto;
+}
+@property --lynx-linear-weight-basis {
+  syntax: "auto|<number>|<length>";
+  inherits: false;
+  initial-value: auto;
+}
+@property --lynx-linear-orientation {
+  syntax: "<custom-ident>";
+  inherits: false;
+  initial-value: vertical;
+}
+
+@property --flex-direction {
+  syntax: "*";
+  inherits: false;
+}
+@property --flex-wrap {
+  syntax: "*";
+  inherits: false;
+}
+@property --flex-grow {
+  syntax: "<number>";
+  inherits: false;
+  initial-value: 0;
+}
+@property --flex-shrink {
+  syntax: "<number>";
+  inherits: false;
+  initial-value: 1;
+}
+@property --flex-basis {
+  syntax: "*";
+  inherits: false;
+  initial-value: auto;
+}
+@property --flex-value {
+  syntax: "*";
+  inherits: false;
+}
+@property --flex {
+  syntax: "*";
+  inherits: false;
+}
+
+@property --linear-justify-content {
+  syntax: "flex-start|flex-end|center|space-between|space-around";
+  inherits: false;
+  initial-value: flex-start;
+}

package/dist/client/LynxCrossThreadContext.d.ts

@@ -0,0 +1,22 @@
+import type { dispatchCoreContextOnBackgroundEndpoint } from './endpoints.js';
+import type { LynxContextEventTarget } from '../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare const DispatchEventResult: {
+    readonly NotCanceled: 0;
+    readonly CanceledByEventHandler: 1;
+    readonly CanceledByDefaultEventHandler: 2;
+    readonly CanceledBeforeDispatch: 3;
+};
+type LynxCrossThreadContextConfig = {
+    rpc: Rpc;
+    receiveEventEndpoint: typeof dispatchCoreContextOnBackgroundEndpoint;
+    sendEventEndpoint: typeof dispatchCoreContextOnBackgroundEndpoint;
+};
+export declare class LynxCrossThreadContext extends EventTarget implements LynxContextEventTarget {
+    #private;
+    constructor(config: LynxCrossThreadContextConfig);
+    postMessage(...args: any[]): void;
+    dispatchEvent(event: ContextCrossThreadEvent): 3;
+    __start(): void;
+}
+export {};

package/dist/client/LynxCrossThreadContext.js

@@ -0,0 +1,44 @@
+// 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 const DispatchEventResult = {
+    // Event was not canceled by event handler or default event handler.
+    NotCanceled: 0,
+    // Event was canceled by event handler; i.e. a script handler calling
+    // preventDefault.
+    CanceledByEventHandler: 1,
+    // Event was canceled by the default event handler; i.e. executing the default
+    // action.  This result should be used sparingly as it deviates from the DOM
+    // Event Dispatch model. Default event handlers really shouldn't be invoked
+    // inside of dispatch.
+    CanceledByDefaultEventHandler: 2,
+    // Event was canceled but suppressed before dispatched to event handler.  This
+    // result should be used sparingly; and its usage likely indicates there is
+    // potential for a bug. Trusted events may return this code; but untrusted
+    // events likely should always execute the event handler the developer intends
+    // to execute.
+    CanceledBeforeDispatch: 3,
+};
+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/client/background/background-apis/createBackgroundLynx.d.ts

@@ -0,0 +1,24 @@
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+import type { Cloneable, NativeApp } from '../../../types/index.js';
+import { LynxCrossThreadContext } from '../../LynxCrossThreadContext.js';
+export declare function createBackgroundLynx(globalProps: Cloneable, customSections: Record<string, Cloneable>, nativeApp: NativeApp, mainThreadRpc: Rpc): {
+    __globalProps: Cloneable;
+    getJSModule(_moduleName: string): any;
+    getNativeApp(): NativeApp;
+    getCoreContext(): LynxCrossThreadContext;
+    getCustomSectionSync(key: string): Cloneable;
+    getCustomSection: (key: string, callback: (object: Cloneable) => void) => void;
+    queueMicrotask: (callback: () => void) => void;
+    createElement(_: string, id: string): {
+        animate(operation: import("../../../constants.js").AnimationOperation, id: string, keyframes?: Record<string, any>[], timingOptions?: Record<string, any>): void;
+    };
+    getI18nResource: () => Cloneable;
+    QueryComponent: (source: string, callback: (ret: {
+        __hasReady: boolean;
+    } | {
+        code: number;
+        detail?: {
+            schema: string;
+        };
+    }) => void) => void;
+};

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

@@ -0,0 +1,38 @@
+// 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 '../../endpoints.js';
+import { createGetCustomSection } from './crossThreadHandlers/createGetCustomSection.js';
+import { createElement } from './createElement.js';
+import { LynxCrossThreadContext } from '../../LynxCrossThreadContext.js';
+export function createBackgroundLynx(globalProps, customSections, nativeApp, mainThreadRpc) {
+    const coreContext = new LynxCrossThreadContext({
+        rpc: mainThreadRpc,
+        receiveEventEndpoint: dispatchCoreContextOnBackgroundEndpoint,
+        sendEventEndpoint: dispatchJSContextOnMainThreadEndpoint,
+    });
+    return {
+        __globalProps: globalProps,
+        getJSModule(_moduleName) {
+        },
+        getNativeApp() {
+            return nativeApp;
+        },
+        getCoreContext() {
+            return coreContext;
+        },
+        getCustomSectionSync(key) {
+            return customSections[key];
+        },
+        getCustomSection: createGetCustomSection(mainThreadRpc, customSections),
+        queueMicrotask: (callback) => {
+            queueMicrotask(callback);
+        },
+        createElement(_, id) {
+            return createElement(id, mainThreadRpc);
+        },
+        getI18nResource: () => nativeApp.i18nResource.data,
+        QueryComponent: (source, callback) => nativeApp.queryComponent(source, callback),
+    };
+}
+//# sourceMappingURL=createBackgroundLynx.js.map

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

@@ -0,0 +1,7 @@
+import type { NativeApp } from '../../../types/index.js';
+export declare function createChunkLoading(entryTemplateUrl: string): {
+    readScript: NativeApp['readScript'];
+    loadScript: NativeApp['loadScript'];
+    loadScriptAsync: NativeApp['loadScriptAsync'];
+    templateCache: Map<string, Record<string, string>>;
+};

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

@@ -0,0 +1,66 @@
+// 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(entryTemplateUrl) {
+    const templateCache = new Map();
+    const readScript = (sourceURL, templateUrl) => {
+        if (!templateUrl || templateUrl === '__Card__') {
+            templateUrl = entryTemplateUrl;
+        }
+        const finalSourceURL = templateCache.get(templateUrl)?.[`/${sourceURL}`] ?? sourceURL;
+        const xhr = new XMLHttpRequest();
+        xhr.open('GET', finalSourceURL, 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, templateUrl) => {
+        if (!templateUrl || templateUrl === '__Card__') {
+            templateUrl = entryTemplateUrl;
+        }
+        const finalSourceURL = templateCache.get(templateUrl)?.[`/${sourceURL}`] ?? sourceURL;
+        return new Promise((resolve, reject) => {
+            fetch(finalSourceURL).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) => {
+        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);
+        return {
+            init(lynxCoreInject) {
+                const module = { exports: {} };
+                const tt = lynxCoreInject.tt;
+                foo(undefined, module, module.exports, lynxCoreInject, tt.Card.bind(tt), tt.setTimeout, tt.setInterval, tt.clearInterval, tt.clearTimeout, tt.NativeModules, tt.Component.bind(tt), 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, templateUrl) => {
+            const jsContent = readScript(sourceURL, templateUrl);
+            return createBundleInitReturnObj(jsContent);
+        },
+        loadScriptAsync: async (sourceURL, callback, templateUrl) => {
+            readScriptAsync(sourceURL, templateUrl).then((jsContent) => {
+                callback(null, createBundleInitReturnObj(jsContent));
+            });
+        },
+        templateCache,
+    };
+}
+//# sourceMappingURL=createChunkLoading.js.map

package/dist/client/background/background-apis/createElement.d.ts

@@ -0,0 +1,5 @@
+import type { AnimationOperation } from '../../../constants.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare const createElement: (elementId: string, uiThreadRpc: Rpc) => {
+    animate(operation: AnimationOperation, id: string, keyframes?: Record<string, any>[], timingOptions?: Record<string, any>): void;
+};

package/dist/client/background/background-apis/createElement.js

@@ -0,0 +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 { triggerElementMethodEndpoint } from '../../endpoints.js';
+export const createElement = (elementId, uiThreadRpc) => {
+    const triggerElementMethod = uiThreadRpc.createCall(triggerElementMethodEndpoint);
+    return {
+        animate(operation, id, keyframes, timingOptions) {
+            triggerElementMethod('animate', elementId, {
+                operation,
+                id,
+                keyframes,
+                timingOptions,
+            });
+        },
+    };
+};
+//# sourceMappingURL=createElement.js.map

package/dist/client/background/background-apis/createNapiLoader.d.ts

@@ -0,0 +1,5 @@
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+import type { NapiModulesMap } from '../../../types/index.js';
+export declare const createNapiLoader: (rpc: Rpc, napiModulesMap: NapiModulesMap) => Promise<{
+    load(moduleName: string): Record<string, any> | undefined;
+}>;

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

@@ -0,0 +1,23 @@
+// 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.
+/* LYNX_NAPI_MODULES_IMPORT */
+import { dispatchNapiModuleEndpoint, napiModulesCallEndpoint, } from '../../endpoints.js';
+export const createNapiLoader = async (rpc, napiModulesMap) => {
+    const napiModulesCall = rpc.createCall(napiModulesCallEndpoint);
+    const napiModules = {};
+    const listeners = new Set();
+    rpc.registerHandler(dispatchNapiModuleEndpoint, (data) => {
+        listeners.forEach((listener) => listener(data));
+    });
+    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) => {
+        listeners.add(func);
+    })))));
+    /* LYNX_NAPI_MODULES_ADD */
+    return {
+        load(moduleName) {
+            return napiModules[moduleName];
+        },
+    };
+};
+//# sourceMappingURL=createNapiLoader.js.map

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

@@ -0,0 +1,4 @@
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+import type { NativeApp, NativeModulesMap } from '../../../types/index.js';
+import type { TimingSystem } from './createTimingSystem.js';
+export declare function createNativeApp(mainThreadRpc: Rpc, timingSystem: TimingSystem, nativeModulesMap: NativeModulesMap, entryTemplateUrl: string): Promise<NativeApp>;

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

@@ -0,0 +1,98 @@
+import { callLepusMethodEndpoint, setNativePropsEndpoint, triggerComponentEventEndpoint, selectComponentEndpoint, reportErrorEndpoint, queryComponentEndpoint, updateBTSChunkEndpoint, } from '../../endpoints.js';
+import { createInvokeUIMethod } from './crossThreadHandlers/createInvokeUIMethod.js';
+import { registerPublicComponentEventHandler } from './crossThreadHandlers/registerPublicComponentEventHandler.js';
+import { createNativeModules } from './createNativeModules.js';
+import { registerUpdateDataHandler } from './crossThreadHandlers/registerUpdateDataHandler.js';
+import { registerPublishEventHandler } from './crossThreadHandlers/registerPublishEventHandler.js';
+import { createPerformanceApis } from './createPerformanceApis.js';
+import { registerSendGlobalEventHandler } from './crossThreadHandlers/registerSendGlobalEvent.js';
+import { createJSObjectDestructionObserver } from './crossThreadHandlers/createJSObjectDestructionObserver.js';
+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 = {};
+class I18nResource {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    setData(data) {
+        this.data = data;
+    }
+}
+export async function createNativeApp(mainThreadRpc, timingSystem, nativeModulesMap, entryTemplateUrl) {
+    const performanceApis = createPerformanceApis(timingSystem);
+    const callLepusMethod = mainThreadRpc.createCallbackify(callLepusMethodEndpoint, 2);
+    const setNativeProps = mainThreadRpc.createCall(setNativePropsEndpoint);
+    const triggerComponentEvent = mainThreadRpc.createCall(triggerComponentEventEndpoint);
+    const selectComponent = mainThreadRpc.createCallbackify(selectComponentEndpoint, 3);
+    const queryComponent = mainThreadRpc.createCall(queryComponentEndpoint);
+    const reportError = mainThreadRpc.createCall(reportErrorEndpoint);
+    const { templateCache, loadScript, loadScriptAsync, readScript } = createChunkLoading(entryTemplateUrl);
+    mainThreadRpc.registerHandler(updateBTSChunkEndpoint, (url, btsChunkUrls) => {
+        templateCache.set(url, btsChunkUrls);
+    });
+    const i18nResource = new I18nResource();
+    let release = '';
+    const nativeApp = {
+        id: (nativeAppCount++).toString(),
+        ...performanceApis,
+        setTimeout: setTimeout,
+        setInterval: setInterval,
+        clearTimeout: clearTimeout,
+        clearInterval: clearInterval,
+        nativeModuleProxy: await createNativeModules(mainThreadRpc, mainThreadRpc, nativeModulesMap),
+        readScript,
+        loadScriptAsync,
+        loadScript,
+        requestAnimationFrame(cb) {
+            return requestAnimationFrame(cb);
+        },
+        cancelAnimationFrame(handler) {
+            return cancelAnimationFrame(handler);
+        },
+        callLepusMethod,
+        setNativeProps,
+        getPathInfo: createGetPathInfo(mainThreadRpc),
+        invokeUIMethod: createInvokeUIMethod(mainThreadRpc),
+        tt: null,
+        setCard(tt) {
+            registerPublicComponentEventHandler(mainThreadRpc, tt);
+            registerPublishEventHandler(mainThreadRpc, tt);
+            registerUpdateDataHandler(mainThreadRpc, tt);
+            registerSendGlobalEventHandler(mainThreadRpc, tt);
+            registerUpdateGlobalPropsHandler(mainThreadRpc, tt);
+            registerUpdateI18nResource(mainThreadRpc, i18nResource, tt);
+            timingSystem.registerGlobalEmitter(tt.GlobalEventEmitter);
+            tt.lynx.getCoreContext().__start();
+            nativeApp.tt = tt;
+        },
+        triggerComponentEvent,
+        selectComponent,
+        createJSObjectDestructionObserver: createJSObjectDestructionObserver(),
+        setSharedData(dataKey, dataVal) {
+            sharedData[dataKey] = dataVal;
+        },
+        getSharedData(dataKey) {
+            return sharedData[dataKey];
+        },
+        i18nResource,
+        reportException: (err, _) => reportError(err, _, release),
+        __SetSourceMapRelease: (err) => release = err.message,
+        __GetSourceMapRelease: (_url) => release,
+        queryComponent: (source, callback) => {
+            if (templateCache.has(source)) {
+                callback({ __hasReady: true });
+            }
+            else {
+                queryComponent(source).then(res => {
+                    callback?.(res);
+                });
+            }
+        },
+    };
+    return nativeApp;
+}
+//# sourceMappingURL=createNativeApp.js.map

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

@@ -0,0 +1,3 @@
+import { type NativeModulesMap } from '../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function createNativeModules(uiThreadRpc: Rpc, mainThreadRpc: Rpc, nativeModulesMap: NativeModulesMap): Promise<Record<string, any>>;

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

@@ -0,0 +1,33 @@
+// 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.
+/* LYNX_NATIVE_MODULES_IMPORT */
+import {} from '../../../types/index.js';
+import { nativeModulesCallEndpoint, switchExposureServiceEndpoint, } from '../../endpoints.js';
+export async function createNativeModules(uiThreadRpc, mainThreadRpc, nativeModulesMap) {
+    const switchExposure = mainThreadRpc.createCall(switchExposureServiceEndpoint);
+    const nativeModulesCall = uiThreadRpc.createCall(nativeModulesCallEndpoint);
+    const lynxExposureModule = {
+        resumeExposure() {
+            switchExposure(true, true);
+        },
+        stopExposure(param) {
+            switchExposure(false, param.sendEvent ?? true);
+        },
+    };
+    const bridgeModule = {
+        call(name, data, callback) {
+            nativeModulesCall(name, data, 'bridge').then(callback);
+        },
+    };
+    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)))));
+    /* LYNX_NATIVE_MODULES_ADD */
+    return Object.assign(nativeModules, {
+        bridge: bridgeModule,
+        LynxExposureModule: lynxExposureModule,
+        ...customNativeModules,
+    });
+}
+//# sourceMappingURL=createNativeModules.js.map

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

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

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

@@ -0,0 +1,47 @@
+// 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 createPerformanceApis(timingSystem) {
+    let inc = 0;
+    const performanceApis = {
+        generatePipelineOptions: () => {
+            const newPipelineId = `_pipeline_` + (inc++);
+            return {
+                pipelineID: newPipelineId,
+                needTimestamps: false,
+            };
+        },
+        onPipelineStart: function () {
+            // Do nothing
+        },
+        markPipelineTiming: function (pipelineId, timingKey) {
+            timingSystem.markTimingInternal(timingKey, pipelineId);
+        },
+        bindPipelineIdWithTimingFlag: function (pipelineId, timingFlag) {
+            if (!timingSystem.pipelineIdToTimingFlags.has(pipelineId)) {
+                timingSystem.pipelineIdToTimingFlags.set(pipelineId, []);
+            }
+            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.');
+        },
+        profileMark: () => {
+            console.error('NYI: profileMark. This is an issue of lynx-core.');
+        },
+        profileFlowId: () => {
+            console.error('NYI: profileFlowId. This is an issue of lynx-core.');
+            return 0;
+        },
+        isProfileRecording: () => {
+            console.error('NYI: isProfileRecording. This is an issue of lynx-core.');
+            return false;
+        },
+    };
+    return performanceApis;
+}
+//# sourceMappingURL=createPerformanceApis.js.map