drgame-cc 1.0.13 → 1.0.14

package/bin/drgame.d.ts

@@ -0,0 +1,632 @@
+declare module "BtnExtra" {
+    export default class BtnExtra extends cc.Component {
+        hoverSprite: cc.SpriteFrame;
+        normalSprite: cc.SpriteFrame;
+    }
+}
+declare module "Define" {
+    export enum EVideoScene {
+        UseProp = "use_prop",
+        StartGame = "start_game",
+        RevivePop = "revive_pop",
+        BuySkin = "buy_skin",
+        BuyProp = "buy_prop",
+        GameOver = "game_over",
+        LevelComplete = "level_complete",
+        Shop = "shop",
+        DailyReward = "daily_reward",
+        Boost = "boost"
+    }
+}
+declare module "config/TvUiConfig" {
+    export type TvUiDirection = "up" | "down" | "left" | "right";
+    export interface TvUiIconItem {
+        path?: string;
+        url?: string;
+        width?: number;
+        height?: number;
+        offsetX?: number;
+        offsetY?: number;
+    }
+    export interface TvUiFocusVisualConfig {
+        enabled?: boolean;
+        frameEnabled?: boolean;
+        framePadding?: number;
+        frameColor?: string;
+        frameOpacity?: number;
+        lineWidth?: number;
+        animationTime?: number;
+        defaultIconKey?: string;
+        iconPlacement?: "topRight" | "bottomRight";
+        iconOffsetX?: number;
+        iconOffsetY?: number;
+        zIndex?: number;
+    }
+    export interface TvUiAdChannelConfig {
+        type: string;
+        enabled?: boolean;
+        priority?: number;
+        placementId?: string;
+        reward_type?: string;
+        action?: string;
+        rewardAction?: string;
+        popupAction?: string;
+        hideAction?: string;
+        imagePath?: string;
+        imageUrl?: string;
+    }
+    export interface TvUiAdSlotConfig {
+        enabled?: boolean;
+        mode?: "reward" | "popup" | "banner" | "self" | string;
+        channels?: TvUiAdChannelConfig[];
+        fallback?: TvUiAdChannelConfig;
+    }
+    export interface TvUiAdSdkConfig {
+        platform?: "xiaomi" | string;
+        adapterConfig?: any;
+    }
+    export interface TvUiConfig {
+        designWidth?: number;
+        designHeight?: number;
+        resolutionPolicy?: number;
+        cpId?: string;
+        version?: string;
+        configPath?: string;
+        defaultScopeId?: string;
+        enableRemoteInput?: boolean;
+        enableCursor?: boolean;
+        enableLifecycle?: boolean;
+        focus?: TvUiFocusVisualConfig;
+        icons?: {
+            [key: string]: TvUiIconItem;
+        };
+        ads?: {
+            [slotId: string]: TvUiAdSlotConfig;
+        };
+        adSdk?: TvUiAdSdkConfig;
+        nativeCallback?: (action: string, data?: any) => void;
+    }
+    export function createDefaultTvUiConfig(): TvUiConfig;
+}
+declare module "config/TvUiConfigManager" {
+    import { TvUiConfig } from "config/TvUiConfig";
+    type ConfigListener = (config: TvUiConfig) => void;
+    export default class TvUiConfigManager {
+        private static readonly LOCAL_KEY;
+        private static config;
+        private static projectConfig;
+        private static resourceConfig;
+        private static listeners;
+        static init(config?: TvUiConfig, callback?: (config: TvUiConfig) => void): void;
+        static getConfig(): TvUiConfig;
+        static updateConfig(config: TvUiConfig, saveLocal?: boolean): void;
+        static onChanged(listener: ConfigListener): void;
+        static offChanged(listener: ConfigListener): void;
+        private static rebuildConfig;
+        private static loadResourceConfig;
+        private static loadLocalConfig;
+        private static saveLocalConfig;
+        private static emitChanged;
+        private static merge;
+        private static clone;
+        private static isPlainObject;
+    }
+}
+declare module "input/KeyCodeAdapter" {
+    export enum TvRemoteKey {
+        Back = "back",
+        Ok = "ok",
+        Left = "left",
+        Right = "right",
+        Up = "up",
+        Down = "down",
+        Pause = "pause",
+        Unknown = "unknown"
+    }
+    export default class KeyCodeAdapter {
+        static toRemoteKey(keyCode: number): TvRemoteKey;
+    }
+}
+declare module "focus/FocusScope" {
+    export default class FocusScope {
+        scopeId: string;
+        root: cc.Node | null;
+        lastFocusId: string;
+        constructor(scopeId: string, root?: cc.Node);
+    }
+}
+declare module "focus/FocusManager" {
+    import { TvUiDirection } from "config/TvUiConfig";
+    export interface FocusOptions {
+        root?: cc.Node;
+        scopeId?: string;
+        focusId?: string;
+        iconKey?: string;
+        up?: string;
+        down?: string;
+        left?: string;
+        right?: string;
+        onClick?: Function;
+        onFocus?: Function;
+        onBlur?: Function;
+        focusScale?: number;
+        showCursor?: boolean;
+    }
+    export interface FocusCursorOptions {
+        basePath?: string;
+        normalPath?: string;
+        focusPath?: string;
+        corner?: string;
+        width?: number;
+        height?: number;
+        offsetX?: number;
+        offsetY?: number;
+    }
+    export interface FocusRuntimeItem {
+        node: cc.Node;
+        root?: cc.Node;
+        scopeId: string;
+        focusId: string;
+        iconKey?: string;
+        up?: string;
+        down?: string;
+        left?: string;
+        right?: string;
+        onClick?: Function;
+        onFocus?: Function;
+        onBlur?: Function;
+        component?: any;
+        baseScaleX: number;
+        baseScaleY: number;
+        focusScale: number;
+        showCursor: boolean;
+    }
+    type FocusListener = (item: FocusRuntimeItem | null, previous?: FocusRuntimeItem | null) => void;
+    export default class FocusManager {
+        private static readonly FOCUS_SCALE_ACTION_TAG;
+        private static readonly BASE_SCALE_X_KEY;
+        private static readonly BASE_SCALE_Y_KEY;
+        private static items;
+        private static itemMap;
+        private static currentFocusId;
+        private static scopes;
+        private static activeScopeId;
+        private static listeners;
+        private static cursorOptions;
+        static setCursor(options: FocusCursorOptions | null): void;
+        static getCursor(): FocusCursorOptions | null;
+        static register(target: cc.Node | any, options?: FocusOptions): void;
+        static unregister(target: cc.Node | any): void;
+        static unregisterByRoot(root: cc.Node): void;
+        static unregisterById(focusId: string): void;
+        static registerButtons(root: cc.Node, options?: FocusOptions): void;
+        static pushScope(scopeId: string, root?: cc.Node, firstFocus?: string | cc.Node): void;
+        static popScope(scopeId?: string): void;
+        static reset(): void;
+        static focus(target: string | cc.Node): boolean;
+        static focusNode(node: cc.Node): boolean;
+        static move(direction: TvUiDirection): boolean;
+        static confirm(): boolean;
+        static back(): boolean;
+        static handleKey(keyCode: number): boolean;
+        static clickCurrent(): boolean;
+        static getCurrentFocusItem(): FocusRuntimeItem | null;
+        static getActiveScopeId(): string;
+        static onFocusChanged(listener: FocusListener): void;
+        static offFocusChanged(listener: FocusListener): void;
+        private static setFocusById;
+        private static setFocusVisual;
+        private static setButtonSpriteVisual;
+        private static ensureFocus;
+        private static moveByOrder;
+        private static removeItemAt;
+        private static cleanup;
+        private static isItemActive;
+        private static isInActiveScope;
+        private static getActiveScope;
+        private static getWorldCenter;
+        private static getDirectionVector;
+        private static invokeButton;
+        private static emitFocusChanged;
+        private static resolveNode;
+        private static resolveComponent;
+        private static findItemByNode;
+        private static getNodeBaseScale;
+        private static readScale;
+        private static isValidScale;
+        private static createFocusId;
+        private static walk;
+        private static isChildOf;
+    }
+}
+declare module "icon/IconManager" {
+    import { TvUiIconItem } from "config/TvUiConfig";
+    type SpriteFrameCallback = (spriteFrame: cc.SpriteFrame | null, config?: TvUiIconItem | null) => void;
+    export default class IconManager {
+        private static cache;
+        private static inited;
+        static init(): void;
+        static getIconConfig(iconKey?: string): TvUiIconItem | null;
+        static getSpriteFrame(iconKey: string, callback: SpriteFrameCallback): void;
+        static setIconTheme(iconKey: string): void;
+        static clearCache(): void;
+        private static loadLocal;
+        private static loadRemote;
+        private static loadFallback;
+    }
+}
+declare module "focus/FocusVisualLayer" {
+    export default class FocusVisualLayer extends cc.Component {
+        private graphics;
+        private iconNode;
+        private iconSprite;
+        private currentItem;
+        private currentIconConfig;
+        private inited;
+        static create(parent: cc.Node): FocusVisualLayer;
+        onDestroy(): void;
+        init(): void;
+        update(): void;
+        private buildView;
+        private onFocusChanged;
+        private onConfigChanged;
+        private refresh;
+        private hide;
+        private refreshIcon;
+        private drawFocus;
+        private positionIcon;
+        private resizeToParent;
+        private parseColor;
+    }
+}
+declare module "ad/IAdProvider" {
+    import { TvUiAdChannelConfig, TvUiAdSlotConfig } from "config/TvUiConfig";
+    export interface AdShowOptions {
+        slotId?: string;
+        mode?: string;
+        cpId?: string;
+        trigger_scene?: string;
+        reward_type?: string;
+        extra?: any;
+        container?: cc.Node;
+        onLoad?: (data?: any) => void;
+        onSuccess?: (data?: any) => void;
+        onClose?: (data?: any) => void;
+        onFail?: (data?: any) => void;
+    }
+    export interface AdRuntimeData {
+        slotId: string;
+        slotConfig: TvUiAdSlotConfig;
+        channel: TvUiAdChannelConfig;
+        options: AdShowOptions;
+    }
+    export type AdShowResultStatus = "success" | "loaded" | "closed" | "failed";
+    export interface AdShowResult {
+        status: AdShowResultStatus;
+        data?: any;
+        error?: any;
+        action?: string;
+    }
+    export default interface IAdProvider {
+        type: string;
+        isAvailable(): boolean;
+        load(data: AdRuntimeData): Promise<AdRuntimeData>;
+        show(data: AdRuntimeData): Promise<AdShowResult>;
+        hide(slotId: string, channel?: TvUiAdChannelConfig): void;
+    }
+}
+declare module "core/NativeBridge" {
+    export type NativeCallback = (action: string, data?: any) => void;
+    export type NativeBridgeCallback = (code: number, data?: any, action?: string) => void;
+    export default class NativeBridge {
+        static hasBridge(): boolean;
+        static call(action: string, data?: any, callback?: NativeBridgeCallback): void;
+        static getDeviceInfo(callback?: NativeBridgeCallback): void;
+        static onGameReady(): void;
+        static onGamePause(): void;
+        static onGameResume(): void;
+        static onExitGame(): void;
+        static uploadRank(data: any, callback?: NativeBridgeCallback): void;
+        static getRankList(data: any, callback?: NativeBridgeCallback): void;
+        static setNativeCallback(callback: NativeCallback | null): void;
+    }
+}
+declare module "ad/AggregateAdProvider" {
+    import { TvUiAdChannelConfig } from "config/TvUiConfig";
+    import IAdProvider, { AdRuntimeData, AdShowResult } from "ad/IAdProvider";
+    export default class AggregateAdProvider implements IAdProvider {
+        type: string;
+        private static initialized;
+        private static initTask;
+        private static gameReadyNotified;
+        private static GAME_VERSION;
+        isAvailable(): boolean;
+        load(data: AdRuntimeData): Promise<AdRuntimeData>;
+        show(data: AdRuntimeData): Promise<AdShowResult>;
+        hide(slotId: string, channel?: TvUiAdChannelConfig): void;
+        private showReward;
+        private ensureSdk;
+        private notifyGameReady;
+        private getPlatform;
+        private isUserAbandoned;
+    }
+}
+declare module "ad/SelfAdProvider" {
+    import IAdProvider, { AdRuntimeData, AdShowResult } from "ad/IAdProvider";
+    export default class SelfAdProvider implements IAdProvider {
+        type: string;
+        isAvailable(): boolean;
+        load(data: AdRuntimeData): Promise<AdRuntimeData>;
+        show(data: AdRuntimeData): Promise<AdShowResult>;
+        hide(_slotId: string): void;
+    }
+}
+declare module "ad/MockAdProvider" {
+    import IAdProvider, { AdRuntimeData, AdShowResult } from "ad/IAdProvider";
+    export default class MockAdProvider implements IAdProvider {
+        type: string;
+        isAvailable(): boolean;
+        load(data: AdRuntimeData): Promise<AdRuntimeData>;
+        show(data: AdRuntimeData): Promise<AdShowResult>;
+        hide(slotId: string): void;
+    }
+}
+declare module "ad/AdManager" {
+    import IAdProvider, { AdShowOptions } from "ad/IAdProvider";
+    export default class AdManager {
+        private static providers;
+        static init(): void;
+        static registerProvider(provider: IAdProvider): void;
+        static showSlot(slotId: string, options?: AdShowOptions): Promise<boolean>;
+        static hideSlot(slotId: string): void;
+        static refreshSlot(slotId: string, options?: AdShowOptions): Promise<boolean>;
+        static showReward(options: AdShowOptions): Promise<boolean>;
+        static showPopup(options: AdShowOptions): Promise<boolean>;
+        static hidePopup(scene?: string): void;
+        private static getSlotConfig;
+        private static showByChannels;
+        private static getSortedChannels;
+        private static normalizeFallback;
+        private static hasChannelType;
+        private static getPriority;
+        private static mergeOptions;
+    }
+}
+declare module "core/BackManager" {
+    export type BackHandler = () => boolean | void;
+    export default class BackManager {
+        private static handlers;
+        private static fallback;
+        static reset(): void;
+        static setFallback(handler: BackHandler | null): void;
+        static push(handler: BackHandler): void;
+        static remove(handler: BackHandler): void;
+        static handle(): boolean;
+    }
+}
+declare module "input/RemoteInputManager" {
+    import { TvRemoteKey } from "input/KeyCodeAdapter";
+    type KeyHandler = (keyCode: number) => boolean | void;
+    export class RemoteInputManager {
+        private static handlers;
+        private static enabled;
+        private static domInputEnabled;
+        private static lastKeyCode;
+        private static lastDispatchTime;
+        private static readonly DISPATCH_DEBOUNCE_MS;
+        static enable(): void;
+        static disable(): void;
+        static clear(): void;
+        static on(key: TvRemoteKey, handler: KeyHandler): void;
+        static off(key: TvRemoteKey, handler: KeyHandler): void;
+        static toRemoteKey(keyCode: number): TvRemoteKey;
+        static dispatchKeyCode(keyCode: number): boolean;
+        private static onKeyDown;
+        private static enableDomInput;
+        private static disableDomInput;
+        private static onDomKeyDown;
+        private static focusCanvas;
+    }
+}
+declare module "core/TvUiRoot" {
+    import { TvUiConfig } from "config/TvUiConfig";
+    export default class TvUiRoot extends cc.Component {
+        private static instance;
+        private static backHandler;
+        private visualLayer;
+        private configured;
+        static ensure(config?: TvUiConfig): TvUiRoot;
+        static getInstance(): TvUiRoot | null;
+        static setBackHandler(handler: (() => boolean | void) | null): void;
+        onLoad(): void;
+        onDestroy(): void;
+        configure(config?: TvUiConfig): void;
+        private applyConfig;
+        private ensureVisualLayer;
+        private bindInputHandlers;
+        private resize;
+        private exposeGlobal;
+    }
+}
+declare module "core/TvUi" {
+    import TvUiRoot from "core/TvUiRoot";
+    import BackManager from "core/BackManager";
+    import NativeBridge from "core/NativeBridge";
+    import TvUiConfigManager from "config/TvUiConfigManager";
+    import { TvUiConfig } from "config/TvUiConfig";
+    import FocusManager from "focus/FocusManager";
+    import IconManager from "icon/IconManager";
+    import AdManager from "ad/AdManager";
+    import { RemoteInputManager } from "input/RemoteInputManager";
+    export default class TvUi {
+        static root: typeof TvUiRoot;
+        static config: typeof TvUiConfigManager;
+        static focus: typeof FocusManager;
+        static icon: typeof IconManager;
+        static ads: typeof AdManager;
+        static api: typeof NativeBridge;
+        static input: typeof RemoteInputManager;
+        static back: typeof BackManager;
+        private static initialized;
+        static init(config?: TvUiConfig): void;
+        static destroy(): void;
+        private static exposeGlobal;
+        private static onGameHide;
+        private static onGameShow;
+    }
+}
+declare module "toast/UIFunctions" {
+    export default class UIFunctions {
+        static getChildrenAnimations(node: any): cc.Animation[];
+        static stopAnimations(animations: any): void;
+        static doShowAnimations(animations: any, finishCallback?: Function, target?: any): void;
+        static isAnimationRunning(animations: cc.Animation[]): any;
+        static doHideAnimations(animations: any, finishCallback?: Function, target?: any): boolean;
+        static getToggleIndex(toggle: cc.Toggle): number;
+        static selectToggleIndex(toggleContainer: cc.Node, index: any): void;
+        static setTouchEnabled(node: any, b: any): void;
+        static setButtonEnabled(btn: any, b: any): void;
+    }
+}
+declare module "toast/ToastComponent" {
+    export default class ToastComponent extends cc.Component {
+        label: cc.Label;
+        onLoad(): void;
+        start(): void;
+        hide(callback: any): any;
+        show(text: any): any;
+    }
+}
+declare module "toast/ToastManager" {
+    export default class ToastManager {
+        static readonly Inst: ToastManager;
+        private toastPool;
+        private prefab;
+        init(): Promise<void>;
+        private loadSpriteFrame;
+        onDestroy(): void;
+        make(text: any, dur?: number): any;
+        private show;
+    }
+}
+declare module "Info" {
+    export interface RewardVideoHooks {
+        onClose?: Function;
+        onFail?: Function;
+        onFinish?: Function;
+    }
+    export function showRewardVideo(scene: string, rewardType: string, callback: Function, target?: any, hooks?: RewardVideoHooks): void;
+}
+declare module "Loader" {
+    export class Loader {
+        static loadRes<T extends cc.Asset>(path: string, progressCallback?: (progress: number) => void): Promise<T>;
+        static loadResDir<T extends cc.Asset>(dir: string, progressCallback?: (progress: number, completedCount: number, totalCount: number) => void): Promise<T[]>;
+        static loadBatch(resources: Array<{
+            path: string;
+            key?: string;
+        }>, progressCallback?: (progress: number, completedCount: number, totalCount: number) => void): Promise<Map<string, any>>;
+    }
+}
+declare module "PlatformAdapter" {
+    import { EVideoScene } from "Define";
+    export class PlatformAdapter {
+        private static readonly cpId;
+        private static readonly version;
+        private static readonly designWidth;
+        private static readonly designHeight;
+        static init(): Promise<void>;
+        static showRewardVideo(scene: EVideoScene, rewardType: string, callback: Function, target?: any): void;
+        static registerButton(button: cc.Button): void;
+        static registerButtonByName(name: string, parent?: cc.Node): void;
+        static focusButtonByName(name: string, parent?: cc.Node): void;
+        static focusButton(btn: cc.Button): void;
+        static findChildByName(parent: cc.Node, name: string): cc.Node | null;
+        static showWindow(window: cc.Node): void;
+        static hideWindow(window: cc.Node): void;
+        static refreshWindow(window: cc.Node): void;
+        static showExitWin(): Promise<void>;
+    }
+}
+declare module "ExitWin" {
+    export default class ExitWin extends cc.Component {
+        btnCancel: cc.Button;
+        btnExit: cc.Button;
+        start(): void;
+        private onClickCancel;
+        private onClickExit;
+        onEnable(): void;
+        onDisable(): void;
+    }
+}
+declare module "ad/AdSlot" {
+    export default class AdSlot extends cc.Component {
+        slotId: string;
+        showOnLoad: boolean;
+        onEnable(): void;
+        onDisable(): void;
+        show(): void;
+        hide(): void;
+        refresh(): void;
+        static show(slotId: string): Promise<boolean>;
+        static hide(slotId: string): void;
+        static refresh(slotId: string): Promise<boolean>;
+    }
+}
+declare module "focus/FocusItem" {
+    export default class FocusItem extends cc.Component {
+        focusId: string;
+        scopeId: string;
+        iconKey: string;
+        up: string;
+        down: string;
+        left: string;
+        right: string;
+        focusScale: number;
+        autoRegister: boolean;
+        onEnable(): void;
+        onDisable(): void;
+        onFocus(): void;
+        onBlur(): void;
+        onConfirm(): void;
+    }
+}
+declare module "icon/IconConfig" {
+    import { TvUiIconItem } from "config/TvUiConfig";
+    export interface IconConfigMap {
+        [key: string]: TvUiIconItem;
+    }
+    export { TvUiIconItem };
+}
+declare module "toast/TvExitConfirmDialog" {
+    export default class TvExitConfirmDialog extends cc.Component {
+        private static pendingPromise;
+        private static currentDialog;
+        private static spriteCache;
+        private resolver;
+        private closed;
+        private tvBackHandler;
+        private tvFocusScopeId;
+        private cancelState;
+        private confirmState;
+        private onExitCallback;
+        static show(onExitCallback?: (confirmed: boolean) => void): Promise<boolean>;
+        private static getDialogParent;
+        private static getParentSize;
+        private static clearPending;
+        private open;
+        private loadSprites;
+        private buildView;
+        private createMask;
+        private createSpriteNode;
+        private createDialogButton;
+        private refreshButtonState;
+        private registerTvControls;
+        private registerFocus;
+        private setFocusedState;
+        private refreshAllButtonStates;
+        private unregisterTvControls;
+        private close;
+        private finish;
+        onDestroy(): void;
+    }
+}