ladybird/Libraries/LibWeb/DOM/NodeList.cpp

/*
 * Copyright (c) 2022, Andreas Kling <andreas@ladybird.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <LibWeb/Bindings/Intrinsics.h>
#include <LibWeb/Bindings/NodeListPrototype.h>
#include <LibWeb/DOM/Node.h>
#include <LibWeb/DOM/NodeList.h>

namespace Web::DOM {

NodeList::NodeList(JS::Realm& realm)
    : PlatformObject(realm)
{
    m_legacy_platform_object_flags = LegacyPlatformObjectFlags { .supports_indexed_properties = true };
}

NodeList::~NodeList() = default;

void NodeList::initialize(JS::Realm& realm)
{
    Base::initialize(realm);
    WEB_SET_PROTOTYPE_FOR_INTERFACE(NodeList);
}

Optional<JS::Value> NodeList::item_value(size_t index) const
{
    auto* node = item(index);
    if (!node)
        return {};
    return const_cast<Node*>(node);
}

}
LibWeb: Make NodeList GC-allocated 2022-09-01 16:30:26 +02:00			`/*`
Meta: Update my e-mail address everywhere 2024-10-04 13:19:50 +02:00			`* Copyright (c) 2022, Andreas Kling <andreas@ladybird.org>`
LibWeb: Make NodeList GC-allocated 2022-09-01 16:30:26 +02:00			`*`
			`* SPDX-License-Identifier: BSD-2-Clause`
			`*/`

LibWeb: Remove unecessary dependence on Window from DOM and WebIDL These classes only needed Window to get at its realm. Pass a realm directly to construct DOM and WebIDL classes. This change importantly removes the guarantee that a Document will always have a non-null Window object. Only Documents created by a BrowsingContext will have a non-null Window object. Documents created by for example, DocumentFragment, will not have a Window (soon). This incremental commit leaves some workarounds in place to keep other parts of the code building. 2022-09-25 16:15:49 -06:00			`#include <LibWeb/Bindings/Intrinsics.h>`
LibWeb: Remove Bindings/Forward.h from LibWeb/Forward.h This was resulting in a whole lot of rebuilding whenever a new IDL interface was added. Instead, just directly include the prototype in every C++ file which needs it. While we only really need a forward declaration in each cpp file; including the full prototype header (which itself only includes LibJS/Object.h, which is already transitively brought in by PlatformObject) - it seems like a small price to pay compared to what feels like a full rebuild of LibWeb whenever a new IDL file is added. Given all of these includes are only needed for the ::initialize method, there is probably a smart way of avoiding this problem altogether. I've considered both using some macro trickery or generating these functions somehow instead. 2024-04-27 12:09:58 +12:00			`#include <LibWeb/Bindings/NodeListPrototype.h>`
LibWeb: Make NodeList GC-allocated 2022-09-01 16:30:26 +02:00			`#include <LibWeb/DOM/Node.h>`
			`#include <LibWeb/DOM/NodeList.h>`

			`namespace Web::DOM {`

LibWeb: Remove unecessary dependence on Window from DOM and WebIDL These classes only needed Window to get at its realm. Pass a realm directly to construct DOM and WebIDL classes. This change importantly removes the guarantee that a Document will always have a non-null Window object. Only Documents created by a BrowsingContext will have a non-null Window object. Documents created by for example, DocumentFragment, will not have a Window (soon). This incremental commit leaves some workarounds in place to keep other parts of the code building. 2022-09-25 16:15:49 -06:00			`NodeList::NodeList(JS::Realm& realm)`
LibWeb: Delete LegacyPlatformObject and move behavior to PlatformObject We have two known PlatformObjects that need to implement some of the behavior of LegacyPlatformObjects to date: Window, and HTMLFormElement. To make this not require double (or virtual) inheritance of PlatformObject, move the behavior of LegacyPlatformObject into PlatformObject. The selection of LegacyPlatformObject behavior is done with a new bitfield of feature flags instead of a dozen virtual functions that return bool. This change simplifies every class involved in the diff with the notable exception of Window, which now needs some ugly const casts to implement named property access. 2024-01-09 16:05:03 -07:00			`: PlatformObject(realm)`
LibWeb: Make NodeList GC-allocated 2022-09-01 16:30:26 +02:00			`{`
LibWeb: Delete LegacyPlatformObject and move behavior to PlatformObject We have two known PlatformObjects that need to implement some of the behavior of LegacyPlatformObjects to date: Window, and HTMLFormElement. To make this not require double (or virtual) inheritance of PlatformObject, move the behavior of LegacyPlatformObject into PlatformObject. The selection of LegacyPlatformObject behavior is done with a new bitfield of feature flags instead of a dozen virtual functions that return bool. This change simplifies every class involved in the diff with the notable exception of Window, which now needs some ugly const casts to implement named property access. 2024-01-09 16:05:03 -07:00			`m_legacy_platform_object_flags = LegacyPlatformObjectFlags { .supports_indexed_properties = true };`
LibWeb: Make NodeList GC-allocated 2022-09-01 16:30:26 +02:00			`}`

			`NodeList::~NodeList() = default;`

LibJS: Make Cell::initialize() return void Stop worrying about tiny OOMs. Work towards #20405 2023-08-07 08:41:28 +02:00			`void NodeList::initialize(JS::Realm& realm)`
LibWeb: Move passing of Web object prototypes out of constructors 2023-01-10 06:56:59 -05:00			`{`
LibJS: Make Cell::initialize() return void Stop worrying about tiny OOMs. Work towards #20405 2023-08-07 08:41:28 +02:00			`Base::initialize(realm);`
LibWeb: Avoid FlyString lookups when setting IDL interface prototypes This commit introduces a WEB_SET_PROTOTYPE_FOR_INTERFACE macro that caches the interface name in a local static FlyString. This means that we only pay for FlyString-from-literal lookup once per browser lifetime instead of every time the interface is instantiated. 2024-03-16 13:13:08 +01:00			`WEB_SET_PROTOTYPE_FOR_INTERFACE(NodeList);`
LibWeb: Move passing of Web object prototypes out of constructors 2023-01-10 06:56:59 -05:00			`}`

Bindings: Make item_value return an Optional<JS::Value> This removes some ambiguity about what the return value should be if the index is out of range. Previously, we would sometimes return a JS null, and other times a JS undefined. It will also let us fold together the checks for whether an index is a supported property index, followed by getting the value just afterwards. 2024-07-25 18:15:51 +12:00			`Optional<JS::Value> NodeList::item_value(size_t index) const`
LibWeb: Make NodeList GC-allocated 2022-09-01 16:30:26 +02:00			`{`
			`auto* node = item(index);`
			`if (!node)`
Bindings: Make item_value return an Optional<JS::Value> This removes some ambiguity about what the return value should be if the index is out of range. Previously, we would sometimes return a JS null, and other times a JS undefined. It will also let us fold together the checks for whether an index is a supported property index, followed by getting the value just afterwards. 2024-07-25 18:15:51 +12:00			`return {};`
LibWeb: Make NodeList GC-allocated 2022-09-01 16:30:26 +02:00			`return const_cast<Node*>(node);`
			`}`

			`}`