Merge 73340f70a6f36bc46514a81b220373112fc7399e into b790c6d59ceaf7a809cc24b60c1f1509807470e2

README.md

@@ -174,7 +174,10 @@ typst help watch
 ```
 
 If you prefer an integrated IDE-like experience with autocompletion and instant 
-preview, you can also check out [Typst's free web app][app].
+preview, you can also check out our [free web app][app]. Alternatively, there is 
+a community-created language server called 
+[Tinymist](https://myriad-dreamin.github.io/tinymist/) which is integrated into 
+various editor extensions.
 
 ## Community
 The main places where the community gathers are our [Forum][forum] and our

crates/typst-library/src/introspection/count.rs

@@ -0,0 +1,92 @@
+use comemo::Tracked;
+
+use crate::diag::HintedStrResult;
+use crate::engine::Engine;
+use crate::foundations::{func, Array, Context, IntoValue, LocatableSelector, Selector};
+
+/// Counts element in the document.
+///
+/// The `count` function lets you count elements in your document of a
+/// particular type or with a particular label. It also allows to count them
+/// in a hierachical way. To use it, you first need to ensure that [context]
+/// is available.
+///
+/// Always returns an array of integers, even if called with just a single
+/// target.
+
+/// # Counting elements - simple
+///
+/// To just count elements of a single type/label up to the current location,
+/// pass the selector you want to count:
+/// ```example
+/// = Heading
+///
+/// = Another Heading
+///
+/// #context count(heading)
+///
+/// = Third Heading
+/// ```
+///
+/// Note that it will not return an integer, but an array with a single integer
+/// entry.
+
+/// # Counting elements - hierarchical
+///
+/// If you pass multiple targets, then it starts by counting the first target.
+/// Then the second target is counted _starting only from the last counted
+/// element of the first target_.
+///
+/// ```example
+/// = Some Heading
+///
+/// == Some Subheading
+///
+/// = Another Heading
+///
+/// == Some Subheading
+///
+/// #context count(heading.where(level: 1), heading.where(level: 2))
+///
+/// == Another Subheading
+/// ```
+#[func(contextual)]
+pub fn count(
+    /// The engine.
+    engine: &mut Engine,
+    /// The callsite context.
+    context: Tracked<Context>,
+    /// Each target can be
+    /// - an element function like a `heading` or `figure`,
+    /// - a `{<label>}`,
+    /// - a more complex selector like `{heading.where(level: 1)}`,
+    /// - or `{selector(heading).before(here())}`.
+    ///
+    /// Only [locatable]($location/#locatable) element functions are supported.
+    #[variadic]
+    targets: Vec<LocatableSelector>,
+    /// When passing this argument, it will count everything only from a
+    /// certain location on.
+    /// The selector must match exactly one element in the document. The most
+    /// useful kinds of selectors for this are [labels]($label) and
+    /// [locations]($location).
+    // TODO remove Option as soon as there is a special `start` location
+    #[named]
+    after: Option<LocatableSelector>,
+) -> HintedStrResult<Array> {
+    // NOTE this could be made more efficient
+    // one could directly get a slice &[Selector] from Vec<LocatableSelector>
+    // by using #[repr(transparent)] on LocatableSelector
+    let selectors: Vec<Selector> = targets.into_iter().map(|sel| sel.0).collect();
+    // TODO add argument "at" with default value "here"
+    // and compute `before` accordingly
+    let before = Some(context.location()?);
+    let after = match after {
+        Some(selector) => Some(selector.resolve_unique(engine.introspector, context)?),
+        None => None,
+    };
+
+    let nums = engine.introspector.count(&selectors, after, before);
+
+    Ok(nums.into_iter().map(IntoValue::into_value).collect())
+}

crates/typst-library/src/introspection/introspector.rs

@@ -254,6 +254,60 @@ impl Introspector {
         }
     }
 
+    /// Count hierarchically.
+    pub fn count(
+        &self,
+        selectors: &[Selector],
+        // TODO remove Option as soon as there is a special `start` location
+        after: Option<Location>,
+        // TODO remove Option as soon as there is a special `end` location
+        before: Option<Location>,
+    ) -> SmallVec<[usize; 3]> {
+        let mut nums = SmallVec::with_capacity(selectors.len());
+
+        // can't write `mut` directly into function parameters because not supported by comemo
+        let mut after = after;
+
+        for selector in selectors.iter() {
+            let list = self.query(selector);
+
+            // count how many elements in `list` are between after and end
+            let index_start = if let Some(after) = after {
+                if let Some(after) = self.get_by_loc(&after) {
+                    match self.binary_search(&list, after) {
+                        Ok(i) => i, // TODO if after is exclusive then must add 1 here
+                        Err(i) => i,
+                    }
+                } else {
+                    0
+                }
+            } else {
+                0
+            };
+            let index_end = if let Some(before) = before {
+                if let Some(before) = self.get_by_loc(&before) {
+                    match self.binary_search(&list, before) {
+                        Ok(i) => i + 1,
+                        Err(i) => i,
+                    }
+                } else {
+                    list.len()
+                }
+            } else {
+                list.len()
+            };
+            nums.push(index_end - index_start);
+
+            // the next level should be counted only from
+            // the last element of the previous level on
+            if index_end != 0 {
+                after = Some(list[index_end - 1].location().unwrap());
+            }
+        }
+
+        nums
+    }
+
     /// The total number pages.
     pub fn pages(&self) -> NonZeroUsize {
         NonZeroUsize::new(self.pages).unwrap_or(NonZeroUsize::ONE)

crates/typst-library/src/introspection/mod.rs

@@ -1,5 +1,7 @@
 //! Interaction between document parts.
 
+#[path = "count.rs"]
+mod count_;
 mod counter;
 #[path = "here.rs"]
 mod here_;
@@ -14,6 +16,7 @@ mod query_;
 mod state;
 mod tag;
 
+pub use self::count_::*;
 pub use self::counter::*;
 pub use self::here_::*;
 pub use self::introspector::*;
@@ -36,6 +39,7 @@ pub fn define(global: &mut Scope) {
     global.define_elem::<MetadataElem>();
     global.define_func::<here>();
     global.define_func::<query>();
+    global.define_func::<count>();
     global.define_func::<locate>();
     global.reset_category();
 }

crates/typst-library/src/visualize/color.rs

@@ -797,7 +797,9 @@ impl Color {
         components
     }
 
-    /// Returns the constructor function for this color's space:
+    /// Returns the constructor function for this color's space.
+    ///
+    /// Returns one of:
     /// - [`luma`]($color.luma)
     /// - [`oklab`]($color.oklab)
     /// - [`oklch`]($color.oklch)

docs/src/lib.rs

@@ -242,7 +242,7 @@ fn category_page(resolver: &dyn Resolver, category: Category) -> PageModel {
             items.push(CategoryItem {
                 name: group.name.clone(),
                 route: subpage.route.clone(),
-                oneliner: oneliner(docs).into(),
+                oneliner: oneliner(docs),
                 code: true,
             });
             children.push(subpage);
@@ -296,7 +296,7 @@ fn category_page(resolver: &dyn Resolver, category: Category) -> PageModel {
                 items.push(CategoryItem {
                     name: name.into(),
                     route: subpage.route.clone(),
-                    oneliner: oneliner(func.docs().unwrap_or_default()).into(),
+                    oneliner: oneliner(func.docs().unwrap_or_default()),
                     code: true,
                 });
                 children.push(subpage);
@@ -306,7 +306,7 @@ fn category_page(resolver: &dyn Resolver, category: Category) -> PageModel {
                 items.push(CategoryItem {
                     name: ty.short_name().into(),
                     route: subpage.route.clone(),
-                    oneliner: oneliner(ty.docs()).into(),
+                    oneliner: oneliner(ty.docs()),
                     code: true,
                 });
                 children.push(subpage);
@@ -637,7 +637,7 @@ fn group_page(
     let item = CategoryItem {
         name: group.name.clone(),
         route: model.route.clone(),
-        oneliner: oneliner(&group.details).into(),
+        oneliner: oneliner(&group.details),
         code: false,
     };
 
@@ -772,8 +772,24 @@ pub fn urlify(title: &str) -> EcoString {
 }
 
 /// Extract the first line of documentation.
-fn oneliner(docs: &str) -> &str {
+fn oneliner(docs: &str) -> EcoString {
-    docs.lines().next().unwrap_or_default()
+    let paragraph = docs.split("\n\n").next().unwrap_or_default();
+    let mut depth = 0;
+    let mut period = false;
+    let mut end = paragraph.len();
+    for (i, c) in paragraph.char_indices() {
+        match c {
+            '(' | '[' | '{' => depth += 1,
+            ')' | ']' | '}' => depth -= 1,
+            '.' if depth == 0 => period = true,
+            c if period && c.is_whitespace() && !docs[..i].ends_with("e.g.") => {
+                end = i;
+                break;
+            }
+            _ => period = false,
+        }
+    }
+    EcoString::from(&docs[..end]).replace("\r\n", " ").replace("\n", " ")
 }
 
 /// The order of types in the documentation.

docs/src/model.rs

@@ -86,7 +86,7 @@ pub struct FuncModel {
     pub name: EcoString,
     pub title: &'static str,
     pub keywords: &'static [&'static str],
-    pub oneliner: &'static str,
+    pub oneliner: EcoString,
     pub element: bool,
     pub contextual: bool,
     pub deprecation: Option<&'static str>,
@@ -139,7 +139,7 @@ pub struct TypeModel {
     pub name: &'static str,
     pub title: &'static str,
     pub keywords: &'static [&'static str],
-    pub oneliner: &'static str,
+    pub oneliner: EcoString,
     pub details: Html,
     pub constructor: Option<FuncModel>,
     pub scope: Vec<FuncModel>,

flake.nix

@@ -127,6 +127,10 @@
           checks = self'.checks;
           inputsFrom = [ typst ];
 
+          buildInputs = with pkgs; [
+            rust-analyzer
+          ];
+
           packages = [
             # A script for quickly running tests.
             # See https://github.com/typst/typst/blob/main/tests/README.md#making-an-alias