make path and globbing more platform invariant

quartz/plugins/emitters/assets.ts

@@ -1,55 +1,33 @@
-import { globbyStream } from "globby"
-import { FilePath, slugifyFilePath } from "../../path"
+import { FilePath, joinSegments, slugifyFilePath } from "../../path"
 import { QuartzEmitterPlugin } from "../types"
 import path from "path"
 import fs from "fs"
+import { glob } from "../../glob"
 
-interface Options {
-  attachmentsFolder: string | null
-}
-
-const defaultOptions: Options = {
-  attachmentsFolder: null,
-}
-
-export const Assets: QuartzEmitterPlugin<Options> = (userOpts?: Options) => {
-  const { attachmentsFolder } = { ...defaultOptions, ...userOpts }
-
+export const Assets: QuartzEmitterPlugin = () => {
   return {
     name: "Assets",
     getQuartzComponents() {
       return []
     },
-    async emit({ argv }, _content, _resources, _emit): Promise<FilePath[]> {
+    async emit({ argv, cfg }, _content, _resources, _emit): Promise<FilePath[]> {
       // glob all non MD/MDX/HTML files in content folder and copy it over
-      const assetsPath = path.join(argv.output, "assets")
-
-      const fps: FilePath[] = []
-      for await (const rawFp of globbyStream("**", {
-        ignore: ["**/*.md"],
-        cwd: argv.directory,
-      })) {
-        const fp = rawFp as FilePath
+      const assetsPath = joinSegments(argv.output, "assets")
+      const fps = await glob("**", argv.directory, ["**/*.md", ...cfg.configuration.ignorePatterns])
+      const res: FilePath[] = []
+      for (const fp of fps) {
         const ext = path.extname(fp)
-        const src = path.join(argv.directory, fp) as FilePath
-        let name = (slugifyFilePath(fp as FilePath) + ext) as FilePath
+        const src = joinSegments(argv.directory, fp) as FilePath
+        const name = (slugifyFilePath(fp as FilePath) + ext) as FilePath
 
-        if (attachmentsFolder) {
-          const segments = name.split("/")
-          if (segments.at(-2) === attachmentsFolder) {
-            segments.splice(-2, 1)
-            name = segments.join("/") as FilePath
-          }
-        }
-
-        const dest = path.join(assetsPath, name) as FilePath
+        const dest = joinSegments(assetsPath, name) as FilePath
         const dir = path.dirname(dest) as FilePath
         await fs.promises.mkdir(dir, { recursive: true }) // ensure dir exists
         await fs.promises.copyFile(src, dest)
-        fps.push(path.join("assets", fp) as FilePath)
+        res.push(joinSegments("assets", fp) as FilePath)
       }
 
-      return fps
+      return res
     },
   }
 }

quartz/plugins/emitters/static.ts

@@ -1,18 +1,18 @@
-import { globby } from "globby"
-import { FilePath, QUARTZ } from "../../path"
+import { FilePath, QUARTZ, joinSegments } from "../../path"
 import { QuartzEmitterPlugin } from "../types"
 import path from "path"
 import fs from "fs"
+import { glob } from "../../glob"
 
 export const Static: QuartzEmitterPlugin = () => ({
   name: "Static",
   getQuartzComponents() {
     return []
   },
-  async emit({ argv }, _content, _resources, _emit): Promise<FilePath[]> {
+  async emit({ argv, cfg }, _content, _resources, _emit): Promise<FilePath[]> {
     const staticPath = path.join(QUARTZ, "static")
-    const fps = await globby("*", { cwd: staticPath })
-    await fs.promises.cp(staticPath, path.join(argv.output, "static"), { recursive: true })
-    return fps.map((fp) => path.join("static", fp)) as FilePath[]
+    const fps = await glob("**", staticPath, cfg.configuration.ignorePatterns)
+    await fs.promises.cp(staticPath, joinSegments(argv.output, "static"), { recursive: true })
+    return fps.map((fp) => joinSegments("static", fp)) as FilePath[]
   },
 })

quartz/plugins/transformers/links.ts

@@ -100,7 +100,7 @@ export const CrawlLinks: QuartzTransformerPlugin<Partial<Options> | undefined> =
                 if (!isAbsoluteUrl(node.properties.src)) {
                   const ext = path.extname(node.properties.src)
                   node.properties.src =
-                    transformLink(path.join("assets", node.properties.src)) + ext
+                    transformLink(joinSegments("assets", node.properties.src)) + ext
                 }
               }
             })