extensions return fully-qualified filter declarations to avoid double-appending project paths

Author: cscheid

src/command/preview/preview.ts

@@ -57,7 +57,11 @@ import { renderFormats } from "../render/render-contexts.ts";
 import { renderResultFinalOutput } from "../render/render.ts";
 import { replacePandocArg } from "../render/flags.ts";
 
-import { Format, isPandocFilter } from "../../config/types.ts";
+import {
+  Format,
+  isPandocFilter,
+  isQuartoFilterEntryPointQualifiedFull,
+} from "../../config/types.ts";
 import {
   kPdfJsInitialPath,
   pdfJsBaseDir,
@@ -467,17 +471,34 @@ export async function renderForPreview(
   extensionFiles.push(...renderResult.files.reduce(
     (extensionFiles: string[], file: RenderResultFile) => {
       const shortcodes = file.format.render.shortcodes || [];
-      const filters = (file.format.pandoc.filters || []).map((filter) =>
-        isPandocFilter(filter) ? filter.path : filter
-      );
+      const filters = (file.format.pandoc.filters || []).map((filter) => {
+        if (isPandocFilter(filter)) {
+          return filter.path;
+        }
+        if (isQuartoFilterEntryPointQualifiedFull(filter)) {
+          switch (filter.path.type) {
+            case "absolute":
+              return filter.path.path;
+            case "relative":
+              return join(dirname(file.input), filter.path.path);
+            case "project-relative":
+              return join(
+                project?.dir ?? dirname(file.input),
+                filter.path.path,
+              );
+          }
+        }
+        return filter;
+      });
       const ipynbFilters = file.format.execute["ipynb-filters"] || [];
       [...shortcodes, ...filters.map((filter) => filter), ...ipynbFilters]
         .forEach((extensionFile) => {
           if (!isAbsolute(extensionFile)) {
-            const extensionFullPath = join(dirname(file.input), extensionFile);
-            if (existsSync(extensionFullPath)) {
-              extensionFiles.push(normalizePath(extensionFullPath));
-            }
+            extensionFile = join(dirname(file.input), extensionFile);
+          }
+          // const extensionFullPath = join(dirname(file.input), extensionFile);
+          if (existsSync(extensionFile)) {
+            extensionFiles.push(normalizePath(extensionFile));
           }
         });
       return extensionFiles;

src/command/render/filters.ts

@@ -65,7 +65,7 @@ import {
   QuartoFilterEntryPointQualifiedFull,
 } from "../../config/types.ts";
 import { QuartoFilterSpec } from "./types.ts";
-import { Metadata } from "../../config/types.ts";
+import { Metadata, QualifiedPath } from "../../config/types.ts";
 import { kProjectType } from "../../project/types.ts";
 import { bibEngine } from "../../config/pdf.ts";
 import { rBinaryPath, resourcePath } from "../../core/resources.ts";
@@ -772,7 +772,7 @@ export async function resolveFilters(
         return filter.path;
       case "relative":
         return resolve(dirname(options.source), filter.path);
-      case "project":
+      case "project-relative":
         return resolve(join(options.project.dir, filter.path));
     }
   };
@@ -891,13 +891,18 @@ async function resolveFilterExtension(
       return { type: filter };
     }
     if (typeof filter !== "string") {
-      const fileType: "project" | "relative" = filter.path.startsWith("/")
-        ? "project"
-        : "relative";
-      const path = {
-        type: fileType,
-        path: filter.path,
-      };
+      const path: QualifiedPath = (() => {
+        if (typeof filter.path !== "string") {
+          const result = filter.path;
+          return result;
+        }
+        const fileType: "project-relative" | "relative" =
+          filter.path.startsWith("/") ? "project-relative" : "relative";
+        return {
+          type: fileType,
+          path: filter.path,
+        };
+      })();
       // deno-lint-ignore no-explicit-any
       if ((filter as any).at) {
         const entryPoint = filter as QuartoFilterEntryPoint;
@@ -939,8 +944,8 @@ async function resolveFilterExtension(
       const filterType: "json" | "lua" = extname(filter) !== ".lua"
         ? "json"
         : "lua";
-      const pathType: "project" | "relative" = filter.startsWith("/")
-        ? "project"
+      const pathType: "project-relative" | "relative" = filter.startsWith("/")
+        ? "project-relative"
         : "relative";
 
       return {
@@ -999,15 +1004,21 @@ async function resolveFilterExtension(
           },
         };
       }
-
+      if (typeof f.path === "string") {
+        return {
+          ...f,
+          // deno-lint-ignore no-explicit-any
+          at: (f as any).at ?? "__quarto-auto",
+          path: {
+            type: "absolute",
+            path: f.path,
+          },
+        };
+      }
       return {
         ...f,
-        // deno-lint-ignore no-explicit-any
         at: (f as any).at ?? "__quarto-auto",
-        path: {
-          type: "absolute",
-          path: f.path,
-        },
+        path: f.path,
       };
     });
   };

src/command/render/pandoc.ts

@@ -207,6 +207,7 @@ import { isWindows } from "../../deno_ral/platform.ts";
 import { appendToCombinedLuaProfile } from "../../core/performance/perfetto-utils.ts";
 import { makeTimedFunctionAsync } from "../../core/performance/function-times.ts";
 import { walkJson } from "../../core/json.ts";
+import { asRawPath } from "../../core/qualified-path.ts";
 
 // in case we are running multiple pandoc processes
 // we need to make sure we capture all of the trace files
@@ -919,11 +920,19 @@ export async function runPandoc(
     allDefaults.filters = allDefaults.filters.map((filter) => {
       if (typeof filter === "string") {
         return pandocMetadataPath(filter);
-      } else {
+      } else if (typeof filter.path === "string") {
         return {
           type: filter.type,
           path: pandocMetadataPath(filter.path),
         };
+      } else {
+        return {
+          type: filter.type,
+          path: pandocMetadataPath(asRawPath(filter.path, {
+            projectRoot: options.project.dir,
+            currentFileDir: dirname(options.source),
+          })),
+        };
       }
     });
 

src/config/types.ts

@@ -277,11 +277,17 @@ export interface FormatDependency {
   resources?: DependencyFile[];
 }
 
-type QualifiedPath = {
+export type PathType = "project-relative" | "relative" | "absolute";
+
+type BasePath = {
   path: string;
-  type: "relative" | "project" | "absolute";
 };
 
+export type QualifiedPath = BasePath & { type: PathType };
+export type AbsolutePath = BasePath & { type: "absolute" };
+export type RelativePath = BasePath & { type: "relative" };
+export type ProjectRelativePath = BasePath & { type: "project-relative" };
+
 export interface DependencyFile {
   name: string;
   path: string;
@@ -369,10 +375,20 @@ export type QuartoFilterEntryPointQualified =
   | QuartoFilterEntryPointQualifiedFull
   | QuartoFilterSpecialEntryPoint;
 
-export type QuartoFilter = string | PandocFilter | QuartoFilterEntryPoint;
+export type QuartoFilter =
+  | string
+  | PandocFilter
+  | QuartoFilterEntryPoint
+  | QuartoFilterEntryPointQualifiedFull;
 
 export function isPandocFilter(filter: QuartoFilter): filter is PandocFilter {
-  return (<PandocFilter> filter).path !== undefined;
+  return typeof (<PandocFilter> filter).path === "string";
+}
+
+export function isQuartoFilterEntryPointQualifiedFull(
+  filter: QuartoFilter,
+): filter is QuartoFilterEntryPointQualifiedFull {
+  return typeof (<PandocFilter> filter).path !== "string";
 }
 
 export function isFilterEntryPoint(