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

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

@@ -0,0 +1,49 @@
+import { queryNodes } from './queryNodes.js';
+import { ErrorCode } from '../../../constants.js';
+import { invokeUIMethodEndpoint } from '../../endpoints.js';
+const methodAlias = {
+    'boundingClientRect': (element) => {
+        const rect = element.getBoundingClientRect();
+        return {
+            id: element.id,
+            width: rect.width,
+            height: rect.height,
+            left: rect.left,
+            right: rect.right,
+            top: rect.top,
+            bottom: rect.bottom,
+        };
+    },
+};
+export function registerInvokeUIMethodHandler(rpc, lynxViewInstance) {
+    rpc.registerHandler(invokeUIMethodEndpoint, (type, identifier, component_id, method, params, root_unique_id) => {
+        let code = ErrorCode.UNKNOWN;
+        let data = undefined;
+        queryNodes(lynxViewInstance, type, identifier, component_id, true, root_unique_id, (element) => {
+            try {
+                const aliasMethod = methodAlias[method];
+                const hasDomMethod = typeof element[method] === 'function';
+                if (!aliasMethod && !hasDomMethod) {
+                    code = ErrorCode.METHOD_NOT_FOUND;
+                }
+                else {
+                    if (aliasMethod) {
+                        data = aliasMethod(element, params);
+                    }
+                    else {
+                        data = element[method](params);
+                    }
+                    code = ErrorCode.SUCCESS;
+                }
+            }
+            catch (e) {
+                console.error(`[lynx-web] invokeUIMethod: apply method failed with`, e, element);
+                code = ErrorCode.PARAM_INVALID;
+            }
+        }, (error) => {
+            code = error;
+        });
+        return { code, data };
+    });
+}
+//# sourceMappingURL=registerInvokeUIMethodHandler.js.map

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

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

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

@@ -0,0 +1,8 @@
+import { dispatchNapiModuleEndpoint, napiModulesCallEndpoint, } from '../../endpoints.js';
+export function registerNapiModulesCallHandler(rpc, lynxViewInstance) {
+    const dispatchNapiModules = rpc.createCall(dispatchNapiModuleEndpoint);
+    rpc.registerHandler(napiModulesCallEndpoint, (name, data, moduleName) => {
+        return lynxViewInstance.parentDom.onNapiModulesCall?.(name, data, moduleName, dispatchNapiModules);
+    });
+}
+//# sourceMappingURL=registerNapiModulesCallHandler.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { nativeModulesCallEndpoint } from '../../endpoints.js';
+export function registerNativeModulesCallHandler(rpc, lynxViewInstance) {
+    rpc.registerHandler(nativeModulesCallEndpoint, (name, data, moduleName) => {
+        return lynxViewInstance.parentDom.onNativeModulesCall?.(name, data, moduleName);
+    });
+}
+//# sourceMappingURL=registerNativeModulesCallHandler.js.map

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

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

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

@@ -0,0 +1,20 @@
+// 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 { selectComponentEndpoint } from '../../endpoints.js';
+import { IdentifierType } from '../../../constants.js';
+export function registerSelectComponentHandler(rpc, lynxViewInstance) {
+    rpc.registerHandler(selectComponentEndpoint, (componentId, idSelector, single) => {
+        let element = null;
+        queryNodes(lynxViewInstance, IdentifierType.ID_SELECTOR, idSelector, componentId === 'card' ? '0' : componentId, single, undefined, (ele) => {
+            element = ele;
+        });
+        if (!element)
+            return [];
+        return [
+            lynxViewInstance.mainThreadGlobalThis.__GetComponentID(element),
+        ];
+    });
+}
+//# sourceMappingURL=registerSelectComponentHandler.js.map

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

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

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

@@ -0,0 +1,28 @@
+import { queryNodes } from './queryNodes.js';
+import { setNativePropsEndpoint } from '../../endpoints.js';
+function applyNativeProps(element, nativeProps) {
+    for (const key in nativeProps) {
+        const value = nativeProps[key];
+        if (key === 'text' && element?.tagName === 'X-TEXT') {
+            if (element.firstElementChild
+                && element.firstElementChild.tagName == 'RAW-TEXT') {
+                element = element.firstElementChild;
+            }
+        }
+        if (CSS.supports(key, value)
+            && element.style) {
+            element.style.setProperty(key, value);
+        }
+        else {
+            element.setAttribute(key, value);
+        }
+    }
+}
+export function registerNativePropsHandler(rpc, lynxViewInstance) {
+    rpc.registerHandler(setNativePropsEndpoint, (type, identifier, component_id, first_only, native_props, root_unique_id) => {
+        queryNodes(lynxViewInstance, type, identifier, component_id, first_only, root_unique_id, (element) => {
+            applyNativeProps(element, native_props);
+        });
+    });
+}
+//# sourceMappingURL=registerSetNativePropsHandler.js.map

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

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

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

@@ -0,0 +1,12 @@
+import { triggerComponentEventEndpoint } from '../../endpoints.js';
+export function registerTriggerComponentEventHandler(rpc, lynxViewInstance) {
+    rpc.registerHandler(triggerComponentEventEndpoint, (id, params) => {
+        const componentDom = lynxViewInstance.mtsWasmBinding
+            .getElementByComponentId(id);
+        componentDom?.dispatchEvent(new CustomEvent(id, {
+            ...params.eventOption,
+            detail: params.eventDetail,
+        }));
+    });
+}
+//# sourceMappingURL=registerTriggerComponentEventHandler.js.map

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

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

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

@@ -0,0 +1,29 @@
+import { triggerElementMethodEndpoint } from '../../endpoints.js';
+import { AnimationOperation } from '../../../constants.js';
+export function registerTriggerElementMethodEndpointHandler(rpc, lynxViewInstance) {
+    const animationMap = new Map();
+    rpc.registerHandler(triggerElementMethodEndpoint, (method, id, options) => {
+        if (method === 'animate') {
+            switch (options.operation) {
+                case AnimationOperation.START:
+                    animationMap.set(options.id, lynxViewInstance.rootDom.querySelector(id)?.animate(options.keyframes, options.timingOptions));
+                    break;
+                case AnimationOperation.PLAY:
+                    animationMap.get(options.id)?.play();
+                    break;
+                case AnimationOperation.PAUSE:
+                    animationMap.get(options.id)?.pause();
+                    break;
+                case AnimationOperation.CANCEL:
+                    animationMap.get(options.id)?.cancel();
+                    animationMap.delete(options.id);
+                    break;
+                case AnimationOperation.FINISH:
+                    animationMap.get(options.id)?.finish();
+                    animationMap.delete(options.id);
+                    break;
+            }
+        }
+    });
+}
+//# sourceMappingURL=registerTriggerElementMethodEndpointHandler.js.map

package/dist/client/mainthread/elementAPIs/WASMJSBinding.d.ts

@@ -0,0 +1,38 @@
+import type { LynxCrossThreadEvent, LynxCrossThreadEventTarget, DecoratedHTMLElement, RustMainthreadContextBinding, CloneableObject, MainThreadGlobalThis } from '../../../types/index.js';
+import type { MainThreadWasmContext } from '../../wasm.js';
+import type { BackgroundThread } from '../Background.js';
+import type { ExposureServices } from '../ExposureServices.js';
+import type { StyleManager } from '../StyleManager.js';
+export type WASMJSBindingInjectedHandler = {
+    rootDom: ShadowRoot;
+    backgroundThread: BackgroundThread;
+    exposureServices: ExposureServices;
+    loadWebElement: (elementId: number) => void;
+    loadUnknownElement: (tagName: string) => void;
+    mainThreadGlobalThis: MainThreadGlobalThis;
+    styleManager?: StyleManager;
+};
+export declare class WASMJSBinding implements RustMainthreadContextBinding {
+    #private;
+    readonly lynxViewInstance: WASMJSBindingInjectedHandler;
+    wasmContext: InstanceType<MainThreadWasmContext> | undefined;
+    uniqueIdToElement: (HTMLElement | undefined)[];
+    toBeEnabledElement: Set<HTMLElement>;
+    toBeDisabledElement: Set<HTMLElement>;
+    constructor(lynxViewInstance: WASMJSBindingInjectedHandler);
+    markExposureRelatedElementByUniqueId(uniqueId: number, toEnable: boolean): void;
+    loadInternalWebElement: (elementId: number) => void;
+    loadUnknownElement: (tagName: string) => void;
+    generateTargetObject(element: DecoratedHTMLElement, dataset: CloneableObject): LynxCrossThreadEventTarget;
+    getElementByUniqueId(uniqueId: number): HTMLElement | undefined;
+    getElementByComponentId(componentId: string): HTMLElement | undefined;
+    runWorklet(handler: {
+        value: unknown;
+    }, eventObject: LynxCrossThreadEvent, targetUniqueId: number, targetDataset: Record<string, string>, currentTargetUniqueId: number, currentTargetDataset: Record<string, string>): void;
+    publishEvent(handlerName: string, parentComponentId: string | undefined, eventObject: LynxCrossThreadEvent, targetUniqueId: number, targetDataset: CloneableObject, currentTargetUniqueId: number, currentTargetDataset: CloneableObject): void;
+    addEventListener(eventName: string): void;
+    postTimingFlags(flags: string[], pipelineId?: string): void;
+    updateExposureStatus(enabledExposureElements: HTMLElement[], disabledExposureElements: HTMLElement[]): void;
+    enableElementEvent(uniqueId: number, eventName: string): void;
+    disableElementEvent(uniqueId: number, eventName: string): void;
+}

package/dist/client/mainthread/elementAPIs/WASMJSBinding.js

@@ -0,0 +1,122 @@
+import { createCrossThreadEvent } from './createCrossThreadEvent.js';
+import { LynxEventNameToW3cCommon, uniqueIdSymbol, } from '../../../constants.js';
+import { __GetElementUniqueID } from './pureElementPAPIs.js';
+export class WASMJSBinding {
+    lynxViewInstance;
+    wasmContext;
+    uniqueIdToElement = [undefined];
+    toBeEnabledElement = new Set();
+    toBeDisabledElement = new Set();
+    constructor(lynxViewInstance) {
+        this.lynxViewInstance = lynxViewInstance;
+        this.loadInternalWebElement = this.lynxViewInstance.loadWebElement.bind(this.lynxViewInstance);
+        this.loadUnknownElement = this.lynxViewInstance.loadUnknownElement.bind(this.lynxViewInstance);
+    }
+    markExposureRelatedElementByUniqueId(uniqueId, toEnable) {
+        const dom = this.uniqueIdToElement[uniqueId];
+        if (dom) {
+            if (toEnable) {
+                this.toBeDisabledElement.delete(dom);
+                this.toBeEnabledElement.add(dom);
+            }
+            else {
+                this.toBeEnabledElement.delete(dom);
+                this.toBeDisabledElement.add(dom);
+            }
+        }
+    }
+    loadInternalWebElement;
+    loadUnknownElement;
+    generateTargetObject(element, dataset) {
+        const uniqueId = element[uniqueIdSymbol];
+        return {
+            dataset: Object.assign(Object.create(null), dataset),
+            id: element.id || null,
+            uniqueId,
+        };
+    }
+    getElementByUniqueId(uniqueId) {
+        return this.uniqueIdToElement[uniqueId];
+    }
+    getElementByComponentId(componentId) {
+        const uniqueId = this.wasmContext?.__wasm_get_unique_id_by_component_id(componentId);
+        if (uniqueId != undefined) {
+            return this.getElementByUniqueId(uniqueId);
+        }
+        return undefined;
+    }
+    runWorklet(handler, eventObject, targetUniqueId, targetDataset, currentTargetUniqueId, currentTargetDataset) {
+        const target = this.getElementByUniqueId(targetUniqueId);
+        const currentTarget = this.getElementByUniqueId(currentTargetUniqueId);
+        eventObject.target = this.generateTargetObject(target, targetDataset);
+        eventObject.currentTarget = this.generateTargetObject(currentTarget, currentTargetDataset);
+        // @ts-expect-error
+        eventObject.target.elementRefptr = target;
+        // @ts-expect-error
+        eventObject.currentTarget.elementRefptr = currentTarget;
+        this.lynxViewInstance.mainThreadGlobalThis.runWorklet?.(handler.value, [
+            eventObject,
+        ]);
+    }
+    publishEvent(handlerName, parentComponentId, eventObject, targetUniqueId, targetDataset, currentTargetUniqueId, currentTargetDataset) {
+        const target = this.getElementByUniqueId(targetUniqueId);
+        const currentTarget = this.getElementByUniqueId(currentTargetUniqueId);
+        eventObject.target = this.generateTargetObject(target, targetDataset);
+        eventObject.currentTarget = this.generateTargetObject(currentTarget, currentTargetDataset);
+        if (parentComponentId) {
+            this.lynxViewInstance?.backgroundThread.publicComponentEvent(parentComponentId, handlerName, eventObject);
+        }
+        else {
+            this.lynxViewInstance.backgroundThread.publishEvent(handlerName, eventObject);
+        }
+    }
+    #commonEventHandler = (event) => {
+        const target = event.target;
+        let bubblePath = new Uint32Array(32);
+        let bubblePathLength = 0;
+        bubblePath;
+        let currentTarget = target;
+        while (currentTarget) {
+            if (currentTarget === this.lynxViewInstance.rootDom) {
+                break;
+            }
+            const uniqueId = __GetElementUniqueID(currentTarget);
+            bubblePath[bubblePathLength++] = uniqueId;
+            if (bubblePathLength >= bubblePath.length) {
+                const newBubblePath = new Uint32Array(bubblePath.length * 2);
+                newBubblePath.set(bubblePath);
+                bubblePath = newBubblePath;
+            }
+            currentTarget = currentTarget.parentElement;
+        }
+        const eventObject = createCrossThreadEvent(event);
+        this.wasmContext?.__wasm_commonEventHandler(eventObject, bubblePath.slice(0, bubblePathLength), eventObject.type);
+    };
+    addEventListener(eventName) {
+        this.lynxViewInstance.rootDom.addEventListener(LynxEventNameToW3cCommon[eventName] ?? eventName, this.#commonEventHandler, {
+            passive: true,
+            capture: true,
+        });
+    }
+    postTimingFlags(flags, pipelineId) {
+        this.lynxViewInstance.backgroundThread.postTimingFlags(flags, pipelineId);
+    }
+    updateExposureStatus(enabledExposureElements, disabledExposureElements) {
+        this.lynxViewInstance.exposureServices.updateExposureStatus(enabledExposureElements, disabledExposureElements);
+    }
+    enableElementEvent(uniqueId, eventName) {
+        const element = this.getElementByUniqueId(uniqueId);
+        if (element) {
+            // @ts-expect-error
+            element.enableEvent?.(LynxEventNameToW3cCommon[eventName] ?? eventName);
+        }
+    }
+    disableElementEvent(uniqueId, eventName) {
+        const element = this.getElementByUniqueId(uniqueId);
+        if (element) {
+            // @ts-expect-error
+            element.disableEvent?.(LynxEventNameToW3cCommon[eventName] ?? eventName);
+        }
+    }
+}
+//# sourceMappingURL=WASMJSBinding.js.map

package/dist/client/mainthread/elementAPIs/createCrossThreadEvent.d.ts

@@ -0,0 +1,2 @@
+import type { LynxCrossThreadEvent, MinimalRawEventObject } from '../../../types/index.js';
+export declare function createCrossThreadEvent(domEvent: MinimalRawEventObject): LynxCrossThreadEvent;

package/dist/client/mainthread/elementAPIs/createCrossThreadEvent.js

@@ -0,0 +1,77 @@
+import { W3cEventNameToLynx } from '../../../constants.js';
+function toCloneableObject(obj) {
+    const cloneableObj = {};
+    for (const key in obj) {
+        const value = obj[key];
+        if (typeof value === 'boolean' || typeof value === 'number'
+            || typeof value === 'string' || value === null) {
+            cloneableObj[key] = value;
+        }
+    }
+    return cloneableObj;
+}
+export function createCrossThreadEvent(domEvent) {
+    const type = domEvent.type;
+    const params = {};
+    const isTrusted = domEvent.isTrusted;
+    const otherProperties = {};
+    let detail = domEvent.detail ?? {};
+    if (type.match(/^transition/)) {
+        Object.assign(params, {
+            'animation_type': 'keyframe-animation',
+            'animation_name': domEvent.propertyName,
+            new_animator: true, // we support the new_animator only
+        });
+    }
+    else if (type.match(/animation/)) {
+        Object.assign(params, {
+            'animation_type': 'keyframe-animation',
+            'animation_name': domEvent.animationName,
+            new_animator: true, // we support the new_animator only
+        });
+    }
+    else if (type.startsWith('touch')) {
+        const touchEvent = domEvent;
+        const touch = [...touchEvent.touches];
+        const targetTouches = [...touchEvent.targetTouches];
+        const changedTouches = [...touchEvent.changedTouches];
+        Object.assign(otherProperties, {
+            touches: isTrusted ? touch.map(toCloneableObject) : touch,
+            targetTouches: isTrusted
+                ? targetTouches.map(toCloneableObject)
+                : targetTouches,
+            changedTouches: isTrusted
+                ? changedTouches.map(toCloneableObject)
+                : changedTouches,
+        });
+    }
+    else if (type.startsWith('mouse')) {
+        const mouseEvent = domEvent;
+        Object.assign(otherProperties, {
+            button: mouseEvent.button,
+            buttons: mouseEvent.buttons,
+            x: mouseEvent.x,
+            y: mouseEvent.y,
+            pageX: mouseEvent.pageX,
+            pageY: mouseEvent.pageY,
+            clientX: mouseEvent.clientX,
+            clientY: mouseEvent.clientY,
+        });
+    }
+    else if (type === 'click') {
+        detail = {
+            x: domEvent.x,
+            y: domEvent.y,
+        };
+    }
+    const lynxEventName = W3cEventNameToLynx[type] ?? type;
+    return {
+        type: lynxEventName,
+        timestamp: domEvent.timeStamp,
+        // @ts-expect-error
+        detail,
+        params,
+        ...otherProperties,
+    };
+}
+//# sourceMappingURL=createCrossThreadEvent.js.map

package/dist/client/mainthread/elementAPIs/createElementAPI.d.ts

@@ -0,0 +1,3 @@
+import type { ElementPAPIs } from '../../../types/index.js';
+import type { WASMJSBinding } from './WASMJSBinding.js';
+export declare function createElementAPI(entryTemplateUrl: string, rootDom: ShadowRoot, mtsBinding: WASMJSBinding, config_enable_css_selector: boolean, config_default_display_linear: boolean, config_default_overflow_visible: boolean): ElementPAPIs;