fix(deps): update rust crate tokio to v1.45.1 (#146)

* fix(deps): update rust crate tokio to v1.45.1

* fix: resolve Clippy issues

---------

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: Daniëlle Huisman <danielle@huisman.me>

Author: renovate[bot]

Cargo.lock

@@ -86,42 +86,40 @@ pub fn compute_position<Element: Clone, Window: Clone>(
             middleware_data.set(middleware.name(), new_data);
         }
 
-        if let Some(reset) = reset {
-            if reset_count <= 50 {
-                reset_count += 1;
-
-                match reset {
-                    Reset::True => {}
-                    Reset::Value(value) => {
-                        if let Some(reset_placement) = value.placement {
-                            stateful_placement = reset_placement;
-                        }
+        if let Some(reset) = reset
+            && reset_count <= 50
+        {
+            reset_count += 1;
 
-                        if let Some(reset_rects) = value.rects {
-                            rects = match reset_rects {
-                                ResetRects::True => {
-                                    platform.get_element_rects(GetElementRectsArgs {
-                                        reference: reference.clone(),
-                                        floating,
-                                        strategy,
-                                    })
-                                }
-                                ResetRects::Value(element_rects) => element_rects,
-                            }
-                        }
+            match reset {
+                Reset::True => {}
+                Reset::Value(value) => {
+                    if let Some(reset_placement) = value.placement {
+                        stateful_placement = reset_placement;
+                    }
 
-                        let Coords {
-                            x: next_x,
-                            y: next_y,
-                        } = compute_coords_from_placement(&rects, stateful_placement, rtl);
-                        x = next_x;
-                        y = next_y;
+                    if let Some(reset_rects) = value.rects {
+                        rects = match reset_rects {
+                            ResetRects::True => platform.get_element_rects(GetElementRectsArgs {
+                                reference: reference.clone(),
+                                floating,
+                                strategy,
+                            }),
+                            ResetRects::Value(element_rects) => element_rects,
+                        }
                     }
-                }
 
-                i = 0;
-                continue;
+                    let Coords {
+                        x: next_x,
+                        y: next_y,
+                    } = compute_coords_from_placement(&rects, stateful_placement, rtl);
+                    x = next_x;
+                    y = next_y;
+                }
             }
+
+            i = 0;
+            continue;
         }
 
         i += 1;

packages/core/src/compute_position.rs

@@ -186,21 +186,21 @@ impl<Element: Clone + PartialEq + 'static, Window: Clone + PartialEq + 'static>
 
         let get_bounding_client_rect = move || {
             // There are two rects and they are disjoined.
-            if client_rects.len() == 2 && client_rects[0].left > client_rects[1].right {
-                if let Some(x) = options.x {
-                    if let Some(y) = options.y {
-                        return client_rects
-                            .clone()
-                            .into_iter()
-                            .find(|rect| {
-                                x > rect.left - padding_object.left
-                                    && x < rect.right + padding_object.right
-                                    && y > rect.top - padding_object.top
-                                    && rect.y < rect.bottom + padding_object.bottom
-                            })
-                            .unwrap_or(fallback.clone());
-                    }
-                }
+            if client_rects.len() == 2
+                && client_rects[0].left > client_rects[1].right
+                && let Some(x) = options.x
+                && let Some(y) = options.y
+            {
+                return client_rects
+                    .clone()
+                    .into_iter()
+                    .find(|rect| {
+                        x > rect.left - padding_object.left
+                            && x < rect.right + padding_object.right
+                            && y > rect.top - padding_object.top
+                            && rect.y < rect.bottom + padding_object.bottom
+                    })
+                    .unwrap_or(fallback.clone());
             }
 
             // There are 2 or more connected rects.

packages/core/src/middleware/inline.rs

@@ -41,13 +41,13 @@ fn convert_value_to_coords<Element: Clone, Window: Clone>(
         ),
     };
 
-    if let Some(alignment) = alignment {
-        if let Some(alignment_axis) = alignment_axis {
-            cross_axis = match alignment {
-                Alignment::Start => alignment_axis,
-                Alignment::End => -alignment_axis,
-            };
-        }
+    if let Some(alignment) = alignment
+        && let Some(alignment_axis) = alignment_axis
+    {
+        cross_axis = match alignment {
+            Alignment::Start => alignment_axis,
+            Alignment::End => -alignment_axis,
+        };
     }
 
     if is_vertical {
@@ -192,20 +192,20 @@ impl<Element: Clone + PartialEq, Window: Clone + PartialEq> Middleware<Element,
         let diff_coords = convert_value_to_coords(state, &options);
 
         // If the placement is the same and the arrow caused an alignment offset then we don't need to change the positioning coordinates.
-        if let Some(data_placement) = data.map(|data| data.placement) {
-            if placement == data_placement {
-                let arrow_data: Option<ArrowData> = middleware_data.get_as(ARROW_NAME);
-                if arrow_data
-                    .and_then(|arrow_data| arrow_data.alignment_offset)
-                    .is_some()
-                {
-                    return MiddlewareReturn {
-                        x: None,
-                        y: None,
-                        data: None,
-                        reset: None,
-                    };
-                }
+        if let Some(data_placement) = data.map(|data| data.placement)
+            && placement == data_placement
+        {
+            let arrow_data: Option<ArrowData> = middleware_data.get_as(ARROW_NAME);
+            if arrow_data
+                .and_then(|arrow_data| arrow_data.alignment_offset)
+                .is_some()
+            {
+                return MiddlewareReturn {
+                    x: None,
+                    y: None,
+                    data: None,
+                    reset: None,
+                };
             }
         }
 

packages/core/src/middleware/offset.rs

@@ -346,18 +346,17 @@ pub fn auto_update(
             let update = update.clone();
 
             move |entries: Vec<ResizeObserverEntry>| {
-                if let Some(first_entry) = entries.first() {
-                    if resize_reference_element
+                if let Some(first_entry) = entries.first()
+                    && resize_reference_element
                         .as_ref()
                         .is_some_and(|reference_element| first_entry.target() == *reference_element)
-                    {
-                        if let Some(reobserve_frame) = reobserve_frame.take() {
-                            cancel_animation_frame(reobserve_frame);
-                        }
-
-                        reobserve_frame
-                            .replace(Some(request_animation_frame(reobserve_closure.as_ref())));
+                {
+                    if let Some(reobserve_frame) = reobserve_frame.take() {
+                        cancel_animation_frame(reobserve_frame);
                     }
+
+                    reobserve_frame
+                        .replace(Some(request_animation_frame(reobserve_closure.as_ref())));
                 }
 
                 update();
@@ -369,14 +368,14 @@ pub fn auto_update(
                 .expect("Resize observer should be created."),
         ));
 
-        if let Some(reference) = reference_element.as_ref() {
-            if !animation_frame {
-                resize_observer
-                    .borrow()
-                    .as_ref()
-                    .expect("Resize observer should exist.")
-                    .observe(reference);
-            }
+        if let Some(reference) = reference_element.as_ref()
+            && !animation_frame
+        {
+            resize_observer
+                .borrow()
+                .as_ref()
+                .expect("Resize observer should exist.")
+                .observe(reference);
         }
 
         resize_observer
@@ -406,10 +405,10 @@ pub fn auto_update(
             let next_ref_rect =
                 get_bounding_client_rect((&owned_reference).into(), false, false, None);
 
-            if let Some(prev_ref_rect) = prev_ref_rect.borrow().as_ref() {
-                if !rects_are_equal(prev_ref_rect, &next_ref_rect) {
-                    update();
-                }
+            if let Some(prev_ref_rect) = prev_ref_rect.borrow().as_ref()
+                && !rects_are_equal(prev_ref_rect, &next_ref_rect)
+            {
+                update();
             }
 
             prev_ref_rect.replace(Some(next_ref_rect));
@@ -427,14 +426,13 @@ pub fn auto_update(
 
         let next_ref_rect = get_bounding_client_rect((&owned_reference).into(), false, false, None);
 
-        if let Some(prev_ref_rect) = prev_ref_rect.borrow().as_ref() {
-            if next_ref_rect.x != prev_ref_rect.x
+        if let Some(prev_ref_rect) = prev_ref_rect.borrow().as_ref()
+            && (next_ref_rect.x != prev_ref_rect.x
                 || next_ref_rect.y != prev_ref_rect.y
                 || next_ref_rect.width != prev_ref_rect.width
-                || next_ref_rect.height != prev_ref_rect.height
-            {
-                update();
-            }
+                || next_ref_rect.height != prev_ref_rect.height)
+        {
+            update();
         }
 
         prev_ref_rect.replace(Some(next_ref_rect));

packages/dom/src/auto_update.rs

@@ -53,12 +53,11 @@ pub fn convert_offset_parent_relative_rect_to_viewport_relative_rect(
 
     #[allow(clippy::nonminimal_bool)]
     if is_offset_parent_an_element || (!is_offset_parent_an_element && !is_fixed) {
-        if let Some(offset_parent) = offset_parent.as_ref() {
-            if get_node_name(offset_parent.into()) != "body"
-                || is_overflow_element(&document_element)
-            {
-                scroll = get_node_scroll(offset_parent.into());
-            }
+        if let Some(offset_parent) = offset_parent.as_ref()
+            && (get_node_name(offset_parent.into()) != "body"
+                || is_overflow_element(&document_element))
+        {
+            scroll = get_node_scroll(offset_parent.into());
         }
 
         if let Some(ElementOrWindow::Element(offset_parent)) = offset_parent {

packages/dom/src/platform/convert_offset_parent_relative_rect_to_viewport_relative_rect.rs

@@ -29,19 +29,18 @@ pub fn get_true_offset_parent(element: &Element, polyfill: &Option<Polyfill>) ->
 
             // Firefox returns the <html> element as the offsetParent if it's non-static, while Chrome and Safari return the <body> element.
             // The <body> element must be used to perform the correct calculations even if the <html> element is non-static.
-            if let Some(raw_offset_parent) = raw_offset_parent.as_ref() {
-                if get_document_element(Some(DomNodeOrWindow::Node(raw_offset_parent)))
+            if let Some(raw_offset_parent) = raw_offset_parent.as_ref()
+                && get_document_element(Some(DomNodeOrWindow::Node(raw_offset_parent)))
                     == *raw_offset_parent
-                {
-                    return Some(
-                        raw_offset_parent
-                            .owner_document()
-                            .expect("Element should have owner document.")
-                            .body()
-                            .expect("Document should have body.")
-                            .unchecked_into::<Element>(),
-                    );
-                }
+            {
+                return Some(
+                    raw_offset_parent
+                        .owner_document()
+                        .expect("Element should have owner document.")
+                        .body()
+                        .expect("Document should have body.")
+                        .unchecked_into::<Element>(),
+                );
             }
 
             raw_offset_parent
@@ -88,13 +87,12 @@ pub fn get_offset_parent(
         }
     }
 
-    if let Some(parent) = offset_parent.as_ref() {
-        if is_last_traversable_node(parent)
-            && is_static_positioned(parent)
-            && !is_containing_block(parent.into())
-        {
-            return OwnedElementOrWindow::Window(window);
-        }
+    if let Some(parent) = offset_parent.as_ref()
+        && is_last_traversable_node(parent)
+        && is_static_positioned(parent)
+        && !is_containing_block(parent.into())
+    {
+        return OwnedElementOrWindow::Window(window);
     }
 
     offset_parent