finchie/new_manual - Change ZRGSUUICJKNHKVH2JZHHOKSSIQXNWCNLJX2ICSX524AG2XJKD3VAC

Add MVP list support

Still needs a merging pass, and styles to be added (including numbering). These changes will require a re-work of constructing HTML elements though.

Created by finchie on November 12, 2023

ZRGSUUICJKNHKVH2JZHHOKSSIQXNWCNLJX2ICSX524AG2XJKD3VAC

Dependencies

In channels

main

Change contents

Replacement in docs/test.typ at line 1 [3.242]

B:BD[3.242] → [2.0:61]

#table(
  columns: 2,
  rows: 2,
  [1],
  [2],
  [3],
  [4]
)

[3.242]

List:
- First
- Second
- Third
Ordered:
+ First
+ Second
+ Third
#enum(
  enum.item(1)[First step],
  enum.item(5)[Fifth step],
  enum.item(10)[Tenth step]
)

Replacement in crates/typser/src/content.rs at line 2 [4.2939]

B:BD[4.2967] → [2.277:315]

use typst_library::layout::TableElem;

[4.2967]

use typst_library::layout::{EnumElem, EnumItem, ListElem, ListItem, ParbreakElem, TableElem};

Insertion in crates/typser/src/content.rs at line 15 [4.2939]

[2.392]

[4.3233]

    UnorderedList(&'a ListElem),
    UnorderedListItem(&'a ListItem),
    ParagraphBreak(&'a ParbreakElem),
    OrderedList(&'a EnumElem),
    OrderedListItem(&'a EnumItem),

Insertion in crates/typser/src/content.rs at line 37 [4.2939]

[2.791]

[4.3620]

        } else if let Some(list) = value.to::<ListElem>() {
            Self::UnorderedList(list)
        } else if let Some(list) = value.to::<EnumElem>() {
            Self::OrderedList(list)
        } else if let Some(item) = value.to::<ListItem>() {
            Self::UnorderedListItem(item)
        } else if let Some(item) = value.to::<EnumItem>() {
            Self::OrderedListItem(item)
        } else if let Some(pragraph_break) = value.to::<ParbreakElem>() {
            Self::ParagraphBreak(pragraph_break)

Insertion in crates/typser/src/content.rs at line 97 [4.2939]

[2.2885]

            SupportedContent::UnorderedList(list) => {
                vec![xilem_html_element(
                    "ul",
                    vec![syn::Expr::Tuple(syn::ExprTuple {
                        attrs: Vec::new(),
                        paren_token: syn::token::Paren::default(),
                        elems: syn::punctuated::Punctuated::from_iter(
                            list.children()
                                .into_iter()
                                .map(|content| SupportedContent::downcast(content.body()))
                                .map(|supported| supported.to_xilem())
                                .flatten(),
                        ),
                    })],
                )]
            }
            SupportedContent::OrderedList(list) => {
                vec![xilem_html_element(
                    "ol",
                    vec![syn::Expr::Tuple(syn::ExprTuple {
                        attrs: Vec::new(),
                        paren_token: syn::token::Paren::default(),
                        elems: syn::punctuated::Punctuated::from_iter(
                            list.children()
                                .into_iter()
                                .map(|content| SupportedContent::downcast(content.body()))
                                .map(|supported| supported.to_xilem())
                                .flatten(),
                        ),
                    })],
                )]
            }
            SupportedContent::UnorderedListItem(item) => {
                vec![xilem_html_element(
                    "ul",
                    vec![xilem_html_element(
                        "li",
                        vec![syn::Expr::Tuple(syn::ExprTuple {
                            attrs: Vec::new(),
                            paren_token: syn::token::Paren::default(),
                            elems: syn::punctuated::Punctuated::from_iter(
                                SupportedContent::downcast(item.body()).to_xilem(),
                            ),
                        })],
                    )],
                )]
            }
            SupportedContent::OrderedListItem(item) => {
                vec![xilem_html_element(
                    "ol",
                    vec![xilem_html_element(
                        "li",
                        vec![syn::Expr::Tuple(syn::ExprTuple {
                            attrs: Vec::new(),
                            paren_token: syn::token::Paren::default(),
                            elems: syn::punctuated::Punctuated::from_iter(
                                SupportedContent::downcast(item.body()).to_xilem(),
                            ),
                        })],
                    )],
                )]
            }
            SupportedContent::ParagraphBreak(_parahraph_break) => {
                vec![xilem_html_element(
                    "br",
                    vec![syn::Expr::Tuple(syn::ExprTuple {
                        attrs: Vec::new(),
                        paren_token: syn::token::Paren::default(),
                        elems: syn::punctuated::Punctuated::new(),
                    })],
                )]
            }