@chrisburnell/eleventy-cache-webmentions 0.2.0 → 1.0.0-beta.2

package/eleventy-cache-webmentions.js

@@ -2,6 +2,7 @@ const fetch = require("node-fetch")
 const sanitizeHTML = require("sanitize-html")
 const uniqBy = require("lodash/uniqBy")
 const { AssetCache } = require("@11ty/eleventy-fetch")
+const { defaultsDeep } = require("lodash")
 
 const absoluteURL = (url, domain) => {
 	try {
@@ -37,161 +38,180 @@ const epoch = (value) => {
 	return new Date(value).getTime()
 }
 
-module.exports = (eleventyConfig, options = {}) => {
-	options = Object.assign(
-		{
-			uniqueKey: "webmentions",
-			allowedHTML: {
-				allowedTags: ["b", "i", "em", "strong", "a"],
-				allowedAttributes: {
-					a: ["href"],
-				},
-			},
-			urlReplacements: {},
-			maximumHtmlLength: 2000,
-			maximumHtmlText: "mentioned this in",
-		},
-		options
-	)
+const getPublished = (webmention) => {
+	return webmention["wm-received"] || webmention?.["data"]["published"] || webmention["verified_date"] || webmention["published"]
+}
 
-	const fetchWebmentions = async () => {
-		let asset = new AssetCache(options.uniqueKey)
-		asset.ensureDir()
+const getContent = (webmention) => {
+	return webmention?.["content"]["html"] || webmention["content"] || webmention?.["data"]["content"]
+}
 
-		let webmentions = []
+const getSource = (webmention) => {
+	return webmention["url"] || webmention?.["data"]["url"] || webmention["wm-source"] || webmention["source"]
+}
 
-		// If there is a cached file at all, grab its contents now
-		if (asset.isCacheValid("9001y")) {
-			webmentions = await asset.getCachedValue()
-		}
+const getTarget = (webmention) => {
+	return webmention["wm-target"] || webmention["target"]
+}
 
-		// If there is a cached file but it is outside of expiry, fetch fresh
-		// results since the most recent webmention
-		if (!asset.isCacheValid(options.duration)) {
-			const since = webmentions.length ? webmentions[0]["wm-received"] || webmentions[0]["published"] : false
-			const url = `${options.feed}${since && options.feed.includes("https://webmention.io") ? `&since=${since}` : ""}`
-			await fetch(url)
-				.then(async (response) => {
-					if (response.ok) {
-						const feed = await response.json()
-						if (feed[options.key].length) {
-							webmentions = uniqBy([...feed[options.key], ...webmentions], (item) => {
-								return item["wm-source"] || item["source"]
-							})
-							console.log(`[${hostname(options.domain)}] ${feed[options.key].length} new Webmentions fetched into cache.`)
-						}
-						await asset.save(webmentions, "json")
-						return webmentions
-					}
-					return Promise.reject(response)
-				})
-				.catch((error) => {
-					console.log(`[${hostname(options.domain)}] Something went wrong with your request to ${hostname(options.feed)}!`, error)
-				})
-		}
+const getType = (webmention) => {
+	return webmention["wm-property"] || webmention?.["activity"]["type"] || webmention["type"]
+}
+
+const defaults = {
+	uniqueKey: "webmentions",
+	allowedHTML: {
+		allowedTags: ["b", "i", "em", "strong", "a"],
+		allowedAttributes: {
+			a: ["href"],
+		},
+	},
+	urlReplacements: {},
+	maximumHtmlLength: 2000,
+	maximumHtmlText: "mentioned this in",
+}
+
+const fetchWebmentions = async (options) => {
+	let asset = new AssetCache(options.uniqueKey)
+	asset.ensureDir()
 
-		return webmentions
+	let webmentions = []
+
+	// If there is a cached file at all, grab its contents now
+	if (asset.isCacheValid("9001y")) {
+		webmentions = await asset.getCachedValue()
 	}
 
-	const filteredWebmentions = async () => {
-		const rawWebmentions = await fetchWebmentions()
-		let webmentions = {}
+	// If there is a cached file but it is outside of expiry, fetch fresh
+	// results since the most recent webmention
+	if (!asset.isCacheValid(options.duration)) {
+		const since = webmentions.length ? getPublished(webmentions[0]) : false
+		const url = `${options.feed}${since ? `${options.feed.includes("?") ? "&" : "?"}since=${since}` : ""}`
+		await fetch(url)
+			.then(async (response) => {
+				if (response.ok) {
+					const feed = await response.json()
+					if (feed[options.key].length) {
+						webmentions = uniqBy([...feed[options.key], ...webmentions], (entry) => {
+							return getSource(entry)
+						})
+						console.log(`[${hostname(options.domain)}] ${feed[options.key].length} new Webmentions fetched into cache.`)
+					}
+					await asset.save(webmentions, "json")
+					return webmentions
+				}
+				return Promise.reject(response)
+			})
+			.catch((error) => {
+				console.log(`[${hostname(options.domain)}] Something went wrong with your request to ${hostname(options.feed)}!`, error)
+			})
+	}
 
-		// Sort Webmentions into groups by `wm-target` || `target`
-		rawWebmentions.forEach((webmention) => {
-			// Get the target of the Webmention and fix it up
-			let url = baseUrl(fixUrl((webmention["wm-target"] || webmention["target"]).replace(/\/?$/, "/"), options.urlReplacements))
+	return webmentions
+}
 
-			if (!webmentions[url]) {
-				webmentions[url] = []
-			}
+const filteredWebmentions = async (options) => {
+	const rawWebmentions = await fetchWebmentions(options)
+	let webmentions = {}
 
-			webmentions[url].push(webmention)
-		})
+	// Sort Webmentions into groups by target
+	rawWebmentions.forEach((webmention) => {
+		// Get the target of the Webmention and fix it up
+		let url = baseUrl(fixUrl(getTarget(webmention).replace(/\/?$/, "/"), options.urlReplacements))
 
-		// Sort Webmentions in groups by url and remove duplicates by `url`
-		for (let url in webmentions) {
-			webmentions[url] = uniqBy(webmentions[url], (item) => {
-				return item["url"]
-			})
+		if (!webmentions[url]) {
+			webmentions[url] = []
 		}
 
-		return webmentions
+		webmentions[url].push(webmention)
+	})
+
+	// Sort Webmentions in groups by url and remove duplicates by `url`
+	for (let url in webmentions) {
+		webmentions[url] = uniqBy(webmentions[url], (entry) => {
+			return getSource(entry)
+		})
 	}
 
-	const getWebmentions = async (url, allowedTypes = {}) => {
-		const webmentions = await filteredWebmentions()
-		url = absoluteURL(url, options.domain)
+	return webmentions
+}
 
-		if (!url || !webmentions || !webmentions[url]) {
-			return []
-		}
+const getWebmentions = async (options, url, allowedTypes = {}) => {
+	const webmentions = await filteredWebmentions(options)
+	url = absoluteURL(url, options.domain)
 
-		const results = webmentions[url]
-			// filter webmentions by allowed response post types
-			.filter((entry) => {
-				return typeof allowedTypes === "object" && Object.keys(allowedTypes).length ? allowedTypes.includes(entry["wm-property"] || entry["type"]) : true
-			})
-			// remove webmentions without an author name
-			.filter((entry) => {
-				const { author } = entry
-				return !!author && !!author.name
-			})
-			// sanitize content of webmentions and check against HTML limit
-			.map((entry) => {
-				if (!("content" in entry)) {
-					return entry
-				}
-				const { html, text } = entry.content
-				if (html && html.length > options.maximumHtmlLength) {
-					entry.content.value = `${options.maximumHtmlText} <a href="${entry["wm-source"] || entry["source"]}">${entry["wm-source"] || entry["source"]}</a>`
-				} else if (Object.keys(options.allowedHTML).length) {
-					entry.content.value = sanitizeHTML(html || text, options.allowedHTML)
-				} else {
-					entry.content.value = html || text
-				}
+	if (!url || !webmentions || !webmentions[url]) {
+		return []
+	}
+
+	const results = webmentions[url]
+		// filter webmentions by allowed response post types
+		.filter((entry) => {
+			return typeof allowedTypes === "object" && Object.keys(allowedTypes).length ? allowedTypes.includes(getType(entry)) : true
+		})
+		// sanitize content of webmentions against HTML limit
+		.map((entry) => {
+			if (!("content" in entry) || !("data" in entry)) {
 				return entry
-			})
-			// sort by `wm-received` || `published`
-			.sort((a, b) => {
-				return epoch(a["wm-received"] || a.published) - epoch(b["wm-received"] || b.published)
-			})
+			}
+			const html = getContent(entry)
+			if (html && html.length > options.maximumHtmlLength) {
+				entry.content = `${options.maximumHtmlText} <a href="${getSource(entry)}">${getSource(entry)}</a>`
+			} else if (Object.keys(options.allowedHTML).length) {
+				entry.content = sanitizeHTML(html, options.allowedHTML)
+			} else {
+				entry.content = html
+			}
+			return entry
+		})
+		// sort by published
+		.sort((a, b) => {
+			return epoch(getPublished(a)) - epoch(getPublished(b))
+		})
 
-		return results
+	return results
+}
+
+const getWebmentionsFilter = async (options, url, allowedTypes, callback) => {
+	if (typeof callback !== "function") {
+		callback = allowedTypes
+		allowedTypes = {}
 	}
+	const webmentions = await getWebmentions(options, url, allowedTypes)
+	callback(null, webmentions)
+}
 
-	const getWebmentionsFilter = async (url, allowedTypes, callback) => {
-		if (typeof callback !== "function") {
-			callback = allowedTypes
-			allowedTypes = {}
-		}
-		const webmentions = await getWebmentions(url, allowedTypes)
-		callback(null, webmentions)
+module.exports = (eleventyConfig, options = {}) => {
+	options = Object.assign(defaults, options)
+
+	if (!options.domain) {
+		throw new Error("domain is a required field when adding the plugin to your eleventyConfig using addPlugin. See https://chrisburnell.com/eleventy-cache-webmentions/#installation for more information.")
 	}
 
-	if (eleventyConfig && options) {
-		if (!options.domain) {
-			throw new Error("domain is a required field when adding the plugin to your eleventyConfig using addPlugin. See https://chrisburnell.com/eleventy-cache-webmentions/#installation for more information.")
-		}
+	if (!options.feed) {
+		throw new Error("feed is a required field when adding the plugin to your eleventyConfig using addPlugin. See https://chrisburnell.com/eleventy-cache-webmentions/#installation for more information.")
+	}
 
-		if (!options.feed) {
-			throw new Error("feed is a required field when adding the plugin to your eleventyConfig using addPlugin. See https://chrisburnell.com/eleventy-cache-webmentions/#installation for more information.")
-		}
+	if (!options.key) {
+		throw new Error("key is a required field when adding the plugin to your eleventyConfig using addPlugin. See https://chrisburnell.com/eleventy-cache-webmentions/#installation for more information.")
+	}
 
-		if (!options.key) {
-			throw new Error("key is a required field when adding the plugin to your eleventyConfig using addPlugin. See https://chrisburnell.com/eleventy-cache-webmentions/#installation for more information.")
-		}
+	if (eleventyConfig) {
+		// Global Data
+		eleventyConfig.addGlobalData("webmentions", filteredWebmentions(options))
 
 		// Liquid Filter
 		eleventyConfig.addLiquidFilter("getWebmentions", getWebmentionsFilter)
 
 		// Nunjucks Filter
 		eleventyConfig.addNunjucksAsyncFilter("getWebmentions", getWebmentionsFilter)
+	}
 
-		// Global Data
-		eleventyConfig.addGlobalData("webmentions", filteredWebmentions)
-	} else {
-		// JavaScript
-		return filteredWebmentions
+	return {
+		defaults: defaults,
+		webmentions: filteredWebmentions(options),
+		fetchWebmentions: fetchWebmentions,
+		filteredWebmentions: filteredWebmentions,
+		getWebmentions: getWebmentions,
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrisburnell/eleventy-cache-webmentions",
-  "version": "0.2.0",
+  "version": "1.0.0-beta.2",
   "description": "Fetch and cache webmentions using eleventy-fetch.",
   "main": "eleventy-cache-webmentions.js",
   "author": "Chris Burnell <me@chrisburnell.com>",