@lynx-js/web-mainthread-apis 0.13.4 → 0.14.0

package/dist/prepareMainThreadAPIs.js

@@ -1,21 +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.
-import { BackgroundThreadStartEndpoint, publishEventEndpoint, publicComponentEventEndpoint, postExposureEndpoint, switchExposureServiceEndpoint, postTimingFlagsEndpoint, dispatchCoreContextOnBackgroundEndpoint, dispatchJSContextOnMainThreadEndpoint, LynxCrossThreadContext, } from '@lynx-js/web-constants';
+import { BackgroundThreadStartEndpoint, publishEventEndpoint, publicComponentEventEndpoint, postExposureEndpoint, postTimingFlagsEndpoint, dispatchCoreContextOnBackgroundEndpoint, dispatchJSContextOnMainThreadEndpoint, LynxCrossThreadContext, switchExposureServiceEndpoint, getCacheI18nResourcesKey, dispatchI18nResourceEndpoint, } from '@lynx-js/web-constants';
 import { registerCallLepusMethodHandler } from './crossThreadHandlers/registerCallLepusMethodHandler.js';
 import { registerGetCustomSectionHandler } from './crossThreadHandlers/registerGetCustomSectionHandler.js';
-import { MainThreadRuntime, switchExposureService, } from './MainThreadRuntime.js';
+import { createMainThreadGlobalThis } from './createMainThreadGlobalThis.js';
+import { createExposureService } from './utils/createExposureService.js';
 const moduleCache = {};
-export function prepareMainThreadAPIs(backgroundThreadRpc, rootDom, createElement, commitDocument, markTimingInternal, reportError) {
+export function prepareMainThreadAPIs(backgroundThreadRpc, rootDom, createElement, commitDocument, markTimingInternal, reportError, triggerI18nResourceFallback, initialI18nResources) {
     const postTimingFlags = backgroundThreadRpc.createCall(postTimingFlagsEndpoint);
     const backgroundStart = backgroundThreadRpc.createCall(BackgroundThreadStartEndpoint);
     const publishEvent = backgroundThreadRpc.createCall(publishEventEndpoint);
     const publicComponentEvent = backgroundThreadRpc.createCall(publicComponentEventEndpoint);
     const postExposure = backgroundThreadRpc.createCall(postExposureEndpoint);
+    const dispatchI18nResource = backgroundThreadRpc.createCall(dispatchI18nResourceEndpoint);
     markTimingInternal('lepus_execute_start');
     async function startMainThread(config) {
         let isFp = true;
-        const { globalProps, template, browserConfig, nativeModulesMap, napiModulesMap, tagMap, } = config;
+        const { globalProps, template, browserConfig, nativeModulesMap, napiModulesMap, tagMap, initI18nResources, } = config;
         const { styleInfo, pageConfig, customSections, cardType, lepusCode } = template;
         markTimingInternal('decode_start');
         const lepusCodeEntries = await Promise.all(Object.entries(lepusCode).map(async ([name, url]) => {
@@ -39,7 +41,8 @@ export function prepareMainThreadAPIs(backgroundThreadRpc, rootDom, createElemen
             receiveEventEndpoint: dispatchJSContextOnMainThreadEndpoint,
             sendEventEndpoint: dispatchCoreContextOnBackgroundEndpoint,
         });
-        const runtime = new MainThreadRuntime({
+        const i18nResources = initialI18nResources(initI18nResources);
+        const mtsGlobalThis = createMainThreadGlobalThis({
             jsContext,
             tagMap,
             browserConfig,
@@ -48,18 +51,20 @@ export function prepareMainThreadAPIs(backgroundThreadRpc, rootDom, createElemen
             pageConfig,
             styleInfo,
             lepusCode: lepusCodeLoaded,
-            createElement,
             rootDom,
             callbacks: {
                 mainChunkReady: () => {
                     markTimingInternal('data_processor_start');
-                    const initData = runtime.processData
-                        ? runtime.processData(config.initData)
-                        : config.initData;
+                    let initData = config.initData;
+                    if (pageConfig.enableJSDataProcessor !== true
+                        && mtsGlobalThis.processData) {
+                        initData = mtsGlobalThis.processData(config.initData);
+                    }
                     markTimingInternal('data_processor_end');
-                    registerCallLepusMethodHandler(backgroundThreadRpc, runtime);
+                    registerCallLepusMethodHandler(backgroundThreadRpc, mtsGlobalThis);
                     registerGetCustomSectionHandler(backgroundThreadRpc, customSections);
-                    backgroundThreadRpc.registerHandler(switchExposureServiceEndpoint, runtime[switchExposureService]);
+                    const { switchExposureService } = createExposureService(rootDom, postExposure);
+                    backgroundThreadRpc.registerHandler(switchExposureServiceEndpoint, switchExposureService);
                     backgroundStart({
                         initData,
                         globalProps,
@@ -70,8 +75,8 @@ export function prepareMainThreadAPIs(backgroundThreadRpc, rootDom, createElemen
                         napiModulesMap,
                         browserConfig,
                     });
-                    runtime.renderPage(initData);
-                    runtime.__FlushElementTree(undefined, {});
+                    mtsGlobalThis.renderPage(initData);
+                    mtsGlobalThis.__FlushElementTree(undefined, {});
                 },
                 flushElementTree: async (options, timingFlags) => {
                     const pipelineId = options?.pipelineOptions?.pipelineID;
@@ -108,13 +113,22 @@ export function prepareMainThreadAPIs(backgroundThreadRpc, rootDom, createElemen
                 markTiming: (a, b) => markTimingInternal(b, a),
                 publishEvent,
                 publicComponentEvent,
-                postExposure,
+                createElement,
+                _I18nResourceTranslation: (options) => {
+                    const matchedInitI18nResources = i18nResources.data?.find(i => getCacheI18nResourcesKey(i.options)
+                        === getCacheI18nResourcesKey(options));
+                    dispatchI18nResource(matchedInitI18nResources?.resource);
+                    if (matchedInitI18nResources) {
+                        return matchedInitI18nResources.resource;
+                    }
+                    return triggerI18nResourceFallback(options);
+                },
             },
         });
         markTimingInternal('decode_end');
-        entry(runtime);
+        entry(mtsGlobalThis);
         jsContext.__start(); // start the jsContext after the runtime is created
-        return runtime;
+        return mtsGlobalThis;
     }
     return { startMainThread };
 }

package/dist/pureElementPAPIs.d.ts

@@ -0,0 +1,32 @@
+import { type AddClassPAPI, type AddConfigPAPI, type AddDatasetPAPI, type AddInlineStylePAPI, type AppendElementPAPI, type ElementIsEqualPAPI, type FirstElementPAPI, type GetAttributesPAPI, type GetChildrenPAPI, type GetClassesPAPI, type GetComponentIdPAPI, type GetDataByKeyPAPI, type GetDatasetPAPI, type GetElementConfigPAPI, type GetElementUniqueIDPAPI, type GetIDPAPI, type GetParentPAPI, type GetTagPAPI, type InsertElementBeforePAPI, type LastElementPAPI, type NextElementPAPI, type RemoveElementPAPI, type ReplaceElementPAPI, type ReplaceElementsPAPI, type SetClassesPAPI, type SetConfigPAPI, type SetCSSIdPAPI, type SetDatasetPAPI, type SetIDPAPI, type SetInlineStylesPAPI, type UpdateComponentIDPAPI } from '@lynx-js/web-constants';
+export declare const __AppendElement: AppendElementPAPI;
+export declare const __ElementIsEqual: ElementIsEqualPAPI;
+export declare const __FirstElement: FirstElementPAPI;
+export declare const __GetChildren: GetChildrenPAPI;
+export declare const __GetParent: GetParentPAPI;
+export declare const __InsertElementBefore: InsertElementBeforePAPI;
+export declare const __LastElement: LastElementPAPI;
+export declare const __NextElement: NextElementPAPI;
+export declare const __RemoveElement: RemoveElementPAPI;
+export declare const __ReplaceElement: ReplaceElementPAPI;
+export declare const __ReplaceElements: ReplaceElementsPAPI;
+export declare const __AddConfig: AddConfigPAPI;
+export declare const __AddDataset: AddDatasetPAPI;
+export declare const __GetDataset: GetDatasetPAPI;
+export declare const __GetDataByKey: GetDataByKeyPAPI;
+export declare const __GetAttributes: GetAttributesPAPI;
+export declare const __GetComponentID: GetComponentIdPAPI;
+export declare const __GetElementConfig: GetElementConfigPAPI;
+export declare const __GetElementUniqueID: GetElementUniqueIDPAPI;
+export declare const __GetID: GetIDPAPI;
+export declare const __SetID: SetIDPAPI;
+export declare const __GetTag: GetTagPAPI;
+export declare const __SetConfig: SetConfigPAPI;
+export declare const __SetDataset: SetDatasetPAPI;
+export declare const __UpdateComponentID: UpdateComponentIDPAPI;
+export declare const __GetClasses: GetClassesPAPI;
+export declare const __SetCSSId: SetCSSIdPAPI;
+export declare const __SetClasses: SetClassesPAPI;
+export declare const __AddInlineStyle: AddInlineStylePAPI;
+export declare const __AddClass: AddClassPAPI;
+export declare const __SetInlineStyles: SetInlineStylesPAPI;

package/dist/pureElementPAPIs.js

@@ -0,0 +1,140 @@
+// 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 { componentIdAttribute, cssIdAttribute, lynxComponentConfigAttribute, lynxDatasetAttribute, lynxTagAttribute, lynxUniqueIdAttribute, } from '@lynx-js/web-constants';
+import { queryCSSProperty } from './style/cssPropertyMap.js';
+import { transformInlineStyleString, transformParsedStyles, } from './style/transformInlineStyle.js';
+import hyphenateStyleName from 'hyphenate-style-name';
+export const __AppendElement = /*#__PURE__*/ (parent, child) => parent.appendChild(child);
+export const __ElementIsEqual = /*#__PURE__*/ (left, right) => left === right;
+export const __FirstElement = /*#__PURE__*/ (element) => element.firstElementChild;
+export const __GetChildren = /*#__PURE__*/ (element) => element.children;
+export const __GetParent = /*#__PURE__*/ (element) => element.parentElement;
+export const __InsertElementBefore = /*#__PURE__*/ (parent, child, ref) => parent.insertBefore(child, ref);
+export const __LastElement = /*#__PURE__*/ (element) => element.lastElementChild;
+export const __NextElement = /*#__PURE__*/ (element) => element.nextElementSibling;
+export const __RemoveElement = /*#__PURE__*/ (parent, child) => parent.removeChild(child);
+export const __ReplaceElement = /*#__PURE__*/ (newElement, oldElement) => oldElement.replaceWith(newElement);
+export const __ReplaceElements = /*#__PURE__*/ (parent, newChildren, oldChildren) => {
+    newChildren = Array.isArray(newChildren) ? newChildren : [newChildren];
+    if (!oldChildren || (Array.isArray(oldChildren) && oldChildren?.length === 0)) {
+        parent.append(...newChildren);
+    }
+    else {
+        oldChildren = Array.isArray(oldChildren) ? oldChildren : [oldChildren];
+        for (let ii = 1; ii < oldChildren.length; ii++) {
+            __RemoveElement(parent, oldChildren[ii]);
+        }
+        const firstOldChildren = oldChildren[0];
+        firstOldChildren.replaceWith(...newChildren);
+    }
+};
+export const __AddConfig = /*#__PURE__*/ (element, type, value) => {
+    const currentComponentConfigString = element.getAttribute(lynxComponentConfigAttribute);
+    let currentComponentConfig = currentComponentConfigString
+        ? JSON.parse(decodeURIComponent(currentComponentConfigString))
+        : {};
+    currentComponentConfig[type] = value;
+    element.setAttribute(lynxComponentConfigAttribute, encodeURIComponent(JSON.stringify(currentComponentConfig)));
+};
+export const __AddDataset = /*#__PURE__*/ (element, key, value) => {
+    const currentDataset = __GetDataset(element);
+    currentDataset[key] = value;
+    element.setAttribute(lynxDatasetAttribute, encodeURIComponent(JSON.stringify(currentDataset)));
+    value
+        ? element.setAttribute('data-' + key, value.toString())
+        : element.removeAttribute('data-' + key);
+};
+export const __GetDataset = /*#__PURE__*/ (element) => {
+    const datasetString = element.getAttribute(lynxDatasetAttribute);
+    const currentDataset = datasetString
+        ? JSON.parse(decodeURIComponent(datasetString))
+        : {};
+    return currentDataset;
+};
+export const __GetDataByKey = /*#__PURE__*/ (element, key) => {
+    const dataset = __GetDataset(element);
+    return dataset[key];
+};
+export const __GetAttributes = /*#__PURE__*/ (element) => {
+    return Object.fromEntries(element.getAttributeNames().map((attributeName) => [attributeName, element.getAttribute(attributeName)])
+        .filter(([, value]) => value));
+};
+export const __GetComponentID = /*#__PURE__*/ (element) => element.getAttribute(componentIdAttribute);
+export const __GetElementConfig = /*#__PURE__*/ (element) => {
+    const currentComponentConfigString = element.getAttribute(lynxComponentConfigAttribute);
+    return currentComponentConfigString
+        ? JSON.parse(decodeURIComponent(currentComponentConfigString))
+        : {};
+};
+export const __GetElementUniqueID = /*#__PURE__*/ (element) => (element && element.getAttribute
+    ? Number(element.getAttribute(lynxUniqueIdAttribute))
+    : -1);
+export const __GetID = /*#__PURE__*/ (element) => element.getAttribute('id');
+export const __SetID = /*#__PURE__*/ (element, id) => id ? element.setAttribute('id', id) : element.removeAttribute('id');
+export const __GetTag = /*#__PURE__*/ (element) => element.getAttribute(lynxTagAttribute);
+export const __SetConfig = /*#__PURE__*/ (element, config) => {
+    element.setAttribute(lynxComponentConfigAttribute, encodeURIComponent(JSON.stringify(config)));
+};
+export const __SetDataset = /*#__PURE__*/ (element, dataset) => {
+    element.setAttribute(lynxDatasetAttribute, encodeURIComponent(JSON.stringify(dataset)));
+    for (const [key, value] of Object.entries(dataset)) {
+        element.setAttribute('data-' + key, value.toString());
+    }
+};
+export const __UpdateComponentID = /*#__PURE__*/ (element, componentID) => element.setAttribute(componentIdAttribute, componentID);
+export const __GetClasses = /*#__PURE__*/ (element) => ((element.getAttribute('class') ?? '').split(' ').filter(e => e));
+export const __SetCSSId = /*#__PURE__*/ (elements, cssId) => {
+    for (const element of elements) {
+        element.setAttribute(cssIdAttribute, cssId + '');
+    }
+};
+export const __SetClasses = /*#__PURE__*/ (element, classname) => {
+    classname
+        ? element.setAttribute('class', classname)
+        : element.removeAttribute('class');
+};
+export const __AddInlineStyle = /*#__PURE__*/ (element, key, value) => {
+    let dashName;
+    if (typeof key === 'number') {
+        const queryResult = queryCSSProperty(key);
+        dashName = queryResult.dashName;
+        if (queryResult.isX) {
+            console.error(`[lynx-web] css property: ${dashName} is not supported.`);
+        }
+    }
+    else {
+        dashName = key;
+    }
+    const valueStr = typeof value === 'number' ? value.toString() : value;
+    if (!valueStr) { // null or undefined
+        element.style.removeProperty(dashName);
+    }
+    else {
+        const { transformedStyle } = transformParsedStyles([[
+                dashName,
+                valueStr,
+            ]]);
+        for (const [property, value] of transformedStyle) {
+            element.style.setProperty(property, value);
+        }
+    }
+};
+export const __AddClass = /*#__PURE__*/ (element, className) => {
+    const newClassName = ((element.getAttribute('class') ?? '') + ' ' + className)
+        .trim();
+    element.setAttribute('class', newClassName);
+};
+export const __SetInlineStyles = /*#__PURE__*/ (element, value) => {
+    if (!value)
+        return;
+    const { transformedStyle } = typeof value === 'string'
+        ? transformInlineStyleString(value)
+        : transformParsedStyles(Object.entries(value).map(([k, value]) => [
+            hyphenateStyleName(k),
+            value,
+        ]));
+    const transformedStyleStr = transformedStyle.map(([property, value]) => `${property}:${value};`).join('');
+    element.setAttribute('style', transformedStyleStr);
+};
+//# sourceMappingURL=pureElementPAPIs.js.map

package/dist/utils/createCrossThreadEvent.d.ts

@@ -1,3 +1,2 @@
-import type { LynxCrossThreadEvent } from '@lynx-js/web-constants';
-import { type MainThreadRuntime } from '../MainThreadRuntime.js';
-export declare function createCrossThreadEvent(runtime: MainThreadRuntime, domEvent: Event, eventName: string): LynxCrossThreadEvent;
+import { type LynxCrossThreadEvent, type MinimalRawEventObject } from '@lynx-js/web-constants';
+export declare function createCrossThreadEvent(domEvent: MinimalRawEventObject, eventName: string): LynxCrossThreadEvent;

package/dist/utils/createCrossThreadEvent.js

@@ -1,4 +1,7 @@
-import { elementToRuntimeInfoMap, } from '../MainThreadRuntime.js';
+// 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 { lynxDatasetAttribute, lynxUniqueIdAttribute, } from '@lynx-js/web-constants';
 function toCloneableObject(obj) {
     const cloneableObj = {};
     for (const key in obj) {
@@ -10,10 +13,12 @@ function toCloneableObject(obj) {
     }
     return cloneableObj;
 }
-export function createCrossThreadEvent(runtime, domEvent, eventName) {
+export function createCrossThreadEvent(domEvent, eventName) {
     const targetElement = domEvent.target;
     const currentTargetElement = domEvent
-        .currentTarget;
+        .currentTarget.getAttribute
+        ? domEvent.currentTarget
+        : undefined;
     const type = domEvent.type;
     const params = {};
     const isTrusted = domEvent.isTrusted;
@@ -47,21 +52,27 @@ export function createCrossThreadEvent(runtime, domEvent, eventName) {
                 : changedTouches,
         });
     }
-    const targetElementRuntimeInfo = runtime[elementToRuntimeInfoMap].get(targetElement);
-    const currentTargetElementRuntimeInfo = runtime[elementToRuntimeInfoMap].get(currentTargetElement);
+    const currentTargetDatasetString = currentTargetElement?.getAttribute(lynxDatasetAttribute);
+    const currentTargetDataset = currentTargetDatasetString
+        ? JSON.parse(decodeURIComponent(currentTargetDatasetString))
+        : {};
+    const targetDatasetString = targetElement.getAttribute(lynxDatasetAttribute);
+    const targetDataset = targetDatasetString
+        ? JSON.parse(decodeURIComponent(targetDatasetString))
+        : {};
     return {
         type: eventName,
         timestamp: domEvent.timeStamp,
         target: {
-            id: targetElement.id,
-            dataset: targetElementRuntimeInfo.lynxDataset,
-            uniqueId: targetElementRuntimeInfo.uniqueId,
+            id: targetElement.getAttribute('id'),
+            dataset: targetDataset,
+            uniqueId: Number(targetElement.getAttribute(lynxUniqueIdAttribute)),
         },
-        currentTarget: currentTargetElementRuntimeInfo
+        currentTarget: currentTargetElement
             ? {
-                id: currentTargetElement.id,
-                dataset: currentTargetElementRuntimeInfo.lynxDataset,
-                uniqueId: currentTargetElementRuntimeInfo.uniqueId,
+                id: currentTargetElement.getAttribute('id'),
+                dataset: currentTargetDataset,
+                uniqueId: Number(currentTargetElement.getAttribute(lynxUniqueIdAttribute)),
             }
             : null,
         // @ts-expect-error

package/dist/utils/createExposureService.d.ts

@@ -1,4 +1,4 @@
-import type { MainThreadRuntime } from '../MainThreadRuntime.js';
-export declare function createExposureService(runtime: MainThreadRuntime): {
+import { type postExposureEndpoint, type RpcCallType } from '@lynx-js/web-constants';
+export declare function createExposureService(rootDom: Pick<EventTarget, 'addEventListener'>, postExposure: RpcCallType<typeof postExposureEndpoint>): {
     switchExposureService: (enable: boolean, sendEvent: boolean) => void;
 };

package/dist/utils/createExposureService.js

@@ -3,14 +3,13 @@
 // LICENSE file in the root directory of this source tree.
 import { lynxUniqueIdAttribute, } from '@lynx-js/web-constants';
 import { createCrossThreadEvent } from './createCrossThreadEvent.js';
-export function createExposureService(runtime) {
-    const postExposure = runtime.config.callbacks.postExposure;
+export function createExposureService(rootDom, postExposure) {
     let working = true;
     let exposureCache = [];
     let disexposureCache = [];
     const onScreen = new Map();
     function exposureEventHandler(ev) {
-        const exposureEvent = createCrossThreadEvent(runtime, ev, ev.type);
+        const exposureEvent = createCrossThreadEvent(ev, ev.type);
         exposureEvent.detail['unique-id'] = parseFloat(ev.target.getAttribute(lynxUniqueIdAttribute));
         const exposureID = exposureEvent.detail.exposureID;
         if (ev.type === 'exposure') {
@@ -34,10 +33,10 @@ export function createExposureService(runtime) {
             });
         }
     }, 1000 / 20);
-    runtime._rootDom.addEventListener('exposure', exposureEventHandler, {
+    rootDom.addEventListener('exposure', exposureEventHandler, {
         passive: true,
     });
-    runtime._rootDom.addEventListener('disexposure', exposureEventHandler, {
+    rootDom.addEventListener('disexposure', exposureEventHandler, {
         passive: true,
     });
     function switchExposureService(enable, sendEvent) {

package/dist/utils/decodeCssInJs.js

@@ -16,7 +16,7 @@ export function decodeCssInJs(classes, styleInfo, cssId) {
         }
     }
     else {
-        throw new Error(`[lynx-web] cannot find styleinfo for cssid ${cssId}`);
+        console.warn(`[lynx-web] cannot find styleinfo for cssid ${cssId}`);
     }
     return declarations.map(([property, value]) => `${property}:${value};`).join('');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lynx-js/web-mainthread-apis",
-  "version": "0.13.4",
+  "version": "0.14.0",
   "private": false,
   "description": "",
   "keywords": [],
@@ -25,7 +25,7 @@
   "dependencies": {
     "css-tree": "^3.1.0",
     "hyphenate-style-name": "^1.1.0",
-    "@lynx-js/web-constants": "0.13.4",
-    "@lynx-js/web-style-transformer": "0.3.0"
+    "@lynx-js/web-constants": "0.14.0",
+    "@lynx-js/web-style-transformer": "0.3.1"
   }
 }

package/dist/MainThreadLynx.d.ts

@@ -1,10 +0,0 @@
-import { type MainThreadRuntimeConfig } from './MainThreadRuntime.js';
-export declare function createMainThreadLynx(config: MainThreadRuntimeConfig): {
-    getJSContext(): import("@lynx-js/web-constants").LynxContextEventTarget;
-    requestAnimationFrame(cb: FrameRequestCallback): number;
-    cancelAnimationFrame(handler: number): void;
-    __globalProps: unknown;
-    getCustomSectionSync(key: string): import("@lynx-js/web-constants").Cloneable;
-    markPipelineTiming: (pipelineId: string, timingKey: string) => void;
-};
-export type MainThreadLynx = ReturnType<typeof createMainThreadLynx>;

package/dist/MainThreadRuntime.d.ts

@@ -1,92 +0,0 @@
-import { type LynxTemplate, type PageConfig, type ProcessDataCallback, type StyleInfo, type FlushElementTreeOptions, type Cloneable, type BrowserConfig, type publishEventEndpoint, type publicComponentEventEndpoint, type reportErrorEndpoint, type RpcCallType, type postExposureEndpoint, type LynxContextEventTarget, type LynxJSModule, systemInfo } from '@lynx-js/web-constants';
-import { type MainThreadLynx } from './MainThreadLynx.js';
-import type { LynxRuntimeInfo } from './elementAPI/ElementThreadElement.js';
-export interface MainThreadRuntimeCallbacks {
-    mainChunkReady: () => void;
-    flushElementTree: (options: FlushElementTreeOptions, timingFlags: string[]) => void;
-    _ReportError: RpcCallType<typeof reportErrorEndpoint>;
-    __OnLifecycleEvent: (lifeCycleEvent: Cloneable) => void;
-    markTiming: (pipelineId: string, timingKey: string) => void;
-    publishEvent: RpcCallType<typeof publishEventEndpoint>;
-    publicComponentEvent: RpcCallType<typeof publicComponentEventEndpoint>;
-    postExposure: RpcCallType<typeof postExposureEndpoint>;
-}
-export interface MainThreadRuntimeConfig {
-    pageConfig: PageConfig;
-    globalProps: unknown;
-    callbacks: MainThreadRuntimeCallbacks;
-    styleInfo: StyleInfo;
-    customSections: LynxTemplate['customSections'];
-    lepusCode: Record<string, LynxJSModule>;
-    browserConfig: BrowserConfig;
-    tagMap: Record<string, string>;
-    createElement: Document['createElement'];
-    rootDom: Pick<Element, 'append' | 'addEventListener'>;
-    jsContext: LynxContextEventTarget;
-}
-export declare const elementToRuntimeInfoMap: unique symbol;
-export declare const getElementByUniqueId: unique symbol;
-export declare const updateCSSInJsStyle: unique symbol;
-export declare const lynxUniqueIdToElement: unique symbol;
-export declare const switchExposureService: unique symbol;
-export declare class MainThreadRuntime {
-    #private;
-    config: MainThreadRuntimeConfig;
-    /**
-     * @private
-     */
-    [lynxUniqueIdToElement]: WeakRef<HTMLElement>[];
-    /**
-     * @private
-     */
-    [switchExposureService]: (enable: boolean, sendEvent: boolean) => void;
-    /**
-     * @private
-     */
-    private _lynxUniqueIdToStyleSheet;
-    /**
-     * @private
-     */
-    _page?: HTMLElement;
-    /**
-     * @private the CreatePage will append it to this
-     */
-    _rootDom: Pick<Element, 'append' | 'addEventListener'>;
-    _createElement: Document['createElement'];
-    /**
-     * @private
-     */
-    _timingFlags: string[];
-    /**
-     * @private
-     */
-    [elementToRuntimeInfoMap]: WeakMap<HTMLElement, LynxRuntimeInfo>;
-    constructor(config: MainThreadRuntimeConfig);
-    /**
-     * @private
-     */
-    [getElementByUniqueId](uniqueId: number): HTMLElement | undefined;
-    [updateCSSInJsStyle](uniqueId: number, newStyles: string): void;
-    /**
-     * @private
-     */
-    __lynxGlobalBindingValues: Record<string, any>;
-    globalThis: this;
-    SystemInfo: typeof systemInfo;
-    lynx: MainThreadLynx;
-    __globalProps: unknown;
-    processData?: ProcessDataCallback;
-    ssrEncode?: () => string;
-    ssrHydrate?: (encodeData?: string) => void;
-    renderPage: (data: unknown) => void;
-    __GetTemplateParts?: () => Record<string, Element> | undefined;
-    __GetPageElement: () => HTMLElement | undefined;
-    _ReportError: RpcCallType<typeof reportErrorEndpoint>;
-    __OnLifecycleEvent: (lifeCycleEvent: Cloneable) => void;
-    __LoadLepusChunk: (path: string) => boolean;
-    __FlushElementTree: (_subTree: unknown, options: FlushElementTreeOptions) => void;
-    updatePage?: (data: Cloneable, options?: Record<string, string>) => void;
-    runWorklet?: (obj: unknown, event: unknown) => void;
-    private __varsUpdateHandlers;
-    set _updateVars(handler: () => void);
-}