makepack 1.6.9 → 1.6.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "makepack",
-  "version": "1.6.9",
+  "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,15 +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",
-    "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": [
@@ -56,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/start/index.js

@@ -1,117 +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';
+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));
+   });
+}
 
-let __filename, __dirname;
+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 (typeof import.meta.url !== 'undefined') {
-   __filename = fileURLToPath(import.meta.url);
-   __dirname = path.dirname(__filename);
-} else {
-   __filename = __filename;
-   __dirname = __dirname;
-}
+   if (viteServer) {
+      await viteServer.close();
+   }
 
-const startServer = () => {
-   const mpack = path.join(process.cwd(), '.mpack')
-   const server = spawn('node', [path.resolve(mpack, 'index.js')], {
-      stdio: 'inherit',
-   });
+   app = express();
+   try {
+      const middleware = await loadExp();
+      if (typeof middleware === 'function') {
+         middleware(app);
+      }
 
-   server.on('error', (err) => {
-      console.error(`Error starting server: ${err.message}`);
-   });
-   return server;
+      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}`);
+   }
 }
 
-const start = async (args) => {
-   let port = args.port || 4000
 
-   // create a folder call .mpack
-   const mpack = path.join(process.cwd(), '.mpack')
-   if (fs.existsSync(mpack)) {
-      fs.rmSync(mpack, { recursive: true, force: true });
+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];
+         }
+      }
    }
-   fs.mkdirSync(mpack)
-
-   let format = 'esm'
-   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'
+
+   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();
+      }
+
+      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, 'core.js'),
-      bundle: true,
-      minify: true,
-      format,
-      platform: 'node',
-      packages: 'external',
-      define: {
-         'process.env.PORT': JSON.stringify(port),
-      },
-   })
-
-   const uxpjs = path.join(process.cwd(), 'express.js')
-   const uxpts = path.join(process.cwd(), 'express.ts')
-   const exists = fs.existsSync(uxpjs) || fs.existsSync(uxpts);
-   const uxpFile = exists ? (fs.existsSync(uxpjs) ? 'express.js' : 'express.ts') : '';
-   let contents = `import server from './.mpack/core';`;
-   contents += uxpFile ? `
-         import uxp from './${uxpFile}';
-         server(uxp);
-      ` : `server();`;
-
-   const result = await esbuild.build({
-      bundle: true,
-      stdin: {
-         contents,
-         resolveDir: process.cwd(),
-         sourcefile: 'virtual.js',
-         loader: 'ts',
-      },
-      format,
-      outfile: path.join(mpack, 'index.js'),
-      platform: 'node',
-      packages: 'external',
-      sourcemap: true,
-      metafile: true,
-   })
-
-   let server = startServer();
-   if (uxpFile) {
-      const importedFiles = Object.keys(result.metafile.inputs);
-      const watcher = chokidar.watch(importedFiles, {
-         ignored: /node_modules/,
-         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 () => {
-         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/actions/start/express.js

@@ -1,45 +0,0 @@
-import express from 'express';
-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 (cb) => {
-
-   // 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';
-   }
-
-   if (cb) {
-      cb(app)
-   }
-
-   // 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, () => {
-      console.log(`Server is running on: http://localhost:${port}`);
-   });
-}
-
-export default server;