@vitejs/release-scripts 1.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present, Vite contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+# @vitejs/release-scripts
+
+This repo is used to share release & publish scripts for the org. Scripts should be executed from the workspace root via `tsx scripts/release.ts`
+
+## release
+
+```ts
+import { release } from "@vitejs/release-scripts";
+
+release({
+  // Name of the repo for CI link
+  repo: "release-scripts",
+  // List of options. Choice will be available in following callback as `pkg`
+  packages: ["release-scripts"],
+  toTag: (pkg, version) =>
+    pkg === "vite" ? `v${version}` : `${pkg}@${version}`,
+  // Not shared until we find a new changelog process
+  logChangelog: (pkg) =>
+    console.log(
+      execSync(
+        "git log $(git describe --tags --abbrev=0)..HEAD --oneline",
+      ).toString(),
+    ),
+  generateChangelog: (pkg, version) => {},
+  // use getPkgDir when not using a monorepo. Default to `packages/${pkg}`
+  getPkgDir: (pkg) => ".",
+});
+```
+
+## publish
+
+```ts
+import { publish } from "@vitejs/release-scripts";
+
+publish({
+  // Used when tag is not `pkg@version`
+  defaultPackage: "release-scripts",
+  // use getPkgDir when not in a monorepo. Default to `packages/${pkg}`
+  getPkgDir: (pkg) => ".",
+});
+```

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export declare function publish(options: {
+  defaultPackage: string;
+  getPkgDir?: (pkg: string) => string;
+}): Promise<void>;
+
+export declare function release(options: {
+  repo: string;
+  packages: string[];
+  logChangelog: (pkg: string) => void | Promise<void>;
+  generateChangelog: (pkg: string, version: string) => void | Promise<void>;
+  toTag: (pkg: string, version: string) => string;
+  getPkgDir?: (pkg: string) => string;
+}): Promise<void>;

package/dist/index.js

@@ -0,0 +1,279 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  publish: () => publish,
+  release: () => release
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/publish.ts
+var import_semver2 = __toESM(require("semver"));
+
+// src/utils.ts
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"));
+var import_picocolors = __toESM(require("picocolors"));
+var import_execa = require("execa");
+var import_semver = __toESM(require("semver"));
+var import_minimist = __toESM(require("minimist"));
+var args = (0, import_minimist.default)(process.argv.slice(2));
+var isDryRun = !!args.dry;
+if (isDryRun) {
+  console.log(import_picocolors.default.inverse(import_picocolors.default.yellow(" DRY RUN ")));
+  console.log();
+}
+function getPackageInfo(pkgName, getPkgDir = (pkg) => `packages/${pkg}`) {
+  const pkgDir = getPkgDir(pkgName);
+  const pkgPath = import_node_path.default.resolve(pkgDir, "package.json");
+  const pkg = require(pkgPath);
+  const currentVersion = pkg.version;
+  if (pkg.private) {
+    throw new Error(`Package ${pkgName} is private`);
+  }
+  return { npmName: pkg.name, pkgDir, pkgPath, currentVersion };
+}
+async function run(bin, args2, opts = {}) {
+  return (0, import_execa.execa)(bin, args2, { stdio: "inherit", ...opts });
+}
+async function dryRun(bin, args2, opts) {
+  return console.log(
+    import_picocolors.default.blue(`[dryrun] ${bin} ${args2.join(" ")}`),
+    opts || ""
+  );
+}
+var runIfNotDry = isDryRun ? dryRun : run;
+function step(msg) {
+  return console.log(import_picocolors.default.cyan(msg));
+}
+function getVersionChoices(currentVersion) {
+  const currentBeta = currentVersion.includes("beta");
+  const currentAlpha = currentVersion.includes("alpha");
+  const isStable = !currentBeta && !currentAlpha;
+  function inc(i, tag = currentAlpha ? "alpha" : "beta") {
+    return import_semver.default.inc(currentVersion, i, tag);
+  }
+  let versionChoices = [
+    {
+      title: "next",
+      value: inc(isStable ? "patch" : "prerelease")
+    }
+  ];
+  if (isStable) {
+    versionChoices.push(
+      {
+        title: "beta-minor",
+        value: inc("preminor")
+      },
+      {
+        title: "beta-major",
+        value: inc("premajor")
+      },
+      {
+        title: "alpha-minor",
+        value: inc("preminor", "alpha")
+      },
+      {
+        title: "alpha-major",
+        value: inc("premajor", "alpha")
+      },
+      {
+        title: "minor",
+        value: inc("minor")
+      },
+      {
+        title: "major",
+        value: inc("major")
+      }
+    );
+  } else if (currentAlpha) {
+    versionChoices.push({
+      title: "beta",
+      value: inc("patch") + "-beta.0"
+    });
+  } else {
+    versionChoices.push({
+      title: "stable",
+      value: inc("patch")
+    });
+  }
+  versionChoices.push({ value: "custom", title: "custom" });
+  versionChoices = versionChoices.map((i) => {
+    i.title = `${i.title} (${i.value})`;
+    return i;
+  });
+  return versionChoices;
+}
+function updateVersion(pkgPath, version) {
+  const pkg = JSON.parse((0, import_node_fs.readFileSync)(pkgPath, "utf-8"));
+  pkg.version = version;
+  (0, import_node_fs.writeFileSync)(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+async function publishPackage(pkdDir, tag) {
+  const publicArgs = ["publish", "--access", "public"];
+  if (tag) {
+    publicArgs.push(`--tag`, tag);
+  }
+  await runIfNotDry("npm", publicArgs, {
+    cwd: pkdDir
+  });
+}
+async function getActiveVersion(npmName) {
+  try {
+    return (await run("npm", ["info", npmName, "version"], { stdio: "pipe" })).stdout;
+  } catch (e) {
+    if (e.stderr.startsWith("npm ERR! code E404"))
+      return;
+    throw e;
+  }
+}
+
+// src/publish.ts
+var publish = async ({ defaultPackage, getPkgDir }) => {
+  const tag = args._[0];
+  if (!tag)
+    throw new Error("No tag specified");
+  let pkgName = defaultPackage;
+  let version;
+  if (tag.includes("@"))
+    [pkgName, version] = tag.split("@");
+  else
+    version = tag;
+  if (version.startsWith("v"))
+    version = version.slice(1);
+  const { npmName, currentVersion, pkgDir } = getPackageInfo(
+    pkgName,
+    getPkgDir
+  );
+  if (currentVersion !== version)
+    throw new Error(
+      `Package version from tag "${version}" mismatches with current version "${currentVersion}"`
+    );
+  const activeVersion = await getActiveVersion(npmName);
+  step("Publishing package...");
+  const releaseTag = version.includes("beta") ? "beta" : version.includes("alpha") ? "alpha" : activeVersion && import_semver2.default.lt(currentVersion, activeVersion) ? "previous" : void 0;
+  await publishPackage(pkgDir, releaseTag);
+};
+
+// src/release.ts
+var import_prompts = __toESM(require("prompts"));
+var import_semver3 = __toESM(require("semver"));
+var import_picocolors2 = __toESM(require("picocolors"));
+var release = async ({
+  repo,
+  packages,
+  logChangelog,
+  generateChangelog,
+  toTag,
+  getPkgDir
+}) => {
+  let targetVersion;
+  const pkg = packages.length === 1 ? packages[0] : (await (0, import_prompts.default)({
+    type: "select",
+    name: "pkg",
+    message: "Select package",
+    choices: packages.map((i) => ({ value: i, title: i }))
+  })).pkg;
+  if (!pkg)
+    return;
+  await logChangelog(pkg);
+  const { currentVersion, pkgPath } = getPackageInfo(pkg, getPkgDir);
+  if (!targetVersion) {
+    const { release: release2 } = await (0, import_prompts.default)({
+      type: "select",
+      name: "release",
+      message: "Select release type",
+      choices: getVersionChoices(currentVersion)
+    });
+    if (release2 === "custom") {
+      const res = await (0, import_prompts.default)({
+        type: "text",
+        name: "version",
+        message: "Input custom version",
+        initial: currentVersion
+      });
+      targetVersion = res.version;
+    } else {
+      targetVersion = release2;
+    }
+  }
+  if (!import_semver3.default.valid(targetVersion)) {
+    throw new Error(`invalid target version: ${targetVersion}`);
+  }
+  const tag = toTag(pkg, targetVersion);
+  if (targetVersion.includes("beta") && !args.tag) {
+    args.tag = "beta";
+  }
+  if (targetVersion.includes("alpha") && !args.tag) {
+    args.tag = "alpha";
+  }
+  const { yes } = await (0, import_prompts.default)({
+    type: "confirm",
+    name: "yes",
+    message: `Releasing ${import_picocolors2.default.yellow(tag)} Confirm?`
+  });
+  if (!yes)
+    return;
+  step("\nUpdating package version...");
+  updateVersion(pkgPath, targetVersion);
+  await generateChangelog(pkg, targetVersion);
+  const { stdout } = await run("git", ["diff"], { stdio: "pipe" });
+  if (stdout) {
+    step("\nCommitting changes...");
+    await runIfNotDry("git", ["add", "-A"]);
+    await runIfNotDry("git", ["commit", "-m", `release: ${tag}`]);
+    await runIfNotDry("git", ["tag", tag]);
+  } else {
+    console.log("No changes to commit.");
+    return;
+  }
+  step("\nPushing to GitHub...");
+  await runIfNotDry("git", ["push", "origin", `refs/tags/${tag}`]);
+  await runIfNotDry("git", ["push"]);
+  if (isDryRun) {
+    console.log(`
+Dry run finished - run git diff to see package changes.`);
+  } else {
+    console.log(
+      import_picocolors2.default.green(
+        `
+Pushed, publishing should starts shortly on CI.
+https://github.com/vitejs/${repo}/actions/workflows/publish.yml`
+      )
+    );
+  }
+  console.log();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  publish,
+  release
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@vitejs/release-scripts",
+  "version": "1.0.4",
+  "description": "@vitejs release scripts",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsx scripts/build.ts",
+    "prettier": "pnpm prettier-ci --write",
+    "prettier-ci": "prettier --cache --ignore-path=.gitignore --check '**/*.{ts,json,md,yml}'",
+    "ci": "tsc && pnpm prettier-ci && pnpm build",
+    "release": "tsx scripts/release.ts"
+  },
+  "prettier": {
+    "trailingComma": "all"
+  },
+  "dependencies": {
+    "execa": "^6.1.0",
+    "minimist": "^1.2.7",
+    "picocolors": "^1.0.0",
+    "prompts": "^2.4.2",
+    "semver": "^7.3.8"
+  },
+  "devDependencies": {
+    "@types/minimist": "^1.2.2",
+    "@types/node": "^18.11.18",
+    "@types/prompts": "^2.4.2",
+    "@types/semver": "^7.3.13",
+    "esbuild": "^0.16.17",
+    "prettier": "^2.8.2",
+    "tsx": "^3.12.2",
+    "typescript": "^4.9.4"
+  }
+}