@bunit/build 0.0.0

package/README.md

@@ -0,0 +1,136 @@
+# @bunit/build
+
+> ⚡️ Zero-config TypeScript package builder powered by [**Bun**](https://bun.sh).
+
+## Features
+
+- 🚀 **Blazing Fast** - Built on Bun's native bundler and transpiler
+- 📦 **Dual Mode** - Bundle mode for entry points, Transform mode for directories
+- 🎯 **Zero-Config** - Smart defaults with flexible customization
+- 📝 **Type Generation** - Automatic `.d.ts` declarations with unplugin-isolated-decl
+- 🛠️ **CLI Tool** - Simple command-line interface
+- 🚀 **Stub Mode** - Development mode for faster builds
+
+## Installation
+
+```bash
+bun add @bunit/build
+```
+
+## Usage
+
+### CLI
+
+```bash
+# Build using build.config.ts
+built
+
+# Stub mode (development)
+built --stub
+
+# Bundle mode
+built ./src/index.ts
+
+# Transform mode (directory)
+built ./src/lib/:./dist/lib
+
+# Specify working directory
+built --dir ./packages/my-lib
+```
+
+### Programmatic
+
+```typescript
+import { build } from "@bunit/build";
+
+await build({
+  entries: ["./src/index.ts"],
+});
+```
+
+## Config
+
+Create `build.config.ts` (or `.mjs`):
+
+```typescript
+import { defineBuildConfig } from "@bunit/build/config";
+
+export default defineBuildConfig({
+  entries: [
+    {
+      type: "bundle",
+      input: ["./src/index.ts", "./src/cli.ts"],
+      // outDir: "./dist",
+      // minify: false,
+      // stub: false,
+      // bun: {}, // https://bun.sh/docs/bundler
+      // dts: true,
+    },
+    {
+      type: "transform",
+      input: "./src/lib",
+      outDir: "./dist/lib",
+      // stub: false,
+      // transpiler: {},
+      // filter: (file) => !file.includes('.test.ts'),
+      // dts: true,
+    },
+  ],
+  hooks: {
+    // start: (ctx) => {},
+    // end: (ctx) => {},
+    // entries: (entries, ctx) => {},
+    // bunConfig: (config, ctx) => {},
+    // bunOutput: (config, ctx) => {},
+  },
+});
+```
+
+## Stub Mode
+
+When working on a package locally, rebuilding can be tedious. Use `stub: true` or the `--stub` CLI flag to skip the actual build and link expected dist paths to source files.
+
+- **Bundle entries**: `.mjs` and `.d.mts` files re-export the source file
+- **Transform entries**: `.mjs` files re-export from source TypeScript files
+
+**Caveats:**
+
+- You need a runtime that natively supports TypeScript (Bun, Deno)
+- When using stub mode with transform mode, ensure your bundler can resolve `.ts` or `.mjs` extensions
+- For bundle mode, if you add/remove exports, run the stub build again
+
+## Build Modes
+
+### Bundle Mode
+
+Ideal for library entry points with dependency analysis and code splitting.
+
+```typescript
+{
+  type: "bundle",
+  input: "./src/index.ts",
+  minify: true,
+  bun: {
+    sourcemap: "external",
+    // ... any Bun.build option
+  },
+}
+```
+
+### Transform Mode
+
+Preserves file structure for transforming directories.
+
+```typescript
+{
+  type: "transform",
+  input: "./src/lib",
+  outDir: "./dist/lib",
+  filter: (file) => !file.includes('.test.ts'),
+  stub: false,
+}
+```
+
+## License
+
+[MIT](../../LICENSE) © [Demo Macro](https://www.demomacro.com/)

package/dist/_chunks/index.mjs

@@ -0,0 +1,23 @@
+// @bun
+var x=import.meta.require;import{resolve as P}from"path";function _(Q,V){let H=P(Q),I=V||process.cwd(),Y=H.replace(/\\/g,"/"),Z=I.replace(/\\/g,"/");return Y.replace(Z,".")}function W(Q){if(Array.isArray(Q)){let Y=0,Z=0;for(let J of Q){let{size:$,files:q}=W(J);Y+=$,Z+=q}return{size:Y,files:Z}}let V=0,H=0,I=Array.from(new Bun.Glob("**/*").scanSync({cwd:Q,absolute:!0}));for(let Y of I){let Z=Bun.file(Y);if(Z.size>0)V+=Z.size,H++}return{size:V,files:H}}import{fileURLToPath as n,pathToFileURL as i}from"url";import{isAbsolute as D,join as r,resolve as e}from"path";import{rm as t}from"fs/promises";import{builtinModules as z}from"module";import{mkdir as f,chmod as d}from"fs/promises";import{dirname as F,relative as L,join as M,basename as m,extname as p,resolve as k}from"path";import u from"unplugin-isolated-decl/esbuild";import U from"pretty-bytes";async function E(Q,V,H){let I=c(V.input,Q);if(V.stub){for(let[q,K]of Object.entries(I)){let X=M(Q.pkgDir,"dist",`${q}.mjs`);await f(F(X),{recursive:!0}),console.log(`[bundle] ${_(X)} (stub)`);let O=await Bun.file(K).text(),B=new Bun.Transpiler({loader:"ts"}).scan(O).exports.includes("default"),w=O.split(`
+`)[0],N=w.startsWith("#!"),G=L(F(X),K);if(G=G.replace(/\\/g,"/"),await Bun.write(X,`${N?w+`
+`:""}export * from "${G}";
+${B?`export { default } from "${G}";
+`:""}`),N)await d(X,493);await Bun.write(X.replace(/\.mjs$/,".d.mts"),`export * from "${G}";
+${B?`export { default } from "${G}";
+`:""}`)}return}let Y=[...z,...z.map((q)=>`node:${q}`),...[...Object.keys(Q.pkg.dependencies||{}),...Object.keys(Q.pkg.peerDependencies||{})].flatMap((q)=>[q])],Z={root:Q.pkgDir,entrypoints:Object.values(I),outdir:k(Q.pkgDir,V.outDir||"dist"),target:"bun",format:"esm",external:Y,minify:V.minify??!1,naming:{entry:"[name].mjs",chunk:"_chunks/[name].mjs"},splitting:!0,metafile:!0,plugins:V.dts!==!1?[u()]:[],...V.bun};await H.bunConfig?.(Z,Q);let J=await Bun.build(Z);if(!J.success){console.error("Build failed:");for(let q of J.logs)if(q.level==="error")console.error(`  ${q.message}`);throw Error("Build failed")}await H.bunOutput?.(Z,Q);let $=[];for(let[q,K]of Object.entries(J.metafile.outputs)){if(!K.entryPoint)continue;if(q.endsWith(".ts"))continue;let X=q.replace(`${Z.outdir}${x("path").sep}`,""),O=K.exports||[],C=(K.imports||[]).filter((R)=>!R.path.startsWith(".")).map((R)=>R.path).sort();$.push({name:X,exports:O,deps:C,size:K.bytes,minSize:K.bytes,minGzipSize:K.bytes,sideEffectSize:K.bytes})}console.log(`
+${$.map((q)=>`[bundle] ${_(M(Z.outdir,q.name),Q.pkgDir)}
+Size: ${U(q.size)}, ${U(q.minSize)} minified, ${U(q.minGzipSize)} min+gzipped (Side effects: ${U(q.sideEffectSize)})
+${q.exports.some((K)=>K!=="default")?`Exports: ${q.exports.join(", ")}
+`:""}${q.deps.length>0?`Dependencies: ${q.deps.join(", ")}`:""}`).join(`
+
+`)}`)}function c(Q,V){let H={};for(let I of Array.isArray(Q)?Q:[Q]){if(!I.startsWith("/"))I=k(V.pkgDir,I);let Y=L(M(V.pkgDir,"src"),I);if(Y.startsWith(".."))Y=L(M(V.pkgDir),I);if(Y.startsWith(".."))throw Error(`Source should be within the package directory (${V.pkgDir}): ${I}`);let Z=M(F(Y),m(Y,p(Y)));if(H[Z])throw Error(`Rename one of the entries to avoid a conflict in the dist name "${Z}":
+ - ${I}
+ - ${H[Z]}`);H[Z]=I}return H}import{mkdir as g,symlink as h,chmod as S}from"fs/promises";import{dirname as j,extname as y,join as T,relative as l}from"path";var{Glob:o}=globalThis.Bun;var v=/^#![^\n]*/;async function b(Q,V){let H=[],I=new o("**/*.*");for await(let $ of I.scan(V.input)){if(V.filter&&await V.filter($)===!1)continue;H.push((async()=>{let q=T(V.input,$);switch(y(q)){case".ts":{let X=T(V.outDir,$.replace(/\.ts$/,".mjs")),O=await s(q,V,X);if(await g(j(X),{recursive:!0}),await Bun.write(X,O),v.test(O))await S(X,493);return X}default:{let X=T(V.outDir,$);if(await g(j(X),{recursive:!0}),V.stub)await h(q,X,"junction").catch(()=>{});else{let O=await Bun.file(q).text();if(await Bun.write(X,O),v.test(O))await S(X,493)}return X}}})())}let Y=await Promise.allSettled(H),Z=Y.filter(($)=>$.status==="rejected").map(($)=>$.reason);if(Z.length>0){let $=[],q=[];for(let K of Z.flatMap((X)=>Array.isArray(X.cause)?X.cause:[X]))if(K.message?.includes("--isolatedDeclarations"))$.push(K);else q.push(K);for(let K of q)console.error(K);for(let K of $)console.warn(K);if(q.length>0)throw Error(`Errors while transforming ${V.input}`)}let J=Y.filter(($)=>$.status==="fulfilled").map(($)=>$.value);console.log(`
+[transform] ${_(V.outDir+"/")}${V.stub?" (stub)":""}
+${a(J.map(($)=>_($)))}`)}function a(Q,V=process.stdout.columns||80){if(Q.length===0)return"";let I=Math.max(...Q.map((J)=>J.length))+2,Y=Math.max(1,Math.floor(V/I)),Z=[];for(let J=0;J<Q.length;J+=Y){let $=Q.slice(J,J+Y);Z.push($.map((q)=>q.padEnd(I)).join(""))}return Z.join(`
+`)}async function s(Q,V,H){let I=await Bun.file(Q).text();if(V.stub){let q=new Bun.Transpiler({loader:"ts"}).scan(I).exports.includes("default"),K=l(j(H),Q);return K=K.replace(/\\/g,"/"),`export * from "${K}";${q?`
+export { default } from "${K}";`:""}`}let Y={loader:V.transpiler?.loader||"ts",target:V.transpiler?.target||"bun",tsconfig:V.transpiler?.tsconfig};return new Bun.Transpiler(Y).transformSync(I)}import qq from"pretty-bytes";async function Bq(Q){let V=Date.now(),H=A(Q.cwd),Y={pkg:await Kq(r(H,"package.json")).catch(()=>({})),pkgDir:H};console.log(`Building \`${Y.pkg.name||"<no name>"}\` (\`${Y.pkgDir}\`)`);let Z=Q.hooks||{};await Z.start?.(Y);let J=(Q.entries||[]).map((q)=>{let K;if(typeof q==="string"){let[X,O]=q.split(":");K=X.endsWith("/")?{type:"transform",input:X,outDir:O}:{type:"bundle",input:X.split(","),outDir:O}}else K=q;if(!K.input)throw Error(`Build entry missing \`input\`: ${JSON.stringify(K,null,2)}`);return K={...K},K.outDir=A(K.outDir||"dist",H),K.input=Array.isArray(K.input)?K.input.map((X)=>A(X,H)):A(K.input,H),K});await Z.entries?.(J,Y);let $=[];for(let q of J.map((K)=>K.outDir).sort((K,X)=>(K??"").localeCompare(X??"")))if(!$.some((K)=>q.startsWith(K)))$.push(q);for(let q of $)console.log(`Cleaning up \`${_(q)}\``),await t(q,{recursive:!0,force:!0});for(let q of J)await(q.type==="bundle"?E(Y,q,Z):b(Y,q));if(await Z.end?.(Y),!J.every((q)=>q.stub)){let q=W($);console.log(`
+\u03A3 Total dist byte size: ${qq(q.size)} (${q.files} files)`)}console.log(`
+build finished in ${Date.now()-V}ms`)}function A(Q,V){return typeof Q==="string"&&D(Q)?Q:Q instanceof URL?n(Q):e(V||".",Q||".")}function Kq(Q){return import(D(Q)?i(Q).href:Q,{with:{type:"json"}}).then((H)=>H.default)}
+export{_ as a,W as b,Bq as c};

package/dist/build.d.ts

@@ -0,0 +1,5 @@
+import type { BuildConfig } from "./types";
+/**
+* Build dist/ from src/
+*/
+export declare function build(config: BuildConfig): Promise<void>;

package/dist/builders/bundle.d.ts

@@ -0,0 +1,3 @@
+import type { BuildContext, BuildHooks, BundleEntry } from "../types";
+export declare function bunBuild(ctx: BuildContext, entry: BundleEntry, hooks: BuildHooks): Promise<void>;
+export declare function normalizeBundleInputs(input: string | string[], ctx: BuildContext): Record<string, string>;

package/dist/builders/transform.d.ts

@@ -0,0 +1,5 @@
+import type { BuildContext, TransformEntry } from "../types";
+/**
+* Transform all .ts modules in a directory using Bun.Transpiler.
+*/
+export declare function transformDir(ctx: BuildContext, entry: TransformEntry): Promise<void>;

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+// @bun
+import{c as d}from"./_chunks/index.mjs";import{defineCommand as u,runMain as l}from"citty";import{loadConfig as p}from"c12";var c=u({meta:{name:"build",version:"0.0.0",description:"Build your project with Bun"},args:{dir:{type:"string",description:"Project root directory",default:"."},stub:{type:"boolean",description:"Generate stub builds (re-export source files)",default:!1},entries:{type:"positional",description:"Build entries (e.g., src/index.ts or src/)",required:!1}},async run({args:i}){let{config:r={}}=await p({name:"build",configFile:"build.config",cwd:i.dir}),n=i.entries?Array.isArray(i.entries)?i.entries:[i.entries]:r.entries||[],o=n.map((e)=>{if(typeof e==="string"){let[t,s]=e.split(":");return t.endsWith("/")?{type:"transform",input:t,outDir:s}:{type:"bundle",input:t.split(","),outDir:s}}return e});if(i.stub)for(let e of o)e.stub=!0;if(n.length===0)console.error("No build entries specified."),process.exit(1);await d({cwd:i.dir,...r,entries:o})}});l(c);

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./build";
+export * from "./types";
+export * from "./utils";

package/dist/index.mjs

@@ -0,0 +1,2 @@
+// @bun
+import{a as g,b as j,c as k}from"./_chunks/index.mjs";export{g as fmtPath,k as build,j as analyzeDir};

package/dist/types.d.ts

@@ -0,0 +1,80 @@
+import type { BuildConfig as BunBuildOptions, TranspilerOptions } from "bun";
+export interface BuildContext {
+	pkgDir: string;
+	pkg: {
+		name: string;
+	} & Record<string, unknown>;
+}
+export type _BuildEntry = {
+	/**
+	* Output directory relative to project root.
+	*
+	* Defaults to `dist/` if not provided.
+	*/
+	outDir?: string;
+	/**
+	* Avoid actual build but instead link to the source files.
+	*/
+	stub?: boolean;
+};
+export type BundleEntry = _BuildEntry & {
+	type: "bundle";
+	/**
+	* Entry point(s) to bundle relative to the project root.
+	* */
+	input: string | string[];
+	/**
+	* Minify the output using Bun.
+	*
+	* Defaults to `false` if not provided.
+	*/
+	minify?: boolean | {
+		whitespace?: boolean;
+		syntax?: boolean;
+		identifiers?: boolean;
+	};
+	/**
+	* Options passed to Bun.build.
+	*
+	* See [Bun.build options](https://bun.sh/docs/bundler) for more details.
+	*/
+	bun?: Partial<BunBuildOptions>;
+	/**
+	* Declaration generation options.
+	*
+	* Set to `false` to disable.
+	*/
+	dts?: boolean;
+};
+export type TransformEntry = _BuildEntry & {
+	type: "transform";
+	/**
+	* Directory to transform relative to the project root.
+	*/
+	input: string;
+	/**
+	* Options passed to Bun.Transpiler.
+	*/
+	transpiler?: Partial<TranspilerOptions>;
+	/**
+	* A filter function to exclude files from being transformed.
+	*/
+	filter?: (filePath: string) => boolean | Promise<boolean>;
+	/**
+	* If sets to `false`, or if the function returns `false`, declaration files won't be emitted for the module.
+	*/
+	dts?: boolean | ((filePath: string) => boolean | Promise<boolean>);
+};
+export type BuildEntry = BundleEntry | TransformEntry;
+export interface BuildHooks {
+	start?: (ctx: BuildContext) => void | Promise<void>;
+	end?: (ctx: BuildContext) => void | Promise<void>;
+	entries?: (entries: BuildEntry[], ctx: BuildContext) => void | Promise<void>;
+	bunConfig?: (cfg: BunBuildOptions, ctx: BuildContext) => void | Promise<void>;
+	bunOutput?: (cfg: BunBuildOptions, ctx: BuildContext) => void | Promise<void>;
+}
+export interface BuildConfig {
+	cwd?: string | URL;
+	entries?: (BuildEntry | string)[];
+	hooks?: BuildHooks;
+}

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function fmtPath(path: string, cwd?: string): string;
+export declare function analyzeDir(dir: string | string[]): {
+	size: number;
+	files: number;
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@bunit/build",
+  "version": "0.0.0",
+  "description": "A blazing-fast build tool powered by Bun for TypeScript libraries with flexible bundling and transformation modes",
+  "keywords": [
+    "build",
+    "bun",
+    "bundle",
+    "bundler",
+    "library",
+    "package",
+    "tooling",
+    "transform",
+    "typescript"
+  ],
+  "homepage": "https://github.com/DemoMacro/BunIt#readme",
+  "bugs": {
+    "url": "https://github.com/DemoMacro/BunIt/issues"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Demo Macro",
+    "email": "abc@imst.xyz",
+    "url": "https://www.demomacro.com/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DemoMacro/BunIt.git"
+  },
+  "bin": {
+    "built": "dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "scripts": {
+    "dev": "bun run src/cli.ts --stub",
+    "build": "bun run src/cli.ts",
+    "prepack": "bun run build"
+  },
+  "dependencies": {
+    "c12": "4.0.0-beta.3",
+    "citty": "0.2.1",
+    "pretty-bytes": "7.1.0",
+    "unplugin-isolated-decl": "0.15.7"
+  },
+  "devDependencies": {}
+}