@fuman/build 0.0.1

package/versioning/generate-changelog.js

@@ -0,0 +1,81 @@
+import { join } from "node:path";
+import { asNonNull } from "@fuman/utils";
+import { getCommitsBetween, parseConventionalCommit, findChangedFiles } from "../git/utils.js";
+import { findProjectChangedFiles } from "./collect-files.js";
+function defaultOnParseFailed(commit) {
+  console.warn("[warn] Failed to parse commit message: %s", commit.message);
+}
+function defaultCommitFormatter(commit, parsed) {
+  const { breaking } = parsed;
+  const { hash, message, description } = commit;
+  let line = `- ${hash}: ${breaking ? "**❗ BREAKING** " : ""}${message}`;
+  if (breaking && description) {
+    line += `
+${commit.description.trim().split("\n").map((line2) => `  ${line2}`).join("\n")}`;
+  }
+  return line;
+}
+function defaultCommitFilter(commit, parsed) {
+  const { type, breaking } = parsed;
+  if (breaking) return true;
+  if (!type || ["chore", "ci", "docs", "test"].includes(type)) return false;
+  return true;
+}
+function defaultPackageCommitsFormatter(packageName, commits) {
+  return `### ${packageName}
+${Object.values(commits).join("\n")}`;
+}
+async function generateChangelog(params) {
+  const {
+    cwd,
+    since,
+    params: {
+      changelog: {
+        onCommitParseFailed = defaultOnParseFailed,
+        onCommitsFetched,
+        commitFilter = defaultCommitFilter,
+        commitFilterWithFiles,
+        commitFormatter = defaultCommitFormatter,
+        packageCommitsFormatter = defaultPackageCommitsFormatter
+      } = {}
+    } = {}
+  } = params;
+  const commitsByPackage = {};
+  const changedFiles = await findProjectChangedFiles({
+    params: params.params ?? {},
+    root: cwd,
+    since
+  });
+  const changedFilesByPackage = /* @__PURE__ */ new Map();
+  for (const file of changedFiles) {
+    changedFilesByPackage.set(join(file.package.path, file.file), file.package);
+  }
+  const commits = await getCommitsBetween({ since, cwd });
+  await onCommitsFetched?.(commits);
+  for (const commit of commits) {
+    const parsed = parseConventionalCommit(commit.message);
+    if (!parsed) {
+      onCommitParseFailed(commit);
+      continue;
+    }
+    if (!commitFilter(commit, parsed)) continue;
+    const changed = await findChangedFiles({ since: `${commit.hash}~1`, until: commit.hash, cwd });
+    if (commitFilterWithFiles && !commitFilterWithFiles(commit, parsed, changed)) continue;
+    for (const file of changed) {
+      const pkg = changedFilesByPackage.get(file);
+      if (!pkg) continue;
+      const packageName = asNonNull(pkg.json.name);
+      if (commitsByPackage[packageName] == null) commitsByPackage[packageName] = {};
+      commitsByPackage[packageName][commit.hash] = commitFormatter(commit, parsed, changed);
+    }
+  }
+  let ret = "";
+  for (const [pkg, commits2] of Object.entries(commitsByPackage)) {
+    ret += packageCommitsFormatter(pkg, commits2);
+    ret += "\n\n";
+  }
+  return ret;
+}
+export {
+  generateChangelog
+};

package/versioning/types.d.ts

@@ -0,0 +1,32 @@
+import { MaybePromise } from '@fuman/utils';
+import { CommitInfo, ConventionalCommit } from '../git/utils.js';
+import { ProjectChangedFile } from './collect-files.js';
+export interface ChangelogGeneratorParams {
+    onCommitParseFailed?: (commit: CommitInfo) => void;
+    onCommitsFetched?: (commits: CommitInfo[]) => Promise<void>;
+    commitFilter?: (commit: CommitInfo) => boolean;
+    commitFilterWithFiles?: (commit: CommitInfo, parsed: ConventionalCommit, files: string[]) => boolean;
+    commitFormatter?: (commit: CommitInfo, parsed: ConventionalCommit, files: string[]) => string;
+    packageCommitsFormatter?: (packageName: string, commits: Record<string, string>) => string;
+}
+export interface VersioningOptions {
+    /**
+     * globs of files changes to which to white-list (relative to package root)
+     *
+     * @default all
+     */
+    include?: string[] | null;
+    /**
+     * globs of files changes to which to black-list (relative to package root)
+     *
+     * @default `['**\/*.test.ts', '**\/*.md']`
+     */
+    exclude?: string[] | null;
+    /**
+     * custom predicate for inclusion of files
+     * (will be called in addition to the globs,
+     * defaults to checking if the file is in tsconfig.json)
+     */
+    shouldInclude?: (file: ProjectChangedFile) => MaybePromise<boolean>;
+    changelog?: ChangelogGeneratorParams;
+}

package/vite/build-plugin.d.ts

@@ -0,0 +1,73 @@
+import { PluginOption } from 'vite';
+import { BuildHookContext } from '../config.js';
+import { MaybeArray, MaybePromise } from '@fuman/utils';
+export declare function fumanBuild(params: {
+    root: URL | string;
+    /**
+     * package root, will be passed to vite's `root` option
+     *
+     * @default `process.cwd()`
+     */
+    packageRoot?: string;
+    /**
+     * files to copy from the workspace root directory to the build directory
+     *
+     * @default ['LICENSE']
+     */
+    copyRootFiles?: string[];
+    /**
+     * files to copy from the package root directory to the build directory
+     *
+     * @default ['README.md']
+     */
+    copyPackageFiles?: string[];
+    /**
+     * the modifiable part of the chunk file name
+     * there will be a prefix of `chunks/[format]/` and a suffix of `.js`
+     * @default `[hash]`
+     */
+    chunkFileName?: string;
+    /**
+     * workspace dependencies that are bundled with the library,
+     * and as such shouldn't present in the final package.json
+     */
+    bundledWorkspaceDeps?: MaybeArray<string | RegExp>;
+    rootFieldsToCopy?: string[];
+    /** when true, will automatically add `sideEffects: false` to generated package.json-s */
+    autoSideEffectsFalse?: boolean;
+    /**
+     * hook to run *before* anything is done to the package.json file
+     * you **can** modify the .packageJson property of the context
+     *
+     * this hook is called before vite build has started,
+     * and as such `.outDir` is not available yet
+     * (note: this hook is run *before* package-level hooks)
+     */
+    preparePackageJson?: (ctx: BuildHookContext) => void;
+    /**
+     * hook to run *after* the package.json file is finalized,
+     * right before it is written to disk
+     * you **can** modify the .packageJson property of the context
+     * (note: this hook is run *before* package-level hooks)
+     */
+    finalizePackageJson?: (ctx: BuildHookContext) => MaybePromise<void>;
+    /**
+     * hook to run *after* the build is done,
+     * time to do any final modifications to the package contents
+     * (note: this hook is run *before* package-level hooks)
+     */
+    finalize?: (ctx: BuildHookContext) => MaybePromise<void>;
+    /**
+     * when using with `vite-plugin-dts`, use this flag instead of
+     * their `insertTypesEntry` option to insert the types entry,
+     * as their implementation doesn't always yield the correct result
+     *
+     * @default false
+     */
+    insertTypesEntry?: boolean;
+    /**
+     * when using with `vite-plugin-dts`, this value should match `entryRoot`
+     * value passed to the `vite-plugin-dts` plugin
+     */
+    typesEntryRoot?: string;
+}): Promise<PluginOption[]>;

package/vite/build-plugin.js

@@ -0,0 +1,170 @@
+import * as fsp from "node:fs/promises";
+import { join, relative } from "node:path";
+import process from "node:process";
+import { asNonNull, deepMerge, assertStartsWith } from "@fuman/utils";
+import { loadBuildConfig } from "../misc/_config.js";
+import { tryCopy, fileExists, directoryExists } from "../misc/fs.js";
+import { normalizeFilePath } from "../misc/path.js";
+import { collectPackageJsons } from "../package-json/collect-package-jsons.js";
+import { processPackageJson } from "../package-json/process-package-json.js";
+import { collectVersions } from "../package-json/utils.js";
+async function fumanBuild(params) {
+  const {
+    copyRootFiles = ["LICENSE"],
+    copyPackageFiles = ["README.md"],
+    chunkFileName = "[hash]",
+    rootFieldsToCopy,
+    packageRoot = process.cwd(),
+    bundledWorkspaceDeps,
+    autoSideEffectsFalse = false,
+    insertTypesEntry = false,
+    typesEntryRoot
+  } = params;
+  const rootDir = normalizeFilePath(params.root);
+  const fixedVersion = process.env.__FUMAN_INTERNAL_FIXED_VERSION;
+  const cachedWorkspace = process.env.__FUMAN_INTERNAL_PACKAGES_LIST;
+  const allPackageJsons = cachedWorkspace !== void 0 ? JSON.parse(cachedWorkspace) : await collectPackageJsons(rootDir, true);
+  const rootPackageJson = allPackageJsons.find((it) => it.root)?.json;
+  if (!rootPackageJson) {
+    throw new Error("Could not find root package.json");
+  }
+  const ourPackageJson = allPackageJsons.find((it) => it.path.replace(/\/$/g, "") === packageRoot.replace(/\/$/g, ""))?.json;
+  if (!ourPackageJson) {
+    throw new Error(`Could not find package.json for ${packageRoot}`);
+  }
+  if (rootPackageJson === ourPackageJson) {
+    return [
+      {
+        name: "vite-plugin-fuman-build",
+        config(ctx, env) {
+          if (env.command === "build" && env.mode === "production") {
+            throw new Error("[@fuman/build] Cannot build the root package from root. Please change cwd to the package directory, or pass it via `packageRoot` option.");
+          }
+        }
+      }
+    ];
+  }
+  const workspaceVersions = collectVersions(allPackageJsons);
+  let isNoop = false;
+  const packageConfig = await loadBuildConfig(packageRoot);
+  const hookContext = {
+    outDir: "",
+    packageDir: packageRoot,
+    packageName: asNonNull(ourPackageJson.name),
+    packageJson: ourPackageJson,
+    jsr: false
+  };
+  params.preparePackageJson?.(hookContext);
+  packageConfig?.preparePackageJson?.(hookContext);
+  const { packageJson, entrypoints } = processPackageJson({
+    packageJson: ourPackageJson,
+    rootPackageJson,
+    workspaceVersions,
+    bundledWorkspaceDeps: (bundledWorkspaceDeps === void 0 || Array.isArray(bundledWorkspaceDeps) ? bundledWorkspaceDeps : [bundledWorkspaceDeps])?.map((dep) => typeof dep === "string" ? new RegExp(dep) : dep),
+    rootFieldsToCopy,
+    fixedVersion
+  });
+  hookContext.packageJson = packageJson;
+  if (packageJson.sideEffects == null) {
+    if (autoSideEffectsFalse) {
+      packageJson.sideEffects = false;
+    } else {
+      console.warn("[@fuman/build] package.json for %s has no sideEffects field, this may cause issues with tree-shaking", packageJson.name);
+      console.warn("[@fuman/build] (tip: set `autoSideEffectsFalse: true` in plugin params to add it automatically)");
+    }
+  }
+  let buildCjs = false;
+  let buildDir;
+  return [
+    ...packageConfig?.pluginsPre ?? [],
+    {
+      name: "vite-plugin-fuman-build",
+      async config(config, env) {
+        if (env.command !== "build") {
+          isNoop = true;
+          return null;
+        }
+        buildDir = join(packageRoot, config.build?.outDir ?? "dist");
+        hookContext.outDir = buildDir;
+        const libOptions = config?.build?.lib;
+        const libOptionsCustom = packageConfig?.viteConfig?.build?.lib;
+        const outputFormats = (libOptions === false ? void 0 : libOptions?.formats) ?? (libOptionsCustom === false ? void 0 : libOptionsCustom?.formats) ?? ["es", "cjs"];
+        buildCjs = outputFormats.includes("cjs");
+        return deepMerge({
+          root: packageRoot,
+          build: {
+            emptyOutDir: true,
+            target: "es2022",
+            minify: false,
+            rollupOptions: {
+              output: {
+                minifyInternalExports: false,
+                chunkFileNames: buildCjs ? `chunks/[format]/${chunkFileName}.js` : `chunks/${chunkFileName}.js`
+              }
+            },
+            lib: {
+              entry: entrypoints,
+              formats: outputFormats
+            }
+          }
+        }, packageConfig?.viteConfig ?? {});
+      },
+      async closeBundle() {
+        if (isNoop) return;
+        await params.finalizePackageJson?.(hookContext);
+        await packageConfig?.finalizePackageJson?.(hookContext);
+        await fsp.writeFile(join(buildDir, "package.json"), JSON.stringify(packageJson, null, 4));
+        for (const file of copyRootFiles) {
+          await tryCopy(join(rootDir, file), join(buildDir, file));
+        }
+        for (const file of copyPackageFiles) {
+          await tryCopy(join(packageRoot, file), join(buildDir, file));
+        }
+        if (insertTypesEntry) {
+          for (const [name, value] of Object.entries(entrypoints)) {
+            const dTsFile = join(buildDir, `${name}.d.ts`);
+            if (await fileExists(dTsFile)) continue;
+            let entrypointFile = value;
+            if (!value.endsWith(".ts")) continue;
+            if (typesEntryRoot == null) {
+              assertStartsWith(entrypointFile, "./");
+              while (true) {
+                if (await fileExists(join(buildDir, entrypointFile.replace(/\.ts$/, ".d.ts")))) break;
+                const idx = entrypointFile.indexOf("/", 2);
+                if (idx === -1) {
+                  throw new Error(`Could not find d.ts for entrypoint ${entrypointFile}, please pass typesEntryRoot explicitly`);
+                }
+                entrypointFile = `./${entrypointFile.slice(idx + 1)}`;
+              }
+            } else {
+              const fullEntrypointFile = join(packageRoot, entrypointFile);
+              entrypointFile = relative(typesEntryRoot, fullEntrypointFile);
+              if (!entrypointFile.startsWith(".")) {
+                entrypointFile = `./${entrypointFile}`;
+              }
+            }
+            entrypointFile = entrypointFile.replace(/\.ts$/, ".js");
+            await fsp.writeFile(dTsFile, `export * from ${JSON.stringify(entrypointFile)}`);
+          }
+        }
+        if (buildCjs && await directoryExists(join(buildDir, "chunks/cjs"))) {
+          const cjsFile = join(buildDir, "chunks/cjs/package.json");
+          await fsp.writeFile(cjsFile, JSON.stringify({ type: "commonjs" }));
+          for (const name of Object.keys(entrypoints)) {
+            const dTsFile = join(buildDir, `${name}.d.ts`);
+            if (!await fileExists(dTsFile)) {
+              continue;
+            }
+            await fsp.cp(dTsFile, dTsFile.replace(/\.d\.ts$/, ".d.cts"));
+          }
+        }
+        await params.finalize?.(hookContext);
+        await packageConfig?.finalize?.(hookContext);
+      },
+      ...packageConfig?.pluginsPost ?? []
+    }
+  ];
+}
+export {
+  fumanBuild
+};

package/vite/config.d.ts

@@ -0,0 +1,34 @@
+import { MaybePromise } from '@fuman/utils';
+import { Plugin, UserConfig } from 'vite';
+import { BuildHookContext } from '../config.js';
+import { JsrConfig } from '../jsr/config.js';
+export interface CustomBuildConfigObject {
+    /** jsr-specific configuration */
+    jsr?: JsrConfig;
+    /** any additional vite plugins to be added before the fuman-build plugin */
+    pluginsPre?: Plugin[];
+    /** any additional vite plugins to be added after the fuman-build plugin */
+    pluginsPost?: Plugin[];
+    /** vite config to be merged into the base config */
+    viteConfig?: UserConfig;
+    /**
+     * hook to run *before* anything is done to the package.json file
+     * you **can** modify the .packageJson property of the context
+     *
+     * this hook is called before vite build has started,
+     * and as such `.outDir` is not available yet
+     */
+    preparePackageJson?: (ctx: BuildHookContext) => void;
+    /**
+     * hook to run *after* the package.json file is finalized,
+     * right before it is written to disk
+     * you **can** modify the .packageJson property of the context
+     */
+    finalizePackageJson?: (ctx: BuildHookContext) => MaybePromise<void>;
+    /**
+     * hook to run *after* the build is done,
+     * time to do any final modifications to the package contents
+     */
+    finalize?: (ctx: BuildHookContext) => MaybePromise<void>;
+}
+export type CustomBuildConfig = CustomBuildConfigObject | (() => CustomBuildConfigObject);

package/vite/index.d.ts

@@ -0,0 +1,2 @@
+export * from './build-plugin.js';
+export * from './config.js';

package/vite.d.ts

@@ -0,0 +1 @@
+export * from "./vite/index.js"

package/vite.js

@@ -0,0 +1,4 @@
+import { fumanBuild } from "./vite/build-plugin.js";
+export {
+  fumanBuild
+};