Merge 06bc7bac6694d63459b39844782aca50ddee8d6e into 0264534928864c7aed0466d670824ac0ce5ca1a8

crates/typst-ide/src/analyze.rs

@@ -1,3 +1,5 @@
+use std::collections::HashSet;
+
 use comemo::Track;
 use ecow::{eco_vec, EcoString, EcoVec};
 use typst::foundations::{Label, Styles, Value};
@@ -66,14 +68,22 @@ pub fn analyze_import(world: &dyn IdeWorld, source: &LinkedNode) -> Option<Value
 /// - All labels and descriptions for them, if available
 /// - A split offset: All labels before this offset belong to nodes, all after
 ///   belong to a bibliography.
+///
+/// Note: When multiple labels in the document have the same identifier,
+/// this only returns the first one.
 pub fn analyze_labels(
     document: &PagedDocument,
 ) -> (Vec<(Label, Option<EcoString>)>, usize) {
     let mut output = vec![];
+    let mut seen_labels = HashSet::new();
 
     // Labels in the document.
     for elem in document.introspector.all() {
         let Some(label) = elem.label() else { continue };
+        if !seen_labels.insert(label) {
+            continue;
+        }
+
         let details = elem
             .to_packed::<FigureElem>()
             .and_then(|figure| match figure.caption.as_option() {

crates/typst-ide/src/complete.rs

@@ -76,7 +76,7 @@ pub struct Completion {
 }
 
 /// A kind of item that can be completed.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub enum CompletionKind {
     /// A syntactical structure.
@@ -130,7 +130,14 @@ fn complete_markup(ctx: &mut CompletionContext) -> bool {
         return true;
     }
 
-    // Start of a reference: "@|" or "@he|".
+    // Start of a reference: "@|".
+    if ctx.leaf.kind() == SyntaxKind::Text && ctx.before.ends_with("@") {
+        ctx.from = ctx.cursor;
+        ctx.label_completions();
+        return true;
+    }
+
+    // An existing reference: "@he|".
     if ctx.leaf.kind() == SyntaxKind::RefMarker {
         ctx.from = ctx.leaf.offset() + 1;
         ctx.label_completions();
@@ -1564,7 +1571,7 @@ mod tests {
 
     use typst::layout::PagedDocument;
 
-    use super::{autocomplete, Completion};
+    use super::{autocomplete, Completion, CompletionKind};
     use crate::tests::{FilePos, TestWorld, WorldLike};
 
     /// Quote a string.
@@ -1644,6 +1651,19 @@ mod tests {
         test_with_doc(world, pos, doc.as_ref())
     }
 
+    #[track_caller]
+    fn test_with_addition(
+        initial_text: &str,
+        addition: &str,
+        pos: impl FilePos,
+    ) -> Response {
+        let mut world = TestWorld::new(initial_text);
+        let doc = typst::compile(&world).output.ok();
+        let end = world.main.text().len();
+        world.main.edit(end..end, addition);
+        test_with_doc(&world, pos, doc.as_ref())
+    }
+
     #[track_caller]
     fn test_with_doc(
         world: impl WorldLike,
@@ -1709,6 +1729,30 @@ mod tests {
             .must_exclude(["bib"]);
     }
 
+    #[test]
+    fn test_autocomplete_ref_function() {
+        test_with_addition("x<test>", " #ref(<)", -2).must_include(["test"]);
+    }
+
+    #[test]
+    fn test_autocomplete_ref_shorthand() {
+        test_with_addition("x<test>", " @", -1).must_include(["test"]);
+    }
+
+    #[test]
+    fn test_autocomplete_ref_shorthand_with_partial_identifier() {
+        test_with_addition("x<test>", " @te", -1).must_include(["test"]);
+    }
+
+    #[test]
+    fn test_autocomplete_ref_identical_labels_returns_single_completion() {
+        let result = test_with_addition("x<test> y<test>", " @t", -1);
+        let completions = result.completions();
+        let label_count =
+            completions.iter().filter(|c| c.kind == CompletionKind::Label).count();
+        assert_eq!(label_count, 1);
+    }
+
     /// Test what kind of brackets we autocomplete for function calls depending
     /// on the function and existing parens.
     #[test]

crates/typst-library/src/foundations/dict.rs

@@ -3,15 +3,17 @@ use std::hash::{Hash, Hasher};
 use std::ops::{Add, AddAssign};
 use std::sync::Arc;
 
+use comemo::Tracked;
 use ecow::{eco_format, EcoString};
 use indexmap::IndexMap;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use typst_syntax::is_ident;
 use typst_utils::ArcExt;
 
-use crate::diag::{Hint, HintedStrResult, StrResult};
+use crate::diag::{Hint, HintedStrResult, SourceResult, StrResult};
+use crate::engine::Engine;
 use crate::foundations::{
-    array, cast, func, repr, scope, ty, Array, Module, Repr, Str, Value,
+    array, cast, func, repr, scope, ty, Array, Context, Func, Module, Repr, Str, Value,
 };
 
 /// Create a new [`Dict`] from key-value pairs.
@@ -254,6 +256,101 @@ impl Dict {
             .map(|(k, v)| Value::Array(array![k.clone(), v.clone()]))
             .collect()
     }
+
+    /// Produces a new dictionary or array by transforming each key-value pair with the given function.
+    ///
+    /// If the mapper function returns a pair (array of length 2), the result will be a new dictionary.
+    /// Otherwise, the result will be an array containing all mapped values.
+    ///
+    /// ```example
+    /// #let prices = (apples: 2, oranges: 3, bananas: 1.5)
+    /// #prices.map(pair => pair.at(0).len())
+    /// #prices.map((key, value) => (key, value * 1.1))
+    /// ```
+    #[func]
+    pub fn map(
+        self,
+        engine: &mut Engine,
+        context: Tracked<Context>,
+        /// The function to apply to each key-value pair.
+        /// The function can either take a single parameter (receiving a pair as array of length 2),
+        /// or two parameters (receiving key and value separately).
+        /// Parameters exceeding two will be ignored.
+        mapper: Func,
+    ) -> SourceResult<Value> {
+        let mut dict_result = IndexMap::new();
+        let mut array_result = Vec::new();
+        let mut is_dict = true;
+
+        // try to check the number of parameters, if not, use array form
+        let mut first_pair = true;
+        let mut use_single_arg = false;
+
+        for (key, value) in self {
+            let mapped = if first_pair {
+                // try two calling ways for the first pair
+                first_pair = false;
+
+                // try to call with two parameters
+                let result = mapper.call(
+                    engine,
+                    context,
+                    [Value::Str(key.clone()), value.clone()],
+                );
+
+                // if failed, try to call with one parameter
+                if result.is_err() {
+                    use_single_arg = true;
+                    mapper.call(
+                        engine,
+                        context,
+                        [Value::Array(array![Value::Str(key.clone()), value])],
+                    )?
+                } else {
+                    result?
+                }
+            } else if use_single_arg {
+                // try to call with one parameter
+                mapper.call(
+                    engine,
+                    context,
+                    [Value::Array(array![Value::Str(key.clone()), value])],
+                )?
+            } else {
+                // try to call with two parameters
+                mapper.call(engine, context, [Value::Str(key.clone()), value.clone()])?
+            };
+
+            // check if the result is a dictionary key-value pair
+            if let Value::Array(arr) = &mapped {
+                if arr.len() == 2 {
+                    if let Value::Str(k) = &arr.as_slice()[0] {
+                        if is_dict {
+                            dict_result.insert(k.clone(), arr.as_slice()[1].clone());
+                            continue;
+                        }
+                    }
+                }
+            }
+
+            // if the result is not a key-value pair, switch the result type to array
+            if is_dict {
+                is_dict = false;
+                // convert the collected dictionary result to array items
+                for (k, v) in dict_result.drain(..) {
+                    array_result.push(Value::Array(array![Value::Str(k), v]));
+                }
+            }
+
+            array_result.push(mapped);
+        }
+
+        if is_dict {
+            Ok(Value::Dict(Dict::from(dict_result)))
+        } else {
+            Ok(Value::Array(array_result.into_iter().collect()))
+        }
+    }
 }
 
 /// A value that can be cast to dictionary.

tests/suite/foundations/dict.typ

@@ -23,6 +23,34 @@
   test(world, "world")
 }
 
+--- dict-map ---
+// Test the map function
+#let dict = (a: 1, b: 2, c: 3)
+
+// test map return new dict
+#test(
+  dict.map((key, value) => (key, value * 2)),
+  (a: 2, b: 4, c: 6)
+)
+
+// test map empty dict
+#test(
+  (:).map((key, value) => (key, value * 2)),
+  (:)
+)
+
+// test map return array
+#test(
+  dict.map(pair => pair.at(0) + ": " + str(pair.at(1))),
+  ("a: 1", "b: 2", "c: 3")
+)
+
+// test map return array(different return type)
+#test(
+  dict.map((key, value) => if value > 1 { (key, value * 2) } else { "key smaller than 1: " + key }),
+  ("key smaller than 1: a", ("b", 4), ("c", 6))
+)
+
 --- dict-missing-field ---
 // Error: 6-13 dictionary does not contain key "invalid"
 #(:).invalid