Parsers work, tagpage/folderpage broken

quartz.config.ts

@@ -77,8 +77,8 @@ const config: QuartzConfig = {
       Plugin.AliasRedirects(),
       Plugin.ComponentResources(),
       Plugin.ContentPage(),
-      Plugin.FolderPage(),
+      //Plugin.FolderPage(),
-      Plugin.TagPage(),
+      //Plugin.TagPage(),
       Plugin.ContentIndex({
         enableSiteMap: true,
         enableRSS: true,

quartz/plugins/parsers/custom/default.ts

@@ -23,11 +23,11 @@ export const CustomDefault: QuartzParser<Partial<Options>> = (userOpts) => {
       return src
     },
     markdownPlugins(_ctx) {
-      const plug: Pluggable = (tree: Root, _file) => {
       const replacements: [RegExp, string | ReplaceFunction][] = []
+      const plug: Pluggable = (tree: Root, _file) => {
         mdastFindReplace(tree, replacements)
       }
-      return plug
+      return replacements
     },
     htmlPlugins() {
       const plug: Pluggable = () => {}

quartz/plugins/parsers/obsidian/arrows.ts

@@ -42,9 +42,9 @@ export const ObsidianArrow: QuartzParser<Partial<Options>> = (userOpts) => {
       return src
     },
     markdownPlugins(_ctx) {
+      const replacements: [RegExp, string | ReplaceFunction][] = []
       const plug: Pluggable = (tree: Root, _path) => {
         if (opts.enabled) {
-          const replacements: [RegExp, string | ReplaceFunction][] = []
           replacements.push([
             arrowRegex,
             (value: string, ..._capture: string[]) => {
@@ -56,10 +56,9 @@ export const ObsidianArrow: QuartzParser<Partial<Options>> = (userOpts) => {
               }
             },
           ])
-          mdastFindReplaceInHtml(tree, replacements, opts.inHtml)
         }
       }
-      return plug
+      return replacements
     },
     htmlPlugins() {
       const plug: Pluggable = () => {}

quartz/plugins/parsers/obsidian/blockreference.ts

@@ -27,11 +27,11 @@ export const ObsidianBlockReference: QuartzParser<Partial<Options>> = (userOpts)
       return src
     },
     markdownPlugins(_ctx) {
-      const plug: Pluggable = (tree: Root, _file) => {
       const replacements: [RegExp, string | ReplaceFunction][] = []
+      const plug: Pluggable = (tree: Root, _file) => {
         mdastFindReplace(tree, replacements)
       }
-      return plug
+      return replacements
     },
     htmlPlugins() {
       const inlineTagTypes = new Set(["p", "li"])

quartz/plugins/parsers/obsidian/callouts.ts

@@ -1,6 +1,7 @@
 import { QuartzParser } from "../../types"
 import { JSResource } from "../../../util/resources"
 import { Root, BlockContent, DefinitionContent, Paragraph, Html } from "mdast"
+import { ReplaceFunction, findAndReplace as mdastFindReplace } from "mdast-util-find-and-replace"
 import { visit } from "unist-util-visit"
 import { Pluggable } from "unified"
 // @ts-ignore
@@ -77,6 +78,7 @@ export const ObsidianCallouts: QuartzParser<Partial<Options>> = (userOpts) => {
       return src
     },
     markdownPlugins(_ctx) {
+      const replacements: [RegExp, string | ReplaceFunction][] = []
       const plug: Pluggable = (tree: Root, _path) => {
         if (opts.enabled) {
           visit(tree, "blockquote", (node) => {
@@ -181,7 +183,7 @@ export const ObsidianCallouts: QuartzParser<Partial<Options>> = (userOpts) => {
           })
         }
       }
-      return plug
+      return replacements
     },
     htmlPlugins() {
       const plug: Pluggable = () => {}

quartz/plugins/parsers/obsidian/checkboxes.ts

@@ -30,11 +30,11 @@ export const ObsidianCheckboxes: QuartzParser<Partial<Options>> = (userOpts) =>
       return src
     },
     markdownPlugins(_ctx) {
-      const plug: Pluggable = (tree: Root, _file) => {
       const replacements: [RegExp, string | ReplaceFunction][] = []
+      const plug: Pluggable = (tree: Root, _file) => {
         mdastFindReplaceInHtml(tree, replacements, opts.inHtml)
       }
-      return plug
+      return replacements
     },
     htmlPlugins() {
       if (opts.enabled) {

quartz/plugins/parsers/obsidian/comments.ts

@@ -33,13 +33,9 @@ export const ObsidianComments: QuartzParser<Partial<Options>> = (userOpts) => {
       return src
     },
     markdownPlugins(_ctx) {
-      const plug: Pluggable = (tree: Root, _file) => {
-        if (opts.enabled) {
       const replacements: [RegExp, string | ReplaceFunction][] = []
-          mdastFindReplaceInHtml(tree, replacements, opts.inHtml)
+      const plug: Pluggable = (tree: Root, _file) => {}
-        }
+      return replacements
-      }
-      return plug
     },
     htmlPlugins() {
       const plug: Pluggable = () => {}

quartz/plugins/parsers/obsidian/highlights.ts

@@ -30,9 +30,9 @@ export const ObsidianHighlights: QuartzParser<Partial<Options>> = (userOpts) =>
       return src
     },
     markdownPlugins(_ctx) {
+      const replacements: [RegExp, string | ReplaceFunction][] = []
       const plug: Pluggable = (tree: Root, _path) => {
         if (opts.enabled) {
-          const replacements: [RegExp, string | ReplaceFunction][] = []
           replacements.push([
             highlightRegex,
             (_value: string, ...capture: string[]) => {
@@ -43,10 +43,9 @@ export const ObsidianHighlights: QuartzParser<Partial<Options>> = (userOpts) =>
               }
             },
           ])
-          mdastFindReplaceInHtml(tree, replacements, opts.inHtml)
         }
       }
-      return plug
+      return replacements
     },
     htmlPlugins() {
       const plug: Pluggable = () => {}

quartz/plugins/parsers/obsidian/mermaid.ts

@@ -1,5 +1,6 @@
 import { QuartzParser } from "../../types"
 import { JSResource } from "../../../util/resources"
+import { ReplaceFunction, findAndReplace as mdastFindReplace } from "mdast-util-find-and-replace"
 import { visit } from "unist-util-visit"
 import { Root, Code } from "mdast"
 import { Pluggable } from "unified"
@@ -25,6 +26,7 @@ export const ObsidianMermaid: QuartzParser<Partial<Options>> = (userOpts) => {
       return src
     },
     markdownPlugins() {
+      const replacements: [RegExp, string | ReplaceFunction][] = []
       const plug: Pluggable = (tree: Root, _file) => {
         if (opts.enabled) {
           visit(tree, "code", (node: Code) => {
@@ -38,7 +40,7 @@ export const ObsidianMermaid: QuartzParser<Partial<Options>> = (userOpts) => {
           })
         }
       }
-      return plug
+      return replacements
     },
     htmlPlugins() {
       const plug: Pluggable = () => {}

quartz/plugins/parsers/obsidian/tags.ts

@@ -3,6 +3,7 @@ import { ReplaceFunction, findAndReplace as mdastFindReplace } from "mdast-util-
 import { FilePath, pathToRoot, slugTag, slugifyFilePath } from "../../../util/path"
 import { JSResource } from "../../../util/resources"
 import { Root } from "mdast"
+import path from "path"
 import { Pluggable } from "unified"
 import { mdastFindReplaceInHtml } from "../../transformers/markdown"
 
@@ -35,9 +36,10 @@ export const ObsidianTags: QuartzParser<Partial<Options>> = (userOpts) => {
       return src
     },
     markdownPlugins(_ctx) {
-      const plug: Pluggable = (tree: Root, file) => {
-        const base = pathToRoot(file.data.slug!)
       const replacements: [RegExp, string | ReplaceFunction][] = []
+      const plug: Pluggable = (tree: Root, file) => {
+        if (opts.enabled) {
+          const base = pathToRoot(file.data.slug!)
           replacements.push([
             tagRegex,
             (_value: string, tag: string) => {
@@ -69,9 +71,9 @@ export const ObsidianTags: QuartzParser<Partial<Options>> = (userOpts) => {
               }
             },
           ])
-        mdastFindReplaceInHtml(tree, replacements, opts.inHtml)
         }
-      return plug
+      }
+      return replacements
     },
     htmlPlugins() {
       const plug: Pluggable = () => {}

quartz/plugins/parsers/obsidian/wikilinks.ts

@@ -5,6 +5,7 @@ import { JSResource } from "../../../util/resources"
 import { Root } from "mdast"
 import { Pluggable } from "unified"
 import { mdastFindReplaceInHtml } from "../../transformers/markdown"
+import path from "path"
 
 interface Options {
   enabled: Boolean
@@ -82,8 +83,9 @@ export const ObsidianWikilinks: QuartzParser<Partial<Options>> = (userOpts) => {
       return src
     },
     markdownPlugins(_ctx) {
-      const plug: Pluggable = (tree: Root, path) => {
       const replacements: [RegExp, string | ReplaceFunction][] = []
+      const plug: Pluggable = (tree: Root, file) => {
+        if (opts.enabled) {
           replacements.push([
             wikilinkRegex,
             (value: string, ...capture: string[]) => {
@@ -117,7 +119,9 @@ export const ObsidianWikilinks: QuartzParser<Partial<Options>> = (userOpts) => {
                     type: "html",
                     value: `<video src="${url}" controls></video>`,
                   }
-              } else if ([".mp3", ".webm", ".wav", ".m4a", ".ogg", ".3gp", ".flac"].includes(ext)) {
+                } else if (
+                  [".mp3", ".webm", ".wav", ".m4a", ".ogg", ".3gp", ".flac"].includes(ext)
+                ) {
                   return {
                     type: "html",
                     value: `<audio src="${url}" controls></audio>`,
@@ -155,9 +159,9 @@ export const ObsidianWikilinks: QuartzParser<Partial<Options>> = (userOpts) => {
               }
             },
           ])
-        mdastFindReplaceInHtml(tree, replacements, opts.inHtml)
         }
-      return plug
+      }
+      return replacements
     },
     htmlPlugins() {
       const plug: Pluggable = () => {}

quartz/plugins/parsers/obsidian/youtube.ts

@@ -28,11 +28,11 @@ export const ObsidianYouTube: QuartzParser<Partial<Options>> = (userOpts) => {
       return src
     },
     markdownPlugins(_ctx) {
-      const plug: Pluggable = (tree: Root, _file) => {
       const replacements: [RegExp, string | ReplaceFunction][] = []
+      const plug: Pluggable = (tree: Root, _file) => {
         mdastFindReplace(tree, replacements)
       }
-      return plug
+      return replacements
     },
     htmlPlugins() {
       if (opts.enabled) {

quartz/plugins/transformers/markdown.ts

@@ -184,9 +184,10 @@ export const mdastFindReplaceInHtml = (
         }
       }
     })
-  }
+  } else {
     mdastFindReplace(tree, replacements)
   }
+}
 
 export const CommonMarkFlavoredMarkdown: QuartzTransformerPlugin<Partial<CommonMarkOptions>> = (
   userOpts,
@@ -254,7 +255,9 @@ export const GitHubFlavoredMarkdown: QuartzTransformerPlugin<Partial<GitHubOptio
     markdownPlugins(ctx) {
       const plugins: PluggableList = []
 
-      plugins.push(GitHubSmartypants({ enabled: opts.enableSmartyPants }).markdownPlugins(ctx))
+      plugins.push(
+        GitHubSmartypants({ enabled: opts.enableSmartyPants }).markdownPlugins(ctx) as Pluggable,
+      )
 
       return plugins
     },
@@ -291,6 +294,27 @@ export const ObsidianFlavoredMarkdown: QuartzTransformerPlugin<Partial<ObsidianO
 
       const inHtml = opts.enableInHtmlEmbed
 
+      const replacements: [RegExp, string | ReplaceFunction][] = []
+
+      replacements.push.apply(
+        ObsidianWikilinks({ enabled: opts.wikilinks, inHtml: inHtml }).markdownPlugins(ctx),
+      )
+      replacements.push.apply(
+        ObsidianHighlights({ enabled: opts.highlight, inHtml: inHtml }).markdownPlugins(ctx),
+      )
+      replacements.push.apply(
+        ObsidianArrow({ enabled: opts.parseArrows, inHtml: inHtml }).markdownPlugins(ctx),
+      )
+      replacements.push.apply(
+        ObsidianTags({ enabled: opts.parseTags, inHtml: inHtml }).markdownPlugins(ctx),
+      )
+
+      plugins.push(() => {
+        return (tree: Root, file) => {
+          mdastFindReplaceInHtml(tree, replacements, inHtml)
+        }
+      })
+
       /*plugins.push(() => {
         return (tree: Root, file) => {
           //const replacements: [RegExp, string | ReplaceFunction][] = []
@@ -305,7 +329,7 @@ export const ObsidianFlavoredMarkdown: QuartzTransformerPlugin<Partial<ObsidianO
           //mdastFindReplace(tree, replacements)
         }
       })*/
-      plugins.push(
+      /*plugins.push(
         ObsidianWikilinks({ enabled: opts.wikilinks, inHtml: inHtml }).markdownPlugins(ctx),
       )
       plugins.push(
@@ -314,23 +338,35 @@ export const ObsidianFlavoredMarkdown: QuartzTransformerPlugin<Partial<ObsidianO
       plugins.push(
         ObsidianArrow({ enabled: opts.parseArrows, inHtml: inHtml }).markdownPlugins(ctx),
       )
-      plugins.push(ObsidianTags({ enabled: opts.parseTags, inHtml: inHtml }).markdownPlugins(ctx))
+      plugins.push(ObsidianTags({ enabled: opts.parseTags, inHtml: inHtml }).markdownPlugins(ctx))*/
-      plugins.push(ObsidianVideo({ enabled: opts.enableVideoEmbed }).markdownPlugins(ctx))
+      plugins.push(() => {
-      plugins.push(ObsidianCallouts({ enabled: opts.callouts }).markdownPlugins(ctx))
+        return (tree: Root, file) =>
-      plugins.push(ObsidianMermaid({ enabled: opts.mermaid }).markdownPlugins(ctx))
+          ObsidianVideo({ enabled: opts.enableVideoEmbed }).markdownPlugins(ctx)
+      })
+      plugins.push(() => {
+        return (tree: Root, file) =>
+          ObsidianCallouts({ enabled: opts.callouts }).markdownPlugins(ctx)
+      })
+      plugins.push(() => {
+        return (tree: Root, file) => ObsidianMermaid({ enabled: opts.mermaid }).markdownPlugins(ctx)
+      })
 
       return plugins
     },
     htmlPlugins() {
       const plugins: PluggableList = [rehypeRaw]
 
-      plugins.push(
+      plugins.push(() => {
-        ObsidianBlockReference({ enabled: opts.parseBlockReferences }).htmlPlugins() as Pluggable,
+        return (tree: Root, file) =>
-      )
+          ObsidianBlockReference({ enabled: opts.parseBlockReferences }).htmlPlugins() as Pluggable
-      plugins.push(ObsidianYouTube({ enabled: opts.enableYouTubeEmbed }).htmlPlugins() as Pluggable)
+      })
-      plugins.push.apply(
+      plugins.push(() => {
-        ObsidianCheckboxes({ enabled: opts.enableCheckbox }).htmlPlugins() as Pluggable[],
+        return (tree: Root, file) =>
-      )
+          ObsidianYouTube({ enabled: opts.enableYouTubeEmbed }).htmlPlugins() as Pluggable
+      })
+      /*plugins.push(() => {
+        return (tree: HtmlRoot, file) => ObsidianCheckboxes({ enabled: opts.enableCheckbox }).htmlPlugins() as Pluggable}
+      )*/
 
       return plugins
     },

quartz/plugins/types.ts

@@ -1,5 +1,6 @@
 import { PluggableList, Pluggable } from "unified"
 import { JSResource, StaticResources } from "../util/resources"
+import { ReplaceFunction, findAndReplace as mdastFindReplace } from "mdast-util-find-and-replace"
 import { ProcessedContent } from "./vfile"
 import { QuartzComponent } from "../components/types"
 import { FilePath } from "../util/path"
@@ -56,7 +57,7 @@ export type QuartzParser<Options extends OptionType = undefined> = (
 export type QuartzParserInstance = {
   name: string
   textTransform: (ctx: BuildCtx, src: string | Buffer) => string | Buffer
-  markdownPlugins: (ctx: BuildCtx) => Pluggable
+  markdownPlugins: (ctx: BuildCtx) => [RegExp, string | ReplaceFunction][]
   htmlPlugins: () => Pluggable | Pluggable[]
   externalResources: () => JSResource | string
 }