@lynx-js/web-mainthread-apis 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @lynx-js/web-mainthread-apis
 
+## 0.11.0
+
+### Patch Changes
+
+- feat: support mts event handler (1/n) ([#495](https://github.com/lynx-family/lynx-stack/pull/495))
+
+  now the main-thread:bind handler could be invoked. The params of the handler will be implemented later.
+
+- Updated dependencies [[`ea42e62`](https://github.com/lynx-family/lynx-stack/commit/ea42e62fbcd5c743132c3e6e7c4851770742d544), [`a0f5ca4`](https://github.com/lynx-family/lynx-stack/commit/a0f5ca4ea0895ccbaa6aa63f449f53a677a1cf73)]:
+  - @lynx-js/web-constants@0.11.0
+
+## 0.10.1
+
+### Patch Changes
+
+- Updated dependencies [[`1af3b60`](https://github.com/lynx-family/lynx-stack/commit/1af3b6052ab27f98bf0e4d1b0ec9f7d9e88e0afc)]:
+  - @lynx-js/web-constants@0.10.1
+
 ## 0.10.0
 
 ### Minor Changes

package/dist/MainThreadLynx.d.ts

@@ -1,5 +1,6 @@
 import { type MainThreadConfig, MainThreadRuntime } from './MainThreadRuntime.js';
 export declare function createMainThreadLynx(config: MainThreadConfig, lepusRuntime: MainThreadRuntime): {
+    getJSContext(): EventTarget;
     requestAnimationFrame(cb: FrameRequestCallback): number;
     cancelAnimationFrame(handler: number): void;
     __globalProps: unknown;

package/dist/MainThreadLynx.js

@@ -1,6 +1,10 @@
 import { MainThreadRuntime, } from './MainThreadRuntime.js';
 export function createMainThreadLynx(config, lepusRuntime) {
     return {
+        getJSContext() {
+            // TODO: implement this
+            return new EventTarget();
+        },
         requestAnimationFrame(cb) {
             return requestAnimationFrame(cb);
         },
@@ -11,9 +15,9 @@ export function createMainThreadLynx(config, lepusRuntime) {
         requireModule(path) {
             // @ts-expect-error
             if (self.WorkerGlobalScope) {
-                const mainfestUrl = config.lepusCode[`/${path}`];
-                if (mainfestUrl)
-                    path = mainfestUrl;
+                const lepusChunkUrl = config.lepusCode[`${path}`];
+                if (lepusChunkUrl)
+                    path = lepusChunkUrl;
                 // @ts-expect-error
                 importScripts(path);
                 const entry = globalThis.module.exports;
@@ -24,9 +28,9 @@ export function createMainThreadLynx(config, lepusRuntime) {
             }
         },
         requireModuleAsync(path, callback) {
-            const mainfestUrl = config.lepusCode[`/${path}`];
-            if (mainfestUrl)
-                path = mainfestUrl;
+            const lepusChunkUrl = config.lepusCode[`${path}`];
+            if (lepusChunkUrl)
+                path = lepusChunkUrl;
             import(
             /* webpackIgnore: true */
             path).catch(callback).then(() => {

package/dist/MainThreadRuntime.d.ts

@@ -1,11 +1,11 @@
-import { type LynxTemplate, type PageConfig, type ProcessDataCallback, type StyleInfo, type FlushElementTreeOptions, type Cloneable, type BrowserConfig, type publishEventEndpoint, type publicComponentEventEndpoint, type reportErrorEndpoint, type onLifecycleEventEndpoint, type RpcCallType, type postExposureEndpoint } from '@lynx-js/web-constants';
+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 } 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: RpcCallType<typeof onLifecycleEventEndpoint>;
+    __OnLifecycleEvent: (lifeCycleEvent: Cloneable) => void;
     markTiming: (pipelineId: string, timingKey: string) => void;
     publishEvent: RpcCallType<typeof publishEventEndpoint>;
     publicComponentEvent: RpcCallType<typeof publicComponentEventEndpoint>;
@@ -74,9 +74,11 @@ export declare class MainThreadRuntime {
     processData?: ProcessDataCallback;
     renderPage: (data: unknown) => void;
     _ReportError: RpcCallType<typeof reportErrorEndpoint>;
-    __OnLifecycleEvent: RpcCallType<typeof onLifecycleEventEndpoint>;
+    __OnLifecycleEvent: (lifeCycleEvent: Cloneable) => void;
     __LoadLepusChunk: (path: string) => boolean;
     __FlushElementTree: (_subTree: unknown, options: FlushElementTreeOptions) => void;
     updatePage?: (data: Cloneable, options?: Record<string, string>) => void;
-    _updateVars?: () => void;
+    runWorklet?: (obj: unknown, event: unknown) => void;
+    private __varsUpdateHandlers;
+    set _updateVars(handler: () => void);
 }

package/dist/MainThreadRuntime.js

@@ -98,7 +98,9 @@ export class MainThreadRuntime {
                 },
                 set: (v) => {
                     this.__lynxGlobalBindingValues[nm] = v;
-                    this._updateVars?.();
+                    for (const handler of this.__varsUpdateHandlers) {
+                        handler();
+                    }
                 },
             });
         }
@@ -150,6 +152,10 @@ export class MainThreadRuntime {
         this.config.callbacks.flushElementTree(options, timingFlags);
     };
     updatePage;
-    _updateVars;
+    runWorklet;
+    __varsUpdateHandlers = [];
+    set _updateVars(handler) {
+        this.__varsUpdateHandlers.push(handler);
+    }
 }
 //# sourceMappingURL=MainThreadRuntime.js.map

package/dist/elementAPI/ElementThreadElement.d.ts

@@ -7,11 +7,17 @@ export interface LynxRuntimeInfo {
     eventHandlerMap: Record<string, {
         capture: {
             type: LynxEventType;
-            handler: string;
+            handler: string | {
+                type: 'worklet';
+                value: unknown;
+            };
         } | undefined;
         bind: {
             type: LynxEventType;
-            handler: string;
+            handler: string | {
+                type: 'worklet';
+                value: unknown;
+            };
         } | undefined;
     }>;
     componentAtIndex?: ComponentAtIndexCallback;

package/dist/elementAPI/event/eventFunctions.d.ts

@@ -1,12 +1,21 @@
-import { type LynxCrossThreadEvent, type LynxEventType } from '@lynx-js/web-constants';
+import { type LynxEventType } from '@lynx-js/web-constants';
 import { type MainThreadRuntime } from '../../MainThreadRuntime.js';
 export declare function createEventFunctions(runtime: MainThreadRuntime): {
-    __AddEvent: (element: HTMLElement, eventType: LynxEventType, eventName: string, newEventHandler: string | undefined) => void;
-    __GetEvent: (element: HTMLElement, eventName: string, eventType: LynxEventType) => string | ((ev: LynxCrossThreadEvent) => void) | undefined;
+    __AddEvent: (element: HTMLElement, eventType: LynxEventType, eventName: string, newEventHandler: string | {
+        type: "worklet";
+        value: unknown;
+    } | undefined) => void;
+    __GetEvent: (element: HTMLElement, eventName: string, eventType: LynxEventType) => string | {
+        type: "worklet";
+        value: unknown;
+    } | undefined;
     __GetEvents: (element: HTMLElement) => {
         type: LynxEventType;
         name: string;
-        function: string | ((ev: Event) => void) | undefined;
+        function: string | {
+            type: "worklet";
+            value: unknown;
+        } | undefined;
     }[];
     __SetEvents: (element: HTMLElement, listeners: {
         type: LynxEventType;

package/dist/elementAPI/event/eventFunctions.js

@@ -18,7 +18,7 @@ export function createEventFunctions(runtime) {
                 ?.handler
             : runtimeInfo.eventHandlerMap[lynxEventName]?.bind
                 ?.handler;
-        if (hname) {
+        if (typeof hname === 'string') {
             const crossThreadEvent = createCrossThreadEvent(runtime, event, lynxEventName);
             const parentComponentUniqueId = runtimeInfo.parentComponentUniqueId;
             const parentComponent = runtime[getElementByUniqueId](Number(parentComponentUniqueId));
@@ -33,6 +33,9 @@ export function createEventFunctions(runtime) {
             }
             return true;
         }
+        else if (hname) {
+            runtime.runWorklet?.(hname.value, []);
+        }
         return false;
     };
     const btsCatchHandler = (event) => {
@@ -40,8 +43,7 @@ export function createEventFunctions(runtime) {
         if (handlerTriggered)
             event.stopPropagation();
     };
-    function __AddEvent(element, eventType, eventName, newEventHandler // | ((ev: LynxCrossThreadEvent) => void) | undefined,
-    ) {
+    function __AddEvent(element, eventType, eventName, newEventHandler) {
         eventName = eventName.toLowerCase();
         const isCatch = eventType === 'catchEvent' || eventType === 'capture-catch';
         const isCapture = eventType.startsWith('capture');
@@ -106,14 +108,13 @@ export function createEventFunctions(runtime) {
         for (const [lynxEventName, info] of Object.entries(eventHandlerMap)) {
             for (const atomInfo of [info.bind, info.capture]) {
                 if (atomInfo) {
-                    for (const [type, handler] of Object.values(atomInfo)) {
-                        if (handler) {
-                            eventInfos.push({
-                                type: type,
-                                name: lynxEventName,
-                                function: handler,
-                            });
-                        }
+                    const { type, handler } = atomInfo;
+                    if (handler) {
+                        eventInfos.push({
+                            type: type,
+                            name: lynxEventName,
+                            function: handler,
+                        });
                     }
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lynx-js/web-mainthread-apis",
-  "version": "0.10.0",
+  "version": "0.11.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.10.0",
+    "@lynx-js/web-constants": "0.11.0",
     "@lynx-js/web-style-transformer": "0.2.3"
   }
 }