Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / dom / tree_walker.lucb

#==============================================================================================
#
#   tree_walker - DOM::TreeWalker: a movable cursor over a root's subtree
#
#   DESCRIPTION:
#       Port of LibWeb/DOM/TreeWalker.cpp (lines 1-397) and the inline functions of
#       TreeWalker.h: parentNode, first/lastChild, previous/nextSibling, previous/nextNode,
#       "filter", and the traverse-children / traverse-siblings algorithms.
#
#==============================================================================================

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

## Ported from TreeWalker.cpp:20 Web::DOM::TreeWalker::TreeWalker.
pub func dom_tree_walker_construct(this: DomTreeWalker*, realm: Realm*, root: DomNode*):
    bind_platform_object_construct_realm(this.bind_platform_object(), realm)
    this.m_root = root
    this.m_current = root

## Ported from TreeWalker.cpp:29 Web::DOM::TreeWalker::initialize (override).
pub func dom_tree_walker_initialize_impl(base: JsCell*, realm: Realm*):
    web_set_prototype_for_interface(base, realm, BindInterfaceName.tree_walker)
    # Base::initialize(realm): PlatformObject inherits JS::Object's.
    js_cell_initialize_impl(base, realm)

## Ported from TreeWalker.cpp:35 Web::DOM::TreeWalker::visit_edges (override).
pub func dom_tree_walker_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (DomTreeWalker*)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_current)

## Ported from TreeWalker.cpp:44 Web::DOM::TreeWalker::create.
# https://dom.spec.whatwg.org/#dom-document-createtreewalker
pub func dom_tree_walker_create(realm: Realm*, root: DomNode*, what_to_show: u32, filter: DomNodeFilter*?) -> DomTreeWalker*:
    # 1. Let walker be a new TreeWalker object.
    # 2. Set walker’s root and walker’s current to root.
    let walker = realm_create_dom_tree_walker(realm, realm, root)

    # 3. Set walker’s whatToShow to whatToShow.
    walker.m_what_to_show = what_to_show

    # 4. Set walker’s filter to filter.
    walker.m_filter = filter

    # 5. Return walker.
    return walker

## Ported from TreeWalker.cpp:61 Web::DOM::TreeWalker::current_node.
# https://dom.spec.whatwg.org/#dom-treewalker-currentnode
pub func dom_tree_walker_current_node(this: DomTreeWalker*) -> DomNode*:
    return this.m_current

## Ported from TreeWalker.cpp:67 Web::DOM::TreeWalker::set_current_node.
# https://dom.spec.whatwg.org/#dom-treewalker-currentnode
pub func dom_tree_walker_set_current_node(this: DomTreeWalker*, node: DomNode*):
    this.m_current = node

# mark: Moving ==================================================================================

## Ported from TreeWalker.cpp:73 Web::DOM::TreeWalker::parent_node.
# https://dom.spec.whatwg.org/#dom-treewalker-parentnode
pub func dom_tree_walker_parent_node(this: DomTreeWalker*) -> DomNode*?!:
    # 1. Let node be this’s current.
    var node: DomNode*? = this.m_current

    # 2. While node is non-null and is not this’s root:
    while let current = node:
        if current == this.m_root:
            break

        # 1. Set node to node’s parent.
        node = tree_node_parent(current)

        # 2. If node is non-null and filtering node within this returns FILTER_ACCEPT,
        #    then set this’s current to node and return node.
        if let parent = node:
            let result = try dom_tree_walker_filter_dom_node(this, parent)
            if result == DomNodeFilterResult.filter_accept:
                this.m_current = parent
                return parent

    return none

## Ported from TreeWalker.cpp:98 Web::DOM::TreeWalker::first_child.
# https://dom.spec.whatwg.org/#dom-treewalker-firstchild
pub func dom_tree_walker_first_child(this: DomTreeWalker*) -> DomNode*?!:
    return try dom_tree_walker_traverse_children(this, DomTreeWalkerChildTraversalType.first)

## Ported from TreeWalker.cpp:104 Web::DOM::TreeWalker::last_child.
# https://dom.spec.whatwg.org/#dom-treewalker-lastchild
pub func dom_tree_walker_last_child(this: DomTreeWalker*) -> DomNode*?!:
    return try dom_tree_walker_traverse_children(this, DomTreeWalkerChildTraversalType.last)

## Ported from TreeWalker.cpp:110 Web::DOM::TreeWalker::previous_sibling.
# https://dom.spec.whatwg.org/#dom-treewalker-previoussibling
pub func dom_tree_walker_previous_sibling(this: DomTreeWalker*) -> DomNode*?!:
    return try dom_tree_walker_traverse_siblings(this, DomTreeWalkerSiblingTraversalType.previous)

## Ported from TreeWalker.cpp:116 Web::DOM::TreeWalker::next_sibling.
# https://dom.spec.whatwg.org/#dom-treewalker-nextsibling
pub func dom_tree_walker_next_sibling(this: DomTreeWalker*) -> DomNode*?!:
    return try dom_tree_walker_traverse_siblings(this, DomTreeWalkerSiblingTraversalType.next)

## Ported from TreeWalker.cpp:122 Web::DOM::TreeWalker::previous_node.
# https://dom.spec.whatwg.org/#dom-treewalker-previousnode
pub func dom_tree_walker_previous_node(this: DomTreeWalker*) -> DomNode*?!:
    # 1. Let node be this’s current.
    var node = this.m_current

    # 2. While node is not this’s root:
    while node != this.m_root:
        # 1. Let sibling be node’s previous sibling.
        var sibling = tree_node_previous_sibling(node)

        # 2. While sibling is non-null:
        while let sibling_node = sibling:
            # 1. Set node to sibling.
            node = sibling_node

            # 2. Let result be the result of filtering node within this.
            var result = try dom_tree_walker_filter_dom_node(this, node)

            # 3. While result is not FILTER_REJECT and node has a child:
            while result != DomNodeFilterResult.filter_reject and tree_node_has_children(node):
                # 1. Set node to node’s last child.
                node = tree_node_last_child(node) else trap("unreachable")

                # 2. Set result to the result of filtering node within this.
                result = try dom_tree_walker_filter_dom_node(this, node)

            # 4. If result is FILTER_ACCEPT, then set this’s current to node and return node.
            if result == DomNodeFilterResult.filter_accept:
                this.m_current = node
                return node

            # 5. Set sibling to node’s previous sibling.
            sibling = tree_node_previous_sibling(node)

        # 3. If node is this’s root or node’s parent is null, then return null.
        if node == this.m_root:
            return none
        let parent = tree_node_parent(node) else return none

        # 4. Set node to node’s parent.
        node = parent

        # 5. If the return value of filtering node within this is FILTER_ACCEPT, then set this’s current to node and return node.
        if (try dom_tree_walker_filter_dom_node(this, node)) == DomNodeFilterResult.filter_accept:
            this.m_current = node
            return node

    # 3. Return null.
    return none

## Ported from TreeWalker.cpp:177 Web::DOM::TreeWalker::next_node.
# https://dom.spec.whatwg.org/#dom-treewalker-nextnode
pub func dom_tree_walker_next_node(this: DomTreeWalker*) -> DomNode*?!:
    # 1. Let node be this’s current.
    var node = this.m_current

    # 2. Let result be FILTER_ACCEPT.
    var result = DomNodeFilterResult.filter_accept

    # 3. While true:
    while true:
        # 1. While result is not FILTER_REJECT and node has a child:
        while result != DomNodeFilterResult.filter_reject and tree_node_has_children(node):
            # 1. Set node to its first child.
            node = tree_node_first_child(node) else trap("unreachable")

            # 2. Set result to the result of filtering node within this.
            result = try dom_tree_walker_filter_dom_node(this, node)

            # 3. If result is FILTER_ACCEPT, then set this’s current to node and return node.
            if result == DomNodeFilterResult.filter_accept:
                this.m_current = node
                return node

        # 2. Let sibling be null.
        var sibling: DomNode*? = none

        # 3. Let temporary be node.
        var temporary: DomNode*? = node

        # 4. While temporary is non-null:
        while let temporary_node = temporary:
            # 1. If temporary is this’s root, then return null.
            if temporary_node == this.m_root:
                return none

            # 2. Set sibling to temporary’s next sibling.
            sibling = tree_node_next_sibling(temporary_node)

            # 3. If sibling is non-null, then set node to sibling and break.
            if let sibling_node = sibling:
                node = sibling_node
                break

            # 4. Set temporary to temporary’s parent.
            temporary = tree_node_parent(temporary_node)

            # NON-STANDARD: If temporary is null, then return null.
            #               This prevents us from infinite looping if the current node is not connected.
            #               Spec bug: https://github.com/whatwg/dom/issues/1102
            if temporary == none:
                return none

        # 5. Set result to the result of filtering node within this.
        result = try dom_tree_walker_filter_dom_node(this, node)

        # 6. If result is FILTER_ACCEPT, then set this’s current to node and return node.
        if result == DomNodeFilterResult.filter_accept:
            this.m_current = node
            return node

# mark: Filtering and traversal =================================================================

## Ported from TreeWalker.cpp:246 Web::DOM::TreeWalker::filter.
# https://dom.spec.whatwg.org/#concept-traversal-filter
pub func dom_tree_walker_filter(this: DomTreeWalker*) -> DomNodeFilter*?:
    return this.m_filter

## Ported from TreeWalker.cpp:252 Web::DOM::TreeWalker::filter.
# https://dom.spec.whatwg.org/#concept-node-filter
func dom_tree_walker_filter_dom_node(this: DomTreeWalker*, 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 TreeWalker.cpp:289 Web::DOM::TreeWalker::traverse_children.
# https://dom.spec.whatwg.org/#concept-traverse-children
func dom_tree_walker_traverse_children(this: DomTreeWalker*, type_: DomTreeWalkerChildTraversalType) -> DomNode*?!:
    # 1. Let node be walker’s current.
    let current = this.m_current

    # 2. Set node to node’s first child if type is first, and node’s last child if type is last.
    var node = tree_node_first_child(current) if type_ == DomTreeWalkerChildTraversalType.first else tree_node_last_child(current)

    # 3. While node is non-null:
    while let candidate = node:
        # 1. Let result be the result of filtering node within walker.
        let result = try dom_tree_walker_filter_dom_node(this, candidate)

        # 2. If result is FILTER_ACCEPT, then set walker’s current to node and return node.
        if result == DomNodeFilterResult.filter_accept:
            this.m_current = candidate
            return candidate

        # 3. If result is FILTER_SKIP, then:
        if result == DomNodeFilterResult.filter_skip:
            # 1. Let child be node’s first child if type is first, and node’s last child if type is last.
            let child = tree_node_first_child(candidate) if type_ == DomTreeWalkerChildTraversalType.first else tree_node_last_child(candidate)

            # 2. If child is non-null, then set node to child and continue.
            if child != none:
                node = child
                continue

        # 4. While node is non-null:
        while let sibling_candidate = node:
            # 1. Let sibling be node’s next sibling if type is first, and node’s previous sibling if type is last.
            let sibling = tree_node_next_sibling(sibling_candidate) if type_ == DomTreeWalkerChildTraversalType.first else tree_node_previous_sibling(sibling_candidate)

            # 2. If sibling is non-null, then set node to sibling and break.
            if sibling != none:
                node = sibling
                break

            # 3. Let parent be node’s parent.
            let parent = tree_node_parent(sibling_candidate)

            # 4. If parent is null, walker’s root, or walker’s current, then return null.
            if parent == none or parent == this.m_root or parent == this.m_current:
                return none

            # 5. Set node to parent.
            node = parent

    # 4. Return null.
    return none

## Ported from TreeWalker.cpp:348 Web::DOM::TreeWalker::traverse_siblings.
# https://dom.spec.whatwg.org/#concept-traverse-siblings
func dom_tree_walker_traverse_siblings(this: DomTreeWalker*, type_: DomTreeWalkerSiblingTraversalType) -> DomNode*?!:
    # 1. Let node be walker’s current.
    var node = this.m_current

    # 2. If node is root, then return null.
    if node == this.m_root:
        return none

    # 3. While true:
    while true:
        # 1. Let sibling be node’s next sibling if type is next, and node’s previous sibling if type is previous.
        var sibling = tree_node_next_sibling(node) if type_ == DomTreeWalkerSiblingTraversalType.next else tree_node_previous_sibling(node)

        # 2. While sibling is non-null:
        while let sibling_node = sibling:
            # 1. Set node to sibling.
            node = sibling_node

            # 2. Let result be the result of filtering node within walker.
            let result = try dom_tree_walker_filter_dom_node(this, node)

            # 3. If result is FILTER_ACCEPT, then set walker’s current to node and return node.
            if result == DomNodeFilterResult.filter_accept:
                this.m_current = node
                return node

            # 4. Set sibling to node’s first child if type is next, and node’s last child if type is previous.
            sibling = tree_node_first_child(node) if type_ == DomTreeWalkerSiblingTraversalType.next else tree_node_last_child(node)

            # 5. If result is FILTER_REJECT or sibling is null, then set sibling to node’s next sibling if type is next, and node’s previous sibling if type is previous.
            if result == DomNodeFilterResult.filter_reject or sibling == none:
                sibling = tree_node_next_sibling(node) if type_ == DomTreeWalkerSiblingTraversalType.next else tree_node_previous_sibling(node)

        # 3. Set node to node’s parent.
        # 4. If node is null or walker’s root, then return null.
        let parent = tree_node_parent(node) else return none
        node = parent
        if node == this.m_root:
            return none

        # 5. If the return value of filtering node within walker is FILTER_ACCEPT, then return null.
        if (try dom_tree_walker_filter_dom_node(this, node)) == DomNodeFilterResult.filter_accept:
            return none

# mark: TreeWalker.h ============================================================================

## Ported from TreeWalker.h:34 Web::DOM::TreeWalker::root.
pub func dom_tree_walker_root(this: DomTreeWalker*) -> DomNode*:
    return this.m_root

## Ported from TreeWalker.h:38 Web::DOM::TreeWalker::what_to_show.
pub func dom_tree_walker_what_to_show(this: DomTreeWalker*) -> u32:
    return this.m_what_to_show