Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-19 07:33:20 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWeb/CSS/Properties.json

3036 lines
62 KiB
JSON
Raw Normal View History

LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
{
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
"-webkit-align-content": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "align-content"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-align-items": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "align-items"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-align-self": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "align-self"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-animation": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "animation"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-animation-delay": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "animation-delay"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-animation-direction": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "animation-direction"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-animation-duration": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "animation-duration"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-animation-fill-mode": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "animation-fill-mode"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-animation-iteration-count": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "animation-iteration-count"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-animation-name": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "animation-name"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-animation-play-state": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "animation-play-state"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-animation-timing-function": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "animation-timing-function"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
LibWeb: Make -webkit-appearance an alias for the appearance css property
2023-12-20 18:16:55 +01:00
"-webkit-appearance": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "appearance"
LibWeb: Make -webkit-appearance an alias for the appearance css property
2023-12-20 18:16:55 +01:00
},
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
"-webkit-background-clip": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "background-clip"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-background-origin": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "background-origin"
},
"-webkit-background-size": {
"legacy-alias-for": "background-size"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-border-bottom-left-radius": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "border-bottom-left-radius"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-border-bottom-right-radius": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "border-bottom-right-radius"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-border-radius": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "border-radius"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-border-top-left-radius": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "border-top-left-radius"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-border-top-right-radius": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "border-top-right-radius"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-box-shadow": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "box-shadow"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-box-sizing": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "box-sizing"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-flex": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "flex"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-flex-basis": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "flex-basis"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-flex-direction": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "flex-direction"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-flex-flow": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "flex-flow"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-flex-grow": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "flex-grow"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-flex-shrink": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "flex-shrink"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-flex-wrap": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "flex-wrap"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-justify-content": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "justify-content"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-mask": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "mask"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
LibWeb: Implement `mask-image` CSS property support Implemented by reusing AddMask display list item that was initially added for `background-clip` property. Progress on flashlight effect on https://null.com/games/athena-crisis
2024-11-16 03:25:48 +03:00
"-webkit-mask-image": {
"legacy-alias-for": "mask-image"
},
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
"-webkit-order": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "order"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
LibWeb: Add support for -webkit-text-fill-color
2024-07-07 19:41:18 -06:00
"-webkit-text-fill-color": {
"animation-type": "by-computed-value",
"inherited": true,
"initial": "currentColor",
LibWeb: Format Properties.json
2024-07-24 09:51:31 +01:00
"valid-types": [
"color"
]
LibWeb: Add support for -webkit-text-fill-color
2024-07-07 19:41:18 -06:00
},
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
"-webkit-transform": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "transform"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-transform-origin": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "transform-origin"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-transition": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "transition"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-transition-delay": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "transition-delay"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-transition-duration": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "transition-duration"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-transition-property": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "transition-property"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
"-webkit-transition-timing-function": {
LibWeb/CSS: Implement legacy name aliases for properties When a property is a "legacy name alias", any time it is used in CSS or via the CSSOM its aliased name is used instead. (See https://drafts.csswg.org/css-cascade-5/#legacy-name-alias) This means we only care about the alias when parsing a string as a PropertyID - and we can just return the PropertyID it is an alias for. No need for a distinct PropertyID for it, and no need for LibWeb to care about it at all. Previously, we had a bunch of these properties, which misused our code for "logical aliases", some of which I've discovered were not even fully implemented. But with this change, all that code can go away, and making a legacy alias is just a case of putting it in the JSON. This also shrinks `StyleProperties` as it doesn't need to contain data for these aliases, and removes a whole load of `-webkit-*` spam from the style inspector.
2024-09-27 12:54:08 +01:00
"legacy-alias-for": "transition-timing-function"
LibWeb: Add more legacy -webkit- aliases
2024-07-11 21:22:14 -06:00
},
LibWeb: Improve user-select support
2025-01-04 15:25:17 +01:00
"-webkit-user-select": {
"legacy-alias-for": "user-select"
},
LibWeb: Parse and plumb the `accent-color` CSS property
2023-03-18 20:49:00 +01:00
"accent-color": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Parse and plumb the `accent-color` CSS property
2023-03-18 20:49:00 +01:00
"inherited": true,
"initial": "auto",
"valid-types": [
"color"
],
"valid-identifiers": [
"auto"
]
},
LibWeb: Parse the CSS align-content property
2022-10-14 13:50:06 +02:00
"align-content": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Parse the CSS align-content property
2022-10-14 13:50:06 +02:00
"inherited": false,
LibWeb: Add support for "align-content: normal" in CSS parser
2024-01-04 08:13:37 +01:00
"initial": "normal",
LibWeb: Parse the CSS align-content property
2022-10-14 13:50:06 +02:00
"valid-types": [
"align-content"
]
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"align-items": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": false,
LibWeb: Make `align-items: normal` behave like `stretch` on flex items CSS-ALIGN-3 tells us that `normal` behavior inside flex containers is simply to behave as `stretch` so this patch makes them behave the same inside FFC. Furthermore, we change the `align-items` initial value to `normal`, matching other engines.
2023-08-20 16:39:49 +02:00
"initial": "normal",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"align-items"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
LibWeb: Honor `align-self` over `align-items` when non-auto on flex item
2022-07-11 23:52:36 +02:00
"align-self": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Honor `align-self` over `align-items` when non-auto on flex item
2022-07-11 23:52:36 +02:00
"inherited": false,
"initial": "auto",
"valid-types": [
"align-self"
]
},
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"animation": {
"affects-layout": true,
"inherited": false,
"initial": "none 0s ease 1 normal running 0s none",
"longhands": [
"animation-name",
"animation-duration",
"animation-timing-function",
"animation-iteration-count",
"animation-direction",
"animation-play-state",
"animation-delay",
"animation-fill-mode"
]
},
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"animation-delay": {
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"affects-layout": true,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "none",
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"inherited": false,
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"initial": "0s",
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"valid-types": [
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"time [-∞,∞]"
]
},
"animation-direction": {
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "none",
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"inherited": false,
"initial": "normal",
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"valid-identifiers": [
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"normal",
"reverse",
"alternate",
"alternate-reverse"
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
]
},
"animation-duration": {
"affects-layout": true,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "none",
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"inherited": false,
LibWeb: Allow `auto` as `animation-duration` and make that the default This is a spec change: https://github.com/w3c/csswg-drafts/commit/2a7cc4b58f903389926cb429af2f42307dced186
2023-06-09 14:25:32 +01:00
"initial": "auto",
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"valid-types": [
"time [0,∞]"
LibWeb: Allow `auto` as `animation-duration` and make that the default This is a spec change: https://github.com/w3c/csswg-drafts/commit/2a7cc4b58f903389926cb429af2f42307dced186
2023-06-09 14:25:32 +01:00
],
"valid-identifiers": [
"auto"
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
]
},
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"animation-fill-mode": {
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"affects-layout": true,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "none",
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"inherited": false,
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"initial": "none",
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"valid-identifiers": [
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"none",
"forwards",
"backwards",
"both"
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
]
},
"animation-iteration-count": {
"affects-layout": true,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "none",
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"inherited": false,
"initial": "1",
"valid-types": [
"number [0,∞]"
],
"valid-identifiers": [
"infinite"
]
},
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"animation-name": {
"affects-layout": true,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "none",
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"inherited": false,
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"initial": "none",
"valid-types": [
"string",
LibWeb/CSS: Add custom-ident blacklists to Properties.json These excluded values use a similar notation to the ranges for numeric types: `![foo,bar,baz]` to exclude `foo`, `bar`, and `baz`.
2025-02-24 14:59:03 +00:00
"custom-ident ![none]"
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
],
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"valid-identifiers": [
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"none"
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
]
},
"animation-play-state": {
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "none",
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"inherited": false,
"initial": "running",
"valid-identifiers": [
"running",
"paused"
]
},
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"animation-timing-function": {
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"affects-layout": true,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "none",
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"inherited": false,
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"initial": "ease",
LibWeb: Fully implement CSS animation-timing-function This implements all the timing functions, and hopefully all their quirks. Also changes the animation demo to use some funny cubic timing functions.
2023-07-06 16:56:25 +03:30
"valid-types": [
"easing-function"
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
]
},
LibWeb: Implement `appearance` CSS property This includes the "compat" values even though they are not strictly necessary.
2022-07-22 16:05:11 +01:00
"appearance": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Implement `appearance` CSS property This includes the "compat" values even though they are not strictly necessary.
2022-07-22 16:05:11 +01:00
"inherited": false,
"initial": "auto",
"valid-types": [
"appearance"
]
},
LibWeb: Parse `aspect-ratio` property Parse it, store the result in the ComputedValues, and also expose it to ResolvedCSSStyleDeclaration.
2023-06-08 15:25:16 +01:00
"aspect-ratio": {
"affects-layout": true,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Parse `aspect-ratio` property Parse it, store the result in the ComputedValues, and also expose it to ResolvedCSSStyleDeclaration.
2023-06-08 15:25:16 +01:00
"inherited": false,
"initial": "auto",
"valid-types": [
"ratio"
],
LibWeb: Make the linter happy in Properties.json There was a space missing and the linter complained.
2023-08-01 20:11:03 +02:00
"valid-identifiers": [
LibWeb: Parse `aspect-ratio` property Parse it, store the result in the ComputedValues, and also expose it to ResolvedCSSStyleDeclaration.
2023-06-08 15:25:16 +01:00
"auto"
]
},
LibWeb+Meta: Parse the `backdrop-filter` CSS property Note: The parsing and style value completely ignores the SVG filters part of the spec for now... That's a yak for another day :^)
2022-09-15 08:31:17 +01:00
"backdrop-filter": {
"affects-layout": false,
LibWeb: Establish stacking context when backdrop-filter is not 'none'
2022-10-24 16:05:10 +01:00
"affects-stacking-context": true,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "custom",
LibWeb+Meta: Parse the `backdrop-filter` CSS property Note: The parsing and style value completely ignores the SVG filters part of the spec for now... That's a yak for another day :^)
2022-09-15 08:31:17 +01:00
"inherited": false,
"initial": "none",
LibWeb: Fill in some missing property data and bodge extra types We don't yet have generic parsing support for `<filter-value-list>` or `<paint>`, so listing them here confuses the new StyleValue parsing code I'm working on. For now, let's skip `<filter-value-list>` since it's only used in one pkace which manually parses it, and list the parts of `<paint>` instead which are taken from here: https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint
2023-05-10 17:19:08 +01:00
"__comment": "FIXME: List `filter-value-list` as a valid-type once it's generically supported.",
LibWeb+Meta: Parse the `backdrop-filter` CSS property Note: The parsing and style value completely ignores the SVG filters part of the spec for now... That's a yak for another day :^)
2022-09-15 08:31:17 +01:00
"valid-identifiers": [
"none"
]
},
LibWeb: Add initial values and longhands to `background` definition There is no specified initial value, but `transparent` is equivalent to setting all the background properties to their defaults.
2021-11-10 13:29:41 +00:00
"background": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add initial values and longhands to `background` definition There is no specified initial value, but `transparent` is equivalent to setting all the background properties to their defaults.
2021-11-10 13:29:41 +00:00
"inherited": false,
"initial": "transparent",
"longhands": [
"background-attachment",
"background-clip",
"background-color",
"background-image",
"background-origin",
"background-position",
"background-repeat",
"background-size"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"background-attachment": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "scroll",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"background-attachment"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Parse `background-clip` and `background-origin` Including as part of the `background` shorthand. :^)
2021-11-03 20:28:34 +00:00
"background-clip": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "repeatable-list",
LibWeb: Parse `background-clip` and `background-origin` Including as part of the `background` shorthand. :^)
2021-11-03 20:28:34 +00:00
"inherited": false,
"initial": "border-box",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"background-box"
LibWeb: Parse `background-clip` and `background-origin` Including as part of the `background` shorthand. :^)
2021-11-03 20:28:34 +00:00
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"background-color": {
LibWeb: Annotate which CSS properties may affect layout This patch adds CSS::property_affects_layout(PropertyID) which tells us whether a CSS property would affect layout if it were changed. This will be used to avoid unnecessary relayout work when something changes that really only requires us to repaint the page. To mark a property as not affecting layout, set "affects-layout" to false in the corresponding Properties.json entry. Note that all properties affect layout by default.
2022-03-16 17:46:24 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "transparent",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
"color"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"hashless-hex-color"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"background-image": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "none",
"valid-types": [
"image"
],
"valid-identifiers": [
"none"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Parse `background-clip` and `background-origin` Including as part of the `background` shorthand. :^)
2021-11-03 20:28:34 +00:00
"background-origin": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "repeatable-list",
LibWeb: Parse `background-clip` and `background-origin` Including as part of the `background` shorthand. :^)
2021-11-03 20:28:34 +00:00
"inherited": false,
"initial": "padding-box",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"background-box"
LibWeb: Parse `background-clip` and `background-origin` Including as part of the `background` shorthand. :^)
2021-11-03 20:28:34 +00:00
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"background-position": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0% 0%",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"max-values": 4,
"valid-types": [
LibWeb: Merge background-position parsing into position code Implemented by adding the extra 3-value syntax as its own case and only running it when parsing background-position. I'm sure it could be implemented in a smarter way but this is still a bunch less code than before. :^)
2023-11-20 15:33:21 +00:00
"background-position"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Add longhand properties for background-position If background-position was not longhand enough for you, we've now got background-position-x and background-position-y :^)
2023-04-02 22:52:54 +01:00
"quirks": [
"unitless-length"
],
"longhands": [
"background-position-x",
"background-position-y"
LibWeb/CSS: Correct "percentages-resolve-to" data for properties These were missing for properties that take a `<position>`, and were incorrectly present for opacity-related properties.
2025-01-31 11:46:18 +00:00
],
"percentages-resolve-to": "length"
LibWeb: Add longhand properties for background-position If background-position was not longhand enough for you, we've now got background-position-x and background-position-y :^)
2023-04-02 22:52:54 +01:00
},
"background-position-x": {
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "repeatable-list",
"inherited": false,
LibWeb: Add longhand properties for background-position If background-position was not longhand enough for you, we've now got background-position-x and background-position-y :^)
2023-04-02 22:52:54 +01:00
"initial": "0%",
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add longhand properties for background-position If background-position was not longhand enough for you, we've now got background-position-x and background-position-y :^)
2023-04-02 22:52:54 +01:00
],
"valid-identifiers": [
"center",
"left",
"right"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
"percentages-resolve-to": "length"
LibWeb: Add longhand properties for background-position If background-position was not longhand enough for you, we've now got background-position-x and background-position-y :^)
2023-04-02 22:52:54 +01:00
},
"background-position-y": {
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "repeatable-list",
"inherited": false,
LibWeb: Add longhand properties for background-position If background-position was not longhand enough for you, we've now got background-position-x and background-position-y :^)
2023-04-02 22:52:54 +01:00
"initial": "0%",
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add longhand properties for background-position If background-position was not longhand enough for you, we've now got background-position-x and background-position-y :^)
2023-04-02 22:52:54 +01:00
],
"valid-identifiers": [
"center",
"bottom",
"top"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
"percentages-resolve-to": "length"
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"background-repeat": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Combine background-repeat-x/y pseudo-properties While right now this doesn't save much complexity, it will do once we care about multiple background layers per node. Then, having a single repeat value per layer will simplify things. It also means we can remove the pseudo-property concept entirely! :^)
2021-11-04 16:51:34 +00:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "repeat",
"max-values": 2,
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"repeat"
],
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-identifiers": [
"repeat-x",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"repeat-y"
LibWeb: Support two-value background-repeat The background-repeat value may be specified as either one- or two-value identifiers (to be interpreted as horizontal and vertical repeat). This adds two pseudo-properties, background-repeat-x and background-repeat-y, to handle this. One-value identifiers are mapped to two-value in accordance with the spec.
2021-04-05 12:05:35 -04:00
]
},
LibWeb: Parse `background-size` property
2021-11-05 13:44:37 +00:00
"background-size": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "repeatable-list",
LibWeb: Parse `background-size` property
2021-11-05 13:44:37 +00:00
"inherited": false,
"initial": "auto",
"max-values": 2,
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Parse `background-size` property
2021-11-05 13:44:37 +00:00
],
"valid-identifiers": [
"auto",
"cover",
"contain"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
"percentages-resolve-to": "length"
LibWeb: Parse `background-size` property
2021-11-05 13:44:37 +00:00
},
LibWeb/CSS: Implement the ({min,max}-)block-size properties These are heavily used by morrisons.com, using them in place of the usual properties these map to.
2025-01-29 14:17:52 +00:00
"block-size": {
"logical-alias-for": [
"height",
"width"
],
"initial": "auto",
"max-values": 1
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"border": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "medium currentcolor none",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"longhands": [
"border-width",
"border-style",
"border-color"
]
},
LibWeb: Expand border-{top,right,bottom-left} CSS shorthand properties This code is pretty rough, but it's something that will also improve with the eventual new CSS parser.
2020-06-10 16:14:31 +02:00
"border-bottom": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "medium currentcolor none",
LibWeb: Expand border-{top,right,bottom-left} CSS shorthand properties This code is pretty rough, but it's something that will also improve with the eventual new CSS parser.
2020-06-10 16:14:31 +02:00
"longhands": [
"border-bottom-width",
"border-bottom-style",
"border-bottom-color"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"border-bottom-color": {
LibWeb: Format Properties.json
2024-07-24 09:51:31 +01:00
"affects-layout": false,
"animation-type": "by-computed-value",
LibWeb: Make "currentcolor" lowercase in Properties.json It's technically case-insensitive, but the spec always defines it as "currentcolor" so it feels wrong to capitalise it differently there.
2021-09-16 20:59:45 +01:00
"initial": "currentcolor",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"inherited": false,
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"valid-types": [
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"color"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"hashless-hex-color"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
"border-bottom-left-radius": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Quote all initial values in Properties.json This is in preparation for parsing these into StyleValues automatically. Having them all be Strings makes the generation code simpler.
2021-08-16 17:09:34 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inherited": false,
"max-values": 2,
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
"percentages-resolve-to": "length"
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
},
"border-bottom-right-radius": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Quote all initial values in Properties.json This is in preparation for parsing these into StyleValues automatically. Having them all be Strings makes the generation code simpler.
2021-08-16 17:09:34 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inherited": false,
"max-values": 2,
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
"percentages-resolve-to": "length"
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"border-bottom-style": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"initial": "none",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inherited": false,
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"line-style"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-bottom-width": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"initial": "medium",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"medium",
"thick",
"thin"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"border-collapse": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"inherited": true,
"initial": "separate",
"valid-types": [
"border-collapse"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"border-color": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Correct some initial values and add missing ones - The `text-decoration-foo` values now match the spec. - Added values for `border-foo` since those are needed soon. - Make `color`'s initial value be `-libweb-palette-base-text`.
2021-09-17 17:18:06 +01:00
"initial": "currentcolor",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"longhands": [
"border-top-color",
"border-right-color",
"border-bottom-color",
"border-left-color"
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
],
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"max-values": 4,
"valid-types": [
"color"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"hashless-hex-color"
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
]
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"border-left": {
"inherited": false,
"initial": "medium currentcolor none",
"longhands": [
"border-left-width",
"border-left-style",
"border-left-color"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-left-color": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Make "currentcolor" lowercase in Properties.json It's technically case-insensitive, but the spec always defines it as "currentcolor" so it feels wrong to capitalise it differently there.
2021-09-16 20:59:45 +01:00
"initial": "currentcolor",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
"color"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"hashless-hex-color"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-left-style": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"initial": "none",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inherited": false,
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"line-style"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-left-width": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"initial": "medium",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"medium",
"thick",
"thin"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
"border-radius": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "0",
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
"longhands": [
"border-top-left-radius",
"border-top-right-radius",
"border-bottom-left-radius",
"border-bottom-right-radius"
LibWeb/CSS: Correct "percentages-resolve-to" data for properties These were missing for properties that take a `<position>`, and were incorrectly present for opacity-related properties.
2025-01-31 11:46:18 +00:00
],
"percentages-resolve-to": "length"
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"border-right": {
"inherited": false,
"initial": "medium currentcolor none",
"longhands": [
"border-right-width",
"border-right-style",
"border-right-color"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"border-right-color": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Make "currentcolor" lowercase in Properties.json It's technically case-insensitive, but the spec always defines it as "currentcolor" so it feels wrong to capitalise it differently there.
2021-09-16 20:59:45 +01:00
"initial": "currentcolor",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
"color"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"hashless-hex-color"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-right-style": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"initial": "none",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inherited": false,
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"line-style"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-right-width": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"initial": "medium",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"medium",
"thick",
"thin"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-spacing": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Correct initial values in Properties.json - `align-items`: `normal` is the initial value in the CSS-ALIGN spec, but `stretch` is in CSS-FLEXBOX. The FLEXBOX spec is the one we've actually implemented elsewhere, and ALIGN adds new values with special syntax, so it's not trivial to add it here. - `border-spacing`: `0` is equivalent to `0px 0px` and we don't yet parse the double-value syntax. - `text-decoration-thickness`: Had the wrong value.
2021-11-10 13:27:16 +00:00
"initial": "0",
LibWeb: Add CSS support for border-spacing property
2023-06-16 02:35:03 +00:00
"max-values": 2,
LibWeb: Fill in some missing property data and bodge extra types We don't yet have generic parsing support for `<filter-value-list>` or `<paint>`, so listing them here confuses the new StyleValue parsing code I'm working on. For now, let's skip `<filter-value-list>` since it's only used in one pkace which manually parses it, and list the parts of `<paint>` instead which are taken from here: https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint
2023-05-10 17:19:08 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [0,∞]"
LibWeb: Fill in some missing property data and bodge extra types We don't yet have generic parsing support for `<filter-value-list>` or `<paint>`, so listing them here confuses the new StyleValue parsing code I'm working on. For now, let's skip `<filter-value-list>` since it's only used in one pkace which manually parses it, and list the parts of `<paint>` instead which are taken from here: https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint
2023-05-10 17:19:08 +01:00
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-style": {
LibWeb: Correct some initial values and add missing ones - The `text-decoration-foo` values now match the spec. - Added values for `border-foo` since those are needed soon. - Make `color`'s initial value be `-libweb-palette-base-text`.
2021-09-17 17:18:06 +01:00
"initial": "none",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"longhands": [
"border-top-style",
"border-right-style",
"border-bottom-style",
"border-left-style"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"max-values": 4,
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"line-style"
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
]
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"border-top": {
"inherited": false,
"initial": "medium currentcolor none",
"longhands": [
"border-top-width",
"border-top-style",
"border-top-color"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"border-top-color": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Make "currentcolor" lowercase in Properties.json It's technically case-insensitive, but the spec always defines it as "currentcolor" so it feels wrong to capitalise it differently there.
2021-09-16 20:59:45 +01:00
"initial": "currentcolor",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"inherited": false,
LibWeb: Fill in some missing property data and bodge extra types We don't yet have generic parsing support for `<filter-value-list>` or `<paint>`, so listing them here confuses the new StyleValue parsing code I'm working on. For now, let's skip `<filter-value-list>` since it's only used in one pkace which manually parses it, and list the parts of `<paint>` instead which are taken from here: https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint
2023-05-10 17:19:08 +01:00
"valid-types": [
"color"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"hashless-hex-color"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
"border-top-left-radius": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Quote all initial values in Properties.json This is in preparation for parsing these into StyleValues automatically. Having them all be Strings makes the generation code simpler.
2021-08-16 17:09:34 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inherited": false,
"max-values": 2,
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
"percentages-resolve-to": "length"
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
},
"border-top-right-radius": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Quote all initial values in Properties.json This is in preparation for parsing these into StyleValues automatically. Having them all be Strings makes the generation code simpler.
2021-08-16 17:09:34 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inherited": false,
"max-values": 2,
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
"percentages-resolve-to": "length"
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"border-top-style": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"initial": "none",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inherited": false,
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"line-style"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-top-width": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"initial": "medium",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"medium",
"thick",
"thin"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-width": {
LibWeb: Correct some initial values and add missing ones - The `text-decoration-foo` values now match the spec. - Added values for `border-foo` since those are needed soon. - Make `color`'s initial value be `-libweb-palette-base-text`.
2021-09-17 17:18:06 +01:00
"initial": "medium",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"longhands": [
"border-top-width",
"border-right-width",
"border-bottom-width",
"border-left-width"
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
],
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"max-values": 4,
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"medium",
"thick",
"thin"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
]
},
"bottom": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"box-shadow": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "custom",
LibWeb: Add box-shadow as a known ValueID
2021-07-23 21:21:39 +02:00
"inherited": false,
LibWeb: Parse "none" value for box-shadow property Previously, `box-shadow: none` would fail to parse, meaning that in this example: ```css p { box-shadow: 20px 10px 5px magenta; } p.foo { box-shadow: none; } ``` ... a `<p class="foo">` would still have a box-shadow, when it should not have one. Now, we handle the `none` value. :^)
2021-10-15 19:25:27 +01:00
"initial": "none",
"valid-identifiers": [
"none"
]
LibWeb: Add box-shadow as a known ValueID
2021-07-23 21:21:39 +02:00
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"box-sizing": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "content-box",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"box-sizing"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"caption-side": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "top",
LibWeb: Add support for table caption Adds layout support and the CSS caption-side property.
2023-06-07 02:10:55 +00:00
"valid-types": [
"caption-side"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"clear": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "none",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"clear"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"clip": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb/CSS: Set "inherited" to false for "clip" property "clip" should not be inherited.
2023-08-23 13:48:57 +02:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-identifiers": [
"auto"
],
LibWeb: Parse rect style value Add ability to parse a rect when it is used as the value of a style property.
2022-07-31 18:46:35 +02:00
"valid-types": [
"rect"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add the `clip-path` property and resolve it for SVG elements
2024-03-27 00:06:35 +00:00
"clip-path": {
"animation-type": "none",
"affects-layout": false,
"affects-stacking-context": true,
"inherited": false,
"valid-identifiers": [
"none"
],
"__comment": "FIXME: This should be a <clip-source> | [ <basic-shape> || <geometry-box> ]",
"valid-types": [
LibWeb: Resolve `basic-shape` clip-paths These will be ignored within SVGs (for now SVGs only support <clipPath> elements), but will allow clipping standard HTML elements.
2024-05-26 00:25:05 +01:00
"basic-shape",
LibWeb: Add the `clip-path` property and resolve it for SVG elements
2024-03-27 00:06:35 +00:00
"url"
],
"initial": "none"
},
LibWeb: Implement the SVG `clip-rule` attribute This controls the fill rule used when rasterizing `<clipPath>` elements.
2024-05-12 20:19:43 +01:00
"clip-rule": {
"affects-layout": false,
"animation-type": "discrete",
"inherited": true,
"initial": "nonzero",
LibWeb: Format Properties.json
2024-07-24 09:51:31 +01:00
"valid-types": [
"fill-rule"
]
LibWeb: Implement the SVG `clip-rule` attribute This controls the fill rule used when rasterizing `<clipPath>` elements.
2024-05-12 20:19:43 +01:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"color": {
LibWeb: Annotate which CSS properties may affect layout This patch adds CSS::property_affects_layout(PropertyID) which tells us whether a CSS property would affect layout if it were changed. This will be used to avoid unnecessary relayout work when something changes that really only requires us to repaint the page. To mark a property as not affecting layout, set "affects-layout" to false in the corresponding Properties.json entry. Note that all properties affect layout by default.
2022-03-16 17:46:24 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb/CSS: Set initial value of color property to `canvastext` Previously the non-standard value `-libweb-palette-base-text` was used.
2024-07-05 19:55:07 +01:00
"initial": "canvastext",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
"color"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"hashless-hex-color"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb/CSS: Implement the color-scheme CSS property
2025-01-02 12:59:09 +11:00
"color-scheme": {
"affects-layout": false,
"animation-type": "discrete",
"inherited": true,
LibWeb/CSS: Add custom-ident blacklists to Properties.json These excluded values use a similar notation to the ranges for numeric types: `![foo,bar,baz]` to exclude `foo`, `bar`, and `baz`.
2025-02-24 14:59:03 +00:00
"initial": "normal",
"valid-types": [
"custom-ident ![normal,light,dark,only]"
],
"valid-identifiers": [
"normal",
"light",
"dark"
]
LibWeb/CSS: Implement the color-scheme CSS property
2025-01-02 12:59:09 +11:00
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"column-count": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
"inherited": false,
"initial": "auto",
"valid-types": [
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"integer [1,∞]"
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
],
"valid-identifiers": [
"auto"
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
]
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"column-gap": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Implement support for parsing CSS column-count property
2023-09-06 18:30:57 +02:00
"inherited": false,
LibWeb: Restrict CSS gap properties to values allowed by the spec Gap values are now represented by Variant<LengthPercentage, NormalGap>. NormalGap is just an empty struct to represent the `normal` keyword. This fixes a long-standing issue where we were incorrectly storing gaps as CSS::Size, which led to us allowing a bunch of invalid gap values.
2024-11-09 17:38:09 +01:00
"initial": "normal",
LibWeb: Implement support for parsing CSS column-count property
2023-09-06 18:30:57 +02:00
"valid-types": [
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Implement support for parsing CSS column-count property
2023-09-06 18:30:57 +02:00
],
"valid-identifiers": [
LibWeb: Restrict CSS gap properties to values allowed by the spec Gap values are now represented by Variant<LengthPercentage, NormalGap>. NormalGap is just an empty struct to represent the `normal` keyword. This fixes a long-standing issue where we were incorrectly storing gaps as CSS::Size, which led to us allowing a bunch of invalid gap values.
2024-11-09 17:38:09 +01:00
"normal"
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
],
"percentages-resolve-to": "length"
LibWeb: Implement support for parsing CSS column-count property
2023-09-06 18:30:57 +02:00
},
LibWeb: Support parsing column-span
2024-08-20 20:23:55 -04:00
"column-span": {
"animation-type": "discrete",
"inherited": false,
"initial": "none",
"valid-types": [
"column-span"
]
},
LibWeb: Support parsing column-width
2024-08-20 19:58:14 -04:00
"column-width": {
"animation-type": "by-computed-value",
"inherited": false,
"initial": "auto",
"valid-types": [
"length [0,∞]"
],
"valid-identifiers": [
"auto"
]
},
LibWeb: Support parsing columns
2024-08-21 11:09:08 -04:00
"columns": {
"inherited": false,
"initial": "auto auto",
"longhands": [
"column-width",
"column-count"
]
},
LibWeb: Implement CSS 'contain' property
2025-01-18 20:39:26 +01:00
"contain": {
"__comment": "FIXME: Some values of contain need to be mutually exclusive. The grammar this should adhere to is 'none | strict | content | [ [size | inline-size] || layout || style || paint ]'.",
"affects-stacking-context": true,
"animation-type": "none",
"inherited": false,
"initial": "none",
"valid-types": [
"contain"
]
},
LibWeb: Parse the `content` property For now, we only understand `none`, `normal`, `<image>` and `<string>`. The various other functions and identifiers can be added later. We can *almost* use a StyleValueList for this, except it's divided into two parts - the content, and the optional "alt text". So, I've added a new StyleValue for it.
2022-02-23 19:56:25 +00:00
"content": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Parse the `content` property For now, we only understand `none`, `normal`, `<image>` and `<string>`. The various other functions and identifiers can be added later. We can *almost* use a StyleValueList for this, except it's divided into two parts - the content, and the optional "alt text". So, I've added a new StyleValue for it.
2022-02-23 19:56:25 +00:00
"inherited": false,
"initial": "normal",
"__comment": "FIXME: This accepts a whole lot of other types and identifiers!",
"valid-types": [
LibWeb: Implement CounterStyleValue This is `counter(name, style?)` or `counters(name, link, style?)`. The difference being, `counter()` matches only the nearest level (eg, "1"), and `counters()` combines all the levels in the tree (eg, "3.4.1").
2024-07-24 14:56:16 +01:00
"counter",
LibWeb: Parse the `content` property For now, we only understand `none`, `normal`, `<image>` and `<string>`. The various other functions and identifiers can be added later. We can *almost* use a StyleValueList for this, except it's divided into two parts - the content, and the optional "alt text". So, I've added a new StyleValue for it.
2022-02-23 19:56:25 +00:00
"string"
],
"valid-identifiers": [
"normal",
LibWeb: Support quotes in `content` values This adds initial support for `open-quote`, `close-quote`, `no-open-quote` and `no-close-quote`. We don't yet track the "nesting level" so we always use the first pair of quotes from the `quotes` property.
2023-09-12 14:22:46 +01:00
"none",
"open-quote",
"close-quote",
"no-open-quote",
"no-close-quote"
LibWeb: Parse the `content` property For now, we only understand `none`, `normal`, `<image>` and `<string>`. The various other functions and identifiers can be added later. We can *almost* use a StyleValueList for this, except it's divided into two parts - the content, and the optional "alt text". So, I've added a new StyleValue for it.
2022-02-23 19:56:25 +00:00
]
},
LibWeb: Support content-visibility css
2024-06-23 14:52:56 +02:00
"content-visibility": {
"animation-type": "none",
"__comment": "FIXME: Implement animation https://drafts.csswg.org/css-contain/#content-visibility-animation",
"inherited": false,
"initial": "visible",
"valid-types": [
"content-visibility"
]
},
LibWeb: Implement counter-[increment,reset,set] properties These control the state of CSS counters. Parsing code for `reversed(counter-name)` is implemented, but disabled for now until we are able to resolve values for those.
2024-07-24 15:47:11 +01:00
"counter-increment": {
"animation-type": "by-computed-value",
"inherited": false,
"initial": "none",
"valid-types": [
LibWeb/CSS: Add custom-ident blacklists to Properties.json These excluded values use a similar notation to the ranges for numeric types: `![foo,bar,baz]` to exclude `foo`, `bar`, and `baz`.
2025-02-24 14:59:03 +00:00
"custom-ident ![none]",
LibWeb: Implement counter-[increment,reset,set] properties These control the state of CSS counters. Parsing code for `reversed(counter-name)` is implemented, but disabled for now until we are able to resolve values for those.
2024-07-24 15:47:11 +01:00
"integer [-∞,∞]"
],
"valid-identifiers": [
"none"
]
},
"counter-reset": {
"animation-type": "by-computed-value",
"inherited": false,
"initial": "none",
"valid-types": [
LibWeb/CSS: Add custom-ident blacklists to Properties.json These excluded values use a similar notation to the ranges for numeric types: `![foo,bar,baz]` to exclude `foo`, `bar`, and `baz`.
2025-02-24 14:59:03 +00:00
"custom-ident ![none]",
LibWeb: Implement counter-[increment,reset,set] properties These control the state of CSS counters. Parsing code for `reversed(counter-name)` is implemented, but disabled for now until we are able to resolve values for those.
2024-07-24 15:47:11 +01:00
"integer [-∞,∞]"
],
"valid-identifiers": [
"none"
]
},
"counter-set": {
"animation-type": "by-computed-value",
"inherited": false,
"initial": "none",
"valid-types": [
LibWeb/CSS: Add custom-ident blacklists to Properties.json These excluded values use a similar notation to the ranges for numeric types: `![foo,bar,baz]` to exclude `foo`, `bar`, and `baz`.
2025-02-24 14:59:03 +00:00
"custom-ident ![none]",
LibWeb: Implement counter-[increment,reset,set] properties These control the state of CSS counters. Parsing code for `reversed(counter-name)` is implemented, but disabled for now until we are able to resolve values for those.
2024-07-24 15:47:11 +01:00
"integer [-∞,∞]"
],
"valid-identifiers": [
"none"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"cursor": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "auto",
"valid-types": [
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"url",
"cursor"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Define the rest of the SVG geometry properties This defines all the (remaining) geometry properties from https://svgwg.org/svg2-draft/geometry.html#Sizing.
2023-02-25 10:31:00 +01:00
"cx": {
"__comment": "This is an SVG 2 geometry property, see: https://www.w3.org/TR/SVG/geometry.html#CX.",
"animation-type": "by-computed-value",
"inherited": false,
"initial": "0",
"valid-types": [
"length [-∞,∞]",
"percentage [-∞,∞]"
],
"percentages-resolve-to": "length",
"quirks": [
"unitless-length"
]
},
"cy": {
"__comment": "This is an SVG 2 geometry property, see: https://www.w3.org/TR/SVG/geometry.html#CY.",
"animation-type": "by-computed-value",
"inherited": false,
"initial": "0",
"valid-types": [
"length [-∞,∞]",
"percentage [-∞,∞]"
],
"percentages-resolve-to": "length",
"quirks": [
"unitless-length"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"direction": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "none",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "ltr",
LibWeb: Use reverse direction on flex containers with `rtl` direction If a flex container has `direction: rtl` set, reverse the row direction.
2024-08-10 23:13:26 +01:00
"valid-types": [
"direction"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"display": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "custom",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "inline",
LibWeb: Set max-values for display CSS property
2023-04-26 19:49:02 +02:00
"max-values": 3,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-identifiers": [
LibWeb: Move `<display-foo>` definitions into Enums.json This eliminates a fair bit of boilerplate.
2023-09-04 17:39:15 +01:00
"list-item"
],
"valid-types": [
"display-outside",
"display-inside",
"display-internal",
"display-box",
"display-legacy"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"fill": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "none",
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "black",
"valid-types": [
LibWeb: Add parsing for CSS `<paint>` values This gets rid of a couple of FIXMEs in Properties.json :^)
2023-06-15 16:37:36 +01:00
"paint"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
"fill-opacity": {
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
"inherited": true,
"initial": "1",
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"number [-∞,∞]",
"percentage [-∞,∞]"
LibWeb/CSS: Correct "percentages-resolve-to" data for properties These were missing for properties that take a `<position>`, and were incorrectly present for opacity-related properties.
2025-01-31 11:46:18 +00:00
]
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
},
LibWeb: Implement SVG `fill-rule` attribute Previously, we did an evenodd fill for everything which while for most SVGs works, it is not correct default (it should be nonzero), and broke some SVGs. This fixes a few of the icons on https://shopify.com/.
2023-06-11 16:43:46 +01:00
"fill-rule": {
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Implement SVG `fill-rule` attribute Previously, we did an evenodd fill for everything which while for most SVGs works, it is not correct default (it should be nonzero), and broke some SVGs. This fixes a few of the icons on https://shopify.com/.
2023-06-11 16:43:46 +01:00
"inherited": true,
"initial": "nonzero",
LibWeb: Format Properties.json
2024-07-24 09:51:31 +01:00
"valid-types": [
"fill-rule"
]
LibWeb: Implement SVG `fill-rule` attribute Previously, we did an evenodd fill for everything which while for most SVGs works, it is not correct default (it should be nonzero), and broke some SVGs. This fixes a few of the icons on https://shopify.com/.
2023-06-11 16:43:46 +01:00
},
LibWeb: Parse and store `filter` property This shares its implementation with `backdrop-filter`.
2024-10-25 11:00:22 +02:00
"filter": {
"affects-layout": false,
"animation-type": "custom",
"inherited": false,
"initial": "none",
"__comment": "FIXME: List `filter-value-list` as a valid-type once it's generically supported.",
"valid-identifiers": [
"none"
]
},
LibWeb: Parse and resolve flex: shorthand
2021-06-01 15:50:17 +02:00
"flex": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "0 1 auto",
LibWeb: Use new StyleValue parsing for flex To make this work, we also add `none` as a valid identifier for `flex`. (This is correct, we just didn't need it before.)
2023-05-18 16:21:10 +01:00
"valid-identifiers": [
"none"
],
LibWeb: Parse and resolve flex: shorthand
2021-06-01 15:50:17 +02:00
"longhands": [
"flex-grow",
"flex-shrink",
"flex-basis"
]
},
LibWeb: Parse flex-basis Flex-basis accepts either 'content' or a Length.
2021-05-30 14:23:43 +02:00
"flex-basis": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Parse flex-basis Flex-basis accepts either 'content' or a Length.
2021-05-30 14:23:43 +02:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "auto",
"valid-types": [
LibWeb: Parse CSS fit-content(<length-percentage>) values Before this change, we only parsed fit-content as a standalone keyword, but CSS-SIZING-3 added it as a function as well. I don't know of anything else in CSS that is overloaded like this, so it ends up looking a little awkward in the implementation. Note that a lot of code had already been prepped for fit-content values to have an argument, we just weren't parsing it.
2025-02-26 18:16:36 +01:00
"fit-content",
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto",
LibWeb: Allow flex-basis: {min,max,fit}-content
2024-06-23 15:36:51 +02:00
"content",
"max-content",
"min-content"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
"percentages-resolve-to": "length"
LibWeb: Parse flex-basis Flex-basis accepts either 'content' or a Length.
2021-05-30 14:23:43 +02:00
},
LibWeb: Parse the CSS "flex-direction" property
2021-01-18 17:41:57 +01:00
"flex-direction": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Parse the CSS "flex-direction" property
2021-01-18 17:41:57 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "row",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"flex-direction"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Parse the CSS "flex-direction" property
2021-01-18 17:41:57 +01:00
},
LibWeb: Parse and resolve flex-flow property
2021-05-30 12:25:10 +02:00
"flex-flow": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "row nowrap",
LibWeb: Parse and resolve flex-flow property
2021-05-30 12:25:10 +02:00
"longhands": [
"flex-direction",
"flex-wrap"
]
},
LibWeb: Add flex-grow and flex-shrink They get parsed and are available to the programmer of Layouts :^)
2021-05-30 20:22:25 +02:00
"flex-grow": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Add flex-grow and flex-shrink They get parsed and are available to the programmer of Layouts :^)
2021-05-30 20:22:25 +02:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "0",
"valid-types": [
LibWeb: Reject negative values for `flex-grow` and `flex-shrink`
2022-07-18 21:52:30 +02:00
"number [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add flex-grow and flex-shrink They get parsed and are available to the programmer of Layouts :^)
2021-05-30 20:22:25 +02:00
},
"flex-shrink": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Add flex-grow and flex-shrink They get parsed and are available to the programmer of Layouts :^)
2021-05-30 20:22:25 +02:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "1",
"valid-types": [
LibWeb: Reject negative values for `flex-grow` and `flex-shrink`
2022-07-18 21:52:30 +02:00
"number [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add flex-grow and flex-shrink They get parsed and are available to the programmer of Layouts :^)
2021-05-30 20:22:25 +02:00
},
LibWeb: Add parsing for flex-wrap property
2021-05-30 12:11:32 +02:00
"flex-wrap": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Add parsing for flex-wrap property
2021-05-30 12:11:32 +02:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "nowrap",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"flex-wrap"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add parsing for flex-wrap property
2021-05-30 12:11:32 +02:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"float": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "none",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"float"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Start parsing font property
2021-04-13 20:41:57 +03:00
"font": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": true,
LibWeb/CSS: Use `serif` for font and font-family initial property values These properties previously used sans-serif for their initial values.
2024-07-05 19:59:18 +01:00
"initial": "normal medium serif",
LibWeb/CSS: Parse and propagate the font-language-override property
2024-09-27 17:11:05 +01:00
"__comment": "FIXME: Handle properties that are reset implicitly. https://drafts.csswg.org/css-fonts/#reset-implicitly",
LibWeb: Start parsing font property
2021-04-13 20:41:57 +03:00
"longhands": [
"font-family",
"font-size",
LibWeb/CSS: Make font-stretch a legacy alias for new font-width CSS Fonts level 4 renames font-stretch to font-width, with font-stretch being left as a legacy alias. Unfortunately the other specs have not yet been updated, so both terms are used in different places.
2024-09-27 14:04:59 +01:00
"font-width",
LibWeb: Fill out `font` property data
2023-09-26 16:17:02 +01:00
"font-style",
LibWeb: Start parsing font property
2021-04-13 20:41:57 +03:00
"font-variant",
LibWeb: Fill out `font` property data
2023-09-26 16:17:02 +01:00
"font-weight",
"line-height"
LibWeb: Start parsing font property
2021-04-13 20:41:57 +03:00
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"font-family": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb/CSS: Use `serif` for font and font-family initial property values These properties previously used sans-serif for their initial values.
2024-07-05 19:59:18 +01:00
"initial": "serif",
LibWeb: Allow font-family names to start with `-` We achieve this by making properties that accept a custom-ident value skip the "someone else's vendor prefix" check for values that start with a `-` character. This fixes an issue where e.g `font-family: Arial, -apple-system` would be rejected by the parser completely. We now treat `-apple-system` like an identifier in such cases. Also add `valid-types` metadata for the `font-family` property so this actually works. :^)
2023-07-06 13:05:48 +02:00
"valid-types": [
"custom-ident",
"string"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb/CSS: Parse and propagate font-feature-settings property
2024-10-01 09:37:43 +01:00
"font-feature-settings": {
"animation-type": "discrete",
"inherited": true,
"initial": "normal",
"valid-types": [
"integer [0,∞]",
"opentype-tag"
],
"valid-identifiers": [
"normal",
"on",
"off"
]
},
LibWeb/CSS: Parse and propagate the font-language-override property
2024-09-27 17:11:05 +01:00
"font-language-override": {
"animation-type": "discrete",
"inherited": true,
"initial": "normal",
"valid-types": [
"string"
],
"valid-identifiers": [
"normal"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"font-size": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "medium",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"large",
"larger",
"medium",
"small",
"smaller",
"x-large",
"x-small",
"xx-large",
"xx-small",
LibWeb: Implement `font-size: math` This is a MathML extension, basically a big hack to make parts of equations smaller, such as sub/superscripts. The important thing is, it works. :^)
2023-09-07 17:39:07 +01:00
"xxx-large",
"math"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Parse font-stretch CSS property
2023-02-03 14:27:09 +03:00
"font-stretch": {
LibWeb/CSS: Make font-stretch a legacy alias for new font-width CSS Fonts level 4 renames font-stretch to font-width, with font-stretch being left as a legacy alias. Unfortunately the other specs have not yet been updated, so both terms are used in different places.
2024-09-27 14:04:59 +01:00
"legacy-alias-for": "font-width"
LibWeb: Parse font-stretch CSS property
2023-02-03 14:27:09 +03:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"font-style": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "custom",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "normal",
"valid-identifiers": [
"italic",
"normal",
"oblique"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"font-variant": {
LibWeb: Add font-variant-* css properties
2024-11-07 16:27:04 +01:00
"inherited": true,
"initial": "normal",
"longhands": [
"font-variant-alternates",
"font-variant-caps",
"font-variant-east-asian",
"font-variant-emoji",
"font-variant-ligatures",
"font-variant-numeric",
"font-variant-position"
],
"valid-types": [
"string"
]
},
"font-variant-alternates": {
"animation-type": "discrete",
"inherited": true,
"initial": "normal",
"valid-types": [
"font-variant-alternates"
]
},
"font-variant-caps": {
"animation-type": "discrete",
"inherited": true,
"initial": "normal",
"valid-types": [
"font-variant-caps"
]
},
"font-variant-east-asian": {
"animation-type": "discrete",
"inherited": true,
"initial": "normal",
"valid-types": [
"font-variant-east-asian"
]
},
"font-variant-emoji": {
"animation-type": "discrete",
"inherited": true,
"initial": "normal",
"valid-types": [
"font-variant-emoji"
]
},
"font-variant-ligatures": {
"animation-type": "discrete",
"inherited": true,
"initial": "normal",
"valid-types": [
"font-variant-ligatures"
]
},
"font-variant-numeric": {
"animation-type": "discrete",
"inherited": true,
"initial": "normal",
"valid-types": [
"font-variant-numeric"
]
},
"font-variant-position": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "normal",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
LibWeb: Add font-variant-* css properties
2024-11-07 16:27:04 +01:00
"font-variant-position"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb/CSS: Parse and propagate font-variation-settings property
2024-10-01 09:20:06 +01:00
"font-variation-settings": {
"animation-type": "custom",
"inherited": true,
"initial": "normal",
"valid-types": [
"number",
"opentype-tag"
],
"valid-identifiers": [
"normal"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"font-weight": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "normal",
"valid-types": [
LibWeb: Add range-checking to property_accepts_value() For `number` and `integer` types, you can add a range afterwards to add a range check, using similar syntax to that used in the CSS specs. For example: ```json "font-weight": { ... "valid-types": [ "number [1,1000]" ], ... } ``` This limits any numbers to the range `1 <= n <= 1000`.
2021-09-23 12:45:08 +01:00
"number [1,1000]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"bold",
"bolder",
"lighter",
"normal"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb/CSS: Make font-stretch a legacy alias for new font-width CSS Fonts level 4 renames font-stretch to font-width, with font-stretch being left as a legacy alias. Unfortunately the other specs have not yet been updated, so both terms are used in different places.
2024-09-27 14:04:59 +01:00
"font-width": {
"animation-type": "by-computed-value",
"inherited": true,
"initial": "normal",
"valid-types": [
"percentage [0,∞]",
"font-width"
]
},
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
"gap": {
"inherited": false,
LibWeb: Restrict CSS gap properties to values allowed by the spec Gap values are now represented by Variant<LengthPercentage, NormalGap>. NormalGap is just an empty struct to represent the `normal` keyword. This fixes a long-standing issue where we were incorrectly storing gaps as CSS::Size, which led to us allowing a bunch of invalid gap values.
2024-11-09 17:38:09 +01:00
"initial": "normal",
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
"valid-types": [
"length [0,∞]",
"percentage [0,∞]"
],
"max-values": 2,
"valid-identifiers": [
LibWeb: Restrict CSS gap properties to values allowed by the spec Gap values are now represented by Variant<LengthPercentage, NormalGap>. NormalGap is just an empty struct to represent the `normal` keyword. This fixes a long-standing issue where we were incorrectly storing gaps as CSS::Size, which led to us allowing a bunch of invalid gap values.
2024-11-09 17:38:09 +01:00
"normal"
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
"longhands": [
"row-gap",
"column-gap"
]
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"grid": {
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"length",
"percentage",
"string"
],
"percentages-resolve-to": "length",
"longhands": [
LibWeb: Correct longhands for `grid` property These three are the ones that ShorthandStyleValue uses to serialize `grid`, so let's use them here. The spec also mentions `grid-auto-*` properties as being set by `grid`, but I'll leave that for someone who understands grid better.
2023-09-26 15:59:01 +01:00
"grid-template-areas",
"grid-template-rows",
"grid-template-columns"
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
]
},
LibWeb: Parse `grid-area` CSS property
2023-01-16 19:02:39 +01:00
"grid-area": {
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"string"
],
"longhands": [
"grid-column-end",
"grid-column-start",
"grid-row-end",
"grid-row-start"
]
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"grid-auto-columns": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"length",
"percentage",
"string"
],
"percentages-resolve-to": "length"
},
"grid-auto-flow": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"inherited": false,
"initial": "row"
},
"grid-auto-rows": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"length",
"percentage",
"string"
],
"percentages-resolve-to": "length"
},
LibWeb: Parse grid-column and grid-row CSS values
2022-08-23 20:00:16 +02:00
"grid-column": {
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"string"
],
"longhands": [
"grid-column-end",
"grid-column-start"
]
},
LibWeb: Parse grid-column-start and related CSS properties Parse grid-column-start, end, and the equivalent for rows.
2022-08-23 19:58:00 +02:00
"grid-column-end": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Parse grid-column-start and related CSS properties Parse grid-column-start, end, and the equivalent for rows.
2022-08-23 19:58:00 +02:00
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"string"
]
},
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
"grid-column-gap": {
LibWeb/CSS: Mark grid-[gap, column-gap, row-gap] properties as aliases These are legacy name aliases for the properties without the 'grid-' prefix. See https://drafts.csswg.org/css-align-3/#gap-legacy
2024-10-14 11:24:48 +01:00
"legacy-alias-for": "column-gap"
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
},
LibWeb: Parse grid-column-start and related CSS properties Parse grid-column-start, end, and the equivalent for rows.
2022-08-23 19:58:00 +02:00
"grid-column-start": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Parse grid-column-start and related CSS properties Parse grid-column-start, end, and the equivalent for rows.
2022-08-23 19:58:00 +02:00
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"string"
]
},
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
"grid-gap": {
LibWeb/CSS: Mark grid-[gap, column-gap, row-gap] properties as aliases These are legacy name aliases for the properties without the 'grid-' prefix. See https://drafts.csswg.org/css-align-3/#gap-legacy
2024-10-14 11:24:48 +01:00
"legacy-alias-for": "gap"
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
},
LibWeb: Parse grid-column and grid-row CSS values
2022-08-23 20:00:16 +02:00
"grid-row": {
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"string"
],
"longhands": [
"grid-row-end",
"grid-row-start"
]
},
LibWeb: Parse grid-column-start and related CSS properties Parse grid-column-start, end, and the equivalent for rows.
2022-08-23 19:58:00 +02:00
"grid-row-end": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Parse grid-column-start and related CSS properties Parse grid-column-start, end, and the equivalent for rows.
2022-08-23 19:58:00 +02:00
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"string"
]
},
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
"grid-row-gap": {
LibWeb/CSS: Mark grid-[gap, column-gap, row-gap] properties as aliases These are legacy name aliases for the properties without the 'grid-' prefix. See https://drafts.csswg.org/css-align-3/#gap-legacy
2024-10-14 11:24:48 +01:00
"legacy-alias-for": "row-gap"
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
},
LibWeb: Parse grid-column-start and related CSS properties Parse grid-column-start, end, and the equivalent for rows.
2022-08-23 19:58:00 +02:00
"grid-row-start": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Parse grid-column-start and related CSS properties Parse grid-column-start, end, and the equivalent for rows.
2022-08-23 19:58:00 +02:00
"inherited": false,
"initial": "auto",
LibWeb: Parse `grid-template-areas` CSS property
2023-01-16 18:17:05 +01:00
"valid-identifiers": [
"auto"
],
"valid-types": [
"string"
]
},
LibWeb: Parse `grid-template` property
2023-04-29 19:32:56 +02:00
"grid-template": {
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"length",
"percentage",
"string"
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Parse `grid-template` property
2023-04-29 19:32:56 +02:00
"longhands": [
"grid-template-areas",
"grid-template-rows",
"grid-template-columns"
]
},
LibWeb: Parse `grid-template-areas` CSS property
2023-01-16 18:17:05 +01:00
"grid-template-areas": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Parse `grid-template-areas` CSS property
2023-01-16 18:17:05 +01:00
"inherited": false,
LibWeb: Correct grid-template-areas definition The spec syntax is `none | <string>+` and `none` is the default.
2023-12-07 21:07:21 +00:00
"initial": "none",
LibWeb: Parse grid-column-start and related CSS properties Parse grid-column-start, end, and the equivalent for rows.
2022-08-23 19:58:00 +02:00
"valid-identifiers": [
LibWeb: Correct grid-template-areas definition The spec syntax is `none | <string>+` and `none` is the default.
2023-12-07 21:07:21 +00:00
"none"
LibWeb: Parse grid-column-start and related CSS properties Parse grid-column-start, end, and the equivalent for rows.
2022-08-23 19:58:00 +02:00
],
"valid-types": [
"string"
]
},
LibWeb: Parse grid-template-columns and grid-template-rows Add functionality to begin parsing grid-template-columns and grid-template-rows. There are still things to be added, like parsing functions, but I would say a couple of the major points are already adressed like length, percentage, and flexible-length.
2022-08-23 19:49:07 +02:00
"grid-template-columns": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "custom",
LibWeb: Parse grid-template-columns and grid-template-rows Add functionality to begin parsing grid-template-columns and grid-template-rows. There are still things to be added, like parsing functions, but I would say a couple of the major points are already adressed like length, percentage, and flexible-length.
2022-08-23 19:49:07 +02:00
"inherited": false,
LibWeb: Use none as initial value for grid-template-column/rows This fixes the issue that currently we use "auto" as initial value for grid-template-column and grid-template-rows although spec says it should be "none". This makes a lot of difference for these properties because currently we represent "auto" as a list with one auto-sized track which means initial value for grid-template-column defines one "explicit" track while it should define none of them. This change makes grid-auto-columns/rows be applied to the correct tracks when initial values is used for grid-template-column/rows.
2023-06-07 13:04:06 +03:00
"initial": "none",
LibWeb: Parse grid-template-columns and grid-template-rows Add functionality to begin parsing grid-template-columns and grid-template-rows. There are still things to be added, like parsing functions, but I would say a couple of the major points are already adressed like length, percentage, and flexible-length.
2022-08-23 19:49:07 +02:00
"max-values": 4,
"valid-identifiers": [
"auto"
],
"valid-types": [
"length",
"percentage",
"string"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
"percentages-resolve-to": "length"
LibWeb: Parse grid-template-columns and grid-template-rows Add functionality to begin parsing grid-template-columns and grid-template-rows. There are still things to be added, like parsing functions, but I would say a couple of the major points are already adressed like length, percentage, and flexible-length.
2022-08-23 19:49:07 +02:00
},
"grid-template-rows": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "custom",
LibWeb: Parse grid-template-columns and grid-template-rows Add functionality to begin parsing grid-template-columns and grid-template-rows. There are still things to be added, like parsing functions, but I would say a couple of the major points are already adressed like length, percentage, and flexible-length.
2022-08-23 19:49:07 +02:00
"inherited": false,
LibWeb: Use none as initial value for grid-template-column/rows This fixes the issue that currently we use "auto" as initial value for grid-template-column and grid-template-rows although spec says it should be "none". This makes a lot of difference for these properties because currently we represent "auto" as a list with one auto-sized track which means initial value for grid-template-column defines one "explicit" track while it should define none of them. This change makes grid-auto-columns/rows be applied to the correct tracks when initial values is used for grid-template-column/rows.
2023-06-07 13:04:06 +03:00
"initial": "none",
LibWeb: Parse grid-template-columns and grid-template-rows Add functionality to begin parsing grid-template-columns and grid-template-rows. There are still things to be added, like parsing functions, but I would say a couple of the major points are already adressed like length, percentage, and flexible-length.
2022-08-23 19:49:07 +02:00
"max-values": 4,
"valid-identifiers": [
"auto"
],
"valid-types": [
"length",
"percentage",
"string"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
"percentages-resolve-to": "length"
LibWeb: Parse grid-template-columns and grid-template-rows Add functionality to begin parsing grid-template-columns and grid-template-rows. There are still things to be added, like parsing functions, but I would say a couple of the major points are already adressed like length, percentage, and flexible-length.
2022-08-23 19:49:07 +02:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"height": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Parse CSS fit-content(<length-percentage>) values Before this change, we only parsed fit-content as a standalone keyword, but CSS-SIZING-3 added it as a function as well. I don't know of anything else in CSS that is overloaded like this, so it ends up looking a little awkward in the implementation. Note that a lot of code had already been prepped for fit-content values to have an argument, we just weren't parsing it.
2025-02-26 18:16:36 +01:00
"fit-content",
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
LibWeb: Accept height: {min,max,fit}-content And treat them as "auto" for now, per CSS-SIZING-3, with a FIXME about supporting more layout directions. This fixes an issue on MDN where `height: max-content` was not overriding height from non-CSS presentational hints.
2023-08-20 18:25:54 +02:00
"auto",
"max-content",
"min-content"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add support for CSS image-rendering property Currently only "auto" and "pixelated" values are supported.
2022-02-18 12:21:27 +01:00
"image-rendering": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add support for CSS image-rendering property Currently only "auto" and "pixelated" values are supported.
2022-02-18 12:21:27 +01:00
"inherited": true,
"initial": "auto",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"image-rendering"
LibWeb: Add support for CSS image-rendering property Currently only "auto" and "pixelated" values are supported.
2022-02-18 12:21:27 +01:00
]
},
LibWeb: Add support for the inline-size CSS property
2024-03-06 18:12:09 +04:00
"inline-size": {
LibWeb: Format Properties.json
2024-07-24 09:51:31 +01:00
"logical-alias-for": [
LibWeb/CSS: Make inline-size a logical alias for the height property
2025-01-29 15:03:06 +00:00
"width",
"height"
LibWeb: Format Properties.json
2024-07-24 09:51:31 +01:00
],
"initial": "auto",
"max-values": 1
LibWeb: Add support for the inline-size CSS property
2024-03-06 18:12:09 +04:00
},
LibWeb: Add support for parsing 'inset' shorthand CSS property
2023-05-29 21:43:37 -04:00
"inset": {
"inherited": false,
"initial": "auto",
"longhands": [
"top",
"right",
"bottom",
"left"
],
"max-values": 4,
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add support for parsing 'inset' shorthand CSS property
2023-05-29 21:43:37 -04:00
],
"valid-identifiers": [
"auto"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
"percentages-resolve-to": "length"
LibWeb: Add support for parsing 'inset' shorthand CSS property
2023-05-29 21:43:37 -04:00
},
LibWeb: Add logical CSS properties for insets This patch adds the following properties: - inset-inline - inset-inline-start - inset-inline-end - inset-block - inset-block-start - inset-block-end
2023-07-13 20:52:36 +02:00
"inset-block": {
"logical-alias-for": [
"inset"
],
"max-values": 2
},
"inset-block-end": {
"logical-alias-for": [
"top",
"right",
"bottom",
"left"
],
"max-values": 1
},
"inset-block-start": {
"logical-alias-for": [
"top",
"right",
"bottom",
"left"
],
"max-values": 1
},
"inset-inline": {
"logical-alias-for": [
"inset"
],
"max-values": 2
},
"inset-inline-end": {
"logical-alias-for": [
"top",
"right",
"bottom",
"left"
],
"max-values": 1
},
"inset-inline-start": {
"logical-alias-for": [
"top",
"right",
"bottom",
"left"
],
"max-values": 1
},
LibWeb: Implement CSS 'isolation' property
2025-01-11 01:34:47 +01:00
"isolation": {
"animation-type": "none",
"inherited": false,
"initial": "auto",
"valid-types": [
"isolation"
]
},
LibWeb: Add parsing for the justify-content property
2021-07-16 18:38:26 +02:00
"justify-content": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Add parsing for the justify-content property
2021-07-16 18:38:26 +02:00
"inherited": false,
LibWeb: Support "normal" and "stretch" justify-content in CSS parser
2024-01-04 08:16:06 +01:00
"initial": "normal",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"justify-content"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add parsing for the justify-content property
2021-07-16 18:38:26 +02:00
},
LibWeb: Add support for justify-items property in CSS parser
2023-07-14 20:49:22 +02:00
"justify-items": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Add support for justify-items property in CSS parser
2023-07-14 20:49:22 +02:00
"inherited": false,
"initial": "legacy",
"valid-types": [
"justify-items"
]
},
LibWeb: Add support for justify-self property in CSS parser
2023-07-14 14:41:22 +02:00
"justify-self": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Add support for justify-self property in CSS parser
2023-07-14 14:41:22 +02:00
"inherited": false,
"initial": "auto",
"valid-types": [
"justify-self"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"left": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"letter-spacing": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "normal",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-identifiers": [
"normal"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"line-height": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "normal",
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"number [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"normal"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
"percentages-resolve-to": "length"
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"list-style": {
LibWeb: Replace is_inherited_property() with generated code We already include the inheritance for each property in Properties.json, so made sense to use that instead of a list in StyleResolver. Added `inherited: true` to a couple of properties to match the previous code's behavior. One of those had a FIXME which I've moved to the JSON file, which is hacky, but it works.
2021-08-16 16:07:13 +01:00
"inherited": true,
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"initial": "outside disc",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"longhands": [
"list-style-type",
"list-style-position",
"list-style-image"
]
},
"list-style-image": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "none",
"valid-types": [
"image"
],
"valid-identifiers": [
"none"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"list-style-position": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "outside",
LibWeb: Support list-style-position This moves the ::marker inside of <summary> actually inside. :^)
2023-06-02 23:05:15 +02:00
"valid-types": [
"list-style-position"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"list-style-type": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "disc",
"valid-types": [
LibWeb: Support strings as list-style-types We've long claimed to support this, but then silently ignored string values, until 4cb20635771a54f59cdb36616dbdcbd402ef080e which would not-so-silently crash instead. (Oops) So, actually pass the string value along and use it in the list marker. As part of this, rename our `list-style-type` enum to `counter-style-name-keyword`. This is an awkward name, attempting to be spec-based. (The spec says `<counter-style>`, which is either a `<counter-style-name>` or a function, and the `<counter-style-name>` is a `<custom-ident>` that also has a few predefined values. So this is the best I could come up with.) Unfortunately only one WPT test for this passes - the others fail because we produce a different layout when text is in `::before` than when it's in `::marker`, and similar issues.
2025-02-10 12:48:40 +00:00
"counter-style-name-keyword",
"string"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"margin": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "0",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"longhands": [
"margin-top",
"margin-right",
"margin-bottom",
"margin-left"
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
],
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"max-values": 4,
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
]
},
LibWeb: Add naive support for {margin,padding}-{block,inline} Like other logical properties, we just alias these to the LTR TB default properties for now.
2023-06-07 09:13:21 +02:00
"margin-block": {
"logical-alias-for": [
"margin"
],
"max-values": 2
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"margin-block-end": {
LibWeb: Add CSS logical property aliases for margin and padding sides These just map to the LTR+TB defaults for now, as we don't yet resolve any of the inputs to the logical property selection algorithm.
2023-06-06 12:24:08 +02:00
"logical-alias-for": [
"margin-top",
"margin-right",
"margin-bottom",
"margin-left"
]
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"margin-block-start": {
LibWeb: Add CSS logical property aliases for margin and padding sides These just map to the LTR+TB defaults for now, as we don't yet resolve any of the inputs to the logical property selection algorithm.
2023-06-06 12:24:08 +02:00
"logical-alias-for": [
"margin-top",
"margin-right",
"margin-bottom",
"margin-left"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"margin-bottom": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add naive support for {margin,padding}-{block,inline} Like other logical properties, we just alias these to the LTR TB default properties for now.
2023-06-07 09:13:21 +02:00
"margin-inline": {
"logical-alias-for": [
"margin"
],
"max-values": 2
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"margin-inline-end": {
LibWeb: Add CSS logical property aliases for margin and padding sides These just map to the LTR+TB defaults for now, as we don't yet resolve any of the inputs to the logical property selection algorithm.
2023-06-06 12:24:08 +02:00
"logical-alias-for": [
"margin-top",
"margin-right",
"margin-bottom",
"margin-left"
]
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"margin-inline-start": {
LibWeb: Add CSS logical property aliases for margin and padding sides These just map to the LTR+TB defaults for now, as we don't yet resolve any of the inputs to the logical property selection algorithm.
2023-06-06 12:24:08 +02:00
"logical-alias-for": [
"margin-top",
"margin-right",
"margin-bottom",
"margin-left"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"margin-left": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"margin-right": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"margin-top": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add CSS `mask` property and make it form a stacking context
2023-09-03 19:44:00 +01:00
"mask": {
"inherited": false,
LibWeb/CSS: Treat 'mask' as a longhand property Before this change, an element masked with 'mask-image: url(...)' would show the mask, but 'mask: url(...)' would not. On e.g. dialogic.nl it would show white boxes instead of the actual images in the top navigation bar. We still do not support many of the other mask properties, but with this change at least the masks show up in both cases.
2025-03-01 11:27:55 +01:00
"__comment": "FIXME: add longhands mask-clip, mask-composite, mask-mode, mask-origin, mask-position, mask-repeat, mask-size; also reset mask-border",
"initial": "none",
"longhands": [
"mask-image"
]
LibWeb: Add CSS `mask` property and make it form a stacking context
2023-09-03 19:44:00 +01:00
},
LibWeb: Implement `mask-image` CSS property support Implemented by reusing AddMask display list item that was initially added for `background-clip` property. Progress on flashlight effect on https://null.com/games/athena-crisis
2024-11-16 03:25:48 +03:00
"mask-image": {
"animation-type": "discrete",
"inherited": false,
"affects-layout": false,
LibWeb/CSS: Treat 'mask' as a longhand property Before this change, an element masked with 'mask-image: url(...)' would show the mask, but 'mask: url(...)' would not. On e.g. dialogic.nl it would show white boxes instead of the actual images in the top navigation bar. We still do not support many of the other mask properties, but with this change at least the masks show up in both cases.
2025-03-01 11:27:55 +01:00
"affects-stacking-context": true,
LibWeb: Implement `mask-image` CSS property support Implemented by reusing AddMask display list item that was initially added for `background-clip` property. Progress on flashlight effect on https://null.com/games/athena-crisis
2024-11-16 03:25:48 +03:00
"valid-types": [
LibWeb/CSS: Treat 'mask' as a longhand property Before this change, an element masked with 'mask-image: url(...)' would show the mask, but 'mask: url(...)' would not. On e.g. dialogic.nl it would show white boxes instead of the actual images in the top navigation bar. We still do not support many of the other mask properties, but with this change at least the masks show up in both cases.
2025-03-01 11:27:55 +01:00
"image",
"url"
LibWeb: Implement `mask-image` CSS property support Implemented by reusing AddMask display list item that was initially added for `background-clip` property. Progress on flashlight effect on https://null.com/games/athena-crisis
2024-11-16 03:25:48 +03:00
],
"valid-identifiers": [
"none"
],
"initial": "none"
},
LibWeb: Implement `mask-type` CSS property This property allows specifying if a mask is an alpha or luminance mask. See: https://drafts.fxtf.org/css-masking/#the-mask-type
2023-10-08 11:06:34 +01:00
"mask-type": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Implement `mask-type` CSS property This property allows specifying if a mask is an alpha or luminance mask. See: https://drafts.fxtf.org/css-masking/#the-mask-type
2023-10-08 11:06:34 +01:00
"inherited": false,
"affects-layout": false,
"valid-types": [
"mask-type"
],
"initial": "luminance"
},
LibWeb: Implement the `math-depth` CSS property This one is a bit fun because it can be `add(<integer>)` or `auto-add`, but children have to inherit the computed value not the specified one. We also have to compute it before computing the font-size, because of `font-size: math` which will be implemented later.
2023-09-07 15:29:54 +01:00
"math-depth": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "none",
LibWeb: Implement the `math-depth` CSS property This one is a bit fun because it can be `add(<integer>)` or `auto-add`, but children have to inherit the computed value not the specified one. We also have to compute it before computing the font-size, because of `font-size: math` which will be implemented later.
2023-09-07 15:29:54 +01:00
"inherited": true,
"initial": "0",
"__comment": "FIXME: `add(<integer>)` is also valid but we can't represent that here yet.",
"valid-types": [
"integer"
],
"valid-identifiers": [
"auto-add"
]
},
LibWeb: Parse the `math-shift` and `math-style` CSS properties Currently these have no effect, but they're simple, and `math-style` influences `math-depth` which is coming next.
2023-09-05 20:23:15 +01:00
"math-shift": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "none",
LibWeb: Parse the `math-shift` and `math-style` CSS properties Currently these have no effect, but they're simple, and `math-style` influences `math-depth` which is coming next.
2023-09-05 20:23:15 +01:00
"inherited": true,
"initial": "normal",
"valid-types": [
"math-shift"
]
},
"math-style": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "none",
LibWeb: Parse the `math-shift` and `math-style` CSS properties Currently these have no effect, but they're simple, and `math-style` influences `math-depth` which is coming next.
2023-09-05 20:23:15 +01:00
"inherited": true,
"initial": "normal",
"valid-types": [
"math-style"
]
},
LibWeb/CSS: Implement the ({min,max}-)block-size properties These are heavily used by morrisons.com, using them in place of the usual properties these map to.
2025-01-29 14:17:52 +00:00
"max-block-size": {
"logical-alias-for": [
"max-height",
"max-width"
],
"initial": "none"
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"max-height": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "none",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Parse CSS fit-content(<length-percentage>) values Before this change, we only parsed fit-content as a standalone keyword, but CSS-SIZING-3 added it as a function as well. I don't know of anything else in CSS that is overloaded like this, so it ends up looking a little awkward in the implementation. Note that a lot of code had already been prepped for fit-content values to have an argument, we just weren't parsing it.
2025-02-26 18:16:36 +01:00
"fit-content",
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
LibWeb: Allow intrinsic size keywords for `min-height` and `max-height`
2024-10-27 18:28:10 +01:00
"max-content",
"min-content",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"none"
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Support min-inline-size & max-inline-size Currently this assumes that writing-mode is horizontal, and therefore only affects the min-width/max-width
2023-05-23 00:29:01 -07:00
"max-inline-size": {
LibWeb: Make CSS/Properties.json "logical-aliases-for" an array This allows us to specify all aliases properties instead of just one.
2023-06-06 10:35:16 +02:00
"logical-alias-for": [
"max-width",
"max-height"
],
LibWeb: Support min-inline-size & max-inline-size Currently this assumes that writing-mode is horizontal, and therefore only affects the min-width/max-width
2023-05-23 00:29:01 -07:00
"initial": "none"
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"max-width": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "none",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Parse CSS fit-content(<length-percentage>) values Before this change, we only parsed fit-content as a standalone keyword, but CSS-SIZING-3 added it as a function as well. I don't know of anything else in CSS that is overloaded like this, so it ends up looking a little awkward in the implementation. Note that a lot of code had already been prepped for fit-content values to have an argument, we just weren't parsing it.
2025-02-26 18:16:36 +01:00
"fit-content",
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
LibWeb: Support `max-content` for `width`, `min-width` and `max-width` We're gonna need to handle this in many more places, this patch only adds it to calculate_inner_width().
2023-05-28 18:18:34 +02:00
"max-content",
LibWeb: Support `min-content` for `width`, `min-width` and `max-width` We're gonna need to handle this in many more places, this patch only adds it to calculate_inner_width().
2023-05-28 18:24:55 +02:00
"min-content",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"none"
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb/CSS: Implement the ({min,max}-)block-size properties These are heavily used by morrisons.com, using them in place of the usual properties these map to.
2025-01-29 14:17:52 +00:00
"min-block-size": {
"logical-alias-for": [
"min-height",
"min-width"
],
"initial": "0"
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"min-height": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Parse CSS fit-content(<length-percentage>) values Before this change, we only parsed fit-content as a standalone keyword, but CSS-SIZING-3 added it as a function as well. I don't know of anything else in CSS that is overloaded like this, so it ends up looking a little awkward in the implementation. Note that a lot of code had already been prepped for fit-content values to have an argument, we just weren't parsing it.
2025-02-26 18:16:36 +01:00
"fit-content",
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
LibWeb: Allow intrinsic size keywords for `min-height` and `max-height`
2024-10-27 18:28:10 +01:00
"auto",
"max-content",
"min-content"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Support min-inline-size & max-inline-size Currently this assumes that writing-mode is horizontal, and therefore only affects the min-width/max-width
2023-05-23 00:29:01 -07:00
"min-inline-size": {
LibWeb: Make CSS/Properties.json "logical-aliases-for" an array This allows us to specify all aliases properties instead of just one.
2023-06-06 10:35:16 +02:00
"logical-alias-for": [
"min-width",
"min-height"
],
LibWeb: Support min-inline-size & max-inline-size Currently this assumes that writing-mode is horizontal, and therefore only affects the min-width/max-width
2023-05-23 00:29:01 -07:00
"initial": "0"
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"min-width": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Parse CSS fit-content(<length-percentage>) values Before this change, we only parsed fit-content as a standalone keyword, but CSS-SIZING-3 added it as a function as well. I don't know of anything else in CSS that is overloaded like this, so it ends up looking a little awkward in the implementation. Note that a lot of code had already been prepped for fit-content values to have an argument, we just weren't parsing it.
2025-02-26 18:16:36 +01:00
"fit-content",
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
LibWeb: Add missing "auto" identifiers for min-width/height Both of these have "auto" as their initial value, so the only reason they work currently is that "auto" is implicitly a Length.
2022-01-16 21:35:33 +00:00
"auto",
LibWeb: Support `max-content` for `width`, `min-width` and `max-width` We're gonna need to handle this in many more places, this patch only adds it to calculate_inner_width().
2023-05-28 18:18:34 +02:00
"max-content",
LibWeb: Disallow `none` for `min-width` and `min-height`
2024-10-27 18:26:28 +01:00
"min-content"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb/CSS: Implement mix-blend-mode This adds support for the `mix-blend-mode` CSS property.
2025-01-22 09:50:49 +01:00
"mix-blend-mode": {
"animation-type": "none",
"inherited": false,
"initial": "normal",
"valid-types": [
"mix-blend-mode"
]
},
LibWeb: Add 'object-fit' property This patch adds support for the 'object-fit' CSS property. :^)
2023-08-01 20:06:50 +02:00
"object-fit": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Add 'object-fit' property This patch adds support for the 'object-fit' CSS property. :^)
2023-08-01 20:06:50 +02:00
"inherited": false,
"initial": "fill",
"valid-types": [
"object-fit"
]
},
LibWeb: Add 'object-position' property and 'position' enum This patch adds the 'object-position' CSS property description to the json for code generation. Also the 'position' enum is added. The values of this enum are the valid inputs to the object-position property from CSS Values-4.
2023-10-16 13:49:52 +02:00
"object-position": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "repeatable-list",
LibWeb: Add 'object-position' property and 'position' enum This patch adds the 'object-position' CSS property description to the json for code generation. Also the 'position' enum is added. The values of this enum are the valid inputs to the object-position property from CSS Values-4.
2023-10-16 13:49:52 +02:00
"affects-layout": false,
"inherited": false,
"initial": "50% 50%",
"valid-types": [
"position"
LibWeb/CSS: Correct "percentages-resolve-to" data for properties These were missing for properties that take a `<position>`, and were incorrectly present for opacity-related properties.
2025-01-31 11:46:18 +00:00
],
"percentages-resolve-to": "length"
LibWeb: Add 'object-position' property and 'position' enum This patch adds the 'object-position' CSS property description to the json for code generation. Also the 'position' enum is added. The values of this enum are the valid inputs to the object-position property from CSS Values-4.
2023-10-16 13:49:52 +02:00
},
LibWeb: Parse and store the opacity property
2021-07-23 13:18:09 +03:00
"opacity": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Only invalidate stacking context tree for opacity/z-index change I came across some websites that change an elements CSS "opacity" in their :hover selectors. That caused us to relayout on hover, which we'd like to avoid. With this patch, we now check if a property only affects the stacking context tree, and if nothing layout-affecting has changed, we only invalidate the stacking context tree, causing it to be rebuilt on next paint or hit test. This makes :hover { opacity: ... } rules much faster. :^)
2022-03-21 10:58:51 +01:00
"affects-layout": false,
"affects-stacking-context": true,
LibWeb: Parse and store the opacity property
2021-07-23 13:18:09 +03:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "1",
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"number [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
LibWeb/CSS: Correct "percentages-resolve-to" data for properties These were missing for properties that take a `<position>`, and were incorrectly present for opacity-related properties.
2025-01-31 11:46:18 +00:00
"__comment": "We don't have a percentages-resolve-to here because even though we're supposed to map percentages to [0,1], calc(10%) should resolve to 10% not 0.1."
LibWeb: Parse and store the opacity property
2021-07-23 13:18:09 +03:00
},
LibWeb: Fix order/formatting of Properties.json
2023-06-02 17:23:00 +01:00
"order": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Fix order/formatting of Properties.json
2023-06-02 17:23:00 +01:00
"inherited": false,
"initial": "0",
"valid-types": [
"integer [-∞,∞]"
]
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"outline": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": false,
LibWeb: Implement the CSS `outline` property :^) ...along with `outline-color`, `outline-style`, and `outline-width`. This re-uses the existing border-painting code, which seems to work well enough! This replaces the previous code for drawing focus-outlines, with generic outline painting for any elements that want it. Focus outlines are now instead supported by this code in Default.css: ```css :focus-visible { outline: auto; } ```
2023-08-02 17:24:14 +01:00
"initial": "medium currentColor none",
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"longhands": [
"outline-color",
"outline-style",
"outline-width"
]
},
"outline-color": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": false,
LibWeb: Implement the CSS `outline` property :^) ...along with `outline-color`, `outline-style`, and `outline-width`. This re-uses the existing border-painting code, which seems to work well enough! This replaces the previous code for drawing focus-outlines, with generic outline painting for any elements that want it. Focus outlines are now instead supported by this code in Default.css: ```css :focus-visible { outline: auto; } ```
2023-08-02 17:24:14 +01:00
"__comment": "FIXME: We don't yet support `invert`. Until we do, the spec directs us to use `currentColor` as the default instead, and reject `invert`",
"initial": "currentColor",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
"color"
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
LibWeb: Implement the CSS `outline-offset` property This allows you to push the outline a certain distance away from the border (or inside it, if the offset is negative).
2023-08-02 20:09:10 +01:00
"outline-offset": {
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Implement the CSS `outline-offset` property This allows you to push the outline a certain distance away from the border (or inside it, if the offset is negative).
2023-08-02 20:09:10 +01:00
"inherited": false,
"initial": "0",
"valid-types": [
"length [-∞,∞]"
]
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"outline-style": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "none",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
LibWeb: Implement the CSS `outline` property :^) ...along with `outline-color`, `outline-style`, and `outline-width`. This re-uses the existing border-painting code, which seems to work well enough! This replaces the previous code for drawing focus-outlines, with generic outline painting for any elements that want it. Focus outlines are now instead supported by this code in Default.css: ```css :focus-visible { outline: auto; } ```
2023-08-02 17:24:14 +01:00
"outline-style"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
"outline-width": {
LibWeb: Annotate which CSS properties may affect layout This patch adds CSS::property_affects_layout(PropertyID) which tells us whether a CSS property would affect layout if it were changed. This will be used to avoid unnecessary relayout work when something changes that really only requires us to repaint the page. To mark a property as not affecting layout, set "affects-layout" to false in the corresponding Properties.json entry. Note that all properties affect layout by default.
2022-03-16 17:46:24 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "medium",
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"medium",
"thick",
"thin"
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
LibWeb: Add parsing and application of CSS "overflow" property We don't actually do anything with the values yet, but now they are available for layout nodes once we are ready to implement them.
2021-02-22 15:20:31 +01:00
"overflow": {
"longhands": [
"overflow-x",
"overflow-y"
],
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "visible",
"max-values": 2,
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"overflow"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add parsing and application of CSS "overflow" property We don't actually do anything with the values yet, but now they are available for layout nodes once we are ready to implement them.
2021-02-22 15:20:31 +01:00
},
"overflow-x": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Add parsing and application of CSS "overflow" property We don't actually do anything with the values yet, but now they are available for layout nodes once we are ready to implement them.
2021-02-22 15:20:31 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "visible",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"overflow"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add parsing and application of CSS "overflow" property We don't actually do anything with the values yet, but now they are available for layout nodes once we are ready to implement them.
2021-02-22 15:20:31 +01:00
},
"overflow-y": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Add parsing and application of CSS "overflow" property We don't actually do anything with the values yet, but now they are available for layout nodes once we are ready to implement them.
2021-02-22 15:20:31 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "visible",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"overflow"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add parsing and application of CSS "overflow" property We don't actually do anything with the values yet, but now they are available for layout nodes once we are ready to implement them.
2021-02-22 15:20:31 +01:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"padding": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "0",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"longhands": [
"padding-top",
"padding-right",
"padding-bottom",
"padding-left"
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
],
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"max-values": 4,
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
]
},
LibWeb: Add naive support for {margin,padding}-{block,inline} Like other logical properties, we just alias these to the LTR TB default properties for now.
2023-06-07 09:13:21 +02:00
"padding-block": {
"logical-alias-for": [
"padding"
],
"max-values": 2
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"padding-block-end": {
LibWeb: Add CSS logical property aliases for margin and padding sides These just map to the LTR+TB defaults for now, as we don't yet resolve any of the inputs to the logical property selection algorithm.
2023-06-06 12:24:08 +02:00
"logical-alias-for": [
"padding-top",
"padding-right",
"padding-bottom",
"padding-left"
]
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"padding-block-start": {
LibWeb: Add CSS logical property aliases for margin and padding sides These just map to the LTR+TB defaults for now, as we don't yet resolve any of the inputs to the logical property selection algorithm.
2023-06-06 12:24:08 +02:00
"logical-alias-for": [
"padding-top",
"padding-right",
"padding-bottom",
"padding-left"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"padding-bottom": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add naive support for {margin,padding}-{block,inline} Like other logical properties, we just alias these to the LTR TB default properties for now.
2023-06-07 09:13:21 +02:00
"padding-inline": {
"logical-alias-for": [
"padding"
],
"max-values": 2
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"padding-inline-end": {
LibWeb: Add CSS logical property aliases for margin and padding sides These just map to the LTR+TB defaults for now, as we don't yet resolve any of the inputs to the logical property selection algorithm.
2023-06-06 12:24:08 +02:00
"logical-alias-for": [
"padding-top",
"padding-right",
"padding-bottom",
"padding-left"
]
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"padding-inline-start": {
LibWeb: Add CSS logical property aliases for margin and padding sides These just map to the LTR+TB defaults for now, as we don't yet resolve any of the inputs to the logical property selection algorithm.
2023-06-06 12:24:08 +02:00
"logical-alias-for": [
"padding-top",
"padding-right",
"padding-bottom",
"padding-left"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"padding-left": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"padding-right": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"padding-top": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add support for parsing place-content shorthand CSS property
2023-05-29 16:34:53 -04:00
"place-content": {
"inherited": false,
"initial": "normal",
"longhands": [
"align-content",
"justify-content"
]
},
LibWeb: Add support for "place-items" CSS property Adds support for place-items property which allows to specify both align-items and justify-items in a single declaration.
2023-07-17 16:34:12 +02:00
"place-items": {
"inherited": false,
"initial": "normal",
"longhands": [
"align-items",
"justify-items"
]
},
LibWeb: Add place-self css property support
2023-08-04 14:04:05 +02:00
"place-self": {
"inherited": false,
"initial": "normal",
"longhands": [
"align-self",
"justify-self"
]
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"pointer-events": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": true,
LibWeb: Add initial version of pointer-events CSS property
2021-10-05 19:47:13 +01:00
"initial": "auto",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"pointer-events"
LibWeb: Add initial version of pointer-events CSS property
2021-10-05 19:47:13 +01:00
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
LibHTML: Add the CSS "position" property to CSS/Properties.json
2019-11-19 18:20:54 +01:00
"position": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Add the CSS "position" property to CSS/Properties.json
2019-11-19 18:20:54 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "static",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
LibWeb: Rename "position" enum to "positioning" The postitioning enum values are used by the position CSS property. Unfortunately, the prior naming clashes with the CSS Values-4 type named position, which will be implemented in a later commit.
2023-10-27 15:17:36 +02:00
"positioning"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Add the CSS "position" property to CSS/Properties.json
2019-11-19 18:20:54 +01:00
},
LibWeb: Parse and compute CSS `quotes` property
2023-09-12 11:34:26 +01:00
"quotes": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Parse and compute CSS `quotes` property
2023-09-12 11:34:26 +01:00
"inherited": true,
"initial": "auto",
"valid-types": [
"string"
],
"valid-identifiers": [
"auto",
"none"
]
},
LibWeb: Define the rest of the SVG geometry properties This defines all the (remaining) geometry properties from https://svgwg.org/svg2-draft/geometry.html#Sizing.
2023-02-25 10:31:00 +01:00
"r": {
"__comment": "This is an SVG 2 geometry property, see: https://www.w3.org/TR/SVG/geometry.html#R.",
"animation-type": "by-computed-value",
"inherited": false,
"initial": "0",
"valid-types": [
"length [-∞,∞]",
"percentage [-∞,∞]"
],
"percentages-resolve-to": "length",
"quirks": [
"unitless-length"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"right": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Parse the rotate css property
2024-10-16 08:50:35 +02:00
"rotate": {
"animation-type": "custom",
"inherited": false,
"initial": "none",
"affects-layout": false,
"affects-stacking-context": true
},
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
"row-gap": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
"inherited": false,
LibWeb: Restrict CSS gap properties to values allowed by the spec Gap values are now represented by Variant<LengthPercentage, NormalGap>. NormalGap is just an empty struct to represent the `normal` keyword. This fixes a long-standing issue where we were incorrectly storing gaps as CSS::Size, which led to us allowing a bunch of invalid gap values.
2024-11-09 17:38:09 +01:00
"initial": "normal",
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
"valid-types": [
"length [0,∞]",
"percentage [0,∞]"
],
"valid-identifiers": [
LibWeb: Restrict CSS gap properties to values allowed by the spec Gap values are now represented by Variant<LengthPercentage, NormalGap>. NormalGap is just an empty struct to represent the `normal` keyword. This fixes a long-standing issue where we were incorrectly storing gaps as CSS::Size, which led to us allowing a bunch of invalid gap values.
2024-11-09 17:38:09 +01:00
"normal"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
"percentages-resolve-to": "length"
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
},
LibWeb: Define the rest of the SVG geometry properties This defines all the (remaining) geometry properties from https://svgwg.org/svg2-draft/geometry.html#Sizing.
2023-02-25 10:31:00 +01:00
"rx": {
"__comment": "This is an SVG 2 geometry property, see: https://www.w3.org/TR/SVG/geometry.html#RX.",
"animation-type": "by-computed-value",
"inherited": false,
"initial": "auto",
"valid-types": [
"length [-∞,∞]",
"percentage [-∞,∞]"
],
"valid-identifiers": [
"auto"
],
"percentages-resolve-to": "length",
"quirks": [
"unitless-length"
]
},
"ry": {
"__comment": "This is an SVG 2 geometry property, see: https://www.w3.org/TR/SVG/geometry.html#RY.",
"animation-type": "by-computed-value",
"inherited": false,
"initial": "auto",
"valid-types": [
"length [-∞,∞]",
"percentage [-∞,∞]"
],
"valid-identifiers": [
"auto"
],
"percentages-resolve-to": "length",
"quirks": [
"unitless-length"
]
},
LibWeb: Support individual `scale` CSS property
2024-11-22 18:07:16 +01:00
"scale": {
"animation-type": "custom",
"inherited": false,
"initial": "none",
"affects-layout": false,
"affects-stacking-context": true
},
LibWeb: Implement support for scrollbar-gutter This property is now correctly parsed. Ladybird always uses overlay scrollbars so this property does nothing.
2024-06-26 23:19:38 +01:00
"scrollbar-gutter": {
"affects-layout": false,
"animation-type": "discrete",
"__comment": "This property should affect layout per-spec, but ladybird always uses overlay scrollbars so it doesn't in practice.",
"inherited": false,
"initial": "auto"
},
LibWeb: Parse the CSS scrollbar-width property
2024-02-27 09:37:18 +01:00
"scrollbar-width": {
"affects-layout": false,
"animation-type": "by-computed-value",
"inherited": false,
"initial": "auto",
LibWeb: Format Properties.json
2024-07-24 09:51:31 +01:00
"valid-types": [
"scrollbar-width"
],
LibWeb: Parse the CSS scrollbar-width property
2024-02-27 09:37:18 +01:00
"valid-identifiers": [
"auto",
"thin",
"none"
]
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"stop-color": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"inherited": false,
"initial": "black",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"color"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add for CSS `fill/stroke/stroke-color` properties for SVG In the spec, `fill` and `stroke` are supposed to be a shorthands for various properties. But since the spec is still a working draft, and neither Firefox or Chrome support the `fill-color` or `stroke-color` properties, we'll stick with `fill` and `stroke` as simple colors for now. Also, note that SVG expects things in "user units", and we are assuming that 1px = 1 user unit for now.
2021-09-16 12:28:14 +01:00
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"stop-opacity": {
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"inherited": false,
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
"initial": "1",
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"number [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
LibWeb/CSS: Correct "percentages-resolve-to" data for properties These were missing for properties that take a `<position>`, and were incorrectly present for opacity-related properties.
2025-01-31 11:46:18 +00:00
"__comment": "We don't have a percentages-resolve-to here for the same reason as for opacity."
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"stroke": {
LibWeb: Add stop-color as a CSS property (This is to set the color of a stop for an SVG gradient)
2023-04-19 18:51:00 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"inherited": true,
"initial": "none",
LibWeb: Add stop-color as a CSS property (This is to set the color of a stop for an SVG gradient)
2023-04-19 18:51:00 +01:00
"valid-types": [
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"paint"
LibWeb: Add stop-color as a CSS property (This is to set the color of a stop for an SVG gradient)
2023-04-19 18:51:00 +01:00
]
},
LibWeb: Plumbing for svg stroke-dasharray
2024-11-20 19:23:10 -05:00
"stroke-dasharray": {
"animation-type": "custom",
"inherited": true,
"initial": "none",
"affects-layout": false
},
LibWeb: Plumbing for svg stroke-dashoffset
2024-11-18 21:21:22 -05:00
"stroke-dashoffset": {
"affects-layout": false,
"animation-type": "by-computed-value",
"inherited": true,
"initial": "0",
"valid-types": [
"length [0,∞]",
"number [0,∞]",
"percentage [0,∞]"
],
"percentages-resolve-to": "length"
},
LibWeb: Add stroke-linecap attribute and plumb it to SVGGraphicsElement SVGGraphicsElement then goes ahead and does nothing with it for now.
2024-10-10 10:15:49 -04:00
"stroke-linecap": {
"affects-layout": false,
"animation-type": "discrete",
"inherited": true,
"initial": "butt",
"valid-types": [
"stroke-linecap"
]
},
LibWeb: Parse stroke-{linejoin,miterlimit} attributes Similar to LadybirdBrowser/ladybird#1714. We don't implement the linejoin values `miter-clip` and `arcs`, because according to the SVG 2 spec: > The values miter-clip and arcs of the stroke-linejoin property are at > risk. There are no known browser implementations. See issue Github > issue w3c/svgwg#592. Nothing uses this yet. The next step is to change SVGPathPaintable::paint() to read `graphics_element.stroke_linejoin()` and `graphics_element.stroke_miterlimit()` when painting.
2024-10-28 20:51:16 -04:00
"stroke-linejoin": {
"affects-layout": false,
"animation-type": "discrete",
"inherited": true,
"initial": "miter",
"valid-types": [
"stroke-linejoin"
]
},
"stroke-miterlimit": {
"affects-layout": false,
"animation-type": "by-computed-value",
"inherited": true,
"initial": "4",
"valid-types": [
"number [0,∞]"
]
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"stroke-opacity": {
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"inherited": true,
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
"initial": "1",
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"number [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
LibWeb/CSS: Correct "percentages-resolve-to" data for properties These were missing for properties that take a `<position>`, and were incorrectly present for opacity-related properties.
2025-01-31 11:46:18 +00:00
"__comment": "We don't have a percentages-resolve-to here for the same reason as for opacity."
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
},
LibWeb: Add for CSS `fill/stroke/stroke-color` properties for SVG In the spec, `fill` and `stroke` are supposed to be a shorthands for various properties. But since the spec is still a working draft, and neither Firefox or Chrome support the `fill-color` or `stroke-color` properties, we'll stick with `fill` and `stroke` as simple colors for now. Also, note that SVG expects things in "user units", and we are assuming that 1px = 1 user unit for now.
2021-09-16 12:28:14 +01:00
"stroke-width": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Add for CSS `fill/stroke/stroke-color` properties for SVG In the spec, `fill` and `stroke` are supposed to be a shorthands for various properties. But since the spec is still a working draft, and neither Firefox or Chrome support the `fill-color` or `stroke-color` properties, we'll stick with `fill` and `stroke` as simple colors for now. Also, note that SVG expects things in "user units", and we are assuming that 1px = 1 user unit for now.
2021-09-16 12:28:14 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "1px",
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"number [0,∞]",
"percentage [0,∞]"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
"percentages-resolve-to": "length"
LibWeb: Add for CSS `fill/stroke/stroke-color` properties for SVG In the spec, `fill` and `stroke` are supposed to be a shorthands for various properties. But since the spec is still a working draft, and neither Firefox or Chrome support the `fill-color` or `stroke-color` properties, we'll stick with `fill` and `stroke` as simple colors for now. Also, note that SVG expects things in "user units", and we are assuming that 1px = 1 user unit for now.
2021-09-16 12:28:14 +01:00
},
LibWeb/CSS: Parse the tab-size property
2024-10-01 13:07:06 +01:00
"tab-size": {
"animation-type": "by-computed-value",
"inherited": true,
"initial": "8",
"valid-types": [
"length [0,∞]",
"number [0,∞]"
]
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"table-layout": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"inherited": false,
"initial": "auto",
LibWeb: Add an initial implementation of SVG `text-anchor` This only handles very simple <text> elements, but this is enough (with the font-size changes) to improve the badges on the GitHub README a fair bit.
2023-07-19 19:12:00 +01:00
"valid-types": [
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"table-layout"
LibWeb: Add an initial implementation of SVG `text-anchor` This only handles very simple <text> elements, but this is enough (with the font-size changes) to improve the badges on the GitHub README a fair bit.
2023-07-19 19:12:00 +01:00
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"text-align": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add `start` and `end` values to `text-align` The `start` and `end` value set the text alignment based on the computed value of `direction`. The default value of `text-align` is now `start` instead of `left`.
2024-08-11 18:14:12 +01:00
"initial": "start",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"text-align"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"text-anchor": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"inherited": true,
"initial": "start",
"valid-types": [
"text-anchor"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"text-decoration": {
LibWeb: Mark all text-decoration* CSS properties as not affecting layout
2022-03-16 19:11:25 +01:00
"affects-layout": false,
LibWeb: Use IdentifierStyleValue for CSS 'text-decoration-line' Also 'text-decoration' is actually a shorthand, so treat it that way.
2020-12-15 13:36:27 +01:00
"inherited": false,
"initial": "none",
"longhands": [
"text-decoration-color",
"text-decoration-line",
"text-decoration-style",
"text-decoration-thickness"
]
},
"text-decoration-color": {
LibWeb: Mark all text-decoration* CSS properties as not affecting layout
2022-03-16 19:11:25 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Use IdentifierStyleValue for CSS 'text-decoration-line' Also 'text-decoration' is actually a shorthand, so treat it that way.
2020-12-15 13:36:27 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "currentcolor",
"valid-types": [
"color"
]
LibWeb: Use IdentifierStyleValue for CSS 'text-decoration-line' Also 'text-decoration' is actually a shorthand, so treat it that way.
2020-12-15 13:36:27 +01:00
},
"text-decoration-line": {
LibWeb: Annotate which CSS properties may affect layout This patch adds CSS::property_affects_layout(PropertyID) which tells us whether a CSS property would affect layout if it were changed. This will be used to avoid unnecessary relayout work when something changes that really only requires us to repaint the page. To mark a property as not affecting layout, set "affects-layout" to false in the corresponding Properties.json entry. Note that all properties affect layout by default.
2022-03-16 17:46:24 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
"__comment": "FIXME: This property is not supposed to be inherited, but we currently rely on inheritance to propagate decorations into line boxes.",
LibWeb: Replace is_inherited_property() with generated code We already include the inheritance for each property in Properties.json, so made sense to use that instead of a list in StyleResolver. Added `inherited: true` to a couple of properties to match the previous code's behavior. One of those had a FIXME which I've moved to the JSON file, which is hacky, but it works.
2021-08-16 16:07:13 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "none",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"text-decoration-line"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Use IdentifierStyleValue for CSS 'text-decoration-line' Also 'text-decoration' is actually a shorthand, so treat it that way.
2020-12-15 13:36:27 +01:00
},
"text-decoration-style": {
LibWeb: Mark all text-decoration* CSS properties as not affecting layout
2022-03-16 19:11:25 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Use IdentifierStyleValue for CSS 'text-decoration-line' Also 'text-decoration' is actually a shorthand, so treat it that way.
2020-12-15 13:36:27 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "solid",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"text-decoration-style"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Use IdentifierStyleValue for CSS 'text-decoration-line' Also 'text-decoration' is actually a shorthand, so treat it that way.
2020-12-15 13:36:27 +01:00
},
"text-decoration-thickness": {
LibWeb: Mark all text-decoration* CSS properties as not affecting layout
2022-03-16 19:11:25 +01:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Correct initial values in Properties.json - `align-items`: `normal` is the initial value in the CSS-ALIGN spec, but `stretch` is in CSS-FLEXBOX. The FLEXBOX spec is the one we've actually implemented elsewhere, and ALIGN adds new values with special syntax, so it's not trivial to add it here. - `border-spacing`: `0` is equivalent to `0px 0px` and we don't yet parse the double-value syntax. - `text-decoration-thickness`: Had the wrong value.
2021-11-10 13:27:16 +00:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto",
"from-font"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
"percentages-resolve-to": "length"
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"text-indent": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add support for the text-justify property This commit adds the text-justify property as defined in: https://drafts.csswg.org/css-text/#propdef-text-justify
2022-03-12 19:31:32 +00:00
"text-justify": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Add support for the text-justify property This commit adds the text-justify property as defined in: https://drafts.csswg.org/css-text/#propdef-text-justify
2022-03-12 19:31:32 +00:00
"inherited": true,
"initial": "auto",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"text-justify"
LibWeb: Add support for the text-justify property This commit adds the text-justify property as defined in: https://drafts.csswg.org/css-text/#propdef-text-justify
2022-03-12 19:31:32 +00:00
]
},
LibWeb: Add "text-overflow" property to code generation The CSS property "text-overflow" as well as its valid identifiers are added to the relevant json files for code generation
2024-07-24 20:52:21 +02:00
"text-overflow": {
"affects-layout": false,
"animation-type": "discrete",
"inherited": false,
"initial": "clip",
"valid-types": [
"text-overflow"
]
},
LibWeb: Parse and compute text-shadow property
2022-03-23 21:16:36 +00:00
"text-shadow": {
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "custom",
LibWeb: Parse and compute text-shadow property
2022-03-23 21:16:36 +00:00
"inherited": true,
"initial": "none",
"valid-identifiers": [
"none"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"text-transform": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "none",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"text-transform"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"top": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add transform property to the system This patch adds parsing support as well as all the needed stuctures all over LibWeb to pass Transformations around.
2021-09-18 17:20:00 +02:00
"transform": {
LibWeb: Revert changing transform's animation-type to by-computed-value In the upcoming commits where we properly handle transformation interpolation, it actually becomes easier to change this back to custom, so lets do that since its more correct anyways.
2024-02-28 18:47:49 -07:00
"animation-type": "custom",
LibWeb: Add transform property to the system This patch adds parsing support as well as all the needed stuctures all over LibWeb to pass Transformations around.
2021-09-18 17:20:00 +02:00
"inherited": false,
LibWeb: Mark `transform` property as affecting stacking contexts
2022-07-19 16:05:58 +01:00
"initial": "none",
LibWeb: Don't relayout whenever a CSS transform changes Transforms are a paint-level concept for us, so we should be okay to only update the stacking context tree and repaint. This makes a lot of CSS animations use way less CPU.
2023-07-27 09:54:45 +02:00
"affects-layout": false,
LibWeb/CSS: Mark transform property as resolving percentages as lengths
2025-01-09 15:14:06 +00:00
"affects-stacking-context": true,
"percentages-resolve-to": "length"
LibWeb: Add transform property to the system This patch adds parsing support as well as all the needed stuctures all over LibWeb to pass Transformations around.
2021-09-18 17:20:00 +02:00
},
LibWeb: Parse the CSS transform-box property
2024-01-25 17:02:37 +00:00
"transform-box": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Parse the CSS transform-box property
2024-01-25 17:02:37 +00:00
"inherited": false,
"initial": "view-box",
"affects-layout": false,
"valid-types": [
"transform-box"
]
},
LibWeb: Parse the CSS transform-origin property This is almost a PositionStyleValue, but it's serialized differently, so let's use a StyleValueList with 2 length-percentage values.
2022-03-21 19:11:06 +01:00
"transform-origin": {
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Parse the CSS transform-origin property This is almost a PositionStyleValue, but it's serialized differently, so let's use a StyleValueList with 2 length-percentage values.
2022-03-21 19:11:06 +01:00
"inherited": false,
"initial": "50% 50%",
"max-values": 3,
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Parse the CSS transform-origin property This is almost a PositionStyleValue, but it's serialized differently, so let's use a StyleValueList with 2 length-percentage values.
2022-03-21 19:11:06 +01:00
],
"valid-identifiers": [
"bottom",
"center",
"left",
"right",
"top"
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
],
"percentages-resolve-to": "length"
LibWeb: Parse the CSS transform-origin property This is almost a PositionStyleValue, but it's serialized differently, so let's use a StyleValueList with 2 length-percentage values.
2022-03-21 19:11:06 +01:00
},
LibWeb: Add transition properties to Properties.json
2024-02-19 19:13:45 -07:00
"transition": {
"affects-layout": true,
"inherited": false,
"initial": "none",
"longhands": [
"transition-property",
"transition-duration",
"transition-timing-function",
"transition-delay"
]
},
LibWeb: Resolve the `transition-delay` property
2023-05-27 22:05:48 +02:00
"transition-delay": {
LibWeb: Add transition properties to Properties.json
2024-02-19 19:13:45 -07:00
"affects-layout": true,
"animation-type": "none",
"inherited": false,
"initial": "0s",
"valid-types": [
"time"
]
},
"transition-duration": {
"affects-layout": true,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "none",
LibWeb: Resolve the `transition-delay` property
2023-05-27 22:05:48 +02:00
"inherited": false,
"initial": "0s",
"valid-types": [
LibWeb: Make CSS/Properties.json "logical-aliases-for" an array This allows us to specify all aliases properties instead of just one.
2023-06-06 10:35:16 +02:00
"time"
LibWeb: Resolve the `transition-delay` property
2023-05-27 22:05:48 +02:00
]
},
LibWeb: Add transition properties to Properties.json
2024-02-19 19:13:45 -07:00
"transition-property": {
"affects-layout": true,
"animation-type": "none",
"inherited": false,
"initial": "all",
"valid-types": [
LibWeb/CSS: Add custom-ident blacklists to Properties.json These excluded values use a similar notation to the ranges for numeric types: `![foo,bar,baz]` to exclude `foo`, `bar`, and `baz`.
2025-02-24 14:59:03 +00:00
"custom-ident ![all,none]"
LibWeb: Add transition properties to Properties.json
2024-02-19 19:13:45 -07:00
],
"valid-identifiers": [
"all",
"none"
]
},
"transition-timing-function": {
"affects-layout": true,
"animation-type": "none",
"inherited": false,
"initial": "ease",
"valid-types": [
"easing-function"
]
},
LibWeb: Support individual `translate` CSS property
2024-11-22 16:42:20 +01:00
"translate": {
"animation-type": "custom",
"inherited": false,
"initial": "none",
"affects-layout": false,
"affects-stacking-context": true
},
LibWeb/CSS: Add support for `unicode-bidi` property
2024-10-03 21:09:29 +02:00
"unicode-bidi": {
"animation-type": "none",
"inherited": false,
"initial": "normal",
"valid-types": [
"unicode-bidi"
]
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"user-select": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "auto",
LibWeb: Implement user-select This implements all values of user-select.
2025-01-08 01:51:29 +01:00
"valid-types": [
"user-select"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"vertical-align": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "baseline",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"vertical-align"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add CSS view-transition-name
2025-02-21 17:56:24 +01:00
"view-transition-name": {
"affects-layout": false,
"affects-stacking-context": true,
"animation-type": "discrete",
"inherited": false,
"initial": "none",
"valid-types": [
LibWeb/CSS: Add custom-ident blacklists to Properties.json These excluded values use a similar notation to the ranges for numeric types: `![foo,bar,baz]` to exclude `foo`, `bar`, and `baz`.
2025-02-24 14:59:03 +00:00
"custom-ident ![auto,none]"
LibWeb: Add CSS view-transition-name
2025-02-21 17:56:24 +01:00
],
"valid-identifiers": [
"none"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"visibility": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "custom",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "visible",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"visibility"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"white-space": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Alphabetize property names in Properties.json And add a check to make sure it stays that way!
2023-09-08 20:20:17 +01:00
"inherited": true,
"initial": "normal",
"valid-types": [
"white-space"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"width": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Parse CSS fit-content(<length-percentage>) values Before this change, we only parsed fit-content as a standalone keyword, but CSS-SIZING-3 added it as a function as well. I don't know of anything else in CSS that is overloaded like this, so it ends up looking a little awkward in the implementation. Note that a lot of code had already been prepped for fit-content values to have an argument, we just weren't parsing it.
2025-02-26 18:16:36 +01:00
"fit-content",
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
LibWeb: Add fit-content as a valid size value for CSS width
2023-05-26 18:58:06 +02:00
"auto",
LibWeb: Support `min-content` for `width`, `min-width` and `max-width` We're gonna need to handle this in many more places, this patch only adds it to calculate_inner_width().
2023-05-28 18:24:55 +02:00
"max-content",
"min-content"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Parse the word-break css property
2024-10-25 16:47:05 +01:00
"word-break": {
"animation-type": "discrete",
"initial": "normal",
"inherited": true,
"valid-identifiers": [
"normal",
"keep-all",
"break-all",
"break-word"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"word-spacing": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "normal",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"normal"
],
LibWeb: Generate function for what properties resolve percentages to This is required by "determine the type of a calculation". https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
2023-06-22 16:22:16 +01:00
"percentages-resolve-to": "length",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"word-wrap": {
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "discrete",
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "normal",
"valid-identifiers": [
"anywhere",
"break-word",
"normal"
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
LibWeb: Add `writing-mode` CSS property, and its values Introduce the `writing-mode` property, as specified in https://drafts.csswg.org/css-writing-modes/#block-flow
2024-10-27 22:12:54 +00:00
"writing-mode": {
"animation-type": "none",
"inherited": true,
"initial": "horizontal-tb",
LibWeb/CSS: Use writing-mode enum for writing-mode property
2024-11-04 12:12:27 +00:00
"valid-types": [
"writing-mode"
LibWeb: Add `writing-mode` CSS property, and its values Introduce the `writing-mode` property, as specified in https://drafts.csswg.org/css-writing-modes/#block-flow
2024-10-27 22:12:54 +00:00
]
},
LibWeb: Support `x` and `y` attributes on nested SVGs This allows positioning a child SVG relative to its parent SVG. Note: These have been implemented as CSS properties as in SVG 2, these are geometry properties that can be used in CSS (see https://www.w3.org/TR/SVG/geometry.html), but there is not much browser support for this. It is nicer to implement than the ad-hoc SVG attribute parsing though, so I feel it may make sense to port the rest of the attributes specified here (which should fix some issues with viewport relative sizes).
2024-01-28 17:48:59 +00:00
"x": {
"__comment": "This is an SVG 2 geometry property, see: https://www.w3.org/TR/SVG/geometry.html#X.",
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Support `x` and `y` attributes on nested SVGs This allows positioning a child SVG relative to its parent SVG. Note: These have been implemented as CSS properties as in SVG 2, these are geometry properties that can be used in CSS (see https://www.w3.org/TR/SVG/geometry.html), but there is not much browser support for this. It is nicer to implement than the ad-hoc SVG attribute parsing though, so I feel it may make sense to port the rest of the attributes specified here (which should fix some issues with viewport relative sizes).
2024-01-28 17:48:59 +00:00
"inherited": false,
"initial": "0",
"valid-types": [
"length [-∞,∞]",
"percentage [-∞,∞]"
],
"percentages-resolve-to": "length",
"quirks": [
"unitless-length"
]
},
"y": {
"__comment": "This is an SVG 2 geometry property, see: https://www.w3.org/TR/SVG/geometry.html#Y.",
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibWeb: Support `x` and `y` attributes on nested SVGs This allows positioning a child SVG relative to its parent SVG. Note: These have been implemented as CSS properties as in SVG 2, these are geometry properties that can be used in CSS (see https://www.w3.org/TR/SVG/geometry.html), but there is not much browser support for this. It is nicer to implement than the ad-hoc SVG attribute parsing though, so I feel it may make sense to port the rest of the attributes specified here (which should fix some issues with viewport relative sizes).
2024-01-28 17:48:59 +00:00
"inherited": false,
"initial": "0",
"valid-types": [
"length [-∞,∞]",
"percentage [-∞,∞]"
],
"percentages-resolve-to": "length",
"quirks": [
"unitless-length"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"z-index": {
LibWeb: Only invalidate stacking context tree for opacity/z-index change I came across some websites that change an elements CSS "opacity" in their :hover selectors. That caused us to relayout on hover, which we'd like to avoid. With this patch, we now check if a property only affects the stacking context tree, and if nothing layout-affecting has changed, we only invalidate the stacking context tree, causing it to be rebuilt on next paint or hit test. This makes :hover { opacity: ... } rules much faster. :^)
2022-03-21 10:58:51 +01:00
"affects-layout": false,
"affects-stacking-context": true,
LibWeb: Add a way to test if a CSS::PropertyID is animatable
2023-10-31 19:33:58 -07:00
"animation-type": "by-computed-value",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "auto",
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"integer [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
}
}
Reference in a new issue Copy permalink