Make tags hierarchical

Author: martinstabe

src/_data/tag-definitions.json

@@ -562,6 +562,7 @@
   {
     "tag": "associated-newspapers",
     "title": "Associated Newspapers",
+    "parent": "dmgt",
     "permalink": "/tags/associated-newspapers/",
     "aliases": [
       "associated-newspapers"
@@ -2162,6 +2163,7 @@
   {
     "tag": "daily-mail",
     "title": "Daily Mail",
+    "parent": "associated-newspapers",
     "permalink": "/tags/daily-mail/",
     "aliases": [
       "daily-mail"

src/_data/tagDefinitions.js

@@ -31,6 +31,7 @@ function createDefinition(data) {
   const tag = decodeValue(data.tag);
   const title = decodeValue(data.title) || `Tag: ${tag}`;
   const commentary = decodeValue(data.commentary);
+  const parent = decodeValue(data.parent);
   const displayTitle = stripTagPrefix(title, tag);
   const permalink = ensureWrappedSlashes(data.permalink || `/tags/${tag}/`);
   const slug = permalink.replace(/^\/+|\/+$/g, "");
@@ -48,6 +49,7 @@ function createDefinition(data) {
     tag,
     title,
     commentary,
+    parent: parent ? String(parent).trim() : null,
     displayTitle,
     heading: `Tag: ${displayTitle}`,
     permalink,
@@ -66,6 +68,23 @@ module.exports = function () {
     }
   }
 
+  for (const definition of definitions) {
+    if (!definition.parent) {
+      definition.parentTag = null;
+      definition.parentPermalink = null;
+      continue;
+    }
+
+    const parentDefinition = byAlias[definition.parent];
+
+    if (!parentDefinition) {
+      throw new Error(`Unknown parent tag alias "${definition.parent}" for tag "${definition.tag}"`);
+    }
+
+    definition.parentTag = parentDefinition.tag;
+    definition.parentPermalink = parentDefinition.permalink;
+  }
+
   return {
     all: definitions,
     byAlias

src/_data/tags.js

@@ -1,48 +1,123 @@
 const getPosts = require("./posts.js");
 const getTagDefinitions = require("./tagDefinitions.js");
 
+function createFallbackDefinition(rawTag) {
+  return {
+    tag: rawTag,
+    title: `Tag: ${rawTag}`,
+    commentary: null,
+    parent: null,
+    parentTag: null,
+    parentPermalink: null,
+    displayTitle: rawTag,
+    heading: `Tag: ${rawTag}`,
+    permalink: `/tags/${rawTag}/`,
+    slug: `tags/${rawTag}`,
+    aliases: [rawTag]
+  };
+}
+
+function uniquePosts(posts) {
+  const seen = new Set();
+  const result = [];
+
+  for (const post of posts) {
+    if (seen.has(post.permalink)) {
+      continue;
+    }
+
+    seen.add(post.permalink);
+    result.push(post);
+  }
+
+  return result;
+}
+
 module.exports = function () {
   const posts = getPosts();
-  const { byAlias } = getTagDefinitions();
+  const { all, byAlias } = getTagDefinitions();
   const tagMap = new Map();
 
+  for (const definition of all) {
+    tagMap.set(definition.permalink, {
+      ...definition,
+      directPosts: [],
+      posts: [],
+      rawTags: new Set(),
+      childrenPermalinks: new Set()
+    });
+  }
+
   for (const post of posts) {
     for (const rawTag of post.tags || []) {
-      const definition = byAlias[rawTag] || {
-        tag: rawTag,
-        title: `Tag: ${rawTag}`,
-        displayTitle: rawTag,
-        heading: `Tag: ${rawTag}`,
-        permalink: `/tags/${rawTag}/`,
-        slug: `tags/${rawTag}`,
-        aliases: [rawTag]
-      };
+      const definition = byAlias[rawTag] || createFallbackDefinition(rawTag);
       const key = definition.permalink;
 
       if (!tagMap.has(key)) {
         tagMap.set(key, {
           ...definition,
+          directPosts: [],
           posts: [],
           rawTags: new Set()
         });
       }
 
       const tagEntry = tagMap.get(key);
 
-      if (!tagEntry.posts.some((entry) => entry.permalink === post.permalink)) {
-        tagEntry.posts.push(post);
+      if (!tagEntry.directPosts.some((entry) => entry.permalink === post.permalink)) {
+        tagEntry.directPosts.push(post);
       }
 
       tagEntry.rawTags.add(rawTag);
     }
   }
 
+  for (const tagEntry of tagMap.values()) {
+    if (tagEntry.parentPermalink && tagMap.has(tagEntry.parentPermalink)) {
+      tagMap.get(tagEntry.parentPermalink).childrenPermalinks.add(tagEntry.permalink);
+    }
+  }
+
+  const memo = new Map();
+
+  function collectPostsForTag(permalink, stack = []) {
+    if (memo.has(permalink)) {
+      return memo.get(permalink);
+    }
+
+    if (stack.includes(permalink)) {
+      throw new Error(`Tag hierarchy cycle detected: ${stack.concat(permalink).join(" -> ")}`);
+    }
+
+    const tagEntry = tagMap.get(permalink);
+    const nestedStack = stack.concat(permalink);
+    let postsForTag = [...(tagEntry.directPosts || [])];
+
+    for (const childPermalink of tagEntry.childrenPermalinks || []) {
+      postsForTag = postsForTag.concat(collectPostsForTag(childPermalink, nestedStack));
+    }
+
+    const deduped = uniquePosts(postsForTag).sort((a, b) => new Date(b.date) - new Date(a.date));
+    memo.set(permalink, deduped);
+    return deduped;
+  }
+
   return Array.from(tagMap.values())
     .map((tag) => ({
       ...tag,
+      directCount: tag.directPosts.length,
+      childTags: Array.from(tag.childrenPermalinks)
+        .map((permalink) => tagMap.get(permalink))
+        .filter(Boolean)
+        .map((entry) => ({
+          tag: entry.tag,
+          displayTitle: entry.displayTitle,
+          permalink: entry.permalink
+        }))
+        .sort((a, b) => a.displayTitle.localeCompare(b.displayTitle)),
       rawTags: Array.from(tag.rawTags).sort(),
-      posts: tag.posts.sort((a, b) => new Date(b.date) - new Date(a.date)),
-      count: tag.posts.length
+      posts: collectPostsForTag(tag.permalink),
+      count: collectPostsForTag(tag.permalink).length
     }))
     .sort((a, b) => a.displayTitle.localeCompare(b.displayTitle));
 };