finish path refactoring, add sourcemap + better trace support

quartz/plugins/transformers/links.ts

@@ -1,5 +1,5 @@
 import { QuartzTransformerPlugin } from "../types"
-import { CanonicalSlug, transformInternalLink } from "../../path"
+import { CanonicalSlug, RelativeURL, canonicalizeServer, joinSegments, pathToRoot, resolveRelative, splitAnchor, transformInternalLink } from "../../path"
 import path from "path"
 import { visit } from 'unist-util-visit'
 import isAbsoluteUrl from "is-absolute-url"
@@ -9,15 +9,11 @@ interface Options {
   markdownLinkResolution: 'absolute' | 'relative' | 'shortest'
   /** Strips folders from a link so that it looks nice */
   prettyLinks: boolean
-  indexAnchorLinks: boolean
-  indexExternalLinks: boolean
 }
 
 const defaultOptions: Options = {
   markdownLinkResolution: 'absolute',
   prettyLinks: true,
-  indexAnchorLinks: false,
-  indexExternalLinks: false,
 }
 
 export const CrawlLinks: QuartzTransformerPlugin<Partial<Options> | undefined> = (userOpts) => {
@@ -27,32 +23,34 @@ export const CrawlLinks: QuartzTransformerPlugin<Partial<Options> | undefined> =
     htmlPlugins() {
       return [() => {
         return (tree, file) => {
-          const curSlug = file.data.slug!
-          const transformLink = (target: string) => {
-            const targetSlug = transformInternalLink(target) 
-            if (opts.markdownLinkResolution === 'relative' && !path.isAbsolute(targetSlug)) {
-              return './' + relative(curSlug, targetSlug)
+          const curSlug = canonicalizeServer(file.data.slug!)
+          const transformLink = (target: string): RelativeURL => {
+            const targetSlug = transformInternalLink(target).slice("./".length)
+            let [targetCanonical, targetAnchor] = splitAnchor(targetSlug)
+            if (opts.markdownLinkResolution === 'relative') {
+              return targetSlug as RelativeURL
             } else if (opts.markdownLinkResolution === 'shortest') {
               // https://forum.obsidian.md/t/settings-new-link-format-what-is-shortest-path-when-possible/6748/5
               const allSlugs = file.data.allSlugs!
 
               // if the file name is unique, then it's just the filename
               const matchingFileNames = allSlugs.filter(slug => {
-                const parts = toServerSlug(slug).split(path.posix.sep)
+                const parts = slug.split(path.posix.sep)
                 const fileName = parts.at(-1)
-                return targetSlug === fileName
+                return targetCanonical === fileName
               })
 
               if (matchingFileNames.length === 1) {
-                const targetSlug = toServerSlug(matchingFileNames[0])
-                return './' + relativeToRoot(curSlug, targetSlug)
+                const targetSlug = canonicalizeServer(matchingFileNames[0])
+                return resolveRelative(curSlug, targetSlug) + targetAnchor as RelativeURL
               }
 
               // if it's not unique, then it's the absolute path from the vault root
               // (fall-through case)
             }
+
             // treat as absolute
-            return './' + relativeToRoot(curSlug, targetSlug)
+            return joinSegments(pathToRoot(curSlug), targetSlug) as RelativeURL
           }
 
           const outgoing: Set<CanonicalSlug> = new Set()
@@ -63,26 +61,15 @@ export const CrawlLinks: QuartzTransformerPlugin<Partial<Options> | undefined> =
               node.properties &&
               typeof node.properties.href === 'string'
             ) {
-              let dest = node.properties.href
+              let dest = node.properties.href as RelativeURL
               node.properties.className = isAbsoluteUrl(dest) ? "external" : "internal"
 
               // don't process external links or intra-document anchors
               if (!(isAbsoluteUrl(dest) || dest.startsWith("#"))) {
-                node.properties.href = transformLink(dest)
-              }
-
-              dest = node.properties.href
-              if (dest.startsWith(".")) {
-                const normalizedPath = path.normalize(path.join(curSlug, dest))
-                outgoing.add(trimPathSuffix(normalizedPath))
-              } else if (dest.startsWith("#")) {
-                if (opts.indexAnchorLinks) {
-                  outgoing.add(dest)
-                }
-              } else {
-                if (opts.indexExternalLinks) {
-                  outgoing.add(dest)
-                }
+                dest = node.properties.href = transformLink(dest)
+                const canonicalDest = path.normalize(joinSegments(curSlug, dest))
+                const [destCanonical, _destAnchor] = splitAnchor(canonicalDest)
+                outgoing.add(destCanonical as CanonicalSlug)
               }
 
               // rewrite link internals if prettylinks is on

quartz/plugins/transformers/ofm.ts

@@ -2,7 +2,6 @@ import { PluggableList } from "unified"
 import { QuartzTransformerPlugin } from "../types"
 import { Root, HTML, BlockContent, DefinitionContent, Code } from 'mdast'
 import { findAndReplace } from "mdast-util-find-and-replace"
-import { slugify } from "../../path"
 import { slug as slugAnchor } from 'github-slugger'
 import rehypeRaw from "rehype-raw"
 import { visit } from "unist-util-visit"
@@ -10,6 +9,7 @@ import path from "path"
 import { JSResource } from "../../resources"
 // @ts-ignore
 import calloutScript from "../../components/scripts/callout.inline.ts"
+import { FilePath, slugifyFilePath, transformInternalLink } from "../../path"
 
 export interface Options {
   comments: boolean
@@ -139,14 +139,15 @@ export const ObsidianFlavoredMarkdown: QuartzTransformerPlugin<Partial<Options>
         plugins.push(() => {
           return (tree: Root, _file) => {
             findAndReplace(tree, wikilinkRegex, (value: string, ...capture: string[]) => {
-              const [fp, rawHeader, rawAlias] = capture
+              let [fp, rawHeader, rawAlias] = capture
+              fp = fp.trim()
               const anchor = rawHeader?.trim() ?? ""
               const alias = rawAlias?.slice(1).trim()
 
               // embed cases
               if (value.startsWith("!")) {
-                const ext = path.extname(fp).toLowerCase()
-                const url = slugify(fp.trim()) + ext
+                const ext: string | undefined = path.extname(fp).toLowerCase()
+                const url = slugifyFilePath(fp as FilePath) + ext
                 if ([".png", ".jpg", ".jpeg", ".gif", ".bmp", ".svg"].includes(ext)) {
                   const dims = alias ?? ""
                   let [width, height] = dims.split("x", 2)
@@ -176,12 +177,15 @@ export const ObsidianFlavoredMarkdown: QuartzTransformerPlugin<Partial<Options>
                     type: 'html',
                     value: `<iframe src="${url}"></iframe>`
                   }
+                } else {
+                  // TODO: this is the node embed case
                 }
                 // otherwise, fall through to regular link
               }
 
               // internal link
-              const url = slugify(fp.trim() + anchor)
+              // const url = transformInternalLink(fp + anchor)
+              const url = fp + anchor
               return {
                 type: 'link',
                 url,

quartz/plugins/transformers/toc.ts

@@ -3,7 +3,6 @@ import { Root } from "mdast"
 import { visit } from "unist-util-visit"
 import { toString } from "mdast-util-to-string"
 import { slug as slugAnchor } from 'github-slugger'
-import { CanonicalSlug } from "../../path"
 
 export interface Options {
   maxDepth: 1 | 2 | 3 | 4 | 5 | 6,
@@ -20,7 +19,7 @@ const defaultOptions: Options = {
 interface TocEntry {
   depth: number,
   text: string,
-  slug: CanonicalSlug
+  slug: string // this is just the anchor (#some-slug), not the canonical slug
 }
 
 export const TableOfContents: QuartzTransformerPlugin<Partial<Options> | undefined> = (userOpts) => {