@next-core/build-config-factory 2.20.0 → 2.23.0

package/CHANGELOG.md

@@ -3,6 +3,47 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.23.0](https://github.com/easyops-cn/next-core/compare/@next-core/build-config-factory@2.22.0...@next-core/build-config-factory@2.23.0) (2022-07-12)
+
+
+### Bug Fixes
+
+* **generateBrickDocs:** filter inherited properties ([38daaff](https://github.com/easyops-cn/next-core/commit/38daaffa0dcb5c4ef66cc3d846e525db2ea3ba95))
+
+
+### Features
+
+* **generateBrickDocs:** support typle types ([148ad87](https://github.com/easyops-cn/next-core/commit/148ad87935a8deac87c69fd4d60828a2aef7723f))
+
+
+
+
+
+# [2.22.0](https://github.com/easyops-cn/next-core/compare/@next-core/build-config-factory@2.21.0...@next-core/build-config-factory@2.22.0) (2022-07-11)
+
+
+### Features
+
+* **generateBrickDocs:** support function type ([b085bbf](https://github.com/easyops-cn/next-core/commit/b085bbf089b89dc6e7fa7f743a69731b24ea449a))
+
+
+
+
+
+# [2.21.0](https://github.com/easyops-cn/next-core/compare/@next-core/build-config-factory@2.20.0...@next-core/build-config-factory@2.21.0) (2022-07-07)
+
+
+### Features
+
+* **generateBrickDocs:** support description of enum and interface ([3b81fe1](https://github.com/easyops-cn/next-core/commit/3b81fe1a5ee3d1666083fad50c7da8d62379c98a))
+* **generateBrickDocs:** support get detail of reflection type from declaration ([b62557f](https://github.com/easyops-cn/next-core/commit/b62557f09a362a85ac25151d8940cec4e691700b))
+* **generateBrickDocs:** support get parameters type of method from declaration ([e88bef6](https://github.com/easyops-cn/next-core/commit/e88bef6006140001bd44271911566df497e03ca4))
+* **generateBrickDocs:** support get property type from setter ([5825363](https://github.com/easyops-cn/next-core/commit/5825363195c4359a21b9b80360a58a261e886825))
+
+
+
+
+
 # [2.20.0](https://github.com/easyops-cn/next-core/compare/@next-core/build-config-factory@2.19.0...@next-core/build-config-factory@2.20.0) (2022-07-05)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next-core/build-config-factory",
-  "version": "2.20.0",
+  "version": "2.23.0",
   "description": "build config factory",
   "homepage": "https://github.com/easyops-cn/next-core/tree/master/packages/build-config-factory",
   "license": "GPL-3.0",
@@ -18,7 +18,7 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@next-core/brick-utils": "^2.37.20",
+    "@next-core/brick-utils": "^2.37.21",
     "@next-core/repo-config": "^0.2.1",
     "@next-core/typedoc-plugin-filter-inherit": "^1.2.2",
     "@next-core/webpack-config-factory": "^2.16.6",
@@ -37,5 +37,5 @@
     "typedoc": "^0.19.2",
     "typedoc-plugin-no-inherit": "^1.2.2"
   },
-  "gitHead": "81ac28a0f1346239d497cd23acc7795e5f8c21cc"
+  "gitHead": "c8dfe32cac64f85af7aa55e420d6b5182d1c1505"
 }

package/src/generateBrickDocs.js

@@ -100,11 +100,24 @@ function convertTagsToMapByFields(tags, fields) {
   }, {});
 }
 
+function getClassChildType(child) {
+  let type = child.type;
+
+  // setter
+  if (!type && child.kindString === "Accessor" && child.setSignature) {
+    type = child.setSignature[0].parameters[0].type;
+  }
+
+  return type;
+}
+
 function composeBrickDocProperties(brick) {
-  const { name, comment, type, flags, defaultValue } = brick;
+  const { name, comment, flags, defaultValue } = brick;
+  const type = getClassChildType(brick);
+
   return {
     name,
-    type: extractRealInterfaceType(type?.type, type),
+    type: extractRealInterfaceType(type),
     required: flags?.isOptional !== true,
     default: defaultValue,
     ...convertTagsToMapByFields(get(comment, "tags", []), propertyDocComments),
@@ -126,7 +139,7 @@ function getEventTypeByDecorators(decorators) {
 function getDetailTypeByEventType(type) {
   if (type.name === "EventEmitter" && type.typeArguments?.length > 0) {
     const argument = type.typeArguments[0];
-    return extractRealInterfaceType(argument.type, argument);
+    return extractRealInterfaceType(argument);
   }
 }
 
@@ -148,6 +161,14 @@ function composeBrickDocMethods(brick) {
     [];
   return {
     name,
+    params: signatures[0].parameters
+      ?.map(
+        (parameter) =>
+          `${parameter.name}${
+            parameter.flags?.isOptional ? "?" : ""
+          }: ${extractRealInterfaceType(parameter.type)}`
+      )
+      .join(", "),
     ...convertTagsToMapByFields(tags, methodComments),
   };
 }
@@ -293,8 +314,8 @@ function existBrickDocId(element) {
   }
 }
 
-function extractRealInterfaceType(type, typeData, parentType) {
-  switch (type) {
+function extractRealInterfaceType(typeData, parentType) {
+  switch (typeData?.type) {
     case "reference":
       // eslint-disable-next-line no-case-declarations
       let result = "";
@@ -304,26 +325,25 @@ function extractRealInterfaceType(type, typeData, parentType) {
 
       if (typeData.typeArguments && typeData.typeArguments.length > 0) {
         result += `<${typeData.typeArguments
-          .map((type) => extractRealInterfaceType(type.type, type))
+          .map((type) => extractRealInterfaceType(type))
           .join(", ")}>`;
       }
 
       return result;
     case "array":
       return `${extractRealInterfaceType(
-        typeData.elementType.type,
         typeData.elementType,
-        type
+        typeData.type
       )}[]`;
-    case "union":
-      if (parentType === "array") {
-        return `(${typeData.types
-          .map((type) => extractRealInterfaceType(type.type, type))
-          .join(" | ")})`;
-      }
-      return typeData.types
-        .map((type) => extractRealInterfaceType(type.type, type))
+    case "union": {
+      const typeStr = typeData.types
+        .map((type) => extractRealInterfaceType(type, typeData.type))
         .join(" | ");
+
+      return parentType === "array" || parentType === "union"
+        ? `(${typeStr})`
+        : typeStr;
+    }
     case "stringLiteral":
       return `"${typeData.value}"`;
     case "intrinsic":
@@ -332,10 +352,55 @@ function extractRealInterfaceType(type, typeData, parentType) {
       return typeData.name;
     case "intersection":
       return typeData.types
-        .map((type) => extractRealInterfaceType(type.type, type))
+        .map((type) => extractRealInterfaceType(type))
         .join(" & ");
-    case "reflection":
-      return "object";
+    case "reflection": {
+      if (typeData.declaration) {
+        const {
+          signatures,
+          children = [],
+          indexSignature = [],
+        } = typeData.declaration;
+
+        if (signatures) {
+          const { parameters, type } = signatures[0];
+          const typeStr = `(${parameters
+            ?.map(
+              (parameter) =>
+                `${parameter.name}${
+                  parameter.flags?.isOptional ? "?" : ""
+                }: ${extractRealInterfaceType(parameter.type)}`
+            )
+            .join(", ")}) => ${extractRealInterfaceType(type)}`;
+
+          return parentType === "array" || parentType === "union"
+            ? `(${typeStr})`
+            : typeStr;
+        } else {
+          return `{ ${[
+            ...children.map(
+              (child) =>
+                `${child.name}${
+                  child.flags?.isOptional ? "?" : ""
+                }: ${extractRealInterfaceType(child.type)};`
+            ),
+            ...indexSignature.map((item) => {
+              const parameter = item.parameters[0];
+              return `[${parameter.name}: ${extractRealInterfaceType(
+                parameter.type.type,
+                parameter.type
+              )}]: ${extractRealInterfaceType(item.type)};`;
+            }),
+          ].join(" ")} }`;
+        }
+      } else {
+        return "object";
+      }
+    }
+    case "tuple":
+      return `[${typeData.elements
+        ?.map((element) => element.name)
+        .join(", ")}]`;
     default:
       return "";
   }
@@ -347,7 +412,7 @@ function extractBrickDocTypes(type) {
     typeParameter: getTypeParameter(type),
     kind: "type",
     description: get(type, ["comment", "shortText"], "").trim(),
-    type: extractRealInterfaceType(type.type.type, type.type),
+    type: extractRealInterfaceType(type.type),
   };
 }
 
@@ -356,6 +421,7 @@ function extractBrickDocEnumerations(enumerations) {
     name: enumerations.name,
     typeParameter: null,
     kind: "enum",
+    description: enumerations?.comment?.shortText?.trim(),
     children: [
       ...enumerations.children.map((child) => {
         return {
@@ -402,29 +468,32 @@ function extractBrickDocInterface(typeIds, references) {
             typeParameter: getTypeParameter(finder),
             kind: "interface",
             extendedTypes: finder.extendedTypes,
+            description: finder?.comment?.shortText?.trim(),
             children:
-              finder.children?.map((child) => {
-                return {
-                  name: child.name,
-                  type: extractRealInterfaceType(child.type.type, child.type),
-                  required: !get(child, ["flags", "isOptional"], false),
-                  description: get(child, ["comment", "shortText"], "").trim(),
-                };
-              }) || [],
+              finder.children
+                ?.filter((child) => !child.inheritedFrom)
+                .map((child) => {
+                  return {
+                    name: child.name,
+                    type: extractRealInterfaceType(child.type),
+                    required: !get(child, ["flags", "isOptional"], false),
+                    description: get(
+                      child,
+                      ["comment", "shortText"],
+                      ""
+                    ).trim(),
+                  };
+                }) || [],
             indexSignature:
               finder.indexSignature?.map((child) => {
                 return {
                   name: child.name,
                   parameters: child.parameters.map((parameter) => ({
                     ...parameter,
-                    type: extractRealInterfaceType(
-                      parameter.type.type,
-                      parameter.type
-                    ),
+                    type: extractRealInterfaceType(parameter.type),
                   })),
-                  type: extractRealInterfaceType(child.type.type, child.type),
+                  type: extractRealInterfaceType(child.type),
                   required: !get(child, ["flags", "isOptional"], false),
-                  description: get(child, ["comment", "shortText"], "").trim(),
                 };
               }) || [],
           };
@@ -467,12 +536,25 @@ function traverseElementUsedInterfaceIds(
   traversedTypeSet
 ) {
   element.children.forEach((child) => {
-    traverseUsedReferenceIdsByType(
-      child.type,
-      usedReferenceIds,
-      references,
-      traversedTypeSet
-    );
+    if (child.kindString === "Method") {
+      child.signatures[0].parameters?.map((parameter) =>
+        traverseUsedReferenceIdsByType(
+          parameter.type,
+          usedReferenceIds,
+          references,
+          traversedTypeSet
+        )
+      );
+    } else {
+      const type = getClassChildType(child);
+
+      traverseUsedReferenceIdsByType(
+        type,
+        usedReferenceIds,
+        references,
+        traversedTypeSet
+      );
+    }
   });
 }
 
@@ -581,6 +663,54 @@ function traverseUsedReferenceIdsByType(
         traversedTypeSet
       );
       break;
+    case "reflection":
+      if (type.declaration) {
+        const { signatures, children, indexSignature } = type.declaration;
+
+        signatures?.forEach((signature) => {
+          signature.parameters?.forEach((parameter) =>
+            traverseUsedReferenceIdsByType(
+              parameter.type,
+              usedReferenceIds,
+              references,
+              traversedTypeSet
+            )
+          );
+          traverseUsedReferenceIdsByType(
+            signature.type,
+            usedReferenceIds,
+            references,
+            traversedTypeSet
+          );
+        });
+        children?.forEach((child) => {
+          traverseUsedReferenceIdsByType(
+            child.type,
+            usedReferenceIds,
+            references,
+            traversedTypeSet
+          );
+        });
+        indexSignature?.forEach((item) => {
+          traverseUsedReferenceIdsByType(
+            item.type,
+            usedReferenceIds,
+            references,
+            traversedTypeSet
+          );
+        });
+      }
+      break;
+    case "tuple":
+      type.elements?.forEach((element) =>
+        traverseUsedReferenceIdsByType(
+          element,
+          usedReferenceIds,
+          references,
+          traversedTypeSet
+        )
+      );
+      break;
   }
 }