v2.2.0

.github/workflows/tests.yaml

@@ -7,7 +7,7 @@ jobs:
         strategy:
             matrix:
                 node-version:
-                - 18.x
+                - 20.19
                 - 22.x
                 - latest
         steps:

lib/index.js

@@ -0,0 +1,68 @@
+import { buildProcessPipeline } from "./util.js";
+import { readFile } from "node:fs/promises";
+import * as path from "node:path";
+
+export const key = "static";
+export const bucket = "static";
+
+/** @type FaucetPlugin<Config> */
+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(pipeline.map(copy => copy(filepaths)));
+}
+
+/**
+ * Returns a function that copies a single file with optional compactor
+ *
+ * @param {Config} copyConfig
+ * @param {FaucetPluginOptions} options
+ * @returns {ProcessFile}
+ */
+function buildProcessFile(copyConfig, options) {
+	let compactors = (options.compact && copyConfig.compact) || {};
+
+	return async function(filename,
+			{ source, target, targetDir, assetManager }) {
+		let sourcePath = path.join(source, filename);
+		let targetPath = path.join(target, filename);
+		let content;
+
+		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;
+		}
+
+		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(copyConfig.fingerprint !== undefined) {
+			options.fingerprint = copyConfig.fingerprint;
+		}
+		return assetManager.writeFile(targetPath, content, options);
+	};
+}
+
+/** @import {
+  *   Config,
+	*   FaucetPlugin,
+	*   FaucetPluginOptions,
+	*   WriteFileOpts,
+	*   ProcessFile
+	*   } from "./types.ts"
+	**/

lib/types.ts

@@ -0,0 +1,67 @@
+// 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?: Filter
+}
+
+export interface CompactorMap {
+	[fileExtension: string]: Compactor
+}
+
+export interface Compactor {
+	(contact: Buffer): Promise<Buffer>
+}
+
+export interface ProcessFile {
+	(filename: string, opts: ProcessFileOptions): Promise<unknown>
+}
+
+export interface ProcessFileOptions {
+	source: string,
+	target: string,
+	targetDir: string,
+	assetManager: AssetManager,
+}
+
+export interface FileFinderOptions {
+	skipDotfiles: boolean,
+	filter?: Filter
+}
+
+export interface Filter {
+	(filename: string): boolean
+}

lib/util.js

@@ -0,0 +1,119 @@
+import { readdir, stat } from "node:fs/promises";
+import * as path from "node:path";
+
+/**
+ * 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
+	 */
+	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 {
+	*   AssetManager,
+	*   FaucetPluginFunc,
+	*   Filter,
+	*   FileFinderOptions,
+	*   ProcessFile
+	*   } from "./types.ts"
+	**/

package.json

@@ -2,11 +2,13 @@
 	"name": "faucet-pipeline-static",
 	"version": "2.1.0",
 	"description": "static files for faucet-pipeline",
-	"main": "index.js",
+	"main": "lib/index.js",
+	"type": "module",
 	"scripts": {
-		"test": "npm-run-all --parallel lint 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 lib test && echo ✓",
+		"typecheck": "tsc"
 	},
 	"repository": {
 		"type": "git",
@@ -19,15 +21,16 @@
 	},
 	"homepage": "https://www.faucet-pipeline.org",
 	"engines": {
-		"node": ">= 18"
+		"node": ">= 20.19.0"
 	},
 	"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",
-		"npm-run-all": "^4.1.5",
-		"release-util-fnd": "^3.0.0"
+		"release-util-fnd": "^3.0.0",
+		"typescript": "^5.8.2"
 	}
 }