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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next-core/build-next-bricks",
-  "version": "1.8.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.1.0"
+    "@next-core/brick-manifest": "^0.3.0"
   },
-  "gitHead": "a2f8ca6b36b45b4a306f4b933e6bc2ca195cdd1f"
+  "gitHead": "14b533269133db07014b416199d988b0025f2b3c"
 }

package/src/build.js

@@ -81,6 +81,8 @@ async function getWebpackConfig(config) {
     "js-yaml",
     "i18next-browser-languagedetector",
     "react-i18next",
+    "@easyops-cn/brick-next-pipes",
+    "@next-core/pipes",
     "@next-core/runtime",
     "@next-core/easyops-runtime",
     "@next-core/http",

package/src/makeBrickManifest.js

@@ -1,10 +1,12 @@
 import { parse } from "doctrine";
+import { getTypeAnnotation } from "./utils.js";
 
 /**
  * @typedef {import("@next-core/brick-manifest").BrickManifest} BrickManifest
  * @typedef {import("@next-core/brick-manifest").PropertyManifest} PropertyManifest
  * @typedef {import("@next-core/brick-manifest").EventManifest} EventManifest
  * @typedef {import("@next-core/brick-manifest").MethodManifest} MethodManifest
+ * @typedef {import("@next-core/brick-manifest").ProviderManifest} ProviderManifest
  * @typedef {import("@babel/types").Node} Node
  * @typedef {import("@babel/traverse").NodePath} NodePath
  * @typedef {import("@babel/types").ClassDeclaration} ClassDeclaration
@@ -14,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) {
@@ -32,6 +35,7 @@ export default function makeBrickManifest(name, nodePath, source) {
   const docComment = findDocComment(nodePath, source);
   if (docComment) {
     manifest.description = docComment.description;
+    manifest.deprecated = getDeprecatedInfo(docComment.tags);
     for (const tag of docComment.tags) {
       if (tag.title === "slot") {
         const match = tag.description.match(/^(?:([-\w]+)\s+-\s+)?(.*)$/);
@@ -53,6 +57,25 @@ export default function makeBrickManifest(name, nodePath, source) {
   return manifest;
 }
 
+/**
+ * @param {string} name
+ * @param {NodePath} nodePath
+ * @param {string} source
+ * @returns {ProviderManifest}
+ */
+export function makeProviderManifest(name, nodePath, source) {
+  /** @type {ProviderManifest} */
+  const manifest = {
+    name,
+  };
+  const docComment = findDocComment(nodePath, source);
+  if (docComment) {
+    manifest.description = docComment.description;
+    manifest.deprecated = getDeprecatedInfo(docComment.tags);
+  }
+  return manifest;
+}
+
 /**
  * @param {NodePath} nodePath
  * @param {string} source
@@ -73,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) {
@@ -124,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(
@@ -188,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);
@@ -223,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);
         }
@@ -266,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

@@ -5,7 +5,9 @@ import { parse } from "@babel/parser";
 import babelTraverse from "@babel/traverse";
 import _ from "lodash";
 import getCamelPackageName from "./getCamelPackageName.js";
-import makeBrickManifest from "./makeBrickManifest.js";
+import makeBrickManifest, {
+  makeProviderManifest,
+} from "./makeBrickManifest.js";
 import { BASE_TYPE, TS_KEYWORD_LIST, getTypeAnnotation } from "./utils.js";
 import {
   isImportDefaultSpecifier,
@@ -57,6 +59,7 @@ export default async function scanBricks(packageDir) {
     package: packageJson.name,
     name: packageName,
     bricks: [],
+    providers: [],
   };
 
   /** @type {Map<string, Set<string>} */
@@ -216,7 +219,10 @@ export default async function scanBricks(packageDir) {
     }
 
     traverse(ast, {
-      CallExpression({ node: { callee, arguments: args } }) {
+      CallExpression(nodePath) {
+        const {
+          node: { callee, arguments: args },
+        } = nodePath;
         // Match `customProcessors.define(...)`
         // Match `customElements.define(...)`
         if (
@@ -265,6 +271,9 @@ export default async function scanBricks(packageDir) {
           const { type, value: fullName } = args[0];
           if (type === "StringLiteral") {
             collectBrick(fullName);
+            manifest.providers.push(
+              makeProviderManifest(fullName, nodePath, content)
+            );
           } else {
             throw new Error(
               "Please call `customElements.define()` only with literal string"
@@ -691,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)
+      );
     });
   }
 
@@ -725,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,
+          },
+        ];
       })
     ),
   };