@lynx-js/web-core 0.7.0

package/dist/apis/LynxView.js

@@ -0,0 +1,368 @@
+// 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 { createLynxView, } from './createLynxView.js';
+import { cardIdAttribute, lynxViewEntryIdPrefix, lynxViewRootDomId, } from '@lynx-js/web-constants';
+import { loadElement } from '@lynx-js/web-elements/lazy';
+/**
+ * Based on our experiences, these elements are almost used in all lynx cards.
+ */
+loadElement('lynx-wrapper');
+loadElement('x-view');
+loadElement('x-text');
+loadElement('x-image');
+loadElement('scroll-view');
+/**
+ * @param {string} url [required] The url of the entry of your Lynx card
+ * @param {Cloneable} globalProps [optional] The globalProps value of this Lynx card
+ * @param {Cloneable} initData [oprional] The initial data of this Lynx card
+ * @param {Record<string,string>} overrideLynxTagToHTMLTagMap [optional] use this property/attribute to override the lynx tag -> html tag map
+ * @param {string} nativeModulesUrl [optional] It is a esm url, use to customize NativeModules.
+ * @param {INativeModulesCall} onNativeModulesCall [optional] the NativeModules value handler. Arguments will be cached before this property is assigned.
+ * @param {"auto" | null} height [optional] set it to "auto" for height auto-sizing
+ * @param {"auto" | null} width [optional] set it to "auto" for width auto-sizing
+ *
+ * @property entryId the currently Lynx view entryId.
+ *
+ * @event error lynx card fired an error
+ *
+ * @example
+ * HTML Exmaple
+ *
+ * Note that you should declarae the size of lynx-view
+ *
+ * ```html
+ * <lynx-view url="https://path/to/main-thread.js" rawData="{}" globalProps="{}" style="height:300px;width:300px">
+ * </lynx-view>
+ * ```
+ *
+ * React 19 Example
+ * ```jsx
+ * <lynx-view url={myLynxCardUrl} rawData={{}} globalProps={{}} style={{height:'300px', width:'300px'}}>
+ * </lynx-vew>
+ * ```
+ */
+export class LynxView extends HTMLElement {
+    static lynxViewCount = 0;
+    static tag = 'lynx-view';
+    static observedAttributeAsProperties = [
+        'url',
+        'globalProps',
+        'initData',
+        'overrideLynxTagToHTMLTagMap',
+        'nativeModulesUrl',
+    ];
+    static attributeCamelCaseMap = Object.fromEntries(this.observedAttributeAsProperties.map((nm) => [nm.toLocaleLowerCase(), nm]));
+    /**
+     * @private
+     */
+    static observedAttributes = LynxView.observedAttributeAsProperties.map(nm => nm.toLowerCase());
+    #instance;
+    #url;
+    /**
+     * @public
+     * @property the url of lynx view output entry file
+     */
+    get url() {
+        return this.#url;
+    }
+    set url(val) {
+        this.#url = val;
+        this.#render();
+    }
+    #globalProps = {};
+    /**
+     * @public
+     * @property globalProps
+     * @default {}
+     */
+    get globalProps() {
+        return this.#globalProps;
+    }
+    set globalProps(val) {
+        if (typeof val === 'string') {
+            this.#globalProps = JSON.parse(val);
+        }
+        else {
+            this.#globalProps = val;
+        }
+    }
+    #initData = {};
+    /**
+     * @public
+     * @property initData
+     * @default {}
+     */
+    get initData() {
+        return this.#initData;
+    }
+    set initData(val) {
+        if (typeof val === 'string') {
+            this.#initData = JSON.parse(val);
+        }
+        else {
+            this.#initData = val;
+        }
+    }
+    #entryId;
+    /**
+     * @public
+     * @readonly
+     * @property
+     * The random generated entryId of current lynxview
+     */
+    get entryId() {
+        return this.#entryId;
+    }
+    #overrideLynxTagToHTMLTagMap = { 'page': 'div' };
+    /**
+     * @public
+     * @property
+     * @default {page: 'div'}
+     */
+    get overrideLynxTagToHTMLTagMap() {
+        return this.#overrideLynxTagToHTMLTagMap;
+    }
+    set overrideLynxTagToHTMLTagMap(val) {
+        if (typeof val === 'string') {
+            this.#overrideLynxTagToHTMLTagMap = JSON.parse(val);
+        }
+        else {
+            this.#overrideLynxTagToHTMLTagMap = val;
+        }
+    }
+    #cachedNativeModulesCall = [];
+    #onNativeModulesCall;
+    /**
+     * @param
+     * @property
+     */
+    get onNativeModulesCall() {
+        return this.#onNativeModulesCall;
+    }
+    set onNativeModulesCall(handler) {
+        this.#onNativeModulesCall = handler;
+        if (this.#cachedNativeModulesCall) {
+            for (const callInfo of this.#cachedNativeModulesCall) {
+                handler.apply(undefined, callInfo);
+            }
+        }
+    }
+    #nativeModulesUrl;
+    /**
+     * @public
+     * @property nativeModules
+     */
+    get nativeModulesUrl() {
+        return this.#nativeModulesUrl;
+    }
+    set nativeModulesUrl(val) {
+        this.#nativeModulesUrl = val;
+    }
+    #autoHeight = false;
+    #autoWidth = false;
+    #currentWidth = 0;
+    #currentHeight = 0;
+    /**
+     * @public
+     * "auto" for auto calculated height
+     */
+    get height() {
+        return this.#autoHeight ? 'auto' : null;
+    }
+    /**
+     * @public
+     * "auto" for auto calculated width
+     */
+    get width() {
+        return this.#autoWidth ? 'auto' : null;
+    }
+    set height(val) {
+        this.#handleAutoSize();
+        this.#autoHeight = val === 'auto' ? true : false;
+    }
+    set width(val) {
+        this.#handleAutoSize();
+        this.#autoWidth = val === 'auto' ? true : false;
+    }
+    #handleAutoSize() {
+        if (this.#autoHeight || this.#autoWidth) {
+            if (this.#instance && !this.#instance.resizeObserver) {
+                this.#instance.resizeObserver = new ResizeObserver((sizes) => {
+                    const size = sizes[0];
+                    if (size) {
+                        const { width, height } = size.contentRect;
+                        if (this.#autoWidth) {
+                            if (this.#currentWidth !== width) {
+                                this.#currentWidth = width;
+                                this.style.setProperty('--lynx-view-width', `${width}px`);
+                            }
+                        }
+                        if (this.#autoHeight) {
+                            if (this.#currentHeight !== height) {
+                                this.#currentHeight = height;
+                                this.style.setProperty('--lynx-view-height', `${height}px`);
+                            }
+                        }
+                    }
+                });
+                this.#instance.resizeObserver.observe(this.#instance.rootDom);
+            }
+        }
+        else {
+            if (this.#instance?.resizeObserver) {
+                this.#instance.resizeObserver.disconnect();
+            }
+        }
+        if (this.#autoHeight) {
+            this.setAttribute('height', 'auto');
+        }
+        else {
+            this.removeAttribute('height');
+        }
+        if (this.#autoWidth) {
+            this.setAttribute('width', 'auto');
+        }
+        else {
+            this.removeAttribute('width');
+        }
+    }
+    /**
+     * @public
+     * @method
+     * update the `__initData` and trigger essential flow
+     */
+    updateData(data, updateDataType, callback) {
+        this.#instance?.lynxView.updateData(data, updateDataType, callback);
+    }
+    /**
+     * @public
+     * @method
+     * send global events, which can be listened to using the GlobalEventEmitter
+     */
+    sendGlobalEvent(eventName, params) {
+        this.#instance?.lynxView.sendGlobalEvent(eventName, params);
+    }
+    /**
+     * @public
+     * @method
+     * reload the current page
+     */
+    reload() {
+        this.#render();
+    }
+    /**
+     * @override
+     * "false" value will be omitted
+     *
+     * {@inheritdoc HTMLElement.setAttribute}
+     */
+    setAttribute(qualifiedName, value) {
+        if (value === 'false') {
+            this.removeAttribute(qualifiedName);
+        }
+        else {
+            super.setAttribute(qualifiedName, value);
+        }
+    }
+    /**
+     * @private
+     */
+    attributeChangedCallback(name, oldValue, newValue) {
+        if (oldValue !== newValue) {
+            name = LynxView.attributeCamelCaseMap[name] ?? name;
+            if (name in this) {
+                // @ts-expect-error
+                this[name] = newValue;
+            }
+        }
+    }
+    /**
+     * @private
+     */
+    disconnectedCallback() {
+        if (this.#instance) {
+            this.#instance.resizeObserver?.disconnect();
+            this.#instance.lynxView.dispose();
+            this.#instance.rootDom.remove();
+        }
+        this.#instance = undefined;
+    }
+    /**
+     * @private the flag to group all changes into one render operation
+     */
+    #rendering = false;
+    /**
+     * @private
+     */
+    #render() {
+        if (!this.#rendering) {
+            this.#rendering = true;
+            queueMicrotask(() => {
+                this.#rendering = false;
+                if (this.#instance) {
+                    this.disconnectedCallback();
+                }
+                if (this.#url) {
+                    const rootDom = document.createElement('div');
+                    rootDom.id = lynxViewRootDomId;
+                    const entryId = `${lynxViewEntryIdPrefix}-${LynxView
+                        .lynxViewCount++}`;
+                    this.#entryId = entryId;
+                    rootDom.setAttribute(cardIdAttribute, entryId);
+                    rootDom.setAttribute('part', lynxViewRootDomId);
+                    const commonEventDetail = {
+                        entryId,
+                    };
+                    const lynxView = createLynxView({
+                        entryId,
+                        rootDom,
+                        templateUrl: this.#url,
+                        globalProps: this.#globalProps,
+                        initData: this.#initData,
+                        overrideLynxTagToHTMLTagMap: this.#overrideLynxTagToHTMLTagMap,
+                        nativeModulesUrl: this.#nativeModulesUrl,
+                        callbacks: {
+                            loadNewTag: loadElement,
+                            nativeModulesCall: (...args) => {
+                                if (this.#onNativeModulesCall) {
+                                    return this.#onNativeModulesCall(...args);
+                                }
+                                else if (this.#cachedNativeModulesCall) {
+                                    this.#cachedNativeModulesCall.push(args);
+                                }
+                                else {
+                                    this.#cachedNativeModulesCall = [args];
+                                }
+                            },
+                            onError: () => {
+                                this.dispatchEvent(new CustomEvent('error', {
+                                    detail: commonEventDetail,
+                                }));
+                            },
+                        },
+                    });
+                    this.#instance = {
+                        lynxView,
+                        rootDom,
+                    };
+                    this.#handleAutoSize();
+                    this.append(rootDom);
+                }
+            });
+        }
+    }
+    /**
+     * @private
+     */
+    connectedCallback() {
+        this.#render();
+    }
+}
+if (customElements.get(LynxView.tag)) {
+    console.warn(`[${LynxView.tag}] has already been defined`);
+}
+else {
+    customElements.define(LynxView.tag, LynxView);
+}
+//# sourceMappingURL=LynxView.js.map

package/dist/apis/createLynxView.d.ts

@@ -0,0 +1,18 @@
+import type { Cloneable, UpdateDataType } from '@lynx-js/web-constants';
+import { startUIThread } from '../uiThread/startUIThread.js';
+export interface LynxViewConfigs {
+    templateUrl: string;
+    initData: Cloneable;
+    globalProps: Cloneable;
+    entryId: string;
+    rootDom: HTMLElement;
+    callbacks: Parameters<typeof startUIThread>[3];
+    overrideLynxTagToHTMLTagMap?: Record<string, string>;
+    nativeModulesUrl: string | undefined;
+}
+export interface LynxView {
+    updateData(data: Cloneable, updateDataType: UpdateDataType, callback?: () => void): void;
+    dispose(): Promise<void>;
+    sendGlobalEvent(name: string, params?: Cloneable[]): void;
+}
+export declare function createLynxView(configs: LynxViewConfigs): LynxView;

package/dist/apis/createLynxView.js

@@ -0,0 +1,17 @@
+// 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 { supportAtScope } from '../utils/browser.js';
+export function createLynxView(configs) {
+    const { rootDom, callbacks, templateUrl, globalProps, entryId, initData, overrideLynxTagToHTMLTagMap, nativeModulesUrl, } = configs;
+    return startUIThread(templateUrl, {
+        initData,
+        globalProps,
+        entryId,
+        browserConfig: {
+            supportAtScope,
+        },
+    }, rootDom, callbacks, overrideLynxTagToHTMLTagMap, nativeModulesUrl);
+}
+//# sourceMappingURL=createLynxView.js.map

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,7 @@
+// Copyright 2023 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+export { createLynxView } from './apis/createLynxView.js';
+export { LynxView } from './apis/LynxView.js';
+export { lynxRuntimeValue } from '@lynx-js/web-constants';
+//# sourceMappingURL=index.js.map

package/dist/types/LynxExposureModule.d.ts

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

package/dist/types/LynxExposureModule.js

@@ -0,0 +1,5 @@
+// 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

package/dist/types/RuntimePropertyOnElement.d.ts

@@ -0,0 +1,17 @@
+import type { LynxEventType, Cloneable } from '@lynx-js/web-constants';
+import { lynxRuntimeValue } from '@lynx-js/web-constants';
+type RuntimeValue = {
+    dataset: {
+        [key: string]: Cloneable;
+    };
+    eventHandler: Record<string, {
+        type: LynxEventType;
+        handler: (ev: Event) => void;
+        hname: string;
+    } | undefined>;
+    [key: string]: any;
+};
+export type RuntimePropertyOnElement = {
+    [lynxRuntimeValue]: RuntimeValue;
+};
+export {};

package/dist/types/RuntimePropertyOnElement.js

@@ -0,0 +1,2 @@
+import { lynxRuntimeValue } from '@lynx-js/web-constants';
+//# sourceMappingURL=RuntimePropertyOnElement.js.map

package/dist/types/UpdatePageCallback.d.ts

@@ -0,0 +1,7 @@
+export interface UpdatePageOption {
+    nativeUpdateDataOrder?: number;
+    reloadTemplate?: boolean;
+    reloadFromJS?: boolean;
+    resetPageData?: boolean;
+}
+export type UpdatePageCallback = (data: any, options: UpdatePageOption) => any;

package/dist/types/UpdatePageCallback.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=UpdatePageCallback.js.map

package/dist/uiThread/bootWorkers.d.ts

@@ -0,0 +1,8 @@
+import { Rpc } from '@lynx-js/web-worker-rpc';
+interface LynxViewRpc {
+    mainThreadRpc: Rpc;
+    backgroundRpc: Rpc;
+    terminateWorkers: () => void;
+}
+export declare function bootWorkers(): LynxViewRpc;
+export {};

package/dist/uiThread/bootWorkers.js

@@ -0,0 +1,60 @@
+// 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 { Rpc } from '@lynx-js/web-worker-rpc';
+let preHeatedMainWorker = createMainWorker();
+export function bootWorkers() {
+    const curMainWorker = preHeatedMainWorker;
+    const curBackgroundWorker = createBackgroundWorker(curMainWorker.channelMainThreadWithBackground);
+    preHeatedMainWorker = createMainWorker();
+    return {
+        mainThreadRpc: curMainWorker.mainThreadRpc,
+        backgroundRpc: curBackgroundWorker.backgroundRpc,
+        terminateWorkers: () => {
+            curMainWorker.mainThreadWorker.terminate();
+            curBackgroundWorker.backgroundThreadWorker.terminate();
+        },
+    };
+}
+function createMainWorker() {
+    const channelToMainThread = new MessageChannel();
+    const channelMainThreadWithBackground = new MessageChannel();
+    const mainThreadWorker = new Worker(new URL('@lynx-js/web-worker-runtime', import.meta.url), {
+        type: 'module',
+        name: `lynx-main`,
+    });
+    const mainThreadMessage = {
+        mode: 'main',
+        toUIThread: channelToMainThread.port2,
+        toPeerThread: channelMainThreadWithBackground.port1,
+    };
+    mainThreadWorker.postMessage(mainThreadMessage, [
+        channelToMainThread.port2,
+        channelMainThreadWithBackground.port1,
+    ]);
+    const mainThreadRpc = new Rpc(channelToMainThread.port1, 'ui-to-main');
+    return {
+        mainThreadRpc,
+        mainThreadWorker,
+        channelMainThreadWithBackground,
+    };
+}
+function createBackgroundWorker(channelMainThreadWithBackground) {
+    const channelToBackground = new MessageChannel();
+    const backgroundThreadWorker = new Worker(new URL('@lynx-js/web-worker-runtime', import.meta.url), {
+        type: 'module',
+        name: `lynx-bg`,
+    });
+    const backgroundThreadMessage = {
+        mode: 'background',
+        toUIThread: channelToBackground.port2,
+        toPeerThread: channelMainThreadWithBackground.port2,
+    };
+    backgroundThreadWorker.postMessage(backgroundThreadMessage, [
+        channelToBackground.port2,
+        channelMainThreadWithBackground.port2,
+    ]);
+    const backgroundRpc = new Rpc(channelToBackground.port1, 'ui-to-bg');
+    return { backgroundRpc, backgroundThreadWorker };
+}
+//# sourceMappingURL=bootWorkers.js.map

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

@@ -0,0 +1,5 @@
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function bootTimingSystem(mainThreadRpc: Rpc, backgroundThreadRpc: Rpc, rootDom: HTMLElement): {
+    markTimingInternal: (timingKey: string, pipelineId?: string, timeStamp?: number) => void;
+    sendTimingResult: (pipelineId: string | undefined, timingFlags: string[], isFp: boolean) => void;
+};

package/dist/uiThread/crossThreadHandlers/bootTimingSystem.js

@@ -0,0 +1,50 @@
+// 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 { postTimingInfoFromBackgroundThread, postTimingInfoFromMainThread, postTimingResult, } from '@lynx-js/web-constants';
+export function bootTimingSystem(mainThreadRpc, backgroundThreadRpc, rootDom) {
+    const setupTiming = {};
+    const pipelineIdToTiming = new Map();
+    let commonTimingFlags = [];
+    function markTimingInternal(timingKey, pipelineId, timeStamp) {
+        if (!timeStamp)
+            timeStamp = performance.now() + performance.timeOrigin;
+        if (!pipelineId) {
+            setupTiming[timingKey] = timeStamp;
+            return;
+        }
+        if (!pipelineIdToTiming.has(pipelineId)) {
+            pipelineIdToTiming.set(pipelineId, {});
+        }
+        const timingInfo = pipelineIdToTiming.get(pipelineId);
+        timingInfo[timingKey] = timeStamp;
+    }
+    function sendTimingResult(pipelineId, timingFlags, isFp) {
+        const timingInfo = (pipelineId ? pipelineIdToTiming.get(pipelineId) : undefined) ?? {};
+        if (!pipelineId)
+            commonTimingFlags = commonTimingFlags.concat(timingFlags);
+        else
+            timingFlags = timingFlags.concat(commonTimingFlags);
+        backgroundThreadRpc.invoke(postTimingResult, [
+            pipelineId,
+            timingInfo,
+            timingFlags,
+            isFp ? setupTiming : undefined,
+        ]);
+        rootDom.dispatchEvent(new CustomEvent('timing', {
+            detail: isFp ? setupTiming : timingInfo,
+            bubbles: true,
+            cancelable: true,
+        }));
+        if (pipelineId) {
+            pipelineIdToTiming.delete(pipelineId);
+        }
+    }
+    mainThreadRpc.registerHandler(postTimingInfoFromMainThread, markTimingInternal);
+    backgroundThreadRpc.registerHandler(postTimingInfoFromBackgroundThread, markTimingInternal);
+    return {
+        markTimingInternal,
+        sendTimingResult,
+    };
+}
+//# sourceMappingURL=bootTimingSystem.js.map

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

@@ -0,0 +1,3 @@
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+import type { LynxView } from '../../apis/createLynxView.js';
+export declare function createDispose(rpc: Rpc, terminateWorkers: () => void): LynxView['dispose'];

package/dist/uiThread/crossThreadHandlers/createDispose.js

@@ -0,0 +1,11 @@
+// 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 { disposeEndpoint } from '@lynx-js/web-constants';
+export function createDispose(rpc, terminateWorkers) {
+    return async () => {
+        await rpc.invoke(disposeEndpoint, []);
+        terminateWorkers();
+    };
+}
+//# sourceMappingURL=createDispose.js.map

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

@@ -0,0 +1,2 @@
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function createExposureService(rpc: Rpc, rootDom: Element): void;

package/dist/uiThread/crossThreadHandlers/createExposureService.js

@@ -0,0 +1,55 @@
+import { lynxUniqueIdAttribute, postExposureEndpoint, switchExposureService, } from '@lynx-js/web-constants';
+import { createCrossThreadEvent } from '../../utils/createCrossThreadEvent.js';
+export function createExposureService(rpc, rootDom) {
+    let working = true;
+    let exposureCache = [];
+    let disexposureCache = [];
+    const onScreen = new Map();
+    async function exposureEventHandler(ev) {
+        const exposureEvent = createCrossThreadEvent(ev);
+        exposureEvent.detail['unique-id'] = parseFloat(ev.target.getAttribute(lynxUniqueIdAttribute));
+        const exposureID = exposureEvent.exposureID;
+        if (ev.type === 'exposure') {
+            exposureCache.push(exposureEvent);
+            onScreen.set(exposureID, exposureEvent);
+        }
+        else {
+            disexposureCache.push(exposureEvent);
+            onScreen.delete(exposureID);
+        }
+    }
+    setInterval(() => {
+        if (exposureCache.length > 0 || disexposureCache.length > 0) {
+            const currentExposure = exposureCache;
+            const currentDisexposure = disexposureCache;
+            exposureCache = [];
+            disexposureCache = [];
+            rpc.invoke(postExposureEndpoint, [{
+                    exposures: currentExposure,
+                    disExposures: currentDisexposure,
+                }]);
+        }
+    }, 1000 / 20);
+    rootDom.addEventListener('exposure', exposureEventHandler, { passive: true });
+    rootDom.addEventListener('disexposure', exposureEventHandler, {
+        passive: true,
+    });
+    rpc.registerHandler(switchExposureService, async (enable, sendEvent) => {
+        if (enable && !working) {
+            // send all onScreen info
+            rpc.invoke(postExposureEndpoint, [{
+                    exposures: [...onScreen.values()],
+                    disExposures: [],
+                }]);
+        }
+        else if (!enable && working) {
+            if (sendEvent) {
+                rpc.invoke(postExposureEndpoint, [{
+                        exposures: [],
+                        disExposures: [...onScreen.values()],
+                    }]);
+            }
+        }
+    });
+}
+//# sourceMappingURL=createExposureService.js.map

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

@@ -0,0 +1,3 @@
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+import type { LynxView } from '../../apis/createLynxView.js';
+export declare function createUpdateData(mainThreadRpc: Rpc, backgroundRpc: Rpc): LynxView['updateData'];