@fuman/build 0.0.15 → 0.0.17

package/cli/commands/bump-version.d.ts

@@ -3,13 +3,13 @@ import { bc } from './_utils.js';
 export declare function formatBumpVersionResult(result: BumpVersionResult, withReleaseType: boolean): string;
 export declare const bumpVersionCli: bc.Command<{
     root: string | undefined;
-    type: "major" | "minor" | "patch" | "auto";
+    type: "auto" | "major" | "minor" | "patch";
     since: string | undefined;
     dryRun: boolean | undefined;
     quiet: boolean | undefined;
 }, {
     root: string | undefined;
-    type: "major" | "minor" | "patch" | "auto";
+    type: "auto" | "major" | "minor" | "patch";
     since: string | undefined;
     dryRun: boolean | undefined;
     quiet: boolean | undefined;

package/cli/commands/gen-changelog.js

@@ -29,7 +29,6 @@ const generateChangelogCli = bc.command({
       throw new Error("no previous tag found, cannot determine changeset");
     }
     const changelog = await generateChangelog({
-      workspace: workspacePackages,
       cwd: root,
       since,
       params: config?.versioning

package/cli/commands/lint/index.js

@@ -4,7 +4,6 @@ import { validateWorkspaceDeps } from "./validate-workspace-deps.js";
 import * as bc from "@drizzle-team/brocli";
 const INTERNAL_MESSAGES = {
   not_workspace_proto: "internal dependencies must be linked with workspace: protocol",
-  standalone_dep: "non-standalone packages cannot depend on standalone packages with workspace: protocol",
   not_workspace_dep: "workspace: protocol is used to link to a package not found in the workspace"
 };
 const lintCli = bc.command({

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

@@ -25,10 +25,9 @@ export interface InternalDepsError {
     /**
      * sub-type of the error
      * - not_workspace_proto: internal dependencies must be linked with workspace: protocol
-     * - standalone_dep: non-standalone packages cannot depend on standalone packages
      * - not_workspace_dep: `workspace:` protocol is used to link to a package not found in the workspace
      */
-    subtype: 'not_workspace_proto' | 'standalone_dep' | 'not_workspace_dep';
+    subtype: 'not_workspace_proto' | 'not_workspace_dep';
 }
 export type WorkspaceDepsError = ExternalDepsError | InternalDepsError;
 /**

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

@@ -37,14 +37,6 @@ async function validateWorkspaceDeps(params) {
             });
             continue;
           }
-          if (!pj.fuman?.standalone && otherPkgStandalone && version.startsWith("workspace:")) {
-            errors.push({
-              type: "internal",
-              package: pj.name,
-              dependency: name,
-              subtype: "standalone_dep"
-            });
-          }
           continue;
         }
         if (version.startsWith("workspace:")) {

package/cli/commands/release.d.ts

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

package/cli/commands/release.js

@@ -114,7 +114,6 @@ const releaseCli = bc.command({
     console.log("🚀 next tag:", tagName);
     console.log("📝 generating changelog...");
     const changelog = prevTag != null ? await generateChangelog({
-      workspace: changedPackages,
       cwd: root,
       since: prevTag,
       params: config?.versioning

package/git/github.js

@@ -1,13 +1,9 @@
-import { ffetchBase, ffetchAddons } from "@fuman/fetch";
-import { ffetchZodAdapter } from "@fuman/fetch/zod";
+import { ffetchBase } from "@fuman/fetch";
 import { asyncPool } from "@fuman/utils";
 import { z } from "zod";
 async function createGithubRelease(params) {
   const ffetch = ffetchBase.extend({
     baseUrl: params.apiUrl ?? "https://api.github.com",
-    addons: [
-      ffetchAddons.parser(ffetchZodAdapter())
-    ],
     headers: {
       "Accept": "application/vnd.github+json",
       "User-Agent": "@fuman/build",

package/jsr/deno-json.js

@@ -8,7 +8,7 @@ function packageJsonToDeno({
   baseDir
 }) {
   const importMap = {};
-  const exports = {};
+  const exports$1 = {};
   for (const field of ["dependencies", "peerDependencies", "optionalDependencies"]) {
     const deps = packageJson[field];
     if (deps == null) continue;
@@ -55,16 +55,16 @@ function packageJsonToDeno({
         if (!value.startsWith(`./${baseDir}`)) {
           throw new Error(`Invalid export value: ${value} (must be inside ./${baseDir})`);
         }
-        exports[name] = `./${value.slice(baseDir.length + 3)}`;
+        exports$1[name] = `./${value.slice(baseDir.length + 3)}`;
       } else {
-        exports[name] = value;
+        exports$1[name] = value;
       }
     }
   }
   return {
     name: asNonNull(packageJson.name),
     version: asNonNull(packageJson.version),
-    exports,
+    exports: exports$1,
     exclude,
     imports: importMap,
     publish: {

package/jsr/utils/jsr.js

@@ -2,8 +2,7 @@ import * as fs from "node:fs";
 import * as fsp from "node:fs/promises";
 import { join } from "node:path";
 import process from "node:process";
-import { ffetchBase, ffetchAddons } from "@fuman/fetch";
-import { ffetchZodAdapter } from "@fuman/fetch/zod";
+import { ffetchBase } from "@fuman/fetch";
 import { write, webReadableToFuman } from "@fuman/io";
 import { nodeWritableToFuman } from "@fuman/node";
 import { asyncPool } from "@fuman/utils";
@@ -30,10 +29,7 @@ async function downloadJsrPackage(specifier, params) {
   }
   const registry = params?.registry ?? DEFAULT_REGISTRY;
   const ffetch = ffetchBase.extend({
-    baseUrl: registry,
-    addons: [
-      ffetchAddons.parser(ffetchZodAdapter())
-    ]
+    baseUrl: registry
   });
   const targetDir = `${specifier.packageName.replace(/\//g, "+")}@${specifier.version}`;
   const registryHost = new URL(registry).host;
@@ -46,7 +42,7 @@ async function downloadJsrPackage(specifier, params) {
     }
   }
   const meta = await ffetch(`${specifier.packageName}/meta.json`).parsedJson(z.object({
-    versions: z.record(z.unknown())
+    versions: z.record(z.string(), z.unknown())
   }));
   const availableVersions = Object.keys(meta.versions);
   const version = semver.maxSatisfying(availableVersions, specifier.version);
@@ -55,7 +51,7 @@ async function downloadJsrPackage(specifier, params) {
   }
   await fsp.mkdir(cacheDir, { recursive: true });
   const versionMeta = await ffetch(`${specifier.packageName}/${version}_meta.json`).parsedJson(z.object({
-    manifest: z.record(z.unknown())
+    manifest: z.record(z.string(), z.unknown())
   }));
   const fetchFile = async (file) => {
     file = file.replace(/^\//, "");

package/misc/_config.js

@@ -1,8 +1,10 @@
 import { join } from "node:path";
+import { pathToFileURL } from "node:url";
 const CONFIG_NAME = "build.config.js";
 async function loadBuildConfig(packageRoot) {
   try {
-    const mod = (await import(join(packageRoot, CONFIG_NAME))).default;
+    const filePath = pathToFileURL(join(packageRoot, CONFIG_NAME)).href;
+    const mod = (await import(filePath)).default;
     if (typeof mod === "function") {
       return mod();
     } else {

package/package-json/process-package-json.js

@@ -87,15 +87,15 @@ function processPackageJson(params) {
     delete packageJson.fuman;
   }
   if (packageJson.exports != null) {
-    let exports = packageJson.exports;
-    if (typeof exports === "string") {
-      exports = { ".": exports };
+    let exports$1 = packageJson.exports;
+    if (typeof exports$1 === "string") {
+      exports$1 = { ".": exports$1 };
     }
-    if (typeof exports !== "object") {
+    if (typeof exports$1 !== "object") {
       throw new TypeError("package.json exports must be an object");
     }
     const newExports = {};
-    for (const [key, value] of Object.entries(exports)) {
+    for (const [key, value] of Object.entries(exports$1)) {
       if (typeof value !== "string") {
         throw new TypeError(`package.json exports value must be a string: ${key}`);
       }
@@ -138,14 +138,14 @@ function processPackageJson(params) {
     entrypoints
   };
 }
-function removeCommonjsExports(exports) {
-  const keys = Object.keys(exports);
+function removeCommonjsExports(exports$1) {
+  const keys = Object.keys(exports$1);
   if (keys.includes("import")) {
-    delete exports.require;
+    delete exports$1.require;
     return;
   }
   for (const key of keys) {
-    const value = exports[key];
+    const value = exports$1[key];
     if (value == null || typeof value !== "object") continue;
     delete value.require;
   }

package/package-json/types.d.ts

@@ -57,10 +57,9 @@ export interface PackageJson {
          * standalone packages have a few differences from normal ones:
          *   - (bump-version) each standalone package has independent versioning
          *   - (lint) normal packages can't depend on standalone packages
-         *   - (lint) unlike normal packages, standalone packages are allowed to depend on older versions of workspace packages
          */
         standalone?: boolean;
     };
     [key: string]: any;
 }
-export declare const PackageJsonSchema: z.AnyZodObject;
+export declare const PackageJsonSchema: z.ZodObject;

package/package-json/types.js

@@ -25,15 +25,15 @@ const PackageJsonSchema = z.object({
   }),
   keywords: z.array(z.string()),
   workspaces: z.array(z.string()),
-  scripts: z.record(z.string()),
-  dependencies: z.record(z.string()),
-  devDependencies: z.record(z.string()),
-  peerDependencies: z.record(z.string()),
-  optionalDependencies: z.record(z.string()),
+  scripts: z.record(z.string(), z.string()),
+  dependencies: z.record(z.string(), z.string()),
+  devDependencies: z.record(z.string(), z.string()),
+  peerDependencies: z.record(z.string(), z.string()),
+  optionalDependencies: z.record(z.string(), z.string()),
   bundledDependencies: z.array(z.string()),
-  engines: z.record(z.string()),
+  engines: z.record(z.string(), z.string()),
   pnpm: z.object({
-    overrides: z.record(z.string())
+    overrides: z.record(z.string(), z.string())
   }).partial(),
   fuman: z.object({
     jsr: z.union([
@@ -45,7 +45,7 @@ const PackageJsonSchema = z.object({
       z.literal("only")
     ]),
     keepScripts: z.array(z.string()),
-    distOnlyFields: z.record(z.unknown()),
+    distOnlyFields: z.record(z.string(), z.unknown()),
     ownVersioning: z.boolean(),
     standalone: z.boolean(),
     private: z.boolean()

package/package.json

@@ -1,16 +1,16 @@
 {
     "name": "@fuman/build",
     "type": "module",
-    "version": "0.0.15",
+    "version": "0.0.17",
     "description": "utils for building packages and managing monorepos",
     "license": "MIT",
     "scripts": {},
     "dependencies": {
-        "@drizzle-team/brocli": "^0.10.2",
-        "@fuman/fetch": "0.0.13",
-        "@fuman/io": "^0.0.15",
-        "@fuman/node": "^0.0.15",
-        "@fuman/utils": "^0.0.15",
+        "@drizzle-team/brocli": "^0.11.0",
+        "@fuman/fetch": "^0.3.0",
+        "@fuman/io": "^0.0.17",
+        "@fuman/node": "^0.0.17",
+        "@fuman/utils": "^0.0.17",
         "cross-spawn": "^7.0.5",
         "detect-indent": "^7.0.1",
         "js-yaml": "^4.1.0",
@@ -18,12 +18,12 @@
         "picomatch": "^4.0.2",
         "semver": "^7.6.3",
         "tinyglobby": "^0.2.6",
-        "zod": "^3.0.0"
+        "zod": "^4.0.0"
     },
     "peerDependencies": {
         "typedoc": ">=0.24.0",
         "typescript": "^5.2.2",
-        "vite": "^5.4.0 || ^6.0.0"
+        "vite": "^5.4.0 || ^6.0.0 || ^7.0.0"
     },
     "exports": {
         ".": {

package/versioning/bump-version.js

@@ -3,10 +3,38 @@ import { join } from "node:path";
 import process from "node:process";
 import { asNonNull } from "@fuman/utils";
 import detectIndent from "detect-indent";
-import { parse, inc, satisfies, gt } from "semver";
+import { inc, satisfies, parse, gt } from "semver";
 import { getCommitsBetween, parseConventionalCommit, getLatestTag } from "../git/utils.js";
 import { collectVersions, findRootPackage } from "../package-json/utils.js";
 import { findProjectChangedPackages } from "./collect-files.js";
+function determineBumpType(params) {
+  const { oldVersion, commits } = params;
+  let hasBreakingChanges = false;
+  let hasFeatures = false;
+  for (const commit of commits) {
+    const parsed = parseConventionalCommit(commit.message);
+    if (!parsed) continue;
+    if (parsed.breaking) hasBreakingChanges = true;
+    if (parsed.type === "feat") hasFeatures = true;
+  }
+  const parsedVersion = parse(oldVersion);
+  if (!parsedVersion) {
+    throw new Error(`Invalid version: ${oldVersion}`);
+  }
+  if (hasBreakingChanges) {
+    if (parsedVersion.major === 0 && parsedVersion.minor === 0) {
+      return "patch";
+    } else if (parsedVersion.major === 0) {
+      return "minor";
+    } else {
+      return "major";
+    }
+  } else if (hasFeatures) {
+    return parsedVersion.major === 0 ? "patch" : "minor";
+  } else {
+    return "patch";
+  }
+}
 async function bumpVersion(params) {
   const {
     workspace,
@@ -41,32 +69,16 @@ async function bumpVersion(params) {
   let hasFeatures = false;
   let hasBreakingChanges = false;
   if (type == null) {
-    for (const commit of await getCommitsBetween({
+    const commits = await getCommitsBetween({
       since,
       cwd
-    })) {
-      const parsed = parseConventionalCommit(commit.message);
-      if (!parsed) continue;
-      if (parsed.breaking) hasBreakingChanges = true;
-      if (parsed.type === "feat") hasFeatures = true;
-    }
-    const parsedVersion = parse(maxVersion);
-    if (!parsedVersion) {
-      throw new Error(`Invalid version: ${maxVersion}`);
-    }
-    if (hasBreakingChanges) {
-      if (parsedVersion.major === 0 && parsedVersion.minor === 0) {
-        type = "patch";
-      } else if (parsedVersion.major === 0) {
-        type = "minor";
-      } else {
-        type = "major";
-      }
-    } else if (hasFeatures) {
-      type = parsedVersion.major === 0 ? "patch" : "minor";
-    } else {
-      type = "patch";
-    }
+    });
+    type = determineBumpType({
+      oldVersion: maxVersion,
+      commits
+    });
+    hasFeatures = commits.some((commit) => parseConventionalCommit(commit.message)?.type === "feat");
+    hasBreakingChanges = commits.some((commit) => parseConventionalCommit(commit.message)?.breaking);
   }
   const nextVersion = inc(maxVersion, type);
   if (nextVersion == null) {
@@ -80,6 +92,7 @@ async function bumpVersion(params) {
       prevVersion: asNonNull(pkg.json.version)
     });
   }
+  const bumpWithDependants = params.params?.bumpWithDependants;
   for (const pkg of changedPackages) {
     if (pkg.json.fuman?.ownVersioning) continue;
     const pkgName = asNonNull(pkg.json.name);
@@ -94,7 +107,15 @@ async function bumpVersion(params) {
         }
         if (expandedVersion === "workspace:^") expandedVersion = `^${workspaceVersions[pkgName]}`;
         if (expandedVersion === "workspace:*") expandedVersion = workspaceVersions[pkgName];
-        if (!satisfies(nextVersion, expandedVersion)) {
+        let shouldBump;
+        if (bumpWithDependants === true) {
+          shouldBump = true;
+        } else if (bumpWithDependants === "only-minor") {
+          shouldBump = !satisfies(nextVersion, expandedVersion) && type === "minor";
+        } else {
+          shouldBump = !satisfies(nextVersion, expandedVersion);
+        }
+        if (shouldBump) {
           if (otherPkg.json.fuman?.ownVersioning) {
             throw new Error(`package ${otherPkg.json.name}@${otherPkg.json.version} is marked as "own versioning", and will not be compatible with ${pkgName}@${expandedVersion} after bumping. please bump it manually`);
           }
@@ -132,10 +153,11 @@ async function bumpVersion(params) {
         const commits = await getCommitsBetween({
           until: prevTag,
           cwd,
-          files: [join(pkg.path, "package.json")]
+          files: [join(pkg.path, "**")]
         });
         if (commits.length > 0) {
-          newVersion = asNonNull(inc(newVersion, type));
+          const bumpType = determineBumpType({ oldVersion: newVersion, commits });
+          newVersion = asNonNull(inc(newVersion, bumpType));
         }
       }
     }

package/versioning/types.d.ts

@@ -39,6 +39,24 @@ export interface VersioningOptions {
      * @default `['**\/*.test.ts', '**\/*.md']`
      */
     exclude?: string[] | null;
+    /**
+     * whether to also bump dependant packages when bumping a package,
+     * even if this is a semver-compatible bump.
+     *
+     * example:
+     * - A depends on package B, and B depends on package C
+     * - A gets patch bump (e.g. `v1.2.3` -> `v1.2.4`)
+     * - when `false` or `'only-minor'`, B and C єlwill not be bumped
+     * - when `true`, B and C will be bumped to the same version as A (i.e. `v1.2.4`)
+     *
+     * `only-minor` will make fuman ignore patch bumps and only bump dependants
+     * when minor version is bumped.
+     *
+     * note that dependants are always bumped on a major bump.
+     *
+     * @default false
+     */
+    bumpWithDependants?: boolean | 'only-minor';
     /**
      * custom predicate for inclusion of files
      * (will be called in addition to the globs,

package/vite/build-plugin.js

@@ -1,7 +1,7 @@
 import * as fsp from "node:fs/promises";
 import { join, relative } from "node:path";
 import process from "node:process";
-import { asNonNull, deepMerge, assertStartsWith, parallelMap } from "@fuman/utils";
+import { asNonNull, assertStartsWith, deepMerge, parallelMap } from "@fuman/utils";
 import { glob } from "tinyglobby";
 import { loadBuildConfig } from "../misc/_config.js";
 import { tryCopy, fileExists, directoryExists } from "../misc/fs.js";