Vendor FileFinder to make this dual compatible, type the code

Author: moonglum

index.js

@@ -1,20 +1,44 @@
-let { readFile, stat } = require("fs").promises;
-let path = require("path");
-let { FileFinder } = require("faucet-pipeline-core/lib/util/files/finder");
+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",
 	bucket: "static",
 	plugin: faucetStatic
 };
 
+/**
+ * The static plugin copies files with an option to define compaction functions
+ *
+ * @type FaucetPlugin<Config>
+ */
 function faucetStatic(config, assetManager, { compact } = {}) {
 	let copiers = config.map(copyConfig =>
 		makeCopier(copyConfig, assetManager, { compact }));
 
 	return filepaths => Promise.all(copiers.map(copy => copy(filepaths)));
 }
 
+/**
+ * Create a copier for a single configuration
+ *
+ * @param {Config} copyConfig
+ * @param {AssetManager} assetManager
+ * @param {FaucetPluginOptions} options
+ * @returns {FaucetPluginFunc}
+ */
 function makeCopier(copyConfig, assetManager, { compact } = {}) {
 	let source = assetManager.resolvePath(copyConfig.source);
 	let target = assetManager.resolvePath(copyConfig.target, {
@@ -25,47 +49,71 @@ function makeCopier(copyConfig, assetManager, { compact } = {}) {
 		filter: copyConfig.filter
 	});
 	let { fingerprint } = copyConfig;
-	let plugins = determinePlugins(compact, copyConfig);
+	let compactors = determineCompactors(compact, copyConfig);
 
 	return filepaths => {
 		return Promise.all([
 			(filepaths ? fileFinder.match(filepaths) : fileFinder.all()),
 			determineTargetDir(source, target)
 		]).then(([fileNames, targetDir]) => {
 			return processFiles(fileNames, {
-				assetManager, source, target, targetDir, plugins, fingerprint
+				assetManager, source, target, targetDir, compactors, fingerprint
 			});
 		});
 	};
 }
 
-function determinePlugins(compact, copyConfig) {
+/**
+ * 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 || {};
 }
 
-// If `source` is a directory, `target` is used as target directory -
-// otherwise, `target`'s parent directory is used
+/**
+ * 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>}
+ */
 function determineTargetDir(source, target) {
 	return stat(source).
 		then(results => 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 {ProcessFile} opts
+ * @returns {Promise<unknown>}
+ */
 async function processFile(fileName,
-		{ source, target, targetDir, fingerprint, assetManager, plugins }) {
+		{ 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-ignore
 		if(err.code !== "ENOENT") {
 			throw err;
 		}
@@ -74,18 +122,27 @@ async function processFile(fileName,
 	}
 
 	let type = determineFileType(sourcePath);
-	if(type && plugins[type]) {
-		let plugin = plugins[type];
-		content = await plugin(content);
+	if(type && compactors[type]) {
+		let compactor = compactors[type];
+		content = await compactor(content);
 	}
 
+	/**
+	 * @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();
 }

lib.js

@@ -0,0 +1,100 @@
+let { readdir, stat } = require("node:fs/promises");
+let path = require("node:path");
+/** @import { FileFinderOptions } from "./types.ts" */
+
+exports.FileFinder = class FileFinder {
+	/**
+	 * @param {string} directory
+	 * @param {FileFinderOptions} options?
+	 */
+	constructor(directory, { skipDotfiles, filter = () => true } = {}) {
+		this.directory = directory;
+		/**
+		 * @param {string} filename
+		 * @return {boolean}
+		 */
+		this.filter = filename => {
+			if(skipDotfiles && isDotfile(filename)) {
+				return false;
+			}
+			return filter(filename);
+		};
+	}
+
+	/**
+	 * a list of relative file paths within the respective directory
+	 *
+	 * @returns {Promise<string[]>}
+	 */
+	all() {
+		return tree(this.directory).
+			then(filenames => filenames.filter(this.filter));
+	}
+
+	/**
+	 * all file paths that match the filter function
+	 *
+	 * @param {string[]} filepaths
+	 * @returns {Promise<string[]>}
+	 */
+	match(filepaths) {
+		return filesWithinDirectory(this.directory, filepaths).
+			then(filepaths => filepaths.filter(this.filter));
+	}
+};
+
+/**
+ * @param {string} filepath
+ * @param {string} referenceDir
+ * @returns {Promise<string[]>}
+ */
+function tree(filepath, referenceDir = filepath) {
+	return stat(filepath).
+		then(res => {
+			if(!res.isDirectory()) {
+				return [path.relative(referenceDir, filepath)];
+			}
+
+			return readdir(filepath).
+				then(entries => {
+					let res = Promise.all(entries.map(entry => {
+						return tree(path.join(filepath, entry), referenceDir);
+					}));
+					return res.then(flatten);
+				});
+		});
+}
+
+/**
+ * @param {string} directory
+ * @param {string[]} files
+ * @returns {Promise<string[]>}
+ */
+function filesWithinDirectory(directory, files) {
+	return new Promise(resolve => {
+		resolve(files.
+			map(filepath => path.relative(directory, filepath)).
+			filter(filename => !filename.startsWith("..")));
+	});
+}
+
+/**
+ * @param {string} filename
+ * @returns {boolean}
+ */
+function isDotfile(filename) {
+	return path.basename(filename).startsWith(".");
+}
+
+/**
+ * @param {string[][]} arr
+ * @returns {string[]}
+ */
+function flatten(arr) {
+	/**
+	 * I'm deeply sorry for this
+	 * @type string[]
+	 */
+	const akwardlyTypedStringArray = [];
+	return akwardlyTypedStringArray.concat.apply([], arr);
+}

package.json

@@ -4,9 +4,10 @@
 	"description": "static files for faucet-pipeline",
 	"main": "index.js",
 	"scripts": {
-		"test": "npm run lint && npm run test:cli",
+		"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 index.js test && echo ✓",
+		"typecheck": "tsc"
 	},
 	"repository": {
 		"type": "git",
@@ -22,11 +23,13 @@
 		"node": ">= 20"
 	},
 	"dependencies": {
-		"faucet-pipeline-core": "^3.0.0"
+		"faucet-pipeline-core": "^2.0.0 || ^3.0.0"
 	},
 	"devDependencies": {
+		"@types/node": "^22.13.10",
 		"eslint-config-fnd": "^1.13.0",
 		"json-diff": "^1.0.0",
-		"release-util-fnd": "^3.0.0"
+		"release-util-fnd": "^3.0.0",
+		"typescript": "^5.8.2"
 	}
 }

tsconfig.json

@@ -0,0 +1,13 @@
+{
+	"compilerOptions": {
+		"allowJs": true,
+		"checkJs": true,
+		"noEmit": true,
+		"strict": true,
+		"allowImportingTsExtensions": true,
+		"lib": ["dom", "es2023"],
+	},
+	"exclude": [
+			"./test/**",
+	]
+}

types.ts

@@ -0,0 +1,61 @@
+// 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,
+}
+
+export interface FileFinderOptions {
+		skipDotfiles?: boolean,
+		filter?: (filename: string) => boolean
+}