@chrisburnell/eleventy-cache-webmentions 2.1.6 → 2.1.8

package/.cache/eleventy-fetch-68a403136c61abd104ade94e69ba62

@@ -1 +1 @@
-[{"68a403136c61abd104ade94e69ba62":"1"},{"cachedAt":1723578147488,"type":"2"},"json"]
+[{"68a403136c61abd104ade94e69ba62":"1"},{"cachedAt":1723708494710,"type":"2"},"json"]

package/eleventy-cache-webmentions.js

@@ -1,14 +1,36 @@
 const fetch = require("node-fetch");
 const sanitizeHTML = require("sanitize-html");
-const uniqBy = require("lodash/uniqBy");
+const uniqBy = require("lodash.uniqby");
 const { AssetCache } = require("@11ty/eleventy-fetch");
+const chalk = require("chalk");
+
+const defaults = {
+	refresh: false,
+	duration: "1d",
+	uniqueKey: "webmentions",
+	allowedHTML: {
+		allowedTags: ["b", "i", "em", "strong", "a"],
+		allowedAttributes: {
+			a: ["href"],
+		},
+	},
+	allowlist: [],
+	blocklist: [],
+	urlReplacements: {},
+	maximumHtmlLength: 1000,
+	maximumHtmlText: "mentioned this in",
+};
 
 const absoluteURL = (url, domain) => {
 	try {
 		return new URL(url, domain).toString();
 	} catch (e) {
-		console.log(
-			`Trying to convert ${url} to be an absolute url with base ${domain} and failed.`,
+		console.error(
+			`Trying to convert ${chalk.bold(
+				url,
+			)} to be an absolute url with base ${chalk.bold(
+				domain,
+			)} and failed.`,
 		);
 		return url;
 	}
@@ -113,21 +135,42 @@ const getByTypes = (webmentions, allowedTypes) => {
 	});
 };
 
-const defaults = {
-	refresh: false,
-	duration: "1d",
-	uniqueKey: "webmentions",
-	allowedHTML: {
-		allowedTags: ["b", "i", "em", "strong", "a"],
-		allowedAttributes: {
-			a: ["href"],
-		},
-	},
-	allowlist: [],
-	blocklist: [],
-	urlReplacements: {},
-	maximumHtmlLength: 1000,
-	maximumHtmlText: "mentioned this in",
+const removeDuplicates = (webmentions) => {
+	return uniqBy(webmentions, (webmention) => {
+		return getSource(webmention);
+	});
+};
+
+const processBlocklist = (webmentions, blocklist) => {
+	return webmentions.filter((webmention) => {
+		let url = getSource(webmention);
+		let source = getSource(webmention);
+		for (let blocklistURL of blocklist) {
+			if (
+				url.includes(blocklistURL.replace(/\/?$/, "/")) ||
+				source.includes(blocklistURL.replace(/\/?$/, "/"))
+			) {
+				return false;
+			}
+		}
+		return true;
+	});
+};
+
+const processAllowlist = (webmentions, allowlist) => {
+	return webmentions.filter((webmention) => {
+		let url = getSource(webmention);
+		let source = getSource(webmention);
+		for (let allowlistURL of allowlist) {
+			if (
+				url.includes(allowlistURL.replace(/\/?$/, "/")) ||
+				source.includes(allowlistURL.replace(/\/?$/, "/"))
+			) {
+				return true;
+			}
+		}
+		return false;
+	});
 };
 
 const performFetch = async (options, webmentions, url) => {
@@ -141,10 +184,10 @@ const performFetch = async (options, webmentions, url) => {
 
 			if (!options.key in feed) {
 				console.log(
-					`[${hostname(options.domain)}] ${
+					`${chalk.grey(`[${hostname(options.domain)}]`)} ${
 						options.key
-					} was not found as a key in the response from ${hostname(
-						options.feed,
+					} was not found as a key in the response from ${chalkf.bold(
+						hostname(options.feed),
 					)}!`,
 				);
 				return Promise.reject(response);
@@ -153,43 +196,14 @@ const performFetch = async (options, webmentions, url) => {
 			// Combine newly-fetched Webmentions with cached Webmentions
 			webmentions = feed[options.key].concat(webmentions);
 			// Remove duplicates by source URL
-			webmentions = uniqBy(
-				[...feed[options.key], ...webmentions],
-				(webmention) => {
-					return getSource(webmention);
-				},
-			);
+			webmentions = removeDuplicates(webmentions);
 			// Process the blocklist, if it has any entries
 			if (options.blocklist.length) {
-				webmentions = webmentions.filter((webmention) => {
-					let url = getSource(webmention);
-					let source = getSource(webmention);
-					for (let blocklistURL of options.blocklist) {
-						if (
-							url.includes(blocklistURL.replace(/\/?$/, "/")) ||
-							source.includes(blocklistURL.replace(/\/?$/, "/"))
-						) {
-							return false;
-						}
-					}
-					return true;
-				});
+				webmentions = processBlocklist(webmentions, options.blocklist);
 			}
 			// Process the allowlist, if it has any entries
 			if (options.allowlist.length) {
-				webmentions = webmentions.filter((webmention) => {
-					let url = getSource(webmention);
-					let source = getSource(webmention);
-					for (let allowlistURL of options.allowlist) {
-						if (
-							url.includes(allowlistURL.replace(/\/?$/, "/")) ||
-							source.includes(allowlistURL.replace(/\/?$/, "/"))
-						) {
-							return true;
-						}
-					}
-					return false;
-				});
+				webmentions = processAllowlist(webmentions, options.allowlist);
 			}
 			// Sort webmentions by received date for getting most recent Webmention on subsequent requests
 			webmentions = webmentions.sort((a, b) => {
@@ -203,10 +217,10 @@ const performFetch = async (options, webmentions, url) => {
 		})
 		.catch((error) => {
 			console.log(
-				`[${hostname(
-					options.domain,
-				)}] Something went wrong with your request to ${hostname(
-					options.feed,
+				`${chalk.grey(
+					`[${hostname(options.domain)}]`,
+				)} Something went wrong with your request to ${chalk.bold(
+					hostname(options.feed),
 				)}!`,
 				error,
 			);
@@ -232,7 +246,10 @@ const fetchWebmentions = async (options) => {
 		);
 	}
 
-	let asset = new AssetCache(options.uniqueKey, options.directory);
+	let asset = new AssetCache(
+		options.uniqueKey || `webmentions-${hostname(options.domain)}`,
+		options.directory,
+	);
 	asset.ensureDir();
 
 	let webmentions = [];
@@ -250,6 +267,7 @@ const fetchWebmentions = async (options) => {
 	// If there is a cached file but it is outside of expiry, fetch fresh
 	// results since the most recent Webmention
 	if (!asset.isCacheValid(options.refresh ? "0s" : options.duration)) {
+		const performanceStart = process.hrtime();
 		// Get the received date of the most recent Webmention, if it exists
 		const since = webmentions.length ? getReceived(webmentions[0]) : false;
 		// Build the URL for the fetch request
@@ -305,14 +323,29 @@ const fetchWebmentions = async (options) => {
 			webmentions = fetched.filtered;
 		}
 
+		// Process the blocklist, if it has any entries
+		if (options.blocklist.length) {
+			webmentions = processBlocklist(webmentions, options.blocklist);
+		}
+
+		// Process the allowlist, if it has any entries
+		if (options.allowlist.length) {
+			webmentions = processAllowlist(webmentions, options.allowlist);
+		}
+
 		await asset.save(webmentions, "json");
 
+		const performance = process.hrtime(performanceStart);
+
 		// Add a console message with the number of fetched and processed Webmentions, if any
 		if (webmentionsCachedLength < webmentions.length) {
 			console.log(
-				`[${hostname(options.domain)}] ${
-					webmentions.length - webmentionsCachedLength
-				} new Webmentions fetched into cache.`,
+				`${chalk.grey(`[${hostname(options.domain)}]`)} ${chalk.bold(
+					webmentions.length - webmentionsCachedLength,
+				)} new Webmentions fetched into cache in ${chalk.bold(
+					(performance[0] + performance[1] / 1e9).toFixed(3) +
+						" seconds",
+				)}.`,
 			);
 		}
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrisburnell/eleventy-cache-webmentions",
-  "version": "2.1.6",
+  "version": "2.1.8",
   "description": "Cache webmentions using eleventy-fetch and make them available to use in collections, layouts, pages, etc. in Eleventy.",
   "license": "MIT",
   "repository": {
@@ -52,7 +52,8 @@
   ],
   "dependencies": {
     "@11ty/eleventy-fetch": "^4.0.1",
-    "lodash": "^4.17.21",
+    "chalk": "^4.1.2",
+    "lodash.uniqby": "^4.7.0",
     "node-fetch": "2.6.7",
     "sanitize-html": "^2.13.0"
   },