Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / dom / node_iterator.lucb

#==============================================================================================
#
#   node_iterator - DOM::NodeIterator: a traversal over a root's subtree in tree order
#
#   DESCRIPTION:
#       Port of LibWeb/DOM/NodeIterator.cpp (lines 1-258) and the inline functions of
#       NodeIterator.h: creation (registered with the document so node removal can adjust its
#       pointers), traverse, "filter" (which calls the NodeFilter's acceptNode) and the
#       pre-removing steps.
#
#==============================================================================================

# mark: Construction ============================================================================

## Ported from NodeIterator.cpp:18 Web::DOM::NodeIterator::NodeIterator.
pub func dom_node_iterator_construct(this: DomNodeIterator*, realm: Realm*, root: DomNode*):
    bind_platform_object_construct_realm(this.bind_platform_object(), realm)
    this.m_root = root
    this.m_reference = DomNodeIteratorNodePointer(node = root, is_before_node = true)
    dom_document_register_node_iterator(dom_node_document(root), this)

## Ported from NodeIterator.cpp:28 Web::DOM::NodeIterator::initialize (override).
pub func dom_node_iterator_initialize_impl(base: JsCell*, realm: Realm*):
    web_set_prototype_for_interface(base, realm, BindInterfaceName.node_iterator)
    # Base::initialize(realm): PlatformObject inherits JS::Object's.
    js_cell_initialize_impl(base, realm)

## Ported from NodeIterator.cpp:34 Web::DOM::NodeIterator::finalize (override).
pub func dom_node_iterator_finalize_impl(base: gc.Cell*):
    let this = (DomNodeIterator*)base
    # Base::finalize(): PlatformObject inherits GC::Cell's, which does nothing.
    dom_document_unregister_node_iterator(dom_node_document(this.m_root), this)

## Ported from NodeIterator.cpp:40 Web::DOM::NodeIterator::visit_edges (override).
pub func dom_node_iterator_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (DomNodeIterator*)base
    bind_platform_object_visit_edges_impl(base, visitor)
    gc.cell_visitor_visit_t(visitor, this.m_filter)
    gc.cell_visitor_visit_t_2(visitor, this.m_root)
    gc.cell_visitor_visit_t_2(visitor, this.m_reference.node)
    if let traversal_pointer = this.m_traversal_pointer:
        gc.cell_visitor_visit_t_2(visitor, traversal_pointer.node)

## Ported from NodeIterator.cpp:52 Web::DOM::NodeIterator::create.
# https://dom.spec.whatwg.org/#dom-document-createnodeiterator
pub func dom_node_iterator_create(realm: Realm*, root: DomNode*, what_to_show: u32, filter: DomNodeFilter*?) -> DomNodeIterator*:
    # 1. Let iterator be a new NodeIterator object.
    # 2. Set iterator’s root and iterator’s reference to root.
    # 3. Set iterator’s pointer before reference to true.
    let iterator = realm_create_dom_node_iterator(realm, realm, root)

    # 4. Set iterator’s whatToShow to whatToShow.
    iterator.m_what_to_show = what_to_show

    # 5. Set iterator’s filter to filter.
    iterator.m_filter = filter

    # 6. Return iterator.
    return iterator

## Ported from NodeIterator.cpp:70 Web::DOM::NodeIterator::detach.
# https://dom.spec.whatwg.org/#dom-nodeiterator-detach
pub func dom_node_iterator_detach(this: DomNodeIterator*):
    # The detach() method steps are to do nothing.
    # Its functionality (disabling a NodeIterator object) was removed, but the method itself is preserved for compatibility.
    return

# mark: Traversal ===============================================================================

## The traversal pointer during a traversal (C++'s `m_traversal_pointer->`).
func dom_node_iterator_traversal_pointer(this: DomNodeIterator*) -> DomNodeIteratorNodePointer*:
    let pointer = ak.optional_base_ptr(&this.m_traversal_pointer)
    return pointer else trap("VERIFY: traversal pointer")

## Ported from NodeIterator.cpp:77 Web::DOM::NodeIterator::traverse.
# https://dom.spec.whatwg.org/#concept-nodeiterator-traverse
func dom_node_iterator_traverse(this: DomNodeIterator*, direction: DomNodeIteratorDirection) -> DomNode*?!:
    # 1. Let node be iterator’s reference.
    # 2. Let beforeNode be iterator’s pointer before reference.
    this.m_traversal_pointer = this.m_reference

    var candidate: DomNode*? = none

    # 3. While true:
    while true:
        # 4. Branch on direction:
        if direction == DomNodeIteratorDirection.next:
            # next
            # If beforeNode is false, then set node to the first node following node in iterator’s iterator collection.
            # If there is no such node, then return null.
            let pointer = dom_node_iterator_traversal_pointer(this)
            if not pointer.is_before_node:
                let next_node = tree_node_next_in_pre_order_t(pointer.node, this.m_root) else return none
                pointer.node = next_node
            else:
                # If beforeNode is true, then set it to false.
                pointer.is_before_node = false
        else:
            # previous
            # If beforeNode is true, then set node to the first node preceding node in iterator’s iterator collection.
            # If there is no such node, then return null.
            let pointer = dom_node_iterator_traversal_pointer(this)
            if pointer.is_before_node:
                if pointer.node == this.m_root:
                    return none
                let previous_node = tree_node_previous_in_pre_order(pointer.node) else return none
                pointer.node = previous_node
            else:
                # If beforeNode is false, then set it to true.
                pointer.is_before_node = true

        # NOTE: If the NodeFilter deletes the iterator's current traversal pointer,
        #       we will automatically retarget it. However, in that case, we're expected
        #       to return the node passed to the filter, not the adjusted traversal pointer's
        #       node after the filter returns!
        candidate = dom_node_iterator_traversal_pointer(this).node

        # 2. Let result be the result of filtering node within iterator.
        let result = try dom_node_iterator_filter_dom_node(this, dom_node_iterator_traversal_pointer(this).node)

        # 3. If result is FILTER_ACCEPT, then break.
        if result == DomNodeFilterResult.filter_accept:
            break

    # 4. Set iterator’s reference to node.
    # 5. Set iterator’s pointer before reference to beforeNode.
    this.m_reference = this.m_traversal_pointer else trap("VERIFY: traversal pointer")
    this.m_traversal_pointer = none

    # 6. Return node.
    return candidate

## Ported from NodeIterator.cpp:141 Web::DOM::NodeIterator::filter.
# https://dom.spec.whatwg.org/#concept-traversal-filter
pub func dom_node_iterator_filter(this: DomNodeIterator*) -> DomNodeFilter*?:
    return this.m_filter

## Ported from NodeIterator.cpp:147 Web::DOM::NodeIterator::filter.
# https://dom.spec.whatwg.org/#concept-node-filter
func dom_node_iterator_filter_dom_node(this: DomNodeIterator*, node: DomNode*) -> DomNodeFilterResult!:
    # 1. If traverser’s active flag is set, then throw an "InvalidStateError" DOMException.
    if this.m_active:
        try idl_throw(.idl_dom_exception(idl_invalid_state_error_create(bind_platform_object_realm(this.bind_platform_object()), ak.utf16_string_from_str("NodeIterator is already active"))))

    # 2. Let n be node’s nodeType attribute value − 1.
    let n = (u32)dom_node_node_type(node) - 1

    # 3. If the nth bit (where 0 is the least significant bit) of traverser’s whatToShow is not set, then return FILTER_SKIP.
    if (this.m_what_to_show & ((u32)1 << n)) == 0:
        return DomNodeFilterResult.filter_skip

    # 4. If traverser’s filter is null, then return FILTER_ACCEPT.
    let filter = this.m_filter else return DomNodeFilterResult.filter_accept

    # 5. Set traverser’s active flag.
    this.m_active = true

    # 6. Let result be the return value of call a user object’s operation with traverser’s filter, "acceptNode", and « node ».
    #    If this throws an exception, then unset traverser’s active flag and rethrow the exception.
    let arguments: JsValue[1] = [js_value_from_object((JsObject*)node)]
    let result = idl_call_user_object_operation(dom_node_filter_callback(filter), ak.utf16_fly_string_from_utf8_string_view(ak.sv("acceptNode")), none, arguments)
    if js_completion_is_abrupt(&result):
        this.m_active = false
        try idl_throw(.js_completion(result))

    # 7. Unset traverser’s active flag.
    this.m_active = false

    # 8. Return result.
    let result_value = try dom_js_value_to_i32(js_cell_vm(this.js_cell()), js_completion_value(&result))
    return (DomNodeFilterResult)(u8)result_value

## Ported from NodeIterator.cpp:184 Web::DOM::NodeIterator::next_node.
# https://dom.spec.whatwg.org/#dom-nodeiterator-nextnode
pub func dom_node_iterator_next_node(this: DomNodeIterator*) -> DomNode*?!:
    return try dom_node_iterator_traverse(this, DomNodeIteratorDirection.next)

## Ported from NodeIterator.cpp:190 Web::DOM::NodeIterator::previous_node.
# https://dom.spec.whatwg.org/#dom-nodeiterator-previousnode
pub func dom_node_iterator_previous_node(this: DomNodeIterator*) -> DomNode*?!:
    return try dom_node_iterator_traverse(this, DomNodeIteratorDirection.previous)

# mark: Node removal ============================================================================

## Ported from NodeIterator.cpp:195 Web::DOM::NodeIterator::run_pre_removing_steps_with_node_pointer.
func dom_node_iterator_run_pre_removing_steps_with_node_pointer(this: DomNodeIterator*, to_be_removed_node: DomNode*, pointer: DomNodeIteratorNodePointer*):
    # NOTE: This function tries to match the behavior of other engines, but not the DOM specification
    #       as it's a known issue that the spec doesn't match how major browsers behave.
    #       Spec bug: https://github.com/whatwg/dom/issues/907

    let root = this.m_root
    if not tree_node_is_descendant_of(to_be_removed_node, root):
        return

    if not tree_node_is_inclusive_ancestor_of(to_be_removed_node, pointer.node):
        return

    if pointer.is_before_node:
        if let first_following = tree_node_next_in_pre_order_t(to_be_removed_node, root):
            var node: DomNode*? = first_following
            while let current = node:
                if not tree_node_is_descendant_of(current, to_be_removed_node):
                    break
                node = tree_node_next_in_pre_order_t(current, root)
            if let found = node:
                pointer.node = found
            return

        if let first_preceding = tree_node_previous_in_pre_order(to_be_removed_node):
            var node: DomNode*? = first_preceding
            if tree_node_is_ancestor_of(to_be_removed_node, pointer.node):
                while let current = node:
                    if not tree_node_is_descendant_of(current, to_be_removed_node):
                        break
                    node = tree_node_previous_in_pre_order(current)
            if let found = node:
                *pointer = DomNodeIteratorNodePointer(node = found, is_before_node = false)
        return

    if let first_preceding = tree_node_previous_in_pre_order(to_be_removed_node):
        var node: DomNode*? = first_preceding
        if tree_node_is_ancestor_of(to_be_removed_node, pointer.node):
            while let current = node:
                if not tree_node_is_descendant_of(current, to_be_removed_node):
                    break
                node = tree_node_previous_in_pre_order(current)
        if let found = node:
            pointer.node = found
        return

    var node = tree_node_next_in_pre_order_t(to_be_removed_node, root)
    if tree_node_is_ancestor_of(to_be_removed_node, pointer.node):
        while let current = node:
            if not tree_node_is_descendant_of(current, to_be_removed_node):
                break
            node = tree_node_previous_in_pre_order(current)
    if let found = node:
        pointer.node = found

## Ported from NodeIterator.cpp:249 Web::DOM::NodeIterator::run_pre_removing_steps.
# https://dom.spec.whatwg.org/#nodeiterator-pre-removing-steps
pub func dom_node_iterator_run_pre_removing_steps(this: DomNodeIterator*, to_be_removed_node: DomNode*):
    # NOTE: If we're in the middle of traversal, we have to adjust the traversal pointer in response to node removal.
    if this.m_traversal_pointer != none:
        dom_node_iterator_run_pre_removing_steps_with_node_pointer(this, to_be_removed_node, dom_node_iterator_traversal_pointer(this))
    dom_node_iterator_run_pre_removing_steps_with_node_pointer(this, to_be_removed_node, &this.m_reference)

# mark: NodeIterator.h ==========================================================================

## Ported from NodeIterator.h:26 Web::DOM::NodeIterator::root.
pub func dom_node_iterator_root(this: DomNodeIterator*) -> DomNode*:
    return this.m_root

## Ported from NodeIterator.h:27 Web::DOM::NodeIterator::reference_node.
pub func dom_node_iterator_reference_node(this: DomNodeIterator*) -> DomNode*:
    return this.m_reference.node

## Ported from NodeIterator.h:28 Web::DOM::NodeIterator::pointer_before_reference_node.
pub func dom_node_iterator_pointer_before_reference_node(this: DomNodeIterator*) -> bool:
    return this.m_reference.is_before_node

## Ported from NodeIterator.h:29 Web::DOM::NodeIterator::what_to_show.
pub func dom_node_iterator_what_to_show(this: DomNodeIterator*) -> u32:
    return this.m_what_to_show