Refactor

Author: sindresorhus

index.d.ts

@@ -62,6 +62,8 @@ export type Options = {
 	/**
 	The path to the PHP binary.
 
+	Can be useful if you have multiple versions of PHP installed.
+
 	@default 'php'
 	*/
 	readonly binary?: string;

index.js

@@ -6,63 +6,58 @@ import open from 'open';
 import binaryVersionCheck from 'binary-version-check';
 import getPort from 'get-port';
 
-const isServerRunning = (hostname, port, pathname) => new Promise((resolve, reject) => {
-	(async () => {
-		const retryDelay = 50;
-		const maxRetries = 20; // Give up after 1 second
-		let retryCount = 0;
-
-		const fetchErrorDetails = async statusCode => {
-			try {
-				const response = await fetch(`http://${hostname}:${port}${pathname}`);
-				const body = await response.text();
-				// Extract the error message from the HTML response
-				// PHP errors are wrapped in <b> tags: "<b>Fatal error</b>: ..."
-				const errorMatch = body.match(/<b>(Fatal error|Parse error|Warning|Notice)<\/b>:\s*([^<\n]+)/);
-				if (errorMatch) {
-					return `Server returned ${statusCode} error: ${errorMatch[1]}: ${errorMatch[2]}`;
-				}
-
-				return `Server returned ${statusCode} error. Please check your PHP application for possible errors.`;
-			} catch {
-				return `Server returned ${statusCode} error. Could not fetch error details.`;
+const isServerRunning = async (serverUrl, pathname) => {
+	const retryDelay = 50;
+	const maxRetries = 20; // Give up after 1 second
+	let retryCount = 0;
+
+	const fetchErrorDetails = async statusCode => {
+		try {
+			const response = await fetch(`${serverUrl}${pathname}`);
+			const body = await response.text();
+			// Extract the error message from the HTML response
+			// PHP errors are wrapped in <b> tags: "<b>Fatal error</b>: ..."
+			const errorMatch = body.match(/<b>(Fatal error|Parse error|Warning|Notice)<\/b>:\s*([^<\n]+)/);
+			if (errorMatch) {
+				return `Server returned ${statusCode} error: ${errorMatch[1]}: ${errorMatch[2]}`;
 			}
-		};
-
-		const checkServer = async () => {
-			try {
-				const response = await fetch(`http://${hostname}:${port}${pathname}`, {
-					method: 'HEAD',
-				});
-
-				const statusCodeType = Number.parseInt(response.status.toString()[0], 10);
-				if ([2, 3, 4].includes(statusCodeType)) {
-					resolve();
-					return;
-				}
-
-				if (statusCodeType === 5) {
-					const errorMessage = await fetchErrorDetails(response.status);
-					reject(new Error(errorMessage));
-					return;
-				}
-
-				await setTimeout(retryDelay);
-				await checkServer();
-			} catch (error) {
-				if (++retryCount > maxRetries) {
-					reject(new Error(`Could not start the PHP server: ${error.message}`));
-					return;
-				}
-
-				await setTimeout(retryDelay);
-				await checkServer();
+
+			return `Server returned ${statusCode} error. Please check your PHP application for possible errors.`;
+		} catch {
+			return `Server returned ${statusCode} error. Could not fetch error details.`;
+		}
+	};
+
+	const checkServer = async () => {
+		try {
+			const response = await fetch(`${serverUrl}${pathname}`, {
+				method: 'HEAD',
+			});
+
+			const statusCodeType = Math.trunc(response.status / 100);
+			if ([2, 3, 4].includes(statusCodeType)) {
+				return;
+			}
+
+			if (statusCodeType === 5) {
+				const errorMessage = await fetchErrorDetails(response.status);
+				throw new Error(errorMessage);
 			}
-		};
 
-		await checkServer();
-	})();
-});
+			await setTimeout(retryDelay);
+			await checkServer();
+		} catch (error) {
+			if (++retryCount > maxRetries) {
+				throw new Error(`Could not start the PHP server: ${error.message}`);
+			}
+
+			await setTimeout(retryDelay);
+			await checkServer();
+		}
+	};
+
+	await checkServer();
+};
 
 export default async function phpServer(options) {
 	options = {
@@ -125,22 +120,28 @@ export default async function phpServer(options) {
 
 	subprocess.ref();
 
-	process.on('exit', () => {
+	// Clean up subprocess when the parent process exits
+	const exitHandler = () => {
 		subprocess.kill();
-	});
+	};
+
+	process.once('exit', exitHandler);
+
+	// Remove the exit handler when the server is manually stopped
+	const originalStop = () => {
+		process.off('exit', exitHandler);
+		subprocess.kill();
+	};
 
 	let pathname = '/';
 	let openUrl = url;
 
 	if (typeof options.open === 'string') {
 		// Check if it's an absolute URL
 		try {
-			// eslint-disable-next-line no-new
-			new URL(options.open);
+			const parsedUrl = new URL(options.open);
 			// It's an absolute URL, use it as-is
 			openUrl = options.open;
-			// Extract pathname for server check
-			const parsedUrl = new URL(options.open);
 			pathname = parsedUrl.pathname;
 		} catch {
 			// It's a relative path, append to base URL
@@ -152,7 +153,7 @@ export default async function phpServer(options) {
 	// Check when the server is ready. Tried doing it by listening
 	// to the child process `data` event, but it's not triggered...
 	try {
-		await isServerRunning(options.hostname, options.port, pathname);
+		await isServerRunning(url, pathname);
 	} catch (error) {
 		subprocess.kill();
 		throw error;
@@ -166,8 +167,6 @@ export default async function phpServer(options) {
 		stdout: subprocess.stdout,
 		stderr: subprocess.stderr,
 		url,
-		stop() {
-			subprocess.kill();
-		},
+		stop: originalStop,
 	};
 }

readme.md

@@ -17,8 +17,21 @@ npm install php-server
 ```js
 import phpServer from 'php-server';
 
+// Basic usage
 const server = await phpServer();
 console.log(`PHP server running at ${server.url}`);
+
+// With custom configuration
+const server2 = await phpServer({
+	port: 8080,
+	hostname: 'localhost',
+	base: './public',
+	open: true, // Opens browser automatically
+});
+
+// Clean up when done
+server.stop();
+server2.stop();
 ```
 
 ## API
@@ -41,7 +54,7 @@ Type: `object`
 Type: `number`\
 Default: `0`
 
-The port on which you want to access the server.
+The port on which you want to access the webserver.
 
 Specify `0` to use a random port.
 
@@ -121,3 +134,14 @@ Type: `object`\
 Default: `{}`
 
 Add custom [INI directives](https://php.net/manual/en/ini.list.php).
+
+**Example:**
+
+```js
+const server = await phpServer({
+	directives: {
+		memory_limit: '256M',
+		max_execution_time: '60',
+	},
+});
+```

test/open-url.test.js

@@ -1,9 +1,16 @@
+import process from 'node:process';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
 import {test} from 'node:test';
 import assert from 'node:assert/strict';
 import phpServer from '../index.js';
 
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+process.chdir(__dirname);
+
 test('stdout/stderr are flowing to avoid blocking', async () => {
-	const server = await phpServer({base: 'test/fixtures/200'});
+	const server = await phpServer({base: 'fixtures/200'});
 	try {
 		assert.equal(server.stdout?.readableFlowing, true);
 		assert.equal(server.stderr?.readableFlowing, true);