@hypernym/bundler 0.13.1 → 0.14.0

package/README.md

@@ -58,7 +58,7 @@ import { defineConfig } from '@hypernym/bundler'
 export default defineConfig({
   entries: [
     { input: './src/index.ts' },
-    { declaration: './src/types/index.ts' },
+    { dts: './src/types/index.ts' },
     {
       input: './src/utils/index.ts',
       output: './dist/utils/utils.min.mjs',
@@ -99,11 +99,34 @@ Set a custom config path via the CLI command:
 npx hyperbundler --config hyper.config.ts
 ```
 
-## Options
+## Formats
+
+During transformation, file formats are automatically resolved and in most cases there is no need for additional configuration.
+
+`Hyperbundler` module environment for generated files defaults to `esm`, which means the outputs will have a `.mjs` extension unless otherwise specified. For TypeScript declarations, the appropriate extension will be `.d.mts`.
+
+Formats can also be explicitly specified for each entry, if necessary.
+
+### Inputs
+
+Default transformation behaviour for all `chunk` entries:
+
+- `./srcDir/file.js` resolves to `./outDir/file.mjs`
+- `./srcDir/file.mjs` resolves to `./outDir/file.mjs`
+- `./srcDir/file.cjs` resolves to `./outDir/file.cjs`
+- `./srcDir/file.ts` resolves to `./outDir/file.mjs`
+- `./srcDir/file.mts` resolves to `./outDir/file.mjs`
+- `./srcDir/file.cts` resolves to `./outDir/file.cjs`
 
-All options are documented with descriptions and examples so auto-completion will be offered as you type.
+### Declarations
 
-Simply hover over the property and see what it does in the `quickinfo`.
+Default transformation behaviour for all `dts` entries:
+
+- `./srcDir/file.ts` resolves to `./outDir/file.d.mts`
+
+## Options
+
+All options are documented with descriptions and examples so auto-completion will be offered as you type. Simply hover over the property and see what it does in the `quickinfo`.
 
 ### entries
 
@@ -121,7 +144,7 @@ import { defineConfig } from '@hypernym/bundler'
 export default defineConfig({
   entries: [
     { input: './src/index.ts' }, // => './dist/index.mjs'
-    { declaration: './src/types.ts' }, // => './dist/types.d.ts'
+    { dts: './src/types.ts' }, // => './dist/types.d.mts'
     // ...
   ],
 })
@@ -140,9 +163,7 @@ import { defineConfig } from '@hypernym/bundler'
 
 export default defineConfig({
   entries: [
-    {
-      input: './src/index.ts', // => './dist/index.mjs'
-    },
+    { input: './src/index.ts' }, // => './dist/index.mjs'
   ],
 })
 ```
@@ -160,9 +181,19 @@ import { defineConfig } from '@hypernym/bundler'
 
 export default defineConfig({
   entries: [
-    {
-      { declaration: './src/types.ts' }, // => './dist/types.d.ts'
-    },
+    { declaration: './src/types.ts' }, // => './dist/types.d.mts'
+  ],
+})
+```
+
+Also, it is possible to use `dts` alias.
+
+```ts
+import { defineConfig } from '@hypernym/bundler'
+
+export default defineConfig({
+  entries: [
+    { dts: './src/types.ts' }, // => './dist/types.d.mts'
   ],
 })
 ```
@@ -373,7 +404,7 @@ export default defineConfig({
 
 ### build:entry:start
 
-- Type: `(options: BuildEntryOptions, stats: BuildStats) => void | Promise<void>`
+- Type: `(entry: BuildEntryOptions, stats: BuildEntryStats) => void | Promise<void>`
 - Default: `undefined`
 
 Called on each entry just before the build process.
@@ -388,12 +419,12 @@ import { plugin1, plugin2 } from './src/utils/plugins.js'
 
 export default defineConfig({
   hooks: {
-    'build:entry:start': async (options, stats) => {
+    'build:entry:start': async (entry, stats) => {
       // adds custom plugins for a specific entry only
-      if (options.input?.includes('./src/index.ts')) {
-        options.defaultPlugins = [
+      if (entry.input?.includes('./src/index.ts')) {
+        entry.defaultPlugins = [
           plugin1(), // adds a custom plugin before the default bundler plugins
-          ...options.defaultPlugins, // list of default bundler plugins
+          ...entry.defaultPlugins, // list of default bundler plugins
           plugin2(), // adds a custom plugin after the default bundler plugins
         ]
       }
@@ -404,7 +435,7 @@ export default defineConfig({
 
 ### build:entry:end
 
-- Type: `(options: BuildEntryOptions, stats: BuildStats) => void | Promise<void>`
+- Type: `(entry: BuildEntryOptions, stats: BuildEntryStats) => void | Promise<void>`
 - Default: `undefined`
 
 Called on each entry right after the build process is completed.
@@ -416,7 +447,7 @@ import { defineConfig } from '@hypernym/bundler'
 
 export default defineConfig({
   hooks: {
-    'build:entry:end': async (options, stats) => {
+    'build:entry:end': async (entry, stats) => {
       // ...
     },
   },

package/dist/bin/index.mjs

@@ -25,7 +25,7 @@ const externals = [
 ];
 
 const logo = `\u2726\u2726`;
-const version = `0.13.1`;
+const version = `0.14.0`;
 
 const cl = console.log;
 const separator = `/`;
@@ -73,37 +73,33 @@ function formatBytes(bytes) {
   return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${units[i]}`;
 }
 
-function getOutputPath(outDir, input, types = false) {
+function getOutputPath(outDir, input, dts) {
   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}`;
+  const ext = dts ? "d.mts" : "mjs";
+  const cts = dts ? "d.cts" : "cjs";
+  if (output.endsWith(".js")) output = `${output.slice(0, -2)}${ext}`;
+  else if (output.endsWith(".ts")) output = `${output.slice(0, -2)}${ext}`;
+  else if (output.endsWith(".mts")) output = `${output.slice(0, -3)}${ext}`;
+  else if (output.endsWith(".cts")) output = `${output.slice(0, -3)}${cts}`;
   if (outDir.startsWith("./") || outDir.startsWith("../")) return output;
-  return `./${output}`;
+  else return `./${output}`;
 }
 
 function getLongestOutput(outDir, entries) {
   const outputs = [];
   for (const entry of entries) {
-    if ("copy" in entry && entry.copy) {
-      const out = entry.copy.output;
-      outputs.push(out);
-    }
-    if ("input" in entry && entry.input) {
+    if (entry.copy) outputs.push(entry.copy.output);
+    if (entry.input) {
       const out = entry.output || getOutputPath(outDir, entry.input);
       outputs.push(out);
     }
-    if ("declaration" in entry && entry.declaration) {
-      const out = entry.output || getOutputPath(outDir, entry.declaration, true);
+    if (entry.declaration || entry.dts) {
+      const dts = entry.declaration || entry.dts;
+      const out = entry.output || getOutputPath(outDir, dts, true);
       outputs.push(out);
     }
-    if ("template" in entry && entry.template) {
-      outputs.push(entry.output);
-    }
+    if (entry.template) outputs.push(entry.output);
   }
   return Math.max(...outputs.map((v) => v.length));
 }
@@ -301,6 +297,7 @@ async function build(cwd, options) {
             else return `./${path}`;
           };
           const fileStats = {
+            cwd,
             path: `${parseOutput(_entry.output)}/${parseInput(copyInput)}`,
             size: totalSize,
             buildTime: Date.now() - entryStart,
@@ -314,31 +311,22 @@ async function build(cwd, options) {
       }
       if (entry.input) {
         const logFilter = getLogFilter(entry.logFilter || []);
-        const _output = getOutputPath(outDir, entry.input);
+        const _output = entry.output || getOutputPath(outDir, entry.input);
         let _format = "esm";
         if (_output.endsWith(".cjs")) _format = "cjs";
         const buildLogs = [];
         const _entry = {
           input: entry.input,
-          output: entry.output || _output,
+          output: _output,
           externals: entry.externals || options.externals,
           format: entry.format || _format,
-          transformers: entry.transformers,
+          ...entry,
           defaultPlugins: [
             esbuild({
               minify: !isUndefined(entry.minify) ? entry.minify : options.minify,
               ...entry.transformers?.esbuild
             })
-          ],
-          plugins: entry.plugins,
-          banner: entry.banner,
-          footer: entry.footer,
-          intro: entry.intro,
-          outro: entry.outro,
-          paths: entry.paths,
-          name: entry.name,
-          globals: entry.globals,
-          extend: entry.extend
+          ]
         };
         if (!entry.plugins) {
           if (_entry.transformers?.json) {
@@ -348,7 +336,7 @@ async function build(cwd, options) {
           if (_entry.transformers?.replace) {
             _entry.defaultPlugins.unshift(
               replacePlugin({
-                true: true,
+                preventAssignment: true,
                 ..._entry.transformers.replace
               })
             );
@@ -361,7 +349,15 @@ async function build(cwd, options) {
             aliasPlugin(_entry.transformers?.alias || aliasOptions)
           );
         }
-        await hooks?.["build:entry:start"]?.(_entry, buildStats);
+        const fileStats = {
+          cwd,
+          path: _entry.output,
+          size: 0,
+          buildTime: entryStart,
+          format: _entry.format,
+          logs: buildLogs
+        };
+        await hooks?.["build:entry:start"]?.(_entry, fileStats);
         const _build = await rollup({
           input: resolve(cwd, _entry.input),
           external: _entry.externals,
@@ -383,46 +379,42 @@ async function build(cwd, options) {
           extend: _entry.extend
         });
         const stats = await stat(resolve(cwd, _entry.output));
-        const file = {
-          path: _entry.output,
-          size: stats.size,
-          buildTime: Date.now() - entryStart,
-          format: _entry.format,
-          logs: buildLogs
-        };
-        buildStats.files.push(file);
+        fileStats.size = stats.size;
+        fileStats.buildTime = Date.now() - entryStart;
+        fileStats.logs = buildLogs;
+        buildStats.files.push(fileStats);
         buildStats.size = buildStats.size + stats.size;
-        logModuleStats(file, longestOutput);
-        await hooks?.["build:entry:end"]?.(_entry, buildStats);
+        logModuleStats(fileStats, longestOutput);
+        await hooks?.["build:entry:end"]?.(_entry, fileStats);
       }
-      if (entry.declaration) {
+      if (entry.dts || entry.declaration) {
         const logFilter = getLogFilter(entry.logFilter || []);
-        const _output = getOutputPath(outDir, entry.declaration, true);
-        let _format = "esm";
-        if (_output.endsWith(".d.cts")) _format = "cjs";
         const buildLogs = [];
+        const dts$1 = entry.dts || entry.declaration;
         const _entry = {
-          input: entry.declaration,
-          output: entry.output || _output,
+          dts: dts$1,
+          output: entry.output || getOutputPath(outDir, dts$1, true),
           externals: entry.externals || options.externals,
-          format: entry.format || _format,
-          transformers: entry.transformers,
-          defaultPlugins: [dts(entry.transformers?.dts)],
-          plugins: entry.plugins,
-          banner: entry.banner,
-          footer: entry.footer,
-          intro: entry.intro,
-          outro: entry.outro,
-          paths: entry.paths
+          format: entry.format || "esm",
+          ...entry,
+          defaultPlugins: [dts(entry.transformers?.dts)]
         };
         if (!entry.plugins) {
           _entry.defaultPlugins.unshift(
             aliasPlugin(_entry.transformers?.alias || aliasOptions)
           );
         }
-        await hooks?.["build:entry:start"]?.(_entry, buildStats);
+        const fileStats = {
+          cwd,
+          path: _entry.output,
+          size: 0,
+          buildTime: entryStart,
+          format: "dts",
+          logs: buildLogs
+        };
+        await hooks?.["build:entry:start"]?.(_entry, fileStats);
         const _build = await rollup({
-          input: resolve(cwd, _entry.input),
+          input: resolve(cwd, _entry.dts),
           external: _entry.externals,
           plugins: _entry.plugins || _entry.defaultPlugins,
           onLog: (level, log) => {
@@ -439,28 +431,21 @@ async function build(cwd, options) {
           paths: _entry.paths
         });
         const stats = await stat(resolve(cwd, _entry.output));
-        const fileStats = {
-          path: _entry.output,
-          size: stats.size,
-          buildTime: Date.now() - entryStart,
-          format: "dts",
-          logs: buildLogs
-        };
+        fileStats.size = stats.size;
+        fileStats.buildTime = Date.now() - entryStart;
+        fileStats.logs = buildLogs;
         buildStats.files.push(fileStats);
         buildStats.size = buildStats.size + stats.size;
         logModuleStats(fileStats, longestOutput);
-        await hooks?.["build:entry:end"]?.(_entry, buildStats);
+        await hooks?.["build:entry:end"]?.(_entry, fileStats);
       }
       if (entry.template && entry.output) {
         const buildLogs = [];
-        const _entry = {
-          template: entry.template,
-          output: entry.output
-        };
-        await write(_entry.output, _entry.template);
-        const stats = await stat(resolve(cwd, _entry.output));
+        await write(entry.output, entry.template);
+        const stats = await stat(resolve(cwd, entry.output));
         const fileStats = {
-          path: _entry.output,
+          cwd,
+          path: entry.output,
           size: stats.size,
           buildTime: Date.now() - entryStart,
           format: "tmp",

package/dist/index.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+const externals = [
+  /^node:/,
+  /^@types/,
+  /^@rollup/,
+  /^@hypernym/,
+  /^rollup/
+];
+function defineConfig(options) {
+  return options;
+}
+
+function resolvePaths(options) {
+  return (id) => {
+    for (const resolver of options) {
+      const { find, replacement } = resolver;
+      if (id.match(find)) id = replacement;
+    }
+    return id;
+  };
+}
+
+exports.defineConfig = defineConfig;
+exports.externals = externals;
+exports.resolvePaths = resolvePaths;

package/dist/types/{index.d.ts → index.d.cts}

@@ -82,11 +82,34 @@ interface EntryBase {
 interface EntryChunk extends EntryBase {
     /**
      * Specifies the path of the build source.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   entries: [
+     *     { input: './src/index.ts' }, // => './dist/index.mjs'
+     *   ]
+     * })
+     * ```
      */
     input?: string;
     /**
      * Specifies the path of the transformed file.
      *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   entries: [
+     *     {
+     *       input: './src/index.ts',
+     *       output: './out/index.js', // => './out/index.js'
+     *     },
+     *   ]
+     * })
+     * ```
+     *
      * @default undefined
      */
     output?: string;
@@ -133,17 +156,57 @@ interface EntryChunk extends EntryBase {
      */
     minify?: boolean;
     declaration?: never;
+    dts?: never;
     copy?: never;
     template?: never;
 }
 interface EntryDeclaration extends EntryBase {
     /**
      * Specifies the path of the TypeScript `declaration` build source.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   entries: [
+     *     { dts: './src/types.ts' }, // => './dist/types.d.mts'
+     *   ]
+     * })
+     * ```
+     */
+    dts?: string;
+    /**
+     * Specifies the path of the TypeScript `declaration` build source.
+     *
+     * Also, it is possible to use `dts` alias.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   entries: [
+     *     { declaration: './src/types.ts' }, // => './dist/types.d.mts'
+     *   ]
+     * })
+     * ```
      */
     declaration?: string;
     /**
      * Specifies the path of the TypeScript  transformed `declaration` file.
      *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   entries: [
+     *     {
+     *       dts: './src/types.ts',
+     *       output: './out/types.d.ts', // => './out/types.d.ts'
+     *     },
+     *   ]
+     * })
+     * ```
+     *
      * @default undefined
      */
     output?: string;
@@ -216,6 +279,7 @@ interface EntryCopy {
     copy?: CopyOptions;
     input?: never;
     declaration?: never;
+    dts?: never;
     template?: never;
     name?: never;
     globals?: never;
@@ -248,6 +312,7 @@ interface EntryTemplate {
     output: string;
     input?: never;
     declaration?: never;
+    dts?: never;
     copy?: never;
     name?: never;
     globals?: never;
@@ -268,7 +333,7 @@ interface Options {
      * export default defineConfig({
      *   entries: [
      *     { input: './src/index.ts' }, // => './dist/index.mjs'
-     *     { declaration: './src/types.ts' }, // => './dist/types.d.ts'
+     *     { dts: './src/types.ts' }, // => './dist/types.d.mts'
      *     // ...
      *   ]
      * })
@@ -392,6 +457,32 @@ interface BuildLogs {
     level: LogLevel;
     log: RollupLog;
 }
+interface BuildEntryStats {
+    /**
+     * The root path of the project.
+     */
+    cwd: string;
+    /**
+     * Module output path.
+     */
+    path: string;
+    /**
+     * Module size.
+     */
+    size: number;
+    /**
+     * Build time of individual module.
+     */
+    buildTime: number;
+    /**
+     * Module format.
+     */
+    format: string;
+    /**
+     * List of warnings from build plugins.
+     */
+    logs: BuildLogs[];
+}
 interface BuildStats {
     /**
      * The root path of the project.
@@ -408,30 +499,17 @@ interface BuildStats {
     /**
      * List of generated bundle modules.
      */
-    files: {
-        /**
-         * Module output path.
-         */
-        path: string;
-        /**
-         * Module size.
-         */
-        size: number;
-        /**
-         * Build time of individual module.
-         */
-        buildTime: number;
-        /**
-         * Module format.
-         */
-        format: string;
-        /**
-         * List of warnings from build plugins.
-         */
-        logs: BuildLogs[];
-    }[];
+    files: BuildEntryStats[];
 }
-interface BuildEntryOptions extends EntryBase {
+type PickEntryChunkOptions = 'input' | 'name' | 'globals' | 'extend' | 'minify' | 'transformers';
+type PickEntryDtsOptions = 'declaration' | 'dts' | 'transformers';
+interface BuildEntryOptions extends EntryBase, Pick<EntryChunk, PickEntryChunkOptions>, Pick<EntryDeclaration, PickEntryDtsOptions> {
+    /**
+     * Specifies the path of the transformed file.
+     *
+     * @default undefined
+     */
+    output?: string;
     /**
      * Specifies options for default plugins.
      *
@@ -491,7 +569,7 @@ interface HooksOptions {
      * ```ts
      * export default defineConfig({
      *   hooks: {
-     *     'build:entry:start': async (options, stats) => {
+     *     'build:entry:start': async (entry, stats) => {
      *      // ...
      *     }
      *   }
@@ -500,7 +578,7 @@ interface HooksOptions {
      *
      * @default undefined
      */
-    'build:entry:start'?: (options: BuildEntryOptions, stats: BuildStats) => void | Promise<void>;
+    'build:entry:start'?: (entry: BuildEntryOptions, stats: BuildEntryStats) => void | Promise<void>;
     /**
      * Called on each entry right after the build process is completed.
      *
@@ -509,7 +587,7 @@ interface HooksOptions {
      * ```ts
      * export default defineConfig({
      *   hooks: {
-     *     'build:entry:end': async (options, stats) => {
+     *     'build:entry:end': async (entry, stats) => {
      *      // ...
      *     }
      *   }
@@ -518,7 +596,7 @@ interface HooksOptions {
      *
      * @default undefined
      */
-    'build:entry:end'?: (options: BuildEntryOptions, stats: BuildStats) => void | Promise<void>;
+    'build:entry:end'?: (entry: BuildEntryOptions, stats: BuildEntryStats) => void | Promise<void>;
     /**
      * Called right after building is complete.
      *

package/dist/types/index.d.mts

@@ -0,0 +1,708 @@
+import { OutputOptions, Plugin, LogLevel, RollupLog } from 'rollup';
+import { RollupReplaceOptions } from '@rollup/plugin-replace';
+import { RollupJsonOptions } from '@rollup/plugin-json';
+import { RollupNodeResolveOptions } from '@rollup/plugin-node-resolve';
+import { RollupAliasOptions, Alias } from '@rollup/plugin-alias';
+import { TransformOptions } from 'esbuild';
+import { Options as Options$1 } from 'rollup-plugin-dts';
+
+interface TransformersChunk {
+    esbuild?: TransformOptions;
+    resolve?: RollupNodeResolveOptions | true;
+    replace?: RollupReplaceOptions;
+    json?: RollupJsonOptions | true;
+    alias?: RollupAliasOptions;
+}
+interface TransformersDeclaration {
+    dts?: Options$1;
+    alias?: RollupAliasOptions;
+}
+
+interface EntryBase {
+    /**
+     * Specifies the format of the generated module.
+     *
+     * @default 'esm'
+     */
+    format?: OutputOptions['format'];
+    /**
+     * Specifies the module IDs, or regular expressions to match module IDs,
+     * that should remain external to the bundle.
+     *
+     * If not specified, infers the IDs from the global `options.externals` option.
+     *
+     * @default undefined
+     */
+    externals?: (string | RegExp)[];
+    /**
+     * Specifies the string to be inserted at the beginning of the module.
+     *
+     * @default undefined
+     */
+    banner?: OutputOptions['banner'];
+    /**
+     * Specifies the string to be inserted at the end of the module.
+     *
+     * @default undefined
+     */
+    footer?: OutputOptions['footer'];
+    /**
+     * Specifies the code at the beginning that goes inside any _format-specific_ wrapper.
+     *
+     * @default undefined
+     */
+    intro?: OutputOptions['intro'];
+    /**
+     * Specifies the code at the end that goes inside any _format-specific_ wrapper.
+     *
+     * @default undefined
+     */
+    outro?: OutputOptions['outro'];
+    /**
+     * Maps external module IDs to paths.
+     *
+     * @default undefined
+     */
+    paths?: OutputOptions['paths'];
+    /**
+     * Specifies custom filters that will display only certain log messages.
+     *
+     * @default undefined
+     */
+    logFilter?: string[];
+    /**
+     * Specifies `rollup` plugins.
+     *
+     * Adding custom plugins disables all built-in `transformers` for full customization.
+     *
+     * @default undefined
+     */
+    plugins?: Plugin[];
+}
+interface EntryChunk extends EntryBase {
+    /**
+     * Specifies the path of the build source.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   entries: [
+     *     { input: './src/index.ts' }, // => './dist/index.mjs'
+     *   ]
+     * })
+     * ```
+     */
+    input?: string;
+    /**
+     * Specifies the path of the transformed file.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   entries: [
+     *     {
+     *       input: './src/index.ts',
+     *       output: './out/index.js', // => './out/index.js'
+     *     },
+     *   ]
+     * })
+     * ```
+     *
+     * @default undefined
+     */
+    output?: string;
+    /**
+     * Specifies the built-in `transformers` options.
+     *
+     * Available transformers:
+     *
+     * - `esbuild`
+     * - `resolve`
+     * - `replace`
+     * - `json`
+     * - `alias`
+     *
+     * @default undefined
+     */
+    transformers?: TransformersChunk;
+    /**
+     * Specifies the global variable name that representing exported bundle.
+     *
+     * Intended for `umd/iife` formats.
+     *
+     * @default undefined
+     */
+    name?: OutputOptions['name'];
+    /**
+     * Specifies global _module ID_ and _variable name_ pairs necessary for external imports.
+     *
+     * Intended for `umd/iife` formats.
+     *
+     * @default undefined
+     */
+    globals?: OutputOptions['globals'];
+    /**
+     * Specifies whether to extend the global variable defined by the `name` option.
+     *
+     * Intended for `umd/iife` formats.
+     */
+    extend?: OutputOptions['extend'];
+    /**
+     * Minifies the generated code if enabled.
+     *
+     * @default undefined
+     */
+    minify?: boolean;
+    declaration?: never;
+    dts?: never;
+    copy?: never;
+    template?: never;
+}
+interface EntryDeclaration extends EntryBase {
+    /**
+     * Specifies the path of the TypeScript `declaration` build source.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   entries: [
+     *     { dts: './src/types.ts' }, // => './dist/types.d.mts'
+     *   ]
+     * })
+     * ```
+     */
+    dts?: string;
+    /**
+     * Specifies the path of the TypeScript `declaration` build source.
+     *
+     * Also, it is possible to use `dts` alias.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   entries: [
+     *     { declaration: './src/types.ts' }, // => './dist/types.d.mts'
+     *   ]
+     * })
+     * ```
+     */
+    declaration?: string;
+    /**
+     * Specifies the path of the TypeScript  transformed `declaration` file.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   entries: [
+     *     {
+     *       dts: './src/types.ts',
+     *       output: './out/types.d.ts', // => './out/types.d.ts'
+     *     },
+     *   ]
+     * })
+     * ```
+     *
+     * @default undefined
+     */
+    output?: string;
+    /**
+     * Specifies the built-in `transformers` options.
+     *
+     * Available transformers:
+     *
+     * - `dts`
+     * - `alias`
+     *
+     * @default undefined
+     */
+    transformers?: TransformersDeclaration;
+    input?: never;
+    copy?: never;
+    template?: never;
+    name?: never;
+    globals?: never;
+    extend?: never;
+    minify?: never;
+}
+interface CopyOptions {
+    /**
+     * Specifies the path of the source.
+     */
+    input: string | string[];
+    /**
+     * Specifies the path of the destination directory.
+     */
+    output: string;
+    /**
+     * Copy directories recursively.
+     *
+     * @default true
+     */
+    recursive?: boolean;
+    /**
+     * Filters copied `files/directories`.
+     *
+     * Returns `true` to copy the item, `false` to ignore it.
+     *
+     * @default undefined
+     */
+    filter?(source: string, destination: string): boolean;
+}
+interface EntryCopy {
+    /**
+     * Copies the single `file` or entire `directory` structure from source to destination, including subdirectories and files.
+     *
+     * This can be very useful for copying some assets that don't need a transformation process, but a simple copy paste feature.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   entries: [
+     *     {
+     *       copy: {
+     *         input: './src/path/file.ts', // or ['path-dir', 'path-file.ts', ...]
+     *         output: './dist/out', // path to output dir
+     *       }
+     *     }
+     *   ]
+     * })
+     * ```
+     *
+     * @default undefined
+     */
+    copy?: CopyOptions;
+    input?: never;
+    declaration?: never;
+    dts?: never;
+    template?: never;
+    name?: never;
+    globals?: never;
+    extend?: never;
+    minify?: never;
+}
+interface EntryTemplate {
+    /**
+     * Specifies the content of the `template` file.
+     *
+     * Provides the ability to dynamically inject template content during the build phase.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   entries: [
+     *     {
+     *       template: `// TypeScript code...`,
+     *       output: './dist/template.ts',
+     *     },
+     *   ]
+     * })
+     * ```
+     */
+    template: string;
+    /**
+     * Specifies the path of the transformed `template` file.
+     */
+    output: string;
+    input?: never;
+    declaration?: never;
+    dts?: never;
+    copy?: never;
+    name?: never;
+    globals?: never;
+    extend?: never;
+    minify?: never;
+}
+type EntryOptions = EntryChunk | EntryDeclaration | EntryCopy | EntryTemplate;
+
+interface Options {
+    /**
+     * Specifies the bundle's entry points.
+     *
+     * It allows you to manually set all build entries and adjust options for each one individually.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   entries: [
+     *     { input: './src/index.ts' }, // => './dist/index.mjs'
+     *     { dts: './src/types.ts' }, // => './dist/types.d.mts'
+     *     // ...
+     *   ]
+     * })
+     * ```
+     */
+    entries: EntryOptions[];
+    /**
+     * Specifies the output directory for production bundle.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   outDir: 'output',
+     * })
+     * ```
+     *
+     * @default 'dist'
+     */
+    outDir?: string;
+    /**
+     * Specifies the module IDs, or regular expressions to match module IDs,
+     * that should remain external to the bundle.
+     *
+     * IDs and regexps from this option are applied globally to all entries.
+     *
+     * Also, it is possible to define externals individually per entry (`entry.externals`).
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   externals: ['id-1', 'id-2', /regexp/],
+     * })
+     * ```
+     *
+     * @default [/^node:/, /^@types/, /^@rollup/, /^@hypernym/, /^rollup/, ...pkg.dependencies]
+     */
+    externals?: (string | RegExp)[];
+    /**
+     * Provides a powerful hooking system to further expand bundling mode.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   hooks: {
+     *     'build:end': async (options, buildStats) => {
+     *       // ...
+     *     }
+     *   }
+     * })
+     * ```
+     *
+     * @default undefined
+     */
+    hooks?: HooksOptions;
+    /**
+     * Specifies prefixes that will resolve imports with custom paths.
+     *
+     * Enables these `alias` by default:
+     *
+     * ```ts
+     * // Imports module from './src/utils/index.js'
+     * import { module } from '@/utils' // @
+     * import { module } from '~/utils' // ~
+     * ```
+     *
+     * Also, it is possible to completely override the default aliases by setting custom ones.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   alias: [
+     *     { find: /^#/, replacement: resolve('./src') },
+     *   ]
+     * })
+     * ```
+     *
+     * Now imports can be used like this:
+     *
+     * ```ts
+     * // Imports module from './src/utils/index.js'
+     * import { module } from '#/utils' // #
+     * ```
+     *
+     * @default undefined
+     */
+    alias?: Alias[];
+    /**
+     * Specifies the minification for all `chunk` entries.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   minify: true,
+     * })
+     * ```
+     *
+     * It can also be set per entry.
+     *
+     * ```ts
+     * export default defineConfig({
+     *   entries: [
+     *     {
+     *       input: './src/index.ts',
+     *       minify: true,
+     *     },
+     *   ],
+     * })
+     * ```
+     *
+     * @default undefined
+     */
+    minify?: boolean;
+}
+
+interface BuildLogs {
+    level: LogLevel;
+    log: RollupLog;
+}
+interface BuildEntryStats {
+    /**
+     * The root path of the project.
+     */
+    cwd: string;
+    /**
+     * Module output path.
+     */
+    path: string;
+    /**
+     * Module size.
+     */
+    size: number;
+    /**
+     * Build time of individual module.
+     */
+    buildTime: number;
+    /**
+     * Module format.
+     */
+    format: string;
+    /**
+     * List of warnings from build plugins.
+     */
+    logs: BuildLogs[];
+}
+interface BuildStats {
+    /**
+     * The root path of the project.
+     */
+    cwd: string;
+    /**
+     * Final bundle size.
+     */
+    size: number;
+    /**
+     * Total bundle build time.
+     */
+    buildTime: number;
+    /**
+     * List of generated bundle modules.
+     */
+    files: BuildEntryStats[];
+}
+type PickEntryChunkOptions = 'input' | 'name' | 'globals' | 'extend' | 'minify' | 'transformers';
+type PickEntryDtsOptions = 'declaration' | 'dts' | 'transformers';
+interface BuildEntryOptions extends EntryBase, Pick<EntryChunk, PickEntryChunkOptions>, Pick<EntryDeclaration, PickEntryDtsOptions> {
+    /**
+     * Specifies the path of the transformed file.
+     *
+     * @default undefined
+     */
+    output?: string;
+    /**
+     * Specifies options for default plugins.
+     *
+     * @default undefined
+     */
+    transformers?: TransformersChunk & TransformersDeclaration;
+    /**
+     * Specifies list of default plugins.
+     */
+    defaultPlugins: Plugin[];
+}
+
+interface HooksOptions {
+    /**
+     * Called at the beginning of bundling.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   hooks: {
+     *     'bundle:start': async (options) => {
+     *       // ...
+     *     }
+     *   }
+     * })
+     * ```
+     *
+     * @default undefined
+     */
+    'bundle:start'?: (options: Options) => void | Promise<void>;
+    /**
+     * Called at the beginning of building.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   hooks: {
+     *     'build:start': async (options, stats) => {
+     *       // ...
+     *     }
+     *   }
+     * })
+     * ```
+     *
+     * @default undefined
+     */
+    'build:start'?: (options: Options, stats: BuildStats) => void | Promise<void>;
+    /**
+     * Called on each entry just before the build process.
+     *
+     * Provides the ability to customize entry options before they are passed to the next phase.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   hooks: {
+     *     'build:entry:start': async (entry, stats) => {
+     *      // ...
+     *     }
+     *   }
+     * })
+     * ```
+     *
+     * @default undefined
+     */
+    'build:entry:start'?: (entry: BuildEntryOptions, stats: BuildEntryStats) => void | Promise<void>;
+    /**
+     * Called on each entry right after the build process is completed.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   hooks: {
+     *     'build:entry:end': async (entry, stats) => {
+     *      // ...
+     *     }
+     *   }
+     * })
+     * ```
+     *
+     * @default undefined
+     */
+    'build:entry:end'?: (entry: BuildEntryOptions, stats: BuildEntryStats) => void | Promise<void>;
+    /**
+     * Called right after building is complete.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   hooks: {
+     *     'build:end': async (options, stats) => {
+     *       // ...
+     *     }
+     *   }
+     * })
+     * ```
+     *
+     * @default undefined
+     */
+    'build:end'?: (options: Options, stats: BuildStats) => void | Promise<void>;
+    /**
+     * Called right after bundling is complete.
+     *
+     * @example
+     *
+     * ```ts
+     * export default defineConfig({
+     *   hooks: {
+     *     'bundle:end': async (options) => {
+     *       // ...
+     *     }
+     *   }
+     * })
+     * ```
+     *
+     * @default undefined
+     */
+    'bundle:end'?: (options: Options) => void | Promise<void>;
+}
+
+interface ConfigLoader {
+    options: Options;
+    path: string;
+}
+
+/**
+ * List of global defaults for externals.
+ *
+ * @example
+ *
+ * ```ts
+ * import { externals } from '@hypernym/bundler'
+ *
+ * export default defineConfig({
+ *   entries: [
+ *     {
+ *       input: './src/index.ts',
+ *       externals: [...externals, 'id', /regexp/]
+ *     },
+ *   ]
+ * })
+ * ```
+ */
+declare const externals: RegExp[];
+/**
+ * `Hyperbundler` automatically detects custom configuration from the project root that can override or extend the build behavior.
+ *
+ * Configuration file also accepts `.js`, `.mjs`, `.ts`, `.mts` formats.
+ *
+ * @example
+ *
+ * ```ts
+ * import { defineConfig } from '@hypernym/bundler'
+ *
+ * export default defineConfig({
+ *   // ...
+ * })
+ * ```
+ */
+declare function defineConfig(options: Options): Options;
+
+/**
+ * Resolves external module IDs into custom paths.
+ *
+ * @example
+ *
+ * ```ts
+ * import { defineConfig, resolvePaths } from '@hypernym/bundler'
+ *
+ * export default defineConfig({
+ *   entries: [
+ *     {
+ *       input: './src/index.ts',
+ *       externals: [/^@\/path/],
+ *       paths: resolvePaths([
+ *         // replaces `@/path` with `./path/index.mjs`
+ *         { find: /^@\/path/, replacement: './path/index.mjs', }
+ *       ]),
+ *     },
+ *   ]
+ * })
+ * ```
+ */
+declare function resolvePaths(options: ResolvePathsOptions[]): (id: string) => string;
+
+interface ResolvePathsOptions {
+    find: string | RegExp;
+    replacement: string;
+}
+
+export { type BuildLogs, type BuildStats, type ConfigLoader, type CopyOptions, type EntryBase, type EntryChunk, type EntryCopy, type EntryDeclaration, type EntryOptions, type EntryTemplate, type HooksOptions, type Options, type ResolvePathsOptions, type TransformersChunk, type TransformersDeclaration, defineConfig, externals, resolvePaths };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypernym/bundler",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "author": "Hypernym Studio",
   "description": "ESM & TS module bundler.",
   "license": "MIT",
@@ -8,11 +8,12 @@
   "homepage": "https://github.com/hypernym-studio/bundler",
   "funding": "https://github.com/sponsors/ivodolenc",
   "type": "module",
-  "types": "./dist/types/index.d.ts",
+  "types": "./dist/types/index.d.cts",
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
-      "import": "./dist/index.mjs"
+      "types": "./dist/types/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
     }
   },
   "files": [
@@ -67,9 +68,9 @@
     "@hypernym/utils": "^3.4.0",
     "@rollup/plugin-alias": "^5.1.1",
     "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^15.2.4",
-    "@rollup/plugin-replace": "^5.0.7",
-    "@rollup/pluginutils": "^5.1.1",
+    "@rollup/plugin-node-resolve": "^15.3.0",
+    "@rollup/plugin-replace": "^6.0.1",
+    "@rollup/pluginutils": "^5.1.2",
     "esbuild": "^0.24.0",
     "rollup": "^4.22.4",
     "rollup-plugin-dts": "^6.1.1"
@@ -78,8 +79,8 @@
     "@hypernym/eslint-config": "^3.5.0",
     "@hypernym/prettier-config": "^3.2.0",
     "@hypernym/tsconfig": "^2.4.0",
-    "@types/node": "^22.5.5",
-    "eslint": "^9.11.0",
+    "@types/node": "^22.6.1",
+    "eslint": "^9.11.1",
     "prettier": "^3.3.3",
     "typescript": "^5.5.4"
   }