vowel 0.3.4 → 0.5.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vowel",
   "type": "module",
-  "version": "0.3.4",
+  "version": "0.5.0",
   "bin": "bin.js",
   "main": "index.js",
   "scripts": {
@@ -67,8 +67,8 @@
     "unist-util-visit": "^5.0.0",
     "unist-util-visit-parents": "^6.0.0",
     "url-metadata": "^5.4.1",
-    "votive": "^0.2.0",
     "voot": "^0.1.0",
+    "votive": "^0.4.0",
     "xast-util-sitemap": "^2.0.0",
     "xast-util-to-xml": "^4.0.0",
     "xml": "^1.0.1",

package/plugins/markdown/index.js

@@ -19,7 +19,7 @@ import { h } from 'hastscript'
 import { normalizeHeadings } from 'mdast-normalize-headings'
 import { readFileSync } from "fs"
 import { remove } from "unist-util-remove"
-import { testURL } from "./../../utils.js"
+import { testURL, testHashtags, createHashtagPage, toTitleCase, hashtagRegexSingle } from "./../../utils.js"
 import { toHast } from 'mdast-util-to-hast'
 import { toString as hastToString } from 'hast-util-to-string'
 import { toString as mdastToString } from 'mdast-util-to-string'
@@ -103,14 +103,6 @@ function makeHead(metadata, url) {
   return treeMainHead
 }
 
-function toTitleCase(string) {
-  if (!string) return
-  return string.split(" ").map(word => {
-    const letters = word.split("")
-    letters[0] = letters[0].toUpperCase()
-    return letters.join("")
-  }).join(" ")
-}
 
 function readURL(data) {
   const hast = fromHtml(data)
@@ -140,7 +132,7 @@ function readURL(data) {
 
 
 /** @type {Votive.ReadText} */
-function readMarkdown(string, filePath, destinationPath, database, config) {
+function readFile(string, filePath, destinationPath, database, config) {
   const mdast = fromMarkdown(string, {
     // Micromark extensions
     extensions: [
@@ -198,6 +190,7 @@ function readMarkdown(string, filePath, destinationPath, database, config) {
   visit(mdast, (node, index, parent) => {
     if (node.type === "text" && parent.children.length === 1 && parent.type === "paragraph") {
       const validURL = testURL(node.value)
+
       if (validURL) {
 
         jobs.push({
@@ -205,6 +198,108 @@ function readMarkdown(string, filePath, destinationPath, database, config) {
           runner: "text",
           destination: destinationPath
         })
+
+        return
+      }
+
+      const hashtags = testHashtags(node.value)
+
+      // TODO: Tags should not appear in menus
+      // TODO: Make this work when tags are embedded in text
+
+      if (hashtags) {
+        function convertTagsToLinks(value) {
+          const match = value.match(hashtagRegexSingle)
+          if (match) {
+            const remainder = value.slice(match[0].length)
+            const child = {
+              type: "link",
+              url: `/tags/${match[3]}`,
+              children: [
+                {
+                  type: "text",
+                  value: match[0]
+                }
+              ]
+            }
+
+            return [
+              {
+                type: "text",
+                value: match[1]
+              },
+              child,
+              {
+                type: "text",
+                value: match[4]
+              },
+
+              ...convertTagsToLinks(remainder)
+            ]
+          }
+          return [
+            {
+              type: "text",
+              value: value
+            }
+          ]
+        }
+
+        parent.children = convertTagsToLinks(node.value)
+
+        const markdown = `/tags/**`
+        const mdast = fromMarkdown(markdown)
+
+        const extant = database.target.get("tags.html")
+
+        // FIXME: Update abstract format
+        if (!extant) {
+          // Delete if unnecessary
+          database.target.create({
+            path: `tags.html`,
+            abstract: mdast,
+            metadata: {
+              breadcrumb: "Tags",
+              title: "Tags",
+              prettyURL: "/tags",
+            }
+          })
+        }
+
+        database.dependency.track({}, "tags", null, destinationPath, "tags.html")
+        database.target.markStale("tags.html")
+
+        if (hashtags) {
+          if (!metadata.tags) {
+            metadata.tags = []
+          } else if (!Array.isArray(metadata.tags)) {
+            metadata.tags = []
+          }
+
+          metadata.tags = []
+
+          hashtags.forEach(hashtag => {
+            const title = toTitleCase(hashtag)
+            metadata.tags.push(hashtag)
+
+            const abstract = createHashtagPage(hashtag)
+
+            const tagMetadata = {
+              breadcrumb: title,
+              title: title,
+              prettyURL: `/tags/${hashtag}`,
+              type: "tag",
+              tag: hashtag
+            }
+
+            const created = database.target.create({
+              path: `tags/${hashtag}.html`,
+              abstract,
+              metadata: tagMetadata
+            })
+
+          })
+        }
       }
     }
   })
@@ -364,7 +459,7 @@ function getMetadata(tree, filePath) {
 }
 
 /** @type {Votive.ReadAbstract} */
-function readAbstract(abstract, database, config) {
+function transformFile(abstract, database, config) {
   const jobs = []
   return { abstract, jobs }
 }
@@ -580,13 +675,31 @@ function readFolder(folder, database, config, isRoot) {
 }
 
 /** @type {Votive.ProcessorWrite} */
-function writeHTML(destination, database, config) {
+function writeFile(destination, database, config) {
   const isRoot = destination.path === "index.html"
 
+  // console.log(destination.metadata)
+
+  if (destination.metadata.type === "tag") {
+    if (!destination.metadata.tag) return false
+
+    const pages = database.target.getManyWithTrackers({
+      recursive: true,
+      dependent: destination,
+      query: {
+        tags: destination.metadata.tag
+      }
+    })
+
+    if (!pages.length) return false
+  }
+
   const settings = database.setting.getByFolder(destination.dir + path.sep)
 
   const { abstract, metadata, ...rest } = destination
 
+  if (metadata.tags) metadata.tags = JSON.parse(metadata.tags)
+
   /** @param {string} filePath */
   function listFolders(filePath) {
     if (!filePath) return []
@@ -616,7 +729,9 @@ function writeHTML(destination, database, config) {
       dependent: destination.path,
       query: {}
     })
-  }).filter(({ path }) => path)
+  }).filter(({ path, dir }) => {
+    return path && path !== "tags.html" && dir !== "tags"
+  })
 
   const treeStyleSheets = []
 
@@ -907,18 +1022,32 @@ function writeHTML(destination, database, config) {
       const folder = path.relative("/", dir)
       // const url = new URL(child.value, "thismessage://")
       const count = url.searchParams.get("count")
+      const tag = url.searchParams.get("tag")
+      const query = tag
+        ? { tags: tag }
+        : {}
+
       const targets = database.target.getManyWithTrackers({
         folder,
         recursive,
-        query: {},
+        query,
         dependent: destination.path
       })
 
       if (count) targets.splice(Number(count))
 
-      const list = h("section",
+      const escapedDir = folder.replace("_", "--").replace(path.sep, "_")
+      const escapedDirs = escapedDir.split("_").filter(a => a).map((segment, index, array) => {
+        return "_" + array.slice(0, index + 1).join("_")
+      })
+      escapedDirs.unshift("_")
+      const dirClasses = escapedDirs.join(".")
+
+      const list = h(`ul.${dirClasses}`,
         targets.map(target => {
-          return h('article', makeHead(target.metadata, target.metadata.prettyURL))
+          return h('li',
+            h('article', makeHead(target.metadata, target.metadata.prettyURL))
+          )
         })
       )
 
@@ -1016,6 +1145,7 @@ function writeHTML(destination, database, config) {
   const globalNavItems = everything.filter(item => {
     return item.dir === ""
       && item.path !== "index.html"
+      && item.path !== "tags.html"
   })
     .map(getChildren)
 
@@ -1152,26 +1282,26 @@ function router(args) {
 
 
 /** @type {Votive.VotiveProcessor} */
-const markdownReader = {
+const readMarkdown = {
   extensions: [".md"],
   format: "text",
-  readFile: readMarkdown,
+  readFile,
   readResource: readURL,
-  transformFile: readAbstract,
-  readFolder: readFolder,
+  transformFile,
+  readFolder,
 }
 
-const htmlWriter = {
+const writeHTML = {
   extensions: [".html"],
   format: "text",
-  writeFile: writeHTML
+  writeFile
 }
 
 
 /** @type {Votive.VotivePlugin} */
 const vowelMarkdownPlugin = {
   name: "vowel",
-  processors: [markdownReader, htmlWriter],
+  processors: [readMarkdown, writeHTML],
   router
 }
 

package/stylesheets/DefaultStyles.css

@@ -226,15 +226,23 @@
 		border-left: 5px solid var(--primary-border-color);
 	}
 
-	article {
+	main>article {
 		border: 1px solid var(--primary-border-color);
-		background: var(--soft-background);
 		padding: 2rem 2rem 2rem;
 		border-radius: calc(1rem + 5px);
 		display: flex;
 		flex-direction: column;
 	}
 
+	main>ul._ {
+		list-style: none;
+		padding: 0;
+
+		& article {
+			padding-bottom: 1em;
+		}
+	}
+
 	th,
 	td {
 		border-bottom: 1px solid var(--border-color-softer);

package/utils.js

@@ -1,3 +1,8 @@
+import {fromMarkdown} from 'mdast-util-from-markdown'
+import {toHast} from 'mdast-util-to-hast'
+import {toHtml} from 'hast-util-to-html'
+
+
 /** @param {string} text */
 export function testURL(text) {
   if (text.match(/^https?:\/\/[\S]+$/)) {
@@ -8,3 +13,28 @@ export function testURL(text) {
     }
   }
 }
+
+export const hashtagRegexSingle = /(^|\s)(#([\w\-\/]+))($|\b)/
+export const hashtagRegexGlobal = /(?:^|\s)(#[\w\-\/]+)(?:$|\b)/g
+
+export function testHashtags(text) {
+  const match = text.match(hashtagRegexGlobal)
+  if(match) return match.map(a => a.trim().slice(1))
+}
+
+
+export function toTitleCase(string) {
+  if (!string) return
+  return string.split(" ").map(word => {
+    const letters = word.split("")
+    letters[0] = letters[0].toUpperCase()
+    return letters.join("")
+  }).join(" ")
+}
+
+export function createHashtagPage(tag) {
+  const markdown = `# ${toTitleCase(tag)}\n\n/**?tag=${tag}`
+  const mdast = fromMarkdown(markdown)
+
+  return mdast
+}