@fuman/build 0.0.13 → 0.0.15

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

@@ -3,6 +3,5 @@ import * as bc from '@drizzle-team/brocli';
 export { bc };
 export declare function loadConfig(params: {
     workspaceRoot: string;
-    configPath?: string;
     require?: boolean;
 }): Promise<RootConfigObject | null>;

package/cli/commands/_utils.js

@@ -3,12 +3,11 @@ import { loadBuildConfig } from "../../misc/_config.js";
 async function loadConfig(params) {
   const {
     workspaceRoot,
-    configPath = "build.config.js",
     require: require2 = true
   } = params;
-  const config = await loadBuildConfig(workspaceRoot, configPath);
+  const config = await loadBuildConfig(workspaceRoot);
   if (!config && require2) {
-    throw new Error(`Config not found: ${configPath}`);
+    throw new Error(`Config not found at ${workspaceRoot}`);
   }
   return config ?? null;
 }

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

@@ -3,15 +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;
-    config: string | undefined;
-    type: "auto" | "major" | "minor" | "patch";
+    type: "major" | "minor" | "patch" | "auto";
     since: string | undefined;
     dryRun: boolean | undefined;
     quiet: boolean | undefined;
 }, {
     root: string | undefined;
-    config: string | undefined;
-    type: "auto" | "major" | "minor" | "patch";
+    type: "major" | "minor" | "patch" | "auto";
     since: string | undefined;
     dryRun: boolean | undefined;
     quiet: boolean | undefined;

package/cli/commands/bump-version.js

@@ -13,8 +13,6 @@ function formatBumpVersionResult(result, withReleaseType) {
     lines.push(`  has new features: ${result.hasFeatures}`);
     lines.push("");
   }
-  lines.push(`next version: ${result.nextVersion}`);
-  lines.push("");
   lines.push("list of changed packages:");
   for (const { package: pkg, because, prevVersion } of result.changedPackages) {
     let versionStr = prevVersion;
@@ -30,7 +28,6 @@ const bumpVersionCli = bc.command({
   desc: "bump the version of changed packages",
   options: {
     root: bc.string().desc("path to the root of the workspace (default: process.cwd())"),
-    config: bc.string().desc("path to the build.config.js file"),
     type: bc.string().desc("override type of release (major, minor, patch) (default: auto-detect)").enum("major", "minor", "patch", "auto").default("auto"),
     since: bc.string().desc("starting point for the changelog (default: latest tag)"),
     dryRun: bc.boolean("dry-run").desc("whether to only print the detected changes without actually modifying anything"),
@@ -42,7 +39,6 @@ const bumpVersionCli = bc.command({
     const workspace = await collectPackageJsons(root);
     const config = await loadConfig({
       workspaceRoot: root,
-      configPath: args.config,
       require: false
     });
     const since = args.since ?? await getLatestTag(root);
@@ -58,12 +54,12 @@ const bumpVersionCli = bc.command({
       dryRun: args.dryRun
     });
     if (args.quiet) {
-      console.log(result.nextVersion);
+      console.log(JSON.stringify(result.nextVersions));
     } else {
       console.log(formatBumpVersionResult(result, releaseType == null));
     }
     if (isRunningInGithubActions()) {
-      writeGithubActionsOutput("version", result.nextVersion);
+      writeGithubActionsOutput("versions", JSON.stringify(result.nextVersions));
       writeGithubActionsOutput("hasBreakingChanges", String(result.hasBreakingChanges));
       writeGithubActionsOutput("hasFeatures", String(result.hasFeatures));
       writeGithubActionsOutput("changedPackages", result.changedPackages.map((it) => it.package.json.name).join(","));

package/cli/commands/find-changed-packages.d.ts

@@ -1,12 +1,10 @@
 import { bc } from './_utils.js';
 export declare const findChangedPackagesCli: bc.Command<{
     root: string | undefined;
-    config: string | undefined;
     since: string | undefined;
     until: string | undefined;
 }, {
     root: string | undefined;
-    config: string | undefined;
     since: string | undefined;
     until: string | undefined;
 }>;

package/cli/commands/find-changed-packages.js

@@ -9,7 +9,6 @@ const findChangedPackagesCli = bc.command({
   desc: "find changed packages between two commits, and output a comma-separated list of package names",
   options: {
     root: bc.string().desc("path to the root of the workspace (default: process.cwd())"),
-    config: bc.string("config").desc("path to the build.config.js file"),
     since: bc.string().desc("starting point for the changelog (default: latest tag)"),
     until: bc.string().desc("ending point for the changelog (default: HEAD)")
   },
@@ -17,7 +16,6 @@ const findChangedPackagesCli = bc.command({
     const root = args.root ?? process.cwd();
     const config = await loadConfig({
       workspaceRoot: root,
-      configPath: args.config,
       require: false
     });
     const since = args.since ?? await getLatestTag(root);

package/cli/commands/gen-changelog.d.ts

@@ -2,11 +2,9 @@ import { bc } from './_utils.js';
 export declare const generateChangelogCli: bc.Command<{
     only: string | undefined;
     root: string | undefined;
-    config: string | undefined;
     since: string | undefined;
 }, {
     only: string | undefined;
     root: string | undefined;
-    config: string | undefined;
     since: string | undefined;
 }>;

package/cli/commands/gen-changelog.js

@@ -11,14 +11,12 @@ const generateChangelogCli = bc.command({
   options: {
     only: bc.string().desc("comma-separated list of packages to include"),
     root: bc.string().desc("path to the root of the workspace (default: process.cwd())"),
-    config: bc.string("config").desc("path to the build.config.js file"),
     since: bc.string().desc("starting point for the changelog (default: latest tag)")
   },
   handler: async (args) => {
     const root = args.root ?? process.cwd();
     const config = await loadConfig({
       workspaceRoot: root,
-      configPath: args.config,
       require: false
     });
     let workspacePackages = await collectPackageJsons(root, false);

package/cli/commands/lint/config.d.ts

@@ -0,0 +1,30 @@
+import { WorkspacePackage } from '../../../package-json/collect-package-jsons.js';
+export interface LintConfig {
+    /**
+     * whether to also validate the root package.json
+     *
+     * @default false
+     */
+    includeRoot?: boolean;
+    /** validation of external dependencies */
+    externalDependencies?: {
+        /** @default true */
+        enabled?: boolean;
+        /**
+         * whether to skip validating peer dependencies
+         *
+         * @default false
+         */
+        skipPeerDependencies?: boolean;
+        shouldSkip?: (ctx: {
+            /** package currently being validated */
+            package: WorkspacePackage;
+            /** name of the dependency */
+            dependency: string;
+            /** version of the dependency */
+            version: string;
+            /** field in which the dependency is declared */
+            field: 'dependencies' | 'devDependencies' | 'peerDependencies' | 'optionalDependencies';
+        }) => boolean;
+    };
+}

package/cli/commands/lint/index.d.ts

@@ -0,0 +1,8 @@
+import { bc } from '../_utils.js';
+export declare const lintCli: bc.Command<{
+    workspace: string | undefined;
+    noErrorCode: boolean;
+}, {
+    workspace: string | undefined;
+    noErrorCode: boolean;
+}>;

package/cli/commands/lint/index.js

@@ -0,0 +1,47 @@
+import process from "node:process";
+import { loadConfig } from "../_utils.js";
+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({
+  name: "lint",
+  desc: "check the workspace for any issues",
+  options: {
+    workspace: bc.string().desc("path to the workspace root (default: cwd)"),
+    noErrorCode: bc.boolean("no-error-code").desc("whether to always exit with a zero code").default(false)
+  },
+  handler: async (args) => {
+    const workspaceRoot = args.workspace ?? process.cwd();
+    const config = (await loadConfig({ workspaceRoot }))?.lint;
+    const errors = await validateWorkspaceDeps({
+      workspaceRoot,
+      config
+    });
+    if (errors.length > 0) {
+      const externalErrors = errors.filter((it) => it.type === "external");
+      const internalErrors = errors.filter((it) => it.type === "internal");
+      if (externalErrors.length > 0) {
+        console.error("⚠️ Found external dependencies mismatch:");
+        for (const error of externalErrors) {
+          console.error(`  - at ${error.package}: ${error.at} has ${error.dependency}@${error.version}, but ${error.otherPackage} has @${error.otherVersion}`);
+        }
+      }
+      if (internalErrors.length > 0) {
+        console.error("⚠️ Found issues with internal dependencies:");
+        for (const error of internalErrors) {
+          console.error(`  - at ${error.package}, dependency ${error.dependency}: ${INTERNAL_MESSAGES[error.subtype]}`);
+        }
+      }
+      if (!args.noErrorCode) {
+        process.exit(1);
+      }
+    }
+  }
+});
+export {
+  lintCli
+};

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

@@ -0,0 +1,41 @@
+import { WorkspacePackage } from '../../../package-json/collect-package-jsons.js';
+import { LintConfig } from './config.js';
+/** information about a mismatch between a package and its dependencies */
+export interface ExternalDepsError {
+    type: 'external';
+    /** package name where the mismatch occurred */
+    package: string;
+    /** name of the mismatched dependency */
+    dependency: string;
+    /** version of the mismatched dependency */
+    version: string;
+    /** type of dependency (`dependencies`, `devDependencies`, etc) */
+    at: string;
+    /** package name where the dependency was originally declared */
+    otherPackage: string;
+    /** original version of the dependency */
+    otherVersion: string;
+}
+export interface InternalDepsError {
+    type: 'internal';
+    /** package name where the mismatch occurred */
+    package: string;
+    /** name of the mismatched dependency */
+    dependency: string;
+    /**
+     * 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';
+}
+export type WorkspaceDepsError = ExternalDepsError | InternalDepsError;
+/**
+ * validate the external dependencies of a workspace
+ */
+export declare function validateWorkspaceDeps(params: {
+    workspaceRoot: string | URL;
+    packages?: WorkspacePackage[];
+    config?: LintConfig;
+}): Promise<WorkspaceDepsError[]>;

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

@@ -0,0 +1,94 @@
+import { valid, satisfies, validRange, subset } from "semver";
+import { collectPackageJsons } from "../../../package-json/collect-package-jsons.js";
+async function validateWorkspaceDeps(params) {
+  const {
+    workspaceRoot,
+    config: {
+      includeRoot,
+      externalDependencies: {
+        enabled: externalDependenciesEnabled = true,
+        skipPeerDependencies: externalDependenciesSkipPeerDependencies = false,
+        shouldSkip: externalDependenciesShouldSkip
+      } = {}
+    } = {}
+  } = params;
+  const packages = params.packages ?? await collectPackageJsons(workspaceRoot, includeRoot);
+  const packagesMap = new Map(packages.map((pj) => [pj.json.name, pj]));
+  const versions = {};
+  const errors = [];
+  for (const pkg of packages) {
+    const pj = pkg.json;
+    if (pj.name === void 0) {
+      throw new Error("package.json without name is not supported");
+    }
+    for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+      const deps = pj[field];
+      if (!deps) continue;
+      for (const [name, version] of Object.entries(deps)) {
+        if (packagesMap.has(name)) {
+          const otherPkg = packagesMap.get(name);
+          const otherPkgStandalone = Boolean(otherPkg?.json.fuman?.standalone);
+          if (!otherPkgStandalone && !version.startsWith("workspace:")) {
+            errors.push({
+              type: "internal",
+              package: pj.name,
+              dependency: name,
+              subtype: "not_workspace_proto"
+            });
+            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:")) {
+          errors.push({
+            type: "internal",
+            package: pj.name,
+            dependency: name,
+            subtype: "not_workspace_dep"
+          });
+          continue;
+        }
+        if (!externalDependenciesEnabled) continue;
+        if (field === "peerDependencies" && externalDependenciesSkipPeerDependencies) continue;
+        if (externalDependenciesShouldSkip?.({ package: pkg, dependency: name, version, field })) continue;
+        if (versions[name] === void 0) {
+          versions[name] = {};
+        }
+        for (const [pkgName, pkgDepVersions] of Object.entries(versions[name])) {
+          let ok = true;
+          if (pkgDepVersions.match(/^(?:https?:\/\/|catalog:)/)) {
+            ok = version === pkgDepVersions;
+          } else if (valid(version) != null) {
+            ok = satisfies(version, pkgDepVersions);
+          } else if (validRange(version) != null) {
+            ok = subset(pkgDepVersions, version);
+          }
+          if (!ok) {
+            errors.push({
+              type: "external",
+              package: pj.name,
+              dependency: name,
+              version,
+              at: field,
+              otherPackage: pkgName,
+              otherVersion: pkgDepVersions
+            });
+          }
+        }
+        versions[name][pj.name] = version;
+      }
+    }
+  }
+  return errors;
+}
+export {
+  validateWorkspaceDeps
+};

package/cli/commands/release.d.ts

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

package/cli/commands/release.js

@@ -39,10 +39,9 @@ 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,
-      configPath: "build.config.js",
       require: false
     });
     const workspaceWithRoot = await collectPackageJsons(root, true);
@@ -79,28 +78,40 @@ const releaseCli = bc.command({
     } else {
       changedPackages = workspace;
     }
+    const taggingSchema = config?.versioning?.taggingSchema ?? "semver";
     let tagName;
-    if (!bumpVersionResult) {
-      const versions = sort(workspace.map((pkg) => asNonNull(pkg.json.version)));
+    if (taggingSchema === "semver") {
+      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]}`;
-    } else {
-      tagName = `v${bumpVersionResult.nextVersion}`;
-    }
-    if (await gitTagExists(tagName, root)) {
-      console.log(`❗ tag ${tagName} already exists. did the previous release complete successfully?`);
-      console.log("❗ if so, please verify versions in package.json and try again");
-      if (!args.dryRun) {
-        process.exit(1);
+      if (await gitTagExists(tagName, root)) {
+        console.log(`❗ tag ${tagName} already exists. did the previous release complete successfully?`);
+        console.log("❗ if so, please verify versions in package.json and try again");
+        if (!args.dryRun) {
+          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);
+      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);
+        }
       }
+    } else if (taggingSchema === "date") {
+      const date = /* @__PURE__ */ new Date();
+      const tagNamePrefix = `v${date.getFullYear()}.${(date.getMonth() + 1).toString().padStart(2, "0")}.${date.getDate().toString().padStart(2, "0")}`;
+      let currentLetter = "a";
+      do {
+        tagName = `${tagNamePrefix}${currentLetter}`;
+        currentLetter = String.fromCharCode(currentLetter.charCodeAt(0) + 1);
+      } while (await gitTagExists(tagName, root));
+    } else {
+      throw new Error(`Unknown tagging schema: ${taggingSchema}`);
     }
     console.log("");
+    console.log("🚀 next tag:", tagName);
     console.log("📝 generating changelog...");
     const changelog = prevTag != null ? await generateChangelog({
       workspace: changedPackages,

package/cli/index.d.ts

@@ -1,4 +1,4 @@
 export { buildPackage } from './commands/build.js';
 export { generateDocs } from './commands/docs.js';
 export { generateDepsGraph } from './commands/gen-deps-graph.js';
-export { validateWorkspaceDeps, type WorkspaceDepsError } from './commands/validate-workspace-deps.js';
+export { validateWorkspaceDeps, type WorkspaceDepsError } from './commands/lint/validate-workspace-deps.js';

package/config.d.ts

@@ -1,5 +1,6 @@
 import { AnyToNever } from '@fuman/utils';
 import { TypeDocOptions } from 'typedoc';
+import { LintConfig } from './cli/commands/lint/config.js';
 import { JsrConfig } from './jsr/config.js';
 import { PackageJson } from './package-json/types.js';
 import { VersioningOptions } from './versioning/types.js';
@@ -49,6 +50,8 @@ export interface RootConfigObject {
          */
         excludePackages?: string[];
     }>;
+    /** `lint` command configuration */
+    lint?: LintConfig;
 }
 /** root configuration (either an object or a function that returns an object) */
 export type RootConfig = RootConfigObject | (() => RootConfigObject);

package/fuman-build.js

@@ -9,11 +9,11 @@ import { findChangedPackagesCli } from "./cli/commands/find-changed-packages.js"
 import { generateChangelogCli } from "./cli/commands/gen-changelog.js";
 import { generateDepsGraphCli } from "./cli/commands/gen-deps-graph.js";
 import { jsrCli } from "./cli/commands/jsr.js";
+import { lintCli } from "./cli/commands/lint/index.js";
 import { publishPackagesCli } from "./cli/commands/publish.js";
 import { releaseCli } from "./cli/commands/release.js";
-import { validateWorkspaceDepsCli } from "./cli/commands/validate-workspace-deps.js";
 await bc.run([
-  validateWorkspaceDepsCli,
+  lintCli,
   generateDepsGraphCli,
   buildPackageCli,
   jsrCli,

package/git/utils.d.ts

@@ -70,7 +70,9 @@ export interface CommitInfo {
  */
 export declare function getCommitsBetween(params: {
     /** starting point for the diff */
-    since: string;
+    since?: string;
+    /** only include commits that modified these files */
+    files?: string[];
     /**
      * ending point for the diff
      * @default  'HEAD'

package/git/utils.js

@@ -50,13 +50,21 @@ async function findChangedFiles(params) {
   return files;
 }
 async function getCommitsBetween(params) {
-  const { since, until = "HEAD", cwd } = params;
+  const { since, until = "HEAD", cwd, files } = params;
   const delim = `---${randomUUID()}---`;
-  const res = await exec(["git", "log", `--pretty=format:%H %s%n%an%n%ae%n%aI%n%cn%n%ce%n%cI%n%b%n${delim}`, `${since}..${until}`], {
+  const res = await exec([
+    "git",
+    "log",
+    `--pretty=format:%H %s%n%an%n%ae%n%aI%n%cn%n%ce%n%cI%n%b%n${delim}`,
+    since != null ? `${since}..${until}` : until,
+    // eslint-disable-next-line ts/strict-boolean-expressions
+    ...files?.length ? ["--", ...files] : []
+  ], {
     cwd,
     throwOnError: true
   });
   const lines = res.stdout.trim().split("\n");
+  if (lines.length === 1 && lines[0] === "") return [];
   const items = [];
   let current = null;
   for (let i = 0; i < lines.length; i++) {

package/index.js

@@ -2,7 +2,7 @@ import { getGithubActionsInput, isRunningInGithubActions, writeGithubActionsOutp
 import { buildPackage } from "./cli/commands/build.js";
 import { generateDocs } from "./cli/commands/docs.js";
 import { generateDepsGraph } from "./cli/commands/gen-deps-graph.js";
-import { validateWorkspaceDeps } from "./cli/commands/validate-workspace-deps.js";
+import { validateWorkspaceDeps } from "./cli/commands/lint/validate-workspace-deps.js";
 import { findChangedFiles, getCommitsBetween, getCurrentBranch, getCurrentCommit, getFirstCommit, getLatestTag, gitTagExists, parseConventionalCommit } from "./git/utils.js";
 import { ExecError, exec } from "./misc/exec.js";
 import { normalizeFilePath } from "./misc/path.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.d.ts

@@ -1 +1 @@
-export declare function loadBuildConfig<T>(packageRoot: string, configName?: string): Promise<T | undefined>;
+export declare function loadBuildConfig<T>(packageRoot: string): Promise<T | undefined>;

package/misc/_config.js

@@ -1,7 +1,8 @@
 import { join } from "node:path";
-async function loadBuildConfig(packageRoot, configName = "build.config.js") {
+const CONFIG_NAME = "build.config.js";
+async function loadBuildConfig(packageRoot) {
   try {
-    const mod = (await import(join(packageRoot, configName))).default;
+    const mod = (await import(join(packageRoot, CONFIG_NAME))).default;
     if (typeof mod === "function") {
       return mod();
     } else {
@@ -9,7 +10,7 @@ async function loadBuildConfig(packageRoot, configName = "build.config.js") {
     }
   } catch (e) {
     if (!(e instanceof Error && e.code === "ERR_MODULE_NOT_FOUND")) {
-      throw new Error(`Could not load ${configName}`, { cause: e });
+      throw new Error(`Could not load ${CONFIG_NAME}`, { cause: e });
     }
   }
 }

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

@@ -45,12 +45,21 @@ export interface PackageJson {
          */
         distOnlyFields?: Record<string, unknown>;
         /**
-         * whether this package has its own versioning scheme
+         * whether this package has its own versioning scheme, not managed by @fuman/build
          * (be careful with this option! this might break cross-release semver compatibility)
          */
         ownVersioning?: boolean;
         /** whether this package should not be published */
         private?: boolean;
+        /**
+         * whether this is a "standalone" package
+         *
+         * 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;
 }

package/package-json/types.js

@@ -47,6 +47,7 @@ const PackageJsonSchema = z.object({
     keepScripts: z.array(z.string()),
     distOnlyFields: z.record(z.unknown()),
     ownVersioning: z.boolean(),
+    standalone: z.boolean(),
     private: z.boolean()
   }).partial(),
   // todo: properly type this

package/package.json

@@ -1,16 +1,16 @@
 {
     "name": "@fuman/build",
     "type": "module",
-    "version": "0.0.13",
+    "version": "0.0.15",
     "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.11",
-        "@fuman/node": "^0.0.11",
-        "@fuman/utils": "^0.0.11",
+        "@fuman/fetch": "0.0.13",
+        "@fuman/io": "^0.0.15",
+        "@fuman/node": "^0.0.15",
+        "@fuman/utils": "^0.0.15",
         "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.d.ts

@@ -17,7 +17,7 @@ export interface BumpVersionResult {
     /** max version of all packages */
     maxVersion: string;
     /** next version */
-    nextVersion: string;
+    nextVersions: Record<string, string>;
     /** changed packages which will be bumped to `nextVersion` */
     changedPackages: BumpVersionPackage[];
     /** detected release type */
@@ -36,6 +36,8 @@ export interface BumpVersionResult {
 export declare function bumpVersion(params: {
     /** packages for which to generate the changelog */
     workspace: WorkspacePackage[];
+    /** previous tag */
+    prevTag?: string | null;
     /** whether to bump version of all packages, not just changed ones */
     all?: boolean;
     type?: ReleaseType;

package/versioning/bump-version.js

@@ -4,7 +4,7 @@ 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 { getCommitsBetween, parseConventionalCommit, getLatestTag } from "../git/utils.js";
 import { collectVersions, findRootPackage } from "../package-json/utils.js";
 import { findProjectChangedPackages } from "./collect-files.js";
 async function bumpVersion(params) {
@@ -21,7 +21,7 @@ async function bumpVersion(params) {
   for (const pkg of workspaceWithoutRoot) {
     if (pkg.root) continue;
     const version = asNonNull(pkg.json.version);
-    if (pkg.json.fuman?.ownVersioning) {
+    if (pkg.json.fuman?.ownVersioning || pkg.json.fuman?.standalone) {
       continue;
     }
     if (maxVersion == null || gt(version, maxVersion)) {
@@ -89,6 +89,9 @@ async function bumpVersion(params) {
         if (obj == null) continue;
         if (obj[pkgName] == null || typeof obj[pkgName] !== "string") continue;
         let expandedVersion = obj[pkgName];
+        if (!expandedVersion.startsWith("workspace:") && otherPkg.json.fuman?.standalone) {
+          continue;
+        }
         if (expandedVersion === "workspace:^") expandedVersion = `^${workspaceVersions[pkgName]}`;
         if (expandedVersion === "workspace:*") expandedVersion = workspaceVersions[pkgName];
         if (!satisfies(nextVersion, expandedVersion)) {
@@ -115,22 +118,42 @@ async function bumpVersion(params) {
   if (withRoot) {
     packagesToBump.push(findRootPackage(workspace));
   }
+  const nextVersions = {};
+  let prevTag = params.prevTag;
   for (const pkg of packagesToBump) {
     if (pkg.json.fuman?.ownVersioning) continue;
+    let newVersion = nextVersion;
+    if (pkg.json.fuman?.standalone) {
+      newVersion = asNonNull(pkg.json.version);
+      if (prevTag === void 0) {
+        prevTag = await getLatestTag(pkg.path);
+      }
+      if (prevTag != null) {
+        const commits = await getCommitsBetween({
+          until: prevTag,
+          cwd,
+          files: [join(pkg.path, "package.json")]
+        });
+        if (commits.length > 0) {
+          newVersion = asNonNull(inc(newVersion, type));
+        }
+      }
+    }
     if (!dryRun) {
       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;
+      pkgJson.version = newVersion;
       await fsp.writeFile(pkgJsonPath, `${JSON.stringify(pkgJson, null, indent)}
 `);
     }
-    pkg.json.version = nextVersion;
+    pkg.json.version = newVersion;
+    nextVersions[asNonNull(pkg.json.name)] = newVersion;
   }
   return {
     maxVersion,
-    nextVersion,
+    nextVersions,
     changedPackages: result,
     releaseType: type,
     hasBreakingChanges,

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

@@ -12,6 +12,21 @@ export interface ChangelogGeneratorParams {
 }
 /** settings for versioning manager */
 export interface VersioningOptions {
+    /**
+     * schema to use when tagging commits
+     * - `semver`: semver-compatible schema (e.g. `v1.2.3`), based on the max. version of the workspace
+     * - `date`: date-based schema (e.g. `v2023.01.01`), based on the date of the release
+     *
+     * unless your monorepo has standalone packages, you should probably use `semver` schema.
+     * `date` schema is primarily useful for repos where different packages have separate release cycles,
+     * to avoid conflicts when bumping versions.
+     *
+     * > note: this is **only** used for the `release` command, when tagging commits.
+     * > this does **not** affect the versioning of the packages themselves, they always use semver.
+     *
+     * @default 'semver'
+     */
+    taggingSchema?: 'semver' | 'date';
     /**
      * globs of files changes to which to white-list (relative to package root)
      *

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));

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

@@ -1,50 +0,0 @@
-import { bc } from './_utils.js';
-/** information about a mismatch between a package and its dependencies */
-export interface WorkspaceDepsError {
-    /** package name where the mismatch occurred */
-    package: string;
-    /** name of the mismatched dependency */
-    dependency: string;
-    /** version of the mismatched dependency */
-    version: string;
-    /** type of dependency (`dependencies`, `devDependencies`, etc) */
-    at: string;
-    /** package name where the dependency was originally declared */
-    otherPackage: string;
-    /** original version of the dependency */
-    otherVersion: string;
-}
-/**
- * validate the external dependencies of a workspace
- */
-export declare function validateWorkspaceDeps(params: {
-    /** path to the workspace root */
-    workspaceRoot: string | URL;
-    /**
-     * whether to also validate the root package.json
-     *
-     * @default true
-     */
-    includeRoot?: boolean;
-    /**
-     * whether to skip validating dependencies of other workspace packages
-     *
-     * @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

@@ -1,87 +0,0 @@
-import process from "node:process";
-import { satisfies } from "semver";
-import { collectPackageJsons } from "../../package-json/collect-package-jsons.js";
-import * as bc from "@drizzle-team/brocli";
-async function validateWorkspaceDeps(params) {
-  const {
-    workspaceRoot,
-    includeRoot = true,
-    skipWorkspaceDeps = true,
-    skipPeerDeps = true
-  } = params;
-  const pjs = await collectPackageJsons(workspaceRoot, includeRoot);
-  const workspacePackages = new Set(skipWorkspaceDeps ? pjs.map((pj) => pj.json.name) : []);
-  const versions = {};
-  const errors = [];
-  for (const { json: pj } of pjs) {
-    if (pj.name === void 0) {
-      throw new Error("package.json without name is not supported");
-    }
-    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;
-        if (versions[name] === void 0) {
-          versions[name] = {};
-        }
-        for (const [pkgName, pkgDepVersions] of Object.entries(versions[name])) {
-          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,
-              version,
-              at: field,
-              otherPackage: pkgName,
-              otherVersion: pkgDepVersions
-            });
-          }
-        }
-        versions[name][pj.name] = version;
-      }
-    }
-  }
-  return errors;
-}
-const validateWorkspaceDepsCli = bc.command({
-  name: "validate-workspace-deps",
-  desc: "validate the external dependencies of a workspace",
-  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)"),
-    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,
-      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!");
-    }
-  }
-});
-export {
-  validateWorkspaceDeps,
-  validateWorkspaceDepsCli
-};