Make this pipeline the basis for other file processors

Author: moonglum

lib/index.js

@@ -1,105 +1,67 @@
-import { FileFinder } from "./util.js";
-import { readFile, stat } from "node:fs/promises";
+import { buildProcessPipeline } from "./util.js";
+import { readFile } from "node:fs/promises";
 import * as path from "node:path";
 
 export const key = "files";
 export const bucket = "static";
 
 /** @type FaucetPlugin<Config> */
-export function plugin(config, assetManager, { compact } = {}) {
-	let copiers = config.map(copyConfig =>
-		makeCopier(copyConfig, assetManager, { compact }));
+export function plugin(config, assetManager, options) {
+	let pipeline = config.map(copyConfig => {
+		let processFile = buildProcessFile(copyConfig, options);
+		let { source, target, filter } = copyConfig;
+		return buildProcessPipeline(source, target, processFile, assetManager, filter);
+	});
 
-	return filepaths => Promise.all(copiers.map(copy => copy(filepaths)));
+	return filepaths => Promise.all(pipeline.map(copy => copy(filepaths)));
 }
 
 /**
- * Create a copier for a single configuration
+ * Returns a function that copies a single file with optional compactor
  *
  * @param {Config} copyConfig
- * @param {AssetManager} assetManager
  * @param {FaucetPluginOptions} options
- * @returns {FaucetPluginFunc}
+ * @returns {ProcessFile}
  */
-function makeCopier(copyConfig, assetManager, { compact } = {}) {
-	let source = assetManager.resolvePath(copyConfig.source);
-	let target = assetManager.resolvePath(copyConfig.target, {
-		enforceRelative: true
-	});
-	let fileFinder = new FileFinder(source, {
-		skipDotfiles: true,
-		filter: copyConfig.filter
-	});
-	let { fingerprint } = copyConfig;
-	let compactors = (compact && copyConfig.compact) || {};
+function buildProcessFile(copyConfig, options) {
+	let compactors = (options.compact && copyConfig.compact) || {};
 
-	return async filepaths => {
-		let [filenames, targetDir] = await Promise.all([
-			(filepaths ? fileFinder.match(filepaths) : fileFinder.all()),
-			determineTargetDir(source, target)
-		]);
+	return async function(filename,
+			{ source, target, targetDir, assetManager }) {
+		let sourcePath = path.join(source, filename);
+		let targetPath = path.join(target, filename);
+		let content;
 
-		return Promise.all(filenames.map(filename => processFile(filename, {
-			assetManager, source, target, targetDir, compactors, fingerprint
-		})));
-	};
-}
-
-/**
- * If `source` is a directory, `target` is used as target directory -
- * otherwise, `target`'s parent directory is used
- *
- * @param {string} source
- * @param {string} target
- * @returns {Promise<string>}
- */
-async function determineTargetDir(source, target) {
-	let results = await stat(source);
-	return results.isDirectory() ? target : path.dirname(target);
-}
-
-/**
- * @param {string} filename
- * @param {ProcessFile} opts
- * @returns {Promise<unknown>}
- */
-async function processFile(filename,
-		{ source, target, targetDir, fingerprint, assetManager, compactors }) {
-	let sourcePath = path.join(source, filename);
-	let targetPath = path.join(target, filename);
-
-	try {
-		var content = await readFile(sourcePath); // eslint-disable-line no-var
-	} catch(err) {
-		// @ts-expect-error TS2345
-		if(err.code !== "ENOENT") {
-			throw err;
+		try {
+			content = await readFile(sourcePath);
+		} catch(err) {
+			// @ts-expect-error TS2345
+			if(err.code !== "ENOENT") {
+				throw err;
+			}
+			console.error(`WARNING: \`${sourcePath}\` no longer exists`);
+			return;
 		}
-		console.error(`WARNING: \`${sourcePath}\` no longer exists`);
-		return;
-	}
 
-	let fileExtension = path.extname(sourcePath).substr(1).toLowerCase();
-	if(fileExtension && compactors[fileExtension]) {
-		let compactor = compactors[fileExtension];
-		content = await compactor(content);
-	}
+		let fileExtension = path.extname(sourcePath).substr(1).toLowerCase();
+		if(fileExtension && compactors[fileExtension]) {
+			let compactor = compactors[fileExtension];
+			content = await compactor(content);
+		}
 
-	/** @type WriteFileOpts */
-	let options = { targetDir };
-	if(fingerprint !== undefined) {
-		options.fingerprint = fingerprint;
-	}
-	return assetManager.writeFile(targetPath, content, options);
+		/** @type WriteFileOpts */
+		let options = { targetDir };
+		if(copyConfig.fingerprint !== undefined) {
+			options.fingerprint = copyConfig.fingerprint;
+		}
+		return assetManager.writeFile(targetPath, content, options);
+	};
 }
 
 /** @import {
   *   Config,
-	*   AssetManager,
 	*   FaucetPlugin,
 	*   FaucetPluginOptions,
-	*   FaucetPluginFunc,
-	*   CompactorMap,
 	*   WriteFileOpts,
 	*   ProcessFile
 	*   } from "./types.ts"

lib/types.ts

@@ -35,7 +35,7 @@ export interface Config {
 	fingerprint?: boolean,
 	compact?: CompactorMap,
 	assetManager: AssetManager,
-	filter?: (filename: string) => boolean
+	filter?: Filter
 }
 
 export interface CompactorMap {
@@ -47,16 +47,21 @@ export interface Compactor {
 }
 
 export interface ProcessFile {
+	(filename: string, opts: ProcessFileOptions): Promise<unknown>
+}
+
+export interface ProcessFileOptions {
 	source: string,
 	target: string,
 	targetDir: string,
-	fingerprint?: boolean,
-	compactors: CompactorMap,
 	assetManager: AssetManager,
-	filter?: (filename: string) => boolean
 }
 
 export interface FileFinderOptions {
 	skipDotfiles: boolean,
-	filter?: (filename: string) => boolean
+	filter?: Filter
+}
+
+export interface Filter {
+	(filename: string): boolean
 }

lib/util.js

@@ -1,7 +1,52 @@
 import { readdir, stat } from "node:fs/promises";
 import * as path from "node:path";
 
-export class FileFinder {
+/**
+ * Creates a processor for a single configuration
+ *
+ * @param {string} source - the source folder or file for this pipeline
+ * @param {string} target - the target folder or file for this pipeline
+ * @param {ProcessFile} processFile - process a single file
+ * @param {AssetManager} assetManager
+ * @param {Filter} [filter] - optional filter based on filenames
+ * @returns {FaucetPluginFunc}
+ */
+export function buildProcessPipeline(source, target, processFile, assetManager, filter) {
+	source = assetManager.resolvePath(source);
+	target = assetManager.resolvePath(target, {
+		enforceRelative: true
+	});
+	let fileFinder = new FileFinder(source, {
+		skipDotfiles: true,
+		filter
+	});
+
+	return async filepaths => {
+		let [filenames, targetDir] = await Promise.all([
+			(filepaths ? fileFinder.match(filepaths) : fileFinder.all()),
+			determineTargetDir(source, target)
+		]);
+
+		return Promise.all(filenames.map(filename => processFile(filename, {
+			assetManager, source, target, targetDir
+		})));
+	};
+}
+
+/**
+ * If `source` is a directory, `target` is used as target directory -
+ * otherwise, `target`'s parent directory is used
+ *
+ * @param {string} source
+ * @param {string} target
+ * @returns {Promise<string>}
+ */
+async function determineTargetDir(source, target) {
+	let results = await stat(source);
+	return results.isDirectory() ? target : path.dirname(target);
+}
+
+class FileFinder {
 	/**
 	 * @param {string} root
 	 * @param {FileFinderOptions} options
@@ -22,7 +67,7 @@ export class FileFinder {
 	}
 
 	/**
-	 * a list of relative file paths within the respective directory
+	 * A list of relative file paths within the respective directory
 	 *
 	 * @returns {Promise<string[]>}
 	 */
@@ -32,7 +77,7 @@ export class FileFinder {
 	}
 
 	/**
-	 * all file paths that match the filter function
+	 * All file paths that match the filter function
 	 *
 	 * @param {string[]} filepaths
 	 * @returns {Promise<string[]>}
@@ -45,7 +90,7 @@ export class FileFinder {
 }
 
 /**
- * flat list of all files of a directory tree
+ * Flat list of all files of a directory tree
  *
  * @param {string} filepath
  * @param {string} referenceDir
@@ -64,4 +109,11 @@ async function tree(filepath, referenceDir = filepath) {
 	return entries.flat();
 }
 
-/** @import { FileFinderOptions } from "./types.ts" */
+/** @import {
+	*   AssetManager,
+	*   FaucetPluginFunc,
+	*   Filter,
+	*   FileFinderOptions,
+	*   ProcessFile
+	*   } from "./types.ts"
+	**/