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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next-core/build-next-bricks",
-  "version": "1.9.0",
+  "version": "1.11.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.4.0"
   },
-  "gitHead": "618559c95f5a1ef0eaf4d2792b530deaf933d45d"
+  "gitHead": "93ee03d986df5388568ed2ea424833718d6fc7eb"
 }

package/src/getTypeDeclaration.js

@@ -0,0 +1,377 @@
+// @ts-check
+import { parseTypeComment } from "./makeBrickManifest.js";
+
+/** @typedef {import("@babel/types").Node} Node */
+/** @typedef {import("@next-core/brick-manifest").Declaration} Declaration */
+/** @typedef {import("@next-core/brick-manifest").Annotation} Annotation */
+/** @typedef {import("@next-core/brick-manifest").AnnotationTypeParameterDeclaration} AnnotationTypeParameterDeclaration */
+/** @typedef {import("@next-core/brick-manifest").AnnotationTypeParameterInstantiation} AnnotationTypeParameterInstantiation */
+/** @typedef {import("@next-core/brick-manifest").AnnotationExpressionWithTypeArguments} AnnotationExpressionWithTypeArguments */
+/** @typedef {import("@next-core/brick-manifest").AnnotationEnumMember} AnnotationEnumMember */
+/** @typedef {import("@next-core/brick-manifest").AnnotationTypeParameter} AnnotationTypeParameter */
+/** @typedef {import("@next-core/brick-manifest").AnnotationPropertySignature} AnnotationPropertySignature */
+
+/**
+ * @param {Node | null | undefined} node
+ * @param {string} source
+ * @param {Set<string>} usedReferences
+ * @returns {Declaration | undefined}
+ */
+export default function getTypeDeclaration(node, source, usedReferences) {
+  switch (node.type) {
+    case "TSInterfaceDeclaration":
+      // interface A { ... }
+      return {
+        type: "interface",
+        name: node.id.name,
+        typeParameters:
+          /** @type {AnnotationTypeParameterDeclaration | undefined} */
+          (getTypeAnnotation(node.typeParameters, source, usedReferences)),
+        body: node.body.body.map(
+          (item) =>
+            /** @type {AnnotationPropertySignature} */
+            (getTypeAnnotation(item, source, usedReferences))
+        ),
+        extends:
+          /** @type {AnnotationExpressionWithTypeArguments[] | undefined} */
+          (
+            node.extends?.map((item) =>
+              getTypeAnnotation(item, source, usedReferences)
+            )
+          ),
+        ...parseTypeComment(node, source),
+      };
+
+    case "TSTypeAliasDeclaration":
+      // type A = B
+      return {
+        type: "typeAlias",
+        name: node.id.name,
+        typeParameters:
+          /** @type {AnnotationTypeParameterDeclaration | undefined} */
+          (getTypeAnnotation(node.typeParameters, source, usedReferences)),
+        annotation: getTypeAnnotation(
+          node.typeAnnotation,
+          source,
+          usedReferences
+        ),
+        ...parseTypeComment(node, source),
+      };
+
+    case "TSEnumDeclaration":
+      // enum A { ... }
+      return {
+        type: "enum",
+        name: node.id.name,
+        members:
+          /** @type {AnnotationEnumMember[] | undefined} */
+          (
+            node.members.map((item) =>
+              getTypeAnnotation(item, source, usedReferences)
+            )
+          ),
+        ...parseTypeComment(node, source),
+      };
+  }
+}
+
+/**
+ * @param {Node | null | undefined} entryNode
+ * @param {string} source
+ * @param {Set<string>} usedReferences
+ * @returns {Annotation | undefined}
+ */
+export function getTypeAnnotation(entryNode, source, usedReferences) {
+  /**
+   * @param {Node | null | undefined} node
+   * @param {Boolean =} isRef
+   * @returns {Annotation | undefined}
+   */
+  function get(node, isRef) {
+    if (!node) {
+      return;
+    }
+    switch (node.type) {
+      case "TSEnumMember":
+        // enum A { b = "B", c = "C" }
+        //          ^^^^^^^
+        return {
+          type: "enumMember",
+          id: get(node.id),
+          initializer: get(node.initializer),
+        };
+
+      case "TSTypeAnnotation":
+        // let a: MyType
+        //        ^^^^^^
+        return get(node.typeAnnotation);
+
+      case "TSTypeReference":
+        // type A = B
+        //          ^
+        return {
+          type: "reference",
+          typeName: get(node.typeName, true),
+          typeParameters:
+            /** @type {AnnotationTypeParameterInstantiation | undefined} */
+            (get(node.typeParameters)),
+        };
+
+      case "TSQualifiedName":
+        // type A = B.C
+        //          ^^^
+        return {
+          type: "qualifiedName",
+          left: get(node.left, true),
+          right: get(node.right),
+        };
+
+      case "TSUnionType":
+        // type A = string | number
+        //          ^^^^^^^^^^^^^^^
+        return {
+          type: "union",
+          types: node.types.map((item) => get(item)),
+        };
+
+      case "TSArrayType":
+        // type A = string[]
+        //          ^^^^^^^^
+        return {
+          type: "array",
+          elementType: get(node.elementType),
+        };
+
+      case "TSTupleType":
+        // type A = [string, number]
+        //          ^^^^^^^^^^^^^^^^
+        return {
+          type: "tuple",
+          elementTypes: node.elementTypes.map((item) => get(item)),
+        };
+
+      case "TSNamedTupleMember":
+        // type A = [x: number, y: number]
+        //           ^^^^^^^^^
+        return {
+          type: "namedTupleMember",
+          label: node.label.name,
+          optional: node.optional,
+          elementType: get(node.elementType),
+        };
+
+      case "TSIntersectionType":
+        // type A = B & C
+        //          ^^^^^
+        return {
+          type: "intersection",
+          types: node.types.map((item) => get(item)),
+        };
+
+      case "TSTypeLiteral":
+        // type A = { prop: number }
+        //          ^^^^^^^^^^^^^^^^
+        return {
+          type: "typeLiteral",
+          members: node.members.map((item) => get(item)),
+        };
+
+      case "TSPropertySignature":
+        // interface A { prop: number }
+        //               ^^^^^^^^^^^^
+        return {
+          type: "propertySignature",
+          key: get(node.key),
+          annotation: get(node.typeAnnotation),
+          // initializer: get(node.initializer),
+          optional: node.optional,
+          computed: node.computed,
+          readonly: node.readonly,
+          kind: node.kind,
+          ...parseTypeComment(node, source),
+        };
+
+      case "TSMethodSignature":
+        // interface A { call(a: number): void }
+        //               ^^^^^^^^^^^^^^^^^^^^^
+        return {
+          type: "methodSignature",
+          key: get(node.key),
+          typeParameters:
+            /** @type {AnnotationTypeParameterDeclaration | undefined} */
+            (get(node.typeParameters)),
+          parameters: node.parameters.map((item) => get(item)),
+          annotation: get(node.typeAnnotation),
+          optional: node.optional,
+          computed: node.computed,
+          kind: node.kind,
+          ...parseTypeComment(node, source),
+        };
+
+      case "TSIndexSignature":
+        // interface A { [k: string]: number }
+        //               ^^^^^^^^^^^^^^^^^^^
+        return {
+          type: "indexSignature",
+          parameter: get(node.parameters[0]),
+          annotation: get(node.typeAnnotation),
+          ...parseTypeComment(node, source),
+        };
+
+      case "TSIndexedAccessType":
+        // type A = B["C"]
+        //          ^^^^^^
+        return {
+          type: "indexedAccess",
+          objectType: get(node.objectType),
+          indexType: get(node.indexType),
+        };
+
+      case "TSTypeParameterDeclaration":
+        // interface A<T, P> {}
+        //            ^^^^^^
+        return {
+          type: "typeParameterDeclaration",
+          params:
+            /** @type {AnnotationTypeParameter[]} */
+            (node.params.map((item) => get(item))),
+        };
+
+      case "TSTypeParameterInstantiation":
+        // type A = B<T, P>
+        //           ^^^^^^
+        return {
+          type: "typeParameterInstantiation",
+          params: node.params.map((item) => get(item)),
+        };
+
+      case "TSTypeParameter":
+        // interface A<T extends string = "", P> {}
+        //             ^^^^^^^^^^^^^^^^^^^^^
+        return {
+          type: "typeParameter",
+          name: node.name,
+          default: get(node.default),
+          constraint: get(node.constraint),
+        };
+
+      case "TSLiteralType":
+        return get(node.literal);
+
+      case "TSTypeOperator":
+        // type A = keyof B
+        //          ^^^^^^^
+        return {
+          type: "typeOperator",
+          operator: node.operator,
+          annotation: get(node.typeAnnotation),
+        };
+
+      case "TSTypeQuery":
+        // type A = typeof B<T>
+        //          ^^^^^^^^^^^
+        return {
+          type: "typeQuery",
+          exprName: get(node.exprName),
+          typeParameters:
+            /** @type {AnnotationTypeParameterInstantiation | undefined} */
+            (get(node.typeParameters)),
+        };
+
+      case "TSExpressionWithTypeArguments":
+        // interface A extends B<T>, C
+        //                     ^^^^
+        return {
+          type: "expressionWithTypeArguments",
+          expression: get(node.expression),
+          typeParameters:
+            /** @type {AnnotationTypeParameterInstantiation | undefined} */
+            (get(node.typeParameters)),
+        };
+
+      case "Identifier":
+        // interface A { call(a: number) => void }
+        //                    ^^^^^^^^^
+        if (isRef) {
+          usedReferences.add(node.name);
+        }
+        return {
+          type: "identifier",
+          name: node.name,
+          annotation: get(node.typeAnnotation),
+        };
+
+      case "RestElement":
+        // interface A { call(a, ...rest: unknown[]) => void }
+        //                       ^^^^^^^^^^^^^^^^^^
+        return {
+          type: "restElement",
+          argument: get(node.argument),
+          annotation: get(node.typeAnnotation),
+        };
+
+      case "TSFunctionType":
+        // interface A { call: (a: number) => void }
+        //                     ^^^^^^^^^^^^^^^^^^^
+        return {
+          type: "function",
+          typeParameters:
+            /** @type {AnnotationTypeParameterDeclaration | undefined} */
+            (get(node.typeParameters)),
+          parameters: node.parameters.map((item) => get(item)),
+          annotation: get(node.typeAnnotation),
+        };
+
+      case "StringLiteral":
+      case "NumericLiteral":
+      case "BooleanLiteral":
+        return {
+          type: "jsLiteral",
+          value: node.value,
+        };
+
+      case "NullLiteral":
+        return {
+          type: "jsLiteral",
+          value: null,
+        };
+
+      // <!-- Keywords start
+      case "TSAnyKeyword":
+        return { type: "keyword", value: "any" };
+      case "TSBooleanKeyword":
+        return { type: "keyword", value: "boolean" };
+      case "TSBigIntKeyword":
+        return { type: "keyword", value: "bigint" };
+      case "TSNullKeyword":
+        return { type: "keyword", value: "null" };
+      case "TSNumberKeyword":
+        return { type: "keyword", value: "number" };
+      case "TSObjectKeyword":
+        return { type: "keyword", value: "object" };
+      case "TSStringKeyword":
+        return { type: "keyword", value: "string" };
+      case "TSUndefinedKeyword":
+        return { type: "keyword", value: "undefined" };
+      case "TSUnknownKeyword":
+        return { type: "keyword", value: "unknown" };
+      case "TSVoidKeyword":
+        return { type: "keyword", value: "void" };
+      case "TSSymbolKeyword":
+        return { type: "keyword", value: "symbol" };
+      case "TSNeverKeyword":
+        return { type: "keyword", value: "never" };
+      // Keywords end -->
+
+      default:
+        return {
+          type: "unsupported",
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          source: source.substring(node.start, node.end),
+        };
+    }
+  }
+
+  return get(entryNode);
+}

package/src/makeBrickManifest.js

@@ -1,33 +1,67 @@
+// @ts-check
 import { parse } from "doctrine";
+import { getTypeAnnotation } from "./getTypeDeclaration.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").MethodParamManifest} MethodParamManifest
  * @typedef {import("@next-core/brick-manifest").ProviderManifest} ProviderManifest
+ * @typedef {import("@next-core/brick-manifest").Annotation} Annotation
  * @typedef {import("@babel/types").Node} Node
  * @typedef {import("@babel/traverse").NodePath} NodePath
  * @typedef {import("@babel/types").ClassDeclaration} ClassDeclaration
+ * @typedef {import("@babel/types").Identifier} Identifier
  * @typedef {import("doctrine").Tag} Tag
+ * @typedef {BrickManifest & { types: BrickTypes; }} BrickManifestAndTypes
+ * @typedef {{ name: string; annotation?: Annotation }} BrickPropertyWithAnnotation
+ * @typedef {{ name: string; detail: { annotation: Annotation } }} BrickEventWithAnnotation
+ * @typedef {{ name: string; params: BrickMethodParamWithAnnotation[]; returns: { annotation?: Annotation } }} BrickMethodWithAnnotation
+ * @typedef {{ name: string; annotation?: Annotation }} BrickMethodParamWithAnnotation
+ * @typedef {{
+ *  properties: BrickPropertyWithAnnotation[];
+ *  events: BrickEventWithAnnotation[];
+ *  methods: BrickMethodWithAnnotation[];
+ *  usedReferences?: Set<string>;
+ * }} BrickTypes
+ * @typedef {ProviderManifest & {
+ *  params: (MethodParamManifest & {
+ *    annotation?: Annotation;
+ *  })[];
+ *  returns?: {
+ *    description?: string;
+ *    annotation?: Annotation;
+ *  };
+ *  typeParameters?: Annotation;
+ *  usedReferences?: Set<string>;
+ * }} ProviderManifestAndTypes
  */
 
 /**
  * @param {string} name
  * @param {NodePath} nodePath
  * @param {string} source
- * @returns {BrickManifest}
+ * @returns {BrickManifestAndTypes}
  */
 export default function makeBrickManifest(name, nodePath, source) {
-  /** @type {import("@babel/traverse").NodePath<ClassDeclaration>} */
-  const classPath = nodePath.parentPath;
-  /** @type {BrickManifest} */
+  const classPath =
+    /** @type {import("@babel/traverse").NodePath<ClassDeclaration>} */ (
+      nodePath.parentPath
+    );
+  /** @type {BrickManifestAndTypes} */
   const manifest = {
     name,
     properties: [],
     events: [],
     slots: [],
     methods: [],
+    types: {
+      properties: [],
+      events: [],
+      methods: [],
+    },
   };
 
   const docComment = findDocComment(nodePath, source);
@@ -50,7 +84,11 @@ export default function makeBrickManifest(name, nodePath, source) {
     }
   }
 
-  scanFields(manifest, classPath.node.body.body, source);
+  manifest.types.usedReferences = scanFields(
+    manifest,
+    classPath.node.body.body,
+    source
+  );
 
   return manifest;
 }
@@ -59,18 +97,74 @@ export default function makeBrickManifest(name, nodePath, source) {
  * @param {string} name
  * @param {NodePath} nodePath
  * @param {string} source
- * @returns {ProviderManifest}
+ * @returns {ProviderManifestAndTypes}
  */
 export function makeProviderManifest(name, nodePath, source) {
-  /** @type {ProviderManifest} */
+  /**
+   * @type {ProviderManifestAndTypes}
+   */
   const manifest = {
     name,
+    type: "provider",
+    params: [],
+    usedReferences: new Set(),
   };
+
   const docComment = findDocComment(nodePath, source);
   if (docComment) {
     manifest.description = docComment.description;
     manifest.deprecated = getDeprecatedInfo(docComment.tags);
   }
+
+  const fn = /** @type {import("@babel/types").FunctionDeclaration} */ (
+    nodePath.node
+  );
+  let index = 0;
+  for (const param of fn.params) {
+    const annotation = getTypeAnnotation(
+      param.typeAnnotation,
+      source,
+      manifest.usedReferences
+    );
+    if (param.type === "Identifier") {
+      manifest.params.push({
+        name: param.name,
+        description: docComment?.tags.find(
+          (tag) => tag.title === "param" && tag.name === param.name
+        )?.description,
+        annotation,
+      });
+    } else {
+      const paramTag = docComment?.tags.filter(
+        (tag) => tag.title === "param"
+      )?.[index];
+      manifest.params.push({
+        name: paramTag?.name ?? `param_${index + 1}`,
+        description: paramTag?.description,
+        isRestElement: param.type === "RestElement",
+        annotation,
+      });
+    }
+    index++;
+  }
+  const returnAnnotation = getTypeAnnotation(
+    fn.returnType,
+    source,
+    manifest.usedReferences
+  );
+
+  manifest.returns = {
+    description: docComment?.tags.find((tag) => tag.title === "returns")
+      ?.description,
+    annotation: returnAnnotation,
+  };
+
+  manifest.typeParameters = getTypeAnnotation(
+    fn.typeParameters,
+    source,
+    manifest.usedReferences
+  );
+
   return manifest;
 }
 
@@ -91,11 +185,14 @@ function findDocComment({ node, parentPath }, source) {
 }
 
 /**
- * @param {BrickManifest} manifest
+ * @param {BrickManifestAndTypes} manifest
  * @param {Node[]} nodes
  * @param {string} source
+ * @returns {Set<string>}
  */
 function scanFields(manifest, nodes, source) {
+  /** @type {Set<string>} */
+  const usedReferences = new Set();
   for (const node of nodes) {
     if (node.type === "ClassAccessorProperty" && node.decorators?.length) {
       for (const { expression } of node.decorators) {
@@ -107,7 +204,7 @@ function scanFields(manifest, nodes, source) {
             case "property": {
               /** @type {PropertyManifest} */
               const prop = {
-                name: node.key.name,
+                name: /** @type {Identifier} */ (node.key).name,
               };
               const docComment = parseDocComment(node, source);
               if (docComment) {
@@ -145,6 +242,18 @@ function scanFields(manifest, nodes, source) {
               ) {
                 const { typeAnnotation } = node.typeAnnotation;
                 prop.type = getTypeWithoutUndefined(typeAnnotation, source);
+
+                const annotation = getTypeAnnotation(
+                  getNodeWithoutUndefined(typeAnnotation),
+                  source,
+                  usedReferences
+                );
+                if (annotation) {
+                  manifest.types.properties.push({
+                    name: prop.name,
+                    annotation,
+                  });
+                }
               }
               if (node.value && !prop.default) {
                 prop.default = source.substring(
@@ -158,7 +267,7 @@ function scanFields(manifest, nodes, source) {
 
             case "event": {
               /** @type {EventManifest} */
-              const event = {};
+              const event = { name: undefined };
 
               // Find out the `type` option for the event.
               if (expression.arguments.length > 0) {
@@ -181,7 +290,9 @@ function scanFields(manifest, nodes, source) {
               }
               if (event.name === undefined) {
                 throw new Error(
-                  `Invalid @event() call: no literal type option in event '${node.key.name}'`
+                  `Invalid @event() call: no literal type option in event '${
+                    /** @type {Identifier} */ (node.key).name
+                  }'`
                 );
               }
               const docComment = parseDocComment(node, source);
@@ -209,6 +320,21 @@ function scanFields(manifest, nodes, source) {
                   const param = typeAnnotation.typeParameters.params[0];
                   event.detail ??= {};
                   event.detail.type = source.substring(param.start, param.end);
+
+                  const annotation = getTypeAnnotation(
+                    param,
+                    source,
+                    usedReferences
+                  );
+
+                  if (annotation) {
+                    manifest.types.events.push({
+                      name: event.name,
+                      detail: {
+                        annotation,
+                      },
+                    });
+                  }
                 }
               }
               manifest.events.push(event);
@@ -226,34 +352,99 @@ function scanFields(manifest, nodes, source) {
         ) {
           /** @type {MethodManifest} */
           const method = {
-            name: node.key.name,
+            name: /** @type {Identifier} */ (node.key).name,
             params: [],
           };
           const docComment = parseDocComment(node, source);
           if (docComment) {
             method.description = docComment.description;
             method.deprecated = getDeprecatedInfo(docComment.tags);
+            method.returns = {
+              description: docComment.tags.find(
+                (tag) => tag.title === "returns"
+              )?.description,
+            };
           }
+
+          let index = 0;
+          /** @type {BrickMethodParamWithAnnotation[]} */
+          const typedParams = [];
           for (const param of node.params) {
-            method.params.push(source.substring(param.start, param.end));
+            const typeAnnotation =
+              /** @type {Identifier} */
+              (param).typeAnnotation;
+            const annotation = getTypeAnnotation(
+              typeAnnotation,
+              source,
+              usedReferences
+            );
+            const paramType =
+              typeAnnotation.type === "TSTypeAnnotation"
+                ? source.substring(
+                    typeAnnotation.typeAnnotation.start,
+                    typeAnnotation.typeAnnotation.end
+                  )
+                : undefined;
+            /** @type {string} */
+            let paramName;
+            if (param.type === "Identifier") {
+              paramName = param.name;
+              method.params.push({
+                name: paramName,
+                description: docComment?.tags.find(
+                  (tag) => tag.title === "param" && tag.name === param.name
+                )?.description,
+                type: paramType,
+              });
+            } else {
+              const paramTag = docComment?.tags.filter(
+                (tag) => tag.title === "param"
+              )?.[index];
+              paramName = paramTag?.name ?? `param_${index + 1}`;
+              method.params.push({
+                name: paramName,
+                description: paramTag?.description,
+                type: paramType,
+              });
+            }
+            typedParams.push({
+              name: paramName,
+              annotation,
+            });
+            index++;
           }
+
+          /** @type {{ annotation?: Annotation }} */
+          const typedReturns = {};
           if (node.returnType && node.returnType.type === "TSTypeAnnotation") {
             const { typeAnnotation } = node.returnType;
-            method.return ??= {};
-            method.return.type = source.substring(
-              typeAnnotation.start,
-              typeAnnotation.end
+            method.returns = {
+              ...method.returns,
+              type: source.substring(typeAnnotation.start, typeAnnotation.end),
+            };
+
+            typedReturns.annotation = getTypeAnnotation(
+              typeAnnotation,
+              source,
+              usedReferences
             );
           }
+          manifest.types.methods.push({
+            name: method.name,
+            params: typedParams,
+            returns: typedReturns,
+          });
           manifest.methods.push(method);
         }
       }
     }
   }
+
+  return usedReferences;
 }
 
 /**
- * @param {Node[]} nodes
+ * @param {Node} node
  * @param {string} source
  */
 export function parseDocComment(node, source) {
@@ -269,6 +460,21 @@ export function parseDocComment(node, source) {
   }
 }
 
+/**
+ * @param {Node} node
+ * @param {string} source
+ * @returns {undefined | { description?: string; deprecated?: boolean | string; }}
+ */
+export function parseTypeComment(node, source) {
+  const docComment = parseDocComment(node, source);
+  if (docComment) {
+    return {
+      description: docComment.description,
+      deprecated: getDeprecatedInfo(docComment.tags),
+    };
+  }
+}
+
 /**
  * @param {Node} node
  * @param {string} source
@@ -287,6 +493,28 @@ function getTypeWithoutUndefined(node, source) {
   return source.substring(node.start, node.end);
 }
 
+/**
+ * @param {Node} node
+ * @returns {Node}
+ */
+function getNodeWithoutUndefined(node) {
+  if (node.type === "TSUnionType") {
+    const filteredTypes = node.types.filter(
+      (type) => type.type !== "TSUndefinedKeyword"
+    );
+    if (filteredTypes.length < node.types.length) {
+      if (filteredTypes.length === 1) {
+        return filteredTypes[0];
+      }
+      return {
+        ...node,
+        types: filteredTypes,
+      };
+    }
+  }
+  return node;
+}
+
 /**
  * @param {Tag[]} tags
  * @param {string} title

package/src/scanBricks.js

@@ -8,17 +8,22 @@ import getCamelPackageName from "./getCamelPackageName.js";
 import makeBrickManifest, {
   makeProviderManifest,
 } from "./makeBrickManifest.js";
-import { BASE_TYPE, TS_KEYWORD_LIST, getTypeAnnotation } from "./utils.js";
 import {
   isImportDefaultSpecifier,
   isImportDeclaration,
   isImportSpecifier,
 } from "@babel/types";
+import getTypeDeclaration from "./getTypeDeclaration.js";
 
 /**
+ *
+ * @typedef {import("@babel/traverse").NodePath} NodePath
  * @typedef {import("@next-core/brick-manifest").PackageManifest} PackageManifest
+ * @typedef {import("@next-core/brick-manifest").ProviderManifest} ProviderManifest
+ * @typedef {import("@next-core/brick-manifest").Declaration} Declaration
  * @typedef {{import: string; name: string; noNamespace?: boolean;}} Expose
  * @typedef {Record<string, Expose>} Exposes
+ * @typedef {import("./makeBrickManifest.js").BrickManifestAndTypes} BrickManifestAndTypes
  */
 
 const { default: traverse } = babelTraverse;
@@ -71,10 +76,14 @@ export default async function scanBricks(packageDir) {
   /** @type {Map<string, Set<string>} */
   const importsMap = new Map();
 
-  const typescriptList = [];
+  /** @type {{ filePath: string; declaration: Declaration; usedReferences: Set<string> }[]} */
+  const typeDeclarations = [];
 
   const bricksImportsInfo = {};
 
+  /** @type {ProviderManifest[]} */
+  const providerTypes = [];
+
   /**
    *
    * @param {string} filePath
@@ -93,7 +102,12 @@ export default async function scanBricks(packageDir) {
     const extname = path.extname(filePath);
     const content = await readFile(filePath, "utf-8");
 
-    /** @type {Record<string, string[]>} */
+    // Record top level functions for providers
+    /** @type {Map<string, NodePath}  */
+    const topLevelFunctions = new Map();
+    /** @type {Map<string, string>}  */
+    const providerMap = new Map();
+
     /** @type {string}  */
     let brickFullName;
     /** @type {ReturnType<typeof import("@babel/parser").parse>} */
@@ -268,12 +282,20 @@ export default async function scanBricks(packageDir) {
           callee.property.name === "define" &&
           args.length === 2
         ) {
-          const { type, value: fullName } = args[0];
+          const [{ type, value: fullName }, constructor] = args;
           if (type === "StringLiteral") {
             collectBrick(fullName);
-            manifest.providers.push(
-              makeProviderManifest(fullName, nodePath, content)
-            );
+            if (
+              constructor.type === "CallExpression" &&
+              constructor.callee.type === "Identifier" &&
+              constructor.callee.name === "createProviderClass" &&
+              constructor.arguments.length > 0 &&
+              constructor.arguments[0].type === "Identifier"
+            ) {
+              providerMap.set(fullName, constructor.arguments[0].name);
+            } else {
+              manifest.providers.push({ name: fullName });
+            }
           } else {
             throw new Error(
               "Please call `customElements.define()` only with literal string"
@@ -425,6 +447,17 @@ export default async function scanBricks(packageDir) {
           });
         }
       },
+      FunctionDeclaration(nodePath) {
+        const { node, parent } = nodePath;
+        if (
+          node.id &&
+          (parent.type === "Program" ||
+            parent.type === "ExportNamedDeclaration" ||
+            parent.type === "ExportDefaultDeclaration")
+        ) {
+          topLevelFunctions.set(node.id.name, nodePath);
+        }
+      },
       ImportDeclaration({ node: { source, importKind } }) {
         // Match `import "..."`
         if (
@@ -458,22 +491,27 @@ export default async function scanBricks(packageDir) {
         }
       },
       TSInterfaceDeclaration({ node }) {
-        if (!node.id) return;
-        typescriptList.push({
-          ...(getTypeAnnotation(node, content) || {}),
+        const usedReferences = new Set();
+        typeDeclarations.push({
           filePath,
+          declaration: getTypeDeclaration(node, content, usedReferences),
+          usedReferences,
         });
       },
       TSTypeAliasDeclaration({ node }) {
-        typescriptList.push({
-          ...(getTypeAnnotation(node, content) || {}),
+        const usedReferences = new Set();
+        typeDeclarations.push({
           filePath,
+          declaration: getTypeDeclaration(node, content, usedReferences),
+          usedReferences,
         });
       },
       TSEnumDeclaration: ({ node }) => {
-        typescriptList.push({
-          ...(getTypeAnnotation(node, content) || {}),
+        const usedReferences = new Set();
+        typeDeclarations.push({
           filePath,
+          declaration: getTypeDeclaration(node, content, usedReferences),
+          usedReferences,
         });
       },
     });
@@ -484,7 +522,7 @@ export default async function scanBricks(packageDir) {
       )
     );
 
-    if (brickFullName) {
+    if (brickFullName || providerMap.size > 0) {
       const imports = ast.program.body
         .map((item) => {
           if (isImportDeclaration(item)) {
@@ -515,10 +553,36 @@ export default async function scanBricks(packageDir) {
         })
         .filter(Boolean);
 
-      bricksImportsInfo[brickFullName] = {
-        imports,
-        filePath,
-      };
+      if (brickFullName) {
+        bricksImportsInfo[brickFullName] = {
+          imports,
+          filePath,
+        };
+      }
+      for (const providerName of providerMap.keys()) {
+        bricksImportsInfo[providerName] = {
+          imports,
+          filePath,
+        };
+      }
+    }
+
+    if (providerMap.size > 0) {
+      for (const [providerName, providerConstructor] of providerMap) {
+        const nodePath = topLevelFunctions.get(providerConstructor);
+        if (nodePath) {
+          const { description, deprecated, ...restTypes } =
+            makeProviderManifest(providerName, nodePath, content);
+          providerTypes.push(restTypes);
+          manifest.providers.push({
+            name: providerName,
+            description,
+            deprecated,
+          });
+        } else {
+          manifest.providers.push({ name: providerName });
+        }
+      }
     }
   }
 
@@ -618,9 +682,6 @@ export default async function scanBricks(packageDir) {
       if (analyzedFiles.has(filePath)) {
         return;
       }
-      if (brickName === "button-with-icon") {
-        console.log("scan:", filePath);
-      }
       analyzedFiles.add(filePath);
       for (const dep of usingWrappedBricks.get(filePath) ?? []) {
         // Do not dependent on itself
@@ -638,9 +699,6 @@ export default async function scanBricks(packageDir) {
     }
   }
 
-  function ingoreField(obj) {
-    return _.omit(obj, ["filePath", "reference"]);
-  }
   function isMatch(importPath, filePath) {
     return (
       importPath.replace(/\.[^.]+$/, "") === filePath.replace(/\.[^.]+$/, "")
@@ -649,11 +707,11 @@ export default async function scanBricks(packageDir) {
 
   /**
    *
-   * @param {string} type
+   * @param {string} name
    * @param {Record<string, unknown} importInfo
    * @param {Set<string>} importKeysSet
    * @param {string} realFilePath
-   * @returns void
+   * @returns {void}
    */
   function findType(name, importInfo, importKeysSet, realFilePath = "") {
     if (importKeysSet.has(name)) return;
@@ -667,60 +725,43 @@ export default async function scanBricks(packageDir) {
       ? importItem.path
       : filePath;
 
-    const interfaceItem = typescriptList.find(
-      (item) => isMatch(item.filePath, importPath) && item.name === name
-    );
+    const { declaration, usedReferences } =
+      typeDeclarations.find(
+        (item) =>
+          isMatch(item.filePath, importPath) && item.declaration.name === name
+      ) ?? {};
 
-    if (interfaceItem) {
-      importInfo.types = (importInfo.types || []).concat(
-        ingoreField(interfaceItem)
-      );
-      findRefrenceItem(
-        interfaceItem.extends,
-        importInfo,
-        importKeysSet,
-        importPath
-      );
-      findRefrenceItem(
-        interfaceItem.reference,
-        importInfo,
-        importKeysSet,
-        importPath
-      );
+    if (declaration) {
+      importInfo.types = (importInfo.types || []).concat(declaration);
+      for (const ref of usedReferences) {
+        findType(ref, importInfo, importKeysSet, importPath);
+      }
     }
   }
 
-  function findRefrenceItem(list, importInfo, importKeySet, realFilePath = "") {
-    if (Array.isArray(list) && list.length) {
-      list.forEach((item) =>
-        findType(item, importInfo, importKeySet, realFilePath)
-      );
+  manifest.bricks.forEach((/** @type {BrickManifestAndTypes} */ brickDoc) => {
+    const {
+      name,
+      types: { usedReferences, ...types },
+    } = brickDoc;
+    const importInfo = bricksImportsInfo[name];
+    Object.assign(importInfo, types);
+
+    const importKeysSet = new Set();
+    for (const ref of usedReferences) {
+      findType(ref, importInfo, importKeysSet);
     }
-  }
+    delete brickDoc.types;
+  });
 
-  if (manifest && manifest.bricks.length) {
-    manifest.bricks.forEach((brickDoc) => {
-      const { name, properties } = 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);
+  for (const providerDoc of providerTypes) {
+    const importInfo = bricksImportsInfo[providerDoc.name];
 
-      const importKeysSet = new Set();
-      if (Array.isArray(fieldTypes) && fieldTypes.length) {
-        [...new Set(fieldTypes)].forEach((type) =>
-          findType(type, importInfo, importKeysSet)
-        );
-      }
-    });
+    const importKeysSet = new Set();
+    for (const ref of providerDoc.usedReferences) {
+      findType(ref, importInfo, importKeysSet);
+    }
+    delete providerDoc.usedReferences;
   }
 
   // console.log("exposes:", exposes);
@@ -733,9 +774,27 @@ export default async function scanBricks(packageDir) {
     },
     manifest,
     types: Object.fromEntries(
-      Object.entries(bricksImportsInfo).map(([k, v]) => {
-        return [k, v.types];
-      })
+      Object.entries(bricksImportsInfo)
+        .map(([k, v]) => {
+          return [
+            k,
+            {
+              properties: v.properties,
+              events: v.events,
+              methods: v.methods,
+              types: v.types,
+            },
+          ];
+        })
+        .concat(
+          providerTypes.map(({ name, ...types }) => [
+            name,
+            {
+              ...types,
+              types: bricksImportsInfo[name]?.types,
+            },
+          ])
+        )
     ),
   };
 }

package/src/utils.js

@@ -1,227 +0,0 @@
-import {
-  isIdentifier,
-  isStringLiteral,
-  isTSArrayType,
-  isTSEnumDeclaration,
-  isTSEnumMember,
-  isTSIndexSignature,
-  isTSIndexedAccessType,
-  isTSInterfaceDeclaration,
-  isTSIntersectionType,
-  isTSLiteralType,
-  isTSPropertySignature,
-  isTSQualifiedName,
-  isTSTupleType,
-  isTSTypeAliasDeclaration,
-  isTSTypeAnnotation,
-  isTSTypeLiteral,
-  isTSTypeParameter,
-  isTSTypeParameterDeclaration,
-  isTSTypeReference,
-  isTSUnionType,
-} from "@babel/types";
-import _ from "lodash";
-import { parseDocComment } from "./makeBrickManifest.js";
-
-export const BASE_TYPE = {
-  any: "any",
-  boolean: "boolean",
-  undefined: "undefined",
-  bigint: "bigint",
-  null: "null",
-  number: "number",
-  object: "object",
-  string: "string",
-};
-
-export const TS_KEYWORD_LIST = ["Record", "Array", "unknow", "void"];
-const TS_BASIC_TYPE = {
-  TSAnyKeyword: BASE_TYPE.any,
-  TSBooleanKeyword: BASE_TYPE.boolean,
-  TSBigIntKeyword: BASE_TYPE.bigint,
-  TSNullKeyword: BASE_TYPE.null,
-  TSNumberKeyword: BASE_TYPE.number,
-  TSObjectKeyword: BASE_TYPE.object,
-  TSStringKeyword: BASE_TYPE.string,
-  TSUndefinedKeyword: BASE_TYPE.undefined,
-  TSUnknownKeyword: BASE_TYPE.any,
-};
-
-function getTSBasicType(annotation) {
-  return annotation && TS_BASIC_TYPE[annotation.type];
-}
-
-const getDocComment = (typeAnnotation, source) => {
-  return parseDocComment(typeAnnotation, source) || {};
-};
-
-/**
- *
- * @param {import("@babel/types").typeAnnotation} typeAnnotation
- * @param {string} source
- * @param {Set<string>} reference
- * @returns
- */
-export const getTypeAnnotation = (
-  typeAnnotation,
-  source,
-  reference = new Set()
-) => {
-  const makeResultWithDocComment = (result) => {
-    return {
-      ...result,
-      ...getDocComment(typeAnnotation, source),
-    };
-  };
-  /**
-   * @param {import("@babel/types").typeAnnotation} typeAnnotation
-   */
-  const walkTypeAnnotation = (typeAnnotation) => {
-    if (isTSInterfaceDeclaration(typeAnnotation)) {
-      const {
-        id,
-        body,
-        extends: extendsItems,
-        typeParameters,
-      } = typeAnnotation;
-      if (!id) return;
-      return makeResultWithDocComment({
-        name: id.name,
-        type: "interface",
-        typeParameters: typeParameters && walkTypeAnnotation(typeParameters),
-        annotation: body.body.map(walkTypeAnnotation),
-        extends: extendsItems?.map((item) => item.expression.name),
-        reference: [...reference],
-      });
-    } else if (isTSTypeAliasDeclaration(typeAnnotation)) {
-      const { id, typeParameters } = typeAnnotation;
-      return makeResultWithDocComment({
-        name: id.name,
-        type: "typeAlias",
-        typeParameters: typeParameters && walkTypeAnnotation(typeParameters),
-        annotation: walkTypeAnnotation(typeAnnotation.typeAnnotation),
-        reference: [...reference],
-      });
-    } else if (isTSEnumDeclaration(typeAnnotation)) {
-      const { id, members } = typeAnnotation;
-      return makeResultWithDocComment({
-        name: id.name,
-        type: "enums",
-        members: members?.map(walkTypeAnnotation),
-        reference: [...reference],
-      });
-    } else if (isTSEnumMember(typeAnnotation)) {
-      return {
-        name: walkTypeAnnotation(typeAnnotation.id),
-        value: walkTypeAnnotation(typeAnnotation.initializer),
-      };
-    } else if (isTSTypeAnnotation(typeAnnotation)) {
-      return walkTypeAnnotation(typeAnnotation.typeAnnotation);
-    } else if (isTSTypeReference(typeAnnotation)) {
-      const { typeName, typeParameters } = typeAnnotation;
-      const qualified = isTSQualifiedName(typeName)
-        ? walkTypeAnnotation(typeName)
-        : undefined;
-      const name = typeName.name;
-      reference.add(name);
-      const params =
-        typeParameters?.params && typeParameters.params.map(walkTypeAnnotation);
-      return makeResultWithDocComment({
-        type: "reference",
-        typeName: name,
-        typeParameters: params,
-        qualified,
-      });
-    } else if (isTSQualifiedName(typeAnnotation)) {
-      const left = walkTypeAnnotation(typeAnnotation.left);
-      if (typeof left === "string") {
-        reference.add(left);
-      }
-      return {
-        type: "qualifiedName",
-        left: left,
-        right: walkTypeAnnotation(typeAnnotation.right),
-      };
-    } else if (isTSUnionType(typeAnnotation)) {
-      return makeResultWithDocComment({
-        type: "union",
-        types: typeAnnotation.types.map(walkTypeAnnotation),
-      });
-    } else if (isTSArrayType(typeAnnotation)) {
-      return makeResultWithDocComment({
-        type: "array",
-        elementType: walkTypeAnnotation(typeAnnotation.elementType),
-      });
-    } else if (isTSTupleType(typeAnnotation)) {
-      return makeResultWithDocComment({
-        type: "tuple",
-        elementTypes: typeAnnotation.elementTypes.map(walkTypeAnnotation),
-      });
-    } else if (isTSIntersectionType(typeAnnotation)) {
-      return makeResultWithDocComment({
-        type: "intersection",
-        types: typeAnnotation.types.map(walkTypeAnnotation),
-      });
-    } else if (isTSTypeLiteral(typeAnnotation)) {
-      return makeResultWithDocComment({
-        type: "typeLiteral",
-        members: typeAnnotation.members.map(walkTypeAnnotation),
-      });
-    } else if (isTSPropertySignature(typeAnnotation)) {
-      return makeResultWithDocComment({
-        type: "propertySignature",
-        name: typeAnnotation.key.name,
-        property: walkTypeAnnotation(typeAnnotation.typeAnnotation),
-      });
-    } else if (isTSIndexSignature(typeAnnotation)) {
-      return makeResultWithDocComment({
-        type: "indexSignature",
-        parameters: {
-          name: typeAnnotation.parameters[0].name,
-          ...walkTypeAnnotation(typeAnnotation.parameters[0].typeAnnotation),
-        },
-        property: walkTypeAnnotation(typeAnnotation.typeAnnotation),
-      });
-    } else if (isTSIndexedAccessType(typeAnnotation)) {
-      return makeResultWithDocComment({
-        type: "indexedAccess",
-        objectType: walkTypeAnnotation(typeAnnotation.objectType),
-        indexType: walkTypeAnnotation(typeAnnotation.indexType),
-      });
-    } else if (isTSTypeParameterDeclaration(typeAnnotation)) {
-      return makeResultWithDocComment({
-        type: "typeParameterDeclaration",
-        params: typeAnnotation.params.map(walkTypeAnnotation),
-      });
-    } else if (isTSTypeParameter(typeAnnotation)) {
-      return makeResultWithDocComment({
-        type: "typeParameter",
-        value: typeAnnotation.name,
-        default:
-          typeAnnotation.default && walkTypeAnnotation(typeAnnotation.default),
-      });
-    } else if (isTSLiteralType(typeAnnotation)) {
-      return makeResultWithDocComment({
-        type: "literal",
-        value: typeAnnotation.literal.value,
-      });
-    } else if (isIdentifier(typeAnnotation)) {
-      return {
-        type: "identifier",
-        value: typeAnnotation.name,
-      };
-    } else if (isStringLiteral(typeAnnotation)) {
-      return {
-        type: "stringLiteral",
-        value: typeAnnotation.value,
-      };
-    } else if (getTSBasicType(typeAnnotation)) {
-      return makeResultWithDocComment({
-        type: "keyword",
-        value: getTSBasicType(typeAnnotation),
-      });
-    }
-  };
-
-  return walkTypeAnnotation(typeAnnotation);
-};