@fuman/build 0.0.14 → 0.0.16

package/README.md

@@ -16,12 +16,12 @@ this package works on some assumptions, allowing to abstract some of the complex
  - `.exports` and `.bin` fields in package.json are build entrypoints, e.g.:
    ```json
    {
-       "exports": {
-           ".": "./src/index.ts"
-       },
-       "bin": {
-           "fuman-build": "./src/cli.ts"
-       }
+     "exports": {
+       ".": "./src/index.ts"
+     },
+     "bin": {
+       "fuman-build": "./src/cli.ts"
+     }
    }
  - `.main`, `.module`, `.types`, `.browser` are explicitly **not** supported. for browser-specific code, you should make a secondary entrypoint/package instead of relying on bundle-time magic
  - package versioning is continous and semver-compliant (except "fixed version" releases, which all share the same version)
@@ -71,15 +71,15 @@ just put this in your `vite.config.js`:
 import { fumanBuild } from '@fuman/build/vite'
 
 export default {
-    plugins: [
-        fumanBuild({
-            root: __dirname,
-            // if you're using `vite-plugin-dts`, make sure to add this option,
-            // otherwise additional entrypoints will not have proper types
-            // (and DO NOT add this option to the dts plugin itself)
-            insertTypesEntry: true,
-        }),
-    ],
+  plugins: [
+    fumanBuild({
+      root: __dirname,
+      // if you're using `vite-plugin-dts`, make sure to add this option,
+      // otherwise additional entrypoints will not have proper types
+      // (and DO NOT add this option to the dts plugin itself)
+      insertTypesEntry: true,
+    }),
+  ],
 }
 ```
 

package/cli/commands/release.js

@@ -39,7 +39,7 @@ const releaseCli = bc.command({
     dryRun: bc.boolean("dry-run").desc("whether to skip publishing and only print what is going to happen")
   },
   handler: async (args) => {
-    const root = process.cwd();
+    const root = process.env.FUMAN_ROOT ?? process.cwd();
     const config = await loadConfig({
       workspaceRoot: root,
       require: false
@@ -81,7 +81,9 @@ const releaseCli = bc.command({
     const taggingSchema = config?.versioning?.taggingSchema ?? "semver";
     let tagName;
     if (taggingSchema === "semver") {
-      const versions = sort(workspace.map((pkg) => asNonNull(pkg.json.version)));
+      const versions = sort(
+        workspace.filter((pkg) => !pkg.json.fuman?.ownVersioning && !pkg.json.fuman?.standalone).map((pkg) => asNonNull(pkg.json.version))
+      );
       tagName = `v${versions[versions.length - 1]}`;
       if (await gitTagExists(tagName, root)) {
         console.log(`❗ tag ${tagName} already exists. did the previous release complete successfully?`);

package/index.js

@@ -12,7 +12,7 @@ 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, parsePackageJsonFromDir, parseWorkspaceRootPackageJson } from "./package-json/parse.js";
-import { processPackageJson } from "./package-json/process-package-json.js";
+import { processPackageJson, removeCommonjsExports } from "./package-json/process-package-json.js";
 import { PackageJsonSchema } from "./package-json/types.js";
 import { bumpVersion } from "./versioning/bump-version.js";
 import { findProjectChangedFiles, findProjectChangedPackages } from "./versioning/collect-files.js";
@@ -52,6 +52,7 @@ export {
   parsePackageJsonFromDir,
   parseWorkspaceRootPackageJson,
   processPackageJson,
+  removeCommonjsExports,
   sortWorkspaceByPublishOrder,
   validateWorkspaceDeps,
   writeGithubActionsOutput

package/jsr/_deno-directives.d.ts

@@ -0,0 +1 @@
+export declare function applyDenoDirectives(code: string): string;

package/jsr/_deno-directives.js

@@ -0,0 +1,23 @@
+import { asNonNull } from "@fuman/utils";
+function applyDenoDirectives(code) {
+  if (!code.match("<deno-(insert|remove|tsignore)>")) return code;
+  let insertContent = code.match(/\/\/\s*<deno-insert>(.*?)<\/deno-insert>/s);
+  while (insertContent) {
+    code = code.slice(0, insertContent.index) + insertContent[1].replace(/\/\/\s*/g, "") + code.slice(asNonNull(insertContent.index) + insertContent[0].length);
+    insertContent = code.match(/\/\/\s*<deno-insert>(.*?)<\/deno-insert>/s);
+  }
+  let removeContent = code.match(/\/\/\s*<deno-remove>(.*?)<\/deno-remove>/s);
+  while (removeContent) {
+    code = code.slice(0, removeContent.index) + code.slice(asNonNull(removeContent.index) + removeContent[0].length);
+    removeContent = code.match(/\/\/\s*<deno-remove>(.*?)<\/deno-remove>/s);
+  }
+  let tsIgnoreContent = code.match(/\/\/\s*<deno-tsignore>/);
+  while (tsIgnoreContent) {
+    code = `${code.slice(0, tsIgnoreContent.index)}/* @ts-ignore */${code.slice(asNonNull(tsIgnoreContent.index) + tsIgnoreContent[0].length)}`;
+    tsIgnoreContent = code.match(/\/\/\s*<deno-tsignore>/);
+  }
+  return code;
+}
+export {
+  applyDenoDirectives
+};

package/jsr/config.d.ts

@@ -45,4 +45,48 @@ export interface JsrConfig {
     transformAst?: (ast: ts.SourceFile) => boolean;
     /** similar to transformAst, but for the code itself (runs after transformAst) */
     transformCode?: (path: string, code: string) => string;
+    /**
+     * whether to enable pre-processor directives when processing typescript files.
+     * this is useful to provide deno-specific typings for stuff.
+     *
+     * **note**: this is run *before* the transformCode hook, but *after* the transformAst hook
+     *
+     * supported directives:
+     *
+     * `<deno-insert>`: inserts the given code at transform time. example:
+     * ```ts
+     * // <deno-insert>
+     * // declare type SharedWorker = never
+     * // </deno-insert>
+     * ```
+     * transforms to:
+     * ```ts
+     * declare type SharedWorker = never
+     * ```
+     *
+     * `<deno-remove>`: remove the given code at transform time. example:
+     * ```ts
+     * // <deno-remove>
+     * if (self instanceof SharedWorkerGlobalScope) {
+     *   // do something
+     * }
+     * // </deno-remove>
+     * ```
+     * transforms to: (nothing)
+     *
+     * `<deno-tsignore>`: insert a `// @ts-ignore` comment when building for deno at the given position
+     * example:
+     * ```ts
+     * // <deno-tsignore>
+     * const foo: string = 123
+     * ```
+     * transforms to:
+     * ```ts
+     * // @ts-ignore
+     * const foo = 123
+     * ```
+     *
+     * @default false
+     */
+    enableDenoDirectives?: boolean;
 }

package/jsr/generate-workspace.js

@@ -12,6 +12,7 @@ import { normalizeFilePath } from "../misc/path.js";
 import { collectPackageJsons, filterPackageJsonsForPublish } from "../package-json/collect-package-jsons.js";
 import { processPackageJson } from "../package-json/process-package-json.js";
 import { findRootPackage, collectVersions } from "../package-json/utils.js";
+import { applyDenoDirectives } from "./_deno-directives.js";
 import { packageJsonToDeno } from "./deno-json.js";
 function mergeArrays(a, b, defaultValue = []) {
   if (!a) return b ?? defaultValue;
@@ -111,6 +112,9 @@ async function generateDenoWorkspace(params) {
         fileContent = printer.printFile(file);
         changed = true;
       }
+      if (rootConfig?.enableDenoDirectives) {
+        fileContent = applyDenoDirectives(fileContent);
+      }
       if (rootConfig?.transformCode || packageConfigJsr?.transformCode) {
         const origFileContent = fileContent;
         if (rootConfig?.transformCode) {

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.d.ts

@@ -12,3 +12,9 @@ export declare function processPackageJson(params: {
     packageJsonOrig: PackageJson;
     entrypoints: Record<string, string>;
 };
+/**
+ * remove comonjs export definitions from package.json
+ *
+ * **note**: this function modifies the input object
+ */
+export declare function removeCommonjsExports(exports: Record<string, unknown>): void;

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

@@ -138,6 +138,19 @@ function processPackageJson(params) {
     entrypoints
   };
 }
+function removeCommonjsExports(exports) {
+  const keys = Object.keys(exports);
+  if (keys.includes("import")) {
+    delete exports.require;
+    return;
+  }
+  for (const key of keys) {
+    const value = exports[key];
+    if (value == null || typeof value !== "object") continue;
+    delete value.require;
+  }
+}
 export {
-  processPackageJson
+  processPackageJson,
+  removeCommonjsExports
 };

package/package.json

@@ -1,16 +1,16 @@
 {
     "name": "@fuman/build",
     "type": "module",
-    "version": "0.0.14",
+    "version": "0.0.16",
     "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.14",
-        "@fuman/node": "^0.0.14",
-        "@fuman/utils": "^0.0.14",
+        "@fuman/io": "^0.0.16",
+        "@fuman/node": "^0.0.16",
+        "@fuman/utils": "^0.0.16",
         "cross-spawn": "^7.0.5",
         "detect-indent": "^7.0.1",
         "js-yaml": "^4.1.0",
@@ -30,30 +30,18 @@
             "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"
             }
         }
     },

package/versioning/bump-version.js

@@ -80,6 +80,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 +95,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`);
           }

package/versioning/collect-files.d.ts

@@ -1,5 +1,5 @@
-import { VersioningOptions } from './types.js';
 import { WorkspacePackage } from '../package-json/index.js';
+import { VersioningOptions } from './types.js';
 export interface ProjectChangedFile {
     /** package to which the file belongs */
     package: WorkspacePackage;

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.d.ts

@@ -1,6 +1,6 @@
+import { MaybeArray, MaybePromise } from '@fuman/utils';
 import { PluginOption } from 'vite';
 import { BuildHookContext } from '../config.js';
-import { MaybeArray, MaybePromise } from '@fuman/utils';
 export declare function fumanBuild(params: {
     root: URL | string;
     /**

package/vite/build-plugin.js

@@ -7,7 +7,7 @@ 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 { processPackageJson, removeCommonjsExports } from "../package-json/process-package-json.js";
 import { collectVersions } from "../package-json/utils.js";
 async function fumanBuild(params) {
   const {
@@ -113,6 +113,9 @@ async function fumanBuild(params) {
       },
       async closeBundle() {
         if (isNoop) return;
+        if (!buildCjs) {
+          removeCommonjsExports(packageJson.exports);
+        }
         await params.finalizePackageJson?.(hookContext);
         await packageConfig?.finalizePackageJson?.(hookContext);
         await fsp.writeFile(join(buildDir, "package.json"), JSON.stringify(packageJson, null, 4));