From 1e380a8ef9204637c17bf95fdcae42654010d976 Mon Sep 17 00:00:00 2001 From: Nate Moore Date: Thu, 12 Nov 2026 21:38:31 -0500 Subject: [PATCH 1/3] feat(wpt): add framework profiles mapping measured dom features to wpt cases --- .changeset/wpt-framework-profiles.md | 5 + .../src/frameworks/features.ts | 193 +++++++++++++++++ .../src/frameworks/frameworks.ts | 205 ++++++++++++++++++ packages/web-platform-tests/src/index.ts | 8 + .../test/frameworks.test.ts | 75 +++++++ 5 files changed, 486 insertions(+) create mode 100644 .changeset/wpt-framework-profiles.md create mode 100644 packages/web-platform-tests/src/frameworks/features.ts create mode 100644 packages/web-platform-tests/src/frameworks/frameworks.ts create mode 100644 packages/web-platform-tests/test/frameworks.test.ts diff --git a/.changeset/wpt-framework-profiles.md b/.changeset/wpt-framework-profiles.md new file mode 100644 index 0000000..a8d2e66 --- /dev/null +++ b/.changeset/wpt-framework-profiles.md @@ -0,0 +1,5 @@ +--- +'@bomb.sh/web-platform-tests': patch +--- + +Adds framework profiles that map the DOM features React, Preact, Vue, Solid, and Svelte use to the WPT cases covering them. `frameworkSelectors()` returns selectors for a framework and its optional modules, and `uncoveredFeatures()` lists required features without adapted WPT coverage. diff --git a/packages/web-platform-tests/src/frameworks/features.ts b/packages/web-platform-tests/src/frameworks/features.ts new file mode 100644 index 0000000..ee2bad7 --- /dev/null +++ b/packages/web-platform-tests/src/frameworks/features.ts @@ -0,0 +1,193 @@ +import type { WPTSelectors } from '../shared/selection.ts'; + +/** + * DOM members measured in framework runtimes, keyed by interface member, mapped to the adapted + * WPT cases that exercise them. An empty selector map means no adapted WPT source covers the + * member yet; it stays listed so profiles keep recording the requirement. + */ +export const features = { + // Document + 'Document#createElement': { 'dom/nodes/Document-createElement.html': true }, + 'Document#createElementNS': { 'dom/nodes/Document-createElementNS.html': true }, + 'Document#createTextNode': { 'dom/nodes/Document-createTextNode.html': true }, + 'Document#createComment': { 'dom/nodes/Document-createComment.html': true }, + 'Document#createDocumentFragment': {}, + 'Document#activeElement': { 'html/editing/focus/focus-management/focus-blur.html': true }, + 'Document#defaultView': {}, + 'Document#head': {}, + 'Document#importNode': { + 'dom/nodes/Document-importNode.html': [/'deep' argument\.$/], + }, + 'Document#createTreeWalker': { + 'dom/traversal/TreeWalker-basic.html': true, + 'dom/traversal/TreeWalker-acceptNode-filter.html': true, + 'dom/traversal/TreeWalker-traversal-reject.html': true, + 'dom/traversal/TreeWalker-traversal-skip.html': true, + }, + 'Document#createRange': { + 'dom/ranges/Range-constructor.html': true, + 'dom/ranges/Range-attributes.html': true, + }, + + // Node + 'Node#nodeType': {}, + 'Node#ownerDocument': {}, + 'Node#parentNode': { + 'dom/nodes/Node-parentNode.html': ['sets the parent of an appended element', 'Root element'], + }, + 'Node#firstChild': {}, + 'Node#lastChild': {}, + 'Node#nextSibling': {}, + 'Node#childNodes': { 'dom/nodes/Node-childNodes.html': true }, + 'Node#insertBefore': { 'dom/nodes/Node-insertBefore.html': true }, + 'Node#appendChild': {}, + 'Node#removeChild': { 'dom/nodes/Node-removeChild.html': true }, + 'Node#replaceChild': { 'dom/nodes/Node-replaceChild.html': true }, + 'Node#cloneNode': { 'dom/nodes/Node-cloneNode.html': true }, + // Frameworks never create ProcessingInstruction or DocumentType nodes, nor set Document text. + 'Node#textContent': { + 'dom/nodes/Node-textContent.html': [/^(?!.*(ProcessingInstruction|DocumentType|Documents))/], + }, + 'Node#nodeValue': { 'dom/nodes/Node-nodeValue.html': ['Text.nodeValue', 'Comment.nodeValue'] }, + 'Node#contains': { 'dom/nodes/Node-contains.html': true }, + 'Node#getRootNode': {}, + 'Node#isConnected': { 'dom/nodes/Node-isConnected.html': true }, + 'Node#compareDocumentPosition': { 'dom/nodes/Node-compareDocumentPosition.html': true }, + + // ChildNode / ParentNode / CharacterData + 'ChildNode#remove': { + 'dom/nodes/Element-remove.html': true, + 'dom/nodes/CharacterData-remove.html': [ + /^(text|comment) should support remove\(\)$/, + /if (text|comment) /, + ], + }, + 'ChildNode#before': {}, + 'ParentNode#moveBefore': {}, + 'ChildNode#after': {}, + 'ParentNode#children': { 'dom/nodes/ParentNode-children.html': true }, + 'CharacterData#data': { 'dom/nodes/CharacterData-data.html': true }, + + // Element + 'Element#setAttribute': { + 'dom/nodes/Element-setAttribute.html': true, + 'dom/nodes/Element-setAttribute-crbug-1138487.html': true, + 'dom/nodes/attributes.html': [/\bsetAttribute\b/], + }, + 'Element#getAttribute': { + 'dom/nodes/attributes.html': [ + 'Unset attributes return null', + 'First set attribute is returned by getAttribute', + 'Only lowercase attributes are returned on HTML elements (upper case attribute)', + 'Only lowercase attributes are returned on HTML elements (mixed case attribute)', + ], + }, + 'Element#namespaceURI': { 'dom/nodes/Document-createElementNS.html': true }, + 'Element#localName': { + 'dom/nodes/Document-createElement.html': true, + 'dom/nodes/Document-createElementNS.html': true, + }, + 'Element#removeAttribute': { 'dom/nodes/Element-removeAttribute.html': true }, + 'Element#className': { 'html/dom/reflection-misc.html': [/^html\.className /] }, + 'Element#classList': { 'dom/nodes/Element-classlist.html': true }, + 'Element#innerHTML': { + 'domparsing/innerhtml-04.html': true, + 'domparsing/innerhtml-07.html': true, + 'domparsing/innerhtml-08.html': true, + 'domparsing/innerhtml-li-autoclosing.html': true, + 'html/syntax/serializing-html-fragments/serializing.html': [/^innerHTML /], + }, + // Svelte's select binding queries `:checked`, `[selected]`, and `option:not([disabled])` only. + 'Element#querySelector': { 'html/semantics/selectors/pseudo-classes/checked.html': true }, + 'DocumentFragment#querySelectorAll': { + 'dom/nodes/DocumentFragment-querySelectorAll-after-modification.html': true, + }, + 'Element#attachShadow': { 'shadow-dom/Element-interface-attachShadow.html': true }, + + // HTMLElement and CSSOM + 'HTMLElement#style': { + 'css/cssom/css-style-attr-decl-block.html': true, + 'css/cssom/css-style-attribute-modifications.html': true, + 'css/cssom/CSSStyleDeclaration-indexed-properties.html': true, + }, + 'CSSStyleDeclaration#setProperty': { 'css/cssom/cssom-setProperty-shorthand.html': true }, + getComputedStyle: { 'css/cssom/computed-style-001.html': true }, + 'HTMLElement#contentEditable': {}, + 'HTMLElement#focus': { + 'html/editing/focus/focus-management/focus-blur.html': true, + 'html/interaction/focus/focus-management/focus-events.html': true, + }, + 'HTMLTemplateElement#content': { + 'html/semantics/scripting-1/the-template-element/definitions/template-contents.html': true, + 'html/semantics/scripting-1/the-template-element/innerhtml-on-templates/innerhtml.html': true, + 'html/semantics/scripting-1/the-template-element/additions-to-the-steps-to-clone-a-node/template-clone-children.html': true, + }, + + // Form controls. Reflection must use prototype accessors (React's value tracker); no WPT covers that. + 'HTMLInputElement#value': { + 'html/semantics/forms/the-input-element/input-value-dirty-flag.html': true, + 'html/semantics/forms/the-input-element/text.html': [/^(Value returns|Setting value changes)/], + }, + 'HTMLInputElement#checked': { + 'html/semantics/forms/the-input-element/input-value-dirty-flag.html': [ + 'Input checked/defaultChecked dirty checkedness semantics', + ], + 'html/semantics/forms/the-input-element/checkbox-click-events.html': true, + }, + 'HTMLInputElement#setSelectionRange': { + 'html/semantics/forms/textfieldselection/selection.html': true, + }, + 'HTMLTextAreaElement#value': { + 'html/semantics/forms/the-textarea-element/value-defaultValue-textContent.html': true, + }, + 'HTMLOptionElement#value': { 'html/semantics/forms/the-option-element/option-value.html': true }, + 'HTMLOptionElement#selected': { + 'html/semantics/forms/the-option-element/option-selected.html': true, + }, + 'HTMLSelectElement#value': { + 'html/semantics/forms/the-select-element/select-value.html': true, + 'html/semantics/forms/the-select-element/selected-index.html': true, + }, + + // Events + 'EventTarget#addEventListener': { + 'dom/events/EventTarget-addEventListener.any.js': true, + 'dom/events/EventTarget-add-remove-listener.any.js': true, + 'dom/events/AddEventListenerOptions-once.any.js': true, + 'dom/events/AddEventListenerOptions-passive.any.js': true, + 'dom/events/AddEventListenerOptions-signal.any.js': true, + 'dom/events/EventListenerOptions-capture.html': true, + 'dom/events/EventListener-handleEvent.html': true, + 'dom/events/EventTarget-this-of-listener.html': true, + }, + 'EventTarget#removeEventListener': { + 'dom/events/EventTarget-removeEventListener.any.js': true, + 'dom/events/remove-all-listeners.html': true, + }, + // Capture/target/bubble over the ancestor path, with target/currentTarget maintenance. + 'EventTarget#dispatchEvent': { + 'dom/events/EventTarget-dispatchEvent.html': true, + 'dom/events/EventTarget-dispatchEvent-returnvalue.html': true, + 'dom/events/Event-dispatch-bubbles-false.html': true, + 'dom/events/Event-dispatch-bubbles-true.html': true, + 'dom/events/Event-dispatch-handlers-changed.html': true, + 'dom/events/Event-dispatch-multiple-cancelBubble.html': true, + 'dom/events/Event-dispatch-multiple-stopPropagation.html': true, + 'dom/events/Event-dispatch-propagation-stopped.html': true, + 'dom/events/Event-dispatch-reenter.html': true, + 'dom/events/Event-dispatch-target-moved.html': true, + 'dom/events/Event-dispatch-throwing.html': true, + 'dom/events/Event-stopImmediatePropagation.html': true, + 'dom/events/Event-defaultPrevented-after-dispatch.html': true, + }, + Event: { 'dom/events/Event-constructors.any.js': true }, + 'Event#composedPath': { + 'shadow-dom/event-composed-path.html': ['Event Path without ShadowRoots.'], + }, + 'Event#isTrusted': {}, + 'MutationObserver#childList': { + 'dom/nodes/MutationObserver-childList.html': [/^childList (?!Range\.|Node\.normalize)/], + }, +} as const satisfies Record; + +export type DOMFeature = keyof typeof features; diff --git a/packages/web-platform-tests/src/frameworks/frameworks.ts b/packages/web-platform-tests/src/frameworks/frameworks.ts new file mode 100644 index 0000000..b3c4842 --- /dev/null +++ b/packages/web-platform-tests/src/frameworks/frameworks.ts @@ -0,0 +1,205 @@ +import { CompatibilityConfigurationError, type WPTSelectors } from '../shared/selection.ts'; +import { features, type DOMFeature } from './features.ts'; + +interface FrameworkProfile { + /** Non-hydrated mount, update, and unmount of a typical application. */ + required: readonly DOMFeature[]; + /** Opt-in renderer modules, each enabled only when the integration supports it. */ + optional: Readonly>; +} + +/** Shared by every measured framework. */ +const core = [ + 'Element#innerHTML', + 'Element#setAttribute', + 'EventTarget#addEventListener', + 'EventTarget#dispatchEvent', + 'Event', + 'HTMLElement#style', + 'CSSStyleDeclaration#setProperty', + 'Document#createTextNode', + 'Node#nodeType', + 'HTMLInputElement#value', + 'HTMLInputElement#checked', + 'HTMLTextAreaElement#value', +] as const satisfies readonly DOMFeature[]; + +/** + * Measured DOM baseline per framework, from the non-hydrated happy-dom recorder study. + * Preact is re-checked against the 11.0.1 source. + */ +export const frameworks = { + react: { + required: [ + ...core, + 'Document#createElement', + 'Document#createElementNS', + 'Node#insertBefore', + 'Node#firstChild', + 'Node#textContent', + 'Node#ownerDocument', + 'Element#removeAttribute', + 'Node#nodeValue', + 'Node#appendChild', + 'Node#removeChild', + 'HTMLOptionElement#value', + 'HTMLOptionElement#selected', + 'HTMLSelectElement#value', + 'Document#activeElement', + 'Document#defaultView', + 'Document#head', + 'Node#lastChild', + 'Node#getRootNode', + 'Node#contains', + 'HTMLElement#contentEditable', + 'Event#composedPath', + 'Event#isTrusted', + ], + optional: { + selection: [ + 'Document#createRange', + 'HTMLInputElement#setSelectionRange', + 'Node#compareDocumentPosition', + ], + }, + }, + preact: { + required: [ + ...core, + 'Document#createElementNS', + 'Node#insertBefore', + 'Node#firstChild', + 'Node#nextSibling', + 'Node#parentNode', + 'ChildNode#remove', + 'Node#ownerDocument', + 'Node#childNodes', + 'Element#namespaceURI', + 'Element#localName', + 'CharacterData#data', + 'EventTarget#removeEventListener', + ], + // Feature-detected; falls back to insertBefore. + optional: { moveBefore: ['ParentNode#moveBefore'] }, + }, + vue: { + required: [ + ...core, + 'Document#createElement', + 'Document#createElementNS', + 'Document#createComment', + 'Node#insertBefore', + 'Node#nextSibling', + 'Node#parentNode', + 'Node#textContent', + 'Element#className', + 'Element#removeAttribute', + 'Element#getAttribute', + 'Node#nodeValue', + 'Node#removeChild', + 'HTMLOptionElement#value', + 'HTMLOptionElement#selected', + 'HTMLSelectElement#value', + 'EventTarget#removeEventListener', + ], + optional: { + hydration: ['Document#createTreeWalker', 'Node#childNodes'], + transitions: ['getComputedStyle', 'Element#classList'], + customElements: ['Element#attachShadow', 'Node#isConnected'], + }, + }, + solid: { + required: [ + ...core, + 'Document#createElement', + 'Document#createElementNS', + 'Node#insertBefore', + 'Node#firstChild', + 'Node#nextSibling', + 'Node#parentNode', + 'Node#textContent', + 'ChildNode#remove', + 'Element#className', + 'Element#classList', + 'Node#appendChild', + 'Node#cloneNode', + 'Node#replaceChild', + 'HTMLTemplateElement#content', + 'Event#composedPath', + ], + optional: { + hydration: ['Document#importNode', 'DocumentFragment#querySelectorAll', 'Node#isConnected'], + }, + }, + svelte: { + required: [ + ...core, + 'Document#createElement', + 'Document#createDocumentFragment', + 'Node#firstChild', + 'Node#lastChild', + 'Node#nextSibling', + 'Node#parentNode', + 'ChildNode#remove', + 'ChildNode#before', + 'ChildNode#after', + 'Node#ownerDocument', + 'Element#className', + 'Node#nodeValue', + 'CharacterData#data', + 'Node#appendChild', + 'Node#removeChild', + 'Node#cloneNode', + 'HTMLTemplateElement#content', + 'HTMLOptionElement#value', + 'HTMLOptionElement#selected', + 'HTMLSelectElement#value', + 'Document#activeElement', + 'EventTarget#removeEventListener', + 'Element#querySelector', + 'ParentNode#children', + 'MutationObserver#childList', + 'Event#composedPath', + ], + optional: { + hydration: ['DocumentFragment#querySelectorAll', 'Element#getAttribute'], + }, + }, +} as const satisfies Record; + +export type Framework = keyof typeof frameworks; + +/** Union of the WPT cases covering the given features. */ +export function featureSelectors(names: Iterable): WPTSelectors { + const merged: Record = {}; + for (const name of names) { + for (const [source, cases] of Object.entries(features[name] as WPTSelectors)) { + const current = merged[source]; + if (current === true || cases === true) merged[source] = true; + else merged[source] = [...new Set([...(current ?? []), ...cases])]; + } + } + return merged; +} + +/** WPT cases a framework requires, plus any named optional modules. */ +export function frameworkSelectors( + framework: Framework, + modules: readonly string[] = [], +): WPTSelectors { + const { required, optional } = frameworks[framework] as FrameworkProfile; + const extra = modules.flatMap((name) => { + const module = optional[name]; + if (!module) + throw new CompatibilityConfigurationError(`${framework} has no optional module ${name}`); + return module; + }); + return featureSelectors([...required, ...extra]); +} + +/** Required features with no adapted WPT coverage yet. */ +export function uncoveredFeatures(framework: Framework): DOMFeature[] { + return [...new Set(frameworks[framework].required)].filter( + (name) => Object.keys(features[name]).length === 0, + ); +} diff --git a/packages/web-platform-tests/src/index.ts b/packages/web-platform-tests/src/index.ts index 3379a73..b0cd5d1 100644 --- a/packages/web-platform-tests/src/index.ts +++ b/packages/web-platform-tests/src/index.ts @@ -7,6 +7,14 @@ export type { WPTConfig, WPTSelectors, } from './shared/test-dom-compatibility.ts'; +export { features, type DOMFeature } from './frameworks/features.ts'; +export { + frameworks, + featureSelectors, + frameworkSelectors, + uncoveredFeatures, + type Framework, +} from './frameworks/frameworks.ts'; export type { CompatibilityRunner, CompatibilityExpect, diff --git a/packages/web-platform-tests/test/frameworks.test.ts b/packages/web-platform-tests/test/frameworks.test.ts new file mode 100644 index 0000000..02b1700 --- /dev/null +++ b/packages/web-platform-tests/test/frameworks.test.ts @@ -0,0 +1,75 @@ +import { describe, expect, it } from 'vitest'; +import { features, type DOMFeature } from '../src/frameworks/features.ts'; +import { + frameworks, + frameworkSelectors, + featureSelectors, + uncoveredFeatures, + type Framework, +} from '../src/frameworks/frameworks.ts'; +import { registry } from '../src/shared/registry.ts'; +import { CompatibilityConfigurationError, selectTests } from '../src/shared/selection.ts'; + +const cases = Object.entries(registry).flatMap(([source, module]) => { + const names: { source: string; name: string }[] = []; + module.register({ + runner: {} as never, + test(name) { + names.push({ source, name }); + }, + }); + return names; +}); + +function selected( + include: ReturnType, +): { source: string; name: string }[] { + return selectTests(cases, { include, exclude: { '**': true } }); +} + +describe('feature selectors', () => { + for (const [name, selectors] of Object.entries(features)) { + if (Object.keys(selectors).length === 0) continue; + it(`${name} matches registered cases`, () => { + expect(selected(featureSelectors([name as DOMFeature])).length).toBeGreaterThan(0); + }); + } +}); + +describe('framework profiles', () => { + for (const [framework, profile] of Object.entries(frameworks)) { + it(`${framework} resolves against the registry`, () => { + expect(selected(frameworkSelectors(framework as Framework)).length).toBeGreaterThan(0); + for (const module of Object.keys(profile.optional)) + selected(frameworkSelectors(framework as Framework, [module])); + }); + } + + it('rejects unknown optional modules', () => { + expect(() => frameworkSelectors('preact', ['hydration'])).toThrow( + CompatibilityConfigurationError, + ); + }); + + it('reports required features without WPT coverage', () => { + expect(uncoveredFeatures('preact')).toEqual([ + 'Node#nodeType', + 'Node#firstChild', + 'Node#nextSibling', + 'Node#ownerDocument', + ]); + }); + + it('merges whole-source selection over case lists', () => { + expect( + featureSelectors(['Element#setAttribute', 'Element#getAttribute'])[ + 'dom/nodes/attributes.html' + ], + ).toHaveLength(5); + expect( + featureSelectors(['HTMLInputElement#checked', 'HTMLInputElement#value'])[ + 'html/semantics/forms/the-input-element/input-value-dirty-flag.html' + ], + ).toBe(true); + }); +}); From 7f5429fc8784cece46fdaf7a60f27f0be5ead742 Mon Sep 17 00:00:00 2001 From: Nate Moore Date: Thu, 12 Nov 2026 22:50:55 -0500 Subject: [PATCH 2/3] ref(wpt): rename profile helpers to framework() and uncoveredByWPT() --- .changeset/wpt-framework-profiles.md | 2 +- .../src/frameworks/frameworks.ts | 23 ++++++++----------- packages/web-platform-tests/src/index.ts | 4 ++-- .../test/frameworks.test.ts | 21 +++++++++-------- 4 files changed, 24 insertions(+), 26 deletions(-) diff --git a/.changeset/wpt-framework-profiles.md b/.changeset/wpt-framework-profiles.md index a8d2e66..3fd7e15 100644 --- a/.changeset/wpt-framework-profiles.md +++ b/.changeset/wpt-framework-profiles.md @@ -2,4 +2,4 @@ '@bomb.sh/web-platform-tests': patch --- -Adds framework profiles that map the DOM features React, Preact, Vue, Solid, and Svelte use to the WPT cases covering them. `frameworkSelectors()` returns selectors for a framework and its optional modules, and `uncoveredFeatures()` lists required features without adapted WPT coverage. +Adds framework profiles that map the DOM features React, Preact, Vue, Solid, and Svelte use to the WPT cases covering them. `framework()` returns selectors for a framework and its optional modules, and `uncoveredByWPT()` lists required features without adapted WPT coverage. diff --git a/packages/web-platform-tests/src/frameworks/frameworks.ts b/packages/web-platform-tests/src/frameworks/frameworks.ts index b3c4842..e95ff13 100644 --- a/packages/web-platform-tests/src/frameworks/frameworks.ts +++ b/packages/web-platform-tests/src/frameworks/frameworks.ts @@ -183,23 +183,20 @@ export function featureSelectors(names: Iterable): WPTSelectors { } /** WPT cases a framework requires, plus any named optional modules. */ -export function frameworkSelectors( - framework: Framework, - modules: readonly string[] = [], -): WPTSelectors { - const { required, optional } = frameworks[framework] as FrameworkProfile; - const extra = modules.flatMap((name) => { - const module = optional[name]; - if (!module) - throw new CompatibilityConfigurationError(`${framework} has no optional module ${name}`); - return module; +export function framework(name: Framework, modules: readonly string[] = []): WPTSelectors { + const { required, optional } = frameworks[name] as FrameworkProfile; + const extra = modules.flatMap((module) => { + const listed = optional[module]; + if (!listed) + throw new CompatibilityConfigurationError(`${name} has no optional module ${module}`); + return listed; }); return featureSelectors([...required, ...extra]); } /** Required features with no adapted WPT coverage yet. */ -export function uncoveredFeatures(framework: Framework): DOMFeature[] { - return [...new Set(frameworks[framework].required)].filter( - (name) => Object.keys(features[name]).length === 0, +export function uncoveredByWPT(name: Framework): DOMFeature[] { + return [...new Set(frameworks[name].required)].filter( + (feature) => Object.keys(features[feature]).length === 0, ); } diff --git a/packages/web-platform-tests/src/index.ts b/packages/web-platform-tests/src/index.ts index b0cd5d1..968edd8 100644 --- a/packages/web-platform-tests/src/index.ts +++ b/packages/web-platform-tests/src/index.ts @@ -11,8 +11,8 @@ export { features, type DOMFeature } from './frameworks/features.ts'; export { frameworks, featureSelectors, - frameworkSelectors, - uncoveredFeatures, + framework, + uncoveredByWPT, type Framework, } from './frameworks/frameworks.ts'; export type { diff --git a/packages/web-platform-tests/test/frameworks.test.ts b/packages/web-platform-tests/test/frameworks.test.ts index 02b1700..094b0eb 100644 --- a/packages/web-platform-tests/test/frameworks.test.ts +++ b/packages/web-platform-tests/test/frameworks.test.ts @@ -1,10 +1,13 @@ +// Framework profiles select WPT cases by source path and case name, but nothing resolves those +// selectors until a consumer calls `framework()`. Resolving every profile here keeps renamed or +// removed upstream cases from leaving stale selectors behind. import { describe, expect, it } from 'vitest'; import { features, type DOMFeature } from '../src/frameworks/features.ts'; import { frameworks, - frameworkSelectors, + framework, featureSelectors, - uncoveredFeatures, + uncoveredByWPT, type Framework, } from '../src/frameworks/frameworks.ts'; import { registry } from '../src/shared/registry.ts'; @@ -37,22 +40,20 @@ describe('feature selectors', () => { }); describe('framework profiles', () => { - for (const [framework, profile] of Object.entries(frameworks)) { - it(`${framework} resolves against the registry`, () => { - expect(selected(frameworkSelectors(framework as Framework)).length).toBeGreaterThan(0); + for (const [name, profile] of Object.entries(frameworks)) { + it(`${name} resolves against the registry`, () => { + expect(selected(framework(name as Framework)).length).toBeGreaterThan(0); for (const module of Object.keys(profile.optional)) - selected(frameworkSelectors(framework as Framework, [module])); + selected(framework(name as Framework, [module])); }); } it('rejects unknown optional modules', () => { - expect(() => frameworkSelectors('preact', ['hydration'])).toThrow( - CompatibilityConfigurationError, - ); + expect(() => framework('preact', ['hydration'])).toThrow(CompatibilityConfigurationError); }); it('reports required features without WPT coverage', () => { - expect(uncoveredFeatures('preact')).toEqual([ + expect(uncoveredByWPT('preact')).toEqual([ 'Node#nodeType', 'Node#firstChild', 'Node#nextSibling', From 6f3653749bac03ea2a83e1d2412d02c90251a0b7 Mon Sep 17 00:00:00 2001 From: Nate Moore Date: Thu, 12 Nov 2026 22:54:37 -0500 Subject: [PATCH 3/3] fix(wpt): update framework profiles from recorded dom usage --- .changeset/wpt-framework-profiles.md | 2 +- .../src/frameworks/features.ts | 41 +++++++++++++++++++ .../src/frameworks/frameworks.ts | 41 ++++++++++++++++--- .../test/frameworks.test.ts | 3 +- 4 files changed, 79 insertions(+), 8 deletions(-) diff --git a/.changeset/wpt-framework-profiles.md b/.changeset/wpt-framework-profiles.md index 3fd7e15..d486bbb 100644 --- a/.changeset/wpt-framework-profiles.md +++ b/.changeset/wpt-framework-profiles.md @@ -2,4 +2,4 @@ '@bomb.sh/web-platform-tests': patch --- -Adds framework profiles that map the DOM features React, Preact, Vue, Solid, and Svelte use to the WPT cases covering them. `framework()` returns selectors for a framework and its optional modules, and `uncoveredByWPT()` lists required features without adapted WPT coverage. +Adds framework profiles that map the DOM features React 19.3, Preact 11.2, Vue 3.5, Solid 1.9, and Svelte 5.57 use to the WPT cases covering them. `framework()` returns selectors for a framework and its optional modules, and `uncoveredByWPT()` lists required features without adapted WPT coverage. diff --git a/packages/web-platform-tests/src/frameworks/features.ts b/packages/web-platform-tests/src/frameworks/features.ts index ee2bad7..2dfedfb 100644 --- a/packages/web-platform-tests/src/frameworks/features.ts +++ b/packages/web-platform-tests/src/frameworks/features.ts @@ -15,6 +15,8 @@ export const features = { 'Document#activeElement': { 'html/editing/focus/focus-management/focus-blur.html': true }, 'Document#defaultView': {}, 'Document#head': {}, + 'Document#documentElement': {}, + 'Document#contentType': {}, 'Document#importNode': { 'dom/nodes/Document-importNode.html': [/'deep' argument\.$/], }, @@ -87,6 +89,9 @@ export const features = { 'dom/nodes/Document-createElement.html': true, 'dom/nodes/Document-createElementNS.html': true, }, + 'Element#id': {}, + 'Element#tagName': {}, + 'Element#nodeName': {}, 'Element#removeAttribute': { 'dom/nodes/Element-removeAttribute.html': true }, 'Element#className': { 'html/dom/reflection-misc.html': [/^html\.className /] }, 'Element#classList': { 'dom/nodes/Element-classlist.html': true }, @@ -128,6 +133,35 @@ export const features = { 'html/semantics/forms/the-input-element/input-value-dirty-flag.html': true, 'html/semantics/forms/the-input-element/text.html': [/^(Value returns|Setting value changes)/], }, + 'HTMLInputElement#type': { + 'html/semantics/forms/the-input-element/input-value-dirty-flag.html': [ + "Input type defaults to 'text' on the property despite no attribute", + 'Setting input type property sets the attribute', + ], + }, + 'HTMLInputElement#name': {}, + 'HTMLInputElement#defaultValue': { + 'html/semantics/forms/the-input-element/input-value-dirty-flag.html': [ + 'Input value/defaultValue dirty value flag semantics', + ], + }, + 'HTMLInputElement#defaultChecked': { + 'html/semantics/forms/the-input-element/input-value-dirty-flag.html': [ + 'Input checked/defaultChecked dirty checkedness semantics', + ], + }, + 'HTMLInputElement#selectionStart': { + 'html/semantics/forms/textfieldselection/defaultSelection.html': true, + }, + 'HTMLInputElement#selectionEnd': { + 'html/semantics/forms/textfieldselection/defaultSelection.html': true, + }, + 'HTMLInputElement#disabled': { 'html/semantics/selectors/pseudo-classes/disabled.html': true }, + 'HTMLButtonElement#disabled': { 'html/semantics/selectors/pseudo-classes/disabled.html': true }, + 'HTMLTextAreaElement#disabled': { + 'html/semantics/selectors/pseudo-classes/disabled.html': true, + }, + 'HTMLOptionElement#disabled': { 'html/semantics/selectors/pseudo-classes/disabled.html': true }, 'HTMLInputElement#checked': { 'html/semantics/forms/the-input-element/input-value-dirty-flag.html': [ 'Input checked/defaultChecked dirty checkedness semantics', @@ -140,6 +174,9 @@ export const features = { 'HTMLTextAreaElement#value': { 'html/semantics/forms/the-textarea-element/value-defaultValue-textContent.html': true, }, + 'HTMLTextAreaElement#defaultValue': { + 'html/semantics/forms/the-textarea-element/value-defaultValue-textContent.html': true, + }, 'HTMLOptionElement#value': { 'html/semantics/forms/the-option-element/option-value.html': true }, 'HTMLOptionElement#selected': { 'html/semantics/forms/the-option-element/option-selected.html': true, @@ -184,7 +221,11 @@ export const features = { 'Event#composedPath': { 'shadow-dom/event-composed-path.html': ['Event Path without ShadowRoots.'], }, + // React feature-detects event support through handler IDL attributes. + 'GlobalEventHandlers#onclick': {}, 'Event#isTrusted': {}, + 'MutationObserver#observe': { 'dom/nodes/MutationObserver-sanity.html': true }, + 'MutationObserver#disconnect': { 'dom/nodes/MutationObserver-takeRecords.html': true }, 'MutationObserver#childList': { 'dom/nodes/MutationObserver-childList.html': [/^childList (?!Range\.|Node\.normalize)/], }, diff --git a/packages/web-platform-tests/src/frameworks/frameworks.ts b/packages/web-platform-tests/src/frameworks/frameworks.ts index e95ff13..d55614d 100644 --- a/packages/web-platform-tests/src/frameworks/frameworks.ts +++ b/packages/web-platform-tests/src/frameworks/frameworks.ts @@ -21,12 +21,13 @@ const core = [ 'Node#nodeType', 'HTMLInputElement#value', 'HTMLInputElement#checked', + 'HTMLInputElement#type', 'HTMLTextAreaElement#value', ] as const satisfies readonly DOMFeature[]; /** * Measured DOM baseline per framework, from the non-hydrated happy-dom recorder study. - * Preact is re-checked against the 11.0.1 source. + * Recorded against React 19.3.1, Preact 11.2.0, Vue 3.5.45, Solid 1.9.19, and Svelte 5.57.3. */ export const frameworks = { react: { @@ -47,15 +48,28 @@ export const frameworks = { 'HTMLSelectElement#value', 'Document#activeElement', 'Document#defaultView', - 'Document#head', + 'Document#documentElement', 'Node#lastChild', 'Node#getRootNode', 'Node#contains', 'HTMLElement#contentEditable', 'Event#composedPath', 'Event#isTrusted', + 'Element#namespaceURI', + 'Element#tagName', + 'Element#nodeName', + 'GlobalEventHandlers#onclick', + 'HTMLInputElement#name', + 'HTMLInputElement#defaultValue', + 'HTMLInputElement#defaultChecked', + 'HTMLInputElement#selectionStart', + 'HTMLInputElement#selectionEnd', + 'HTMLTextAreaElement#defaultValue', + 'HTMLOptionElement#disabled', ], optional: { + // Resource hoisting inserts ,