@next-core/build-config-factory 2.18.52 → 2.21.0

package/CHANGELOG.md

@@ -3,6 +3,48 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [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)
+
+
+### Features
+
+* **generateBrickDocs:** support infer required and default of property and detail of event from declaration ([6a60f26](https://github.com/easyops-cn/next-core/commit/6a60f26563683d89d5b36bb766f973cb23522e70))
+
+
+
+
+
+# [2.19.0](https://github.com/easyops-cn/next-core/compare/@next-core/build-config-factory@2.18.52...@next-core/build-config-factory@2.19.0) (2022-07-05)
+
+
+### Bug Fixes
+
+* **generateBrickDocs:** type will not be traversed in another module once traversed ([c539bcf](https://github.com/easyops-cn/next-core/commit/c539bcf86a8d7d0955f4115373db838032c5c677))
+
+
+### Features
+
+* **generateBrickDocs:** add support for extendedTypes ([12c9e53](https://github.com/easyops-cn/next-core/commit/12c9e536b07104a9ee8478cbe8c2aa6887751335))
+* **generateBrickDocs:** add support for index signature ([1f16c2c](https://github.com/easyops-cn/next-core/commit/1f16c2c1a961a43a139f8bef1117c8eb4e4ba3f6))
+
+
+
+
+
 ## [2.18.52](https://github.com/easyops-cn/next-core/compare/@next-core/build-config-factory@2.18.51...@next-core/build-config-factory@2.18.52) (2022-06-28)
 
 **Note:** Version bump only for package @next-core/build-config-factory

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next-core/build-config-factory",
-  "version": "2.18.52",
+  "version": "2.21.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.19",
+    "@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": "d833b9eedbc33d9fe4ec1041455de693018e5dd4"
+  "gitHead": "34a0808712ecaa925d0860d281ab23cf3bec7317"
 }

package/src/generateBrickDocs.js

@@ -100,12 +100,26 @@ 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 } = brick;
-  const type = brick.type && brick.type.type;
+  const { name, comment, flags, defaultValue } = brick;
+  const type = getClassChildType(brick);
+
   return {
     name,
-    type: extractRealInterfaceType(type, brick.type),
+    type: extractRealInterfaceType(type),
+    required: flags?.isOptional !== true,
+    default: defaultValue,
     ...convertTagsToMapByFields(get(comment, "tags", []), propertyDocComments),
   };
 }
@@ -122,11 +136,19 @@ function getEventTypeByDecorators(decorators) {
   return null;
 }
 
+function getDetailTypeByEventType(type) {
+  if (type.name === "EventEmitter" && type.typeArguments?.length > 0) {
+    const argument = type.typeArguments[0];
+    return extractRealInterfaceType(argument);
+  }
+}
+
 function composeBrickDocEvents(brick) {
-  const { comment, decorators } = brick;
+  const { comment, decorators, type } = brick;
 
   return {
     type: getEventTypeByDecorators(decorators),
+    detail: getDetailTypeByEventType(type),
     ...convertTagsToMapByFields(get(comment, "tags", []), eventDocComments),
   };
 }
@@ -139,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),
   };
 }
@@ -284,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 = "";
@@ -295,25 +325,24 @@ 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))
+          .map((type) => extractRealInterfaceType(type))
           .join(" | ")})`;
       }
       return typeData.types
-        .map((type) => extractRealInterfaceType(type.type, type))
+        .map((type) => extractRealInterfaceType(type))
         .join(" | ");
     case "stringLiteral":
       return `"${typeData.value}"`;
@@ -323,10 +352,31 @@ 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 { children = [], indexSignature = [] } = typeData.declaration;
+
+        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";
+      }
+    }
     default:
       return "";
   }
@@ -338,7 +388,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),
   };
 }
 
@@ -347,6 +397,7 @@ function extractBrickDocEnumerations(enumerations) {
     name: enumerations.name,
     typeParameter: null,
     kind: "enum",
+    description: enumerations?.comment?.shortText?.trim(),
     children: [
       ...enumerations.children.map((child) => {
         return {
@@ -392,16 +443,30 @@ function extractBrickDocInterface(typeIds, references) {
             name: finder.name,
             typeParameter: getTypeParameter(finder),
             kind: "interface",
-            children: [
-              ...finder.children.map((child) => {
+            extendedTypes: finder.extendedTypes,
+            description: finder?.comment?.shortText?.trim(),
+            children:
+              finder.children?.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,
-                  type: extractRealInterfaceType(child.type.type, child.type),
+                  parameters: child.parameters.map((parameter) => ({
+                    ...parameter,
+                    type: extractRealInterfaceType(parameter.type),
+                  })),
+                  type: extractRealInterfaceType(child.type),
                   required: !get(child, ["flags", "isOptional"], false),
                   description: get(child, ["comment", "shortText"], "").trim(),
                 };
-              }),
-            ],
+              }) || [],
           };
         }
 
@@ -438,10 +503,29 @@ function traverseExtraInterfaceReferences(modules, References) {
 function traverseElementUsedInterfaceIds(
   element,
   usedReferenceIds,
-  references
+  references,
+  traversedTypeSet
 ) {
   element.children.forEach((child) => {
-    traverseUsedReferenceIdsByType(child.type, usedReferenceIds, references);
+    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
+      );
+    }
   });
 }
 
@@ -461,13 +545,19 @@ function traverseModules(modules, brickDocs) {
     if (!elementId) return;
 
     const usedReferenceIds = new Set();
+    const traversedTypeSet = new Set();
     const classElement = module.children.find(
       (child) => child.id === elementId && existBrickDocId(child)
     );
     if (!classElement) return;
     const { comment, children, groups } = classElement;
     const references = [...module.children, ...extraInterfaceReferencesValues];
-    traverseElementUsedInterfaceIds(classElement, usedReferenceIds, references);
+    traverseElementUsedInterfaceIds(
+      classElement,
+      usedReferenceIds,
+      references,
+      traversedTypeSet
+    );
     const brick = {
       ...extractBrickDocBaseKind(comment.tags),
       ...extractBrickDocComplexKind(groups, children),
@@ -480,25 +570,38 @@ function traverseModules(modules, brickDocs) {
   });
 }
 
-function traverseUsedReferenceIdsByType(type, usedReferenceIds, references) {
+function traverseUsedReferenceIdsByType(
+  type,
+  usedReferenceIds,
+  references,
+  traversedTypeSet
+) {
   if (!type || !type.type) return;
 
-  if (type.$$traversed) {
+  if (traversedTypeSet.has(type)) {
     return;
   }
-  type.$$traversed = true;
+
+  traversedTypeSet.add(type);
+
   switch (type.type) {
     case "union":
     case "intersection":
       type.types.forEach((item) =>
-        traverseUsedReferenceIdsByType(item, usedReferenceIds, references)
+        traverseUsedReferenceIdsByType(
+          item,
+          usedReferenceIds,
+          references,
+          traversedTypeSet
+        )
       );
       break;
     case "array":
       traverseUsedReferenceIdsByType(
         type.elementType,
         usedReferenceIds,
-        references
+        references,
+        traversedTypeSet
       );
       break;
     case "reference":
@@ -507,12 +610,18 @@ function traverseUsedReferenceIdsByType(type, usedReferenceIds, references) {
         traverseUsedReferenceIdsByReflection(
           references.find((child) => child.id === type.id),
           usedReferenceIds,
-          references
+          references,
+          traversedTypeSet
         );
       }
       if (type.typeArguments && type.typeArguments.length > 0) {
         type.typeArguments.forEach((item) =>
-          traverseUsedReferenceIdsByType(item, usedReferenceIds, references)
+          traverseUsedReferenceIdsByType(
+            item,
+            usedReferenceIds,
+            references,
+            traversedTypeSet
+          )
         );
       }
       break;
@@ -521,7 +630,8 @@ function traverseUsedReferenceIdsByType(type, usedReferenceIds, references) {
       traverseUsedReferenceIdsByType(
         type.objectType,
         usedReferenceIds,
-        references
+        references,
+        traversedTypeSet
       );
       break;
   }
@@ -530,20 +640,40 @@ function traverseUsedReferenceIdsByType(type, usedReferenceIds, references) {
 function traverseUsedReferenceIdsByReflection(
   reflection,
   usedReferenceIds,
-  references
+  references,
+  traversedTypeSet
 ) {
   if (!reflection) {
     return;
   }
   switch (reflection.kindString) {
     case "Interface":
+      reflection.extendedTypes?.forEach((type) =>
+        traverseUsedReferenceIdsByType(
+          type,
+          usedReferenceIds,
+          references,
+          traversedTypeSet
+        )
+      );
       reflection.children
-        .filter((item) => item.kindString === "Property")
+        ?.filter((item) => item.kindString === "Property")
+        .forEach((item) =>
+          traverseUsedReferenceIdsByType(
+            item.type,
+            usedReferenceIds,
+            references,
+            traversedTypeSet
+          )
+        );
+      reflection.indexSignature
+        ?.filter((item) => item.kindString === "Index signature")
         .forEach((item) =>
           traverseUsedReferenceIdsByType(
             item.type,
             usedReferenceIds,
-            references
+            references,
+            traversedTypeSet
           )
         );
       break;
@@ -551,7 +681,8 @@ function traverseUsedReferenceIdsByReflection(
       traverseUsedReferenceIdsByType(
         reflection.type,
         usedReferenceIds,
-        references
+        references,
+        traversedTypeSet
       );
       break;
   }
@@ -590,7 +721,7 @@ function generateBrickBook(docsJson) {
   fs.writeFileSync(storiesPath, JSON.stringify(stories, null, 2), {
     encoding: "utf-8",
   });
-  console.log("Brick book written to doc.json.");
+  console.log("Brick book written to stories.json.");
 }
 
 module.exports = function generateBrickDocs(packageName) {