@hypernym/bundler 0.1.0

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Ivo Dolenc, Hypernym Studio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,100 @@
+# Bundler
+
+ESM & TS module bundler.
+
+<sub><a href="https://github.com/hypernym-studio/bundler">Repository</a> | <a href="https://www.npmjs.com/package/@hypernym/bundler">Package</a> | <a href="https://github.com/hypernym-studio/bundler/releases">Releases</a> | <a href="https://github.com/hypernym-studio/bundler/discussions">Discussions</a></sub>
+
+```sh
+npm i -D @hypernym/bundler
+```
+
+## Features
+
+- Powered by Rollup
+- Allows advanced customization
+- Provides a powerful hooking system
+- Exports fully optimized code
+- Follows modern practice
+- Super easy to use
+
+## Quick Start
+
+1. Create a `bundler.config.ts` file at the root of your project:
+
+> **Note**
+> Configuration also accepts `.js`, `.mjs`, `.ts`, `.mts` formats.
+
+```ts
+// bundler.config.ts
+
+import { defineConfig } from '@hypernym/bundler'
+
+export default defineConfig({
+  // ...
+})
+```
+
+2. Specify the bundle's entry points:
+
+```ts
+// bundler.config.ts
+
+import { defineConfig } from '@hypernym/bundler'
+
+export default defineConfig({
+  entries: [
+    { input: './src/index.ts' },
+    { types: './src/types/index.ts' },
+    {
+      input: './src/utils/index.ts',
+      plugins: {
+        esbuild: { minify: true },
+      },
+    },
+    // ...
+  ],
+})
+```
+
+3. Build via command:
+
+```sh
+npx hyperbundler
+```
+
+## Options
+
+### outDir
+
+- Type: `string`
+- Default: `dist`
+
+Specifies the output directory for production bundle.
+
+```ts
+// bundler.config.ts
+
+export default defineConfig({
+  outDir: 'output',
+})
+```
+
+### Custom Config
+
+Set a custom config path via the CLI command:
+
+```sh
+npx hyperbundler --config my.config.js
+```
+
+## Community
+
+Feel free to use the official [discussions](https://github.com/hypernym-studio/bundler/discussions) for any additional questions.
+
+## License
+
+Developed in 🇭🇷 Croatia
+
+Released under the [MIT](LICENSE.txt) license.
+
+© Hypernym Studio

package/dist/bin/index.mjs

@@ -0,0 +1,388 @@
+#!/usr/bin/env node
+import process, { stdout, cwd } from 'node:process';
+import { createArgs } from '@hypernym/args';
+import { readFile, stat } from 'node:fs/promises';
+import { resolve, parse } from 'node:path';
+import { exists } from '@hypernym/utils/node';
+import { dim, magenta, red, cyan, green } from '@hypernym/colors';
+import { build as build$1, transform } from 'esbuild';
+import { createSpinner } from '@hypernym/spinner';
+import { isObject } from '@hypernym/utils';
+import { rollup } from 'rollup';
+import { getLogFilter } from 'rollup/getLogFilter';
+import _replace from '@rollup/plugin-replace';
+import _json from '@rollup/plugin-json';
+import _resolve from '@rollup/plugin-node-resolve';
+import { dts } from 'rollup-plugin-dts';
+import { createFilter } from '@rollup/pluginutils';
+
+const externals = [
+  /^node:/,
+  /^@types/,
+  /^@rollup/,
+  /^@hypernym/,
+  /^rollup/
+];
+
+const name = "bundler";
+const version = `0.1.0`;
+
+const cl = console.log;
+const log = (...args) => {
+  let length = args.length + 2;
+  const cols = stdout.columns || 80;
+  const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+  for (const arg of args) {
+    length = length + arg.replace(/\u001b\[.*?m/g, "").length;
+  }
+  const repeatLength = cols <= length + time.length ? 0 : cols - (length + time.length);
+  return cl(...args, " ".repeat(repeatLength), dim(time));
+};
+const logger = {
+  exit: (message) => {
+    cl();
+    log(dim(name), dim(version));
+    log(magenta(name), message);
+    cl();
+    return process.exit(1);
+  }
+};
+
+function error(err) {
+  log(red(name), "Something went wrong...");
+  console.error(err);
+  return process.exit(1);
+}
+
+function formatMs(ms) {
+  const s = 1e3;
+  const m = s * 60;
+  const h = m * 60;
+  const msAbs = Math.abs(ms);
+  if (msAbs >= h)
+    return `${(ms / h).toFixed(2)}h`;
+  if (msAbs >= m)
+    return `${(ms / m).toFixed(2)}m`;
+  if (msAbs >= s)
+    return `${(ms / s).toFixed(2)}s`;
+  return `${ms}ms`;
+}
+
+function formatBytes(bytes) {
+  const decimals = 2;
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  if (bytes === 0)
+    return `0 B`;
+  const k = 1024;
+  const dm = decimals;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${units[i]}`;
+}
+
+function getOutputPath(outDir, input, types = false) {
+  const _input = input.startsWith("./") ? input.slice(2) : input;
+  let output = _input.replace(_input.split("/")[0], outDir);
+  const ts = types ? "d.ts" : "mjs";
+  const mts = types ? "d.mts" : "mjs";
+  const cts = types ? "d.cts" : "cjs";
+  if (output.endsWith(".ts"))
+    output = `${output.slice(0, -2)}${ts}`;
+  if (output.endsWith(".mts"))
+    output = `${output.slice(0, -3)}${mts}`;
+  if (output.endsWith(".cts"))
+    output = `${output.slice(0, -3)}${cts}`;
+  if (outDir.startsWith("./") || outDir.startsWith("../"))
+    return output;
+  return `./${output}`;
+}
+
+async function loadConfig(filePath, defaults) {
+  const result = await build$1({
+    entryPoints: [filePath],
+    bundle: true,
+    write: false,
+    format: "esm",
+    target: "esnext",
+    packages: "external"
+  });
+  const code = result.outputFiles[0].text;
+  const buffer = Buffer.from(code).toString("base64");
+  const content = await import(`data:text/javascript;base64,${buffer}`);
+  const config = {
+    ...defaults,
+    ...content.default
+  };
+  return config;
+}
+async function createConfigLoader(cwd, args) {
+  const pkgPath = resolve(cwd, "package.json");
+  const pkg = await readFile(pkgPath, "utf-8").catch(error);
+  const { dependencies } = JSON.parse(pkg);
+  const warnMessage = `Missing required configuration. To start bundling, add the ${cyan(
+    `'bundler.config.{js,mjs,ts,mts}'`
+  )} file to the project's root.`;
+  const defaults = {
+    externals: [...Object.keys(dependencies || {}), ...externals],
+    entries: []
+  };
+  if (args.config) {
+    const path = resolve(cwd, args.config);
+    const isConfig = await exists(path);
+    if (isConfig)
+      return await loadConfig(path, defaults);
+    else
+      return logger.exit(warnMessage);
+  }
+  const configName = "bundler.config";
+  const configExts = [".ts", ".js", ".mts", ".mjs"];
+  for (const ext of configExts) {
+    const path = resolve(cwd, `${configName}${ext}`);
+    const isConfig = await exists(path);
+    if (isConfig)
+      return await loadConfig(path, defaults);
+  }
+  return logger.exit(warnMessage);
+}
+
+function esbuild(options) {
+  const isJs = /\.(?:[mc]?js|jsx)$/;
+  const filter = createFilter(/\.([cm]?ts|[jt]sx)$/);
+  return {
+    name: "esbuild",
+    resolveId(id, importer, options2) {
+      if (isJs.test(id) && importer) {
+        return this.resolve(id.replace(/js(x?)$/, "ts$1"), importer, options2);
+      }
+      return null;
+    },
+    async transform(code, id) {
+      if (!filter(id))
+        return null;
+      const result = await transform(code, {
+        loader: "default",
+        ...options,
+        sourcefile: id.replace(/\.[cm]ts/, ".ts")
+      });
+      return {
+        code: result.code,
+        map: result.map || null
+      };
+    },
+    async renderChunk(code, { fileName }) {
+      if (!options?.minify)
+        return null;
+      if (/\.d\.(c|m)?tsx?$/.test(fileName))
+        return null;
+      const result = await transform(code, {
+        ...options,
+        sourcefile: fileName,
+        minify: true
+      });
+      return {
+        code: result.code,
+        map: result.map || null
+      };
+    }
+  };
+}
+
+const replacePlugin = _replace.default ?? _replace;
+const jsonPlugin = _json.default ?? _json;
+const resolvePlugin = _resolve.default ?? _resolve;
+async function build(cwd, options) {
+  const { outDir = "dist", hooks } = options;
+  let start = 0;
+  const buildStats = {
+    cwd,
+    size: 0,
+    buildTime: 0,
+    files: []
+  };
+  if (hooks?.["build:before"])
+    await hooks["build:before"](options);
+  if (options.entries) {
+    start = Date.now();
+    for (const entry of options.entries) {
+      const entryStart = Date.now();
+      const logFilter = getLogFilter(entry.logFilter || []);
+      if ("input" in entry) {
+        const { input, externals, plugins, banner, footer } = entry;
+        const buildLogs = [];
+        const _output = getOutputPath(outDir, input);
+        let _format = "esm";
+        if (_output.endsWith(".cjs"))
+          _format = "cjs";
+        const output = entry.output || _output;
+        const format = entry.format || _format;
+        const defaultPlugins = [esbuild(plugins?.esbuild)];
+        if (plugins?.json) {
+          const jsonOptions = isObject(plugins.json) ? plugins.json : void 0;
+          defaultPlugins.push(jsonPlugin(jsonOptions));
+        }
+        if (plugins?.replace) {
+          defaultPlugins.unshift(
+            replacePlugin({
+              true: true,
+              ...plugins.replace
+            })
+          );
+        }
+        if (plugins?.resolve) {
+          const resolveOptions = isObject(plugins.resolve) ? plugins.resolve : void 0;
+          defaultPlugins.unshift(resolvePlugin(resolveOptions));
+        }
+        const builder = await rollup({
+          input: resolve(cwd, input),
+          external: externals || options.externals,
+          plugins: defaultPlugins,
+          onLog: (level, log) => {
+            if (logFilter(log))
+              buildLogs.push({ level, log });
+          }
+        });
+        await builder.write({
+          file: resolve(cwd, output),
+          format,
+          banner,
+          footer
+        });
+        const stats = await stat(resolve(cwd, output));
+        buildStats.files.push({
+          path: output,
+          size: stats.size,
+          buildTime: Date.now() - entryStart,
+          format,
+          logs: buildLogs
+        });
+        buildStats.size = buildStats.size + stats.size;
+      }
+      if ("types" in entry) {
+        const { types, plugins } = entry;
+        const buildLogs = [];
+        const _output = getOutputPath(outDir, types, true);
+        let _format = "esm";
+        if (_output.endsWith(".d.cts"))
+          _format = "cjs";
+        const output = entry.output || _output;
+        const format = entry.format || _format;
+        const builder = await rollup({
+          input: resolve(cwd, types),
+          plugins: [dts(plugins?.dts)],
+          onLog: (level, log) => {
+            if (logFilter(log))
+              buildLogs.push({ level, log });
+          }
+        });
+        await builder.write({
+          file: resolve(cwd, output),
+          format
+        });
+        const stats = await stat(resolve(cwd, output));
+        buildStats.files.push({
+          path: output,
+          size: stats.size,
+          buildTime: Date.now() - entryStart,
+          format,
+          logs: buildLogs
+        });
+        buildStats.size = buildStats.size + stats.size;
+      }
+    }
+    buildStats.buildTime = Date.now() - start;
+  }
+  if (hooks?.["build:done"])
+    await hooks["build:done"](options);
+  return buildStats;
+}
+
+async function createBuilder(cwd, args, options) {
+  const spinner = createSpinner();
+  cl();
+  log(dim(name), dim(version));
+  log(cyan(name), `Bundling started...`);
+  spinner.start({
+    message: `Transforming modules ${green("for production...")}`
+  });
+  return await build(cwd, options).then((stats) => {
+    spinner.stop({
+      message: `Modules transformation is ${green("done!")}`,
+      template: (mark, message) => {
+        const temp = `${mark}${message}`;
+        const cols = stdout.columns || 80;
+        const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+        const length = (
+          // eslint-disable-next-line no-control-regex
+          temp.replace(/\u001b\[.*?m/g, "").length + time.length + 1
+        );
+        const repeatLength = cols <= length ? 0 : cols - length;
+        return temp + " ".repeat(repeatLength) + dim(time);
+      }
+    });
+    const check = green("\u2714");
+    const info = cyan("i");
+    const buildTime = green(formatMs(stats.buildTime));
+    const buildSize = green(formatBytes(stats.size));
+    const modules = green(stats.files.length);
+    const longestPath = Math.max(...stats.files.map((v) => v.path.length + 1));
+    const longestTime = Math.max(
+      ...stats.files.map((v) => formatMs(v.buildTime).length)
+    );
+    const longestSize = Math.max(
+      ...stats.files.map((v) => formatBytes(v.size).length)
+    );
+    log(check, `Bundling completed in ${buildTime}`);
+    log(check, `${modules} modules transformed. Total size is ${buildSize}`);
+    log(info, "Individual stats per module");
+    for (const file of stats.files) {
+      let format = file.format;
+      const base = parse(file.path).base;
+      const path = file.path.replace(base, "");
+      if (format.includes("system"))
+        format = "sys";
+      if (format === "commonjs")
+        format = "cjs";
+      if (format === "module")
+        format = "esm";
+      if (base.includes(".d."))
+        format = "dts";
+      if (file.logs) {
+        for (const log2 of file.logs) {
+          cl(magenta("!"), magenta(log2.log.message));
+        }
+      }
+      log(
+        info,
+        dim("\u251C\u2500"),
+        dim(path) + cyan(base),
+        " ".padEnd(longestPath - (path.length + base.length)),
+        dim(format.padStart(5)),
+        dim("\u2502"),
+        dim(formatMs(file.buildTime).padStart(longestTime)),
+        dim("\u2502"),
+        dim(formatBytes(file.size).padStart(longestSize))
+      );
+    }
+    log(
+      check,
+      `Bundle is now fully generated and ready ${green("for production!")}`
+    );
+  }).catch((err) => {
+    spinner.stop({
+      mark: red("\u2716"),
+      message: `Modules transformation is ${red("interupted!")}`
+    });
+    log(red(name), "Something went wrong...");
+    console.error(err);
+    return process.exit(1);
+  });
+}
+
+async function main() {
+  const cwd$1 = cwd();
+  const args = createArgs({
+    alias: { config: "c" }
+  });
+  const config = await createConfigLoader(cwd$1, args);
+  await createBuilder(cwd$1, args, config);
+}
+main().catch(error);

package/dist/index.mjs

@@ -0,0 +1,12 @@
+const externals = [
+  /^node:/,
+  /^@types/,
+  /^@rollup/,
+  /^@hypernym/,
+  /^rollup/
+];
+function defineConfig(options) {
+  return options;
+}
+
+export { defineConfig, externals };

package/dist/types/index.d.ts

@@ -0,0 +1,76 @@
+import { OutputOptions } from 'rollup';
+import { RollupReplaceOptions } from '@rollup/plugin-replace';
+import { RollupJsonOptions } from '@rollup/plugin-json';
+import { RollupNodeResolveOptions } from '@rollup/plugin-node-resolve';
+import { TransformOptions } from 'esbuild';
+import { Options as Options$1 } from 'rollup-plugin-dts';
+
+interface BuildPlugins {
+    esbuild?: TransformOptions;
+    dts?: Options$1;
+    resolve?: RollupNodeResolveOptions | true;
+    json?: RollupJsonOptions | true;
+    replace?: RollupReplaceOptions;
+}
+
+interface Entries {
+    output?: string;
+    format?: OutputOptions['format'];
+    externals?: (string | RegExp)[];
+    logFilter?: string[];
+}
+interface EntriesInput extends Entries {
+    input: string;
+    banner?: OutputOptions['banner'];
+    footer?: OutputOptions['footer'];
+    plugins?: BuildPlugins;
+}
+interface EntriesTypes extends Entries {
+    types: string;
+    plugins?: Pick<BuildPlugins, 'dts'>;
+}
+type EntriesOptions = EntriesInput | EntriesTypes;
+
+interface BuildHooks {
+    /**
+     * Called just before bundling started.
+     */
+    'build:before'?: (options?: Options) => void | Promise<void>;
+    /**
+     * Called right after bundling is complete.
+     */
+    'build:done'?: (options?: Options) => void | Promise<void>;
+}
+
+interface Options {
+    /**
+     * Specifies the bundle's entry points.
+     *
+     * It allows you to manually set all build entries and adjust options for each one individually.
+     */
+    entries: EntriesOptions[];
+    /**
+     * Specifies the output directory for production bundle.
+     *
+     * @default 'dist'
+     */
+    outDir?: string;
+    /**
+     * Specifies the module IDs, or regular expressions to match module IDs,
+     * that should remain external to the bundle.
+     *
+     * @default [/^node:/, /^@types/, /^@rollup/, /^@hypernym/, /^rollup/, ...pkg.dependencies]
+     */
+    externals?: (string | RegExp)[];
+    /**
+     * Provides a powerful hooking system to further expand build mode.
+     *
+     * @default undefined
+     */
+    hooks?: BuildHooks;
+}
+
+declare const externals: RegExp[];
+declare function defineConfig(options: Options): Options;
+
+export { defineConfig, externals };

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@hypernym/bundler",
+  "version": "0.1.0",
+  "author": "Hypernym Studio",
+  "description": "ESM & TS module bundler.",
+  "license": "MIT",
+  "repository": "hypernym-studio/bundler",
+  "homepage": "https://github.com/hypernym-studio/bundler",
+  "funding": "https://github.com/sponsors/ivodolenc",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "module",
+    "modules",
+    "bundling",
+    "javascript",
+    "typescript",
+    "bundler",
+    "builder",
+    "package",
+    "bundle",
+    "types",
+    "build",
+    "esm",
+    "dts"
+  ],
+  "bin": {
+    "hyperbundler": "./dist/bin/index.mjs"
+  },
+  "scripts": {
+    "build": "tsx src/bin/index.ts",
+    "lint": "ESLINT_USE_FLAT_CONFIG=true eslint -c .config/eslint.config.js .",
+    "lint:fix": "ESLINT_USE_FLAT_CONFIG=true eslint -c .config/eslint.config.js --fix .",
+    "format": "prettier --config .config/prettier.config.js --write .",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "@types/node": ">=20.0.0",
+    "typescript": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@types/node": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@hypernym/args": "^0.2.0",
+    "@hypernym/colors": "^1.0.0",
+    "@hypernym/spinner": "^0.1.0",
+    "@hypernym/utils": "^2.0.2",
+    "@rollup/plugin-json": "^6.0.1",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-replace": "^5.0.3",
+    "esbuild": "^0.19.4",
+    "rollup": "^4.0.2",
+    "rollup-plugin-dts": "^6.1.0"
+  },
+  "devDependencies": {
+    "@hypernym/eslint-config": "^2.0.1",
+    "@hypernym/prettier-config": "^2.0.1",
+    "@hypernym/tsconfig": "^1.1.0",
+    "@types/node": "^20.8.4",
+    "eslint": "^8.51.0",
+    "prettier": "^3.0.3",
+    "tsx": "^3.13.0",
+    "typescript": "^5.2.2"
+  },
+  "engines": {
+    "node": ">=v18.0.0"
+  }
+}