feat(WIP): markdown parser rework

quartz.config.ts

@@ -65,7 +65,7 @@ const config: QuartzConfig = {
         },
         keepBackground: false,
       }),
-      Plugin.ObsidianFlavoredMarkdown({ enableInHtmlEmbed: false }),
+      //Plugin.ObsidianFlavoredMarkdown({ enableInHtmlEmbed: false }),
       Plugin.GitHubFlavoredMarkdown(),
       Plugin.TableOfContents(),
       Plugin.CrawlLinks({ markdownLinkResolution: "shortest" }),

quartz/plugins/parsers/custom/default.ts

@@ -0,0 +1,43 @@
+import { QuartzParser } from "../../types"
+import { ReplaceFunction, findAndReplace as mdastFindReplace } from "mdast-util-find-and-replace"
+import { JSResource } from "../../../util/resources"
+import { Root } from "mdast"
+import { Pluggable } from "unified"
+import { visit } from "unist-util-visit"
+import { Element, Literal, Root as HtmlRoot } from "hast"
+
+interface Options {
+  enabled: Boolean
+}
+
+const defaultOptions: Options = {
+  enabled: true,
+}
+
+export const CustomDefault: QuartzParser<Partial<Options>> = (userOpts) => {
+  const opts: Options = { ...defaultOptions, ...userOpts }
+  return {
+    name: "CustomDefault",
+    textTransform(_ctx, src: string | Buffer) {
+      if (src instanceof Buffer) {
+        src = src.toString()
+      }
+      return src
+    },
+    markdownPlugins(tree, file) {
+      return [new RegExp(""), ""] as [RegExp, string | ReplaceFunction]
+    },
+    htmlPlugins(tree, file) {
+      if (opts.enabled) {
+        return () => {
+          visit(tree!, "element", (node) => {})
+        }
+      }
+      return {} as Pluggable
+    },
+    externalResources() {
+      const js = {} as JSResource
+      return js
+    },
+  }
+}

quartz/plugins/parsers/custom/index.ts

@@ -0,0 +1 @@
+import { CustomDefault } from "./default"

quartz/plugins/parsers/github/index.ts

@@ -0,0 +1,2 @@
+export { GitHubSmartypants } from "./smartypants"
+export { GitHubLinkheadings } from "./linkheadings"

quartz/plugins/transformers/gfm.ts → quartz/plugins/parsers/github/linkheadings.ts

@@ -1,28 +1,33 @@
-import remarkGfm from "remark-gfm"
-import smartypants from "remark-smartypants"
-import { QuartzTransformerPlugin } from "../types"
+import { QuartzParser } from "../../types"
+import { JSResource } from "../../../util/resources"
+import { ReplaceFunction, findAndReplace as mdastFindReplace } from "mdast-util-find-and-replace"
+import { Pluggable } from "unified"
 import rehypeSlug from "rehype-slug"
 import rehypeAutolinkHeadings from "rehype-autolink-headings"
 
-export interface Options {
-  enableSmartyPants: boolean
-  linkHeadings: boolean
+interface Options {
+  enabled: Boolean
 }
 
 const defaultOptions: Options = {
-  enableSmartyPants: true,
-  linkHeadings: true,
+  enabled: true,
 }
 
-export const GitHubFlavoredMarkdown: QuartzTransformerPlugin<Partial<Options>> = (userOpts) => {
-  const opts = { ...defaultOptions, ...userOpts }
+export const GitHubLinkheadings: QuartzParser<Partial<Options>> = (userOpts) => {
+  const opts: Options = { ...defaultOptions, ...userOpts }
   return {
-    name: "GitHubFlavoredMarkdown",
-    markdownPlugins() {
-      return opts.enableSmartyPants ? [remarkGfm, smartypants] : [remarkGfm]
+    name: "GitHubLinkheadings",
+    textTransform(_ctx, src: string | Buffer) {
+      if (src instanceof Buffer) {
+        src = src.toString()
+      }
+      return src
+    },
+    markdownPlugins(tree, file) {
+      return [new RegExp(""), ""] as [RegExp, string | ReplaceFunction]
     },
     htmlPlugins() {
-      if (opts.linkHeadings) {
+      if (opts.enabled) {
         return [
           rehypeSlug,
           [
@@ -69,10 +74,13 @@ export const GitHubFlavoredMarkdown: QuartzTransformerPlugin<Partial<Options>> =
               },
             },
           ],
-        ]
-      } else {
-        return []
+        ] as Pluggable
       }
+      return [] as Pluggable
+    },
+    externalResources() {
+      const js = {} as JSResource
+      return js
     },
   }
 }

quartz/plugins/parsers/github/smartypants.ts

@@ -0,0 +1,40 @@
+import { QuartzParser } from "../../types"
+import { JSResource } from "../../../util/resources"
+import { Pluggable } from "unified"
+import remarkGfm from "remark-gfm"
+import smartypants from "remark-smartypants"
+
+interface Options {
+  enabled: Boolean
+}
+
+const defaultOptions: Options = {
+  enabled: true,
+}
+
+export const GitHubSmartypants: QuartzParser<Partial<Options>> = (userOpts) => {
+  const opts: Options = { ...defaultOptions, ...userOpts }
+  return {
+    name: "GitHubSmartypants",
+    textTransform(_ctx, src: string | Buffer) {
+      if (src instanceof Buffer) {
+        src = src.toString()
+      }
+      return src
+    },
+    markdownPlugins() {
+      if (opts.enabled) {
+        return smartypants as Pluggable
+      }
+      return {} as Pluggable
+    },
+    htmlPlugins() {
+      const plug: Pluggable = () => {}
+      return plug
+    },
+    externalResources() {
+      const js = {} as JSResource
+      return js
+    },
+  }
+}

quartz/plugins/parsers/obsidian/arrows.ts

@@ -0,0 +1,67 @@
+import { QuartzParser } from "../../types"
+import { ReplaceFunction, findAndReplace as mdastFindReplace } from "mdast-util-find-and-replace"
+import { JSResource } from "../../../util/resources"
+import { SKIP } from "unist-util-visit"
+import { Root } from "mdast"
+import { Pluggable } from "unified"
+import { mdastFindReplaceInHtml } from "../../transformers/markdown"
+
+interface Options {
+  enabled: Boolean
+}
+
+const defaultOptions: Options = {
+  enabled: true,
+}
+
+const arrowMapping: Record<string, string> = {
+  "->": "&rarr;",
+  "-->": "&rArr;",
+  "=>": "&rArr;",
+  "==>": "&rArr;",
+  "<-": "&larr;",
+  "<--": "&lArr;",
+  "<=": "&lArr;",
+  "<==": "&lArr;",
+}
+
+const arrowRegex = new RegExp(/(-{1,2}>|={1,2}>|<-{1,2}|<={1,2})/g)
+
+export const ObsidianArrow: QuartzParser<Partial<Options>> = (userOpts) => {
+  const opts: Options = { ...defaultOptions, ...userOpts }
+  return {
+    name: "ObsidianArrow",
+    textTransform(_ctx, src: string | Buffer) {
+      if (opts.enabled) {
+        if (src instanceof Buffer) {
+          src = src.toString()
+        }
+      }
+      return src
+    },
+    markdownPlugins() {
+      if (opts.enabled) {
+        return [
+          arrowRegex,
+          (value: string, ..._capture: string[]) => {
+            const maybeArrow = arrowMapping[value]
+            if (maybeArrow === undefined) return SKIP
+            return {
+              type: "html",
+              value: `<span>${maybeArrow}</span>`,
+            }
+          },
+        ] as [RegExp, string | ReplaceFunction]
+      }
+      return [new RegExp(""), ""] as [RegExp, string | ReplaceFunction]
+    },
+    htmlPlugins() {
+      const plug: Pluggable = () => {}
+      return plug
+    },
+    externalResources() {
+      const js = {} as JSResource
+      return js
+    },
+  }
+}

quartz/plugins/parsers/obsidian/blockreference.ts

@@ -0,0 +1,113 @@
+import { QuartzParser } from "../../types"
+import { ReplaceFunction, findAndReplace as mdastFindReplace } from "mdast-util-find-and-replace"
+import { JSResource } from "../../../util/resources"
+import { visit } from "unist-util-visit"
+import { Root } from "mdast"
+import { Pluggable } from "unified"
+import { Element, Literal, Root as HtmlRoot } from "hast"
+
+interface Options {
+  enabled: Boolean
+}
+
+const defaultOptions: Options = {
+  enabled: true,
+}
+
+const blockReferenceRegex = new RegExp(/\^([-_A-Za-z0-9]+)$/g)
+
+export const ObsidianBlockReference: QuartzParser<Partial<Options>> = (userOpts) => {
+  const opts: Options = { ...defaultOptions, ...userOpts }
+  return {
+    name: "ObsidianBlockReference",
+    textTransform(_ctx, src: string | Buffer) {
+      if (src instanceof Buffer) {
+        src = src.toString()
+      }
+      return src
+    },
+    markdownPlugins(_tree, _file) {
+      return [new RegExp(""), ""] as [RegExp, string | ReplaceFunction]
+    },
+    htmlPlugins(tree, file) {
+      const inlineTagTypes = new Set(["p", "li"])
+      const blockTagTypes = new Set(["blockquote"])
+      if (opts.enabled && tree !== undefined) {
+        return () => {
+          file.data.blocks = {}
+
+          visit(tree, "element", (node, index, parent) => {
+            if (blockTagTypes.has(node.tagName)) {
+              const nextChild = parent?.children.at(index! + 2) as Element
+              if (nextChild && nextChild.tagName === "p") {
+                const text = nextChild.children.at(0) as Literal
+                if (text && text.value && text.type === "text") {
+                  const matches = text.value.match(blockReferenceRegex)
+                  if (matches && matches.length >= 1) {
+                    parent!.children.splice(index! + 2, 1)
+                    const block = matches[0].slice(1)
+
+                    if (!Object.keys(file.data.blocks!).includes(block)) {
+                      node.properties = {
+                        ...node.properties,
+                        id: block,
+                      }
+                      file.data.blocks![block] = node
+                    }
+                  }
+                }
+              }
+            } else if (inlineTagTypes.has(node.tagName)) {
+              const last = node.children.at(-1) as Literal
+              if (last && last.value && typeof last.value === "string") {
+                const matches = last.value.match(blockReferenceRegex)
+                if (matches && matches.length >= 1) {
+                  last.value = last.value.slice(0, -matches[0].length)
+                  const block = matches[0].slice(1)
+
+                  if (last.value === "") {
+                    // this is an inline block ref but the actual block
+                    // is the previous element above it
+                    let idx = (index ?? 1) - 1
+                    while (idx >= 0) {
+                      const element = parent?.children.at(idx)
+                      if (!element) break
+                      if (element.type !== "element") {
+                        idx -= 1
+                      } else {
+                        if (!Object.keys(file.data.blocks!).includes(block)) {
+                          element.properties = {
+                            ...element.properties,
+                            id: block,
+                          }
+                          file.data.blocks![block] = element
+                        }
+                        return
+                      }
+                    }
+                  } else {
+                    // normal paragraph transclude
+                    if (!Object.keys(file.data.blocks!).includes(block)) {
+                      node.properties = {
+                        ...node.properties,
+                        id: block,
+                      }
+                      file.data.blocks![block] = node
+                    }
+                  }
+                }
+              }
+            }
+          })
+
+          file.data.htmlAst = tree
+        }
+      }
+      return {} as Pluggable
+    },
+    externalResources() {
+      const js = {} as JSResource
+      return js
+    },
+  }
+}