fix: devkit build error, add external deps

packages/devkit/package.json

@@ -44,6 +44,7 @@
     "execa": "^8.0.1",
     "fast-glob": "^3.3.3",
     "fs-extra": "^11.3.2",
+    "js-yaml": "^4.1.0",
     "lodash": "^4.17.21",
     "npm-packlist": "^10.0.2",
     "open": "^10.2.0",
@@ -66,6 +67,7 @@
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
+    "@types/js-yaml": "^4.0.9",
     "@types/lodash": "^4.17.20",
     "@types/node": "20.17.10",
     "@types/npm-packlist": "^7.0.3",

packages/devkit/src/builder/build/utils/getDepsConfig.ts

@@ -1,7 +1,11 @@
 import { createRequire } from 'node:module';
 import path from 'node:path';
 
+import { findWorkspacePackages } from '@pnpm/workspace.find-packages';
 import fs from 'fs-extra';
+import { load } from 'js-yaml';
+
+import { ROOT_PATH } from '../constant';
 
 const require = createRequire(import.meta.url);
 
@@ -63,6 +67,115 @@ export function getDepPkgPath(dep: string, cwd: string) {
   }
 }
 
+/**
+ * Get workspace package path by name
+ */
+async function getWorkspacePackagePath(packageName: string): Promise<string | null> {
+  try {
+    const allProjects = await findWorkspacePackages(ROOT_PATH, {
+      supportedArchitectures: {
+        os: ['current'],
+        cpu: ['current'],
+        libc: ['current'],
+      },
+    });
+    const pkg = allProjects.find((p) => p.manifest.name === packageName);
+    return pkg ? path.join(pkg.dir, 'package.json') : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get catalog version from pnpm-workspace.yaml
+ */
+function getCatalogVersion(packageName: string, catalogRef: string): string | null {
+  try {
+    const workspaceYamlPath = path.join(ROOT_PATH, 'pnpm-workspace.yaml');
+    if (!fs.existsSync(workspaceYamlPath)) {
+      return null;
+    }
+    const workspaceContent = fs.readFileSync(workspaceYamlPath, 'utf-8');
+    const workspaceConfig = load(workspaceContent) as { catalog?: Record<string, string> };
+    if (!workspaceConfig.catalog) {
+      return null;
+    }
+    // catalog: 协议格式为 catalog:packageName 或 catalog:packageName@version
+    const catalogKey = catalogRef.replace('catalog:', '');
+    return workspaceConfig.catalog[catalogKey] || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get dependency version based on protocol type
+ * - workspace:*: Read from workspace package.json
+ * - catalog:: Read from pnpm-workspace.yaml catalog
+ * - normal: Read from node_modules
+ */
+export async function getDepVersion(packageName: string, cwd: string): Promise<string | null> {
+  try {
+    // Get current package.json to check dependency protocol
+    const currentPkgPath = path.join(cwd, 'package.json');
+    if (!fs.existsSync(currentPkgPath)) {
+      // Fallback to node_modules if package.json not found
+      const depPkgPath = getDepPkgPath(packageName, cwd);
+      const depPkg = require(depPkgPath);
+      return depPkg.version;
+    }
+
+    const currentPkg = fs.readJsonSync(currentPkgPath);
+    const allDeps = {
+      ...currentPkg.dependencies,
+      ...currentPkg.devDependencies,
+      ...currentPkg.peerDependencies,
+    };
+
+    const depVersion = allDeps[packageName];
+    if (!depVersion) {
+      // Not in dependencies, try to get from node_modules
+      const depPkgPath = getDepPkgPath(packageName, cwd);
+      const depPkg = require(depPkgPath);
+      return depPkg.version;
+    }
+
+    // Check protocol type
+    if (depVersion === 'workspace:*' || depVersion.startsWith('workspace:')) {
+      // For workspace:* protocol, read from workspace package.json
+      const workspacePkgPath = await getWorkspacePackagePath(packageName);
+      if (workspacePkgPath && fs.existsSync(workspacePkgPath)) {
+        const workspacePkg = fs.readJsonSync(workspacePkgPath);
+        return workspacePkg.version;
+      }
+      // Fallback to node_modules if workspace package not found
+      const depPkgPath = getDepPkgPath(packageName, cwd);
+      const depPkg = require(depPkgPath);
+      return depPkg.version;
+    }
+
+    if (depVersion.startsWith('catalog:')) {
+      // For catalog: protocol, read from pnpm-workspace.yaml catalog
+      const catalogVersion = getCatalogVersion(packageName, depVersion);
+      if (catalogVersion) {
+        return catalogVersion;
+      }
+      // Fallback to node_modules if catalog not found
+      const depPkgPath = getDepPkgPath(packageName, cwd);
+      const depPkg = require(depPkgPath);
+      return depPkg.version;
+    }
+
+    // For normal dependencies, read from node_modules
+    const depPkgPath = getDepPkgPath(packageName, cwd);
+    const depPkg = require(depPkgPath);
+    return depPkg.version;
+  } catch (error) {
+    console.error(`Error getting version for ${packageName}:`, error);
+    return null;
+  }
+}
+
 interface IDepPkg {
   nccConfig: {
     minify: boolean;

packages/devkit/src/builder/buildable-packages/plugin-package.ts

@@ -24,7 +24,7 @@ import {
   getPackagesFromFiles,
   getSourcePackages,
 } from '../build/utils/buildPluginUtils';
-import { getDepPkgPath, getDepsConfig } from '../build/utils/getDepsConfig';
+import { getDepsConfig, getDepVersion } from '../build/utils/getDepsConfig';
 import { IBuildablePackage, IBuildContext } from '../interfaces';
 
 const require = createRequire(import.meta.url);
@@ -144,23 +144,26 @@ export function deleteServerFiles(cwd: string, log: PkgLog) {
   });
 }
 
-export function writeExternalPackageVersion(cwd: string, log: PkgLog) {
+export async function writeExternalPackageVersion(cwd: string, log: PkgLog) {
   log('write external version');
   const sourceFiles = fg
     .globSync(sourceGlobalFiles, { cwd, absolute: true })
     .map((item) => fs.readFileSync(item, 'utf-8'));
   const sourcePackages = getSourcePackages(sourceFiles);
   const excludePackages = getExcludePackages(sourcePackages, external, pluginPrefix);
-  const data = excludePackages.reduce<Record<string, string>>((prev, packageName) => {
+  const data: Record<string, string> = {};
+
+  for (const packageName of excludePackages) {
     try {
-      const depPkgPath = getDepPkgPath(packageName, cwd);
-      const depPkg = require(depPkgPath);
-      prev[packageName] = depPkg.version;
+      const version = await getDepVersion(packageName, cwd);
+      if (version) {
+        data[packageName] = version;
+      }
     } catch (error) {
-      console.error(error);
+      console.error(`Error getting version for ${packageName}:`, error);
     }
-    return prev;
-  }, {});
+  }
+
   const externalVersionPath = path.join(cwd, target_dir, 'externalVersion.js');
   fs.writeFileSync(externalVersionPath, `module.exports = ${JSON.stringify(data, null, 2)};`);
 }
@@ -391,7 +394,7 @@ export class PluginPackage implements IBuildablePackage {
 
     await buildPluginClient(this.dir, userConfig, this.context.sourcemap, log);
     await buildPluginServer(this.dir, userConfig, this.context.sourcemap, log);
-    writeExternalPackageVersion(this.dir, log);
+    await writeExternalPackageVersion(this.dir, log);
 
     if (this.context.dts) {
       await buildDeclaration(this.dir, 'dist', log);