@sandro-sikic/maker 1.0.4 → 1.0.6

package/.github/workflows/publish.yml

@@ -31,6 +31,9 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
+      - name: Run tests
+        run: npm test
+
       - name: Check if version already published
         id: check
         run: |

package/__tests__/index.test.js

@@ -0,0 +1,119 @@
+const maker = require('../index');
+
+describe('maker module', () => {
+	describe('init()', () => {
+		let origStdinIsTTY;
+		let origStdoutIsTTY;
+		let exitSpy;
+
+		beforeEach(() => {
+			origStdinIsTTY = process.stdin.isTTY;
+			origStdoutIsTTY = process.stdout.isTTY;
+			exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {});
+		});
+
+		afterEach(() => {
+			process.stdin.isTTY = origStdinIsTTY;
+			process.stdout.isTTY = origStdoutIsTTY;
+			exitSpy.mockRestore();
+		});
+
+		test('exits with code 1 when not running in a TTY', () => {
+			process.stdin.isTTY = false;
+			process.stdout.isTTY = false;
+			maker.init();
+			expect(exitSpy).toHaveBeenCalledWith(1);
+		});
+
+		test('does not exit when running in a TTY', () => {
+			process.stdin.isTTY = true;
+			process.stdout.isTTY = true;
+			maker.init();
+			expect(exitSpy).not.toHaveBeenCalled();
+		});
+	});
+
+	describe('run()', () => {
+		jest.setTimeout(10000);
+
+		test('resolves stdout and exit code on success', async () => {
+			const res = await maker.run('echo hello-from-run');
+			expect(res.code).toBe(0);
+			expect(res.isError).toBe(false);
+			expect(res.stdout).toMatch(/hello-from-run/);
+		});
+
+		test('reports non-zero exit code', async () => {
+			const res = await maker.run('node -e "process.exit(3)"');
+			expect(res.code).toBe(3);
+			expect(res.isError).toBe(true);
+		});
+	});
+
+	describe('onExit()', () => {
+		afterEach(() => {
+			// ensure no stray listeners between tests
+			process.removeAllListeners('SIGINT');
+		});
+
+		test('throws if callback is not a function', () => {
+			expect(() => maker.onExit(null)).toThrow(TypeError);
+		});
+
+		test('runs callback on SIGINT and exits after awaiting it', async () => {
+			const cb = jest.fn(async () => {
+				// simulate async cleanup
+				await Promise.resolve();
+			});
+			const exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {});
+
+			const dispose = maker.onExit(cb);
+
+			process.emit('SIGINT');
+			// wait for async handler to complete
+			await new Promise((r) => setImmediate(r));
+
+			expect(cb).toHaveBeenCalledTimes(1);
+			expect(exitSpy).toHaveBeenCalledWith(0);
+
+			dispose();
+			exitSpy.mockRestore();
+		});
+
+		test('disposer removes the SIGINT listener', async () => {
+			const cb = jest.fn();
+			const dispose = maker.onExit(cb);
+			dispose();
+
+			process.emit('SIGINT');
+			// allow any async microtasks to run
+			await new Promise((r) => setImmediate(r));
+			expect(cb).not.toHaveBeenCalled();
+		});
+
+		test('callback is invoked only once for repeated SIGINTs', async () => {
+			const cb = jest.fn();
+			const exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {});
+			const dispose = maker.onExit(cb);
+
+			process.emit('SIGINT');
+			process.emit('SIGINT');
+			await new Promise((r) => setImmediate(r));
+
+			expect(cb).toHaveBeenCalledTimes(1);
+			expect(exitSpy).toHaveBeenCalledTimes(1);
+
+			dispose();
+			exitSpy.mockRestore();
+		});
+	});
+
+	describe('public API', () => {
+		test('exports only prompt and spinner for runtime helpers', () => {
+			expect(typeof maker.prompt).toBe('function');
+			expect(typeof maker.spinner).toBe('function');
+			expect(maker.getPrompt).toBeUndefined();
+			expect(maker.getSpinner).toBeUndefined();
+		});
+	});
+});

package/babel.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+	presets: [
+		[
+			'@babel/preset-env',
+			{
+				targets: { node: 'current' },
+			},
+		],
+	],
+};

package/index.d.ts

@@ -17,8 +17,11 @@ export function run(
 export function onExit(cb: () => void | Promise<void>): () => void;
 
 // runtime-forwarded objects (exported as values in JS)
-export const prompt: typeof import('@inquirer/prompts');
-export const spinner: typeof import('ora');
+export const prompt: <T = any>(...args: any[]) => Promise<T | null>;
+export const spinner: (
+	text?: string,
+	options?: any,
+) => Promise<import('ora').Ora | null>;
 
 // type forwarding for downstream consumers
 export type { Ora } from 'ora';

package/index.js

@@ -1,7 +1,31 @@
-const inquirer = require('@inquirer/prompts');
 const { spawn } = require('child_process');
 const path = require('path');
-const ora = require('ora');
+
+// small helper to lazily load (CJS-first, ESM dynamic import fallback)
+function makeLazyLoader(moduleId) {
+	let _cached = null;
+	return async function load() {
+		if (_cached) return _cached;
+		try {
+			/* eslint-disable global-require, import/no-dynamic-require */
+			const mod = require(moduleId);
+			_cached = mod && (mod.default || mod);
+			return _cached;
+		} catch (err) {
+			try {
+				const ns = await import(moduleId);
+				_cached = ns && (ns.default || ns);
+				return _cached;
+			} catch (e) {
+				// unable to load in this environment — return null so callers can continue
+				return null;
+			}
+		}
+	};
+}
+
+const loadPrompts = makeLazyLoader('@inquirer/prompts');
+const loadOra = makeLazyLoader('ora');
 
 function init() {
 	// Ensure we're running in an interactive terminal
@@ -98,6 +122,9 @@ function run(command, opts = {}) {
  * Register a callback to run when the process receives SIGINT (Ctrl+C).
  * - Accepts a function (may be async).
  * - Returns a disposer function that removes the listener.
+ *
+ * Note: spinner is started asynchronously (ora is lazy-loaded); onExit itself
+ * remains synchronous so callers can register the handler immediately.
  */
 function onExit(cb) {
 	if (typeof cb !== 'function') {
@@ -105,6 +132,17 @@ function onExit(cb) {
 	}
 
 	let called = false;
+	let exiting = null;
+
+	// start spinner asynchronously (best-effort; ignore load errors)
+	loadOra().then((o) => {
+		try {
+			exiting = o('Gracefully shutting down...').start();
+		} catch (e) {
+			/* ignore */
+		}
+	});
+
 	const handler = async () => {
 		if (called) return;
 		called = true;
@@ -113,7 +151,9 @@ function onExit(cb) {
 		} catch (err) {
 			console.error('onExit callback error:', err);
 		} finally {
-			// ensure we exit after callback finishes (0 = success)
+			if (exiting && typeof exiting.stop === 'function') {
+				exiting.stop();
+			}
 			process.exit(0);
 		}
 	};
@@ -124,10 +164,23 @@ function onExit(cb) {
 	return () => process.off('SIGINT', handler);
 }
 
+// `prompt` is an async wrapper around the ESM-only `@inquirer/prompts` package.
+// `prompt(...args)` forwards the call to the underlying module and returns its result.
+async function prompt(...args) {
+	const p = await loadPrompts();
+	if (!p) return null; // prompts unavailable in this environment
+	return p(...args);
+}
+
+async function spinner(...args) {
+	const s = await loadOra();
+	return s(...args);
+}
+
 module.exports = {
 	init,
 	run,
 	onExit,
-	prompt: inquirer?.default || inquirer,
-	spinner: ora?.default || ora,
+	prompt,
+	spinner,
 };

package/jest.config.cjs

@@ -0,0 +1,8 @@
+module.exports = {
+	testEnvironment: 'node',
+	transform: {
+		'^.+\\.js$': 'babel-jest',
+	},
+	// transform @inquirer/prompts (ESM) but ignore other node_modules
+	transformIgnorePatterns: ['/node_modules/(?!(?:@inquirer/prompts)/)'],
+};

package/package.json

@@ -1,9 +1,12 @@
 {
 	"name": "@sandro-sikic/maker",
-	"version": "1.0.4",
+	"version": "1.0.6",
 	"description": "A library to create dev cli",
 	"main": "index.js",
 	"types": "index.d.ts",
+	"scripts": {
+		"test": "jest"
+	},
 	"author": "sandro-sikic",
 	"repository": {
 		"type": "git",
@@ -17,6 +20,10 @@
 	"devDependencies": {
 		"archiver": "^5.3.1",
 		"pkg": "^5.8.1",
-		"rimraf": "^5.0.1"
+		"rimraf": "^5.0.1",
+		"jest": "^29.7.0",
+		"babel-jest": "^29.7.0",
+		"@babel/core": "^7.23.0",
+		"@babel/preset-env": "^7.23.0"
 	}
 }