@lynx-js/types 3.3.1 → 3.3.2

package/types/common/element/textarea.d.ts

@@ -0,0 +1,411 @@
+import { BaseEvent, BaseMethod, Callback } from '../events';
+import { StandardProps } from '../props';
+
+
+export interface TextAreaInputEvent {
+  /**
+   * Input content
+   * @Android
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  value: string;
+  /**
+   * The start position of the selection
+   * @Android
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  selectionStart: number;
+  /**
+   * The end position of the selection
+   * @Android
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  selectionEnd: number;
+  /**
+   * Is composing or not
+   * @iOS
+   * @Web
+   * @Android
+   * @Harmony
+   * @since 3.4
+   */
+  isComposing?: boolean;
+}
+
+export interface TextAreaFocusEvent {
+  /**
+   * Input content
+   * @Android
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  value: string;
+}
+
+export interface TextAreaBlurEvent {
+  /**
+   * Input content
+   * @Android
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  value: string;
+}
+
+export interface TextAreaConfirmEvent {
+  /**
+   * Input content
+   * @Android
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  value: string;
+}
+
+export interface TextAreaSelectionChangeEvent {
+  /**
+   * The start position of the selection
+   * @Android
+   * @iOS
+   * @Harmony
+     * @Web
+   * @since 3.4
+   */
+  selectionStart: number;
+  /**
+   * The end position of the selection
+   * @Android
+   * @iOS
+   * @Harmony
+     * @Web
+   * @since 3.4
+   */
+  selectionEnd: number;
+}
+
+export interface TextAreaProps extends Omit<StandardProps, 'bindfocus' | 'bindblur'> {
+  /**
+   * Placeholder
+   * @Android
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  placeholder?: string
+  /**
+   * The type of confirm button
+   * @defaultValue 'done'
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  'confirm-type'?: 'send' | 'search' | 'go' | 'done' | 'next';
+  /**
+   * Max input length
+   * @defaultValue 140
+   * @Android
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  maxlength?: number;
+  /**
+   * Max input lines
+   * @defaultValue undefined
+   * @Android
+   * @iOS
+   * @Harmony
+   * @since 3.4
+   */
+  maxlines?: number;
+  /**
+   * Bounce effect for iOS
+   * @defaultValue true
+   * @iOS
+   * @since 3.4
+   */
+  bounces?: boolean;
+  /**
+   * Line spacing
+   * @defaultValue undefined
+   * @iOS
+   * @Android
+   * @since 3.4
+   */
+  'line-spacing'?: number | `${number}px` | `${number}rpx`;
+  /**
+   * Readonly
+   * @defaultValue false
+   * @Android
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  readonly?: boolean;
+
+  /**
+   * Interaction enabled
+   * @defaultValue false
+   * @Android
+   * @iOS
+   * @Harmony
+   * @since 3.5
+   */
+  disabled?: boolean;
+
+  /**
+   * Show soft input keyboard while focused
+   * @defaultValue true
+   * @Android
+   * @iOS
+   * @since 3.4
+   */
+  'show-soft-input-on-focus'?: boolean;
+
+  /**
+   * Filter the input content and process it in the form of regular expressions
+   * @defaultValue undefined
+   * @Android
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  'input-filter'?: string;
+
+  /**
+   * Input content type
+   * @defaultValue "text"
+   * @Android
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  type?: 'text' | 'number' | 'digit' | 'tel' | 'email';
+
+  /**
+   * Auto correct input content on iOS
+   * @defaultValue true
+   * @iOS
+   * @since 3.4
+   */
+  'ios-auto-correct'?: boolean;
+
+  /**
+   * Check spelling issue on iOS
+   * @defaultValue true
+   * @iOS
+   * @Web
+   * @since 3.4
+   */
+  'ios-spell-check'?: boolean;
+
+  /**
+   * Whether to enter the full-screen input mode when in landscape screen, in which the keyboard and input box will take up the entire screen
+   * @defaultValue true
+   * @Android
+   * @since 3.4
+   */
+  'android-fullscreen-mode'?: boolean;
+
+  /**
+   * Focused
+   * @Android
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  bindfocus?: (e: BaseEvent<'bindfocus', TextAreaFocusEvent>) => void;
+
+  /**
+   * Blurred
+   * @Android
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  bindblur?: (e: BaseEvent<'bindblur', TextAreaBlurEvent>) => void;
+
+  /**
+   * Input content changed
+   * @Android
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  bindinput?: (e: BaseEvent<'bindinput', TextAreaInputEvent>) => void;
+
+  /**
+   * Input selection changed
+   * @Android
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  bindselection?: (e: BaseEvent<'bindselection', TextAreaSelectionChangeEvent>) => void;
+
+  /**
+   * Confirm button clicked, only work when confirm-type is defined
+   * @Android
+   * @iOS
+   * @Harmony
+   * @Web
+   * @since 3.4
+   */
+  bindconfirm?: (e: BaseEvent<'bindconfirm', TextAreaConfirmEvent>) => void;
+}
+
+/**
+ * Require focus
+ * @Android
+ * @iOS
+ * @Harmony
+ * @Web
+ * @since 3.4
+ */
+export interface TextAreaFocusMethod extends BaseMethod {
+  method: 'focus';
+}
+
+/**
+ * Release focus
+ * @Android
+ * @iOS
+ * @Harmony
+ * @Web
+ * @since 3.4
+ */
+export interface TextAreaBlurMethod extends BaseMethod {
+  method: 'blur';
+}
+
+/**
+ * Get input content
+ * @Android
+ * @iOS
+ * @Harmony
+ * @Web
+ * @since 3.4
+ */
+export interface TextAreaGetValueMethod extends BaseMethod {
+  method: 'getValue';
+  success?: Callback<{
+    /**
+     * Input content
+     * @Android
+     * @iOS
+     * @Harmony
+     * @Web
+     * @since 3.4
+     */
+    value: string;
+    /**
+     * Begin position of the cursor
+     * @Android
+     * @iOS
+     * @Harmony
+     * @Web
+     * @since 3.4
+     */
+    selectionStart: number;
+    /**
+     * End position of the cursor
+     * @Android
+     * @iOS
+     * @Harmony
+     * @Web
+     * @since 3.4
+     */
+    selectionEnd: number;
+    /**
+     * Is composing or not, iOS only
+     * @iOS
+     * @Android
+     * @Harmony
+     * @Web
+     * @since 3.4
+     */
+    isComposing: boolean;
+  }>;
+}
+
+/**
+ * Set input content
+ * @Android
+ * @iOS
+ * @Harmony
+ * @Web
+ * @since 3.4
+ */
+export interface TextAreaSetValueMethod extends BaseMethod {
+  method: 'setValue';
+  params: {
+    /**
+     * Input content
+     * @Android
+     * @iOS
+     * @Harmony
+     * @Web
+     * @since 3.4
+     */
+    value: string;
+  };
+}
+
+/**
+ * Set selection range
+ * @Android
+ * @iOS
+ * @Harmony
+ * @Web
+ * @since 3.4
+ */
+export interface TextAreaSetSelectionRangeMethod extends BaseMethod {
+  method: 'setSelectionRange';
+  params: {
+    /**
+     * Start position of the selection
+     * @Android
+     * @iOS
+     * @Harmony
+     * @Web
+     * @since 3.4
+     */
+    selectionStart: number;
+    /**
+     * End position of the selection
+     * @Android
+     * @iOS
+     * @Harmony
+     * @Web
+     * @since 3.4
+     */
+    selectionEnd: number;
+  };
+}
+
+export type TextAreaUIMethods = TextAreaFocusMethod | TextAreaBlurMethod | TextAreaGetValueMethod | TextAreaSetValueMethod | TextAreaSetSelectionRangeMethod;

package/types/common/events.d.ts

@@ -80,9 +80,9 @@ export interface BaseTouchEvent<T> extends BaseEventOrig<any, T> {
   changedTouches: Array<Touch>;
 
   detail: {
-    /** The current position of the touch point relative to the touched element's x-coordinate. */
+    /** The current position of the touch point relative to the page's x-coordinate. */
     x: number;
-    /** The current position of the touch point relative to the touched element's y-coordinate. */
+    /** The current position of the touch point relative to the page's y-coordinate. */
     y: number;
   }
 }
@@ -173,33 +173,25 @@ export interface BaseTransitionEvent<T> extends BaseEventOrig<{}, T> {
 export interface TransitionEvent extends BaseTransitionEvent<Target> {}
 
 export interface BaseImageLoadEvent<T> extends BaseEventOrig<{}, T> {
-  detail: {
     width: number;
     height: number;
-  };
 }
 
 export interface ImageLoadEvent extends BaseImageLoadEvent<Target> {
-  detail: {
     width: number;
     height: number;
-  };
 }
 
 export interface BaseImageErrorEvent<T> extends BaseEventOrig<{}, T> {
-  detail: {
     errMsg: string;
     error_code: number;
     lynx_categorized_code: number;
-  };
 }
 
 export interface ImageErrorEvent extends BaseImageErrorEvent<Target> {
-  detail: {
     errMsg: string;
     error_code: number;
     lynx_categorized_code: number;
-  };
 }
 
 export interface TextLineInfo {
@@ -217,6 +209,12 @@ export interface TextLayoutEventDetail {
   };
 }
 
+export interface TextSelectionChangeEventDetail {
+  start: number;
+  end: number;
+  direction: 'forward' | 'backward';
+}
+
 export interface AccessibilityActionDetailEvent<T> extends BaseEventOrig<{}, T> {
   detail: {
     /**
@@ -448,11 +446,83 @@ export interface LynxBindCatchEvent<T = any> {
   LongTap?: EventHandler<BaseTouchEvent<T>>;
 }
 
-export type LynxEventPropsBase<T> = {
-  [K in keyof LynxEvent<T> as Lowercase<`bind${K}` | `catch${K}` | `capture-bind${K}` | `capture-catch${K}` | `global-bind${K}`>]: LynxEvent<T>[K];
-} & {
-  [K in keyof LynxBindCatchEvent<T> as Lowercase<`bind${K}` | `catch${K}` | `capture-bind${K}` | `capture-catch${K}` | `global-bind${K}`>]: LynxBindCatchEvent<T>[K];
-};
+type PrefixedEvent<E> = {
+  bind?: E;
+  catch?: E;
+  'capture-bind'?: E;
+  'capture-catch'?: E;
+  'global-bind'?: E;
+}
+
+// Helper interfaces for each event, providing explicit properties
+// for bind, catch, capture-bind, capture-catch, and global-bind prefixes.
+interface BGLoadProps<T> { bindbgload?: LynxEvent<T>['BGLoad']; catchbgload?: LynxEvent<T>['BGLoad']; 'capture-bindbgload'?: LynxEvent<T>['BGLoad']; 'capture-catchbgload'?: LynxEvent<T>['BGLoad']; 'global-bindbgload'?: LynxEvent<T>['BGLoad']; }
+interface BGErrorProps<T> { bindbgerror?: LynxEvent<T>['BGError']; catchbgerror?: LynxEvent<T>['BGError']; 'capture-bindbgerror'?: LynxEvent<T>['BGError']; 'capture-catchbgerror'?: LynxEvent<T>['BGError']; 'global-bindbgerror'?: LynxEvent<T>['BGError']; }
+interface TouchStartProps<T> { bindtouchstart?: LynxEvent<T>['TouchStart']; catchtouchstart?: LynxEvent<T>['TouchStart']; 'capture-bindtouchstart'?: LynxEvent<T>['TouchStart']; 'capture-catchtouchstart'?: LynxEvent<T>['TouchStart']; 'global-bindtouchstart'?: LynxEvent<T>['TouchStart']; }
+interface TouchMoveProps<T> { bindtouchmove?: LynxEvent<T>['TouchMove']; catchtouchmove?: LynxEvent<T>['TouchMove']; 'capture-bindtouchmove'?: LynxEvent<T>['TouchMove']; 'capture-catchtouchmove'?: LynxEvent<T>['TouchMove']; 'global-bindtouchmove'?: LynxEvent<T>['TouchMove']; }
+interface TouchCancelProps<T> { bindtouchcancel?: LynxEvent<T>['TouchCancel']; catchtouchcancel?: LynxEvent<T>['TouchCancel']; 'capture-bindtouchcancel'?: LynxEvent<T>['TouchCancel']; 'capture-catchtouchcancel'?: LynxEvent<T>['TouchCancel']; 'global-bindtouchcancel'?: LynxEvent<T>['TouchCancel']; }
+interface TouchEndProps<T> { bindtouchend?: LynxEvent<T>['TouchEnd']; catchtouchend?: LynxEvent<T>['TouchEnd']; 'capture-bindtouchend'?: LynxEvent<T>['TouchEnd']; 'capture-catchtouchend'?: LynxEvent<T>['TouchEnd']; 'global-bindtouchend'?: LynxEvent<T>['TouchEnd']; }
+interface LongPressProps<T> { bindlongpress?: LynxEvent<T>['LongPress']; catchlongpress?: LynxEvent<T>['LongPress']; 'capture-bindlongpress'?: LynxEvent<T>['LongPress']; 'capture-catchlongpress'?: LynxEvent<T>['LongPress']; 'global-bindlongpress'?: LynxEvent<T>['LongPress']; }
+interface TransitionStartProps<T> { bindtransitionstart?: LynxEvent<T>['TransitionStart']; catchtransitionstart?: LynxEvent<T>['TransitionStart']; 'capture-bindtransitionstart'?: LynxEvent<T>['TransitionStart']; 'capture-catchtransitionstart'?: LynxEvent<T>['TransitionStart']; 'global-bindtransitionstart'?: LynxEvent<T>['TransitionStart']; }
+interface TransitionCancelProps<T> { bindtransitioncancel?: LynxEvent<T>['TransitionCancel']; catchtransitioncancel?: LynxEvent<T>['TransitionCancel']; 'capture-bindtransitioncancel'?: LynxEvent<T>['TransitionCancel']; 'capture-catchtransitioncancel'?: LynxEvent<T>['TransitionCancel']; 'global-bindtransitioncancel'?: LynxEvent<T>['TransitionCancel']; }
+interface TransitionEndProps<T> { bindtransitionend?: LynxEvent<T>['TransitionEnd']; catchtransitionend?: LynxEvent<T>['TransitionEnd']; 'capture-bindtransitionend'?: LynxEvent<T>['TransitionEnd']; 'capture-catchtransitionend'?: LynxEvent<T>['TransitionEnd']; 'global-bindtransitionend'?: LynxEvent<T>['TransitionEnd']; }
+interface AnimationStartProps<T> { bindanimationstart?: LynxEvent<T>['AnimationStart']; catchanimationstart?: LynxEvent<T>['AnimationStart']; 'capture-bindanimationstart'?: LynxEvent<T>['AnimationStart']; 'capture-catchanimationstart'?: LynxEvent<T>['AnimationStart']; 'global-bindanimationstart'?: LynxEvent<T>['AnimationStart']; }
+interface AnimationIterationProps<T> { bindanimationiteration?: LynxEvent<T>['AnimationIteration']; catchanimationiteration?: LynxEvent<T>['AnimationIteration']; 'capture-bindanimationiteration'?: LynxEvent<T>['AnimationIteration']; 'capture-catchanimationiteration'?: LynxEvent<T>['AnimationIteration']; 'global-bindanimationiteration'?: LynxEvent<T>['AnimationIteration']; }
+interface AnimationCancelProps<T> { bindanimationcancel?: LynxEvent<T>['AnimationCancel']; catchanimationcancel?: LynxEvent<T>['AnimationCancel']; 'capture-bindanimationcancel'?: LynxEvent<T>['AnimationCancel']; 'capture-catchanimationcancel'?: LynxEvent<T>['AnimationCancel']; 'global-bindanimationcancel'?: LynxEvent<T>['AnimationCancel']; }
+interface AnimationEndProps<T> { bindanimationend?: LynxEvent<T>['AnimationEnd']; catchanimationend?: LynxEvent<T>['AnimationEnd']; 'capture-bindanimationend'?: LynxEvent<T>['AnimationEnd']; 'capture-catchanimationend'?: LynxEvent<T>['AnimationEnd']; 'global-bindanimationend'?: LynxEvent<T>['AnimationEnd']; }
+interface MouseDownProps<T> { bindmousedown?: LynxEvent<T>['MouseDown']; catchmousedown?: LynxEvent<T>['MouseDown']; 'capture-bindmousedown'?: LynxEvent<T>['MouseDown']; 'capture-catchmousedown'?: LynxEvent<T>['MouseDown']; 'global-bindmousedown'?: LynxEvent<T>['MouseDown']; }
+interface MouseUpProps<T> { bindmouseup?: LynxEvent<T>['MouseUp']; catchmouseup?: LynxEvent<T>['MouseUp']; 'capture-bindmouseup'?: LynxEvent<T>['MouseUp']; 'capture-catchmouseup'?: LynxEvent<T>['MouseUp']; 'global-bindmouseup'?: LynxEvent<T>['MouseUp']; }
+interface MouseMoveProps<T> { bindmousemove?: LynxEvent<T>['MouseMove']; catchmousemove?: LynxEvent<T>['MouseMove']; 'capture-bindmousemove'?: LynxEvent<T>['MouseMove']; 'capture-catchmousemove'?: LynxEvent<T>['MouseMove']; 'global-bindmousemove'?: LynxEvent<T>['MouseMove']; }
+interface MouseClickProps<T> { bindmouseclick?: LynxEvent<T>['MouseClick']; catchmouseclick?: LynxEvent<T>['MouseClick']; 'capture-bindmouseclick'?: LynxEvent<T>['MouseClick']; 'capture-catchmouseclick'?: LynxEvent<T>['MouseClick']; 'global-bindmouseclick'?: LynxEvent<T>['MouseClick']; }
+interface MouseDblClickProps<T> { bindmousedblclick?: LynxEvent<T>['MouseDblClick']; catchmousedblclick?: LynxEvent<T>['MouseDblClick']; 'capture-bindmousedblclick'?: LynxEvent<T>['MouseDblClick']; 'capture-catchmousedblclick'?: LynxEvent<T>['MouseDblClick']; 'global-bindmousedblclick'?: LynxEvent<T>['MouseDblClick']; }
+interface MouseLongPressProps<T> { bindmouselongpress?: LynxEvent<T>['MouseLongPress']; catchmouselongpress?: LynxEvent<T>['MouseLongPress']; 'capture-bindmouselongpress'?: LynxEvent<T>['MouseLongPress']; 'capture-catchmouselongpress'?: LynxEvent<T>['MouseLongPress']; 'global-bindmouselongpress'?: LynxEvent<T>['MouseLongPress']; }
+interface WheelProps<T> { bindwheel?: LynxEvent<T>['Wheel']; catchwheel?: LynxEvent<T>['Wheel']; 'capture-bindwheel'?: LynxEvent<T>['Wheel']; 'capture-catchwheel'?: LynxEvent<T>['Wheel']; 'global-bindwheel'?: LynxEvent<T>['Wheel']; }
+interface KeyDownProps<T> { bindkeydown?: LynxEvent<T>['KeyDown']; catchkeydown?: LynxEvent<T>['KeyDown']; 'capture-bindkeydown'?: LynxEvent<T>['KeyDown']; 'capture-catchkeydown'?: LynxEvent<T>['KeyDown']; 'global-bindkeydown'?: LynxEvent<T>['KeyDown']; }
+interface KeyUpProps<T> { bindkeyup?: LynxEvent<T>['KeyUp']; catchkeyup?: LynxEvent<T>['KeyUp']; 'capture-bindkeyup'?: LynxEvent<T>['KeyUp']; 'capture-catchkeyup'?: LynxEvent<T>['KeyUp']; 'global-bindkeyup'?: LynxEvent<T>['KeyUp']; }
+interface FocusProps<T> { bindfocus?: LynxEvent<T>['Focus']; catchfocus?: LynxEvent<T>['Focus']; 'capture-bindfocus'?: LynxEvent<T>['Focus']; 'capture-catchfocus'?: LynxEvent<T>['Focus']; 'global-bindfocus'?: LynxEvent<T>['Focus']; }
+interface BlurProps<T> { bindblur?: LynxEvent<T>['Blur']; catchblur?: LynxEvent<T>['Blur']; 'capture-bindblur'?: LynxEvent<T>['Blur']; 'capture-catchblur'?: LynxEvent<T>['Blur']; 'global-bindblur'?: LynxEvent<T>['Blur']; }
+interface LayoutChangeProps<T> { bindlayoutchange?: LynxEvent<T>['LayoutChange']; catchlayoutchange?: LynxEvent<T>['LayoutChange']; 'capture-bindlayoutchange'?: LynxEvent<T>['LayoutChange']; 'capture-catchlayoutchange'?: LynxEvent<T>['LayoutChange']; 'global-bindlayoutchange'?: LynxEvent<T>['LayoutChange']; }
+interface UIAppearProps<T> { binduiappear?: LynxEvent<T>['UIAppear']; catchuiappear?: LynxEvent<T>['UIAppear']; 'capture-binduiappear'?: LynxEvent<T>['UIAppear']; 'capture-catchuiappear'?: LynxEvent<T>['UIAppear']; 'global-binduiappear'?: LynxEvent<T>['UIAppear']; }
+interface UIDisappearProps<T> { binduidisappear?: LynxEvent<T>['UIDisappear']; catchuidisappear?: LynxEvent<T>['UIDisappear']; 'capture-binduidisappear'?: LynxEvent<T>['UIDisappear']; 'capture-catchuidisappear'?: LynxEvent<T>['UIDisappear']; 'global-binduidisappear'?: LynxEvent<T>['UIDisappear']; }
+interface AccessibilityActionProps<T> { bindaccessibilityaction?: LynxEvent<T>['AccessibilityAction']; catchaccessibilityaction?: LynxEvent<T>['AccessibilityAction']; 'capture-bindaccessibilityaction'?: LynxEvent<T>['AccessibilityAction']; 'capture-catchaccessibilityaction'?: LynxEvent<T>['AccessibilityAction']; 'global-bindaccessibilityaction'?: LynxEvent<T>['AccessibilityAction']; }
+interface TapProps<T> { bindtap?: LynxBindCatchEvent<T>['Tap']; catchtap?: LynxBindCatchEvent<T>['Tap']; 'capture-bindtap'?: LynxBindCatchEvent<T>['Tap']; 'capture-catchtap'?: LynxBindCatchEvent<T>['Tap']; 'global-bindtap'?: LynxBindCatchEvent<T>['Tap']; }
+interface LongTapProps<T> { bindlongtap?: LynxBindCatchEvent<T>['LongTap']; catchlongtap?: LynxBindCatchEvent<T>['LongTap']; 'capture-bindlongtap'?: LynxBindCatchEvent<T>['LongTap']; 'capture-catchlongtap'?: LynxBindCatchEvent<T>['LongTap']; 'global-bindlongtap'?: LynxBindCatchEvent<T>['LongTap']; }
+
+/**
+ * A combination of all possible event properties, statically defined for IDE-friendliness.
+ * This replaces the previous dynamic mapped type.
+ */
+export type LynxEventPropsBase<T> = BGLoadProps<T> &
+  BGErrorProps<T> &
+  TouchStartProps<T> &
+  TouchMoveProps<T> &
+  TouchCancelProps<T> &
+  TouchEndProps<T> &
+  LongPressProps<T> &
+  TransitionStartProps<T> &
+  TransitionCancelProps<T> &
+  TransitionEndProps<T> &
+  AnimationStartProps<T> &
+  AnimationIterationProps<T> &
+  AnimationCancelProps<T> &
+  AnimationEndProps<T> &
+  MouseDownProps<T> &
+  MouseUpProps<T> &
+  MouseMoveProps<T> &
+  MouseClickProps<T> &
+  MouseDblClickProps<T> &
+  MouseLongPressProps<T> &
+  WheelProps<T> &
+  KeyDownProps<T> &
+  KeyUpProps<T> &
+  FocusProps<T> &
+  BlurProps<T> &
+  LayoutChangeProps<T> &
+  UIAppearProps<T> &
+  UIDisappearProps<T> &
+  AccessibilityActionProps<T> &
+  TapProps<T> &
+  LongTapProps<T>;
 
 export type LynxEventProps = LynxEventPropsBase<Target>;
 
@@ -460,3 +530,73 @@ export interface ITouchEvent extends BaseTouchEvent<Target> {}
 export interface IMouseEvent extends BaseMouseEvent<Target> {}
 export interface IWheelEvent extends BaseWheelEvent<Target> {}
 export interface IKeyEvent extends BaseKeyEvent<Target> {}
+
+interface LynxMessageEvents {
+  // from native context
+  __GlobalEvent: {
+    data: [
+      // name
+      string,
+      // params
+      any,
+    ];
+    origin: 'NATIVE';
+  };
+  __DestroyLifetime: {
+    data: [
+      // appGUID
+      number,
+    ];
+    origin: 'NATIVE';
+  }
+
+  // from engine context
+  __RenderPage: {
+    data: [
+      // data
+      object,
+      // renderOptions
+      object,
+    ];
+    origin: 'ENGINE';
+  };
+  __UpdatePage: {
+    data: [
+      // data
+      object,
+      // updateOptions
+      object,
+    ];
+    origin: 'ENGINE';
+  };
+  __UpdateGlobalProps: {
+    data: [
+      // data
+      Object
+    ];
+    origin: 'ENGINE';
+  };
+  __RemoveComponents: {
+    data: [];
+    origin: 'ENGINE';
+  };
+  __SSRHydrate: {
+    data: [
+      // customHydrateInfo
+      string,
+      // listIDs
+      number[],
+    ];
+    origin: 'ENGINE';
+  };
+}
+
+type LynxMessageEventType = keyof LynxMessageEvents;
+
+type LynxMessageEventsWithType = {
+  [k in LynxMessageEventType]: LynxMessageEvents[k] & {
+    type: k;
+  };
+};
+
+export type LynxMessageEvent = LynxMessageEventsWithType[LynxMessageEventType];

package/types/common/global.d.ts

@@ -3,7 +3,7 @@
 // LICENSE file in the root directory of this source tree.
 
 import { SystemInfo } from './system-info';
-import { Lynx as BackgroundLynx, NativeModules as INativeModules, GetElementByIdFunc } from '../background-thread';
+import { Lynx as BackgroundLynx, NativeModules as INativeModules, GetElementByIdFunc, ITextCodecHelper } from '../background-thread';
 import { Lynx as MainThreadLynx } from '../main-thread';
 import { CommonLynx } from './lynx';
 
@@ -25,6 +25,7 @@ declare global {
   var getElementById: GetElementByIdFunc;
 
   var NativeModules: INativeModules;
+  var TextCodecHelper: ITextCodecHelper;
 
   /**
    * @description requestAnimationFrame
@@ -38,7 +39,8 @@ declare global {
    * @since 3.0
    * below Lynx 3.0, use lynx.cancelAnimationFrame.
    */
-  function cancelAnimationFrame(requestID?: number): void;
+  function cancelAnimationFrame(requestID?: number): void; 
+
 }
 
 declare function setTimeout(callback: (...args: unknown[]) => unknown, number: number): number;