Support parse method result

packages/loader/src/resource-deserialize/resources/parser/ReflectionParser.ts

@@ -2,11 +2,14 @@
 import type {
   IAssetRef,
   IBasicType,
+  ICanCallbackMethodObject,
   IClassObject,
+  IClassTypeObject,
+  IComponentRef,
   IEntity,
   IEntityRef,
-  IComponentRef,
   IHierarchyFile,
+  IMethodParams,
   IRefEntity
 } from "../schema";
 import { ParserContext, ParserType } from "./ParserContext";
@@ -70,17 +73,27 @@
     });
   }
 
-  parseMethod(instance: any, methodName: string, methodParams: Array<IBasicType>) {
-    return Promise.all(methodParams.map((param) => this.parseBasicType(param))).then((result) => {
-      return instance[methodName](...result);
+  parseMethod(instance: any, methodName: string, methodParams: IMethodParams) {
+    const isCanCallbackMethodObject = ReflectionParser._isCanCallbackMethodObject(methodParams);
+    const params = isCanCallbackMethodObject ? methodParams.params : methodParams;
+
+    return Promise.all(params.map((param) => this.parseBasicType(param))).then((result) => {
+      const methodCallback = instance[methodName](...result);
+      if (isCanCallbackMethodObject && methodParams.callback) {
+        return this.parsePropsAndMethods(methodCallback, methodParams.callback);
+      } else {
+        return methodCallback;
+      }
     });
   }
 
   parseBasicType(value: IBasicType, originValue?: any): Promise<any> {
     if (Array.isArray(value)) {
       return Promise.all(value.map((item) => this.parseBasicType(item)));
     } else if (typeof value === "object" && value != null) {
-      if (ReflectionParser._isClass(value)) {
+      if (ReflectionParser._isClassType(value)) {
+        return Promise.resolve(Loader.getClass(value["classType"]));
+      } else if (ReflectionParser._isClass(value)) {
         // class object
         return this.parseClassObject(value);
       } else if (ReflectionParser._isAssetRef(value)) {
@@ -158,6 +171,10 @@
     return value["class"] !== undefined;
   }
 
+  private static _isClassType(value: any): value is IClassTypeObject {
+    return value["classType"] !== undefined;
+  }
+
   private static _isAssetRef(value: any): value is IAssetRef {
     return value["refId"] !== undefined;
   }
@@ -169,4 +186,8 @@
   private static _isComponentRef(value: any): value is IComponentRef {
     return value["ownerId"] !== undefined && value["componentId"] !== undefined;
   }
+
+  private static _isCanCallbackMethodObject(value: any): value is ICanCallbackMethodObject {
+    return Array.isArray(value?.params);
+  }
 }

packages/loader/src/resource-deserialize/resources/schema/BasicSchema.ts

@@ -28,7 +28,15 @@ export interface IHierarchyFile {
   entities: Array<IEntity>;
 }
 
-export type IMethodParams = Array<IBasicType>;
+export type ICanCallbackMethodObject = {
+  params: Array<IBasicType>;
+  callback?: {
+    methods?: { [methodName: string]: Array<IMethodParams> };
+    props?: { [key: string]: IBasicType | IMethodParams };
+  };
+};
+
+export type IMethodParams = Array<IBasicType> | ICanCallbackMethodObject;
 
 export interface IBasicEntity {
   name?: string;
@@ -73,11 +81,15 @@ export type IComponent = { id: string; refId?: string } & IClassObject;
 
 export type IClassObject = {
   class: string;
-  constructParams?: IMethodParams;
+  constructParams?: Array<IBasicType>;
   methods?: { [methodName: string]: Array<IMethodParams> };
   props?: { [key: string]: IBasicType | IMethodParams };
 };
 
+export type IClassTypeObject = {
+  classType: string;
+};
+
 export type IBasicType =
   | string
   | number
@@ -86,6 +98,7 @@ export type IBasicType =
   | undefined
   | IAssetRef
   | IClassObject
+  | IClassTypeObject
   | IMethodParams
   | IEntityRef;