How can an R package's knit_print() discover the active Quarto project output-dir during rendering?

[ashishtiwari03]

In animint2 we are trying to support interactive plots in Quarto websites/books.

Context: animint/animint2#325
PR: animint/animint2#331

animint2::knit_print.animint() writes a directory of web assets for each plot, for example myplot/plot.json,
myplot/animint.js, etc. The HTML returned by knit_print() refers to myplot/plot.json.

This works in single-file R Markdown, but in Quarto website/book projects the final rendered output goes into a
project output directory such as _site/ or _book/. We need to copy the generated asset directory into the final
output directory.

Question: from inside an R package knit_print() method during quarto::quarto_render(), what is the recommended way
to determine the final output directory for the current document/project?

Is there an official environment variable, knitr option, or Quarto API that gives the project output directory and
current document output path? We want to avoid manually parsing _quarto.yml.

[mcanouil]

The location of files created by knitr can be configured by knitr with fig.path (fig-path).
https://yihui.org/knitr/options/

Regarding quarto::quarto_render(), it's a wrapper around Quarto CLI. Options are documented in their respective documentations websites:

• https://quarto.org/docs/cli/
• https://quarto-dev.github.io/quarto-r/reference/quarto_render.html

[cderv]

I don't think fig.path will be what is needed to have some website assets moved to the output directory. 🤔

This is a bit more complex in their case.

[mcanouil]

If the assets are in the document directory and exposed by the code (which should be the case with knit_pirnt(), Quarto should detect them as resources and move them automatically to the output directory.

If that's not the case, a small reproducible example that is not a complex R package is needed.

[cderv]

which should be the case with knit_pirnt()

This is not the idiomatic way to pass dependencies to be included with a plot output. See my answer below.

Tweaking fig.path is also not without side effect. This is a knitr-only option, not a quarto option, and it may not be reliable with quarto context to change it. rmarkdown and quarto expexts a certains structure.
Not always easy to know which do what, but yihui.org/knitr/options is about full knitr options and they need to read in their correct context of use (bare knitr or within rmarkdown / quarto).

Anyhow, for dependencies associated with some output knit_meta should be the way. Hopefully it can handle some resources. Otherwise, we may need to come up with a add_ressources() logic 🤔

[cderv]

Quarto sets some environment variable you can get from your R session

• https://quarto.org/docs/advanced/environment-vars.html#variables-quarto-sets

You could use that.

However, in your case, if you are passing your assets as html dependencies, I would expect them to be moved in the output dir correctly.

I think you are trying to handle yourself the directories resolution. You should probably leverage knit_print metadata to pass your assets as html dependencies to be used for your code to be working in HTML.

Look at knit_print() vignettes: https://cran.r-project.org/web/packages/knitr/vignettes/knit_print.html#sec:metadata

It could also be as html dependencies if your package leverage htmltools or htmlwidgets

Look at knit_print vignettes, I believe this could help. Idea is to provide to knitr the metadata information, and then, knitr, rmarkdown and quarto will do the right thing without you directly needing to know where to put files.

Hope it helps

[ashishtiwari03]

Thanks, this helps.

So it sounds like fig.path is not the right mechanism for this case, and the better direction is to expose the
animint files through knit_print() metadata / knit_meta, possibly as htmltools dependencies, so Quarto can
manage the resources.

I will discuss this on the animint2 PR and try revising the fix in that direction.

[cderv]

I would say you can get something working using any env var that quarto sets and readable from knitr.
Especially QUARTO_EXECUTE_INFO has a lot of information https://quarto.org/docs/advanced/quarto-execute-info.html

However, I see QUARTO_PROJECT_OUTPUT_DIR is only exposed in pre/post render script, and not for execution - which is unexpected. I don't remember the reason - so possibly we could also expose QUARTO_PROJECT_OUTPUT_DIR to R process for use in R packages.

However, looking at knit_meta of other knitr / rmarkdown only logic could be most idiomatic in your case. HTML dependencies are detected and moved to output directory, like website resources

[ashishtiwari03]

Thanks, that clarifies the situation.

I will check what is available in QUARTO_EXECUTE_INFO during the R execution step. If it does not include enough
information to determine the project output directory, I will report that back on the animint2 PR.

For the animint2 fix, I will also look at the knit_meta path, since you mentioned that is probably the more
idiomatic approach for resources associated with HTML output.

[cderv]

You can also look at how other packages that needs to ship HTML dependencies with their outputs are doing within knitr context. Usually htmlwidgets, or htmldependencies is the way to go in rmarkdown context.