@ives_xxz/framework 1.5.17 → 1.6.0

package/FW.d.ts

@@ -373,11 +373,12 @@ declare namespace FW {
   type Symbol = string | number;
 
   type UiManager = {
-    registerButtonEvent(args: FW.RegisterEventArgs | FW.RegisterEventArgs[]);
+    register(args: RegisterArgs);
+    find(path: string, referenceNode: cc.Node): cc.Node;
     pauseEvent<T extends TargetType>(target: T);
     resumeEvent<T extends TargetType>(target: T);
     hasRegister(eventName: string, target: FW.TargetType): boolean;
-    unRegisterEvent(args: FW.RegisterEventArgs);
+    unRegisterEvent(args: RegisterArgs);
     unRegisterTarget(target: TargetType);
     unRegisterAll();
     buttonEnable(target: TargetType);
@@ -599,7 +600,7 @@ declare namespace FW {
   /**
    * 事件管理参数
    */
-  type EventManagerArgs = string | number | object | [];
+  type EventManagerArgs = string | number | object | void | boolean | [];
 
   /**
    * 层级打开参数
@@ -1138,15 +1139,8 @@ declare namespace FW {
         prototype: T;
       }
     ): T;
-    /** 指定注册CC事件 */
-    registerCCEvent(eventName: string, event: FW.CCEvent | FW.CCEvent[]): void;
-
-    /** 指定注册框架自定义事件 */
-    registerFWEvent(eventName: string, event: FW.FWEvent | FW.FWEvent[]): void;
-
-    registerEvent(args: FW.RegisterEventArgs | FW.RegisterEventArgs[]): void;
-
-    unRegisterEvent(args: FW.RegisterEventArgs);
+    registerEvent(args: RegisterArgs): void;
+    unRegisterEvent(args: RegisterArgs);
     unRegisterAll(): void;
     unRegisterTarget(target: TargetType);
     /** 暂停事件 */
@@ -1168,15 +1162,34 @@ declare namespace FW {
   };
 
   type CCEvent = {
+    eventName?: string;
     cb: (...args: any) => void;
     target: TargetType;
+    responseInterval?: number;
     pause?: boolean;
+    enable?: boolean;
+    responseTime?: number;
+    lastResponseTimestamp?: number;
   };
 
   type FWEvent = {
+    eventName?: string;
     cb: (...args: any) => void;
-    target: any;
-    pause?: boolean;
+    responseTime?: number;
+    responseInterval?: number;
+    lastResponseTimestamp?: number;
+    options?: {
+      priority?: number;
+      intercept?: boolean;
+      pause?: boolean;
+      enable?: boolean;
+    };
+  };
+
+  type RegisterArgs = {
+    target?: any;
+    CCEvent?: CCEvent[];
+    FWEvent?: FWEvent[];
   };
 
   type RegisterEventArgs = {
@@ -1189,7 +1202,7 @@ declare namespace FW {
     /**
      * 注册事件对象
      */
-    target: any;
+    target?: any;
     /**
      * 自定义事件
      */

package/controller/FWLayerController.ts

@@ -1,7 +1,6 @@
 import { FWSystemDefine } from "../define/FWSystemDefine";
 import FWLayer from "../layer/FWLayer";
 import { FWLayerData } from "../manager/FWLayerManager";
-import FWLog from "../log/FWLog";
 import { FrameworkBase } from "../FrameworkBase";
 export abstract class FWLayerController
   extends FrameworkBase
@@ -56,17 +55,7 @@ export abstract class FWLayerController
    * @returns
    */
   find(path: string, referenceNode: cc.Node) {
-    if (!cc.isValid(parent)) {
-      FWLog.error(`查找节点失败:${path}`);
-      return undefined;
-    }
-    const node = cc.find(path, referenceNode);
-
-    if (!cc.isValid(node)) {
-      FWLog.error(`查找节点失败:${path}`);
-      return undefined;
-    }
-    return node;
+    return this.entry.uiMgr.find(path, referenceNode);
   }
 
   hide(ctr?: FW.LayerController) {
@@ -106,104 +95,63 @@ export abstract class FWLayerController
     return this.layer.getComponentInChildren(type);
   }
 
-  /** 指定注册CC事件 */
-  registerCCEvent(event: FW.CCEvent | FW.CCEvent[]);
-  registerCCEvent(eventName: string, event: FW.CCEvent | FW.CCEvent[]);
-  registerCCEvent() {
-    let eventName: string;
-    let event: FW.CCEvent | FW.CCEvent[];
-    if (arguments.length == 1) {
-      event = arguments[0];
-    } else {
-      eventName = arguments[0];
-      event = arguments[1];
-    }
-
-    if (Array.isArray(event)) {
-      event.forEach((v) => {
-        FW.Entry.uiMgr.registerButtonEvent({
-          eventName: eventName,
-          CCEvent: {
-            cb: v.cb,
-            target: v.target,
-            pause: v.pause,
-          },
-          responseInterval: this.defaultResponseInterval,
-          target: this,
-        });
-      });
-    } else {
-      FW.Entry.uiMgr.registerButtonEvent({
-        eventName: eventName,
-        CCEvent: {
-          cb: event.cb,
-          target: event.target,
-          pause: event.pause,
-        },
-        responseInterval: this.defaultResponseInterval,
-        target: this,
-      });
-    }
-  }
-
   /**
    *  注册事件
-   * 支持CC事件和框架事件
    */
-  registerEvent(args: FW.RegisterEventArgs | FW.RegisterEventArgs[]): void {
-    const cb: (d: FW.RegisterEventArgs) => void = (d: FW.RegisterEventArgs) => {
-      if (d.CCEvent) {
-        this.registerCCEvent(d.CCEvent);
-      } else {
-        this.registerFWEvent(d.FWEvent);
-      }
-    };
-
-    if (Array.isArray(args)) {
-      args.forEach((v) => {
-        cb(v);
-      });
-    } else {
-      cb(args);
-    }
-  }
-
-  /** 指定注册框架自定义事件 */
-  registerFWEvent(event: FW.FWEvent | FW.FWEvent[]);
-  registerFWEvent(eventName: string, event: FW.FWEvent | FW.FWEvent[]);
-  registerFWEvent() {
-    let eventName: string;
-    let event: FW.CCEvent | FW.CCEvent[];
-    if (arguments.length == 1) {
-      event = arguments[0];
-    } else {
-      eventName = arguments[0];
-      event = arguments[1];
-    }
-
-    if (Array.isArray(event)) {
-      event.forEach((v) => {
-        FW.Entry.uiMgr.registerButtonEvent({
+  registerEvent(args: FW.RegisterArgs): void {
+    args.target = args.target || this;
+    args.CCEvent?.forEach(
+      (v) => (v.responseInterval = this.defaultResponseInterval)
+    );
+    args.FWEvent?.forEach(
+      (v) => (v.responseInterval = this.defaultResponseInterval)
+    );
+    return this.entry.uiMgr.register({
+      target: this,
+      CCEvent: args?.CCEvent ? args?.CCEvent : [],
+      FWEvent: args?.FWEvent ? args?.FWEvent : [],
+    });
+  }
+
+  cc(
+    target: cc.Node,
+    cb: (event: cc.Event) => void,
+    responseInterval?: number,
+    eventName?: string
+  ): this {
+    this.registerEvent({
+      target: this,
+      CCEvent: [
+        {
+          eventName: eventName || cc.Node.EventType.TOUCH_END,
+          cb: cb,
+          target: target,
+          responseInterval: responseInterval,
+        },
+      ],
+    });
+
+    return this;
+  }
+
+  fw(
+    eventName: string,
+    cb: (event: cc.Event) => void,
+    target?: cc.Node,
+    responseInterval?: number
+  ): this {
+    this.registerEvent({
+      target: target || this,
+      FWEvent: [
+        {
           eventName: eventName,
-          FWEvent: {
-            target: v.target,
-            cb: v.cb,
-            pause: v.pause,
-          },
-          target: this,
-        });
-      });
-    } else {
-      FW.Entry.uiMgr.registerButtonEvent({
-        eventName: eventName,
-        FWEvent: {
-          target: event.target,
-          cb: event.cb,
-          pause: event.pause,
+          cb: cb,
+          responseInterval: responseInterval ?? this.defaultResponseInterval,
         },
-        target: this,
-      });
-    }
+      ],
+    });
+
+    return this;
   }
 
   /**
@@ -211,7 +159,7 @@ export abstract class FWLayerController
    * @param args
    * @returns
    */
-  unRegisterEvent(args: FW.RegisterEventArgs) {
+  unRegisterEvent(args: FW.RegisterArgs) {
     FW.Entry.uiMgr.unRegisterEvent(args);
   }
 

package/language/FWLanguage.ts

@@ -1,5 +1,5 @@
-import { FWEventDefine } from '../define/FWEventDefine';
-import { FWLodash } from '../utils/FWLodash';
+import { FWEventDefine } from "../define/FWEventDefine";
+import { FWLodash } from "../utils/FWLodash";
 
 const { ccclass, property, executeInEditMode } = cc._decorator;
 
@@ -10,8 +10,11 @@ export default abstract class FWLanguage extends cc.Component {
   protected _language: number = 0;
 
   @property({
-    type: FWLodash.CCEnum(['请选择语言', ...FW.Entry.languageMgr.getSupportedLanguages()]),
-    displayName: 'language',
+    type: FWLodash.CCEnum([
+      "请选择语言",
+      ...FW.Entry.languageMgr.getSupportedLanguages(),
+    ]),
+    displayName: "language",
     visible: true,
     serializable: true,
   })
@@ -31,7 +34,7 @@ export default abstract class FWLanguage extends cc.Component {
 
   private refreshInspector() {
     //@ts-ignore
-    Editor.Utils.refreshSelectedInspector('node', this.node.uuid);
+    Editor.Utils.refreshSelectedInspector("node", this.node.uuid);
   }
 
   protected onLoad(): void {
@@ -41,7 +44,7 @@ export default abstract class FWLanguage extends cc.Component {
         this._language = FW.Entry.languageMgr.getLanguageIndex();
         this.onLanguageChange();
       },
-      this,
+      this
     );
   }
 

package/manager/FWAssetManager.ts

@@ -105,54 +105,56 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
       ? assetProperty
       : [assetProperty];
 
-    propertys.forEach(async (property) => {
-      const bundleName = property.bundle || FW.Entry.bundleName;
-      const type = property.type;
-      const path = property.path;
-      const progress = property.progress;
-
-      if (!bundleName || bundleName === "") {
-        FWLog.error(`找不到bundle${bundleName},或者bundle未加载!`);
-        return undefined;
-      }
-
-      if (!path || path === "") {
-        FWLog.error(`找不到资源路径${path},请检查!`);
-        return undefined;
-      }
-
-      let bundle: cc.AssetManager.Bundle = await this.resMgr.loadBundle(
-        bundleName
-      );
-
-      if (!bundle) {
-        FWLog.error(`加载bundle失败,请检查!`);
-        return undefined;
-      }
+    await Promise.all(
+      propertys.map(async (property) => {
+        const bundleName = property.bundle || FW.Entry.bundleName;
+        const type = property.type;
+        const path = property.path;
+        const progress = property.progress;
+
+        if (!bundleName || bundleName === "") {
+          FWLog.error(`找不到bundle${bundleName},或者bundle未加载!`);
+          return undefined;
+        }
+
+        if (!path || path === "") {
+          FWLog.error(`找不到资源路径${path},请检查!`);
+          return undefined;
+        }
+
+        let bundle: cc.AssetManager.Bundle = await this.resMgr.loadBundle(
+          bundleName
+        );
 
-      return await this.invoke(
-        FW.Entry.promiseMgr.execute((resolve, reject, signal) => {
-          bundle.preload(
-            path,
-            type,
-            (
-              finish: number,
-              total: number,
-              item: cc.AssetManager.RequestItem
-            ) => {
-              progress?.(finish, total, item);
-            },
-            (err: Error, item: cc.AssetManager.RequestItem[]) => {
-              if (err || !item || item?.length == 0) {
-                reject(err || "preload failed!");
+        if (!bundle) {
+          FWLog.error(`加载bundle失败,请检查!`);
+          return undefined;
+        }
+
+        return await this.invoke(
+          FW.Entry.promiseMgr.execute((resolve, reject, signal) => {
+            bundle.preload(
+              path,
+              type,
+              (
+                finish: number,
+                total: number,
+                item: cc.AssetManager.RequestItem
+              ) => {
+                progress?.(finish, total, item);
+              },
+              (err: Error, item: cc.AssetManager.RequestItem[]) => {
+                if (err || !item || item?.length == 0) {
+                  reject(err || "preload failed!");
+                }
+                resolve(item);
               }
-              resolve(item);
-            }
-          );
-        }, FWSystemConfig.PromiseConfig.loadAsset).promise,
-        `preLoadAssets -> ${property.path}`
-      );
-    });
+            );
+          }, FWSystemConfig.PromiseConfig.loadAsset).promise,
+          `preLoadAssets -> ${property.path}`
+        );
+      })
+    );
   }
 
   /**

package/manager/FWLayerManager.ts

@@ -1,15 +1,8 @@
 import { FWManager } from "./FWManager";
-import { FWLayerController } from "../controller/FWLayerController";
 import { FWSystemDefine } from "../define/FWSystemDefine";
 import FWLayer from "../layer/FWLayer";
 import FWLog from "../log/FWLog";
 import { FWQueue } from "../utils/FWQueue";
-import FWAssetConfig from "../config/FWAssetConfig";
-import FWLogic from "../logic/FWLogic";
-import FWData from "../data/FWData";
-import FWSocketSender from "../service/socket/FWSocketSender";
-import FWSocketHandle from "../service/socket/FWSocketHandle";
-import Framework from "../Framework";
 import { FrameworkBase } from "../FrameworkBase";
 import { PerformanceMonitor } from "../expand/FWDecorator";
 

package/manager/FWUiManager.ts

@@ -1,97 +1,19 @@
-import FWLog from '../log/FWLog';
-import { FWManager } from './FWManager';
+import { searchChild } from "../expand/FWDecorator";
+import FWLog from "../log/FWLog";
+import { FWManager } from "./FWManager";
 
 export default class FWUiManager extends FWManager implements FW.UiManager {
-  /** 默认点击时间间隔 */
-  private eventMap: Map<string, FW.CCEvent | FW.FWEvent> = new Map<
-    string,
-    FW.CCEvent | FW.FWEvent
-  >();
+  private eventMap: Map<
+    number,
+    {
+      uniqueId: number;
+      target: FW.TargetType;
+      event: FW.CCEvent | FW.FWEvent;
+    }
+  > = new Map();
+  private uniqueId: number = 0;
   public initialize(): void {}
   public onDestroy(): void {}
-  registerButtonEvent(args: FW.RegisterEventArgs | FW.RegisterEventArgs[]) {
-    const register: (eventArgs: FW.RegisterEventArgs) => void = (
-      eventArgs: FW.RegisterEventArgs,
-    ) => {
-      if (eventArgs?.CCEvent?.target instanceof cc.Node) {
-        if (cc.isValid(eventArgs.CCEvent.target)) {
-          eventArgs.CCEvent.target.on(
-            eventArgs.eventName || cc.Node.EventType.TOUCH_END,
-            (evt: cc.Event.EventTouch, custom?: string) => {
-              /** 未设置禁用默认为启用状态 */
-              if (eventArgs.enable === undefined) {
-                eventArgs.enable = true;
-              }
-
-              if (!eventArgs.enable) return;
-
-              /** 检测触发间隔 */
-              if (Date.now() - eventArgs.lastResponseTimestamp < eventArgs.responseInterval) {
-                return;
-              }
-
-              const button = (eventArgs.CCEvent.target as cc.Node).getComponent(cc.Button);
-              if (button && !button.interactable) return;
-
-              eventArgs.lastResponseTimestamp = Date.now();
-              eventArgs.CCEvent.cb?.bind(eventArgs.target)?.(evt, custom, eventArgs.data);
-            },
-            eventArgs.CCEvent.target,
-          );
-          this.eventMap.set(
-            `${eventArgs.eventName}_${eventArgs.CCEvent.target.name}`,
-            eventArgs.CCEvent,
-          );
-        } else {
-          FWLog.warn(`register CCEvent is not cc.Node:${eventArgs.CCEvent.target}`);
-          return;
-        }
-      }
-
-      if (eventArgs.FWEvent) {
-        FW.Entry.evtMgr?.register(
-          eventArgs.eventName,
-          (
-            args1?: FW.EventManagerArgs,
-            args2?: FW.EventManagerArgs,
-            args3?: FW.EventManagerArgs,
-            args4?: FW.EventManagerArgs,
-            args5?: FW.EventManagerArgs,
-            args6?: FW.EventManagerArgs,
-            args7?: FW.EventManagerArgs,
-            args8?: FW.EventManagerArgs,
-            args9?: FW.EventManagerArgs,
-            args10?: FW.EventManagerArgs,
-          ) => {
-            if (Date.now() - eventArgs.lastResponseTimestamp < (eventArgs.responseInterval || 0)) {
-              return;
-            }
-            eventArgs.lastResponseTimestamp = Date.now();
-            eventArgs.FWEvent.cb?.bind(eventArgs.FWEvent.target)(
-              args1,
-              args2,
-              args3,
-              args4,
-              args5,
-              args6,
-              args7,
-              args8,
-              args9,
-              args10,
-            );
-          },
-          eventArgs.FWEvent.target,
-        );
-        this.eventMap.set(eventArgs.eventName, eventArgs.FWEvent);
-      }
-    };
-
-    if (Array.isArray(args)) {
-      args.forEach((v) => register(v));
-    } else {
-      register(args);
-    }
-  }
 
   /** 暂停事件 */
   pauseEvent(target: FW.TargetType) {
@@ -114,29 +36,55 @@ export default class FWUiManager extends FWManager implements FW.UiManager {
     this.eventMap.forEach((v) => FW.Entry.evtMgr?.targetResume(v));
   }
 
-  unRegisterEvent(args: FW.RegisterEventArgs) {
-    if (this.eventMap.has(args.eventName)) return;
-    this.eventMap.delete(args.eventName);
+  unRegisterEvent(args: FW.RegisterArgs) {
+    this.eventMap.forEach((evt) => {
+      if (args.target === evt.target) {
+        if (this.eventMap.has(evt.uniqueId)) {
+          this.eventMap.delete(evt.uniqueId);
+          FW.Entry.evtMgr.unRegister(evt.event.eventName, evt.target);
+        }
+      }
+    });
   }
 
   unRegisterAll() {
+    this.eventMap.forEach((evt) => this.unRegisterTarget(evt.target));
     this.eventMap.clear();
   }
 
   unRegisterTarget(target: FW.TargetType) {
-    this.eventMap.forEach((v) => {
-      if (v.target == target) FW.Entry.evtMgr?.targetOff(v.target);
+    this.eventMap.forEach((evt) => {
+      if (evt.target == target) {
+        FW.Entry.evtMgr?.targetOff(evt.target);
+        this.eventMap.delete(evt.uniqueId);
+      }
     });
   }
 
   hasRegister(eventName: string, target: FW.TargetType): boolean {
     let has = false;
     this.eventMap.forEach((v, key) => {
-      if (v.target == target && key == eventName) has = true;
+      if (v.target == target && v.event.eventName == eventName) has = true;
     });
     return has;
   }
 
+  find(path: string, rootNode: cc.Node): cc.Node | null {
+    if (!cc.isValid(rootNode)) {
+      FWLog.error(`查找节点失败: ${path}, 根节点无效`);
+      return null;
+    }
+
+    const node = searchChild(rootNode, path);
+
+    if (!cc.isValid(node)) {
+      FWLog.warn(`未找到节点: ${path}`);
+      return null;
+    }
+
+    return node;
+  }
+
   buttonEnable(target: FW.TargetType) {
     this.eventMap.forEach((v) => {
       const node = v.target as cc.Node;
@@ -149,6 +97,7 @@ export default class FWUiManager extends FWManager implements FW.UiManager {
       }
     });
   }
+
   buttonDisable(target: FW.TargetType) {
     this.eventMap.forEach((v) => {
       const node = v.target as cc.Node;
@@ -161,4 +110,95 @@ export default class FWUiManager extends FWManager implements FW.UiManager {
       }
     });
   }
+
+  register(args: FW.RegisterArgs) {
+    if (!args.target) {
+      FWLog.error("注册事件失败,目标为空!");
+      return;
+    }
+
+    this.uniqueId++;
+
+    if (args.CCEvent) {
+      args.CCEvent.forEach((evt) => {
+        if (evt.target instanceof cc.Node && cc.isValid(evt.target)) {
+          evt.target.on(
+            evt.eventName || cc.Node.EventType.TOUCH_END,
+            (e: cc.Event.EventTouch, c?: string) => {
+              if (evt.enable === undefined) {
+                evt.enable = true;
+              }
+
+              if (!evt.enable) return;
+
+              /** 检测触发间隔 */
+              if (
+                Date.now() - evt.lastResponseTimestamp <
+                evt.responseInterval
+              ) {
+                return;
+              }
+
+              const button = evt.target.getComponent(cc.Button);
+              if (button && !button.interactable) return;
+
+              evt.lastResponseTimestamp = Date.now();
+              evt.cb?.bind(args.target)?.(e, c);
+            },
+            args.target
+          );
+          this.eventMap.set(this.uniqueId, {
+            uniqueId: this.uniqueId,
+            target: args.target,
+            event: evt,
+          });
+        }
+      });
+    } else if (args.FWEvent) {
+      args.FWEvent.forEach((evt) => {
+        FW.Entry.evtMgr?.register(
+          evt.eventName,
+          (
+            args1?: FW.EventManagerArgs,
+            args2?: FW.EventManagerArgs,
+            args3?: FW.EventManagerArgs,
+            args4?: FW.EventManagerArgs,
+            args5?: FW.EventManagerArgs,
+            args6?: FW.EventManagerArgs,
+            args7?: FW.EventManagerArgs,
+            args8?: FW.EventManagerArgs,
+            args9?: FW.EventManagerArgs,
+            args10?: FW.EventManagerArgs
+          ) => {
+            if (
+              Date.now() - evt.lastResponseTimestamp <
+              (evt.responseInterval || 0)
+            ) {
+              return;
+            }
+            evt.lastResponseTimestamp = Date.now();
+            evt.cb?.bind(args.target)(
+              args1,
+              args2,
+              args3,
+              args4,
+              args5,
+              args6,
+              args7,
+              args8,
+              args9,
+              args10
+            );
+          },
+          args.target
+        );
+
+        this.eventMap.set(this.uniqueId, {
+          uniqueId: this.uniqueId,
+          target: args.target,
+          event: evt,
+        });
+      });
+    }
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ives_xxz/framework",
-  "version": "1.5.17",
+  "version": "1.6.0",
   "description": "cocoscreator 2.x mvc framework",
   "main": "index.js",
   "keywords": [

package/service/http/FWHttp.ts

@@ -1,9 +1,10 @@
-import { FWSystemConfig } from '../../config/FWSystemConfig';
-import { FWSystemDefine } from '../../define/FWSystemDefine';
-import FWLog from '../../log/FWLog';
-import FWService from '../FWService';
+import { FWSystemConfig } from "../../config/FWSystemConfig";
+import { FWSystemDefine } from "../../define/FWSystemDefine";
+import FWLog from "../../log/FWLog";
+import FWService from "../FWService";
 
 export default class FWHttp extends FWService {
+  public initialize() {}
   public onDestroy(): void {}
   protected onRestart(): void {}
 
@@ -11,18 +12,30 @@ export default class FWHttp extends FWService {
     url: string,
     params?: string,
     cb?: (response: string) => void,
-    tag?: string,
+    tag?: string
   ): Promise<string> {
-    return this.process(url, params, cb, tag, FWSystemDefine.FWHttpRequestType.GET);
+    return this.process(
+      url,
+      params,
+      cb,
+      tag,
+      FWSystemDefine.FWHttpRequestType.GET
+    );
   }
 
   protected async postMessage(
     url: string,
     params?: string,
     cb?: (response: string) => void,
-    tag?: string,
+    tag?: string
   ): Promise<string> {
-    return this.process(url, params, cb, tag, FWSystemDefine.FWHttpRequestType.POST);
+    return this.process(
+      url,
+      params,
+      cb,
+      tag,
+      FWSystemDefine.FWHttpRequestType.POST
+    );
   }
 
   private async process(
@@ -30,48 +43,54 @@ export default class FWHttp extends FWService {
     params: string,
     cb: (response: any) => void,
     tag: string,
-    type: FWSystemDefine.FWHttpRequestType,
+    type: FWSystemDefine.FWHttpRequestType
   ): Promise<string> {
     let xhr: XMLHttpRequest;
 
-    const promiseProxy: FW.PromiseProxy<string> = FW.Entry.promiseMgr.execute<string>(
-      (resolve, reject, signal, reason) => {
-        xhr = new XMLHttpRequest();
+    const promiseProxy: FW.PromiseProxy<string> =
+      FW.Entry.promiseMgr.execute<string>(
+        (resolve, reject, signal, reason) => {
+          xhr = new XMLHttpRequest();
 
-        xhr.onreadystatechange = () => {
-          if (xhr.readyState == 4 && xhr.status === 200) {
-            cb?.(xhr.response);
-            resolve(xhr.response);
-          }
-        };
+          xhr.onreadystatechange = () => {
+            if (xhr.readyState == 4 && xhr.status === 200) {
+              cb?.(xhr.response);
+              resolve(xhr.response);
+            }
+          };
 
-        xhr.onerror = (err: any) => {
-          FWLog.error(err);
-          this.onError?.(err);
-          reject(`http request error:${err}`);
-        };
+          xhr.onerror = (err: any) => {
+            FWLog.error(err);
+            this.onError?.(err);
+            reject(`http request error:${err}`);
+          };
 
-        xhr.ontimeout = () => {
-          this.onTimeout?.();
-          reject(`http request timeout!`);
-        };
+          xhr.ontimeout = () => {
+            this.onTimeout?.();
+            reject(`http request timeout!`);
+          };
 
-        xhr.open(type, url, true);
-        xhr.send(params);
-      },
-      {
-        ...FWSystemConfig.PromiseConfig.http,
-        retryCondition(error, retryCount) {
-          return xhr.readyState != 4 || (xhr.status !== 200 && retryCount < 3);
+          xhr.open(type, url, true);
+          xhr.send(params);
         },
-      },
-    );
+        {
+          ...FWSystemConfig.PromiseConfig.http,
+          retryCondition(error, retryCount) {
+            return (
+              xhr.readyState != 4 || (xhr.status !== 200 && retryCount < 3)
+            );
+          },
+        }
+      );
 
     promiseProxy.addAbortEventListener(() => {
       xhr.abort();
     });
 
-    return await this.invoke(promiseProxy.promise, tag ? `http request ->${tag}` : '');
+    return await this.invoke(
+      promiseProxy.promise,
+      tag ? `http request ->${tag}` : ""
+    );
   }
 
   onError?(err: any);