Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-04 07:10:57 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWeb/idl_files.cmake

404 lines
17 KiB
CMake
Raw Normal View History

Meta: Move LibWeb's CMake generation script to its own file This patch has no functional changes, but prepares the CMake script to be able to handle LibWeb on Lagom.
2022-04-30 12:50:51 +02:00
# This file is included from "Meta/CMake/libweb_data.cmake"
# It is defined here so that there is no need to go to the Meta directory when adding new idl files
LibWeb: Add the Animation IDL object
2023-11-06 15:17:19 +00:00
libweb_js_bindings(Animations/Animation)
LibWeb: Add the AnimationEffect IDL object
2023-11-06 15:17:15 +00:00
libweb_js_bindings(Animations/AnimationEffect)
LibWeb: Add the AnimationPlaybackEvent IDL object
2023-11-04 12:20:39 -07:00
libweb_js_bindings(Animations/AnimationPlaybackEvent)
LibWeb: Add AnimationTimeline IDL object
2023-11-04 08:16:37 -07:00
libweb_js_bindings(Animations/AnimationTimeline)
LibWeb: Add DocumentTimeline IDL object
2023-11-04 08:32:30 -07:00
libweb_js_bindings(Animations/DocumentTimeline)
LibWeb: Add KeyframeEffect IDL objects
2023-11-04 13:09:57 -07:00
libweb_js_bindings(Animations/KeyframeEffect)
LibWeb: Begin implementing the Clipboard API https://w3c.github.io/clipboard-apis/ This implements enough for navigator.clipboard.writeText(String).
2023-11-10 13:29:20 -05:00
libweb_js_bindings(Clipboard/Clipboard)
LibWeb: Implement the ClipboardEvent IDL interface We don't actually generate any such events ourselves. But Google Lens will create one with the DataTransfer attribute set to that of any drop event we send it.
2024-08-20 18:26:55 -04:00
libweb_js_bindings(Clipboard/ClipboardEvent)
LibWeb: Implement the ClipboardItem API Spec: https://w3c.github.io/clipboard-apis/#clipboard-item-interface
2024-11-30 20:23:38 -08:00
libweb_js_bindings(Clipboard/ClipboardItem)
LibWeb: Implement the CompressionStream interface
2024-11-15 11:11:47 -05:00
libweb_js_bindings(Compression/CompressionStream)
LibWeb: Implement the DecompressionStream interface
2024-11-15 14:40:04 -05:00
libweb_js_bindings(Compression/DecompressionStream)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(Crypto/Crypto)
LibWeb: Add the CryptoKey interface
2023-12-15 20:25:35 +01:00
libweb_js_bindings(Crypto/CryptoKey)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(Crypto/SubtleCrypto)
LibWeb: Add the AnimationEvent IDL objects
2023-11-04 14:00:09 -07:00
libweb_js_bindings(CSS/AnimationEvent)
LibWeb: Add the CSSAnimation IDL object
2023-11-04 13:57:57 -07:00
libweb_js_bindings(CSS/CSSAnimation)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(CSS/CSSConditionRule)
libweb_js_bindings(CSS/CSSFontFaceRule)
libweb_js_bindings(CSS/CSSGroupingRule)
libweb_js_bindings(CSS/CSSImportRule)
LibWeb: Generate JavaScript bindings for `CSSKeyframeRule` We still need to do a bit of work. For example: `set_key_text` isn't implemented due to its requirements being quite complex, but it's a start.
2023-06-20 16:19:40 +01:00
libweb_js_bindings(CSS/CSSKeyframeRule)
LibWeb: Generate JavaScript bindings for `CSSKeyframesRule` This one also needs a bit of work, but it's a nice start.
2023-06-20 16:30:06 +01:00
libweb_js_bindings(CSS/CSSKeyframesRule)
LibWeb/CSS: Add CSSOM types for `@layer` rules Depending on usage, `@layer` has two forms, with two different CSSOM types. One simply lists layer names and the other defines a layer with its contained rules.
2024-09-02 16:45:25 +01:00
libweb_js_bindings(CSS/CSSLayerBlockRule)
libweb_js_bindings(CSS/CSSLayerStatementRule)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(CSS/CSSMediaRule)
LibWeb: Port the CSS namespace to IDL
2023-03-15 10:55:53 -04:00
libweb_js_bindings(CSS/CSS NAMESPACE)
LibWeb: Rough implementation of CSS namespace rule This provides a rough implementation of the CSS @namespace rule. Currently we just support default namespaces, namespace prefixes are still to come.
2023-07-29 11:51:15 -05:00
libweb_js_bindings(CSS/CSSNamespaceRule)
LibWeb: Implement CSSNestedDeclarations type This is basically a list of properties, without a block around it. It'll be part of CSSStyleRules' contents.
2024-10-15 15:59:31 +01:00
libweb_js_bindings(CSS/CSSNestedDeclarations)
LibWeb: Add and implement `CSSPropertyRule` IDL and bindings
2024-10-17 23:28:09 +01:00
libweb_js_bindings(CSS/CSSPropertyRule)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(CSS/CSSRule)
libweb_js_bindings(CSS/CSSRuleList)
libweb_js_bindings(CSS/CSSStyleDeclaration)
libweb_js_bindings(CSS/CSSStyleRule)
libweb_js_bindings(CSS/CSSStyleSheet)
libweb_js_bindings(CSS/CSSSupportsRule)
LibWeb: Add the CSSTransition IDL object
2024-02-19 18:59:58 -07:00
libweb_js_bindings(CSS/CSSTransition)
LibWeb: Add stub implementation of CSS FontFace Web API
2024-05-07 10:05:29 -06:00
libweb_js_bindings(CSS/FontFace)
LibWeb: Add stub implementation of FontFaceSet and Document.fonts This is now enough for duolingo to load and use its fallback fonts.
2024-05-07 14:49:31 -06:00
libweb_js_bindings(CSS/FontFaceSet)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(CSS/MediaList)
libweb_js_bindings(CSS/MediaQueryList)
libweb_js_bindings(CSS/MediaQueryListEvent)
libweb_js_bindings(CSS/Screen)
LibWeb: Add stubs for the Screen Orientation API As defined in: https://w3c.github.io/screen-orientation
2024-04-02 22:44:05 +02:00
libweb_js_bindings(CSS/ScreenOrientation)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(CSS/StyleSheet)
libweb_js_bindings(CSS/StyleSheetList)
LibWeb: Implement basic version of CSSOM View's VisualViewport We got some errors while loading https://twinings.co.uk/ about this interface missing, and it looked fairly simple so I sketched it out. Note that I did leave some FIXMEs where it's not clear exactly which metrics we should be returning.
2023-06-17 16:40:35 +02:00
libweb_js_bindings(CSS/VisualViewport)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(DOM/AbstractRange)
libweb_js_bindings(DOM/Attr)
libweb_js_bindings(DOM/AbortController)
libweb_js_bindings(DOM/AbortSignal)
libweb_js_bindings(DOM/CDATASection)
libweb_js_bindings(DOM/CharacterData)
libweb_js_bindings(DOM/Comment)
libweb_js_bindings(DOM/CustomEvent)
libweb_js_bindings(DOM/Document)
libweb_js_bindings(DOM/DocumentFragment)
libweb_js_bindings(DOM/DocumentType)
libweb_js_bindings(DOM/DOMImplementation)
libweb_js_bindings(DOM/DOMTokenList)
libweb_js_bindings(DOM/Element)
libweb_js_bindings(DOM/Event)
libweb_js_bindings(DOM/EventTarget)
libweb_js_bindings(DOM/HTMLCollection)
libweb_js_bindings(DOM/MutationObserver)
LibWeb: Implement HTMLFormControlsCollection This collection is used in the form element for when element lookup yields multiple elements.
2023-08-20 14:41:51 +12:00
libweb_js_bindings(DOM/MutationRecord)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(DOM/NamedNodeMap)
libweb_js_bindings(DOM/Node)
LibWeb: Expose NodeFilter on the Window object
2022-10-28 15:38:22 +01:00
libweb_js_bindings(DOM/NodeFilter)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(DOM/NodeIterator)
libweb_js_bindings(DOM/NodeList)
libweb_js_bindings(DOM/ProcessingInstruction)
libweb_js_bindings(DOM/Range)
libweb_js_bindings(DOM/ShadowRoot)
libweb_js_bindings(DOM/StaticRange)
libweb_js_bindings(DOM/Text)
libweb_js_bindings(DOM/TreeWalker)
LibWeb: Add XMLDocument stub Required by old versions of Pixi.js's XMLFormat bitmap font loader. https://github.com/pixijs/pixijs/blob/db824181dc3dfffa0951fb8579282ba8e654cb3b/packages/text-bitmap/src/formats/XMLFormat.ts#L16
2023-04-05 23:00:08 +01:00
libweb_js_bindings(DOM/XMLDocument)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(DOMParsing/XMLSerializer)
LibWeb: Rename URL platform object to DOMURL Along with putting functions in the URL namespace into a DOMURL namespace. This is done as LibWeb is in an awkward situation where it needs two URL classes. AK::URL is the general purpose URL class which is all that is needed in 95% of cases. URL in the Web namespace is needed predominantly for interfacing with the javascript interfaces. Because of two URLs in the same namespace, AK::URL has had to be used throughout LibWeb. If we move AK::URL into a URL namespace, this becomes more painful - where ::URL::URL is required to specify the constructor (and something like ::URL::create_with_url_or_path in other places). To fix this problem - rename the class in LibWeb implementing the URL IDL interface to DOMURL, along with moving the other Web URL related classes into this DOMURL folder. One could argue that this name also makes the situation a little more clear in LibWeb for why these two URL classes need be used in the first place.
2024-02-11 19:48:56 +13:00
libweb_js_bindings(DOMURL/DOMURL)
libweb_js_bindings(DOMURL/URLSearchParams ITERABLE)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(Encoding/TextDecoder)
libweb_js_bindings(Encoding/TextEncoder)
LibWeb/EntriesAPI: Implement FileSystemEntry
2024-08-23 19:41:19 +01:00
libweb_js_bindings(EntriesAPI/FileSystemEntry)
LibWeb: Define PerformanceEventTiming https://www.w3.org/TR/event-timing/#sec-performance-event-timing Add idl, header and stubs for PerformanceEventTiming interface. Two missing `PerformanceEntry` types that have come up in issues are the `first-input` and the `event` entryTypes. Those are both this. Also, because both of those are this same interface, the static methods from the parent class are difficult to implement because of instance-specific details. Might either need subclasses or to edit the parent and also everything that inherits from it :/
2024-09-22 15:12:55 -04:00
libweb_js_bindings(EventTiming/PerformanceEventTiming)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(Fetch/Headers ITERABLE)
LibWeb: Implement '5.4. Request class' from the Fetch API :^)
2022-09-25 19:33:13 +01:00
libweb_js_bindings(Fetch/Request)
LibWeb: Implement '5.5. Response class' from the Fetch API :^)
2022-09-25 19:36:30 +01:00
libweb_js_bindings(Fetch/Response)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(FileAPI/Blob)
libweb_js_bindings(FileAPI/File)
LibWeb: Add FileList from the FileAPI spec
2022-10-03 21:10:39 -06:00
libweb_js_bindings(FileAPI/FileList)
LibWeb: Add an initial implementation for Web::FileAPI::FileReader Some steps are still to be implemented, namely: * Properly aborting the read algorithm * Handling BinaryString type properly * Setting error on any error But as it stands, this is enough functionality for the basic case of reading the contents of a blob using the FileReader API.
2023-09-09 13:29:01 +12:00
libweb_js_bindings(FileAPI/FileReader)
LibWeb: Add initial implementation of DOMMatrix(ReadOnly) This is currently missing a lot of functions and initialisation from a <transform-list> string, but is enough for Ruffle.
2023-02-27 18:04:51 +00:00
libweb_js_bindings(Geometry/DOMMatrix)
libweb_js_bindings(Geometry/DOMMatrixReadOnly)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(Geometry/DOMPoint)
libweb_js_bindings(Geometry/DOMPointReadOnly)
LibWeb: Add DOMQuad and text tests
2023-08-20 22:03:41 +02:00
libweb_js_bindings(Geometry/DOMQuad)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(Geometry/DOMRect)
libweb_js_bindings(Geometry/DOMRectList)
libweb_js_bindings(Geometry/DOMRectReadOnly)
LibWeb: Implement the AudioTrack and AudioTrackList interfaces These are used to own and manage the playing of audio data.
2023-06-12 13:52:30 -04:00
libweb_js_bindings(HTML/AudioTrack)
libweb_js_bindings(HTML/AudioTrackList)
LibWeb: Move some classes from the DOM namespace to the HTML namespace The following classes are in the HTML spec and thus belong in the HTML namespace: * BeforeUnloadEvent * HTMLFormControlsCollection * RadioNodeList
2024-11-02 09:22:13 -04:00
libweb_js_bindings(HTML/BeforeUnloadEvent)
LibWeb: Stub BroadcastChannel interface This is enough to get the 1Password login page to load :^)
2024-07-13 14:51:28 +01:00
libweb_js_bindings(HTML/BroadcastChannel)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HTML/CanvasGradient)
LibWeb: Implement CanvasRenderingContext2D.createPattern() This is a first pass at implementing CRC2D.createPattern() and the associated CanvasPattern object. This implementation only works for a few of the required image sources [like CRC2D.drawImage()], and does not yet support transforms. Other than that it supports everything else (which is mainly the various repeat modes).
2023-02-02 20:47:46 +00:00
libweb_js_bindings(HTML/CanvasPattern)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HTML/CanvasRenderingContext2D)
libweb_js_bindings(HTML/CloseEvent)
LibWeb: Implement CloseWatcher API This implements most of the CloseWatcher API from the html spec. AbortSignal support is unimplemented. Integration with dialogs and popovers is also unimplemented.
2024-06-21 22:53:05 +01:00
libweb_js_bindings(HTML/CloseWatcher)
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
libweb_js_bindings(HTML/CustomElements/CustomElementRegistry)
LibWeb: Implement HTML DragEvent class This just defines the class, drag events aren't actually fired yet.
2024-07-08 18:33:12 +02:00
libweb_js_bindings(HTML/DataTransfer)
LibWeb: Add an empty DataTransferItem IDL implementation
2024-08-15 12:18:56 -04:00
libweb_js_bindings(HTML/DataTransferItem)
LibWeb: Add an empty DataTransferItemList IDL implementation
2024-08-15 12:20:22 -04:00
libweb_js_bindings(HTML/DataTransferItemList)
LibWeb: Create separate DedicatedWorkerGlobalScope class This is how it's supposed to have been from the beginning, we were just lazy :).
2024-07-09 15:54:22 -06:00
libweb_js_bindings(HTML/DedicatedWorkerGlobalScope GLOBAL)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HTML/DOMParser)
LibWeb: Implement DOMStringList
2024-07-14 12:31:50 +01:00
libweb_js_bindings(HTML/DOMStringList)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HTML/DOMStringMap)
LibWeb: Implement HTML DragEvent class This just defines the class, drag events aren't actually fired yet.
2024-07-08 18:33:12 +02:00
libweb_js_bindings(HTML/DragEvent)
LibWeb: Implement stub for ElementInternals This implements a stub ElementInternals object which implements the shadowRoot getter only. Also implement attachInternals function.
2024-06-24 21:54:42 +01:00
libweb_js_bindings(HTML/ElementInternals)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HTML/ErrorEvent)
LibWeb: Implement EventSource for server-sent events EventSource allows opening a persistent HTTP connection to a server over which events are continuously streamed. Unfortunately, our test infrastructure does not allow for automating any tests of this feature yet. It only works with HTTP connections.
2024-04-05 13:33:41 -04:00
libweb_js_bindings(HTML/EventSource)
LibWeb: Introduce the FormDataEvent interface
2023-02-03 21:50:10 +01:00
libweb_js_bindings(HTML/FormDataEvent)
LibWeb: Add hashchange event support
2024-04-15 04:25:24 +02:00
libweb_js_bindings(HTML/HashChangeEvent)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HTML/History)
LibWeb: Implement HTMLAllCollection This collection has some pretty strange behaviour, particularly with the IsHTMLDDA slot which is defined in the javascript spec specifically for this object. This commit implements pretty much all of this interface, besides from the custom [[Call]]. There is also no caching over this collection. Since it is a live collection over the entire document, the performance is never going to be great, and I am not convinced any speedup for this legacy interface is worth a massive cache.
2024-04-01 08:44:24 +02:00
libweb_js_bindings(HTML/HTMLAllCollection)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HTML/HTMLAnchorElement)
libweb_js_bindings(HTML/HTMLAreaElement)
libweb_js_bindings(HTML/HTMLAudioElement)
libweb_js_bindings(HTML/HTMLBaseElement)
libweb_js_bindings(HTML/HTMLBodyElement)
libweb_js_bindings(HTML/HTMLBRElement)
libweb_js_bindings(HTML/HTMLButtonElement)
libweb_js_bindings(HTML/HTMLCanvasElement)
libweb_js_bindings(HTML/HTMLDataElement)
libweb_js_bindings(HTML/HTMLDataListElement)
libweb_js_bindings(HTML/HTMLDetailsElement)
libweb_js_bindings(HTML/HTMLDialogElement)
libweb_js_bindings(HTML/HTMLDirectoryElement)
libweb_js_bindings(HTML/HTMLDivElement)
LibWeb: Add HTMLDocument class This class is currently not in the spec, but it *is* still in all the major browser engines. For compatibility reasons, let's do what other engines do. There is discussion about bringing HTMLDocument back into specs: - https://github.com/whatwg/html/issues/4792 - https://github.com/whatwg/dom/issues/221
2023-06-21 13:53:09 +02:00
libweb_js_bindings(HTML/HTMLDocument)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HTML/HTMLDListElement)
libweb_js_bindings(HTML/HTMLElement)
libweb_js_bindings(HTML/HTMLEmbedElement)
libweb_js_bindings(HTML/HTMLFieldSetElement)
libweb_js_bindings(HTML/HTMLFontElement)
LibWeb: Move some classes from the DOM namespace to the HTML namespace The following classes are in the HTML spec and thus belong in the HTML namespace: * BeforeUnloadEvent * HTMLFormControlsCollection * RadioNodeList
2024-11-02 09:22:13 -04:00
libweb_js_bindings(HTML/HTMLFormControlsCollection)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HTML/HTMLFormElement)
libweb_js_bindings(HTML/HTMLFrameElement)
libweb_js_bindings(HTML/HTMLFrameSetElement)
libweb_js_bindings(HTML/HTMLHeadElement)
libweb_js_bindings(HTML/HTMLHeadingElement)
libweb_js_bindings(HTML/HTMLHRElement)
libweb_js_bindings(HTML/HTMLHtmlElement)
libweb_js_bindings(HTML/HTMLIFrameElement)
libweb_js_bindings(HTML/HTMLImageElement)
libweb_js_bindings(HTML/HTMLInputElement)
libweb_js_bindings(HTML/HTMLLabelElement)
libweb_js_bindings(HTML/HTMLLegendElement)
libweb_js_bindings(HTML/HTMLLIElement)
libweb_js_bindings(HTML/HTMLLinkElement)
libweb_js_bindings(HTML/HTMLMapElement)
libweb_js_bindings(HTML/HTMLMarqueeElement)
libweb_js_bindings(HTML/HTMLMediaElement)
libweb_js_bindings(HTML/HTMLMenuElement)
libweb_js_bindings(HTML/HTMLMetaElement)
libweb_js_bindings(HTML/HTMLMeterElement)
libweb_js_bindings(HTML/HTMLModElement)
libweb_js_bindings(HTML/HTMLObjectElement)
libweb_js_bindings(HTML/HTMLOListElement)
libweb_js_bindings(HTML/HTMLOptGroupElement)
libweb_js_bindings(HTML/HTMLOptionElement)
libweb_js_bindings(HTML/HTMLOptionsCollection)
libweb_js_bindings(HTML/HTMLOutputElement)
libweb_js_bindings(HTML/HTMLParagraphElement)
libweb_js_bindings(HTML/HTMLParamElement)
libweb_js_bindings(HTML/HTMLPictureElement)
libweb_js_bindings(HTML/HTMLPreElement)
libweb_js_bindings(HTML/HTMLProgressElement)
libweb_js_bindings(HTML/HTMLQuoteElement)
libweb_js_bindings(HTML/HTMLScriptElement)
libweb_js_bindings(HTML/HTMLSelectElement)
libweb_js_bindings(HTML/HTMLSlotElement)
libweb_js_bindings(HTML/HTMLSourceElement)
libweb_js_bindings(HTML/HTMLSpanElement)
libweb_js_bindings(HTML/HTMLStyleElement)
libweb_js_bindings(HTML/HTMLTableCaptionElement)
libweb_js_bindings(HTML/HTMLTableCellElement)
libweb_js_bindings(HTML/HTMLTableColElement)
libweb_js_bindings(HTML/HTMLTableElement)
libweb_js_bindings(HTML/HTMLTableRowElement)
libweb_js_bindings(HTML/HTMLTableSectionElement)
libweb_js_bindings(HTML/HTMLTemplateElement)
libweb_js_bindings(HTML/HTMLTextAreaElement)
libweb_js_bindings(HTML/HTMLTimeElement)
libweb_js_bindings(HTML/HTMLTitleElement)
libweb_js_bindings(HTML/HTMLTrackElement)
libweb_js_bindings(HTML/HTMLUListElement)
libweb_js_bindings(HTML/HTMLUnknownElement)
libweb_js_bindings(HTML/HTMLVideoElement)
LibWeb: Implement HTML::ImageBitmap And the two methods of `WindowOrWorkerGlobalScope` that are used as constructors for it.
2024-04-04 21:48:58 -04:00
libweb_js_bindings(HTML/ImageBitmap)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HTML/ImageData)
LibWeb: Convert the Location object to IDL This includes: - Moving it from Bindings/ to HTML/ - Renaming it from LocationObject to Location - Removing the manual definitions of the constructor and prototype - Removing special handling of the Location interface from the bindings generator - Converting the JS_DEFINE_NATIVE_FUNCTIONs to regular functions returning DeprecatedString instead of PrimitiveString - Adding missing (no-op) setters for the various attributes, which are expected to exist by the bindings generator
2023-01-18 17:41:12 +00:00
libweb_js_bindings(HTML/Location)
LibWeb: Implement the MediaError IDL interface
2023-04-22 14:39:20 -04:00
libweb_js_bindings(HTML/MediaError)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HTML/MessageChannel)
libweb_js_bindings(HTML/MessageEvent)
libweb_js_bindings(HTML/MessagePort)
LibWeb: Implement navigator.{plugins,mimeTypes}
2023-02-28 00:23:53 +00:00
libweb_js_bindings(HTML/MimeType)
libweb_js_bindings(HTML/MimeTypeArray)
LibWeb: Add NavigateEvent, the main event of the Navigation API This event is the star of the show, and the main way that web content can react to either programmatic or user-initiated navigation. All of the fun algorithms will have to come later though.
2023-08-23 18:40:42 -06:00
libweb_js_bindings(HTML/NavigateEvent)
LibWeb: Implement the start of the Navigation API This API is how JavaScript can manipulate the new Navigable concepts directly. We are still missing most of the interesting algorithms on Navigation that do the actual navigation steps, and call into the currently WIP navigable AOs.
2023-08-23 10:57:12 -06:00
libweb_js_bindings(HTML/Navigation)
LibWeb: Add NavigationCurrentEntryChangeEvent, fired when navigating This event will be fired by Navigation when changing the current NavigationHistoryEntry.
2023-08-23 10:53:11 -06:00
libweb_js_bindings(HTML/NavigationCurrentEntryChangeEvent)
LibWeb: Add NavigationDestination, used for NavigateEvents This class will be used in the algorithms for the navigate event firing algorithms to populate the destination field of the NavigateEvent.
2023-08-23 13:35:25 -06:00
libweb_js_bindings(HTML/NavigationDestination)
LibWeb: Add NavigationHistoryEntry, a wrapper around SessionHistoryEntry
2023-08-23 10:47:05 -06:00
libweb_js_bindings(HTML/NavigationHistoryEntry)
LibWeb: Add NavigationTransition, a transient property of Navigation This property is useful for web content to determine whether an ongoing navigation has settled or not.
2023-08-23 15:34:02 -06:00
libweb_js_bindings(HTML/NavigationTransition)
LibWeb: Re-implement HTML::Navigator using IDL Get rid of the bespoke NavigatorObject class and use the modern IDL strategies for creating platform objects to re-implement Navigator and its associcated mixin interfaces. While we're here, implement it in a way that brings WorkerNavigator up to spec :^)
2022-10-08 20:53:08 -06:00
libweb_js_bindings(HTML/Navigator)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HTML/PageTransitionEvent)
libweb_js_bindings(HTML/Path2D)
LibWeb: Implement navigator.{plugins,mimeTypes}
2023-02-28 00:23:53 +00:00
libweb_js_bindings(HTML/Plugin)
libweb_js_bindings(HTML/PluginArray)
LibWeb: Add popstate event support It is going to be useful in writing tests for History API.
2024-04-10 21:25:31 -07:00
libweb_js_bindings(HTML/PopStateEvent)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HTML/PromiseRejectionEvent)
LibWeb: Move some classes from the DOM namespace to the HTML namespace The following classes are in the HTML spec and thus belong in the HTML namespace: * BeforeUnloadEvent * HTMLFormControlsCollection * RadioNodeList
2024-11-02 09:22:13 -04:00
libweb_js_bindings(HTML/RadioNodeList)
LibWeb: Wire up UniversalGlobalScopeMixin to ShadowRealmGlobalScope
2024-11-08 16:35:16 +13:00
libweb_js_bindings(HTML/ShadowRealmGlobalScope GLOBAL)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HTML/Storage)
LibWeb/HTML: Implement the StorageEvent interface
2024-12-23 22:45:19 +13:00
libweb_js_bindings(HTML/StorageEvent)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HTML/SubmitEvent)
libweb_js_bindings(HTML/TextMetrics)
LibWeb/HTML: Stub TextTrack IDL interface
2024-06-09 10:32:20 +01:00
libweb_js_bindings(HTML/TextTrack)
LibWeb/HTML: Implement TextTrackCue idl interface
2024-09-19 19:41:57 +01:00
libweb_js_bindings(HTML/TextTrackCue)
LibWeb/HTML: Implement TextTrackCueList idl interface
2024-09-20 23:06:51 +01:00
libweb_js_bindings(HTML/TextTrackCueList)
LibWeb/HTML: Implement TextTrackList IDL interface
2024-06-09 11:07:41 +01:00
libweb_js_bindings(HTML/TextTrackList)
LibWeb: Stub out the HTML TimeRanges IDL interface This is used by media elements. Provide a stub for websites which depend on the interface existing.
2023-04-18 16:19:37 -04:00
libweb_js_bindings(HTML/TimeRanges)
LibWeb: Implement ToggleEvent for HTMLDetailsElement
2023-08-31 13:28:49 -04:00
libweb_js_bindings(HTML/ToggleEvent)
LibWeb: Implement TrackEvent for media events
2023-04-04 09:28:59 -04:00
libweb_js_bindings(HTML/TrackEvent)
LibWeb: Implement UserActivation
2024-05-25 12:40:44 +01:00
libweb_js_bindings(HTML/UserActivation)
LibWeb: Add stub for ValidityState This fixes https://html5test.com/ as previously an exception was being thrown after trying to access this attribute which would then result in a popup about the test failing (and none of the test results being shown).
2024-06-09 15:13:38 +12:00
libweb_js_bindings(HTML/ValidityState)
LibWeb: Implement VideoTrack and VideoTrackList This implements the IDL for these types and some event handling around them.
2023-04-04 09:26:02 -04:00
libweb_js_bindings(HTML/VideoTrack)
libweb_js_bindings(HTML/VideoTrackList)
LibWeb: Start generating code for the Window object from IDL :^)
2023-03-05 15:52:34 +00:00
libweb_js_bindings(HTML/Window GLOBAL)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HTML/Worker)
libweb_js_bindings(HTML/WorkerGlobalScope)
libweb_js_bindings(HTML/WorkerLocation)
libweb_js_bindings(HTML/WorkerNavigator)
LibWeb: Add stub definition for WorkletGlobalScope
2024-11-30 19:27:53 +13:00
libweb_js_bindings(HTML/WorkletGlobalScope)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(HighResolutionTime/Performance)
LibWeb: Add IDBCursor
2024-11-07 18:49:31 +01:00
libweb_js_bindings(IndexedDB/IDBCursor)
LibWeb: Implement the IDBDatabase interface
2024-11-04 18:53:05 +01:00
libweb_js_bindings(IndexedDB/IDBDatabase)
LibWeb: Add stub for IDBFactory
2024-05-19 17:58:06 +12:00
libweb_js_bindings(IndexedDB/IDBFactory)
LibWeb: Add IDBIndex
2024-11-07 18:52:59 +01:00
libweb_js_bindings(IndexedDB/IDBIndex)
LibWeb: Add IDBKeyRange
2024-11-07 19:04:11 +01:00
libweb_js_bindings(IndexedDB/IDBKeyRange)
LibWeb: Add IDBObjectStore
2024-11-07 18:56:26 +01:00
libweb_js_bindings(IndexedDB/IDBObjectStore)
LibWeb: Add stub interface for IDBOpenDBRequest
2024-05-19 18:07:06 +12:00
libweb_js_bindings(IndexedDB/IDBOpenDBRequest)
LibWeb: Add stub interface for IDBRequest
2024-05-19 18:03:00 +12:00
libweb_js_bindings(IndexedDB/IDBRequest)
LibWeb: Add IDBTransaction
2024-11-07 19:00:20 +01:00
libweb_js_bindings(IndexedDB/IDBTransaction)
LibWeb: Add IDBVersionChangeEvent
2024-11-04 19:17:54 +01:00
libweb_js_bindings(IndexedDB/IDBVersionChangeEvent)
LibWeb+LibWebView+WebContent: Add an Inspector IDL object to the Window This is an internal object that must be explicitly enabled by the chrome before it is added to the Window. The Inspector object will be used by a special WebView that will replace all chrome-specific inspector windows. The IDL defines methods that this WebView will need to inform the chrome of various events, such as the user clicking a DOM node.
2023-11-23 12:22:23 -05:00
libweb_js_bindings(Internals/Inspector)
LibWeb: Add an InternalAnimationTimeline object This will allow fine grained control over animation times, which will allow us to write timing tests that can reliably pass on the much slower CI machines.
2024-03-27 15:30:54 +00:00
libweb_js_bindings(Internals/InternalAnimationTimeline)
LibWeb: Add a simple `internals` objects only available during testing This object is available as `window.internals` (or just `internals`) and is only accessible while running in "test mode". This first version only has one API: gc(), which triggers a garbage collection immediately. In the future, we can add more APIs here to help us test parts of the engine that are hard or impossible to reach via public web APIs.
2023-07-21 11:59:49 +02:00
libweb_js_bindings(Internals/Internals)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(IntersectionObserver/IntersectionObserver)
LibWeb: Add initial implementation of IntersectionObserver The main missing features are rootMargin, proper nested browsing context support and content clip/clip-path support. This makes images appear on some sites, such as YouTube and howstuffworks.com.
2023-07-06 23:44:07 +01:00
libweb_js_bindings(IntersectionObserver/IntersectionObserverEntry)
LibWeb: Add the MathML Element This patch introduces the MathML element, which provides the interface all MathML elements are built from.
2023-07-05 20:24:51 -05:00
libweb_js_bindings(MathML/MathMLElement)
LibWeb: Stub MediaCapabilities IDL interface
2024-09-04 23:52:21 +01:00
libweb_js_bindings(MediaCapabilitiesAPI/MediaCapabilities)
LibWeb: Add stubbed Media Source Extensions API Just the boilerplate :^)
2024-11-01 14:03:15 +01:00
libweb_js_bindings(MediaSourceExtensions/BufferedChangeEvent)
libweb_js_bindings(MediaSourceExtensions/ManagedMediaSource)
libweb_js_bindings(MediaSourceExtensions/ManagedSourceBuffer)
libweb_js_bindings(MediaSourceExtensions/MediaSource)
libweb_js_bindings(MediaSourceExtensions/MediaSourceHandle)
libweb_js_bindings(MediaSourceExtensions/SourceBuffer)
libweb_js_bindings(MediaSourceExtensions/SourceBufferList)
LibWeb: Add stub implementation of performance.navigation
2024-08-01 19:50:52 -06:00
libweb_js_bindings(NavigationTiming/PerformanceNavigation)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(NavigationTiming/PerformanceTiming)
LibWeb: Introduce Performance Timeline and its Performance functions
2023-03-22 19:12:57 +00:00
libweb_js_bindings(PerformanceTimeline/PerformanceEntry)
LibWeb: Implement PerformanceObserver
2023-08-25 01:26:47 +01:00
libweb_js_bindings(PerformanceTimeline/PerformanceObserver)
libweb_js_bindings(PerformanceTimeline/PerformanceObserverEntryList)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(RequestIdleCallback/IdleDeadline)
libweb_js_bindings(ResizeObserver/ResizeObserver)
LibWeb: Flesh out implementation of ResizeObserver interfaces Adds the initial implementation for interfaces defined in the ResizeObserver specification. These interfaces will be used to construct and send observation events in the upcoming changes.
2024-02-19 05:06:39 +01:00
libweb_js_bindings(ResizeObserver/ResizeObserverEntry)
libweb_js_bindings(ResizeObserver/ResizeObserverSize)
LibWeb: Move ServiceWorker classes to ServiceWorker namespace These are defined by the ServiceWorker spec, not the HTML one.
2024-11-30 18:01:40 +13:00
libweb_js_bindings(ServiceWorker/ServiceWorker)
libweb_js_bindings(ServiceWorker/ServiceWorkerContainer)
LibWeb: Add stubbed implementation for ServiceWorkerGlobalScope
2024-11-30 18:35:45 +13:00
libweb_js_bindings(ServiceWorker/ServiceWorkerGlobalScope GLOBAL)
LibWeb: Move ServiceWorker classes to ServiceWorker namespace These are defined by the ServiceWorker spec, not the HTML one.
2024-11-30 18:01:40 +13:00
libweb_js_bindings(ServiceWorker/ServiceWorkerRegistration)
LibWeb: Implement ByteLengthQueuingStrategy highWaterMark property
2023-06-18 20:26:19 +12:00
libweb_js_bindings(Streams/ByteLengthQueuingStrategy)
LibWeb: Implement CountQueuingStrategy highWaterMark property
2023-06-18 19:43:56 +12:00
libweb_js_bindings(Streams/CountQueuingStrategy)
LibWeb: Add ReadableStreamByteController interface
2023-04-11 16:33:32 -07:00
libweb_js_bindings(Streams/ReadableByteStreamController)
LibWeb: Start fleshing out the ReadableStream interface This is so we can just assume it exists in Fetch APIs (while still skipping functionality that relies on a full implementation, of course).
2022-09-21 23:27:13 +01:00
libweb_js_bindings(Streams/ReadableStream)
LibWeb: Add ReadableStreamBYOBReader interface
2023-04-08 12:01:49 -07:00
libweb_js_bindings(Streams/ReadableStreamBYOBReader)
LibWeb: Add ReadableStreamBYOBRequest interface
2023-04-10 18:37:27 -07:00
libweb_js_bindings(Streams/ReadableStreamBYOBRequest)
LibWeb: Add ReadableStreamDefaultController
2023-03-28 18:56:11 -07:00
libweb_js_bindings(Streams/ReadableStreamDefaultController)
LibWeb: Add ReadableStreamDefaultReader
2023-03-28 18:30:22 -07:00
libweb_js_bindings(Streams/ReadableStreamDefaultReader)
LibWeb: Add TransformStream scaffolding This adds the scaffolding of TransformStream so we can start implementing the necessary abstract operations for it.
2023-07-06 19:37:12 +02:00
libweb_js_bindings(Streams/TransformStream)
LibWeb: Add TransformStreamDefaultController scaffolding This adds the scaffolding of TransformStreamDefaultController so we can start implementing the necessary abstract operations for it.
2023-07-07 15:49:22 +02:00
libweb_js_bindings(Streams/TransformStreamDefaultController)
LibWeb: Add the WritableStream interface
2023-04-02 15:15:53 -07:00
libweb_js_bindings(Streams/WritableStream)
Meta: Bind WritableStreamDefaultController to JS This was missed in 868cd9506923b6e47b56fdb0ec7cb1cc09031960.
2023-07-16 09:48:05 -06:00
libweb_js_bindings(Streams/WritableStreamDefaultController)
LibWeb: Add the WritableStreamDefaultWriter interface
2023-03-30 19:27:45 -07:00
libweb_js_bindings(Streams/WritableStreamDefaultWriter)
LibWeb: Add the bare minimum to render SVGAElement (`<a>`)
2024-06-23 17:05:47 +02:00
libweb_js_bindings(SVG/SVGAElement)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(SVG/SVGAnimatedLength)
LibWeb: Implement SVGAnimatedNumber See https://www.w3.org/TR/2013/WD-SVG2-20130409/types.html#InterfaceSVGAnimatedNumber
2023-04-18 18:51:00 +01:00
libweb_js_bindings(SVG/SVGAnimatedNumber)
LibWeb: Add SVGSVGElement.viewBox attribute This attribute has some compatbility issues... - The spec says it should be an SVGAnimatedRect which contains a DOMRect and a DOMReadOnlyRect. - Blink gives you an SVGAnimatedRect with 2x SVGRect - Gecko gives you an SVGAnimatedRect with 2x SVGRect? (nullable) I ended up with something similar to Gecko, an SVGAnimatedRect with 2x DOMRect? (nullable) With this fixed, we can now load https://polar.sh/ :^)
2024-01-24 22:54:16 +01:00
libweb_js_bindings(SVG/SVGAnimatedRect)
LibWeb: Implement SVGAnimatedString
2023-11-14 00:18:09 +00:00
libweb_js_bindings(SVG/SVGAnimatedString)
LibWeb: Stub out `SVGAnimatedTransformList`
2024-03-31 15:21:00 +01:00
libweb_js_bindings(SVG/SVGAnimatedTransformList)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(SVG/SVGClipPathElement)
libweb_js_bindings(SVG/SVGDefsElement)
LibWeb: Implement <desc> SVG element
2024-04-15 18:43:01 +01:00
libweb_js_bindings(SVG/SVGDescElement)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(SVG/SVGElement)
LibWeb/SVG: Add missing SVGGElement IDL file
2024-08-16 16:30:06 +01:00
libweb_js_bindings(SVG/SVGGElement)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(SVG/SVGGeometryElement)
LibWeb: Implement SVGGradientElement This is the base class for all SVG gradient types. This supports: - The `gradientUnits` attribute - The `gradientTransform` attribute - And following `xlink:hrefs` for inheriting <stops>/attributes
2023-04-21 18:51:00 +01:00
libweb_js_bindings(SVG/SVGGradientElement)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(SVG/SVGGraphicsElement)
LibWeb/SVG: Implement `SVGImageElement` This element allows images to be embedded within SVGs.
2024-08-20 15:12:55 +01:00
libweb_js_bindings(SVG/SVGImageElement)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(SVG/SVGCircleElement)
libweb_js_bindings(SVG/SVGEllipseElement)
LibWeb: Sketch out basic support for SVG <foreignObject> elements This patch adds basic DOM construction and IDL bindings for foreign objects in SVG trees.
2022-11-10 13:49:26 +01:00
libweb_js_bindings(SVG/SVGForeignObjectElement)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(SVG/SVGLength)
libweb_js_bindings(SVG/SVGLineElement)
LibWeb: Implement SVGLinearGradientElement (<linearGradient>) This represents the SVG <linearGradient>. The actual gradient is converted to a Gfx::PaintStyle for use in SVG fills... There is a little guesswork in the implementation, but it seems to match Chrome/Firefox. Note: Still not hooked up to actual painting in this commit.
2023-04-22 18:51:00 +01:00
libweb_js_bindings(SVG/SVGLinearGradientElement)
LibWeb: Stub out SVGMaskElement Just enough that we stop creating layout nodes for mask elements, which was making some SVG content look very wrong. :^)
2023-08-10 09:55:15 +02:00
libweb_js_bindings(SVG/SVGMaskElement)
LibWeb/SVG: Implement <metadata> element
2024-08-16 17:27:32 +01:00
libweb_js_bindings(SVG/SVGMetadataElement)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(SVG/SVGPathElement)
libweb_js_bindings(SVG/SVGPolygonElement)
libweb_js_bindings(SVG/SVGPolylineElement)
LibWeb: Add an initial implementation of SVG `<radialGradient>` This follows on from the SVG linear gradients. It supports the same features (xlink:href, gradientUnits, gradientTransform). With this commit I have now implemented all web gradients :^) (Though we are still missing a few parameters for SVG gradients, e.g. spreadMethod).
2023-05-02 23:11:58 +01:00
libweb_js_bindings(SVG/SVGRadialGradientElement)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(SVG/SVGRectElement)
LibWeb: Add IDL definition for SVGScriptElement It does not currently handle any of the actual scripting, but this should at least allow us to create an instance of the element. The test being added here isn't actually testing much, but before the previous commit we used to crash parsing the page due to a TODO().
2023-09-23 08:56:49 +12:00
libweb_js_bindings(SVG/SVGScriptElement)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(SVG/SVGSVGElement)
LibWeb: Implement SVGStopElement (<stop>) This is used to specify the color/position of color stops for SVG gradients.
2023-04-20 18:51:00 +01:00
libweb_js_bindings(SVG/SVGStopElement)
LibWeb: Implement the `<style>` SVG element The `<style>` element is allowed to be in the SVG namespace, so we now support this element. It has the same behaviour as the HTML namespace `<style>` element as described in the spec. "The semantics and processing of a ‘style’ and its attributes must be the same as is defined for the HTML ‘style’ element."
2023-06-08 17:48:33 +01:00
libweb_js_bindings(SVG/SVGStyleElement)
LibWeb: Implement the `<symbol>` SVG element
2023-05-31 00:50:12 +01:00
libweb_js_bindings(SVG/SVGSymbolElement)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(SVG/SVGTextContentElement)
LibWeb: Split SVGTextContentElement into spec defined subclasses As part of this move properties/methods to the correct subclass (position related properties go under SVGTextPositioningElement). SVG text element hierarchy: SVGTextContentElement ^- SVGTextPositioningElement ^- SVGTextElement ^- SVGTSpanElement ^- SVGTextPathElement (TODO) ^- SVGTRefElement (TODO)
2023-07-22 19:24:55 +01:00
libweb_js_bindings(SVG/SVGTextElement)
LibWeb: Add initial support for SVG `<textPath>` This patch adds basic support for the SVG `<textPath>`, so it supports placing text along a path, but none of the extra attributes for controlling the layout of the text. This is enough to correctly display the MDN example.
2023-12-17 18:35:21 +00:00
libweb_js_bindings(SVG/SVGTextPathElement)
LibWeb: Split SVGTextContentElement into spec defined subclasses As part of this move properties/methods to the correct subclass (position related properties go under SVGTextPositioningElement). SVG text element hierarchy: SVGTextContentElement ^- SVGTextPositioningElement ^- SVGTextElement ^- SVGTSpanElement ^- SVGTextPathElement (TODO) ^- SVGTRefElement (TODO)
2023-07-22 19:24:55 +01:00
libweb_js_bindings(SVG/SVGTextPositioningElement)
LibWeb: Implement the SVG title element
2023-06-08 11:46:44 -04:00
libweb_js_bindings(SVG/SVGTitleElement)
LibWeb: Stub out `SVGTransform`
2024-03-31 14:41:00 +01:00
libweb_js_bindings(SVG/SVGTransform)
LibWeb: Stub out `SVGTransformList`
2024-03-31 14:54:00 +01:00
libweb_js_bindings(SVG/SVGTransformList)
LibWeb: Add support for SVG <tspan> elements
2023-07-22 19:34:51 +01:00
libweb_js_bindings(SVG/SVGTSpanElement)
LibWeb: Implement the `<use>` SVG element The SVG <use> element is used to be able to reuse other SVG graphics without having to re-write the svg element. We now support this feature! :^)
2023-05-30 21:23:52 +01:00
libweb_js_bindings(SVG/SVGUseElement)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(Selection/Selection)
LibWeb: Stub StorageManager idl interface
2024-08-13 20:54:58 +01:00
libweb_js_bindings(StorageAPI/StorageManager)
LibWeb/UIEvents: Implement CompositionEvent
2024-07-18 20:22:44 +01:00
libweb_js_bindings(UIEvents/CompositionEvent)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(UIEvents/FocusEvent)
LibWeb/UIEvents: Implement InputEvent
2024-07-18 19:35:14 +01:00
libweb_js_bindings(UIEvents/InputEvent)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(UIEvents/KeyboardEvent)
libweb_js_bindings(UIEvents/MouseEvent)
LibWeb: Implement the PointerEvent interface As defined in: https://w3c.github.io/pointerevents With the exception of the getCoalescedEvents and getPredictedEvents APIs. There are still many other parts of that spec (such as the event handlers) left to implement, but this does get us at least some of the way.
2024-04-07 19:51:02 +02:00
libweb_js_bindings(UIEvents/PointerEvent)
LibWeb/UIEvents: Implement TextEvent
2024-10-05 14:44:59 +01:00
libweb_js_bindings(UIEvents/TextEvent)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(UIEvents/UIEvent)
LibWeb: Dispatch "wheel" event
2022-10-17 20:54:01 +03:00
libweb_js_bindings(UIEvents/WheelEvent)
LibWeb: Implement performance.mark and performance.clearMarks
2023-03-23 17:07:52 +00:00
libweb_js_bindings(UserTiming/PerformanceMark)
LibWeb: Implement performance.{measure,clearMeasures}
2023-05-13 13:34:28 +01:00
libweb_js_bindings(UserTiming/PerformanceMeasure)
LibWeb: Add WebAssembly.Global and exports support for global instances
2024-12-23 14:47:25 -07:00
libweb_js_bindings(WebAssembly/Global)
LibWeb: Port WebAssembly.Instance to IDL
2023-03-15 18:15:28 -04:00
libweb_js_bindings(WebAssembly/Instance)
LibWeb: Port WebAssembly.Memory to IDL
2023-03-15 19:29:57 -04:00
libweb_js_bindings(WebAssembly/Memory)
LibWeb: Port WebAssembly.Module to IDL
2023-03-15 14:47:54 -04:00
libweb_js_bindings(WebAssembly/Module)
LibWeb: Port WebAssembly.Table to IDL
2023-03-15 20:16:22 -04:00
libweb_js_bindings(WebAssembly/Table)
LibWeb: Port the WebAssembly namespace to IDL
2023-03-16 12:59:32 -04:00
libweb_js_bindings(WebAssembly/WebAssembly NAMESPACE)
LibWeb: Begin implementing the interface for AudioBuffer Implement the constructor and getChannelData function, working towards the functionality that we need in order to implement OfflineAudioContext.
2024-04-25 15:13:51 +12:00
libweb_js_bindings(WebAudio/AudioBuffer)
WebAudio: Stub `AudioBufferSourceNode`
2024-07-21 15:24:25 +03:00
libweb_js_bindings(WebAudio/AudioBufferSourceNode)
LibWeb: Stub AudioContext constructor This is enough to make Discord not throw up "Well this is awkward" on login.
2023-05-21 20:36:22 +01:00
libweb_js_bindings(WebAudio/AudioContext)
WebAudio: Add IDL interface for AudioDestinationNode This is an AudioNode representing the final audio destination and is what the user will ultimately hear. This node is used as one of the connecting nodes in athenacrisis.com Add a placeholder for the interface without anything backing it for now.
2024-07-24 16:44:49 +12:00
libweb_js_bindings(WebAudio/AudioDestinationNode)
LibWeb: Implement AudioListener This exposes BaseAudioContext.listener, which is a container for parameters related to the configuration of an actual "listener" in 3D space.
2024-10-17 21:26:01 +02:00
libweb_js_bindings(WebAudio/AudioListener)
LibWeb: Add stub IDL interface for AudioNode An AudioNode is the fundamental building block used in 'Audio Contexts'. In our immediate case, the audio node we are working towards implementing is an oscillating source node.
2024-04-28 12:46:07 +12:00
libweb_js_bindings(WebAudio/AudioNode)
LibWeb: Add stub IDL interface for AudioParam An AudioParam is a fundamental building block in WebAudio as it controls the value of an individual parameter of an AudioNode, such as volume.
2024-04-28 12:26:30 +12:00
libweb_js_bindings(WebAudio/AudioParam)
LibWeb: Add stub IDL interface for AudioScheduledSourceNode This is a base class of a few different audio nodes, most notably for our immediate needs - OscillatorNode.
2024-04-28 13:17:44 +12:00
libweb_js_bindings(WebAudio/AudioScheduledSourceNode)
LibWeb: Stub AudioContext constructor This is enough to make Discord not throw up "Well this is awkward" on login.
2023-05-21 20:36:22 +01:00
libweb_js_bindings(WebAudio/BaseAudioContext)
WebAudio: Stub `BiquadFilterNode`
2024-07-21 21:25:14 +03:00
libweb_js_bindings(WebAudio/BiquadFilterNode)
LibWeb: Add scaffolding for DynamicsCompressorNode
2024-05-05 10:53:34 +12:00
libweb_js_bindings(WebAudio/DynamicsCompressorNode)
LibWeb: Add Implement GainNode interface As with all other current audio nodes we still need to wire up the inputs and outputs so it can be properly used in an audio context - but this is enough to implement the public IDL interface.
2024-05-28 15:42:07 +12:00
libweb_js_bindings(WebAudio/GainNode)
LibWeb: Add ChannelMergerNode interface
2024-11-25 14:30:36 +01:00
libweb_js_bindings(WebAudio/ChannelMergerNode)
LibWeb: Add skeleton for OfflineAudioContext Implement enough to construct the object itself, with most parts stubbed out.
2024-04-27 07:45:57 +12:00
libweb_js_bindings(WebAudio/OfflineAudioContext)
LibWeb: Add stub IDL interface for OscillatorNode This source node generates a periodic wave form.
2024-04-28 13:29:14 +12:00
libweb_js_bindings(WebAudio/OscillatorNode)
LibWeb/WebAudio: Implement PannerNode Required by https://scottts.itch.io/different-strokes
2024-12-13 21:40:25 +00:00
libweb_js_bindings(WebAudio/PannerNode)
LibWeb: Add stub IDL interface for PeriodicWave PeriodicWave represents an arbitrary periodic waveform to be used with an OscillatorNode.
2024-04-28 12:19:19 +12:00
libweb_js_bindings(WebAudio/PeriodicWave)
LibWeb/WebGL: Add support for ANGLEInstancedArrays extension This is only WebGL 1.0 extension. It's enabled in ANGLE by default. Progress on https://ciechanow.ski/curves-and-surfaces/ that relies on this extension.
2024-12-20 11:26:22 +01:00
libweb_js_bindings(WebGL/ANGLEInstancedArrays)
LibWeb: Add stubbed-out WebGL2RenderingContext
2024-12-05 20:56:18 -07:00
libweb_js_bindings(WebGL/WebGL2RenderingContext)
LibWeb: Add WebGLActiveInfo
2024-11-13 10:15:42 +01:00
libweb_js_bindings(WebGL/WebGLActiveInfo)
LibWeb: Add WebGLBuffer
2024-11-13 09:35:57 +01:00
libweb_js_bindings(WebGL/WebGLBuffer)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(WebGL/WebGLContextEvent)
LibWeb: Add WebGLFramebuffer
2024-11-13 09:46:25 +01:00
libweb_js_bindings(WebGL/WebGLFramebuffer)
LibWeb: Add WebGLObject interface
2024-11-13 09:31:46 +01:00
libweb_js_bindings(WebGL/WebGLObject)
LibWeb: Add WebGLProgram
2024-11-13 09:59:10 +01:00
libweb_js_bindings(WebGL/WebGLProgram)
LibWeb/WebGL: Add stub class for WebGLQuery This is a WebGL 2.0 class
2024-12-05 17:53:50 -07:00
libweb_js_bindings(WebGL/WebGLQuery)
LibWeb: Add WebGLRenderbuffer
2024-11-13 10:03:53 +01:00
libweb_js_bindings(WebGL/WebGLRenderbuffer)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(WebGL/WebGLRenderingContext)
LibWeb/WebGL: Add stub class for WebGLSampler This is a WebGL 2.0 class
2024-12-05 19:12:40 -07:00
libweb_js_bindings(WebGL/WebGLSampler)
LibWeb: Add WebGLShader
2024-11-13 10:06:07 +01:00
libweb_js_bindings(WebGL/WebGLShader)
LibWeb: Add WebGLShaderPrecisionFormat
2024-11-13 10:18:51 +01:00
libweb_js_bindings(WebGL/WebGLShaderPrecisionFormat)
LibWeb/WebGL: Add stub class for WebGLSync This is a WebGL 2.0 class
2024-12-05 19:18:40 -07:00
libweb_js_bindings(WebGL/WebGLSync)
LibWeb: Add WebGLTexture
2024-11-13 10:08:30 +01:00
libweb_js_bindings(WebGL/WebGLTexture)
LibWeb/WebGL: Add stub class for WebGLTransformFeedback This is a WebGL 2.0 class
2024-12-05 19:23:19 -07:00
libweb_js_bindings(WebGL/WebGLTransformFeedback)
LibWeb: Add WebGLUniformLocation
2024-11-13 10:11:08 +01:00
libweb_js_bindings(WebGL/WebGLUniformLocation)
LibWeb/WebGL: Add stub class for WebGLVertexArrayObject This is a WebGL 2.0 class
2024-12-05 19:25:39 -07:00
libweb_js_bindings(WebGL/WebGLVertexArrayObject)
LibWeb: Move DOMException from DOM/ to WebIDL/
2022-09-25 17:28:46 +01:00
libweb_js_bindings(WebIDL/DOMException)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(WebSockets/WebSocket)
LibWeb/WebVTT: Implement VTTCue idl interface
2024-09-19 21:49:54 +01:00
libweb_js_bindings(WebVTT/VTTCue)
LibWeb/WebVTT: Implement VTTRegion idl interface
2024-09-19 19:18:00 +01:00
libweb_js_bindings(WebVTT/VTTRegion)
LibWeb: Add FormDataIterator implementation This adds the FormDataIterator implementation so we can iterate over FormData.{keys(),values(),entries()}.
2023-03-05 17:29:11 +01:00
libweb_js_bindings(XHR/FormData ITERABLE)
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 18:22:16 +01:00
libweb_js_bindings(XHR/ProgressEvent)
libweb_js_bindings(XHR/XMLHttpRequest)
libweb_js_bindings(XHR/XMLHttpRequestEventTarget)
LibWeb: Refactor XHR (almost) exactly to the spec This makes XHR now rely on Fetch, which allows it to correct send Origin and Referer headers, CORS-preflight and filtering and many other goodies. The main thing that's missing is Streams, which means we can't properly produce progress events or switch to the Loading ready state. This also doesn't implement the Document responseType just yet.
2023-02-28 18:27:52 +00:00
libweb_js_bindings(XHR/XMLHttpRequestUpload)
Reference in a new issue Copy permalink