@pob/version 1.0.1

package/src/index.ts

@@ -0,0 +1,13 @@
+import fs from "node:fs";
+import { program } from "commander";
+
+import "./commands/version.ts";
+
+// relative to dist directory
+const pkg = JSON.parse(
+  // eslint-disable-next-line unicorn/prefer-json-parse-buffer
+  fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"),
+);
+
+program.name(pkg.name).description(pkg.description).version(pkg.version);
+program.parse();

package/src/missing-types.d.ts

@@ -0,0 +1,10 @@
+// declare module "conventional-changelog-core" {
+//   export default function conventionalChangelogCore(
+//     options: any,
+//     context?: any,
+//     gitRawCommitsOpts?: any,
+//     parserOpts?: any,
+//     writerOpts?: any,
+//     gitRawExecOpts?: any,
+//   ): Readable;
+// }

package/src/pm/BunPackageManager.ts

@@ -0,0 +1,12 @@
+import { execCommand } from "../utils/execCommand.ts";
+import type { PackageManager } from "./PackageManager.ts";
+
+export const BunPackageManager: PackageManager = {
+  async runScript(workspace, scriptName) {
+    await execCommand(workspace, ["bun", "run", scriptName], "inherit");
+  },
+
+  async publish(workspace) {
+    await execCommand(workspace, ["bun", "publish"], "inherit");
+  },
+};

package/src/pm/PackageManager.ts

@@ -0,0 +1,66 @@
+import { existsSync } from "node:fs";
+import type { Workspace } from "../utils/packageUtils.ts";
+import { BunPackageManager } from "./BunPackageManager.ts";
+import { YarnPackageManager } from "./YarnPackageManager.ts";
+
+export interface PackageManager {
+  installOnPackageContentChange?: (rootWorkspace: Workspace) => Promise<void>;
+  runScript: (workspace: Workspace, scriptName: string) => Promise<void>;
+  publish: (workspace: Workspace) => Promise<void>;
+  publishWorkspaces?: (rootWorkspace: Workspace) => Promise<void>;
+}
+
+export const autoDetectPackageManager = (
+  rootWorkspace: Workspace,
+): PackageManager => {
+  const hasYarnLock = existsSync(`${rootWorkspace.cwd}/yarn.lock`);
+  const hasBunLockLegacy = existsSync(`${rootWorkspace.cwd}/bun.lockb`);
+  const hasBunLock = existsSync(`${rootWorkspace.cwd}/bun.lock`);
+  const hasNpmPackageLock = existsSync(
+    `${rootWorkspace.cwd}/package-lock.json`,
+  );
+
+  if (
+    [hasYarnLock, hasBunLockLegacy, hasBunLock, hasNpmPackageLock].filter(
+      Boolean,
+    ).length > 1
+  ) {
+    throw new Error(
+      `Multiple lock files detected in workspace at ${rootWorkspace.cwd}. Please ensure only one lock file is present, or pass --package-manager option to bypass auto-detection.`,
+    );
+  }
+
+  if (hasYarnLock) {
+    return YarnPackageManager;
+  }
+
+  if (hasBunLockLegacy || hasBunLock) {
+    return BunPackageManager;
+  }
+
+  if (hasNpmPackageLock) {
+    throw new Error(
+      "NPM is not currently supported as a package manager. Please migrate to Yarn or Bun, or open an issue to request support.",
+    );
+  }
+
+  throw new Error(
+    `No lock file detected in workspace at ${rootWorkspace.cwd}. Please ensure a supported lock file is present, or pass --package-manager option to bypass auto-detection.`,
+  );
+};
+
+export const getPackageManager = (
+  rootWorkspace: Workspace,
+  specifiedPackageManager?: "bun" | "yarn",
+): PackageManager => {
+  if (specifiedPackageManager === "bun") {
+    return BunPackageManager;
+  }
+
+  if (specifiedPackageManager === "yarn") {
+    return YarnPackageManager;
+  }
+  throw new Error(
+    "Invalid package manager specified. Supported values are 'bun' and 'yarn'.",
+  );
+};

package/src/pm/YarnPackageManager.ts

@@ -0,0 +1,34 @@
+import { execCommand } from "../utils/execCommand.ts";
+import type { Workspace } from "../utils/packageUtils.ts";
+import type { PackageManager } from "./PackageManager.ts";
+
+export const YarnPackageManager: PackageManager = {
+  async installOnPackageContentChange(rootWorkspace: Workspace) {
+    await execCommand(rootWorkspace, ["yarn", "install"], "inherit");
+  },
+
+  async runScript(workspace: Workspace, scriptName: string) {
+    await execCommand(workspace, ["yarn", "run", scriptName], "inherit");
+  },
+
+  async publish(workspace: Workspace) {
+    await execCommand(workspace, ["yarn", "npm", "publish"], "inherit");
+  },
+
+  async publishWorkspaces(rootWorkspace: Workspace) {
+    await execCommand(
+      rootWorkspace,
+      [
+        "yarn",
+        "workspaces",
+        "foreach",
+        "--all",
+        "--parallel",
+        "--no-private",
+        "npm",
+        "publish",
+      ],
+      "inherit",
+    );
+  },
+};

package/src/utils/UsageError.ts

@@ -0,0 +1,6 @@
+export class UsageError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "UsageError";
+  }
+}

package/src/utils/bumpTypeUtils.ts

@@ -0,0 +1,113 @@
+import semver from "semver";
+import { UsageError } from "./UsageError.ts";
+import type { Workspace } from "./packageUtils.ts";
+import { getWorkspaceName } from "./workspaceUtils.ts";
+
+export type BumpType = "major" | "minor" | "patch";
+
+// https://github.com/yarnpkg/berry/blob/506ded5f5f5a89553435940c74f1d857fd685a42/packages/plugin-version/sources/versionUtils.ts#L10
+// Basically we only support auto-upgrading the ranges that are very simple (^x.y.z, ~x.y.z, >=x.y.z, and of course x.y.z)
+const SUPPORTED_UPGRADE_REGEXP =
+  // eslint-disable-next-line regexp/no-unused-capturing-group
+  /^((?:>=|[~^])?)(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(-(0|[1-9]\d*|\d*[a-z-][0-9a-z-]*)(\.(0|[1-9]\d*|\d*[a-z-][0-9a-z-]*))*)?(\+[0-9a-z-]+(\.[0-9a-z-]+)*)?$/i;
+
+const yarnWorkspaceProtocol = "workspace:";
+
+export const calcBumpRange = (
+  workspace: Workspace,
+  range: string,
+  newVersion: string,
+): string => {
+  if (range === "*") {
+    return range;
+  }
+
+  let useWorkspaceProtocol = false;
+
+  if (range.startsWith(yarnWorkspaceProtocol)) {
+    const slicedRange = range.slice(yarnWorkspaceProtocol.length);
+
+    // Workspaces referenced through their path never get upgraded ("workspace:packages/yarnpkg-core")
+    if (slicedRange === workspace.relativeCwd) {
+      return range;
+    }
+
+    if (slicedRange === "*") {
+      return range;
+    }
+
+    range = slicedRange;
+    useWorkspaceProtocol = true;
+  }
+
+  const parsed = SUPPORTED_UPGRADE_REGEXP.exec(range);
+  if (!parsed) {
+    const workspaceName = getWorkspaceName(workspace);
+    throw new Error(`Couldn't bump range ${range} in ${workspaceName}`);
+  }
+
+  return `${useWorkspaceProtocol ? yarnWorkspaceProtocol : ""}${
+    parsed[1] ?? ""
+  }${newVersion}`;
+};
+
+export const getHighestBumpType = (bumpTypes: BumpType[]): BumpType => {
+  if (bumpTypes.includes("major")) {
+    return "major";
+  }
+
+  if (bumpTypes.includes("minor")) {
+    return "minor";
+  }
+
+  return "patch";
+};
+
+export const calcBumpType = (
+  bumpType: BumpType,
+  maxBumpType: BumpType,
+): BumpType => {
+  if (maxBumpType === "major") {
+    return bumpType;
+  }
+
+  if (maxBumpType === "minor") {
+    return bumpType === "major" || bumpType === "minor" ? "minor" : "patch";
+  }
+
+  return "patch";
+};
+
+const incVersion = (version: string, bumpType: BumpType): string | null => {
+  // handle breaking of 0.x
+  if (bumpType === "major" && semver.major(version) === 0) {
+    bumpType = "minor";
+  }
+  return semver.inc(version, bumpType);
+};
+
+export const incrementVersion = (
+  workspace: Workspace,
+  currentVersion: string,
+  bumpType: BumpType,
+): string => {
+  const newVersion = incVersion(currentVersion, bumpType);
+
+  if (!newVersion) {
+    throw new UsageError(
+      `Could not determine next version for "${getWorkspaceName(
+        workspace,
+      )}" (currentVersion: ${currentVersion}, bumpType: ${bumpType}})`,
+    );
+  }
+
+  return newVersion;
+};
+
+// const createPrerelease = (
+//   version: string,
+//   prereleaseType: ReleaseType,
+//   prereleaseId: string,
+// ) => {
+//   return semver.inc(version, prereleaseType, prereleaseId);
+// };