LibWeb: Implement Event.composedPath

I originally implemented this as something to use the new sequence
wrapper, however, after having a look at uses with grep.app, it's used
often, for example:
- Bootstrap 5 Dropdowns
- Polymer
- Angular
- Closure

Userland/Libraries/LibWeb/DOM/Event.cpp

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2020, the SerenityOS developers.
+ * Copyright (c) 2021, Luke Wilde <lukew@serenityos.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -64,4 +65,119 @@ double Event::time_stamp() const
     return m_time_stamp;
 }
 
+// https://dom.spec.whatwg.org/#dom-event-composedpath
+NonnullRefPtrVector<EventTarget> Event::composed_path() const
+{
+    // 1. Let composedPath be an empty list.
+    NonnullRefPtrVector<EventTarget> composed_path;
+
+    // 2. Let path be this’s path. (NOTE: Not necessary)
+
+    // 3. If path is empty, then return composedPath.
+    if (m_path.is_empty())
+        return composed_path;
+
+    // 4. Let currentTarget be this’s currentTarget attribute value. (NOTE: Not necessary)
+
+    // 5. Append currentTarget to composedPath.
+    // NOTE: If path is not empty, then the event is being dispatched and will have a currentTarget.
+    VERIFY(m_current_target);
+    composed_path.append(*m_current_target);
+
+    // 6. Let currentTargetIndex be 0.
+    size_t current_target_index = 0;
+
+    // 7. Let currentTargetHiddenSubtreeLevel be 0.
+    size_t current_target_hidden_subtree_level = 0;
+
+    // 8. Let index be path’s size − 1.
+    // 9. While index is greater than or equal to 0:
+    for (ssize_t index = m_path.size() - 1; index >= 0; --index) {
+        auto& path_entry = m_path.at(index);
+
+        // 1. If path[index]'s root-of-closed-tree is true, then increase currentTargetHiddenSubtreeLevel by 1.
+        if (path_entry.root_of_closed_tree)
+            ++current_target_hidden_subtree_level;
+
+        // 2. If path[index]'s invocation target is currentTarget, then set currentTargetIndex to index and break.
+        if (path_entry.invocation_target == m_current_target) {
+            current_target_index = index;
+            break;
+        }
+
+        // 3. If path[index]'s slot-in-closed-tree is true, then decrease currentTargetHiddenSubtreeLevel by 1.
+        if (path_entry.slot_in_closed_tree)
+            --current_target_hidden_subtree_level;
+
+        // 4. Decrease index by 1.
+    }
+
+    // 10. Let currentHiddenLevel and maxHiddenLevel be currentTargetHiddenSubtreeLevel.
+    size_t current_hidden_level = current_target_hidden_subtree_level;
+    size_t max_hidden_level = current_target_hidden_subtree_level;
+
+    // 11. Set index to currentTargetIndex − 1.
+    // 12. While index is greater than or equal to 0:
+    for (ssize_t index = current_target_index - 1; index >= 0; --index) {
+        auto& path_entry = m_path.at(index);
+
+        // 1. If path[index]'s root-of-closed-tree is true, then increase currentHiddenLevel by 1.
+        if (path_entry.root_of_closed_tree)
+            ++current_hidden_level;
+
+        // 2. If currentHiddenLevel is less than or equal to maxHiddenLevel, then prepend path[index]'s invocation target to composedPath.
+        if (current_hidden_level <= max_hidden_level) {
+            VERIFY(path_entry.invocation_target);
+            composed_path.prepend(*path_entry.invocation_target);
+        }
+
+        // 3. If path[index]'s slot-in-closed-tree is true, then:
+        if (path_entry.slot_in_closed_tree) {
+            // 1. Decrease currentHiddenLevel by 1.
+            --current_hidden_level;
+
+            // 2. If currentHiddenLevel is less than maxHiddenLevel, then set maxHiddenLevel to currentHiddenLevel.
+            if (current_hidden_level < max_hidden_level)
+                max_hidden_level = current_hidden_level;
+        }
+
+        // 4. Decrease index by 1.
+    }
+
+    // 13. Set currentHiddenLevel and maxHiddenLevel to currentTargetHiddenSubtreeLevel.
+    current_hidden_level = current_target_hidden_subtree_level;
+    max_hidden_level = current_target_hidden_subtree_level;
+
+    // 14. Set index to currentTargetIndex + 1.
+    // 15. While index is less than path’s size:
+    for (size_t index = current_target_index + 1; index < m_path.size(); ++index) {
+        auto& path_entry = m_path.at(index);
+
+        // 1. If path[index]'s slot-in-closed-tree is true, then increase currentHiddenLevel by 1.
+        if (path_entry.slot_in_closed_tree)
+            ++current_hidden_level;
+
+        // 2. If currentHiddenLevel is less than or equal to maxHiddenLevel, then append path[index]'s invocation target to composedPath.
+        if (current_hidden_level <= max_hidden_level) {
+            VERIFY(path_entry.invocation_target);
+            composed_path.append(*path_entry.invocation_target);
+        }
+
+        // 3. If path[index]'s root-of-closed-tree is true, then:
+        if (path_entry.root_of_closed_tree) {
+            // 1. Decrease currentHiddenLevel by 1.
+            --current_hidden_level;
+
+            // 2. If currentHiddenLevel is less than maxHiddenLevel, then set maxHiddenLevel to currentHiddenLevel.
+            if (current_hidden_level < max_hidden_level)
+                max_hidden_level = current_hidden_level;
+        }
+
+        // 4. Increase index by 1.
+    }
+
+    // 16. Return composedPath.
+    return composed_path;
+}
+
 }