makepack 1.7.19 → 1.7.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "makepack",
-  "version": "1.7.19",
+  "version": "1.7.21",
   "type": "module",
   "description": "A CLI tool to create, build, and manage JavaScript, TypeScript, React, and React-TypeScript libraries for npm projects.",
   "categories": [

package/src/actions/build/bundler.js

@@ -6,10 +6,8 @@ import json from "@rollup/plugin-json";
 import terser from "@rollup/plugin-terser";
 import path from "path";
 import fs from "fs/promises";
-import ts from "typescript";
 import { loadRollupConfig, loadViteConfig } from "../../helpers.js";
-
-const MAX_DIR_CONCURRENCY = 16;
+import dts from "rollup-plugin-dts";
 const MAX_FILE_COPY_CONCURRENCY = 32;
 
 // --------------------- Helpers ---------------------
@@ -21,48 +19,6 @@ function isSkippedDir(name) {
    return ["node_modules", ".git", ".next"].includes(name);
 }
 
-// --------------------- Multi-entry collector with type-only detection ---------------------
-async function getEntriesBatch(root) {
-   const entries = {};
-   const dirs = [root];
-
-   async function worker() {
-      while (dirs.length) {
-         const dir = dirs.shift();
-         const items = await fs.readdir(dir, { withFileTypes: true });
-
-         for (const item of items) {
-            const full = path.join(dir, item.name);
-
-            if (item.isDirectory()) {
-               dirs.push(full);
-               continue;
-            }
-
-            if (!isCodeFile(item.name) || item.name.endsWith(".d.ts")) continue;
-
-            // read file content to detect type-only
-            const content = await fs.readFile(full, "utf-8");
-            const lines = content.split(/\r?\n/);
-            const typeOnly = lines.every(
-               line =>
-                  /^\s*(export\s+)?(type|interface|enum|declare)/.test(line) ||
-                  line.trim() === ""
-            );
-
-            if (!typeOnly) {
-               const name = path.relative(root, full).replace(/\.(ts|tsx|js|jsx)$/, "");
-               entries[name] = full;
-            }
-         }
-      }
-   }
-
-   const workers = Array.from({ length: MAX_DIR_CONCURRENCY }, () => worker());
-   await Promise.all(workers);
-   return entries;
-}
-
 // --------------------- Parallel asset copy ---------------------
 async function copyAssetsBatched(rootdir, outdir) {
    const queue = [];
@@ -94,47 +50,55 @@ async function copyAssetsBatched(rootdir, outdir) {
    await Promise.all(workers);
 }
 
-// --------------------- Generate .d.ts using TS Compiler API ---------------------
-async function generateDeclarations(rootDir, outDir) {
-   const tsFiles = [];
+/**
+ * Normalize rollup input (string | array | object)
+ * → returns [{ entry, outdir }]
+ */
+function mapEntriesToOutdirs(entries, rootdir, baseOutdir) {
+   const absRoot = path.resolve(process.cwd(), rootdir);
+   const absOut = path.resolve(process.cwd(), baseOutdir);
 
-   async function walk(dir) {
-      const items = await fs.readdir(dir, { withFileTypes: true });
-      for (const item of items) {
-         const full = path.join(dir, item.name);
-         if (item.isDirectory()) await walk(full);
-         else if (/\.(ts|tsx)$/.test(item.name)) tsFiles.push(full);
-      }
+   /** normalize to array of absolute entry paths */
+   let entryList = [];
+
+   // string
+   if (typeof entries === "string") {
+      entryList = [entries];
    }
 
-   await walk(rootDir);
+   // array
+   else if (Array.isArray(entries)) {
+      entryList = entries;
+   }
 
-   if (!tsFiles.length) return;
+   // object { name: path }
+   else if (entries && typeof entries === "object") {
+      entryList = Object.values(entries);
+   }
 
-   const options = {
-      declaration: true,
-      emitDeclarationOnly: true,
-      outDir: outDir,
-      rootDir: rootDir,
-      moduleResolution: ts.ModuleResolutionKind.NodeJs,
-      target: ts.ScriptTarget.ES2017,
-      module: ts.ModuleKind.ESNext,
-      esModuleInterop: true,
-      skipLibCheck: true,
-   };
+   return entryList.map(entry => {
+      const absEntry = path.isAbsolute(entry)
+         ? entry
+         : path.resolve(process.cwd(), entry);
 
-   const program = ts.createProgram(tsFiles, options);
-   program.emit();
+      // relative path from rootdir (e.g. anydir/entry.ts)
+      const rel = path.relative(absRoot, absEntry);
+
+      // directory only (e.g. anydir)
+      const subdir = path.dirname(rel);
+
+      return {
+         entry: absEntry,
+         outdir: subdir === "." ? absOut : path.join(absOut, subdir),
+      };
+   });
 }
 
 // --------------------- Main Bundler ---------------------
-async function bundler(args, spinner) {
+async function bundler(args, spinner, child = false) {
    const rootdir = args.rootdir;
    const outdir = args.outdir;
 
-   const entries = await getEntriesBatch(rootdir);
-   const isTs = Object.values(entries).some(f => f.endsWith(".ts") || f.endsWith(".tsx"));
-
    const viteConfig = await loadViteConfig();
    const rollupConfig = await loadRollupConfig();
    const viteRollupConfig = viteConfig?.build?.rollupOptions || {};
@@ -142,7 +106,7 @@ async function bundler(args, spinner) {
 
    const config = {
       ...rollupConfig,
-      input: { ...entries },
+      input: args.entry,
       external: id => {
          if (rollupConfig && typeof rollupConfig.external === "function") {
             if (rollupConfig.external(id)) return true;
@@ -176,14 +140,9 @@ async function bundler(args, spinner) {
       ]
    };
 
-   const bundle = await rollup({
-      ...config,
-      onwarn(warning, warn) {
-         // Ignore empty chunk warnings
-         if (warning.code === "EMPTY_BUNDLE") return;
-         warn(warning);
-      }
-   });
+   const bundle = await rollup(config);
+
+
 
    // --------------------- Output formats ---------------------
    const outputs = [];
@@ -229,13 +188,42 @@ async function bundler(args, spinner) {
 
    await bundle.close();
 
+
+   if (!child && rollupConfig && rollupConfig.input) {
+      const mapentries = mapEntriesToOutdirs(rollupConfig.input, rootdir, outdir)
+      if (mapentries.length > 1) {
+         spinner.text = `📦 Bundling ${mapentries.length} entries...`;
+      }
+
+      for (const { entry } of mapentries) {
+         await bundler({
+            ...args,
+            entry,
+            outdir,
+         }, spinner, true);
+      }
+
+   }
+
    // --------------------- Copy assets ---------------------
-   await copyAssetsBatched(rootdir, outdir);
+   if (!child) {
+      spinner.text = "📁 Copying non-code assets...";
+      await copyAssetsBatched(rootdir, outdir);
+   }
 
-   // --------------------- Generate TypeScript declarations ---------------------
-   if (isTs && args.declaration) {
-      spinner.text = "📄 Generating TypeScript declarations programmatically...";
-      await generateDeclarations(rootdir, outdir);
+   if (args.declaration) {
+      spinner.text = "Generating TypeScript declarations..."
+      const bundlets = await rollup({
+         ...config,
+         plugins: [dts()],
+      });
+      await bundlets.write({
+         format: "esm",
+         preserveModules: true,
+         preserveModulesRoot: args.rootdir,
+         dir: path.join(args.outdir),
+      });
+      await bundlets.close();
    }
 }
 

package/src/actions/build/index.js

@@ -20,6 +20,23 @@ const build = async (args) => {
 
    const outdir = path.join(process.cwd(), '.mpack');
    const rootdir = path.join(process.cwd(), 'src');
+   let entry = '';
+   let entryts = path.join(rootdir, 'index.ts');
+   let entryjs = path.join(rootdir, 'index.js');
+   let entrytsx = path.join(rootdir, 'index.tsx');
+   let entryjsx = path.join(rootdir, 'index.jsx');
+
+   if (fs.existsSync(entryts)) {
+      entry = "index.ts";
+   } else if (fs.existsSync(entryjs)) {
+      entry = "index.js";
+   } else if (fs.existsSync(entrytsx)) {
+      entry = "index.tsx";
+   } else if (fs.existsSync(entryjsx)) {
+      entry = "index.jsx";
+   } else {
+      throw new Error("No entry file found in src directory. Please provide an index.ts or index.js file.");
+   }
 
    args = {
       format: args.format || 'both',
@@ -29,6 +46,7 @@ const build = async (args) => {
       declaration: beBool('declaration'),
       outdir,
       rootdir,
+      entry: path.join(rootdir, entry),
    };
 
    const spinner = ora('✨ Building your package...\n').start();
@@ -49,6 +67,12 @@ const build = async (args) => {
          const pkgjson = await fs.readJson(pkgPath);
          delete pkgjson.scripts;
          delete pkgjson.type;
+         delete pkgjson.devDependencies;
+         delete pkgjson.jest;
+         delete pkgjson.prettier;
+         delete pkgjson.eslintConfig;
+         delete pkgjson.vite;
+         delete pkgjson.rollup;
          await fs.writeJson(path.join(outdir, 'package.json'), pkgjson, { spaces: 2 });
       } else {
          spinner.fail(concolor.red('package.json not found!'));

package/src/helpers.js

@@ -1,4 +1,8 @@
 import child_process from 'child_process'
+import fs from 'fs/promises';
+import path from 'path';
+import { pathToFileURL } from 'url';
+
 
 export const execSync = (command, option = {}) => {
    try {
@@ -53,9 +57,6 @@ export const logger = {
    }
 };
 
-import fs from 'fs/promises';
-import path from 'path';
-import { pathToFileURL } from 'url';
 
 /**
  * Load full Vite config object from root