@fuman/build 0.0.7 → 0.0.10

package/cli/commands/release.d.ts

@@ -2,6 +2,7 @@ import { bc } from './_utils.js';
 export declare const releaseCli: bc.Command<{
     kind: "auto" | "major" | "minor" | "patch";
     withGithubRelease: boolean;
+    gitExtraOrigins: string | undefined;
     githubToken: string | undefined;
     githubRepo: string | undefined;
     githubApiUrl: string | undefined;
@@ -19,6 +20,7 @@ export declare const releaseCli: bc.Command<{
 }, {
     kind: "auto" | "major" | "minor" | "patch";
     withGithubRelease: boolean;
+    gitExtraOrigins: string | undefined;
     githubToken: string | undefined;
     githubRepo: string | undefined;
     githubApiUrl: string | undefined;

package/cli/commands/release.js

@@ -21,6 +21,8 @@ const releaseCli = bc.command({
   options: {
     kind: bc.string("kind").desc("release kind").enum("major", "minor", "patch", "auto").default("auto"),
     withGithubRelease: bc.boolean("with-github-release").desc("whether to create a github release (requires GITHUB_TOKEN env var). if false, will only create a commit with the release notes").default(false),
+    gitExtraOrigins: bc.string("git-extra-origins").desc("extra git origins to push to (e.g. for mirrors). note that these origins will be force-pushed to"),
+    // ...because for some reason forgejo fails to properly push to the mirrors on push :/
     githubToken: bc.string("github-token").desc("github token to use for creating a release (defaults to GITHUB_TOKEN env var)"),
     githubRepo: bc.string("github-repo").desc("github repo to create a release for (defaults to GITHUB_REPOSITORY env var)"),
     githubApiUrl: bc.string("github-api-url").desc("github api url to use for creating a release (for github-compatible apis)"),
@@ -58,6 +60,7 @@ const releaseCli = bc.command({
         workspace: workspaceWithRoot,
         since: prevTag ?? await getFirstCommit(root),
         type: args.kind === "auto" ? void 0 : args.kind,
+        all: args.kind !== "auto",
         cwd: root,
         params: config?.versioning,
         dryRun: args.dryRun,
@@ -90,6 +93,13 @@ const releaseCli = bc.command({
         process.exit(1);
       }
     }
+    if (!changedPackages.some((pkg) => pkg.json.version === tagName.replace(/^v/, ""))) {
+      console.log(`❗ tag ${tagName} does not match any of the package versions. did the previous release complete successfully?`);
+      console.log("❗ if so, please verify versions in package.json, tag the commit release and try again");
+      if (!args.dryRun) {
+        process.exit(1);
+      }
+    }
     console.log("");
     console.log("📝 generating changelog...");
     const changelog = prevTag != null ? await generateChangelog({
@@ -161,6 +171,7 @@ const releaseCli = bc.command({
         "--quiet",
         "--allow-dirty",
         ...args.dryRun ? ["--dry-run"] : [],
+        ...args.jsrToken != null ? ["--token", args.jsrToken] : [],
         ...args.jsrPublishArgs?.split(" ") ?? []
       ], {
         env: {
@@ -176,6 +187,7 @@ const releaseCli = bc.command({
     if (args.dryRun) {
       console.log("dry run, skipping release commit and tag");
     } else {
+      await config?.versioning?.beforeReleaseCommit?.(workspaceWithRoot);
       let message = `chore(release): ${tagName}`;
       if (!args.withGithubRelease) {
         message += `
@@ -187,11 +199,32 @@ ${changelog}`;
         stdio: "inherit",
         throwOnError: true
       });
-      await exec(["git", "tag", tagName], {
+      await exec(["git", "tag", tagName, "-m", tagName], {
+        cwd: root,
+        stdio: "inherit",
+        throwOnError: true
+      });
+    }
+    if (!args.dryRun) {
+      await exec(["git", "push", "--follow-tags"], {
         cwd: root,
         stdio: "inherit",
         throwOnError: true
       });
+      if (args.gitExtraOrigins != null) {
+        for (const origin of args.gitExtraOrigins.split(",")) {
+          await exec(["git", "push", origin, "--force"], {
+            cwd: root,
+            stdio: "inherit",
+            throwOnError: true
+          });
+          await exec(["git", "push", origin, "--force", "--tags"], {
+            cwd: root,
+            stdio: "inherit",
+            throwOnError: true
+          });
+        }
+      }
     }
     if (args.withGithubRelease) {
       if (args.dryRun) {
@@ -222,13 +255,6 @@ ${changelog}`;
         console.log(`\x1B[;32m✅github release created: https://github.com/${repo}/releases/tag/${tagName}\x1B[;0m`);
       }
     }
-    if (!args.dryRun) {
-      await exec(["git", "push", "--follow-tags"], {
-        cwd: root,
-        stdio: "inherit",
-        throwOnError: true
-      });
-    }
     console.log("");
     console.log("🎉 done!");
   }

package/cli/commands/validate-workspace-deps.d.ts

@@ -32,13 +32,19 @@ export declare function validateWorkspaceDeps(params: {
      * @default true
      */
     skipWorkspaceDeps?: boolean;
+    /** whether to skip validating peer dependencies */
+    skipPeerDeps?: boolean;
 }): Promise<WorkspaceDepsError[]>;
 export declare const validateWorkspaceDepsCli: bc.Command<{
     includeRoot: boolean;
     noSkipWorkspaceDeps: boolean | undefined;
     root: string | undefined;
+    withErrorCode: boolean | undefined;
+    skipPeerDeps: boolean | undefined;
 }, {
     includeRoot: boolean;
     noSkipWorkspaceDeps: boolean | undefined;
     root: string | undefined;
+    withErrorCode: boolean | undefined;
+    skipPeerDeps: boolean | undefined;
 }>;

package/cli/commands/validate-workspace-deps.js

@@ -6,7 +6,8 @@ async function validateWorkspaceDeps(params) {
   const {
     workspaceRoot,
     includeRoot = true,
-    skipWorkspaceDeps = true
+    skipWorkspaceDeps = true,
+    skipPeerDeps = true
   } = params;
   const pjs = await collectPackageJsons(workspaceRoot, includeRoot);
   const workspacePackages = new Set(skipWorkspaceDeps ? pjs.map((pj) => pj.json.name) : []);
@@ -19,6 +20,7 @@ async function validateWorkspaceDeps(params) {
     for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
       const deps = pj[field];
       if (!deps) continue;
+      if (field === "peerDependencies" && skipPeerDeps) continue;
       for (const [name, version] of Object.entries(deps)) {
         if (workspacePackages.has(name)) continue;
         if (version.startsWith("workspace:")) continue;
@@ -26,7 +28,13 @@ async function validateWorkspaceDeps(params) {
           versions[name] = {};
         }
         for (const [pkgName, pkgDepVersions] of Object.entries(versions[name])) {
-          if (!satisfies(version, pkgDepVersions)) {
+          let ok = true;
+          if (pkgDepVersions.match(/^(?:https?:\/\/|catalog:)/)) {
+            ok = version === pkgDepVersions;
+          } else {
+            ok = satisfies(version, pkgDepVersions);
+          }
+          if (!ok) {
             errors.push({
               package: pj.name,
               dependency: name,
@@ -49,19 +57,25 @@ const validateWorkspaceDepsCli = bc.command({
   options: {
     includeRoot: bc.boolean("include-root").desc("whether to also validate the root package.json").default(false),
     noSkipWorkspaceDeps: bc.boolean("no-skip-workspace-deps").desc("whether to not skip validating dependencies of other workspace packages"),
-    root: bc.string().desc("path to the root of the workspace (default: cwd)")
+    root: bc.string().desc("path to the root of the workspace (default: cwd)"),
+    withErrorCode: bc.boolean("with-error-code").desc("whether to exit with a non-zero code if there are mismatches"),
+    skipPeerDeps: bc.boolean("skip-peer-deps").desc("whether to skip validating peer dependencies")
   },
   handler: async (args) => {
     const errors = await validateWorkspaceDeps({
       workspaceRoot: args.root ?? process.cwd(),
       includeRoot: args.includeRoot,
-      skipWorkspaceDeps: !args.noSkipWorkspaceDeps
+      skipWorkspaceDeps: !args.noSkipWorkspaceDeps,
+      skipPeerDeps: args.skipPeerDeps
     });
     if (errors.length > 0) {
       console.error("⚠️ Found external dependencies mismatch:");
       for (const error of errors) {
         console.error(`  - at ${error.package}: ${error.at} has ${error.dependency}@${error.version}, but ${error.otherPackage} has @${error.otherVersion}`);
       }
+      if (args.withErrorCode) {
+        process.exit(1);
+      }
     } else {
       console.log("✅ All external dependencies match!");
     }

package/git/github.js

@@ -20,16 +20,18 @@ async function createGithubRelease(params) {
       tag_name: params.tag,
       name: params.name,
       body: params.body,
-      draft: params.draft,
-      prerelease: params.prerelease
+      draft: params.draft ?? false,
+      prerelease: params.prerelease ?? false
     },
     validateResponse: (res) => res.status === 201
   }).parsedJson(z.object({
-    id: z.number()
+    id: z.number(),
+    upload_url: z.string()
   }));
+  const uploadUrl = release.upload_url.split("{")[0];
   if (params.artifacts != null && params.artifacts.length > 0) {
     await asyncPool(params.artifacts, async (file) => {
-      await ffetch(`https://uploads.github.com/repos/${params.repo}/releases/${release.id}/assets`, {
+      await ffetch(uploadUrl, {
         method: "POST",
         query: { name: file.name },
         headers: {

package/index.js

@@ -11,7 +11,7 @@ import { getTsconfigFiles, getTsconfigFor } from "./misc/tsconfig.js";
 import { NPM_PACKAGE_NAME_REGEX, npmCheckVersion } from "./npm/npm-api.js";
 import { collectPackageJsons, filterPackageJsonsForPublish } from "./package-json/collect-package-jsons.js";
 import { findPackageJson } from "./package-json/find-package-json.js";
-import { parsePackageJson, parsePackageJsonFile, parseWorkspaceRootPackageJson } from "./package-json/parse.js";
+import { parsePackageJson, parsePackageJsonFile, parsePackageJsonFromDir, parseWorkspaceRootPackageJson } from "./package-json/parse.js";
 import { processPackageJson } from "./package-json/process-package-json.js";
 import { PackageJsonSchema } from "./package-json/types.js";
 import { bumpVersion } from "./versioning/bump-version.js";
@@ -48,6 +48,7 @@ export {
   parseConventionalCommit,
   parsePackageJson,
   parsePackageJsonFile,
+  parsePackageJsonFromDir,
   parseWorkspaceRootPackageJson,
   processPackageJson,
   sortWorkspaceByPublishOrder,

package/jsr/generate-workspace.js

@@ -2,6 +2,7 @@ import * as fsp from "node:fs/promises";
 import { join, relative } from "node:path";
 import process from "node:process";
 import { asyncPool } from "@fuman/utils";
+import picomatch from "picomatch";
 import { glob } from "tinyglobby";
 import ts from "typescript";
 import { loadBuildConfig } from "../misc/_config.js";
@@ -62,12 +63,18 @@ async function generateDenoWorkspace(params) {
     const packageConfigJsr = packageConfig?.jsr;
     const srcDir = join(packageRoot, normalizeFilePath(packageConfigJsr?.sourceDir ?? rootConfig?.sourceDir ?? ""));
     const excludeFiles = mergeArrays(rootConfig?.exclude, packageConfigJsr?.exclude);
-    await fsp.cp(srcDir, packageOutRoot, { recursive: true });
-    const printer = ts.createPrinter();
-    const tsFiles = await glob("**/*.ts", {
-      cwd: packageOutRoot,
-      ignore: excludeFiles
+    const exludeFilesPico = picomatch(excludeFiles);
+    await fsp.cp(srcDir, packageOutRoot, {
+      recursive: true,
+      filter(source) {
+        if (exludeFilesPico(relative(srcDir, source))) {
+          return false;
+        }
+        return true;
+      }
     });
+    const printer = ts.createPrinter();
+    const tsFiles = await glob("**/*.ts", { cwd: packageOutRoot });
     await asyncPool(tsFiles, async (filename) => {
       const fullFilePath = join(packageOutRoot, filename);
       let fileContent = await fsp.readFile(fullFilePath, "utf8");
@@ -121,7 +128,7 @@ async function generateDenoWorkspace(params) {
       }
     });
     const hookContext = {
-      outDir: "",
+      outDir: packageOutRoot,
       packageDir: packageOutRoot,
       packageName: pkg.json.name,
       packageJson: pkg.json,
@@ -144,6 +151,8 @@ async function generateDenoWorkspace(params) {
       packageJson.version = fixedVersion;
       packageJsonOrig.version = fixedVersion;
     }
+    hookContext.packageJson = packageJson;
+    await packageConfig?.finalizePackageJson?.(hookContext);
     const denoJson = packageJsonToDeno({
       packageJson,
       packageJsonOrig,
@@ -152,6 +161,7 @@ async function generateDenoWorkspace(params) {
       baseDir: relative(packageRoot, srcDir),
       exclude: excludeFiles
     });
+    packageConfig?.jsr?.finalizeDenoJson?.(hookContext, denoJson);
     await fsp.writeFile(join(packageOutRoot, "deno.json"), JSON.stringify(denoJson, null, 4));
     for (const file of mergeArrays(rootConfig?.copyRootFiles, packageConfig?.jsr?.copyRootFiles, ["LICENSE"])) {
       await tryCopy(join(workspaceRoot, file), join(packageOutRoot, file), { recursive: true });
@@ -159,8 +169,17 @@ async function generateDenoWorkspace(params) {
     for (const file of mergeArrays(rootConfig?.copyPackageFiles, packageConfig?.jsr?.copyPackageFiles, ["README.md"])) {
       await tryCopy(join(packageRoot, file), join(packageOutRoot, file), { recursive: true });
     }
+    await packageConfig?.jsr?.finalize?.(hookContext);
   }
   await fsp.writeFile(join(outDir, "deno.json"), JSON.stringify(rootDenoJson, null, 4));
+  await rootConfig?.finalize?.({
+    outDir,
+    packageDir: outDir,
+    packageName: "<jsr-root>",
+    packageJson: {},
+    jsr: true,
+    typedoc: false
+  });
   if (rootConfig?.dryRun !== false || withDryRun) {
     await exec(["deno", "publish", "--dry-run", "-q", "--allow-dirty"], {
       cwd: outDir,

package/jsr/index.d.ts

@@ -1,4 +1,3 @@
-export * from './build-jsr.js';
 export * from './config.js';
 export * from './deno-json.js';
 export * from './populate.js';

package/jsr.js

@@ -1,4 +1,3 @@
-import { runJsrBuild } from "./jsr/build-jsr.js";
 import { packageJsonToDeno } from "./jsr/deno-json.js";
 import { populateFromUpstream } from "./jsr/populate.js";
 import { getModuleCacheDirectory, parseImportSpecifier, splitImportRequest } from "./jsr/utils/external-libs.js";
@@ -18,6 +17,5 @@ export {
   parseImportSpecifier,
   parseJsrJson,
   populateFromUpstream,
-  runJsrBuild,
   splitImportRequest
 };

package/package-json/collect-package-jsons.d.ts

@@ -3,6 +3,8 @@ import { PackageJson } from './types.js';
 export interface WorkspacePackage {
     /** path to the package root */
     path: string;
+    /** path to the package.json file (note that it might not be a .json file) */
+    packageJsonPath: string;
     /** whether this is the root package */
     root: boolean;
     /** package.json of the package */

package/package-json/collect-package-jsons.js

@@ -2,12 +2,12 @@ import * as path from "node:path";
 import process from "node:process";
 import { glob } from "tinyglobby";
 import { normalizeFilePath } from "../misc/path.js";
-import { parseWorkspaceRootPackageJson, parsePackageJsonFile } from "./parse.js";
+import { parseWorkspaceRootPackageJson, parsePackageJsonFromDir } from "./parse.js";
 const maxDepth = process.env.FUMAN_BUILD_MAX_DEPTH !== void 0 ? Number(process.env.FUMAN_BUILD_MAX_DEPTH) : 5;
 async function collectPackageJsons(workspaceRoot, includeRoot = false) {
   workspaceRoot = normalizeFilePath(workspaceRoot);
   const packageJsons = [];
-  const rootPackageJson = await parseWorkspaceRootPackageJson(workspaceRoot);
+  const { path: rootPackageJsonPath, json: rootPackageJson } = await parseWorkspaceRootPackageJson(workspaceRoot);
   if (!rootPackageJson.workspaces) {
     throw new Error("No workspaces found in package.json");
   }
@@ -15,7 +15,8 @@ async function collectPackageJsons(workspaceRoot, includeRoot = false) {
     packageJsons.push({
       path: workspaceRoot,
       root: true,
-      json: rootPackageJson
+      json: rootPackageJson,
+      packageJsonPath: rootPackageJsonPath
     });
   }
   for (const dir of await glob({
@@ -26,14 +27,15 @@ async function collectPackageJsons(workspaceRoot, includeRoot = false) {
     deep: maxDepth
   })) {
     try {
-      const packageJson = await parsePackageJsonFile(path.join(workspaceRoot, dir, "package.json"));
+      const { json, path: packageJsonPath } = await parsePackageJsonFromDir(path.join(workspaceRoot, dir));
       packageJsons.push({
         path: path.join(workspaceRoot, dir),
         root: false,
-        json: packageJson
+        packageJsonPath,
+        json
       });
     } catch (err) {
-      if (err.code === "ENOENT") ;
+      if (err.code === "ENOENT" || err.cause?.notFound === true) ;
       else {
         throw err;
       }

package/package-json/parse.d.ts

@@ -1,7 +1,14 @@
 import { PackageJson } from './types.js';
 /** parse a package.json from string */
-export declare function parsePackageJson(packageJson: string): PackageJson;
+export declare function parsePackageJson(packageJson: string, format?: 'json' | 'yaml'): PackageJson;
 /** parse a package.json file */
 export declare function parsePackageJsonFile(packageJsonPath: string | URL): Promise<PackageJson>;
+export declare function parsePackageJsonFromDir(dir: string | URL): Promise<{
+    path: string;
+    json: PackageJson;
+}>;
 /** parse the package.json file at the root of the workspace */
-export declare function parseWorkspaceRootPackageJson(workspaceRoot: string | URL): Promise<PackageJson>;
+export declare function parseWorkspaceRootPackageJson(workspaceRoot: string | URL): Promise<{
+    path: string;
+    json: PackageJson;
+}>;

package/package-json/parse.js

@@ -1,18 +1,58 @@
 import * as fsp from "node:fs/promises";
-import path__default from "node:path";
+import path__default, { extname } from "node:path";
 import * as jsyaml from "js-yaml";
+import * as json5_ from "json5";
+import { fileExists } from "../misc/fs.js";
 import { normalizeFilePath } from "../misc/path.js";
 import { PackageJsonSchema } from "./types.js";
-function parsePackageJson(packageJson) {
-  return PackageJsonSchema.parse(JSON.parse(packageJson));
+let json5 = json5_;
+if ("default" in json5_) {
+  json5 = json5_.default;
+}
+function parsePackageJson(packageJson, format = "json") {
+  let obj;
+  if (format === "json") {
+    obj = json5.parse(packageJson);
+  } else {
+    obj = jsyaml.load(packageJson);
+  }
+  return PackageJsonSchema.parse(obj);
 }
 async function parsePackageJsonFile(packageJsonPath) {
-  return parsePackageJson(await fsp.readFile(normalizeFilePath(packageJsonPath), "utf8"));
+  const path2 = normalizeFilePath(packageJsonPath);
+  const ext = extname(path2).slice(1);
+  let format;
+  if (ext === "json5" || ext === "jsonc" || ext === "json") format = "json";
+  else if (ext === "yml" || ext === "yaml") format = "yaml";
+  else throw new Error(`Unknown package.json extension: ${ext}`);
+  try {
+    return parsePackageJson(await fsp.readFile(normalizeFilePath(packageJsonPath), "utf8"), format);
+  } catch (err) {
+    throw new Error(`Could not parse package.json at ${packageJsonPath}`, { cause: err });
+  }
+}
+const EXT_OPTIONS = ["json", "json5", "jsonc", "yml", "yaml"];
+async function parsePackageJsonFromDir(dir) {
+  dir = normalizeFilePath(dir);
+  let packageJsonPath;
+  for (const ext of EXT_OPTIONS) {
+    const tmp = path__default.join(dir, `package.${ext}`);
+    if (await fileExists(tmp)) {
+      packageJsonPath = tmp;
+      break;
+    }
+  }
+  if (packageJsonPath == null) {
+    throw new Error(`Could not find package.json at ${dir}`, { cause: { notFound: true } });
+  }
+  return {
+    path: packageJsonPath,
+    json: await parsePackageJsonFile(packageJsonPath)
+  };
 }
 async function parseWorkspaceRootPackageJson(workspaceRoot) {
   workspaceRoot = normalizeFilePath(workspaceRoot);
-  const packageJsonPath = path__default.join(workspaceRoot, "package.json");
-  const parsed = await parsePackageJsonFile(packageJsonPath);
+  const { path: pjPath, json: parsed } = await parsePackageJsonFromDir(workspaceRoot);
   if (!parsed.workspaces) {
     const pnpmWorkspacePath = path__default.join(workspaceRoot, "pnpm-workspace.yaml");
     let yaml;
@@ -20,7 +60,7 @@ async function parseWorkspaceRootPackageJson(workspaceRoot) {
       yaml = await fsp.readFile(pnpmWorkspacePath, "utf8");
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
-      return parsed;
+      return { path: pjPath, json: parsed };
     }
     const workspace = jsyaml.load(yaml);
     if (!workspace.packages) {
@@ -40,10 +80,11 @@ async function parseWorkspaceRootPackageJson(workspaceRoot) {
     }
     parsed.workspaces = workspace.packages;
   }
-  return parsed;
+  return { path: pjPath, json: parsed };
 }
 export {
   parsePackageJson,
   parsePackageJsonFile,
+  parsePackageJsonFromDir,
   parseWorkspaceRootPackageJson
 };

package/package-json/types.js

@@ -34,7 +34,7 @@ const PackageJsonSchema = z.object({
   engines: z.record(z.string()),
   pnpm: z.object({
     overrides: z.record(z.string())
-  }),
+  }).partial(),
   fuman: z.object({
     jsr: z.union([
       z.literal("skip"),

package/package.json

@@ -1,19 +1,20 @@
 {
     "name": "@fuman/build",
     "type": "module",
-    "version": "0.0.7",
+    "version": "0.0.10",
     "description": "utils for building packages and managing monorepos",
     "license": "MIT",
     "scripts": {},
     "dependencies": {
         "@drizzle-team/brocli": "^0.10.2",
-        "@fuman/fetch": "^0.0.7",
-        "@fuman/io": "^0.0.4",
-        "@fuman/node": "^0.0.4",
-        "@fuman/utils": "^0.0.4",
+        "@fuman/fetch": "^0.0.10",
+        "@fuman/io": "^0.0.10",
+        "@fuman/node": "^0.0.10",
+        "@fuman/utils": "^0.0.10",
         "cross-spawn": "^7.0.5",
         "detect-indent": "^7.0.1",
         "js-yaml": "^4.1.0",
+        "json5": "^2.2.3",
         "picomatch": "^4.0.2",
         "semver": "^7.6.3",
         "tinyglobby": "^0.2.6",

package/versioning/bump-version.js

@@ -75,7 +75,6 @@ async function bumpVersion(params) {
   const workspaceVersions = collectVersions(workspace);
   const result = [];
   for (const pkg of changedPackages) {
-    if (pkg.json.fuman?.ownVersioning) continue;
     result.push({
       package: pkg,
       prevVersion: asNonNull(pkg.json.version)
@@ -117,6 +116,7 @@ async function bumpVersion(params) {
     packagesToBump.push(findRootPackage(workspace));
   }
   for (const pkg of packagesToBump) {
+    if (pkg.json.fuman?.ownVersioning) continue;
     if (!dryRun) {
       const pkgJsonPath = join(pkg.path, "package.json");
       const pkgJsonText = await fsp.readFile(pkgJsonPath, "utf8");

package/versioning/types.d.ts

@@ -1,5 +1,6 @@
 import { MaybePromise } from '@fuman/utils';
 import { CommitInfo, ConventionalCommit } from '../git/utils.js';
+import { WorkspacePackage } from '../package-json/collect-package-jsons.js';
 import { ProjectChangedFile } from './collect-files.js';
 export interface ChangelogGeneratorParams {
     onCommitParseFailed?: (commit: CommitInfo) => void;
@@ -30,4 +31,11 @@ export interface VersioningOptions {
      */
     shouldInclude?: (file: ProjectChangedFile) => MaybePromise<boolean>;
     changelog?: ChangelogGeneratorParams;
+    /**
+     * hook that is called after the versions were bumped and pushed to registries,
+     * but before the release commit is created and pushed to git.
+     *
+     * can be used to add something to the release commit
+     */
+    beforeReleaseCommit?: (workspace: WorkspacePackage[]) => MaybePromise<void>;
 }

package/jsr/build-jsr.d.ts

@@ -1,7 +0,0 @@
-import { WorkspacePackage } from '../package-json/collect-package-jsons.js';
-import { JsrConfig } from './config.js';
-export declare function runJsrBuild(params: {
-    packageName: string;
-    workspacePackages: WorkspacePackage[];
-    rootConfig?: JsrConfig;
-}): Promise<void>;

package/jsr/build-jsr.js

@@ -1,146 +0,0 @@
-import * as fsp from "node:fs/promises";
-import { join, relative } from "node:path";
-import { asyncPool, asNonNull } from "@fuman/utils";
-import { glob } from "tinyglobby";
-import ts from "typescript";
-import { loadBuildConfig } from "../misc/_config.js";
-import { exec } from "../misc/exec.js";
-import { tryCopy } from "../misc/fs.js";
-import { normalizeFilePath } from "../misc/path.js";
-import { processPackageJson } from "../package-json/process-package-json.js";
-import { findPackageByName, findRootPackage, collectVersions } from "../package-json/utils.js";
-import { packageJsonToDeno } from "./deno-json.js";
-function mergeArrays(a, b, defaultValue = []) {
-  if (!a) return b ?? defaultValue;
-  if (!b) return a;
-  return [...a, ...b];
-}
-async function runJsrBuild(params) {
-  const {
-    packageName,
-    workspacePackages,
-    rootConfig
-  } = params;
-  const ourPackage = findPackageByName(workspacePackages, packageName);
-  const rootPackage = findRootPackage(workspacePackages);
-  const packageRoot = ourPackage.path;
-  const workspaceRoot = rootPackage.path;
-  const outDir = join(packageRoot, normalizeFilePath(rootConfig?.outputDir ?? "dist"));
-  const packageConfig = await loadBuildConfig(packageRoot);
-  const srcDir = join(packageRoot, normalizeFilePath(packageConfig?.jsr?.sourceDir ?? rootConfig?.sourceDir ?? ""));
-  const excludeFiles = mergeArrays(rootConfig?.exclude, packageConfig?.jsr?.exclude);
-  await fsp.rm(outDir, { recursive: true, force: true });
-  await fsp.mkdir(outDir, { recursive: true });
-  await asyncPool(await fsp.readdir(srcDir), async (file) => {
-    const src = join(srcDir, file);
-    if (src === outDir) return;
-    await fsp.cp(src, join(outDir, file), { recursive: true });
-  });
-  const printer = ts.createPrinter();
-  const tsFiles = await glob("**/*.ts", {
-    cwd: outDir,
-    ignore: excludeFiles
-  });
-  const badImports = [];
-  await asyncPool(tsFiles, async (filename) => {
-    const fullFilePath = join(outDir, filename);
-    let fileContent = await fsp.readFile(fullFilePath, "utf8");
-    let changed = false;
-    const file = ts.createSourceFile(filename, fileContent, ts.ScriptTarget.ESNext, true);
-    let changedTs = false;
-    for (const imp of file.statements) {
-      if (!ts.isImportDeclaration(imp) && !ts.isExportDeclaration(imp)) {
-        continue;
-      }
-      if (!imp.moduleSpecifier || !ts.isStringLiteral(imp.moduleSpecifier)) {
-        continue;
-      }
-      const mod = imp.moduleSpecifier.text;
-      if (mod[0] !== ".") {
-        continue;
-      }
-      if (mod.endsWith(".js")) {
-        changedTs = true;
-        imp.moduleSpecifier = ts.factory.createStringLiteral(
-          mod.replace(/\.js$/, ".ts")
-        );
-      } else {
-        badImports.push(`  from ${mod} at ${join(srcDir, filename)}`);
-      }
-    }
-    if (rootConfig?.transformAst?.(file)) {
-      changedTs = true;
-    }
-    if (packageConfig?.jsr?.transformAst?.(file)) {
-      changedTs = true;
-    }
-    if (changedTs) {
-      fileContent = printer.printFile(file);
-      changed = true;
-    }
-    if (rootConfig?.transformCode || packageConfig?.jsr?.transformCode) {
-      const origFileContent = fileContent;
-      if (rootConfig?.transformCode) {
-        fileContent = rootConfig.transformCode(filename, fileContent);
-      }
-      if (packageConfig?.jsr?.transformCode) {
-        fileContent = packageConfig.jsr.transformCode(filename, fileContent);
-      }
-      if (fileContent !== origFileContent) {
-        changed = true;
-      }
-    }
-    if (changed) {
-      await fsp.writeFile(fullFilePath, fileContent);
-    }
-  });
-  if (badImports.length > 0) {
-    throw new Error(`Found ${badImports.length} invalid imports (you must specify .js extension):
-${badImports.join("\n")}`);
-  }
-  const hookContext = {
-    outDir: "",
-    packageDir: ourPackage.path,
-    packageName: asNonNull(ourPackage.json.name),
-    packageJson: ourPackage.json,
-    jsr: true,
-    typedoc: false
-  };
-  packageConfig?.preparePackageJson?.(hookContext);
-  const workspaceVersions = collectVersions(workspacePackages);
-  const { packageJson, packageJsonOrig } = processPackageJson({
-    packageJson: ourPackage.json,
-    rootPackageJson: rootPackage.json,
-    workspaceVersions,
-    // since there's no bundling, we can't drop any deps.
-    // we *could* copy them from node_modules and add to the import map,
-    // but maybe sometime later
-    bundledWorkspaceDeps: [],
-    rootFieldsToCopy: ["license"]
-  });
-  const denoJson = packageJsonToDeno({
-    packageJson,
-    packageJsonOrig,
-    workspaceVersions,
-    buildDirName: relative(packageRoot, outDir),
-    baseDir: relative(packageRoot, srcDir),
-    exclude: excludeFiles
-  });
-  await fsp.writeFile(join(outDir, "deno.json"), JSON.stringify(denoJson, null, 4));
-  for (const file of mergeArrays(rootConfig?.copyRootFiles, packageConfig?.jsr?.copyRootFiles, ["LICENSE"])) {
-    await tryCopy(join(workspaceRoot, file), join(outDir, file), { recursive: true });
-  }
-  for (const file of mergeArrays(rootConfig?.copyPackageFiles, packageConfig?.jsr?.copyPackageFiles, ["README.md"])) {
-    await tryCopy(join(packageRoot, file), join(outDir, file), { recursive: true });
-  }
-  if (!packageConfig?.jsr?.dryRun && !rootConfig?.dryRun) {
-    await exec(["deno", "publish", "--dry-run", "-q", "--allow-dirty"], {
-      cwd: outDir,
-      stdio: "inherit",
-      throwOnError: true
-    });
-  }
-}
-export {
-  runJsrBuild
-};