makepack 1.6.10 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "makepack",
-  "version": "1.6.10",
+  "version": "1.7.0",
   "type": "module",
   "description": "A CLI tool to create, build, and manage JavaScript, TypeScript, React, and React-TypeScript libraries for npm projects.",
   "files": [
@@ -30,17 +30,22 @@
     "build": "node ./src/index.js build"
   },
   "dependencies": {
-    "chalk": "^5.4.1",
+    "@rollup/plugin-commonjs": "^28.0.5",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-terser": "^0.4.4",
     "chokidar": "^4.0.3",
     "commander": "^12.1.0",
     "esbuild": "^0.25.5",
     "express": "^4.21.1",
     "fs-extra": "^11.2.0",
-    "glob": "^11.0.0",
     "inquirer": "^12.1.0",
     "lodash.debounce": "^4.0.8",
     "madge": "^8.0.0",
     "ora": "^8.1.1",
+    "rollup": "^4.43.0",
+    "rollup-plugin-dts": "^6.2.1",
+    "tslib": "^2.8.1",
     "vite": "^6.0.2"
   },
   "keywords": [
@@ -53,9 +58,11 @@
     "npm-package"
   ],
   "devDependencies": {
+    "@rollup/plugin-typescript": "^12.1.2",
     "@types/fs-extra": "^11.0.4",
-    "react": "^19.0.0",
+    "@types/react": "^19.1.8",
+    "react": "^19.1.0",
     "react-dom": "^19.0.0",
-    "typescript": "^5.7.2"
+    "typescript": "^5.8.3"
   }
 }

package/src/actions/build/bundler.js

@@ -0,0 +1,99 @@
+import { rollup } from "rollup";
+import resolve from "@rollup/plugin-node-resolve";
+import commonjs from "@rollup/plugin-commonjs";
+import typescript from "@rollup/plugin-typescript";
+import { builtinModules } from "module";
+import fs from "fs";
+import path from "path";
+import dts from "rollup-plugin-dts";
+import json from '@rollup/plugin-json';
+import terser from "@rollup/plugin-terser";
+
+async function build(args, spinner) {
+   const pkg = JSON.parse(fs.readFileSync("./package.json", "utf-8"));
+   const external = [
+      ...builtinModules,
+      ...Object.keys(pkg.dependencies ?? {}),
+      ...Object.keys(pkg.devDependencies ?? {}),
+      ...Object.keys(pkg.peerDependencies ?? {}),
+   ];
+
+   const isTs = args.entry.endsWith(".ts")
+
+   const config = {
+      input: [args.entry],
+      external,
+      plugins: [
+         json(),
+         resolve(),
+         commonjs(),
+         isTs ? typescript({
+            compilerOptions: {
+               "module": "ESNext",
+               "jsx": "react",
+               "strict": true,
+               "forceConsistentCasingInFileNames": true,
+               "esModuleInterop": true
+            },
+            include: ["src/**/*.ts", "src/**/*.tsx"],
+            exclude: ["node_modules", ".mpack"],
+         }) : null,
+         args.minify ? terser() : null,
+      ]
+   };
+
+   const bundle = await rollup(config);
+   const esm = {
+      dir: args.outdir,
+      format: "esm",
+      sourcemap: args.sourcemap,
+      compact: true,
+      strict: true
+   };
+   if (!args.bundle) {
+      esm.preserveModules = true
+      esm.preserveModulesRoot = args.rootdir
+   }
+
+   let cjs = {
+      ...esm,
+      dir: args.outdir,
+      format: "cjs",
+      dynamicImportInCjs: true,
+      esModule: true,
+   }
+
+   let outputOptions = []
+
+   if (args.format === "both") {
+      outputOptions = [
+         { ...esm, entryFileNames: '[name].mjs' },
+         cjs,
+      ]
+   } else if (args.format === "esm") {
+      outputOptions = [esm];
+   } else if (args.format === "cjs") {
+      outputOptions = [cjs];
+   }
+
+   for (const output of outputOptions) {
+      await bundle.write(output);
+   }
+   await bundle.close();
+
+   // If TypeScript declaration files are requested, generate them
+   if (isTs && args.declaration) {
+      spinner.text = "Generating TypeScript declarations..."
+      const bundlets = await rollup({
+         ...config,
+         plugins: [dts()],
+      });
+      await bundlets.write({
+         ...esm,
+         dir: path.join(args.outdir),
+      });
+      await bundlets.close();
+   }
+}
+
+export default build;

package/src/actions/build/index.js

@@ -1,136 +1,59 @@
-import esbuild from 'esbuild'
 import fs from 'fs-extra'
 import path from 'path'
 import ora from 'ora'
-import { glob } from 'glob'
-import ts from 'typescript'
 import { concolor, logger } from '../../helpers.js'
-
-const eBuild = async (conf) => {
-
-   await esbuild.build({
-      jsx: 'automatic',
-      ...conf,
-      loader: {
-         '.ts': 'ts',
-         '.tsx': 'tsx'
-      },
-      outdir: path.join(process.cwd(), '.mpack', conf.format === 'esm' ? '' : conf.format),
-   })
-}
+import bundler from './bundler.js'
 
 const build = async (args) => {
    /* args 
-   --format=default 
+   --format=both 
    --bundle=true, 
    --minify=false, 
    --sourcemap=true, 
-   --platform=node, 
-   --target=es2020, 
+   --declaration=true,
    */
 
-
    let printBool = (f) => typeof args[f] === 'string' ? (args[f] === 'true') : args[f];
 
+   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 || "default",
+      format: args.format || "both",
       bundle: printBool('bundle'),
       minify: printBool('minify'),
       sourcemap: printBool('sourcemap'),
-      platform: args.platform || "",
-      target: args.target || "es2020",
       declaration: printBool('declaration'),
+      outdir,
+      rootdir,
+      entry: path.join(rootdir, entry),
    }
 
-   const outdir = path.join(process.cwd(), '.mpack');
    if (fs.existsSync(outdir)) {
       fs.rmSync(outdir, { recursive: true, force: true });
    }
    fs.mkdirSync(outdir)
-
-   const spinner = ora("Generating a production build for the package...").start();
-   const files = await glob("src/**/*.{tsx,ts,js,jsx}") || [];
-   const entryPoints = files.map(entry => path.join(process.cwd(), entry));
-   let batchSize = args.format === 'default' ? 300 : 500;
-
-   let ebconfig = {
-      bundle: args.bundle,
-      minify: args.minify,
-      sourcemap: args.sourcemap,
-      platform: args.platform,
-      target: args.target,
-   }
-
-   for (let i = 0; i < entryPoints.length; i += batchSize) {
-      const batch = entryPoints.slice(i, i + batchSize);
-      let config = {
-         ...ebconfig,
-         entryPoints: batch,
-      }
-      if (args.format === 'default') {
-         await eBuild({ ...config, format: "esm" });
-         logger.success('ESM build generated successfully!');
-         await eBuild({ ...config, format: "cjs" });
-         logger.success('CJS build generated successfully!');
-      } else {
-         await eBuild({ ...config, format: args.format });
-         logger.success(`${args.format} build generated successfully!`);
-      }
-   }
-
-
-   if (args.declaration) {
-      const tsconfigPath = path.resolve(process.cwd(), "tsconfig.json");
-      let tsconfig = {};
-      if (fs.existsSync(tsconfigPath)) {
-         const parsedConfig = ts.getParsedCommandLineOfConfigFile(
-            tsconfigPath,
-            {},
-            ts.sys
-         );
-
-         if (!parsedConfig) {
-            logger.error("Error parsing tsconfig.json");
-            process.exit(1);
-         } else {
-            tsconfig = parsedConfig.options;
-         }
-      }
-
-      tsconfig = {
-         allowJs: true,
-         target: ts.ScriptTarget.ESNext, // Ensure it's an enum
-         skipLibCheck: true,
-         moduleResolution: ts.ModuleResolutionKind.Node10,
-         ...tsconfig, // Preserve root tsconfig settings
-         outDir: outdir,
-         declaration: true,
-         emitDeclarationOnly: true,
-         noEmit: false,
-      };
-
-      spinner.text = "Generating TypeScript declarations..."
-      const program = ts.createProgram(files, tsconfig);
-      const emitResult = program.emit();
-      const diagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
-
-      if (diagnostics.length > 0) {
-         diagnostics.forEach(diagnostic => {
-            const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
-            if (diagnostic.file) {
-               const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-               logger.error(`Error at ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
-            } else {
-               logger.error(`${message}`);
-            }
-         });
-      } else {
-         logger.success("TypeScript declaration files generated successfully!")
-      }
-   }
+   const spinner = ora("✨ Bundling your package..\n").start();
+   await bundler(args, spinner);
    spinner.text = "Copying package.json and readme.md files..."
-
-   // update package.json to include the .mpack directory
    const pkgPath = path.join(process.cwd(), 'package.json');
    if (fs.existsSync(pkgPath)) {
       const pkgjson = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
@@ -143,10 +66,9 @@ const build = async (args) => {
    }
 
    fs.copyFileSync(path.join(process.cwd(), '/readme.md'), path.join(outdir, `/readme.md`))
-   logger.success("package.json and readme.md files copied successfully!")
-   logger.success(`completed successfully!`, 'BUILD:', true);
-   logger.info(`To publish your package to npm:`, 'INFO:', true);
-   logger.info(`${concolor.yellow(`npm run release`)} or navigate to the ${concolor.yellow(`.mpack`)} directory and run ${concolor.yellow(`npm publish`)}`, 'RELEASE:', true)
+   spinner.succeed(concolor.bold(concolor.green(`Build successfully completed\n`)));
+   console.log(concolor.bold(`To publish your package to npm run:`));
+   console.log(`${concolor.yellow(`\`npm run release\``)} Or navigate to \`.mpack\` and run: ${concolor.yellow(`\`npm publish\`\n`)}`);
    spinner.stop();
 }
 

package/src/actions/create/files/package-json.js

@@ -21,8 +21,8 @@ export default async (info) => {
    const json = {
       name: info.pdir,
       version: "1.0.0",
-      main: `./cjs/index.js`,
-      module: `./index.js`,
+      main: `./index.js`,
+      module: `./index.mjs`,
       types: `./index.d.ts`,
       description: "",
       keywords: [],
@@ -32,28 +32,12 @@ export default async (info) => {
          "build": "makepack build",
          "release": "makepack release"
       },
-      exports: {
+      "exports": {
          ".": {
-            "require": {
-               "types": "./index.d.ts",
-               "default": "./cjs/index.js"
-            },
-            "import": {
-               "types": "./index.d.ts",
-               "default": "./index.js"
-            }
-         },
-         "./*": {
-            "require": {
-               "types": "./*.d.ts",
-               "default": "./cjs/*.js"
-            },
-            "import": {
-               "types": "./*.d.ts",
-               "default": "./*.js"
-            }
-         },
-         "./cjs": null
+            "import": "./index.mjs",
+            "require": "./index.js",
+            "types": "./index.d.ts"
+         }
       },
       dependencies,
       devDependencies

package/src/actions/start/index.js

@@ -137,12 +137,15 @@ async function loadExp() {
 
 async function getAllDependencies() {
    try {
+      if (!expExists) {
+         return [];
+      }
       const result = await madge(uxpfile, { fileExtensions: ['ts', 'js'] });
       const deps = Object.keys(result.obj());
-      const circular = await result.circular();
-      if (circular.length) {
-         logger.warn(`Circular dependencies detected: ${circular.map(c => c.join(' -> ')).join(', ')}`);
-      }
+      // const circular = await result.circular();
+      // if (circular.length) {
+      //    logger.warning(`Circular dependencies detected: ${circular.map(c => c.join(' -> ')).join(', ')}`);
+      // }
       return deps.map(dep => path.resolve(path.dirname(uxpfile), dep));
    } catch (err) {
       logger.error(`Failed to analyze dependencies with madge: ${err.message || err}`);

package/src/helpers.js

@@ -19,34 +19,15 @@ export const conicon = {
    success: '✔',
    warning: '⚠',
    error: '✖',
-   dot: '․',
-   pointer: '❯',
-   arrowRight: '→',
-   arrowDown: '↓',
-   arrowUp: '↑',
-   star: '★',
-   check: '✅',
-   cross: '❌',
-   question: '?',
-   ellipsis: '…',
-   clock: '⏱',
-   hourglass: '⏳',
-   rocket: '🚀',
-   bug: '🐞',
 };
 
 export const concolor = {
-   reset: (str) => `\x1b[0m${str}\x1b[0m`,
    red: (str) => `\x1b[31m${str}\x1b[0m`,
    green: (str) => `\x1b[32m${str}\x1b[0m`,
    yellow: (str) => `\x1b[33m${str}\x1b[0m`,
    blue: (str) => `\x1b[34m${str}\x1b[0m`,
-   magenta: (str) => `\x1b[35m${str}\x1b[0m`,
-   cyan: (str) => `\x1b[36m${str}\x1b[0m`,
-   white: (str) => `\x1b[37m${str}\x1b[0m`,
    bold: (str) => `\x1b[1m${str}\x1b[0m`,
    dim: (str) => `\x1b[2m${str}\x1b[0m`,
-   underline: (str) => `\x1b[4m${str}\x1b[0m`,
 };
 
 

package/src/index.js

@@ -24,12 +24,10 @@ program
 program
    .command("build")
    .description("Build the project")
-   .option("-f, --format <format>", "Output format (cjs, esm, umd, default)", "default")
+   .option("-f, --format <format>", "Output format (cjs, esm, both)", "both")
    .option("-b, --bundle <bundle>", "Bundle the project", false)
-   .option("-m, --minify <minify>", "Minify the output", true)
+   .option("-m, --minify <minify>", "Minify the output", false)
    .option("-s, --sourcemap <sourcemap>", "Generate sourcemaps", true)
-   .option("-t, --target <target>", "Target ECMAScript version", "es2020")
-   .option("-p, --platform <platform>", "Platform to target (node, browser)", "")
    .option("-d, --declaration <declaration>", "Generate TypeScript declaration files", true)
    .action(build);