makepack 1.6.8 → 1.6.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "makepack",
-  "version": "1.6.8",
+  "version": "1.6.10",
   "type": "module",
   "description": "A CLI tool to create, build, and manage JavaScript, TypeScript, React, and React-TypeScript libraries for npm projects.",
   "files": [
@@ -33,16 +33,14 @@
     "chalk": "^5.4.1",
     "chokidar": "^4.0.3",
     "commander": "^12.1.0",
-    "cosmiconfig": "^9.0.0",
-    "esbuild": "^0.25.0",
+    "esbuild": "^0.25.5",
     "express": "^4.21.1",
-    "figlet": "^1.8.0",
-    "figures": "^6.1.0",
     "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",
-    "typescript": "^5.7.2",
     "vite": "^6.0.2"
   },
   "keywords": [
@@ -57,6 +55,7 @@
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "react": "^19.0.0",
-    "react-dom": "^19.0.0"
+    "react-dom": "^19.0.0",
+    "typescript": "^5.7.2"
   }
 }

package/src/actions/build/index.js

@@ -1,17 +1,16 @@
 import esbuild from 'esbuild'
 import fs from 'fs-extra'
 import path from 'path'
-import chalk from 'chalk'
 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,
-      // outExtension: { '.js': ebconfig.format === 'esm' ? '.mjs' : '.cjs' },
       loader: {
          '.ts': 'ts',
          '.tsx': 'tsx'
@@ -70,12 +69,12 @@ const build = async (args) => {
       }
       if (args.format === 'default') {
          await eBuild({ ...config, format: "esm" });
-         spinner.succeed('ESM build generated successfully!');
+         logger.success('ESM build generated successfully!');
          await eBuild({ ...config, format: "cjs" });
-         spinner.succeed('CJS build generated successfully!');
+         logger.success('CJS build generated successfully!');
       } else {
          await eBuild({ ...config, format: args.format });
-         spinner.succeed(`${args.format} build generated successfully!`);
+         logger.success(`${args.format} build generated successfully!`);
       }
    }
 
@@ -91,7 +90,7 @@ const build = async (args) => {
          );
 
          if (!parsedConfig) {
-            console.error("❌ Error parsing tsconfig.json");
+            logger.error("Error parsing tsconfig.json");
             process.exit(1);
          } else {
             tsconfig = parsedConfig.options;
@@ -120,13 +119,13 @@ const build = async (args) => {
             const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
             if (diagnostic.file) {
                const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-               spinner.fail(`Error at ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+               logger.error(`Error at ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
             } else {
-               spinner.fail(`Error: ${message}`);
+               logger.error(`${message}`);
             }
          });
       } else {
-         spinner.succeed("TypeScript declaration files generated successfully!")
+         logger.success("TypeScript declaration files generated successfully!")
       }
    }
    spinner.text = "Copying package.json and readme.md files..."
@@ -139,15 +138,16 @@ const build = async (args) => {
       delete pkgjson.type
       fs.writeFileSync(path.join(outdir, 'package.json'), JSON.stringify(pkgjson, null, 2));
    } else {
-      spinner.fail("package.json not found!");
+      logger.error("package.json not found!");
       return;
    }
 
    fs.copyFileSync(path.join(process.cwd(), '/readme.md'), path.join(outdir, `/readme.md`))
-   spinner.succeed("package.json and readme.md files copied successfully!")
-   console.log(chalk.green(`\nBuild completed successfully!`));
-   console.log(`\nTo publish your package to npm:`);
-   console.log(`${chalk.green(`npm run release`)} or navigate to the ${chalk.green(`.mpack`)} directory and run ${chalk.green(`npm publish`)}`);
+   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.stop();
 }
 
 export default build

package/src/actions/create/index.js

@@ -1,10 +1,8 @@
-import { execSync, logger } from "../../helpers.js"
+import { execSync, concolor, logger } from "../../helpers.js"
 import makeFiles from "./makeFiles.js"
 import path from 'path'
 import inquirer from 'inquirer'
-import figlet from 'figlet'
 import fs from "fs-extra"
-import chalk from 'chalk';
 const cwd = process.cwd()
 const cwdFolder = cwd.split(path.sep).pop()
 
@@ -89,16 +87,10 @@ const create = async () => {
 
    logger.success("Project setup complete!", "")
    if (isCurrentDir) {
-      console.log(`Run the development server: ${chalk.blue("npm start")}\nEnjoy your new project! 😊`);
+      logger.info(`Run the development server: ${concolor.yellow("npm start")}\nEnjoy your new project! 😊`);
    } else {
-      console.log(`Navigate to your project directory:\n${chalk.blue("cd " + info.pdir, false)} and Run the development server: ${chalk.blue("npm start")}\nEnjoy your new project! 😊`);
+      logger.info(`Navigate to your project directory:\n${concolor.yellow("cd " + info.pdir, false)} and Run the development server: ${concolor.yellow("npm start")}\nEnjoy your new project! 😊`);
    }
-
-   figlet("Makepack CLI", function (err, data) {
-      if (!err) {
-         console.log(data);
-      }
-   });
 }
 
 export default create

package/src/actions/start/index.js

@@ -1,118 +1,172 @@
-import path from 'path'
-import fs from 'fs'
-import { spawn } from 'child_process'
-import esbuild from 'esbuild';
-import { fileURLToPath } from 'url';
+import express from 'express';
+import path from 'path';
+import fs from 'fs';
+import { pathToFileURL } from 'url';
+import { createRequire } from 'module';
 import chokidar from 'chokidar';
-
-let __filename, __dirname;
-
-if (typeof import.meta.url !== 'undefined') {
-   __filename = fileURLToPath(import.meta.url);
-   __dirname = path.dirname(__filename);
-} else {
-   __filename = __filename;
-   __dirname = __dirname;
-}
-
-
-const startServer = () => {
-   const mpack = path.join(process.cwd(), '.mpack')
-   const server = spawn('node', [path.resolve(mpack, 'index.js')], {
-      stdio: 'inherit',
-   });
-
-   server.on('error', (err) => {
-      console.error(`Error starting server: ${err.message}`);
+import madge from 'madge';
+import viteSetup from './vite.js';
+import * as esbuild from 'esbuild';
+import { randomUUID } from 'crypto';
+import debounce from 'lodash.debounce';
+import { logger, concolor } from '../../helpers.js';
+
+const projectRoot = process.cwd();
+const requireFn = createRequire(import.meta.url);
+
+let server = null;
+let app = null;
+let viteServer = null;
+
+const pkg = path.join(process.cwd(), 'package.json');
+const pkgjson = JSON.parse(fs.readFileSync(pkg, 'utf-8'));
+let isEsmProject = pkgjson.type === 'module';
+
+const uxpfileJS = path.resolve(projectRoot, 'express.js');
+const uxpfileTS = path.resolve(projectRoot, 'express.ts');
+const expExists = fs.existsSync(uxpfileJS) || fs.existsSync(uxpfileTS);
+let uxpfile = expExists ? (fs.existsSync(uxpfileJS) ? uxpfileJS : uxpfileTS) : null;
+
+const connections = new Set();
+
+function trackConnections(srv) {
+   srv.on('connection', (conn) => {
+      connections.add(conn);
+      conn.on('close', () => connections.delete(conn));
    });
-   return server;
 }
 
-const start = async (args) => {
-   let { port } = args
+async function bootServer(args) {
+   let wasServer = !!server;
+   if (server) {
+      for (const conn of connections) {
+         conn.destroy();
+      }
+      await new Promise((resolve, reject) => {
+         server.close(err => {
+            if (err) {
+               logger.error(`while closing server: ${err.message || err}`);
+               reject(err);
+            } else {
+               resolve();
+            }
+         });
+      });
+      server = null;
+   }
 
-   if (!port) {
-      port = 4000;
+   if (viteServer) {
+      await viteServer.close();
    }
-   // create a folder call .mpack
-   const mpack = path.join(process.cwd(), '.mpack')
-   if (fs.existsSync(mpack)) {
-      fs.rmSync(mpack, { recursive: true, force: true });
+
+   app = express();
+   try {
+      const middleware = await loadExp();
+      if (typeof middleware === 'function') {
+         middleware(app);
+      }
+
+      viteServer = await viteSetup(app);
+      const port = args.port || 4000;
+      server = app.listen(port, () => {
+         if (!wasServer) {
+            logger.success(`Server running on: ${concolor.green(concolor.bold(`http://localhost:${port}`))}`, '')
+         }
+         trackConnections(server);
+      })
+   } catch (err) {
+      logger.error(`Failed to start server: ${err.message || err}`);
    }
-   fs.mkdirSync(mpack)
+}
 
 
-   // build ./express.js to .mpack/index.js with esbuild
-   let format = 'esm'
-   // get format from package.json
-   const pkg = path.join(process.cwd(), 'package.json')
-   if (fs.existsSync(pkg)) {
-      const pkgjson = JSON.parse(fs.readFileSync(pkg, 'utf-8'))
-      if (pkgjson.type === 'commonjs') {
-         format = 'cjs'
+let esbuildCtx = null;
+const mpack = path.join(projectRoot, '.mpack');
+if (fs.existsSync(mpack)) {
+   fs.rmSync(mpack, { recursive: true, force: true });
+}
+fs.mkdirSync(mpack, { recursive: true });
+const buildFile = path.join(mpack, `${randomUUID().substring(0, 15)}.js`);
+
+async function loadExp() {
+   if (!expExists) return null
+
+   const cacheKeys = Object.keys(requireFn.cache || {});
+   if (!isEsmProject) {
+      for (const key of cacheKeys) {
+         if (key.startsWith(process.cwd())) {
+            delete requireFn.cache[key];
+         }
       }
    }
 
-   const uxpjs = path.join(process.cwd(), 'express.js')
-   const uxpts = path.join(process.cwd(), 'express.ts')
-
-   if (fs.existsSync(uxpjs) || fs.existsSync(uxpts)) {
-      let filename = fs.existsSync(uxpjs) ? "express.js" : "express.ts";
-      let outfile = path.join(mpack, 'uxp.js');
+   const ext = path.extname(uxpfile);
+   const isTs = ext === '.ts';
+
+   if (isTs) {
+      if (esbuildCtx) {
+         await esbuildCtx.rebuild();
+      } else {
+         esbuildCtx = await esbuild.context({
+            entryPoints: [uxpfile],
+            outfile: buildFile,
+            format: isEsmProject ? 'esm' : 'cjs',
+            platform: 'node',
+            sourcemap: 'inline',
+            bundle: true,
+            packages: 'external',
+         });
+         await esbuildCtx.rebuild();
+      }
 
-      const ctx = await esbuild.context({
-         entryPoints: [filename],
-         outfile,
-         bundle: true,
-         format: 'esm',
-         platform: 'node',
-         packages: 'external',
-      })
-      ctx.watch()
+      if (isEsmProject) {
+         const mod = await import(pathToFileURL(buildFile).href + `?update=${Date.now()}`);
+         return mod.default || mod;
+      } else {
+         return requireFn(buildFile);
+      }
    }
 
-   await esbuild.build({
-      entryPoints: [path.resolve(__dirname, 'express.js')],
-      outfile: path.join(mpack, 'index.js'),
-      bundle: true,
-      format,
-      platform: 'node',
-      packages: 'external',
-      define: {
-         'process.env.PORT': JSON.stringify(port),
-      },
-   })
-
-   let server = startServer();
-
-   const uxp = path.join(mpack, 'uxp.js')
-
-   if (fs.existsSync(uxp)) {
-      const watcher = chokidar.watch(uxp, {
-         persistent: true,
-         ignoreInitial: true,
-      });
+   if (isEsmProject) {
+      const mod = await import(pathToFileURL(uxpfile).href + `?update=${Date.now()}`);
+      return mod.default || mod;
+   } else {
+      return requireFn(uxpfile);
+   }
+}
 
-      watcher.on('change', async () => {
-         // restart the server and remove log Server exited with code
-         server.kill();
-         server = startServer();
-      });
+async function getAllDependencies() {
+   try {
+      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(', ')}`);
+      }
+      return deps.map(dep => path.resolve(path.dirname(uxpfile), dep));
+   } catch (err) {
+      logger.error(`Failed to analyze dependencies with madge: ${err.message || err}`);
+      return [uxpfile];
    }
+}
 
-   process.on('SIGINT', () => {
-      console.log('Received SIGINT, killing server...');
-      server.kill('SIGINT');
-      process.exit(0);
-   });
 
-   process.on('SIGTERM', () => {
-      console.log('Received SIGTERM, killing server...');
-      server.kill('SIGTERM');
-      process.exit(0);
-   });
+let watcher;
+async function startDevServer(args) {
+   await bootServer(args);
+   const filesToWatch = await getAllDependencies();
+   if (watcher) watcher.close();
+   watcher = chokidar.watch(filesToWatch, { ignoreInitial: true });
 
-}
+   const reload = debounce(async (f) => {
+      await bootServer(args);
+      const prettyPath = concolor.dim(path.relative(process.cwd(), f));
+      logger.info(`${concolor.green('server reload')} ${prettyPath}`);
+   }, 100);
 
+   watcher.on('change', reload);
+   watcher.on('add', reload);
+   watcher.on('unlink', reload);
+}
 
-export default start
+export default startDevServer

package/src/actions/start/vite.js

@@ -55,6 +55,7 @@ const viteSetup = async (app) => {
          next(e);
       }
    });
+   return vite;
 }
 
 

package/src/helpers.js

@@ -1,7 +1,4 @@
 import child_process from 'child_process'
-import chalk from 'chalk';
-import figures from 'figures';
-
 export const execSync = (command, option = {}) => {
    try {
       const result = child_process.execSync(command, {
@@ -17,21 +14,59 @@ export const execSync = (command, option = {}) => {
 };
 
 
+export const conicon = {
+   info: 'ℹ',
+   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`,
+};
+
 
 export const logger = {
+   log: (message, prefix, icon, color) => {
+      let _color = concolor[color] || concolor.reset;
+      let _icon = conicon[icon] || '';
+      prefix = prefix ? _color(concolor.bold(prefix)) : "";
+      console.log(`${_icon ? _color(_icon) + " " : ""}${prefix} ${message}`);
+   },
    info: (message, prefix = 'INFO', icon = true) => {
-      console.log(`${icon ? chalk.blue(figures.info) + " " : ""}${chalk.cyan.bold(prefix)} ${message}`);
+      logger.log(message, prefix, icon ? 'info' : '', 'blue');
    },
    success: (message, prefix = 'SUCCESS:', icon = true) => {
-      console.log(`${icon ? chalk.green(figures.tick) + " " : ""}${chalk.green.bold(prefix)} ${message}`);
+      logger.log(message, prefix, icon ? 'success' : '', 'green');
    },
    warning: (message, prefix = 'WARNING:', icon = true) => {
-      console.log(`${icon ? chalk.yellow(figures.warning) + " " : ""}${chalk.yellow.bold(prefix)} ${message}`);
+      logger.log(message, prefix, icon ? 'warning' : '', 'yellow');
    },
    error: (message, prefix = 'ERROR:', icon = true) => {
-      console.log(`${icon ? chalk.red(figures.cross) + " " : ""}${chalk.red.bold(prefix)} ${message}`);
-   },
-   custom: (icon, color, label, message) => {
-      console.log(`${chalk[color](icon)} ${chalk[color].bold(`${label}:`)} ${message}`);
-   },
+      logger.log(message, prefix, icon ? 'error' : '', 'red');
+   }
 };

package/src/actions/start/express.js

@@ -1,43 +0,0 @@
-import express from 'express';
-import { logger } from '../../helpers.js'
-import chalk from 'chalk';
-import path from 'path'
-import fs from 'fs'
-import viteSetup from './vite.js';
-const port = process.env.PORT || 3000;
-const app = express();
-const server = async () => {
-
-   // get type from package.json
-   const pkg = path.join(process.cwd(), 'package.json');
-   let type = 'module';
-   if (fs.existsSync(pkg)) {
-      const pkgjson = JSON.parse(fs.readFileSync(pkg, 'utf-8'));
-      type = pkgjson.type || 'module';
-   }
-
-   const mpack = path.join(process.cwd(), '.mpack');
-   const uxp = path.join(mpack, 'uxp.js')
-   if (fs.existsSync(uxp)) {
-      // load user-express.js based on type
-      if (type === 'module') {
-         const { default: userExpress } = await import(uxp);
-         userExpress(app);
-      } else {
-         const userExpress = require(uxp).default;
-         userExpress(app);
-      }
-   }
-
-
-   await viteSetup(app)
-   app.use((_req, res) => {
-      res.status(500).send('Internal Server Error');
-   });
-
-   app.listen(port, () => {
-      logger.success(`Server is running on ${chalk.blue(chalk.underline(`http://localhost:${port}`))}`);
-   });
-}
-
-server()