@fuman/build 0.0.1

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

@@ -0,0 +1,132 @@
+const DEFAULT_FIELDS_TO_COPY_ROOT = ["license", "author", "contributors", "homepage", "repository", "bugs"];
+function processPackageJson(params) {
+  const {
+    packageJson: packageJsonOrig,
+    workspaceVersions,
+    rootPackageJson,
+    rootFieldsToCopy = DEFAULT_FIELDS_TO_COPY_ROOT,
+    bundledWorkspaceDeps,
+    fixedVersion
+  } = params;
+  const packageJson = structuredClone(packageJsonOrig);
+  const entrypoints = {};
+  for (const field of rootFieldsToCopy) {
+    if (rootPackageJson?.[field] != null && packageJson[field] == null) {
+      packageJson[field] = rootPackageJson[field];
+    }
+  }
+  const newScripts = {};
+  if (packageJson.scripts && Array.isArray(packageJson.fuman?.keepScripts)) {
+    for (const script of packageJson.fuman.keepScripts) {
+      if (typeof script !== "string") continue;
+      if (script in packageJson.scripts) continue;
+      newScripts[script] = packageJson.scripts[script];
+    }
+    delete packageJson.keepScripts;
+  }
+  packageJson.scripts = newScripts;
+  delete packageJson.devDependencies;
+  delete packageJson.private;
+  if (packageJson.fuman?.distOnlyFields) {
+    Object.assign(packageJson, packageJson.fuman.distOnlyFields);
+    delete packageJson.distOnlyFields;
+  }
+  function replaceWorkspaceDependencies(field) {
+    if (packageJson[field] == null) return;
+    const dependencies = packageJson[field];
+    for (const name of Object.keys(dependencies)) {
+      const value = dependencies[name];
+      if (value.startsWith("workspace:")) {
+        if (bundledWorkspaceDeps) {
+          let found = false;
+          for (const dep of bundledWorkspaceDeps) {
+            if (dep.test(name)) {
+              delete dependencies[name];
+              found = true;
+              break;
+            }
+          }
+          if (found) continue;
+        }
+        if (value !== "workspace:^" && value !== "workspace:*") {
+          throw new Error(
+            `Cannot replace workspace dependency ${name} with ${value} - only workspace:^ and * are supported`
+          );
+        }
+        if (workspaceVersions?.[name] == null) {
+          throw new Error(`Cannot replace workspace: dependency ${name} not found in workspace`);
+        }
+        if (fixedVersion != null) {
+          dependencies[name] = fixedVersion;
+          continue;
+        }
+        const workspaceVersion = workspaceVersions?.[name];
+        const depVersion = value === "workspace:*" ? workspaceVersion : `^${workspaceVersion}`;
+        dependencies[name] = depVersion;
+      }
+    }
+  }
+  replaceWorkspaceDependencies("dependencies");
+  replaceWorkspaceDependencies("devDependencies");
+  replaceWorkspaceDependencies("peerDependencies");
+  replaceWorkspaceDependencies("optionalDependencies");
+  delete packageJson.typedoc;
+  delete packageJson.eslintConfig;
+  delete packageJson.eslintIgnore;
+  delete packageJson.prettier;
+  delete packageJson.fuman;
+  if (packageJson.exports != null) {
+    let exports = packageJson.exports;
+    if (typeof exports === "string") {
+      exports = { ".": exports };
+    }
+    if (typeof exports !== "object") {
+      throw new TypeError("package.json exports must be an object");
+    }
+    const newExports = {};
+    for (const [key, value] of Object.entries(exports)) {
+      if (typeof value !== "string") {
+        throw new TypeError(`package.json exports value must be a string: ${key}`);
+      }
+      if (value.endsWith(".wasm")) {
+        newExports[key] = value;
+        continue;
+      }
+      let entrypointName = key.replace(/^\.(?:\/|$)/, "").replace(/\.js$/, "");
+      if (entrypointName === "") entrypointName = "index";
+      entrypoints[entrypointName] = value;
+      newExports[key] = {
+        import: {
+          types: `./${entrypointName}.d.ts`,
+          default: `./${entrypointName}.js`
+        },
+        require: {
+          types: `./${entrypointName}.d.cts`,
+          default: `./${entrypointName}.cjs`
+        }
+      };
+    }
+    packageJson.exports = newExports;
+  }
+  if (packageJson.bin != null) {
+    const newBin = {};
+    for (const [key, value] of Object.entries(packageJson.bin)) {
+      if (typeof value !== "string") {
+        throw new TypeError(`package.json bin value must be a string: ${key}`);
+      }
+      let entrypointName = key.replace(/^\.(?:\/|$)/, "").replace(/\.js$/, "");
+      if (entrypointName === "") entrypointName = "index";
+      entrypoints[entrypointName] = value;
+      newBin[key] = `${entrypointName}.js`;
+    }
+    packageJson.bin = newBin;
+  }
+  return {
+    packageJsonOrig,
+    packageJson,
+    entrypoints
+  };
+}
+export {
+  processPackageJson
+};

package/package-json/types.d.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+export interface PackageJson {
+    name?: string;
+    type?: 'module' | 'commonjs';
+    version?: string;
+    private?: boolean;
+    description?: string;
+    packageManager?: string;
+    license?: string;
+    homepage?: string;
+    repository?: (string | {
+        type: string;
+        url: string;
+    });
+    keywords?: string[];
+    workspaces?: string[];
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    bundledDependencies?: Record<string, string>;
+    engines?: Record<string, string>;
+    pnpm?: {
+        overrides: Record<string, string>;
+    };
+    /** fuman-specific package.json fields */
+    fuman?: {
+        /**
+         * whether the package should be published to jsr
+         * (skip – it won't be published to jsr, only – it will only be published to jsr)
+         */
+        jsr?: 'skip' | 'only';
+        /**
+         * whether the package should be published to npm
+         * (skip – it won't be published to npm, only – it will only be published to npm)
+         */
+        npm?: 'skip' | 'only';
+        /** by default @fuman/build strips all scripts, but you can keep some of them by passing their names here */
+        keepScripts?: string[];
+        /**
+         * any additional fields that will be shallowly merged into the resulting package.json.
+         * for more complex modifications than shallow merging, consider using build.config.js
+         */
+        distOnlyFields?: Record<string, unknown>;
+        /**
+         * whether this package has its own versioning scheme
+         * (be careful with this option! this might break cross-release semver compatibility)
+         */
+        ownVersioning?: boolean;
+        /** whether this package should not be published */
+        private?: boolean;
+    };
+    [key: string]: any;
+}
+export declare const PackageJsonSchema: z.AnyZodObject;

package/package-json/types.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+const PackageJsonSchema = z.object({
+  name: z.string(),
+  type: z.union([
+    z.literal("module"),
+    z.literal("commonjs")
+  ]),
+  version: z.string(),
+  private: z.boolean(),
+  description: z.string(),
+  packageManager: z.string(),
+  license: z.string(),
+  homepage: z.string(),
+  repository: z.union([
+    z.string(),
+    z.object({
+      type: z.string(),
+      url: z.string()
+    })
+  ]).transform((val) => {
+    if (typeof val === "string") {
+      return { type: "git", url: val };
+    }
+    return val;
+  }),
+  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()),
+  bundledDependencies: z.array(z.string()),
+  engines: z.record(z.string()),
+  pnpm: z.object({
+    overrides: z.record(z.string())
+  }),
+  fuman: z.object({
+    jsr: z.union([
+      z.literal("skip"),
+      z.literal("only")
+    ]),
+    npm: z.union([
+      z.literal("skip"),
+      z.literal("only")
+    ]),
+    keepScripts: z.array(z.string()),
+    distOnlyFields: z.record(z.unknown()),
+    ownVersioning: z.boolean(),
+    private: z.boolean()
+  }).partial(),
+  // todo: properly type this
+  exports: z.any()
+}).passthrough().partial();
+export {
+  PackageJsonSchema
+};

package/package-json/utils.d.ts

@@ -0,0 +1,4 @@
+import { WorkspacePackage } from './collect-package-jsons.js';
+export declare function findPackageByName(packages: WorkspacePackage[], name: string): WorkspacePackage;
+export declare function findRootPackage(packages: WorkspacePackage[]): WorkspacePackage;
+export declare function collectVersions(packages: WorkspacePackage[]): Record<string, string>;

package/package-json/utils.js

@@ -0,0 +1,27 @@
+function findPackageByName(packages, name) {
+  const pkg = packages.find((it) => it.json.name === name);
+  if (!pkg) {
+    throw new Error(`Could not find package.json for ${name}`);
+  }
+  return pkg;
+}
+function findRootPackage(packages) {
+  const pkg = packages.find((it) => it.root);
+  if (!pkg) {
+    throw new Error("Could not find package.json for workspace root");
+  }
+  return pkg;
+}
+function collectVersions(packages) {
+  const versions = {};
+  for (const pkg of packages) {
+    if (pkg.root || pkg.json.name == null || pkg.json.version == null) continue;
+    versions[pkg.json.name] = pkg.json.version;
+  }
+  return versions;
+}
+export {
+  collectVersions,
+  findPackageByName,
+  findRootPackage
+};

package/package.json

@@ -0,0 +1,67 @@
+{
+    "name": "@fuman/build",
+    "type": "module",
+    "version": "0.0.1",
+    "description": "utils for building packages and managing monorepos",
+    "license": "MIT",
+    "scripts": {},
+    "dependencies": {
+        "@drizzle-team/brocli": "^0.10.2",
+        "@fuman/fetch": "^0.0.1",
+        "@fuman/io": "^0.0.1",
+        "@fuman/node": "^0.0.1",
+        "@fuman/utils": "^0.0.1",
+        "cross-spawn": "^7.0.5",
+        "detect-indent": "^7.0.1",
+        "js-yaml": "^4.1.0",
+        "picomatch": "^4.0.2",
+        "semver": "^7.6.3",
+        "tinyglobby": "^0.2.6",
+        "zod": "^3.23.8"
+    },
+    "peerDependencies": {
+        "typescript": "^5.2.2",
+        "vite": "^5.4.0"
+    },
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./index.d.ts",
+                "default": "./index.js"
+            },
+            "require": {
+                "types": "./index.d.cts",
+                "default": "./index.cjs"
+            }
+        },
+        "./vite": {
+            "import": {
+                "types": "./vite.d.ts",
+                "default": "./vite.js"
+            },
+            "require": {
+                "types": "./vite.d.cts",
+                "default": "./vite.cjs"
+            }
+        },
+        "./jsr": {
+            "import": {
+                "types": "./jsr.d.ts",
+                "default": "./jsr.js"
+            },
+            "require": {
+                "types": "./jsr.d.cts",
+                "default": "./jsr.cjs"
+            }
+        }
+    },
+    "sideEffects": false,
+    "bin": {
+        "fuman-build": "fuman-build.js"
+    },
+    "author": "",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/teidesu/fuman.git"
+    }
+}

package/versioning/bump-version.d.ts

@@ -0,0 +1,48 @@
+import { ReleaseType } from 'semver';
+import { WorkspacePackage } from '../package-json/collect-package-jsons.js';
+import { VersioningOptions } from './types.js';
+export interface BumpVersionPackage {
+    /** info about the package */
+    package: WorkspacePackage;
+    /**
+     * if the package was not changed by itself,
+     * but the bump is required because of another package
+     * that was changed depending on it, name of that package
+     */
+    because?: string[];
+}
+export interface BumpVersionResult {
+    /** max version of all packages */
+    maxVersion: string;
+    /** next version */
+    nextVersion: string;
+    /** changed packages which will be bumped to `nextVersion` */
+    changedPackages: BumpVersionPackage[];
+    /** detected release type */
+    releaseType: ReleaseType;
+    /**
+     * whether there are breaking changes
+     * (note: will be false if release type is explicitly provided)
+     */
+    hasBreakingChanges: boolean;
+    /**
+     * whether there are new features
+     * (note: will be false if release type is explicitly provided)
+     */
+    hasFeatures: boolean;
+}
+export declare function bumpVersion(params: {
+    /** packages for which to generate the changelog */
+    workspace: WorkspacePackage[];
+    /** whether to bump version of all packages, not just changed ones */
+    all?: boolean;
+    type?: ReleaseType;
+    /** root of the git repo */
+    cwd?: string | URL;
+    /** starting point for the changelog (defaults to latest tag) */
+    since: string;
+    /** versioning params */
+    params?: VersioningOptions;
+    /** whether to not actually write the files */
+    dryRun?: boolean;
+}): Promise<BumpVersionResult>;

package/versioning/bump-version.js

@@ -0,0 +1,129 @@
+import * as fsp from "node:fs/promises";
+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 { getCommitsBetween, parseConventionalCommit } from "../git/utils.js";
+import { collectVersions } from "../package-json/utils.js";
+import { findProjectChangedPackages } from "./collect-files.js";
+async function bumpVersion(params) {
+  const {
+    workspace,
+    all,
+    cwd = process.cwd(),
+    since,
+    dryRun = false
+  } = params;
+  let maxVersion = null;
+  for (const pkg of workspace) {
+    const version = asNonNull(pkg.json.version);
+    if (pkg.json.fuman?.ownVersioning) {
+      continue;
+    }
+    if (maxVersion == null || gt(version, maxVersion)) {
+      maxVersion = version;
+    }
+  }
+  if (maxVersion == null) {
+    throw new Error("No packages found with fuman-managed versioning");
+  }
+  const changedPackages = all ? workspace : await findProjectChangedPackages({
+    root: cwd,
+    since,
+    params: params.params
+  });
+  let type = params.type;
+  let hasFeatures = false;
+  let hasBreakingChanges = false;
+  if (type == null) {
+    for (const commit of 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";
+    }
+  }
+  const nextVersion = inc(maxVersion, type);
+  if (nextVersion == null) {
+    throw new Error(`Invalid version increment: ${maxVersion} → ${type}`);
+  }
+  const workspaceVersions = collectVersions(workspace);
+  const result = [];
+  for (const pkg of changedPackages) {
+    if (pkg.json.fuman?.ownVersioning) continue;
+    result.push({ package: pkg });
+  }
+  for (const pkg of changedPackages) {
+    if (pkg.json.fuman?.ownVersioning) continue;
+    const pkgName = asNonNull(pkg.json.name);
+    for (const otherPkg of workspace) {
+      for (const kind of ["dependencies", "peerDependencies"]) {
+        const obj = otherPkg.json[kind];
+        if (obj == null) continue;
+        if (obj[pkgName] == null || typeof obj[pkgName] !== "string") continue;
+        let expandedVersion = obj[pkgName];
+        if (expandedVersion === "workspace:^") expandedVersion = `^${workspaceVersions[pkgName]}`;
+        if (expandedVersion === "workspace:*") expandedVersion = workspaceVersions[pkgName];
+        if (!satisfies(nextVersion, expandedVersion)) {
+          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`);
+          }
+          const existing = result.find((pkg2) => pkg2.package.json.name === otherPkg.json.name);
+          if (existing) {
+            if (!existing.because) break;
+            existing.because.push(pkgName);
+          } else {
+            result.push({
+              package: otherPkg,
+              because: [pkgName]
+            });
+          }
+          break;
+        }
+      }
+    }
+  }
+  if (!dryRun) {
+    for (const { package: pkg } of result) {
+      const pkgJsonPath = join(pkg.path, "package.json");
+      const pkgJsonText = await fsp.readFile(pkgJsonPath, "utf8");
+      const indent = detectIndent(pkgJsonText).indent || "    ";
+      const pkgJson = JSON.parse(pkgJsonText);
+      pkgJson.version = nextVersion;
+      await fsp.writeFile(pkgJsonPath, `${JSON.stringify(pkgJson, null, indent)}
+`);
+    }
+  }
+  return {
+    maxVersion,
+    nextVersion,
+    changedPackages: result,
+    releaseType: type,
+    hasBreakingChanges,
+    hasFeatures
+  };
+}
+export {
+  bumpVersion
+};

package/versioning/collect-files.d.ts

@@ -0,0 +1,22 @@
+import { VersioningOptions } from './types.js';
+import { WorkspacePackage } from '../package-json/index.js';
+export interface ProjectChangedFile {
+    /** package to which the file belongs */
+    package: WorkspacePackage;
+    /** path to the file relative to the package root */
+    file: string;
+    /** path to workspace root */
+    root: string;
+}
+export declare function findProjectChangedFiles(params: {
+    params?: VersioningOptions;
+    root?: string | URL;
+    since: string;
+    until?: string;
+}): Promise<ProjectChangedFile[]>;
+export declare function findProjectChangedPackages(params: {
+    params?: VersioningOptions;
+    root?: string | URL;
+    since: string;
+    until?: string;
+}): Promise<WorkspacePackage[]>;

package/versioning/collect-files.js

@@ -0,0 +1,66 @@
+import { relative, join } from "node:path";
+import process from "node:process";
+import picomatch from "picomatch";
+import { findChangedFiles } from "../git/utils.js";
+import { normalizeFilePath } from "../misc/path.js";
+import { getTsconfigFiles } from "../misc/tsconfig.js";
+import { collectPackageJsons } from "../package-json/collect-package-jsons.js";
+async function defaultShouldInclude(file) {
+  if (!file.file.endsWith(".ts")) return true;
+  if (file.package == null) return false;
+  const tsconfigFiles = await getTsconfigFiles(join(file.root, file.package.path));
+  return tsconfigFiles.includes(file.file);
+}
+async function findProjectChangedFiles(params) {
+  const {
+    params: {
+      include,
+      exclude = ["**/*.test.ts"],
+      shouldInclude = defaultShouldInclude
+    } = {},
+    root: root_ = process.cwd(),
+    since,
+    until
+  } = params;
+  const root = normalizeFilePath(root_);
+  const changed = await findChangedFiles({
+    since,
+    until,
+    cwd: root
+  });
+  if (!changed.length) return [];
+  const packages = await collectPackageJsons(root);
+  for (const pkg of packages) {
+    pkg.path = relative(root, pkg.path);
+  }
+  const files = [];
+  const includeGlobs = include == null ? null : picomatch(include);
+  const excludeGlobs = exclude == null ? null : picomatch(exclude);
+  for (const file of changed) {
+    const pkg = packages.find((pkg2) => file.startsWith(pkg2.path));
+    if (!pkg) continue;
+    const relPath = relative(pkg.path, file);
+    if (includeGlobs != null && !includeGlobs(relPath)) continue;
+    if (excludeGlobs != null && excludeGlobs(relPath)) continue;
+    const info = {
+      file: relPath,
+      package: pkg,
+      root
+    };
+    if (!await shouldInclude(info)) continue;
+    files.push(info);
+  }
+  return files;
+}
+async function findProjectChangedPackages(params) {
+  const files = await findProjectChangedFiles(params);
+  const set = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    if (file.package != null) set.add(file.package);
+  }
+  return Array.from(set);
+}
+export {
+  findProjectChangedFiles,
+  findProjectChangedPackages
+};

package/versioning/generate-changelog.d.ts

@@ -0,0 +1,13 @@
+import { WorkspacePackage } from '../package-json/index.js';
+import { VersioningOptions } from './types.js';
+/** simple changelog generator based on git commits history */
+export declare function generateChangelog(params: {
+    /** packages for which to generate the changelog */
+    workspace: WorkspacePackage[];
+    /** root of the git repo */
+    cwd?: string | URL;
+    /** starting point for the changelog (defaults to latest tag) */
+    since: string;
+    /** versioning params */
+    params?: VersioningOptions;
+}): Promise<string>;