bun-push 0.1.9

package/dist/utils/workspace.js

@@ -0,0 +1,174 @@
+/**
+ * Workspace 相关工具函数
+ */
+import { readFileSync, existsSync, readdirSync, statSync } from "fs";
+import { join, resolve } from "path";
+import { t } from "../i18n";
+/**
+ * 读取 package.json 文件
+ */
+function readPackageJson(path) {
+    const packageJsonPath = join(path, "package.json");
+    if (!existsSync(packageJsonPath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(packageJsonPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 检查是否是 monorepo 项目
+ */
+function isMonorepo(packageJson) {
+    // 检查是否有 workspaces 字段
+    if (packageJson.workspaces && Array.isArray(packageJson.workspaces)) {
+        return true;
+    }
+    // 检查是否有 workspaces.packages 字段（pnpm/npm 7+）
+    if (packageJson.workspaces?.packages && Array.isArray(packageJson.workspaces.packages)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * 解析 workspace 模式
+ */
+function parseWorkspacePatterns(workspaces) {
+    if (Array.isArray(workspaces)) {
+        return workspaces;
+    }
+    if (workspaces?.packages) {
+        return workspaces.packages;
+    }
+    return [];
+}
+/**
+ * 匹配包路径是否满足 workspace 模式
+ */
+function matchesPattern(path, pattern) {
+    // 简单的 glob 匹配实现
+    const regex = pattern
+        .replace(/\*\*/g, ".*")
+        .replace(/\*/g, "[^/]*")
+        .replace(/\//g, "\\/");
+    return new RegExp(`^${regex}$`).test(path);
+}
+/**
+ * 扫描目录下的包
+ */
+function scanPackages(rootPath, patterns, found = []) {
+    const rootPackageJson = readPackageJson(rootPath);
+    if (!rootPackageJson) {
+        return found;
+    }
+    // 递归扫描目录
+    function scanDirectory(dir, depth = 0) {
+        if (depth > 10)
+            return; // 防止无限递归
+        try {
+            const entries = readdirSync(dir);
+            for (const entry of entries) {
+                const fullPath = join(dir, entry);
+                // 计算相对路径，使用 path.relative 确保跨平台兼容
+                const relativePath = fullPath.startsWith(rootPath)
+                    ? fullPath.slice(rootPath.length).replace(/^[/\\]/, "")
+                    : fullPath;
+                // 跳过 node_modules 和隐藏目录
+                if (entry.startsWith(".") || entry === "node_modules") {
+                    continue;
+                }
+                const stat = statSync(fullPath);
+                if (stat.isDirectory()) {
+                    // 检查是否匹配 workspace 模式
+                    const matches = patterns.some((pattern) => matchesPattern(relativePath, pattern));
+                    if (matches) {
+                        const packageJson = readPackageJson(fullPath);
+                        if (packageJson && packageJson.name) {
+                            found.push({
+                                name: packageJson.name,
+                                version: packageJson.version || "0.0.0",
+                                path: fullPath,
+                                packageJson,
+                            });
+                        }
+                    }
+                    else {
+                        // 继续递归扫描
+                        scanDirectory(fullPath, depth + 1);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // 忽略权限错误等
+        }
+    }
+    scanDirectory(rootPath);
+    return found;
+}
+/**
+ * 获取 workspace 信息
+ */
+export function getWorkspaceInfo(workingDir = process.cwd()) {
+    const rootPath = resolve(workingDir);
+    const rootPackageJson = readPackageJson(rootPath);
+    if (!rootPackageJson) {
+        throw new Error(t("workspace.packageJsonNotFound"));
+    }
+    const isMonorepoProject = isMonorepo(rootPackageJson);
+    if (!isMonorepoProject) {
+        // 单仓库项目
+        return {
+            isMonorepo: false,
+            packages: [
+                {
+                    name: rootPackageJson.name || "unknown",
+                    version: rootPackageJson.version || "0.0.0",
+                    path: rootPath,
+                    packageJson: rootPackageJson,
+                },
+            ],
+            rootPackageJson,
+            rootPath,
+        };
+    }
+    // Monorepo 项目
+    const workspaceConfig = rootPackageJson.workspaces;
+    const patterns = parseWorkspacePatterns(workspaceConfig);
+    if (patterns.length === 0) {
+        throw new Error(t("workspace.workspacesConfigInvalid"));
+    }
+    const packages = scanPackages(rootPath, patterns);
+    // 如果没有找到包，至少包含根包
+    if (packages.length === 0 && rootPackageJson.name) {
+        packages.push({
+            name: rootPackageJson.name,
+            version: rootPackageJson.version || "0.0.0",
+            path: rootPath,
+            packageJson: rootPackageJson,
+        });
+    }
+    return {
+        isMonorepo: true,
+        packages,
+        rootPackageJson,
+        rootPath,
+    };
+}
+/**
+ * 根据包名查找包信息
+ */
+export function findPackageByName(workspaceInfo, packageName) {
+    return workspaceInfo.packages.find((pkg) => pkg.name === packageName);
+}
+/**
+ * 根据路径查找包信息
+ */
+export function findPackageByPath(workspaceInfo, packagePath) {
+    const resolvedPath = resolve(packagePath);
+    return workspaceInfo.packages.find((pkg) => resolve(pkg.path) === resolvedPath);
+}

package/dist/utils/workspace.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=workspace.test.d.ts.map

package/dist/utils/workspace.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.test.d.ts","sourceRoot":"","sources":["../../src/utils/workspace.test.ts"],"names":[],"mappings":""}

package/dist/utils/workspace.test.js

@@ -0,0 +1,124 @@
+/**
+ * Workspace 工具函数测试
+ */
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdir, writeFile, rm } from "fs/promises";
+import { join } from "path";
+import { getWorkspaceInfo, findPackageByName, findPackageByPath } from "./workspace";
+// 临时测试目录
+const TEST_DIR = join(process.cwd(), ".test-tmp");
+describe("Workspace 工具函数", () => {
+    beforeEach(async () => {
+        // 清理并创建测试目录
+        try {
+            await rm(TEST_DIR, { recursive: true, force: true });
+        }
+        catch {
+            // 忽略错误
+        }
+        await mkdir(TEST_DIR, { recursive: true });
+    });
+    afterEach(async () => {
+        // 清理测试目录
+        try {
+            await rm(TEST_DIR, { recursive: true, force: true });
+        }
+        catch {
+            // 忽略错误
+        }
+    });
+    describe("getWorkspaceInfo - 单仓库项目", () => {
+        test("应该正确识别单仓库项目", async () => {
+            const packageJson = {
+                name: "test-package",
+                version: "1.0.0",
+            };
+            await writeFile(join(TEST_DIR, "package.json"), JSON.stringify(packageJson, null, 2));
+            const workspaceInfo = getWorkspaceInfo(TEST_DIR);
+            expect(workspaceInfo.isMonorepo).toBe(false);
+            expect(workspaceInfo.packages).toHaveLength(1);
+            expect(workspaceInfo.packages[0].name).toBe("test-package");
+            expect(workspaceInfo.packages[0].version).toBe("1.0.0");
+        });
+        test("没有 package.json 应该抛出错误", () => {
+            expect(() => getWorkspaceInfo(join(TEST_DIR, "nonexistent"))).toThrow("未找到 package.json");
+        });
+    });
+    describe("getWorkspaceInfo - Monorepo 项目", () => {
+        test("应该正确识别数组格式的 workspaces", async () => {
+            const rootPackageJson = {
+                name: "root",
+                version: "1.0.0",
+                workspaces: ["packages/*"],
+            };
+            await writeFile(join(TEST_DIR, "package.json"), JSON.stringify(rootPackageJson, null, 2));
+            // 创建子包目录
+            const packagesDir = join(TEST_DIR, "packages");
+            await mkdir(packagesDir, { recursive: true });
+            const pkg1Dir = join(packagesDir, "pkg1");
+            await mkdir(pkg1Dir, { recursive: true });
+            await writeFile(join(pkg1Dir, "package.json"), JSON.stringify({ name: "pkg1", version: "1.0.0" }, null, 2));
+            const workspaceInfo = getWorkspaceInfo(TEST_DIR);
+            expect(workspaceInfo.isMonorepo).toBe(true);
+            expect(workspaceInfo.packages.length).toBeGreaterThanOrEqual(1);
+        });
+        test("应该正确识别对象格式的 workspaces", async () => {
+            const rootPackageJson = {
+                name: "root",
+                version: "1.0.0",
+                workspaces: {
+                    packages: ["packages/*"],
+                },
+            };
+            await writeFile(join(TEST_DIR, "package.json"), JSON.stringify(rootPackageJson, null, 2));
+            const workspaceInfo = getWorkspaceInfo(TEST_DIR);
+            expect(workspaceInfo.isMonorepo).toBe(true);
+        });
+    });
+    describe("findPackageByName", () => {
+        test("应该根据包名查找包", async () => {
+            const packageJson = {
+                name: "test-package",
+                version: "1.0.0",
+            };
+            await writeFile(join(TEST_DIR, "package.json"), JSON.stringify(packageJson, null, 2));
+            const workspaceInfo = getWorkspaceInfo(TEST_DIR);
+            const found = findPackageByName(workspaceInfo, "test-package");
+            expect(found).toBeDefined();
+            expect(found?.name).toBe("test-package");
+        });
+        test("找不到包应该返回 undefined", async () => {
+            const packageJson = {
+                name: "test-package",
+                version: "1.0.0",
+            };
+            await writeFile(join(TEST_DIR, "package.json"), JSON.stringify(packageJson, null, 2));
+            const workspaceInfo = getWorkspaceInfo(TEST_DIR);
+            const found = findPackageByName(workspaceInfo, "nonexistent");
+            expect(found).toBeUndefined();
+        });
+    });
+    describe("findPackageByPath", () => {
+        test("应该根据路径查找包", async () => {
+            const packageJson = {
+                name: "test-package",
+                version: "1.0.0",
+            };
+            await writeFile(join(TEST_DIR, "package.json"), JSON.stringify(packageJson, null, 2));
+            const workspaceInfo = getWorkspaceInfo(TEST_DIR);
+            const found = findPackageByPath(workspaceInfo, TEST_DIR);
+            expect(found).toBeDefined();
+            expect(found?.name).toBe("test-package");
+        });
+        test("找不到路径应该返回 undefined", async () => {
+            const packageJson = {
+                name: "test-package",
+                version: "1.0.0",
+            };
+            await writeFile(join(TEST_DIR, "package.json"), JSON.stringify(packageJson, null, 2));
+            const workspaceInfo = getWorkspaceInfo(TEST_DIR);
+            const found = findPackageByPath(workspaceInfo, "/nonexistent/path");
+            expect(found).toBeUndefined();
+        });
+    });
+});

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "bun-push",
+  "version": "0.1.9",
+  "description": "一个支持 monorepo 和单仓库的 npm 包发布工具，支持 CLI 和 JS API 两种使用方式",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "private": false,
+  "bin": {
+    "bun-push": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun test && bun run build.config.ts",
+    "dev": "bun run --watch src/cli.ts",
+    "test": "bun test"
+  },
+  "keywords": [
+    "npm",
+    "publish",
+    "monorepo",
+    "workspace",
+    "cli",
+    "release"
+  ],
+  "author": "ccode",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ccode/bun-push.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ccode/bun-push/issues"
+  },
+  "homepage": "https://github.com/ccode/bun-push#readme",
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "dependencies": {
+    "prompts": "^2.4.2",
+    "chalk": "^5.3.0",
+    "ora": "^8.1.1",
+    "semver": "^7.7.1",
+    "zod": "^3.24.1",
+    "figlet": "^1.7.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/prompts": "^2.4.9",
+    "@types/semver": "^7.5.8",
+    "@types/figlet": "^1.7.0",
+    "typescript": "^5.7.3"
+  }
+}