@next-core/build-next-bricks 1.11.1 → 1.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next-core/build-next-bricks",
-  "version": "1.11.1",
+  "version": "1.13.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.4.1"
+    "@next-core/brick-manifest": "^0.5.0"
   },
-  "gitHead": "cdd45da473b22e9f884bcbf2f956b4fc564ab2fd"
+  "gitHead": "06fca79a3a3b63a995d92729cfbed8e312cfdccd"
 }

package/src/build.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import webpack from "webpack";
@@ -6,6 +7,7 @@ import MiniCssExtractPlugin from "mini-css-extract-plugin";
 import postcssPresetEnv from "postcss-preset-env";
 import cssnano from "cssnano";
 import cssnanoPresetLite from "cssnano-preset-lite";
+import _ from "lodash";
 import EmitBricksJsonPlugin from "./EmitBricksJsonPlugin.js";
 import getCamelPackageName from "./getCamelPackageName.js";
 import getSvgrLoaders from "./getSvgrLoaders.js";
@@ -65,13 +67,48 @@ async function getWebpackConfig(config) {
 
   const packageJsonFile = await readFile(
     path.join(packageDir, "package.json"),
-    { encoding: "utf-8" }
+    "utf-8"
   );
   const packageJson = JSON.parse(packageJsonFile);
   const packageName = packageJson.name.split("/").pop();
   const camelPackageName = getCamelPackageName(packageName);
   const libName = isBricks ? `bricks/${packageName}` : config.type;
 
+  /** @type {string[]} */
+  let commonBricks;
+  const commonBricksJsonFile = path.join(
+    packageDir,
+    "../../shared/common-bricks/common-bricks.json"
+  );
+  if (existsSync(commonBricksJsonFile)) {
+    const commonBricksJson = JSON.parse(
+      await readFile(commonBricksJsonFile, "utf-8")
+    );
+
+    /** @type {Set<string, string>} */
+    const commonBricksMap = new Map();
+    for (const [pkg, bricks] of Object.entries(commonBricksJson)) {
+      for (const brick of bricks) {
+        const existedPkg = commonBricksMap.get(brick);
+        if (existedPkg && existedPkg !== pkg) {
+          throw new Error(
+            `Conflicted common brick: "${brick}" in package "${existedPkg}" and "${pkg}"`
+          );
+        }
+        commonBricksMap.set(brick, pkg);
+      }
+    }
+
+    commonBricks = Object.prototype.hasOwnProperty.call(
+      commonBricksJson,
+      packageName
+    )
+      ? commonBricksJson[packageName]
+      : [];
+  } else {
+    commonBricks = [];
+  }
+
   const sharedSingletonPackages = [
     "history",
     "i18next",
@@ -181,6 +218,23 @@ async function getWebpackConfig(config) {
     }
   }
 
+  const invalidElements = _.difference(elements, commonBricks);
+  if (invalidElements.length > 0) {
+    throw new Error(
+      `Find common bricks in \`${packageName}\` which are not in common-bricks.json: ${invalidElements.join(
+        ", "
+      )}`
+    );
+  }
+  const missingElements = _.difference(commonBricks, elements);
+  if (missingElements.length > 0) {
+    throw new Error(
+      `Missing common bricks in \`${packageName}\`: ${missingElements.join(
+        ", "
+      )}`
+    );
+  }
+
   /** @type {Record<string, { import: string; name: string; }>} */
   const extraExposes = {};
 

package/src/makeBrickManifest.js

@@ -41,11 +41,12 @@ import { getTypeAnnotation } from "./getTypeDeclaration.js";
 
 /**
  * @param {string} name
+ * @param {string[] | undefined} alias
  * @param {NodePath} nodePath
  * @param {string} source
  * @returns {BrickManifestAndTypes}
  */
-export default function makeBrickManifest(name, nodePath, source) {
+export default function makeBrickManifest(name, alias, nodePath, source) {
   const classPath =
     /** @type {import("@babel/traverse").NodePath<ClassDeclaration>} */ (
       nodePath.parentPath
@@ -53,6 +54,7 @@ export default function makeBrickManifest(name, nodePath, source) {
   /** @type {BrickManifestAndTypes} */
   const manifest = {
     name,
+    alias,
     properties: [],
     events: [],
     slots: [],

package/src/scanBricks.js

@@ -189,8 +189,8 @@ export default async function scanBricks(packageDir) {
       let brickNamespace;
       /** @type string */
       let brickName;
-      let noNamespace = false;
-      if (fullName.includes(".")) {
+      const hasNamespace = fullName.includes(".");
+      if (hasNamespace) {
         [brickNamespace, brickName] = fullName.split(".");
         if (brickNamespace !== packageName) {
           throw new Error(
@@ -212,10 +212,9 @@ export default async function scanBricks(packageDir) {
       } else {
         // For third-party custom elements, there maybe no namespace.
         brickName = fullName;
-        noNamespace = true;
         if (!validCustomElementName.test(brickName)) {
           throw new Error(
-            `Invalid brick: "${fullName}", the brick name must include a \`-\``
+            `Invalid brick: "${brickName}", the brick name must include a \`-\``
           );
         }
       }
@@ -228,7 +227,7 @@ export default async function scanBricks(packageDir) {
           .replace(/\.[^.]+$/, "")
           .replace(/\/index$/, "")}`,
         name: getExposeName(brickName),
-        [Symbol.for("noNamespace")]: noNamespace,
+        [Symbol.for("noNamespace")]: !hasNamespace,
       });
     }
 
@@ -378,29 +377,53 @@ export default async function scanBricks(packageDir) {
             );
           }
 
+          /** @type {string | undefined} */
+          let brickNamespace;
+          /** @type {string} */
+          let brickName;
           const fullName = expression.arguments[0].value;
-          const [brickNamespace, brickName] = fullName.split(".");
+          if (fullName.includes(".")) {
+            [brickNamespace, brickName] = fullName.split(".");
 
-          if (brickNamespace !== packageName) {
-            throw new Error(
-              `Invalid brick: "${fullName}", expecting prefixed with the package name: "${packageName}"`
-            );
-          }
+            if (brickNamespace !== packageName) {
+              throw new Error(
+                `Invalid brick: "${fullName}", expecting prefixed with the package name: "${packageName}"`
+              );
+            }
 
-          if (!validBrickName.test(fullName)) {
-            throw new Error(
-              `Invalid brick: "${fullName}", expecting: "PACKAGE-NAME.BRICK-NAME", where PACKAGE-NAME and BRICK-NAME must be lower-kebab-case, and BRICK-NAME must include a \`-\``
-            );
-          }
+            if (!validBrickName.test(fullName)) {
+              throw new Error(
+                `Invalid brick: "${fullName}", expecting: "PACKAGE-NAME.BRICK-NAME", where PACKAGE-NAME and BRICK-NAME must be lower-kebab-case, and BRICK-NAME must include a \`-\``
+              );
+            }
 
-          if (brickName.startsWith("tpl-")) {
-            throw new Error(
-              `Invalid brick: "${fullName}", the brick name cannot be started with "tpl-"`
-            );
+            if (brickName.startsWith("tpl-")) {
+              throw new Error(
+                `Invalid brick: "${fullName}", the brick name cannot be started with "tpl-"`
+              );
+            }
+          } else {
+            brickName = fullName;
+
+            if (!brickName.startsWith("eo-")) {
+              throw new Error(
+                `Invalid brick: "${brickName}", expecting prefixed with "eo-" for brick name without namespace`
+              );
+            }
+
+            if (!validCustomElementName.test(brickName)) {
+              throw new Error(
+                `Invalid brick: "${brickName}", expecting a \`-\` in brick name`
+              );
+            }
           }
 
           const defineOptions = expression.arguments[1];
+          /** @type {string[]} */
           const deps = [];
+          /** @type {string[]} */
+          const aliases = [];
+
           if (defineOptions && defineOptions.type === "ObjectExpression") {
             /** @type {import("@babel/types").ObjectProperty} */
             const brickDeps = defineOptions.properties.find(
@@ -427,6 +450,32 @@ export default async function scanBricks(packageDir) {
                 );
               }
             }
+
+            /** @type {import("@babel/types").ObjectProperty} */
+            const alias = defineOptions.properties.find(
+              (prop) =>
+                prop.type === "ObjectProperty" &&
+                prop.key.type === "Identifier" &&
+                prop.key.name === "alias" &&
+                !prop.computed
+            );
+            if (alias) {
+              if (alias.value.type === "ArrayExpression") {
+                for (const item of alias.value.elements) {
+                  if (item.type === "StringLiteral") {
+                    aliases.push(item.value);
+                  } else {
+                    throw new Error(
+                      `Invalid item in brick dependencies: ${item.type} of brick: "${fullName}", expecting only StringLiteral`
+                    );
+                  }
+                }
+              } else {
+                throw new Error(
+                  `Invalid brick alias: ${alias.value.type} of brick: "${fullName}", expecting only ArrayExpression`
+                );
+              }
+            }
           }
           if (deps.length > 0) {
             specifiedDeps[fullName] = deps;
@@ -436,15 +485,39 @@ export default async function scanBricks(packageDir) {
 
           brickSourceFiles.set(fullName, filePath);
 
-          manifest.bricks.push(makeBrickManifest(fullName, nodePath, content));
+          manifest.bricks.push(
+            makeBrickManifest(
+              fullName,
+              aliases.length > 0 ? aliases : undefined,
+              nodePath,
+              content
+            )
+          );
 
-          exposes.set(`./${brickName}`, {
+          const expose = {
             import: `./${path
               .relative(packageDir, overrideImport || filePath)
               .replace(/\.[^.]+$/, "")
               .replace(/\/index$/, "")}`,
             name: getExposeName(brickName),
-          });
+            [Symbol.for("noNamespace")]: !brickNamespace,
+          };
+
+          exposes.set(`./${brickName}`, expose);
+          for (const alias of aliases) {
+            brickSourceFiles.set(alias, filePath);
+            let lastName;
+            const hasNamespace = alias.includes(".");
+            if (hasNamespace) {
+              [, lastName] = alias.split(".");
+            } else {
+              lastName = alias;
+            }
+            exposes.set(`./${lastName}`, {
+              ...expose,
+              [Symbol.for("noNamespace")]: !hasNamespace,
+            });
+          }
         }
       },
       FunctionDeclaration(nodePath) {