Restore the TypeScript sources

Author: Cédric Belin

bin/php_minifier.js

@@ -5,8 +5,8 @@ import {dirname, join, resolve} from "node:path";
 import process from "node:process";
 import {parseArgs} from "node:util";
 import readdirp from "readdirp";
-import pkg from "../package.json" with {type: "json"};
 import {FastTransformer, SafeTransformer, TransformMode} from "../lib/index.js";
+import pkg from "../package.json" with {type: "json"};
 
 // Give the process a friendly name.
 process.title = "PHP Minifier";
@@ -64,41 +64,19 @@ try {
 
 	// Process the PHP files.
 	const output = positionals.length > 1 ? resolve(positionals[1]) : input;
-	await processFiles(input, output, values);
-}
-catch (error) {
-	console.error(error instanceof Error ? error.message : error);
-	process.exit(1);
-}
+	const transformer = values.mode == TransformMode.fast ? new FastTransformer(values.binary) : new SafeTransformer(values.binary);
 
-/**
- * Processes the PHP files located in the specified input directory.
- * @param {string} input The path to the input directory.
- * @param {string} output The path to the output directory.
- * @param {Partial<CliOptions>} options The command line arguments.
- * @returns {Promise<void>} Resolves when all PHP files have been processed.
- */
-async function processFiles(input, output, options = {}) {
-	const binary = options.binary ?? "php";
-	const silent = options.silent ?? false;
-
-	const transformer = (options.mode ?? "safe") == TransformMode.fast ? new FastTransformer(binary) : new SafeTransformer(binary);
-	for await (const file of readdirp(input, {fileFilter: `*.${options.extension ?? "php"}`})) {
-		if (!silent) console.log(`Minifying: ${file.path}`);
+	for await (const file of readdirp(input, {fileFilter: `*.${values.extension}`})) {
+		if (!values.silent) console.log(`Minifying: ${file.path}`);
 		const script = await transformer.transform(file.fullPath);
 		const path = join(output, file.path);
 		await mkdir(dirname(path), {recursive: true});
 		await writeFile(path, script);
 	}
 
-	return transformer.close();
+	await transformer.close();
+}
+catch (error) {
+	console.error(error instanceof Error ? error.message : error);
+	process.exit(1);
 }
-
-/**
- * Defines the command line options.
- * @typedef {object} CliOptions
- * @property {string} binary The path to the PHP executable.
- * @property {string} extension The extension of the PHP files to process.
- * @property {string} mode The operation mode of the minifier.
- * @property {boolean} silent Value indicating whether to silence the minifier output.
- */

etc/eslint.js

@@ -79,7 +79,7 @@ export default ts.config(
 			"no-implicit-globals": "error",
 			"no-implied-eval": "error",
 			"no-inline-comments": "off",
-			"no-invalid-this": "error",
+			"no-invalid-this": "off",
 			"no-iterator": "error",
 			"no-label-var": "error",
 			"no-labels": "error",
@@ -202,7 +202,7 @@ export default ts.config(
 		}
 	},
 	{
-		files: ["gulpfile.js", "test/**/*.js"],
+		files: ["gulpfile.js", "example/*.js", "test/**/*.js"],
 		rules: {
 			"prefer-arrow-callback": "off",
 			"@typescript-eslint/explicit-function-return-type": "off",

gulpfile.js

@@ -1,9 +1,12 @@
 import {env} from "node:process";
 import {deleteAsync} from "del";
-import {$} from "execa";
+import {execa} from "execa";
 import gulp from "gulp";
 import pkg from "./package.json" with {type: "json"};
 
+// Runs a command.
+const $ = execa({preferLocal: true, stdio: "inherit"});
+
 // Builds the project.
 export function build() {
 	return $`tsc --project src/tsconfig.json`;

src/fast_transformer.js renamed to src/fast_transformer.ts

@@ -1,66 +1,61 @@
-import {spawn} from "node:child_process";
+import {spawn, type ChildProcess} from "node:child_process";
 import {normalize, resolve} from "node:path";
 import {setTimeout} from "node:timers";
 import getPort from "get-port";
+import type {Transformer} from "./transformer.js";
 
 /**
  * Removes comments and whitespace from a PHP script, by calling a Web service.
  */
-export class FastTransformer {
+export class FastTransformer implements Transformer {
 
 	/**
 	 * The address that the server is listening on.
-	 * @type {string}
-	 * @readonly
 	 */
-	static #address = "127.0.0.1";
+	static readonly #address = "127.0.0.1";
 
 	/**
 	 * The path to the PHP executable.
-	 * @type {string}
-	 * @readonly
 	 */
-	#executable;
+	readonly #executable: string;
 
 	/**
 	 * The port that the PHP process is listening on.
-	 * @type {number}
 	 */
 	#port = -1;
 
 	/**
 	 * The underlying PHP process.
-	 * @type {import("node:child_process").ChildProcess|null}
 	 */
-	#process = null;
+	#process: ChildProcess|null = null;
 
 	/**
 	 * Creates a new fast transformer.
-	 * @param {string} executable The path to the PHP executable.
+	 * @param executable The path to the PHP executable.
 	 */
 	constructor(executable = "php") {
 		this.#executable = normalize(executable);
 	}
 
 	/**
 	 * Closes this transformer and releases any resources associated with it.
-	 * @returns {Promise<void>} Resolves when the transformer is finally disposed.
+	 * @returns Resolves when the transformer is finally disposed.
 	 */
-	close() {
+	close(): Promise<void> {
 		this.#process?.kill();
 		this.#process = null;
 		return Promise.resolve();
 	}
 
 	/**
 	 * Starts the underlying PHP process and begins accepting connections.
-	 * @returns {Promise<number>} The port used by the PHP process.
+	 * @returns The port used by the PHP process.
 	 */
-	async listen() {
+	async listen(): Promise<number> {
 		if (this.#process) return this.#port;
 		this.#port = await getPort();
 
-		const {promise, reject, resolve: fulfill} = Promise.withResolvers();
+		const {promise, reject, resolve: fulfill} = Promise.withResolvers<number>();
 		const args = ["-S", `${FastTransformer.#address}:${this.#port}`, "-t", import.meta.dirname];
 		this.#process = spawn(this.#executable, args, {stdio: ["ignore", "pipe", "ignore"]});
 		this.#process.on("error", reject);
@@ -70,10 +65,10 @@ export class FastTransformer {
 
 	/**
 	 * Processes a PHP script.
-	 * @param {string} file The path to the PHP script.
-	 * @returns {Promise<string>} The transformed script.
+	 * @param file The path to the PHP script.
+	 * @returns The transformed script.
 	 */
-	async transform(file) {
+	async transform(file: string): Promise<string> {
 		const port = await this.listen();
 		const url = new URL(`http://${FastTransformer.#address}:${port}/index.php`);
 		url.searchParams.set("file", resolve(file));

src/gulp_plugin.js

@@ -0,0 +1,80 @@
+import {Transform, type TransformCallback} from "node:stream";
+import log from "fancy-log";
+import PluginError from "plugin-error";
+import type File from "vinyl";
+import {FastTransformer} from "./fast_transformer.js";
+import {SafeTransformer} from "./safe_transformer.js";
+import {TransformMode} from "./transform_mode.js";
+import type {Transformer} from "./transformer.js";
+
+/**
+ * Minifies PHP source code by removing comments and whitespace.
+ */
+export class GulpPlugin extends Transform {
+
+	/**
+	 * Value indicating whether to silence the plugin output.
+	 */
+	readonly #silent: boolean;
+
+	/**
+	 * The instance used to process the PHP code.
+	 */
+	readonly #transformer: Transformer;
+
+	/**
+	 * Creates a new plugin.
+	 * @param options An object providing values to initialize this instance.
+	 */
+	constructor(options: Partial<GulpPluginOptions> = {}) {
+		super({objectMode: true});
+
+		const binary = options.binary ?? "php";
+		this.#silent = options.silent ?? false;
+		this.#transformer = (options.mode ?? TransformMode.safe) == TransformMode.fast ? new FastTransformer(binary) : new SafeTransformer(binary);
+
+		const close = async (): Promise<void> => { await this.#transformer.close(); };
+		this.on("end", close).on("error", close); // eslint-disable-line @typescript-eslint/no-misused-promises
+	}
+
+	/**
+	 * Transforms input and produces output.
+	 * @param chunk The chunk to transform.
+	 * @param encoding The encoding type if the chunk is a string.
+	 * @param callback The function to invoke when the supplied chunk has been processed.
+	 * @returns The transformed chunk.
+	 */
+	override async _transform(chunk: File, encoding: NodeJS.BufferEncoding, callback: TransformCallback): Promise<File> {
+		try {
+			if (!this.#silent) log(`Minifying: ${chunk.relative}`);
+			chunk.contents = Buffer.from(await this.#transformer.transform(chunk.path), encoding);
+			callback(null, chunk);
+		}
+		catch (error) {
+			callback(new PluginError("@cedx/php-minifier", error instanceof Error ? error : String(error), {fileName: chunk.path}));
+		}
+
+		return chunk;
+	}
+}
+
+/**
+ * Defines the options of a {@link GulpPlugin} instance.
+ */
+export interface GulpPluginOptions {
+
+	/**
+	 * The path to the PHP executable.
+	 */
+	binary: string;
+
+	/**
+	 * The operation mode of the plugin.
+	 */
+	mode: TransformMode|"fast"|"safe";
+
+	/**
+	 * Value indicating whether to silence the plugin output.
+	 */
+	silent: boolean;
+}

src/gulp_plugin.ts

@@ -0,0 +1,16 @@
+import {GulpPlugin, type GulpPluginOptions} from "./gulp_plugin.js";
+
+export * from "./fast_transformer.js";
+export * from "./gulp_plugin.js";
+export * from "./safe_transformer.js";
+export * from "./transform_mode.js";
+export * from "./transformer.js";
+
+/**
+ * Creates a new plugin.
+ * @param options The plugin options.
+ * @returns The newly created instance.
+ */
+export default function phpMinifier(options: Partial<GulpPluginOptions> = {}): GulpPlugin {
+	return new GulpPlugin(options);
+}