@next-core/build-next-bricks 1.9.0 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next-core/build-next-bricks",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Build next bricks",
   "homepage": "https://github.com/easyops-cn/next-core/tree/v3/packages/build-next-bricks",
   "license": "GPL-3.0",
@@ -49,7 +49,7 @@
     "webpack": "^5.84.1"
   },
   "devDependencies": {
-    "@next-core/brick-manifest": "^0.2.0"
+    "@next-core/brick-manifest": "^0.3.0"
   },
-  "gitHead": "618559c95f5a1ef0eaf4d2792b530deaf933d45d"
+  "gitHead": "14b533269133db07014b416199d988b0025f2b3c"
 }

package/src/makeBrickManifest.js

@@ -1,4 +1,5 @@
 import { parse } from "doctrine";
+import { getTypeAnnotation } from "./utils.js";
 
 /**
  * @typedef {import("@next-core/brick-manifest").BrickManifest} BrickManifest
@@ -15,7 +16,8 @@ import { parse } from "doctrine";
 /**
  * @param {string} name
  * @param {NodePath} nodePath
- * @param {string} source
+ * @param {string} source'
+ * @param {Set<string>} referenceSet
  * @returns {BrickManifest}
  */
 export default function makeBrickManifest(name, nodePath, source) {
@@ -94,8 +96,9 @@ function findDocComment({ node, parentPath }, source) {
  * @param {BrickManifest} manifest
  * @param {Node[]} nodes
  * @param {string} source
+ * @param {Set<string>} referenceSet
  */
-function scanFields(manifest, nodes, source) {
+function scanFields(manifest, nodes, source, referenceSet = new Set()) {
   for (const node of nodes) {
     if (node.type === "ClassAccessorProperty" && node.decorators?.length) {
       for (const { expression } of node.decorators) {
@@ -145,6 +148,12 @@ function scanFields(manifest, nodes, source) {
               ) {
                 const { typeAnnotation } = node.typeAnnotation;
                 prop.type = getTypeWithoutUndefined(typeAnnotation, source);
+                prop.types = getTypesWithoutUndefined(
+                  typeAnnotation,
+                  source,
+                  referenceSet
+                );
+                prop.reference = [...referenceSet];
               }
               if (node.value && !prop.default) {
                 prop.default = source.substring(
@@ -209,6 +218,12 @@ function scanFields(manifest, nodes, source) {
                   const param = typeAnnotation.typeParameters.params[0];
                   event.detail ??= {};
                   event.detail.type = source.substring(param.start, param.end);
+                  event.detail.types = getTypeAnnotation(
+                    param,
+                    source,
+                    referenceSet
+                  );
+                  event.detail.reference = [...referenceSet];
                 }
               }
               manifest.events.push(event);
@@ -244,6 +259,12 @@ function scanFields(manifest, nodes, source) {
               typeAnnotation.start,
               typeAnnotation.end
             );
+            method.return.types = getTypeAnnotation(
+              typeAnnotation,
+              source,
+              referenceSet
+            );
+            method.return.reference = [...referenceSet];
           }
           manifest.methods.push(method);
         }
@@ -287,6 +308,23 @@ function getTypeWithoutUndefined(node, source) {
   return source.substring(node.start, node.end);
 }
 
+/**
+ * @param {import("@babel/types")/.typeAnnotation} typeAnnotation
+ * @param {string} source
+ * @param {Set<string} set
+ */
+function getTypesWithoutUndefined(typeAnnotation, source, set) {
+  if (typeAnnotation.type === "TSUnionType" && typeAnnotation.types) {
+    return {
+      type: "union",
+      types: typeAnnotation.types
+        .filter((type) => type.type !== "TSUndefinedKeyword")
+        .map((item) => getTypeAnnotation(item, source, set)),
+    };
+  }
+  return getTypeAnnotation(typeAnnotation, source, set);
+}
+
 /**
  * @param {Tag[]} tags
  * @param {string} title

package/src/scanBricks.js

@@ -700,26 +700,51 @@ export default async function scanBricks(packageDir) {
 
   if (manifest && manifest.bricks.length) {
     manifest.bricks.forEach((brickDoc) => {
-      const { name, properties } = brickDoc;
+      const { name, properties = [], events = [], methods = [] } = brickDoc;
       const importInfo = bricksImportsInfo[name];
-      const fieldTypes = properties
-        .map(
-          ({ type }) =>
-            type &&
-            type
-              .match(/\w+/g)
-              .filter(
-                (item) => !(BASE_TYPE[item] || TS_KEYWORD_LIST.includes(item))
-              )
-        )
-        .flat(1);
+      const fieldTypes = new Set();
+
+      properties.forEach((item) => {
+        importInfo.properties = (importInfo.properties || []).concat({
+          name: item.name,
+          types: item.types,
+        });
+        (item.reference || []).forEach((item) => fieldTypes.add(item));
+
+        delete item.types;
+        delete item.reference;
+      });
+
+      events.forEach((item) => {
+        if (item.detail) {
+          importInfo.events = (importInfo.events || []).concat({
+            name: item.name,
+            types: item.detail.types,
+          });
+          (item.detail.reference || []).forEach((item) => fieldTypes.add(item));
+
+          delete item.detail.types;
+          delete item.detail.reference;
+        }
+      });
+
+      methods.forEach((item) => {
+        if (item.return) {
+          importInfo.methods = (importInfo.methods || []).concat({
+            name: item.name,
+            types: item.return.types,
+          });
+          (item.return.reference || []).forEach((item) => fieldTypes.add(item));
+
+          delete item.return.types;
+          delete item.return.reference;
+        }
+      });
 
       const importKeysSet = new Set();
-      if (Array.isArray(fieldTypes) && fieldTypes.length) {
-        [...new Set(fieldTypes)].forEach((type) =>
-          findType(type, importInfo, importKeysSet)
-        );
-      }
+      [...fieldTypes].forEach((type) =>
+        findType(type, importInfo, importKeysSet)
+      );
     });
   }
 
@@ -734,7 +759,15 @@ export default async function scanBricks(packageDir) {
     manifest,
     types: Object.fromEntries(
       Object.entries(bricksImportsInfo).map(([k, v]) => {
-        return [k, v.types];
+        return [
+          k,
+          {
+            properties: v.properties,
+            events: v.events,
+            methods: v.methods,
+            types: v.types,
+          },
+        ];
       })
     ),
   };