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

508 lines
21 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/CSP: Implement SecurityPolicyViolationEvent This is used to report violations of policies to the element/global object that caused it.
2024-11-26 15:43:02 +00:00
libweb_js_bindings(ContentSecurityPolicy/SecurityPolicyViolationEvent)
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)
LibWeb: Implement CookieChangeEvent
2025-08-07 15:31:24 +03:00
libweb_js_bindings(CookieStore/CookieChangeEvent)
LibWeb: Add initial CookieStore support
2025-08-04 22:17:20 +03:00
libweb_js_bindings(CookieStore/CookieStore)
LibWeb: Stub for Credential Management API Stub out basic Credential Management APIs and import IDL tests. Spec: https://w3c.github.io/webappsec-credential-management/
2025-01-30 22:29:26 +01:00
libweb_js_bindings(CredentialManagement/Credential)
libweb_js_bindings(CredentialManagement/CredentialsContainer)
libweb_js_bindings(CredentialManagement/FederatedCredential)
libweb_js_bindings(CredentialManagement/PasswordCredential)
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: Stub CSSCounterStyleRule Just the interface. Adds 6 new WPT subtest passes.
2025-07-18 10:53:55 +02:00
libweb_js_bindings(CSS/CSSCounterStyleRule)
LibWeb/CSS: Add CSSFontFaceDescriptors type This is a CSSOM type that holds the descriptors for a CSSFontFaceRule, but this commit only adds it without using it.
2025-04-03 11:44:06 +01:00
libweb_js_bindings(CSS/CSSFontFaceDescriptors)
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/CSSFontFaceRule)
libweb_js_bindings(CSS/CSSGroupingRule)
LibWeb/CSS: Implement CSSImageValue and reify images as it This is specced to be opaque, so there's not much to it.
2025-09-12 15:07:19 +01:00
libweb_js_bindings(CSS/CSSImageValue)
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/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: Implement CSSKeywordValue CSSStyleValue is adjusted to allow for subclasses. Serialization for CSSKeywordValue is implemented differently than the spec says because of a spec bug: https://github.com/w3c/csswg-drafts/issues/12545
2025-08-14 12:33:40 +01:00
libweb_js_bindings(CSS/CSSKeywordValue)
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)
LibWeb/CSS: Add basic implementation of CSSMarginRule This is a bit under-specced, specifically there's no definition of CSSMarginDescriptors so I've gone with CSSStyleProperties for now. Gets us 17 WPT subtests.
2025-05-15 11:48:56 +01:00
libweb_js_bindings(CSS/CSSMarginRule)
LibWeb/CSS: Implement CSSMathClamp As the final CSSMathFoo class, this makes the serialization test finally run instead of crashing.
2025-08-21 12:47:26 +01:00
libweb_js_bindings(CSS/CSSMathClamp)
LibWeb/CSS: Implement CSSMathInvert This is almost identical to CSSMathNegate.
2025-08-19 16:23:12 +01:00
libweb_js_bindings(CSS/CSSMathInvert)
LibWeb/CSS: Implement CSSMathMax Basically the same as CSSMathMin.
2025-08-19 17:18:12 +01:00
libweb_js_bindings(CSS/CSSMathMax)
LibWeb/CSS: Implement CSSMathMin
2025-08-19 17:07:05 +01:00
libweb_js_bindings(CSS/CSSMathMin)
LibWeb/CSS: Implement CSSMathNegate
2025-08-19 16:03:09 +01:00
libweb_js_bindings(CSS/CSSMathNegate)
LibWeb/CSS: Implement CSSMathProduct This is almost identical to CSSMathSum.
2025-08-19 15:35:09 +01:00
libweb_js_bindings(CSS/CSSMathProduct)
LibWeb/CSS: Implement CSSMathSum
2025-08-19 15:11:43 +01:00
libweb_js_bindings(CSS/CSSMathSum)
LibWeb/CSS: Implement CSSMathValue This is a base class for the various math functions, so it's not used directly anywhere.
2025-08-19 14:24:39 +01:00
libweb_js_bindings(CSS/CSSMathValue)
LibWeb/CSS: Implement CSSMatrixComponent Equivalent to the matrix() and matrix3d() transform functions. +19 WPT subtests.
2025-09-16 11:50:00 +01:00
libweb_js_bindings(CSS/CSSMatrixComponent)
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/CSS: Implement CSSNumericArray
2025-08-19 12:21:27 +01:00
libweb_js_bindings(CSS/CSSNumericArray)
LibWeb/CSS: Stub out CSSNumericValue Most of the methods on this rely on its subclasses existing, so for now it's very basic.
2025-08-19 13:55:42 +01:00
libweb_js_bindings(CSS/CSSNumericValue)
LibWeb: Add basic implementation of `@page` This doesn't support selectors, and the only descriptors for now are for margins.
2025-05-13 12:17:41 +01:00
libweb_js_bindings(CSS/CSSPageRule)
libweb_js_bindings(CSS/CSSPageDescriptors)
LibWeb/CSS: Implement CSSPerspective Equivalent to the perspective() transform function. +34 WPT subtests, and the transformvalue-normalization test now runs to completion instead of throwing an error - though its cases still fail until CSSTransformValue is implemented.
2025-09-16 11:05:33 +01:00
libweb_js_bindings(CSS/CSSPerspective)
LibWeb: Add and implement `CSSPropertyRule` IDL and bindings
2024-10-17 23:28:09 +01:00
libweb_js_bindings(CSS/CSSPropertyRule)
LibWeb/CSS: Implement CSSRotate Equivalent to the rotate() transform functions. +39 WPT subtests.
2025-09-15 12:58:09 +01:00
libweb_js_bindings(CSS/CSSRotate)
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/CSS: Implement CSSScale Equivalent to the scale() transform functions. +33 WPT subtests.
2025-09-15 14:31:03 +01:00
libweb_js_bindings(CSS/CSSScale)
LibWeb/CSS: Implement CSSSkew Equivalent to the skew() transform function. +39 WPT subtests.
2025-09-15 15:02:16 +01:00
libweb_js_bindings(CSS/CSSSkew)
LibWeb/CSS: Implement CSSSkewX Equivalent to the skewX() transform function. +27 WPT subtests.
2025-09-15 15:18:55 +01:00
libweb_js_bindings(CSS/CSSSkewX)
LibWeb/CSS: Implement CSSSkewY Equivalent to the skewY() transform function. +27 WPT subtests.
2025-09-15 15:33:37 +01:00
libweb_js_bindings(CSS/CSSSkewY)
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/CSSStyleDeclaration)
LibWeb/CSS: Merge style declaration subclasses into CSSStyleProperties We previously had PropertyOwningCSSStyleDeclaration and ResolvedCSSStyleDeclaration, representing the current style properties and resolved style respectively. Both of these were the CSSStyleDeclaration type in the CSSOM. (We also had ElementInlineCSSStyleDeclaration but I removed that in a previous commit.) In the meantime, the spec has changed so that these should now be a new CSSStyleProperties type in the CSSOM. Also, we need to subclass CSSStyleDeclaration for things like CSSFontFaceRule's list of descriptors, which means it wouldn't hold style properties. So, this commit does the fairly messy work of combining these two types into a new CSSStyleProperties class. A lot of what previously was done as separate methods in the two classes, now follows the spec steps of "if the readonly flag is set, do X" instead, which is hopefully easier to follow too. There is still some functionality in CSSStyleDeclaration that belongs in CSSStyleProperties, but I'll do that next. To avoid a huge diff for "CSSStyleDeclaration-all-supported-properties-and-default-values.txt" both here and in the following commit, we don't apply the (currently empty) CSSStyleProperties prototype yet.
2025-03-17 17:50:49 +00:00
libweb_js_bindings(CSS/CSSStyleProperties)
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/CSSStyleRule)
libweb_js_bindings(CSS/CSSStyleSheet)
LibWeb/CSS: Stub out CSSStyleValue
2025-08-08 12:57:23 +01:00
libweb_js_bindings(CSS/CSSStyleValue)
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/CSSSupportsRule)
LibWeb/CSS: Implement CSSTransformComponent This is a base type for the various transform functions. CSSMatrixComponent's to_string() can throw exceptions, so to_string() is implemented that way. https://github.com/w3c/fxtf-drafts/issues/611 +9 WPT subtests.
2025-09-12 16:32:58 +01:00
libweb_js_bindings(CSS/CSSTransformComponent)
LibWeb/CSS: Implement CSSTransformValue This is the final CSSStyleValue class used by the per-property test harness, so those now actually run instead of throwing an exception on load. 🎉 +39 WPT subtests. (Plus however many from the per-property tests finally running.) The two failing serialization tests are also failed by Safari in exactly the same way, so that seems more like a spec issue. (The spec is incomplete in quite a few places.) The failing subtest for toMatrix() is also a spec issue: is2D is handled oddly by CSSMatrixComponent and this subtest fails because of the `matrix` getter, which is unspecified. See https://github.com/w3c/css-houdini-drafts/issues/1155 for details.
2025-09-16 16:11:39 +01:00
libweb_js_bindings(CSS/CSSTransformValue)
LibWeb: Add the CSSTransition IDL object
2024-02-19 18:59:58 -07:00
libweb_js_bindings(CSS/CSSTransition)
LibWeb/CSS: Implement CSSTranslate Equivalent to the translate() transform functions. +34 WPT subtests.
2025-09-15 11:27:45 +01:00
libweb_js_bindings(CSS/CSSTranslate)
LibWeb/CSS: Implement CSSUnitValue
2025-08-18 15:12:55 +01:00
libweb_js_bindings(CSS/CSSUnitValue)
LibWeb/CSS: Implement CSSUnparsedValue and CSSVariableReferenceValue We don't serialize these the way WPT expects, because we don't implement the comment-insertion rules from CSS-Syntax. We don't implement that for regular serialization either, so it's something we can worry about later.
2025-08-14 16:43:12 +01:00
libweb_js_bindings(CSS/CSSUnparsedValue)
libweb_js_bindings(CSS/CSSVariableReferenceValue)
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)
LibWeb/CSS: Stub out StylePropertyMap
2025-08-11 15:11:49 +01:00
libweb_js_bindings(CSS/StylePropertyMap)
LibWeb/CSS: Stub out StylePropertyMapReadOnly Nothing yet produces this, and the useful parts of get() and get_all() will have to wait until type reification is implemented.
2025-08-11 14:28:57 +01:00
libweb_js_bindings(CSS/StylePropertyMapReadOnly)
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/CSS: Add the TransitionEvent type
2024-12-22 15:12:13 -05:00
libweb_js_bindings(CSS/TransitionEvent)
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)
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: Implement TextEncoderStream Required by the server-side rendering mode of React Router, used by https://chatgpt.com/ Note that the imported tests do not have the worker variants to prevent freezing on macOS.
2025-02-05 19:51:33 +00:00
libweb_js_bindings(Encoding/TextEncoderStream)
LibWeb/EME: Implement MediaKeySystemAccess
2025-07-31 12:43:03 +02:00
libweb_js_bindings(EncryptedMediaExtensions/MediaKeySystemAccess)
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: Implement `FileReaderSync` interface This interface allows the user to read File or Blob objects synchronously from inside workers.
2025-02-22 07:15:40 +00:00
libweb_js_bindings(FileAPI/FileReaderSync)
LibWeb: Stub Navigator.getGamepads()
2025-07-22 15:11:18 +02:00
libweb_js_bindings(Gamepad/Gamepad)
LibWeb: Implement the Gamepad API with SDL3
2025-08-18 17:27:00 +01:00
libweb_js_bindings(Gamepad/GamepadButton)
libweb_js_bindings(Gamepad/GamepadEvent)
libweb_js_bindings(Gamepad/GamepadHapticActuator)
LibWeb: Stub Geolocation API
2025-06-19 15:28:02 +02:00
libweb_js_bindings(Geolocation/Geolocation)
libweb_js_bindings(Geolocation/GeolocationCoordinates)
libweb_js_bindings(Geolocation/GeolocationPosition)
libweb_js_bindings(Geolocation/GeolocationPositionError)
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: Implement BarProp properties for Window
2025-03-04 22:51:08 +01:00
libweb_js_bindings(HTML/BarProp)
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/HTML: Implement `CommandEvent` class This implements the `CommandEvent` class.
2025-04-04 12:35:20 +02:00
libweb_js_bindings(HTML/CommandEvent)
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: Add CustomStateSet IDL type
2025-07-03 17:32:10 +01:00
libweb_js_bindings(HTML/CustomElements/CustomStateSet)
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)
LibWeb: Implement basics for OffscreenCanvas This implements the basic interface, classes and functions for OffscreenCanvas. Many are still stubbed out and have many FIXMEs in them, but it is a basic skeleton.
2025-03-07 00:19:45 +01:00
libweb_js_bindings(HTML/OffscreenCanvas)
libweb_js_bindings(HTML/OffscreenCanvasRenderingContext2D)
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)
LibWeb: Begin implementing SharedWorker Shared workers are essentially just workers that may be accessed from scripts within the same origin. There are plenty of FIXMEs here (mostly building on existing worker FIXMEs that are already in place), but this lets us run the shared worker variants of WPT tests.
2025-05-02 12:06:41 -04:00
libweb_js_bindings(HTML/SharedWorker)
libweb_js_bindings(HTML/SharedWorkerGlobalScope 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)
LibWeb: Move XMLSerializer into HTML directory The DOMParsing spec is in the process of being merged into the HTML one, gradually. The linked spec change moves XMLSerializer, but many of the algorithms are still in the DOMParsing spec so I've left the links to those alone. I've done my best to update the GN build but since I'm not actually using it, I might have done that wrong. Corresponds to https://github.com/whatwg/html/commit/2edb8cc7eefc6b918c181ea470350d9447423819
2025-03-03 13:04:14 +00:00
libweb_js_bindings(HTML/XMLSerializer)
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/IDB: Implement IDBCursorWithValue interface
2025-05-13 11:04:55 +02:00
libweb_js_bindings(IndexedDB/IDBCursorWithValue)
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/IDB: Implement IDBRecord
2025-07-09 14:35:33 +02:00
libweb_js_bindings(IndexedDB/IDBRecord)
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: 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 tests for Gamepad API by utilising virtual SDL3 joysticks
2025-08-18 17:28:06 +01:00
libweb_js_bindings(Internals/InternalGamepad)
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)
LibWeb+LibWebView+WebContent: Introduce a WebUI framework When we build internal pages (e.g. about:settings), there is currently quite a lot of boilerplate needed to communicate between the browser and the page. This includes creating IDL for the page and the IPC for every message sent between the processes. These internal pages are also special in that they have privileged access to and control over the browser process. The framework introduced here serves to ease the setup of new internal pages and to reduce the access that WebContent processes have to the browser process. WebUI pages can send requests to the browser process via a `ladybird.sendMessage` API. Responses from the browser are passed through a WebUIMessage event. So, for example, an internal page may: ladybird.sendMessage("getDataFor", { id: 123 }); document.addEventListener("WebUIMessage", event => { if (event.name === "gotData") { console.assert(event.data.id === 123); } }); To handle these messages, we set up a new IPC connection between the browser and WebContent processes. This connection is torn down when the user navigates away from the internal page.
2025-03-24 09:27:36 -04:00
libweb_js_bindings(Internals/WebUI)
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: Add a simplified Notification constructor This allows the Notification object to be created in javascript without any additional functionalities. It passes two wpt tests which require a call to the notification constructor with no arguments. https://wpt.live/notifications/constructor-basic.https.html https://wpt.live/notifications/constructor-invalid.https.html
2025-09-17 09:14:38 +02:00
libweb_js_bindings(NotificationsAPI/Notification)
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: Implement Resource Timing
2025-02-26 15:51:05 +00:00
libweb_js_bindings(ResourceTiming/PerformanceResourceTiming)
LibWeb: Stub WebSerial API
2025-08-06 09:07:40 +02:00
libweb_js_bindings(Serial/Serial)
libweb_js_bindings(Serial/SerialPort)
LibWeb: Stub CacheStorage interface With this change we can again open login form https://discord.com/login instead of failing in js because `caches.open()` is not defined.
2025-06-05 17:50:08 +02:00
libweb_js_bindings(ServiceWorker/CacheStorage)
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: Implement ReadableStream's async iterator
2025-04-12 13:19:05 -04:00
libweb_js_bindings(Streams/ReadableStream ASYNC_ITERABLE)
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: Implement TrustedHTML class The TrustedHTML interface represents a string that a developer can confidently insert into an injection sink that will render it as HTML. These objects are immutable wrappers around a string, constructed via a TrustedTypePolicy’s createHTML method.
2025-07-31 00:21:13 +02:00
libweb_js_bindings(TrustedTypes/TrustedHTML)
LibWeb: Implement TrustedScript type This turns out to be very similar to TrustedHTML.
2025-07-31 16:16:46 +02:00
libweb_js_bindings(TrustedTypes/TrustedScript)
LibWeb: Implement TrustedScriptURL class
2025-07-31 17:08:30 +02:00
libweb_js_bindings(TrustedTypes/TrustedScriptURL)
LibWeb: Add TrustedTypePolicy class It is mostly a skeleton with no actual implementation.
2025-07-31 02:03:29 +02:00
libweb_js_bindings(TrustedTypes/TrustedTypePolicy)
LibWeb: First implementation of the TrustedTypePolicyFactory Most of the functions are either not implemented of filled with dummy values.
2025-05-31 02:24:26 +02:00
libweb_js_bindings(TrustedTypes/TrustedTypePolicyFactory)
LibWeb: Add the bare minimum to render SVGAElement (`<a>`)
2024-06-23 17:05:47 +02:00
libweb_js_bindings(SVG/SVGAElement)
LibWeb: Add SVGAnimatedEnumeration
2025-02-21 13:22:15 +01:00
libweb_js_bindings(SVG/SVGAnimatedEnumeration)
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)
LibWeb: Add barebones SVGAnimationElement class Many wpt test on trusted-types relay on this class being defined to even begin the test as it declares some event handlers. This is not really an implementation but the most basic setup needed to run the tests.
2025-06-02 18:39:20 +02:00
libweb_js_bindings(SVG/SVGAnimationElement)
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/SVG: Add FEBlendElement
2025-07-04 20:55:08 +02:00
libweb_js_bindings(SVG/SVGFEBlendElement)
LibWeb: Implement `<feComposite>` SVG filter
2025-08-06 13:27:50 +01:00
libweb_js_bindings(SVG/SVGFECompositeElement)
LibWeb/SVG: Add FEFloodElement
2025-07-06 21:48:55 +02:00
libweb_js_bindings(SVG/SVGFEFloodElement)
LibWeb/SVG: Add FEGaussianBlurElement
2025-07-04 21:08:28 +02:00
libweb_js_bindings(SVG/SVGFEGaussianBlurElement)
LibWeb: Implement `<feImage>` SVG filter
2025-08-06 22:52:29 +01:00
libweb_js_bindings(SVG/SVGFEImageElement)
LibWeb: Implement `<feMerge>` SVG filter
2025-08-06 16:29:28 +02:00
libweb_js_bindings(SVG/SVGFEMergeElement)
libweb_js_bindings(SVG/SVGFEMergeNodeElement)
LibWeb: Implement `<feOffset>` SVG filter
2025-08-06 13:53:50 +02:00
libweb_js_bindings(SVG/SVGFEOffsetElement)
LibWeb: Add SVGFilterElement
2025-02-21 13:22:48 +01:00
libweb_js_bindings(SVG/SVGFilterElement)
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: Add SVGUnitTypes The empty `.h` is required since our generated bindings currently always try to include one.
2025-08-07 01:27:01 +02:00
libweb_js_bindings(SVG/SVGUnitTypes)
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)
LibWeb: Implement `SVGViewElement` This identifies a particular region of an SVG image, which can then be linked to by an SVG fragment identifier.
2025-07-12 14:26:50 +01:00
libweb_js_bindings(SVG/SVGViewElement)
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/URLPattern: Add initial stub for URLPattern interface
2025-01-05 23:33:26 +13:00
libweb_js_bindings(URLPattern/URLPattern)
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: Implement plumbing for view transitions This implements large parts of the CSS view-transitions-1 spec.
2025-03-23 12:38:21 +01:00
libweb_js_bindings(ViewTransition/ViewTransition)
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/WebAudio: Define and partially implement AnalyserNode https://webaudio.github.io/web-audio-api/#AnalyserNode Most of the interface is naively implemented. Container types probably need adjusted (Vector<double> is used for all the processing). A Fourier Transform is needed, but that's waiting on either a 3rd party library or a complex number type. There are lots of simple miscellaneous filters that need to be applied. It could be reasonable to implement from scratch, supposing that it can be parallelized. It might be hard to find one library with everything. Not my call though. Some additional scaffolding around blocks and render quanta is probably needed before this is developed much further, which probably comes in at the level of the AudioNode. Co-authored-by: Tim Ledbetter <tim.ledbetter@ladybird.org>
2024-09-18 09:09:18 -04:00
libweb_js_bindings(WebAudio/AnalyserNode)
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 ChannelMergerNode interface
2024-11-25 14:30:36 +01:00
libweb_js_bindings(WebAudio/ChannelMergerNode)
LibWeb: Add `ChannelSplitterNode` interface
2025-01-01 22:00:52 +00:00
libweb_js_bindings(WebAudio/ChannelSplitterNode)
LibWeb: Add `ConstantSourceNode` interface
2025-01-02 10:14:31 +00:00
libweb_js_bindings(WebAudio/ConstantSourceNode)
LibWeb/WebAudio: Add `DelayNode` interface
2025-01-03 23:42:22 +00:00
libweb_js_bindings(WebAudio/DelayNode)
LibWeb: Add BaseAudioContext::createScriptProcessor() This is a deprecated node, but it's still widely used on the web.
2025-07-25 09:45:13 +02:00
libweb_js_bindings(WebAudio/GainNode)
LibWeb: Add `MediaElementAudioSourceNode` interface
2025-01-15 23:07:00 +00:00
libweb_js_bindings(WebAudio/MediaElementAudioSourceNode)
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: Add BaseAudioContext::createScriptProcessor() This is a deprecated node, but it's still widely used on the web.
2025-07-25 09:45:13 +02:00
libweb_js_bindings(WebAudio/ScriptProcessorNode)
LibWeb: Add `StereoPannerNode` interface
2025-01-17 14:56:20 +00:00
libweb_js_bindings(WebAudio/StereoPannerNode)
LibWeb/WebGL: Move extensions into their own folder
2025-01-10 14:27:03 +00:00
libweb_js_bindings(WebGL/Extensions/ANGLEInstancedArrays)
LibWeb/WebGL: Implement EXT_blend_minmax extension
2025-04-07 16:47:26 +01:00
libweb_js_bindings(WebGL/Extensions/EXTBlendMinMax)
LibWeb/WebGL2: Implement EXT_color_buffer_float extension This makes the Point Of Sale model on https://www.shopify.com/ have colour instead of being completely black.
2025-03-05 17:13:52 +00:00
libweb_js_bindings(WebGL/Extensions/EXTColorBufferFloat)
LibWeb/WebGL: Move extensions into their own folder
2025-01-10 14:27:03 +00:00
libweb_js_bindings(WebGL/Extensions/OESVertexArrayObject)
LibWeb/WebGL: Implement WEBGL_compressed_texture_s3tc extension
2025-01-28 18:25:26 +00:00
libweb_js_bindings(WebGL/Extensions/WebGLCompressedTextureS3tc)
LibWeb/WebGL: Implement WEBGL_draw_buffers extension
2025-01-10 16:36:00 +00:00
libweb_js_bindings(WebGL/Extensions/WebGLDrawBuffers)
LibWeb/WebGL: Move extensions into their own folder
2025-01-10 14:27:03 +00:00
libweb_js_bindings(WebGL/Extensions/WebGLVertexArrayObjectOES)
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)
LibWeb: Implement stubs for XPathEvaluator
2025-09-29 21:48:38 +02:00
libweb_js_bindings(XPath/XPathResult)
libweb_js_bindings(XPath/XPathExpression)
libweb_js_bindings(XPath/XPathEvaluator)
Reference in a new issue Copy permalink