Apply FND's suggestions

* Improvements to FileFinder
* Doc improvement
* fileName => filename
* determineCompactors
* Inline processFiles
* Code organization
* Remove last `then`
* Inline isDotfile

Author: moonglum

lib.js

@@ -1,17 +1,6 @@
+let { FileFinder } = require("./util.js");
 let { readFile, stat } = require("node:fs/promises");
 let path = require("node:path");
-let { FileFinder } = require("./lib.js");
-/** @import {
-  *   Config,
-	*   AssetManager,
-	*   FaucetPlugin,
-	*   FaucetPluginOptions,
-	*   FaucetPluginFunc,
-	*   CompactorMap,
-	*   WriteFileOpts,
-	*   ProcessFile
-	*   } from "./types.ts"
-	**/
 
 module.exports = {
 	key: "static",
@@ -49,33 +38,18 @@ function makeCopier(copyConfig, assetManager, { compact } = {}) {
 		filter: copyConfig.filter
 	});
 	let { fingerprint } = copyConfig;
-	let compactors = determineCompactors(compact, copyConfig);
+	let compactors = (compact && copyConfig.compact) || {};
 
-	return filepaths => {
-		return Promise.all([
+	return async filepaths => {
+		let [filenames, targetDir] = await Promise.all([
 			(filepaths ? fileFinder.match(filepaths) : fileFinder.all()),
 			determineTargetDir(source, target)
-		]).then(([fileNames, targetDir]) => {
-			return processFiles(fileNames, {
-				assetManager, source, target, targetDir, compactors, fingerprint
-			});
-		});
-	};
-}
-
-/**
- * Determine which compactors should be used
- *
- * @param {boolean | undefined} compact
- * @param {Config} copyConfig
- * @returns {CompactorMap}
- */
-function determineCompactors(compact, copyConfig) {
-	if(!compact) {
-		return {};
-	}
+		]);
 
-	return copyConfig.compact || {};
+		return Promise.all(filenames.map(filename => processFile(filename, {
+			assetManager, source, target, targetDir, compactors, fingerprint
+		})));
+	};
 }
 
 /**
@@ -86,63 +60,54 @@ function determineCompactors(compact, copyConfig) {
  * @param {string} target
  * @returns {Promise<string>}
  */
-function determineTargetDir(source, target) {
-	return stat(source).
-		then(results => results.isDirectory() ? target : path.dirname(target));
+async function determineTargetDir(source, target) {
+	let results = await stat(source);
+	return results.isDirectory() ? target : path.dirname(target);
 }
 
 /**
- * @param {string[]} fileNames
- * @param {ProcessFile} config
- * @returns {Promise<unknown>}
- */
-function processFiles(fileNames, config) {
-	return Promise.all(fileNames.map(fileName => processFile(fileName, config)));
-}
-
-/**
- * @param {string} fileName
+ * @param {string} filename
  * @param {ProcessFile} opts
  * @returns {Promise<unknown>}
  */
-async function processFile(fileName,
+async function processFile(filename,
 		{ source, target, targetDir, fingerprint, assetManager, compactors }) {
-	let sourcePath = path.join(source, fileName);
-	let targetPath = path.join(target, fileName);
+	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-ignore
+		// @ts-expect-error TS2345
 		if(err.code !== "ENOENT") {
 			throw err;
 		}
 		console.error(`WARNING: \`${sourcePath}\` no longer exists`);
 		return;
 	}
 
-	let type = determineFileType(sourcePath);
-	if(type && compactors[type]) {
-		let compactor = compactors[type];
+	let fileExtension = path.extname(sourcePath).substr(1).toLowerCase();
+	if(fileExtension && compactors[fileExtension]) {
+		let compactor = compactors[fileExtension];
 		content = await compactor(content);
 	}
 
-	/**
-	 * @type WriteFileOpts
-	 */
+	/** @type WriteFileOpts */
 	let options = { targetDir };
 	if(fingerprint !== undefined) {
 		options.fingerprint = fingerprint;
 	}
 	return assetManager.writeFile(targetPath, content, options);
 }
 
-/**
- * The filetype is the lower case file extension
- *
- * @param {string} sourcePath
- * @returns {string}
- */
-function determineFileType(sourcePath) {
-	return path.extname(sourcePath).substr(1).toLowerCase();
-}
+/** @import {
+  *   Config,
+	*   AssetManager,
+	*   FaucetPlugin,
+	*   FaucetPluginOptions,
+	*   FaucetPluginFunc,
+	*   CompactorMap,
+	*   WriteFileOpts,
+	*   ProcessFile
+	*   } from "./types.ts"
+	**/

index.js renamed to lib/index.js

@@ -0,0 +1,62 @@
+// faucet-pipeline-core types
+export interface FaucetPlugin<T> {
+	(config: T[], assetManager: AssetManager, options: FaucetPluginOptions): FaucetPluginFunc
+}
+
+export interface FaucetPluginFunc {
+	(filepaths: string[]): Promise<unknown>
+}
+
+export interface FaucetPluginOptions {
+	browsers?: string[],
+	sourcemaps?: boolean,
+	compact?: boolean
+}
+
+export interface AssetManager {
+	resolvePath: (path: string, opts?: ResolvePathOpts) => string
+		writeFile: (targetPath: string, content: Buffer, options: WriteFileOpts) => Promise<unknown>
+}
+
+export interface ResolvePathOpts {
+	enforceRelative?: boolean
+}
+
+export interface WriteFileOpts {
+	targetDir: string,
+	fingerprint?: boolean
+}
+
+// faucet-pipeline-static types
+export interface Config {
+	source: string,
+	target: string,
+	targetDir: string,
+	fingerprint?: boolean,
+	compact?: CompactorMap,
+	assetManager: AssetManager,
+	filter?: (filename: string) => boolean
+}
+
+export interface CompactorMap {
+	[fileExtension: string]: Compactor
+}
+
+export interface Compactor {
+	(contact: Buffer): Promise<Buffer>
+}
+
+export interface ProcessFile {
+	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
+}

lib/types.ts

@@ -0,0 +1,67 @@
+let { readdir, stat } = require("node:fs/promises");
+let path = require("node:path");
+
+exports.FileFinder = class FileFinder {
+	/**
+	 * @param {string} root
+	 * @param {FileFinderOptions} options
+	 */
+	constructor(root, { skipDotfiles, filter }) {
+		this._root = root;
+
+		/**
+		 * @param {string} filename
+		 * @return {boolean}
+		 */
+		this._filter = filename => {
+			if(skipDotfiles && path.basename(filename).startsWith(".")) {
+				return false;
+			}
+			return filter ? filter(filename) : true;
+		};
+	}
+
+	/**
+	 * a list of relative file paths within the respective directory
+	 *
+	 * @returns {Promise<string[]>}
+	 */
+	async all() {
+		let filenames = await tree(this._root);
+		return filenames.filter(this._filter);
+	}
+
+	/**
+	 * all file paths that match the filter function
+	 *
+	 * @param {string[]} filepaths
+	 * @returns {Promise<string[]>}
+	 */
+	async match(filepaths) {
+		return filepaths.map(filepath => path.relative(this._root, filepath)).
+			filter(filename => !filename.startsWith("..")).
+			filter(this._filter);
+	}
+};
+
+/**
+ * flat list of all files of a directory tree
+ *
+ * @param {string} filepath
+ * @param {string} referenceDir
+ * @returns {Promise<string[]>}
+ */
+async function tree(filepath, referenceDir = filepath) {
+	let stats = await stat(filepath);
+
+	if(!stats.isDirectory()) {
+		return [path.relative(referenceDir, filepath)];
+	}
+
+	let entries = await Promise.all((await readdir(filepath)).map(entry => {
+		return tree(path.join(filepath, entry), referenceDir);
+	}));
+	return entries.flat();
+}
+
+/** @import { FileFinderOptions } from "./types.ts" */

lib/util.js

@@ -2,11 +2,11 @@
 	"name": "faucet-pipeline-static",
 	"version": "2.1.0",
 	"description": "static files for faucet-pipeline",
-	"main": "index.js",
+	"main": "lib/index.js",
 	"scripts": {
 		"test": "npm run lint && npm run typecheck && npm run test:cli",
 		"test:cli": "./test/run",
-		"lint": "eslint --cache index.js test && echo ✓",
+		"lint": "eslint --cache lib test && echo ✓",
 		"typecheck": "tsc"
 	},
 	"repository": {