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

package/dist/client/mainthread/StyleManager.js

@@ -0,0 +1,72 @@
+// Copyright 2025 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 { lynxUniqueIdAttribute } from '../../constants.js';
+// @ts-expect-error
+import IN_SHADOW_CSS_MODERN from '../../../css/in_shadow.css?inline';
+const IN_SHADOW_CSS = URL.createObjectURL(new Blob([IN_SHADOW_CSS_MODERN], { type: 'text/css' }));
+const IMPORT_CSS_STMT = `@import url("${IN_SHADOW_CSS}");\n`;
+/**
+ * There are two modes to manage styles:
+ * 1. CSS Selector mode: styles are injected into a <style>, the style manager won't keep track of which styles are applied to which elements.
+ *    The browser's native CSS selector engine will handle the style application.
+ * 2. Non-CSS Selector mode: styles are managed by the style manager, which keeps track of which styles are applied to which elements.
+ *    The style manager will inject styles into the style sheet of a <style> element. All classes is calculated
+ *    based on entry_name, css_id, class_name, and applied by using [unique-id="x"] selectors.
+ */
+export class StyleManager {
+    #cssQueryMapByEntryName = new Map();
+    #cssOGStyleSheet;
+    #uniqueIdToStyleDeclarationsMap;
+    #rootNode;
+    constructor(rootNode) {
+        this.#rootNode = rootNode;
+    }
+    updateCssOgStyle(uniqueId, cssId, classNames, entryName = '__Card__') {
+        const classNamesArray = [...classNames];
+        const newDeclarations = this.#cssQueryMapByEntryName.get(entryName)
+            ?.query_css_og_declarations_by_css_id(cssId, classNamesArray) ?? '';
+        if (!this.#cssOGStyleSheet) {
+            const cssOgStyleElement = document.createElement('style');
+            this.#rootNode.appendChild(cssOgStyleElement);
+            this.#cssOGStyleSheet = cssOgStyleElement.sheet;
+        }
+        // update style declaration
+        if (this.#cssOGStyleSheet && this.#cssQueryMapByEntryName) {
+            if (!this.#uniqueIdToStyleDeclarationsMap) {
+                this.#uniqueIdToStyleDeclarationsMap = new Map();
+            }
+            const styleDeclaration = this.#uniqueIdToStyleDeclarationsMap.get(uniqueId);
+            if (styleDeclaration) {
+                styleDeclaration.cssText = newDeclarations;
+            }
+            else {
+                const ruleIndex = this.#cssOGStyleSheet.insertRule(`[${lynxUniqueIdAttribute}="${uniqueId}"] {${newDeclarations}}`, this.#cssOGStyleSheet.cssRules.length);
+                const rule = this.#cssOGStyleSheet.cssRules[ruleIndex];
+                this.#uniqueIdToStyleDeclarationsMap.set(uniqueId, rule.style);
+            }
+        }
+    }
+    pushStyleSheet(decodedStyle, entryName) {
+        const newStyleElement = document.createElement('style');
+        let styleElementContent = entryName ? '' : IMPORT_CSS_STMT;
+        if (decodedStyle.style_content) {
+            styleElementContent += decodedStyle.style_content;
+            if (entryName) {
+                newStyleElement.setAttribute('name', entryName);
+            }
+        }
+        if (decodedStyle.font_face_content) {
+            const fontFaceStyleElement = document.createElement('style');
+            fontFaceStyleElement.textContent = decodedStyle.font_face_content;
+            if (entryName) {
+                fontFaceStyleElement.setAttribute('name', entryName);
+            }
+            this.#rootNode.parentElement.appendChild(fontFaceStyleElement);
+        }
+        this.#cssQueryMapByEntryName.set(entryName || '__Card__', decodedStyle);
+        newStyleElement.textContent = styleElementContent;
+        this.#rootNode.appendChild(newStyleElement);
+    }
+}
+//# sourceMappingURL=StyleManager.js.map

package/dist/client/mainthread/TemplateManager.d.ts

@@ -0,0 +1,11 @@
+import type { LynxViewInstance } from './LynxViewInstance.js';
+import type { DecodedTemplate } from '../../types/index.js';
+export declare class TemplateManager {
+    #private;
+    constructor();
+    fetchBundle(url: string, lynxViewInstancePromise: Promise<LynxViewInstance>, overrideConfig?: Record<string, string>): Promise<void>;
+    createTemplate(url: string): void;
+    setElementTemplateSection(url: string, section: any): void;
+    getTemplate(url: string): DecodedTemplate | undefined;
+}
+export declare const templateManager: TemplateManager;

package/dist/client/mainthread/TemplateManager.js

@@ -0,0 +1,257 @@
+/*
+ * Copyright 2025 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 { TemplateSectionLabel } from '../../constants.js';
+const wasm = import(
+/* webpackMode: "eager" */
+/* webpackChunkName: "wasm-initializer" */
+/* webpackFetchPriority: "high" */
+/* webpackPrefetch: true */
+/* webpackPreload: true */
+'../wasm.js');
+export class TemplateManager {
+    #templates = new Map();
+    #lynxViewInstancesMap = new Map();
+    #pendingResolves = new Map();
+    #worker = null;
+    #workerReadyPromise = null;
+    #resolveWorkerReady = null;
+    constructor() {
+        this.#ensureWorker();
+    }
+    fetchBundle(url, lynxViewInstancePromise, overrideConfig) {
+        if (this.#templates.has(url) && !overrideConfig) {
+            return (async () => {
+                const template = this.#templates.get(url);
+                const config = (template?.config || {});
+                const lynxViewInstance = await lynxViewInstancePromise;
+                lynxViewInstance.backgroundThread.markTiming('decode_start');
+                lynxViewInstance.onPageConfigReady(config);
+                const styleInfo = template?.styleInfo;
+                if (styleInfo) {
+                    lynxViewInstance.onStyleInfoReady(styleInfo, url);
+                }
+                lynxViewInstance.onMTSScriptsLoaded(url, config.isLazy === 'true');
+                lynxViewInstance.onBTSScriptsLoaded(url);
+            })();
+        }
+        else {
+            this.createTemplate(url);
+            return this.#load(url, lynxViewInstancePromise, overrideConfig);
+        }
+    }
+    async #load(url, lynxViewInstancePromise, overrideConfig) {
+        const currentTime = performance.now() + performance.timeOrigin;
+        lynxViewInstancePromise.then((instance) => {
+            instance.backgroundThread.markTiming('fetch_start', undefined, currentTime);
+        });
+        this.#lynxViewInstancesMap.set(url, lynxViewInstancePromise);
+        await this.#ensureWorker();
+        const msg = {
+            type: 'load',
+            url,
+            fetchUrl: (new URL(url, location.href)).toString(),
+            overrideConfig,
+        };
+        this.#worker.postMessage(msg);
+        return new Promise((resolve, reject) => {
+            this.#pendingResolves.set(url, { resolve, reject });
+        });
+    }
+    #resolvePromise(url) {
+        const promise = this.#pendingResolves.get(url);
+        if (promise) {
+            promise.resolve();
+            this.#pendingResolves.delete(url);
+        }
+    }
+    #rejectPromise(url, reason) {
+        const promise = this.#pendingResolves.get(url);
+        if (promise) {
+            promise.reject(reason);
+            this.#pendingResolves.delete(url);
+        }
+    }
+    #ensureWorker() {
+        if (!this.#worker) {
+            this.#workerReadyPromise = new Promise((resolve) => {
+                this.#resolveWorkerReady = resolve;
+            });
+            this.#worker = new Worker(new URL(
+            /* webpackFetchPriority: "high" */
+            /* webpackChunkName: "web-core-template-loader-thread" */
+            /* webpackPrefetch: true */
+            /* webpackPreload: true */
+            '../decodeWorker/decode.worker.js', import.meta.url), { type: 'module' });
+            this.#worker.onmessage = this.#handleMessage.bind(this);
+            this.#workerReadyPromise.then(() => {
+                wasm.then(({ wasmModule }) => {
+                    this.#worker.postMessage({
+                        type: 'init',
+                        wasmModule,
+                    });
+                });
+            });
+            return this.#workerReadyPromise;
+        }
+        else if (this.#workerReadyPromise) {
+            return this.#workerReadyPromise;
+        }
+    }
+    #handleMessage(event) {
+        const msg = event.data;
+        if (msg.type === 'ready') {
+            if (this.#resolveWorkerReady) {
+                this.#resolveWorkerReady();
+                this.#resolveWorkerReady = null;
+                this.#workerReadyPromise = null;
+            }
+            return;
+        }
+        const { url } = msg;
+        const lynxViewInstancePromise = this.#lynxViewInstancesMap.get(url);
+        if (!lynxViewInstancePromise)
+            return;
+        switch (msg.type) {
+            case 'section':
+                /**
+                 * The lynxViewInstance is already awaited the wasm is ready
+                 */
+                this.#handleSection(msg, lynxViewInstancePromise);
+                break;
+            case 'error':
+                console.error(`Error decoding template ${url}:`, msg.error);
+                this.#cleanup(url);
+                this.#removeTemplate(url);
+                this.#rejectPromise(url, new Error(msg.error));
+                break;
+            case 'done':
+                this.#cleanup(url);
+                /* TODO: The promise resolution is deferred inside .then() without error handling.
+                 *
+                 */
+                lynxViewInstancePromise.then((instance) => {
+                    instance.backgroundThread.markTiming('decode_end');
+                    instance.backgroundThread.markTiming('load_template_start');
+                    this.#resolvePromise(url);
+                });
+                break;
+        }
+    }
+    async #handleSection(msg, instancePromise) {
+        const [instance, { DecodedStyle, ElementTemplateSection },] = await Promise.all([
+            instancePromise,
+            wasm.then(({ DecodedStyle, wasmInstance }) => ({
+                DecodedStyle,
+                ElementTemplateSection: wasmInstance.ElementTemplateSection,
+            })),
+        ]);
+        const { label, data, url, config } = msg;
+        switch (label) {
+            case TemplateSectionLabel.Configurations: {
+                instance.backgroundThread.markTiming('decode_start');
+                this.#setConfig(url, data);
+                instance.onPageConfigReady(data);
+                break;
+            }
+            case TemplateSectionLabel.StyleInfo: {
+                const decodedStyle = new DecodedStyle(new Uint8Array(data));
+                this.#setStyleInfo(url, decodedStyle);
+                instance.onStyleInfoReady(decodedStyle, url);
+                break;
+            }
+            case TemplateSectionLabel.LepusCode: {
+                const blobMap = data;
+                this.#setLepusCode(url, blobMap);
+                instance.onMTSScriptsLoaded(url, config['isLazy'] === 'true');
+                break;
+            }
+            case TemplateSectionLabel.ElementTemplates:
+                // data is Uint8Array
+                const section = ElementTemplateSection.from_encoded(new Uint8Array(data));
+                this.setElementTemplateSection(url, section);
+                break;
+            case TemplateSectionLabel.CustomSections: {
+                this.#setCustomSection(url, data);
+                break;
+            }
+            case TemplateSectionLabel.Manifest: {
+                const blobMap = data;
+                this.#setBackgroundCode(url, blobMap);
+                instance.onBTSScriptsLoaded(url);
+                break;
+            }
+            default:
+                throw new Error(`Unknown section label: ${label}`);
+        }
+    }
+    #cleanup(url) {
+        this.#lynxViewInstancesMap.delete(url);
+    }
+    createTemplate(url) {
+        if (this.#templates.has(url)) {
+            // remove the template and revoke URLs
+            const template = this.#templates.get(url);
+            if (template) {
+                if (template.lepusCode) {
+                    for (const blobUrl of Object.values(template.lepusCode)) {
+                        URL.revokeObjectURL(blobUrl);
+                    }
+                }
+                if (template.backgroundCode) {
+                    for (const blobUrl of Object.values(template.backgroundCode)) {
+                        URL.revokeObjectURL(blobUrl);
+                    }
+                }
+            }
+            this.#templates.delete(url);
+        }
+        this.#templates.set(url, {});
+    }
+    #removeTemplate(url) {
+        this.#templates.delete(url);
+    }
+    #setConfig(url, config) {
+        const template = this.#templates.get(url);
+        if (template) {
+            template.config = config;
+        }
+    }
+    #setStyleInfo(url, styleInfo) {
+        const template = this.#templates.get(url);
+        if (template) {
+            template.styleInfo = styleInfo;
+        }
+    }
+    #setLepusCode(url, lepusCode) {
+        const template = this.#templates.get(url);
+        if (template) {
+            template.lepusCode = lepusCode;
+        }
+    }
+    setElementTemplateSection(url, section) {
+        const template = this.#templates.get(url);
+        if (template) {
+            template.elementTemplates = section;
+        }
+    }
+    #setCustomSection(url, customSections) {
+        const template = this.#templates.get(url);
+        if (template) {
+            template.customSections = customSections;
+        }
+    }
+    #setBackgroundCode(url, backgroundCode) {
+        const template = this.#templates.get(url);
+        if (template) {
+            template.backgroundCode = backgroundCode;
+        }
+    }
+    getTemplate(url) {
+        return this.#templates.get(url);
+    }
+}
+export const templateManager = new TemplateManager();
+//# sourceMappingURL=TemplateManager.js.map

package/dist/client/mainthread/createIFrameRealm.d.ts

@@ -0,0 +1,6 @@
+import type { JSRealm } from '../../types/index.js';
+/**
+ * Creates a isolated JavaScript context for executing mts code.
+ * This context has its own global variables and functions.
+ */
+export declare function createIFrameRealm(parent: Node): Promise<JSRealm>;

package/dist/client/mainthread/createIFrameRealm.js

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2025 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.
+ */
+const existingScript = document.querySelector('script[nonce]');
+const nonce = existingScript?.nonce || existingScript?.getAttribute('nonce');
+/**
+ * Creates a isolated JavaScript context for executing mts code.
+ * This context has its own global variables and functions.
+ */
+export async function createIFrameRealm(parent) {
+    const iframe = document.createElement('iframe');
+    const iframeReadyPromise = new Promise((resolve) => {
+        const listener = (event) => {
+            if (event.data === 'lynx:mtsready' && event.source === iframe.contentWindow) {
+                resolve();
+                globalThis.removeEventListener('message', listener);
+            }
+        };
+        globalThis.addEventListener('message', listener);
+    });
+    iframe.style.display = 'none';
+    iframe.srcdoc =
+        '<!DOCTYPE html><html><head><script>parent.postMessage("lynx:mtsready","*")</script></head><body style="display:none"></body></html>';
+    iframe.sandbox = 'allow-same-origin allow-scripts'; // Restrict capabilities for security
+    iframe.loading = 'eager';
+    parent.appendChild(iframe);
+    await iframeReadyPromise;
+    const iframeWindow = iframe.contentWindow;
+    const loadScript = async (url) => {
+        const script = iframe.contentDocument.createElement('script');
+        script.fetchPriority = 'high';
+        script.defer = true;
+        script.async = false;
+        script.nonce = nonce || '';
+        iframe.contentDocument.head.appendChild(script);
+        return new Promise(async (resolve, reject) => {
+            script.onload = () => {
+                const ret = iframeWindow?.module?.exports;
+                iframeWindow.module = { exports: undefined };
+                resolve(ret);
+            };
+            script.onerror = (err) => reject(new Error(`Failed to load script: ${url}`, { cause: err }));
+            iframeWindow.module = { exports: undefined };
+            script.src = url;
+        });
+    };
+    const loadScriptSync = (url) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open('GET', url, false); // Synchronous request
+        xhr.send(null);
+        if (xhr.status === 200) {
+            const script = iframe.contentDocument.createElement('script');
+            script.textContent = xhr.responseText;
+            iframeWindow.module = { exports: undefined };
+            iframe.contentDocument.head.appendChild(script);
+            const ret = iframeWindow?.module?.exports;
+            iframeWindow.module = { exports: undefined };
+            return ret;
+        }
+        else {
+            throw new Error(`Failed to load script: ${url}`, { cause: xhr });
+        }
+    };
+    return { globalWindow: iframeWindow, loadScript, loadScriptSync };
+}
+//# sourceMappingURL=createIFrameRealm.js.map

package/dist/client/mainthread/createMainThreadGlobalAPIs.d.ts

@@ -0,0 +1,3 @@
+import type { MainThreadGlobalAPIs } from '../../types/index.js';
+import { type LynxViewInstance } from './LynxViewInstance.js';
+export declare function createMainThreadGlobalAPIs(lynxViewInstance: LynxViewInstance): MainThreadGlobalAPIs;

package/dist/client/mainthread/createMainThreadGlobalAPIs.js

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2025 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 { templateManager } from './TemplateManager.js';
+import { systemInfo } from './LynxViewInstance.js';
+function createMainThreadLynx(lynxViewInstance) {
+    const requestAnimationFrameBrowserImpl = requestAnimationFrame;
+    const cancelAnimationFrameBrowserImpl = cancelAnimationFrame;
+    const setTimeoutBrowserImpl = setTimeout;
+    const clearTimeoutBrowserImpl = clearTimeout;
+    const setIntervalBrowserImpl = setInterval;
+    const clearIntervalBrowserImpl = clearInterval;
+    return {
+        getJSContext() {
+            return lynxViewInstance.backgroundThread.jsContext;
+        },
+        requestAnimationFrame(cb) {
+            return requestAnimationFrameBrowserImpl(cb);
+        },
+        cancelAnimationFrame(handler) {
+            return cancelAnimationFrameBrowserImpl(handler);
+        },
+        __globalProps: lynxViewInstance.globalprops,
+        getCustomSectionSync(key) {
+            return templateManager.getTemplate(lynxViewInstance.templateUrl)?.customSections?.[key]
+                ?.content;
+        },
+        markPipelineTiming: lynxViewInstance.backgroundThread.markTiming.bind(lynxViewInstance.backgroundThread),
+        SystemInfo: systemInfo,
+        setTimeout: setTimeoutBrowserImpl,
+        clearTimeout: clearTimeoutBrowserImpl,
+        setInterval: setIntervalBrowserImpl,
+        clearInterval: clearIntervalBrowserImpl,
+    };
+}
+export function createMainThreadGlobalAPIs(lynxViewInstance) {
+    let releaseSetting = '';
+    return {
+        __globalProps: lynxViewInstance.globalprops,
+        SystemInfo: systemInfo,
+        lynx: createMainThreadLynx(lynxViewInstance),
+        __OnLifecycleEvent: (data) => {
+            lynxViewInstance.backgroundThread.jsContext.dispatchEvent({
+                type: '__OnLifecycleEvent',
+                data,
+            });
+        },
+        __LoadLepusChunk: (path) => {
+            try {
+                path = lynxViewInstance.lepusCodeUrls.get(lynxViewInstance.templateUrl)?.[path] ?? path;
+                lynxViewInstance.mtsRealm.loadScriptSync(path);
+                return true;
+            }
+            catch (e) {
+                console.error(`failed to load lepus chunk ${path}`, e);
+                return false;
+            }
+        },
+        _AddEventListener: () => { }, // no-op for main thread
+        _ReportError: (err, _) => {
+            lynxViewInstance.reportError?.(err, releaseSetting, 'lepus.js');
+        },
+        _SetSourceMapRelease: (errInfo) => releaseSetting = errInfo?.release,
+        _I18nResourceTranslation: lynxViewInstance.i18nManager
+            ._I18nResourceTranslation.bind(lynxViewInstance.i18nManager),
+        __QueryComponent: (url, callback) => {
+            lynxViewInstance.queryComponent(url).then((lepusRootChunkExport) => {
+                callback?.({
+                    code: 0,
+                    data: {
+                        url,
+                        evalResult: lepusRootChunkExport,
+                    },
+                });
+            });
+            return null;
+        },
+    };
+}
+//# sourceMappingURL=createMainThreadGlobalAPIs.js.map

package/dist/client/mainthread/crossThreadHandlers/queryNodes.d.ts

@@ -0,0 +1,3 @@
+import { ErrorCode, IdentifierType } from '../../../constants.js';
+import type { LynxViewInstance } from '../LynxViewInstance.js';
+export declare function queryNodes(lynxViewInstance: LynxViewInstance, type: IdentifierType, identifier: string, component_id: string, first_only: boolean, root_unique_id: number | undefined, callback: (dom: Element) => void, error?: (code: ErrorCode) => void): void;

package/dist/client/mainthread/crossThreadHandlers/queryNodes.js

@@ -0,0 +1,74 @@
+// 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 { ErrorCode, IdentifierType } from '../../../constants.js';
+export function queryNodes(lynxViewInstance, type, identifier, component_id, first_only, root_unique_id, callback, error) {
+    let queryRoot = lynxViewInstance.rootDom;
+    if (root_unique_id) {
+        const root = lynxViewInstance.mtsWasmBinding.getElementByUniqueId(root_unique_id);
+        if (root) {
+            queryRoot = root;
+        }
+        else {
+            console.error(`[lynx-web] cannot find dom for root_unique_id: ${root_unique_id}`);
+            error?.(ErrorCode.NODE_NOT_FOUND);
+            return;
+        }
+    }
+    else if (component_id) {
+        const root = lynxViewInstance.mtsWasmBinding.getElementByComponentId(component_id);
+        if (root) {
+            queryRoot = root;
+        }
+        else {
+            console.error(`[lynx-web] cannot find dom for component_id: ${component_id}`);
+            error?.(ErrorCode.NODE_NOT_FOUND);
+            return;
+        }
+    }
+    let selector;
+    if (type === IdentifierType.ID_SELECTOR) {
+        selector = identifier;
+    }
+    else if (type === IdentifierType.UNIQUE_ID) {
+        const element = lynxViewInstance.mtsWasmBinding.getElementByUniqueId(Number(identifier));
+        if (element) {
+            callback(element);
+            return;
+        }
+        else {
+            console.error(`[lynx-web] cannot find dom for unique_id: ${identifier}`);
+            error?.(ErrorCode.NODE_NOT_FOUND);
+            return;
+        }
+    }
+    else {
+        console.error(`[lynx-web] NYI: setnativeprops type ${type}`);
+        error?.(ErrorCode.UNKNOWN);
+        return;
+    }
+    if (first_only) {
+        let targetElement = null;
+        try {
+            targetElement = queryRoot.querySelector(selector);
+        }
+        catch (e) {
+            console.error(`[lynx-web] cannot use selector: ${selector}`);
+            error?.(ErrorCode.SELECTOR_NOT_SUPPORTED);
+            return;
+        }
+        if (targetElement) {
+            callback(targetElement);
+        }
+        else {
+            console.error(`[lynx-web] cannot find from for selector ${identifier} under`, queryRoot);
+            error?.(ErrorCode.NODE_NOT_FOUND);
+        }
+    }
+    else {
+        queryRoot.querySelectorAll(selector).forEach((element) => {
+            callback(element);
+        });
+    }
+}
+//# sourceMappingURL=queryNodes.js.map

package/dist/client/mainthread/crossThreadHandlers/registerGetPathInfoHandler.d.ts

@@ -0,0 +1,3 @@
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+import type { LynxViewInstance } from '../LynxViewInstance.js';
+export declare function registerGetPathInfoHandler(rpc: Rpc, lynxViewInstance: LynxViewInstance): void;

package/dist/client/mainthread/crossThreadHandlers/registerGetPathInfoHandler.js

@@ -0,0 +1,51 @@
+// 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 { queryNodes } from './queryNodes.js';
+import { getPathInfoEndpoint } from '../../endpoints.js';
+import { ErrorCode } from '../../../constants.js';
+export function registerGetPathInfoHandler(rpc, lynxViewInstance) {
+    rpc.registerHandler(getPathInfoEndpoint, (type, identifier, component_id, first_only, root_unique_id) => {
+        let code = ErrorCode.UNKNOWN;
+        let data;
+        queryNodes(lynxViewInstance, type, identifier, component_id, first_only, root_unique_id, (element) => {
+            try {
+                const path = [];
+                let currentNode = element;
+                while (currentNode) {
+                    const parent = currentNode.parentElement;
+                    const parentNodeForChildren = parent ?? lynxViewInstance.rootDom;
+                    const children = Array.from(parentNodeForChildren.children);
+                    const tag = lynxViewInstance.mainThreadGlobalThis.__GetTag(currentNode);
+                    const index = tag === 'page' ? 0 : children.indexOf(currentNode);
+                    const id = currentNode.getAttribute('id') || undefined;
+                    const className = currentNode.getAttribute('class') || undefined;
+                    const dataSet = lynxViewInstance.mainThreadGlobalThis
+                        .__GetDataset(currentNode);
+                    path.push({
+                        tag,
+                        id,
+                        class: className,
+                        dataSet,
+                        index,
+                    });
+                    if (tag === 'page'
+                        || currentNode.parentNode === lynxViewInstance.rootDom) {
+                        break;
+                    }
+                    currentNode = parent;
+                }
+                data = { path };
+                code = ErrorCode.SUCCESS;
+            }
+            catch (e) {
+                console.error('[lynx-web] getPathInfo: failed with', e, element);
+                code = ErrorCode.UNKNOWN;
+            }
+        }, (error) => {
+            code = error;
+        });
+        return { code, data };
+    });
+}
+//# sourceMappingURL=registerGetPathInfoHandler.js.map

package/dist/client/mainthread/crossThreadHandlers/registerInvokeUIMethodHandler.d.ts

@@ -0,0 +1,3 @@
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+import type { LynxViewInstance } from '../LynxViewInstance.js';
+export declare function registerInvokeUIMethodHandler(rpc: Rpc, lynxViewInstance: LynxViewInstance): void;