@quicktvui/quicktvui3 1.1.43 → 1.1.45-beta.1

package/dist/src/tab/QtTabAPI.d.ts

@@ -0,0 +1,53 @@
+import { QtViewAPI } from "../view/QtViewAPI";
+import { Ref } from "@vue/reactivity";
+import { QTITab } from "./QTITab";
+import { QTTab } from "./QTTab";
+import { QTTabPage } from "./QTTabPage";
+import { QTTabPageState } from "./QTTabPageState";
+import { QTTabPageData } from "./QTTabPageData";
+import { QTWaterfallSection } from "../waterfall/core/QTWaterfallSection";
+import { QTWaterfallItem } from "../waterfall/core/QTWaterfallItem";
+import { ESListViewItemFunctionParams, ESViewStateCallback } from "@extscreen/es3-component";
+import { QTTabDataManager } from "./QTTabDataManager";
+export interface QtTabAPI extends Omit<QtViewAPI, 'blockRootFocus' | 'unBlockRootFocus'> {
+    initTab(instance: Ref<QTITab | undefined>, tab: QTTab): void;
+    initPage(instance: Ref<QTITab | undefined>, waterfall: QTTabPage): void;
+    setPageState(instance: Ref<QTITab | undefined>, pageIndex: number, state: QTTabPageState): void;
+    getCurrentPageIndex(instance: Ref<QTITab | undefined>): number;
+    setPageData(instance: Ref<QTITab | undefined>, pageIndex: number, tabPage: QTTabPageData): void;
+    addPageData(instance: Ref<QTITab | undefined>, pageIndex: number, tabPageData: QTTabPageData, deleteCount: number): void;
+    insertPageData(instance: Ref<QTITab | undefined>, tabPageIndex: number, sectionIndex: number, data: any[]): void;
+    updatePageData(instance: Ref<QTITab | undefined>, pageIndex: number, tabPageData: QTTabPageData): void;
+    updatePageSection(instance: Ref<QTITab | undefined>, pageIndex: number, sectionIndex: number, section: QTWaterfallSection): void;
+    deletePageSection(instance: Ref<QTITab | undefined>, pageIndex: number, sectionIndex: number, count: number): void;
+    getPageSection(instance: Ref<QTITab | undefined>, pageIndex: number, sectionIndex: number): QTWaterfallSection | undefined;
+    getPageSectionList(instance: Ref<QTITab | undefined>, pageIndex: number): Array<QTWaterfallSection> | undefined;
+    getPageItem(instance: Ref<QTITab | undefined>, pageIndex: number, sectionIndex: number, itemIndex: number): QTWaterfallItem | undefined;
+    updatePageItem(instance: Ref<QTITab | undefined>, pageIndex: number, sectionIndex: number, itemIndex: number, item: QTWaterfallItem): void;
+    addPageItemList(instance: Ref<QTITab | undefined>, pageIndex: number, sectionIndex: number, itemList: Array<QTWaterfallItem>): void;
+    deletePageItem(instance: Ref<QTITab | undefined>, pageIndex: number, sectionIndex: number, itemIndex: number, count: number): void;
+    blockRootFocus(instance: Ref<QTITab | undefined>): void;
+    unBlockRootFocus(instance: Ref<QTITab | undefined>): void;
+    focusBackToTop(instance: Ref<QTITab | undefined>): void;
+    requestNodeFocus(instance: Ref<QTITab | undefined>, id: string): void;
+    reloadAll(instance: Ref<QTITab | undefined>, updateCurrent: boolean): void;
+    reloadPage(instance: Ref<QTITab | undefined>, pageIndex: number): void;
+    setCurrentPage(instance: Ref<QTITab | undefined>, pageIndex: number): void;
+    getCurrentTabIndex(instance: Ref<QTITab | undefined>): Promise<number>;
+    requestTabFocus(instance: Ref<QTITab | undefined>, tabIndex: number): void;
+    invokeContentFunction(instance: Ref<QTITab | undefined>, pageIndex: number, functionName: string, param: Array<any>): void;
+    invokeContentFunctionDirect(instance: Ref<QTITab | undefined>, functionName: string, param: Array<any>): void;
+    contentScrollToFocus(instance: Ref<QTITab | undefined>, position: number): void;
+    getRootNodeViewState(instance: Ref<QTITab | undefined>, page: number, position: number, callback: ESViewStateCallback): void;
+    getChildNodeViewState(instance: Ref<QTITab | undefined>, page: number, position: number, childIndex: number, name: number, callback: ESViewStateCallback): void;
+    dispatchUIFunctionOnChildNode(instance: Ref<QTITab | undefined>, page: number, position: number, childIndex: number, listViewName: string, functionParams: ESListViewItemFunctionParams): void;
+    updateItemMatched(instance: Ref<QTITab | undefined>, key: string, id: any, newData: any): void;
+    updateChildNode(instance: Ref<QTITab | undefined>, page: number, position: number, childIndex: number, data: any): void;
+    updateRootNode(instance: Ref<QTITab | undefined>, page: number, position: number, data: any): void;
+    translationLeft(instance: Ref<QTITab | undefined>): void;
+    translationRight(instance: Ref<QTITab | undefined>): void;
+    destroy(instance: Ref<QTITab | undefined>): void;
+    cancelAll(instance: Ref<QTITab | undefined>): void;
+    getDataManager(instance: Ref<QTITab | undefined>): QTTabDataManager | undefined;
+}
+export declare function createQtTabAPI(viewAPI: QtViewAPI): QtTabAPI;

package/dist/src/tab/index.vue.d.ts

@@ -174,17 +174,77 @@ declare const _default: import("vue").DefineComponent<{
             itemStoreEnable: boolean;
         };
     };
+    tabConfigs: {
+        type: ObjectConstructor;
+        default: () => {
+            defaultFocusIndex: number;
+            defaultIndex: number;
+        };
+    };
+    waterfallConfig: {
+        type: ObjectConstructor;
+        default: () => {
+            width: number;
+            height: number;
+        };
+    };
+    datas: {
+        type: {
+            (arrayLength: number): any[];
+            (...items: any[]): any[];
+            new (arrayLength: number): any[];
+            new (...items: any[]): any[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
 }, {
-    dispatchFunctionBySid: (sid: string, funcName: string, args: any[]) => void;
-    requestFocus: () => void;
+    dispatchFunctionBySid: (sid: string, funcName: string, args: import("..").QTNativeParams[]) => void;
+    requestFocus: (direction?: import("..").QTFocusDirection | undefined) => void;
+    requestChildFocus: (position: number, direction?: import("..").QTFocusDirection | undefined) => void;
     clearFocus: () => void;
-    requestFocusDirectly: () => void;
+    requestFocusDirectly: (direction?: import("..").QTFocusDirection | undefined) => void;
     setVisibility: (v: import("..").QTIViewVisibility) => void;
+    requestRootLayout: () => void;
+    requestLayout: () => void;
+    setDescendantFocusability: (descendant: import("..").QTFocusDescendant) => void;
+    changeDescendantFocusability: (descendant: import("..").QTDescendantFocusability) => void;
+    forceUpdateRenderNode: () => void;
+    setBackGroundColor: (color: string) => void;
+    layoutViewManual: () => void;
+    blockRootFocus: () => void;
+    unBlockRootFocus: () => void;
+    changeAlpha: (alpha: number) => void;
+    setScale: (x: number, y: number, duration: number) => void;
+    setPosition: (x: number, y: number, z: number) => void;
+    updateLayout: (width: number, height: number, x: number, y: number) => void;
+    invalidate: () => void;
+    dispatchFunctionForTarget: (targetName: string, functionTargetName: string, params: import("..").QTNativeParams[], delay: number) => void;
+    setBlockFocusDirections: (directionList: import("..").QTFocusDirectionName[]) => void;
+    setBlockFocusDirectionsOnFail: (directionList: import("..").QTFocusDirectionName[]) => void;
+    setInitFocus: (sid: string, delay?: number | undefined) => void;
+    setAutoFocus: (sid: string, delay?: number | undefined) => void;
+    enabledAutofocus: (autofocus: boolean) => void;
+    requestAutofocus: () => void;
+    hasFocus: () => Promise<boolean>;
+    isFocused: () => Promise<boolean>;
+    getLocationOnScreen: () => Promise<import("..").QTEventData<import("..").QTLocation>>;
+    getViewState: () => Promise<import("..").QTViewState>;
+    getChildViewState: (position: number) => Promise<import("..").QTViewState>;
+    requestChildFocusAtIndex: (position: number) => void;
+    clearMemoryFocused: () => void;
+    showDialog: (show: boolean) => void;
     tabs: import("vue").Ref<ESITab | undefined>;
     ifTabs: import("vue").Ref<boolean>;
     navBarRef: import("vue").Ref<QTINavBar | undefined>;
     initTab: (tab: QTTab) => void;
-    setAutoFocus: (tag: string, delay: number) => void;
     initPage: (w: QTWaterfall) => void;
     setPageState: (pageIndex: number, state: QTTabPageState) => void;
     setPageData: (pageIndex: number, tabPageData: QTTabPageData) => void;
@@ -192,14 +252,12 @@ declare const _default: import("vue").DefineComponent<{
     updatePageData: (pageIndex: number, tabPageData: QTTabPageData) => void;
     updatePageSection: (pageIndex: number, sectionIndex: number, section: QTWaterfallSection) => void;
     getPageSection: (pageIndex: number, sectionIndex: number) => QTWaterfallSection | undefined;
-    getPageSectionList: (pageIndex: number) => Array<QTWaterfallSection>;
+    getPageSectionList: (pageIndex: number) => Array<QTWaterfallSection> | undefined;
     deletePageSection: (pageIndex: number, sectionIndex: number, count: number) => void;
-    addPageItemList: (pageIndex: number, sectionIndex: number, itemList: Array<QTWaterfallItem>) => void;
+    addPageItemList: (pageIndex: number, sectionIndex: number, itemList: Array<QTWaterfallItem>, insertIndex?: number, deleteCount?: number) => void;
     getPageItem: (pageIndex: number, sectionIndex: number, itemIndex: number) => QTWaterfallItem | undefined;
     updatePageItem: (pageIndex: number, sectionIndex: number, itemIndex: number, item: QTWaterfallItem) => void;
     deletePageItem: (pageIndex: number, sectionIndex: number, itemIndex: number, count: number) => void;
-    blockRootFocus: () => void;
-    unBlockRootFocus: () => void;
     focusBackToTop: () => void;
     requestNodeFocus: (id: string) => void;
     reloadAll: (updateCurrent?: boolean) => void;
@@ -236,7 +294,7 @@ declare const _default: import("vue").DefineComponent<{
     onTabClick: (e: QTTabItem) => void;
     getCurrentPageIndex: () => number;
     getCurrentTabIndex: () => Promise<number>;
-    insertPageData(tabPageIndex: number, sectionIndex: number, data: any[]): void;
+    insertPageData: (tabPageIndex: number, sectionIndex: number, data: any[]) => void;
     onPluginLoadSuccess: (event: QTPluginViewEvent) => void;
     onPluginLoadError: (event: QTPluginViewEvent) => void;
     getDataManager(): import("./QTTabDataManager").QTTabDataManager;
@@ -405,6 +463,37 @@ declare const _default: import("vue").DefineComponent<{
             itemStoreEnable: boolean;
         };
     };
+    tabConfigs: {
+        type: ObjectConstructor;
+        default: () => {
+            defaultFocusIndex: number;
+            defaultIndex: number;
+        };
+    };
+    waterfallConfig: {
+        type: ObjectConstructor;
+        default: () => {
+            width: number;
+            height: number;
+        };
+    };
+    datas: {
+        type: {
+            (arrayLength: number): any[];
+            (...items: any[]): any[];
+            new (arrayLength: number): any[];
+            new (...items: any[]): any[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
 }>> & {
     onOnTabPageLoadData?: ((...args: any[]) => any) | undefined;
     onOnTabPageChanged?: ((...args: any[]) => any) | undefined;
@@ -460,5 +549,8 @@ declare const _default: import("vue").DefineComponent<{
     verticalFadingEdgeEnabled: boolean;
     fadingEdgeLength: number;
     qtTabSectionEnable: Record<string, any>;
+    tabConfigs: Record<string, any>;
+    waterfallConfig: Record<string, any>;
+    datas: any[];
 }, {}>;
 export default _default;

package/dist/src/tab/useQtTabWatch.d.ts

@@ -0,0 +1,3 @@
+export declare const useQtTabWatch: (props: any, instance: any) => {
+    checkIsStaticDatas(pageIndex: number, pageNo: number): boolean;
+};

package/dist/src/text/QTIText.d.ts

@@ -1,3 +1,8 @@
 import { QTIView } from "../view/QTIView";
+import { QTTextSpan } from "./QTTextSpan";
 export interface QTIText extends QTIView {
+    setText(text: string): void;
+    setTextSize(size: number): void;
+    setTextColor(color: string): void;
+    textSpan(span: QTTextSpan): void;
 }

package/dist/src/text/QTTextSpan.d.ts

@@ -0,0 +1,5 @@
+import { QTTextSpanAttribute } from "./QTTextSpanAttribute";
+export interface QTTextSpan {
+    text: string;
+    spanAttr: QTTextSpanAttribute;
+}

package/dist/src/text/QTTextSpanAttribute.d.ts

@@ -0,0 +1,5 @@
+import { QTTextSpanAttributeType } from "./QTTextSpanAttributeType";
+export interface QTTextSpanAttribute {
+    type: QTTextSpanAttributeType;
+    value: Array<number>;
+}

package/dist/src/text/QTTextSpanAttributeType.d.ts

@@ -0,0 +1,4 @@
+export declare enum QTTextSpanAttributeType {
+    QT_TEXT_SPAN_ATTRIBUTE_TYPE_SIZE = "size",
+    QT_TEXT_SPAN_ATTRIBUTE_TYPE_COLOR = "color"
+}

package/dist/src/text/QtTextAPI.d.ts

@@ -0,0 +1,11 @@
+import { QtViewAPI } from "../view/QtViewAPI";
+import { Ref } from "@vue/reactivity";
+import { QTTextSpan } from "./QTTextSpan";
+import { QTIText } from "./QTIText";
+export interface QtTextAPI extends QtViewAPI {
+    setText(instance: string | Ref<QTIText | undefined>, text: string): void;
+    setTextSize(instance: string | Ref<QTIText | undefined>, size: number): void;
+    setTextColor(instance: string | Ref<QTIText | undefined>, color: string): void;
+    textSpan(instance: string | Ref<QTIText | undefined>, span: QTTextSpan): void;
+}
+export declare function createQtTextAPI(viewAPI: QtViewAPI): QtTextAPI;

package/dist/src/text/index.vue.d.ts

@@ -1,9 +1,44 @@
+import { QTTextSpan } from "./QTTextSpan";
 declare const _default: import("vue").DefineComponent<{}, {
-    dispatchFunctionBySid: (sid: string, funcName: string, args: any[]) => void;
-    requestFocus: () => void;
+    dispatchFunctionBySid: (sid: string, funcName: string, args: import("..").QTNativeParams[]) => void;
+    requestFocus: (direction?: import("..").QTFocusDirection | undefined) => void;
+    requestChildFocus: (position: number, direction?: import("..").QTFocusDirection | undefined) => void;
     clearFocus: () => void;
-    requestFocusDirectly: () => void;
+    requestFocusDirectly: (direction?: import("..").QTFocusDirection | undefined) => void;
     setVisibility: (v: import("..").QTIViewVisibility) => void;
+    requestRootLayout: () => void;
+    requestLayout: () => void;
+    setDescendantFocusability: (descendant: import("..").QTFocusDescendant) => void;
+    changeDescendantFocusability: (descendant: import("..").QTDescendantFocusability) => void;
+    forceUpdateRenderNode: () => void;
+    setBackGroundColor: (color: string) => void;
+    layoutViewManual: () => void;
+    blockRootFocus: () => void;
+    unBlockRootFocus: () => void;
+    changeAlpha: (alpha: number) => void;
+    setScale: (x: number, y: number, duration: number) => void;
+    setPosition: (x: number, y: number, z: number) => void;
+    updateLayout: (width: number, height: number, x: number, y: number) => void;
+    invalidate: () => void;
+    dispatchFunctionForTarget: (targetName: string, functionTargetName: string, params: import("..").QTNativeParams[], delay: number) => void;
+    setBlockFocusDirections: (directionList: import("..").QTFocusDirectionName[]) => void;
+    setBlockFocusDirectionsOnFail: (directionList: import("..").QTFocusDirectionName[]) => void;
+    setInitFocus: (sid: string, delay?: number | undefined) => void;
+    setAutoFocus: (sid: string, delay?: number | undefined) => void;
+    enabledAutofocus: (autofocus: boolean) => void;
+    requestAutofocus: () => void;
+    hasFocus: () => Promise<boolean>;
+    isFocused: () => Promise<boolean>;
+    getLocationOnScreen: () => Promise<import("..").QTEventData<import("..").QTLocation>>;
+    getViewState: () => Promise<import("..").QTViewState>;
+    getChildViewState: (position: number) => Promise<import("..").QTViewState>;
+    requestChildFocusAtIndex: (position: number) => void;
+    clearMemoryFocused: () => void;
+    showDialog: (show: boolean) => void;
     viewRef: import("vue").Ref<any>;
+    setText: (text: string) => void;
+    setTextSize: (size: number) => void;
+    setTextColor: (color: string) => void;
+    textSpan: (span: QTTextSpan) => void;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
 export default _default;

package/dist/src/ul/QTIUL.d.ts

@@ -0,0 +1,14 @@
+import { QTIView } from "../view/QTIView";
+import { QTULInitPosition } from "./QTULInitPosition";
+import { QTPosition } from "../core/QTPosition";
+export interface QTIUL extends QTIView {
+    scrollToIndex(x: number, y: number, animated: boolean, duration: number, offset: number): void;
+    setInitPosition(initPosition: QTULInitPosition): void;
+    clearInitPosition(): void;
+    scrollToContentOffset(x: number, y: number, animated: boolean, duration: number): void;
+    scrollToTop(): void;
+    setSelectChildPosition(position: number, changeFocusTarget?: boolean): void;
+    setTargetFocusChildPosition(position: number): void;
+    refreshListData(): void;
+    getScrollOffset(): Promise<QTPosition>;
+}

package/dist/src/ul/QTULInitPosition.d.ts

@@ -0,0 +1,2 @@
+import { QTListInitPosition } from "../list/QTListInitPosition";
+export type QTULInitPosition = QTListInitPosition;

package/dist/src/ul/QtULAPI.d.ts

@@ -0,0 +1,17 @@
+import { QtViewAPI } from "../view/QtViewAPI";
+import { Ref } from "@vue/reactivity";
+import { QTULInitPosition } from "./QTULInitPosition";
+import { QTPosition } from "../core/QTPosition";
+import { QTIUL } from "./QTIUL";
+export interface QtULAPI extends QtViewAPI {
+    scrollToIndex(instance: string | Ref<QTIUL | undefined>, x: number, y: number, animated: boolean, duration: number, offset: number): void;
+    setInitPosition(instance: string | Ref<QTIUL | undefined>, initPosition: QTULInitPosition): void;
+    clearInitPosition(instance: string | Ref<QTIUL | undefined>): void;
+    scrollToContentOffset(instance: string | Ref<QTIUL | undefined>, x: number, y: number, animated: boolean, duration: number): void;
+    scrollToTop(instance: string | Ref<QTIUL | undefined>): void;
+    setSelectChildPosition(instance: string | Ref<QTIUL | undefined>, position: number, changeFocusTarget?: boolean): void;
+    setTargetFocusChildPosition(instance: string | Ref<QTIUL | undefined>, position: number): void;
+    refreshListData(instance: string | Ref<QTIUL | undefined>): void;
+    getScrollOffset(instance: string | Ref<QTIUL | undefined>): Promise<QTPosition>;
+}
+export declare function createQtULAPI(viewAPI: QtViewAPI): QtULAPI;

package/dist/src/utils/QtVirtualViewAPI.d.ts

@@ -0,0 +1,6 @@
+import { QTListViewItem } from "../list-view/core/QTListViewItem";
+export interface QtVirtualViewAPI {
+    searchReplaceItem(instance: string, item: QTListViewItem): void;
+    searchReplaceItemTraverse(instance: string, item: QTListViewItem): void;
+}
+export declare function createQtVirtualViewAPI(): QtVirtualViewAPI;

package/dist/src/utils/type.d.ts

@@ -0,0 +1 @@
+export declare const isString: (val: unknown) => boolean;

package/dist/src/view/QTViewState.d.ts

@@ -0,0 +1,12 @@
+export interface QTViewState {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+    hasFocus: boolean;
+    isFocused: boolean;
+    alpha: number;
+    name: string;
+}

package/dist/src/view/QtViewAPI.d.ts

@@ -0,0 +1,45 @@
+import { QTIViewVisibility } from "./QTIViewVisibility";
+import { Ref } from "@vue/reactivity";
+import { QTIView } from "./QTIView";
+import { QTFocusDirection } from "../focus/QTFocusDirection";
+import { QTFocusDescendant } from "../focus/QTFocusDescendant";
+import { QTDescendantFocusability } from "../focus/QTDescendantFocusability";
+import { QTNativeParams } from "../core/QTNativeParams";
+import { QTFocusDirectionName } from "../focus/QTFocusDirectionName";
+import { QTEventData } from "../core/QTEventData";
+import { QTLocation } from "../core/QTLocation";
+import { QTViewState } from "./QTViewState";
+export interface QtViewAPI {
+    requestFocus(instance: string | Ref<QTIView | undefined>, direction?: QTFocusDirection): void;
+    requestChildFocus(instance: string | Ref<QTIView | undefined>, position: number): void;
+    clearFocus(instance: string | Ref<QTIView | undefined>): void;
+    requestFocusDirectly(instance: string | Ref<QTIView | undefined>, direction?: QTFocusDirection): void;
+    setVisibility(instance: string | Ref<QTIView | undefined>, v: QTIViewVisibility): void;
+    requestRootLayout(instance: string | Ref<QTIView | undefined>): void;
+    requestLayout(instance: string | Ref<QTIView | undefined>): void;
+    setDescendantFocusability(instance: string | Ref<QTIView | undefined>, descendant: QTFocusDescendant): void;
+    changeDescendantFocusability(instance: string | Ref<QTIView | undefined>, descendant: QTDescendantFocusability): void;
+    forceUpdateRenderNode(instance: string | Ref<QTIView | undefined>): void;
+    setBackGroundColor(instance: string | Ref<QTIView | undefined>, color: string): void;
+    layoutViewManual(instance: string | Ref<QTIView | undefined>): void;
+    blockRootFocus(instance: string | Ref<QTIView | undefined>): void;
+    unBlockRootFocus(instance: string | Ref<QTIView | undefined>): void;
+    changeAlpha(instance: string | Ref<QTIView | undefined>, alpha: number): void;
+    setScale(instance: string | Ref<QTIView | undefined>, x: number, y: number, duration: number): void;
+    setPosition(instance: string | Ref<QTIView | undefined>, x: number, y: number, z: number): void;
+    updateLayout(instance: string | Ref<QTIView | undefined>, width: number, height: number, x: number, y: number): void;
+    invalidate(instance: string | Ref<QTIView | undefined>): void;
+    dispatchFunctionForTarget(instance: string | Ref<QTIView | undefined>, targetName: string, functionTargetName: string, params: Array<QTNativeParams>, delay: number): void;
+    setBlockFocusDirections(instance: string | Ref<QTIView | undefined>, directionList: Array<QTFocusDirectionName>): void;
+    setBlockFocusDirectionsOnFail(instance: string | Ref<QTIView | undefined>, directionList: Array<QTFocusDirectionName>): void;
+    setInitFocus(instance: string | Ref<QTIView | undefined>, sid: string, delay?: number): void;
+    setAutoFocus(instance: string | Ref<QTIView | undefined>, sid: string, delay?: number): void;
+    enabledAutofocus(instance: string | Ref<QTIView | undefined>, autofocus: boolean): void;
+    requestAutofocus(instance: string | Ref<QTIView | undefined>): void;
+    hasFocus(instance: string | Ref<QTIView | undefined>): Promise<boolean>;
+    isFocused(instance: string | Ref<QTIView | undefined>): Promise<boolean>;
+    getLocationOnScreen(instance: string | Ref<QTIView | undefined>): Promise<QTEventData<QTLocation>>;
+    getViewState(instance: string | Ref<QTIView | undefined>): Promise<QTViewState>;
+    getChildViewState(instance: string | Ref<QTIView | undefined>, position: number): Promise<QTViewState>;
+}
+export declare function createQtViewAPI(): QtViewAPI;

package/dist/src/view/index.vue.d.ts

@@ -1,9 +1,39 @@
 declare const _default: import("vue").DefineComponent<{}, {
-    dispatchFunctionBySid: (sid: string, funcName: string, args: any[]) => void;
-    requestFocus: () => void;
+    dispatchFunctionBySid: (sid: string, funcName: string, args: import("..").QTNativeParams[]) => void;
+    requestFocus: (direction?: import("..").QTFocusDirection | undefined) => void;
+    requestChildFocus: (position: number, direction?: import("..").QTFocusDirection | undefined) => void;
     clearFocus: () => void;
-    requestFocusDirectly: () => void;
+    requestFocusDirectly: (direction?: import("..").QTFocusDirection | undefined) => void;
     setVisibility: (v: import("./QTIViewVisibility").QTIViewVisibility) => void;
+    requestRootLayout: () => void;
+    requestLayout: () => void;
+    setDescendantFocusability: (descendant: import("..").QTFocusDescendant) => void;
+    changeDescendantFocusability: (descendant: import("..").QTDescendantFocusability) => void;
+    forceUpdateRenderNode: () => void;
+    setBackGroundColor: (color: string) => void;
+    layoutViewManual: () => void;
+    blockRootFocus: () => void;
+    unBlockRootFocus: () => void;
+    changeAlpha: (alpha: number) => void;
+    setScale: (x: number, y: number, duration: number) => void;
+    setPosition: (x: number, y: number, z: number) => void;
+    updateLayout: (width: number, height: number, x: number, y: number) => void;
+    invalidate: () => void;
+    dispatchFunctionForTarget: (targetName: string, functionTargetName: string, params: import("..").QTNativeParams[], delay: number) => void;
+    setBlockFocusDirections: (directionList: import("..").QTFocusDirectionName[]) => void;
+    setBlockFocusDirectionsOnFail: (directionList: import("..").QTFocusDirectionName[]) => void;
+    setInitFocus: (sid: string, delay?: number | undefined) => void;
+    setAutoFocus: (sid: string, delay?: number | undefined) => void;
+    enabledAutofocus: (autofocus: boolean) => void;
+    requestAutofocus: () => void;
+    hasFocus: () => Promise<boolean>;
+    isFocused: () => Promise<boolean>;
+    getLocationOnScreen: () => Promise<import("..").QTEventData<import("..").QTLocation>>;
+    getViewState: () => Promise<import("./QTViewState").QTViewState>;
+    getChildViewState: (position: number) => Promise<import("./QTViewState").QTViewState>;
+    requestChildFocusAtIndex: (position: number) => void;
+    clearMemoryFocused: () => void;
+    showDialog: (show: boolean) => void;
     viewRef: import("vue").Ref<any>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "clearFocus"[], "clearFocus", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>> & {
     onClearFocus?: ((...args: any[]) => any) | undefined;

package/dist/src/waterfall/QtWaterfallAPI.d.ts

@@ -0,0 +1,23 @@
+import { QtViewAPI } from "../view/QtViewAPI";
+import { QtBaseListViewAPI } from "../list/QtBaseListViewAPI";
+import { QTWaterfall } from "./core/QTWaterfall";
+import { QTWaterfallSection } from "./core/QTWaterfallSection";
+import { QTWaterfallItem } from "./core/QTWaterfallItem";
+import { Ref } from "@vue/reactivity";
+import { QTIWaterfall } from "./core/QTIWaterfall";
+export interface QtWaterfallAPI extends QtViewAPI, QtBaseListViewAPI {
+    init(instance: Ref<QTIWaterfall | undefined>, waterfall: QTWaterfall): any;
+    getSectionList(instance: Ref<QTIWaterfall | undefined>): Array<QTWaterfallSection>;
+    setSectionList(instance: Ref<QTIWaterfall | undefined>, sections: Array<QTWaterfallSection>): void;
+    addSectionList(instance: Ref<QTIWaterfall | undefined>, sections: Array<QTWaterfallSection>): void;
+    deleteSection(instance: Ref<QTIWaterfall | undefined>, sectionIndex: number, count: number): void;
+    updateSection(instance: Ref<QTIWaterfall | undefined>, sectionIndex: number, section: QTWaterfallSection): void;
+    updateSectionList(instance: Ref<QTIWaterfall | undefined>, sectionIndex: number, count: number, sectionList: Array<QTWaterfallSection>): void;
+    getSection(instance: Ref<QTIWaterfall | undefined>, sectionIndex: number): QTWaterfallSection | undefined;
+    addItemList(instance: Ref<QTIWaterfall | undefined>, sectionIndex: number, itemList: Array<QTWaterfallItem>): void;
+    deleteItem(instance: Ref<QTIWaterfall | undefined>, sectionIndex: number, itemIndex: number, count: number): void;
+    updateItem(instance: Ref<QTIWaterfall | undefined>, sectionIndex: number, itemIndex: number, item: QTWaterfallItem): void;
+    updateItemList(instance: Ref<QTIWaterfall | undefined>, sectionIndex: number, itemIndex: number, count: number, itemList: Array<QTWaterfallItem>): void;
+    getItem(instance: Ref<QTIWaterfall | undefined>, sectionIndex: number, itemIndex: number): QTWaterfallItem | undefined;
+}
+export declare function createQtWaterfallAPI(viewAPI: QtViewAPI, listViewAPI: QtBaseListViewAPI): QtWaterfallAPI;

package/dist/src/waterfall/core/QTIWaterfall.d.ts

@@ -1,8 +1,8 @@
 import { QTWaterfallSection } from "./QTWaterfallSection";
 import { QTWaterfall } from "./QTWaterfall";
 import { QTWaterfallItem } from "./QTWaterfallItem";
-import { QTIView } from "../../view/QTIView";
-export interface QTIWaterfall extends QTIView {
+import { QTIBaseListView } from "../../list/QTIBaseListView";
+export interface QTIWaterfall extends QTIBaseListView {
     init(waterfall: QTWaterfall): any;
     getSectionList(): Array<QTWaterfallSection>;
     setSectionList(sections: Array<QTWaterfallSection>): void;
@@ -16,10 +16,4 @@ export interface QTIWaterfall extends QTIView {
     updateItem(sectionIndex: number, itemIndex: number, item: QTWaterfallItem): void;
     updateItemList(sectionIndex: number, itemIndex: number, count: number, itemList: Array<QTWaterfallItem>): void;
     getItem(sectionIndex: number, itemIndex: number): QTWaterfallItem | undefined;
-    clearPostTask(): void;
-    pausePostTask(): void;
-    resumePostTask(): void;
-    destroy(): void;
-    scrollToTop(): void;
-    setListData(): void;
 }

package/dist/src/waterfall/index.vue.d.ts

@@ -69,15 +69,44 @@ declare const _default: import("vue").DefineComponent<{
         required: false;
     };
 }, {
-    dispatchFunctionBySid: (sid: string, funcName: string, args: any[]) => void;
-    requestFocus: () => void;
+    dispatchFunctionBySid: (sid: string, funcName: string, args: import("..").QTNativeParams[]) => void;
+    requestFocus: (direction?: import("..").QTFocusDirection | undefined) => void;
+    requestChildFocus: (position: number, direction?: import("..").QTFocusDirection | undefined) => void;
     clearFocus: () => void;
-    requestFocusDirectly: () => void;
+    requestFocusDirectly: (direction?: import("..").QTFocusDirection | undefined) => void;
     setVisibility: (v: import("..").QTIViewVisibility) => void;
+    requestRootLayout: () => void;
+    requestLayout: () => void;
+    setDescendantFocusability: (descendant: import("..").QTFocusDescendant) => void;
+    changeDescendantFocusability: (descendant: import("..").QTDescendantFocusability) => void;
+    forceUpdateRenderNode: () => void;
+    setBackGroundColor: (color: string) => void;
+    layoutViewManual: () => void;
+    blockRootFocus: () => void;
+    unBlockRootFocus: () => void;
+    changeAlpha: (alpha: number) => void;
+    setScale: (x: number, y: number, duration: number) => void;
+    setPosition: (x: number, y: number, z: number) => void;
+    updateLayout: (width: number, height: number, x: number, y: number) => void;
+    invalidate: () => void;
+    dispatchFunctionForTarget: (targetName: string, functionTargetName: string, params: import("..").QTNativeParams[], delay: number) => void;
+    setBlockFocusDirections: (directionList: import("..").QTFocusDirectionName[]) => void;
+    setBlockFocusDirectionsOnFail: (directionList: import("..").QTFocusDirectionName[]) => void;
+    setInitFocus: (sid: string, delay?: number | undefined) => void;
+    setAutoFocus: (sid: string, delay?: number | undefined) => void;
+    enabledAutofocus: (autofocus: boolean) => void;
+    requestAutofocus: () => void;
+    hasFocus: () => Promise<boolean>;
+    isFocused: () => Promise<boolean>;
+    getLocationOnScreen: () => Promise<import("..").QTEventData<import("..").QTLocation>>;
+    getViewState: () => Promise<import("..").QTViewState>;
+    getChildViewState: (position: number) => Promise<import("..").QTViewState>;
+    requestChildFocusAtIndex: (position: number) => void;
+    clearMemoryFocused: () => void;
+    showDialog: (show: boolean) => void;
     waterfallRef: import("vue").Ref<ESIListView | undefined>;
     visibleType: import("vue").Ref<QTWaterfallVisibleType>;
     init: (data: QTWaterfall) => void;
-    setAutoFocus: (tag: string, delay: number) => void;
     getSectionList: () => Array<QTWaterfallSection>;
     setSectionList: (sectionList: Array<QTWaterfallSection>) => void;
     addSectionList: (sectionList: Array<QTWaterfallSection>) => void;

package/dist/src/waterfall/item/plugin-item.vue.d.ts

@@ -1,10 +1,40 @@
 declare const _default: import("vue").DefineComponent<{}, {
     onFocus: (e: any) => void;
-    dispatchFunctionBySid: (sid: string, funcName: string, args: any[]) => void;
-    requestFocus: () => void;
+    dispatchFunctionBySid: (sid: string, funcName: string, args: import("../..").QTNativeParams[]) => void;
+    requestFocus: (direction?: import("../..").QTFocusDirection | undefined) => void;
+    requestChildFocus: (position: number, direction?: import("../..").QTFocusDirection | undefined) => void;
     clearFocus: () => void;
-    requestFocusDirectly: () => void;
+    requestFocusDirectly: (direction?: import("../..").QTFocusDirection | undefined) => void;
     setVisibility: (v: import("../..").QTIViewVisibility) => void;
+    requestRootLayout: () => void;
+    requestLayout: () => void;
+    setDescendantFocusability: (descendant: import("../..").QTFocusDescendant) => void;
+    changeDescendantFocusability: (descendant: import("../..").QTDescendantFocusability) => void;
+    forceUpdateRenderNode: () => void;
+    setBackGroundColor: (color: string) => void;
+    layoutViewManual: () => void;
+    blockRootFocus: () => void;
+    unBlockRootFocus: () => void;
+    changeAlpha: (alpha: number) => void;
+    setScale: (x: number, y: number, duration: number) => void;
+    setPosition: (x: number, y: number, z: number) => void;
+    updateLayout: (width: number, height: number, x: number, y: number) => void;
+    invalidate: () => void;
+    dispatchFunctionForTarget: (targetName: string, functionTargetName: string, params: import("../..").QTNativeParams[], delay: number) => void;
+    setBlockFocusDirections: (directionList: import("../..").QTFocusDirectionName[]) => void;
+    setBlockFocusDirectionsOnFail: (directionList: import("../..").QTFocusDirectionName[]) => void;
+    setInitFocus: (sid: string, delay?: number | undefined) => void;
+    setAutoFocus: (sid: string, delay?: number | undefined) => void;
+    enabledAutofocus: (autofocus: boolean) => void;
+    requestAutofocus: () => void;
+    hasFocus: () => Promise<boolean>;
+    isFocused: () => Promise<boolean>;
+    getLocationOnScreen: () => Promise<import("../..").QTEventData<import("../..").QTLocation>>;
+    getViewState: () => Promise<import("../..").QTViewState>;
+    getChildViewState: (position: number) => Promise<import("../..").QTViewState>;
+    requestChildFocusAtIndex: (position: number) => void;
+    clearMemoryFocused: () => void;
+    showDialog: (show: boolean) => void;
     viewRef: import("vue").Ref<any>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "focus"[], "focus", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>> & {
     onFocus?: ((...args: any[]) => any) | undefined;