How to include pre-rendered tables?

[roaldarbol]

Description

I need to include tables that are produced externally - is there a good (simple) way of doing that? The tables are also output from R (either {gt} or {tinytable}).

I did find #6602 about HTML, but there didn't seem to be an easy way like:

```{=html}
{{<include "table.html" >}}
```

I guess the question implicitly also asks: Which format should I export to for highest portability into Quarto?

[mcanouil]

Did you actually try? The thread you mentioned is more than one year old.

Note that it won't work because the code you are showing is not valid as it does not respect the shortcode syntax.

Spoiler: it works

Input	Output
--- title: "Quarto Playground" format: html --- ```{=html} {{< include table.html >}} ``` <table> <tr> <th>Header 1</th> <th>Header 2</th> </tr> <tr> <td>Row 1, Cell 1</td> <td>Row 1, Cell 2</td> </tr> <tr> <td>Row 2, Cell 1</td> <td>Row 2, Cell 2</td> </tr> </table>

[roaldarbol]

Makes complete sense - I'm surprised since both {gt} and Quarto are developed under the Posit umbrella; I expected a simple workflow to be: Export table -> Import table.

Thanks @mcanouil for pointing that out, I hadn't given it any thought. I'm now looking into how I can save just the <table> content from {gt}. @gordonwoodhull I'm currently trying as_raw_html() with readr::write_file(), but I'm still getting a <div> around it all, but I'll hack around some more. I'll report back! Thanks both!

[mcanouil]

gt::gtsave() goal is to export a valid HTML document with a table. Such export is rarely intended for use inside another HTML document without iframe. (and gt is way older that Quarto)

[gordonwoodhull]

It will work okay with the div. It's the top-level html tags that cause problems.

[roaldarbol]

That's not a table, that's an HTML document.

You cannot have a complete HTML document inside another. That's not possible and it's beyond Quarto. When trying to embed a whole HTML document, the usual solution is iframe.

Haha, I just tried including the full HTML page exported by gtsave() for fun (the one in #11067 (reply in thread)), and it friggin renders too! 😅 So you actually can have a complete HTML document inside another (at least this HTML document). That's quite cool really!

[mcanouil]

That's "luck" and I wouldn't rely on this in general.

To be clear, if the "non table" components are kept in the page, it can break tools such as assistive technologies, etc. as your document would be malformed even if displayed "properly".

[gordonwoodhull]

Here's an example to write an html fragment using gt:

---
title: exporting html fragment from gt
---

```{r}

library(dplyr)
library(gt)

htmlcontent <- as_raw_html(
  exibble |>
    gt() |>
    data_color()
)
writeLines(htmlcontent, "temp.html")
```

I can't combine the html raw block in this example because it tries to include it before the R code runs, but it works in a separate document.

[roaldarbol]

Yup, I can save with this too:

```{r}
library(dplyr)
library(gt)
library(readr)
exibble |> 
  gt::gt() |> 
  gt::data_color() |>
  gt::as_raw_html() |> 
  readr::write_file("table.html")
```

```{r}
htmlcontent <- as_raw_html(
  exibble |>
    gt::gt() |>
    gt::data_color()
)
writeLines(htmlcontent, "table_2.html")
```

But I can't get the rendering to work:

---
title: "test-table"
format: html
---

```{=html}
{{<include "table.html">}}
```

```{=html}
{{<include "table_2.html">}}
```

It results in:

[gordonwoodhull]

As @mcanouil pointed out earlier, your shortcode syntax is slightly off: you need spaces after < and before >

{{< include "table.html" >}}

[cscheid]

(In passing: we really need syntax error checking/linting :( )

[roaldarbol]

Ah, I didn't know what shortcode syntax meant - now it works!!!🥳

[roaldarbol]

In conclusion (as of today), future fellow R strugglers, who need to output your tables and import them into a Quarto project:

• Export. Export to HTML; but NOT with gt::gtsave(), use one of the ways in How to include pre-rendered tables? #11067 (reply in thread).
• Import. You can include your table in a {=html} block:

```{=html}
{{< include "table.html" >}}
```

BONUS:
If you want to be able to reference the table and give it a caption, you can simply place the {=html} block inside a table environment:

:::{#tbl-my-table}
```{=html}
{{< include "table.html" >}}
```
My interesting caption.
:::

Many thanks @mcanouil and @gordonwoodhull for the help!

[cderv]

The tables are also output from R (either {gt} or {tinytable})

Out of curiosity, why do you need to export to HTML in the first place ?

If those are produced by R function you could use it directly in a quarto document. Either the data and the code, or save the R table object to a file (like .rds) and load this object in your quarto document for printing.

Just curious about the workflow that pushed a export HTML to import HTML

Thanks.

[roaldarbol]

Generally, it's a choice of file over app philosophy.
Basically, I want the portability; should Quarto (or MyST, or whichever writing tool) not be able to do what I want, I'd like to migrate my writing to e.g. LaTeX, Typst or Obsidian (or wherever makes sense) without having to worry about being tied to code rendering capabilities.

In this particular case I had been writing in MyST Markdown, so I needed all the imports to be pre-rendered - only after having been writing for half a year am I trying out Quarto as an alternative. It'a also going to be used in two separate writing projects that need to live in separate git repositories, one for a paper and one for my PhD thesis.

Hope that clarifies it. 😊

[cderv]

Thanks a lot. It makes total sense, and thanks for sharing the article link !

[allefeld]

Even if one is happy to rely on specific software – I don't want to have extensive code in text-oriented documents like a paper manuscript. I usually have one or more additional documents which create figures and save them to disk, and they are then used in the manuscript etc.

I want to do the same with tables, and was searching for an appropriate file format for a while. Now I've settled on Quarto's HTML-with-Markdown. The only thing that's missing is a decent editor, for tables which are not data-generated.