@webref/idl 3.2.1 → 3.5.0

package/clipboard-apis.idl

@@ -17,31 +17,14 @@ partial interface Navigator {
   [SecureContext, SameObject] readonly attribute Clipboard clipboard;
 };
 
-typedef sequence<ClipboardItem> ClipboardItems;
-
-[SecureContext, Exposed=Window] interface Clipboard : EventTarget {
-  Promise<ClipboardItems> read();
-  Promise<DOMString> readText();
-  Promise<undefined> write(ClipboardItems data);
-  Promise<undefined> writeText(DOMString data);
-};
-
-typedef (DOMString or Blob) ClipboardItemDataType;
-typedef Promise<ClipboardItemDataType> ClipboardItemData;
-
-callback ClipboardItemDelayedCallback = ClipboardItemData ();
+typedef Promise<(DOMString or Blob)> ClipboardItemData;
 
-[Exposed=Window] interface ClipboardItem {
+[SecureContext, Exposed=Window]
+interface ClipboardItem {
   constructor(record<DOMString, ClipboardItemData> items,
-    optional ClipboardItemOptions options = {});
-  static ClipboardItem createDelayed(
-      record<DOMString, ClipboardItemDelayedCallback> items,
-      optional ClipboardItemOptions options = {});
+              optional ClipboardItemOptions options = {});
 
   readonly attribute PresentationStyle presentationStyle;
-  readonly attribute long long lastModified;
-  readonly attribute boolean delayed;
-
   readonly attribute FrozenArray<DOMString> types;
 
   Promise<Blob> getType(DOMString type);
@@ -53,6 +36,16 @@ dictionary ClipboardItemOptions {
   PresentationStyle presentationStyle = "unspecified";
 };
 
+typedef sequence<ClipboardItem> ClipboardItems;
+
+[SecureContext, Exposed=Window]
+interface Clipboard : EventTarget {
+  Promise<ClipboardItems> read();
+  Promise<DOMString> readText();
+  Promise<undefined> write(ClipboardItems data);
+  Promise<undefined> writeText(DOMString data);
+};
+
 dictionary ClipboardPermissionDescriptor : PermissionDescriptor {
   boolean allowWithoutGesture = false;
 };

package/close-watcher.idl

@@ -5,11 +5,15 @@
 
 [Exposed=Window]
 interface CloseWatcher : EventTarget {
-  constructor();
+  constructor(optional CloseWatcherOptions options = {});
 
   undefined destroy();
-  undefined signalClose();
+  undefined close();
 
   attribute EventHandler oncancel;
   attribute EventHandler onclose;
 };
+
+dictionary CloseWatcherOptions {
+  AbortSignal signal;
+};

package/compute-pressure.idl

@@ -1,36 +1,40 @@
 // GENERATED CONTENT - DO NOT EDIT
 // Content was automatically extracted by Reffy into webref
 // (https://github.com/w3c/webref)
-// Source: Compute Pressure API (https://wicg.github.io/compute-pressure/)
+// Source: Compute Pressure API Level 1 (https://wicg.github.io/compute-pressure/)
 
-enum PressureState { "nominal", "fair", "serious", "critical" };
+enum ComputePressureState { "nominal", "fair", "serious", "critical" };
+
+enum ComputePressureFactor { "thermal", "power-supply" };
 
 callback ComputePressureUpdateCallback = undefined (
   sequence<ComputePressureRecord> changes,
   ComputePressureObserver observer
 );
 
-enum ComputePressureTarget { "cpu" };
+enum ComputePressureSource { "cpu" };
 
 [Exposed=(DedicatedWorker,SharedWorker,Window), SecureContext]
 interface ComputePressureObserver {
-  constructor(ComputePressureUpdateCallback callback);
+  constructor(ComputePressureUpdateCallback callback, optional ComputePressureObserverOptions options = {});
 
-  undefined observe(ComputePressureTarget target, optional ComputePressureObserverOptions options = {});
-  undefined unobserve(ComputePressureTarget target);
+  undefined observe(ComputePressureSource source);
+  undefined unobserve(ComputePressureSource source);
   undefined disconnect();
   sequence<ComputePressureRecord> takeRecords();
 
-  [SameObject] static readonly attribute FrozenArray<DOMString> supportedTargetTypes;
+  [SameObject] static readonly attribute FrozenArray<ComputePressureSource> supportedSources;
 
   [Exposed=Window] static Promise<PermissionState> requestPermission();
 };
 
 dictionary ComputePressureRecord {
-  PressureState state;
-  ComputePressureObserverOptions options;
+  ComputePressureSource source;
+  ComputePressureState state;
+  sequence<ComputePressureFactor> factors;
+  DOMHighResTimeStamp time;
 };
 
 dictionary ComputePressureObserverOptions {
-  // For future-proofing - expect things to be added here later.
+  double frequency;
 };

package/css-typed-om.idl

@@ -199,6 +199,30 @@ partial namespace CSS {
     CSSUnitValue vb(double value);
     CSSUnitValue vmin(double value);
     CSSUnitValue vmax(double value);
+    CSSUnitValue svw(double value);
+    CSSUnitValue svh(double value);
+    CSSUnitValue svi(double value);
+    CSSUnitValue svb(double value);
+    CSSUnitValue svmin(double value);
+    CSSUnitValue svmax(double value);
+    CSSUnitValue lvw(double value);
+    CSSUnitValue lvh(double value);
+    CSSUnitValue lvi(double value);
+    CSSUnitValue lvb(double value);
+    CSSUnitValue lvmin(double value);
+    CSSUnitValue lvmax(double value);
+    CSSUnitValue dvw(double value);
+    CSSUnitValue dvh(double value);
+    CSSUnitValue dvi(double value);
+    CSSUnitValue dvb(double value);
+    CSSUnitValue dvmin(double value);
+    CSSUnitValue dvmax(double value);
+    CSSUnitValue cqw(double value);
+    CSSUnitValue cqh(double value);
+    CSSUnitValue cqi(double value);
+    CSSUnitValue cqb(double value);
+    CSSUnitValue cqmin(double value);
+    CSSUnitValue cqmax(double value);
     CSSUnitValue cm(double value);
     CSSUnitValue mm(double value);
     CSSUnitValue Q(double value);

package/cssom-view.idl

@@ -100,9 +100,16 @@ dictionary ScrollIntoViewOptions : ScrollOptions {
   ScrollLogicalPosition inline = "nearest";
 };
 
+dictionary IsVisibleOptions {
+
+};
+
 partial interface Element {
   DOMRectList getClientRects();
   [NewObject] DOMRect getBoundingClientRect();
+
+  boolean isVisible(optional IsVisibleOptions options = {});
+
   undefined scrollIntoView(optional (boolean or ScrollIntoViewOptions) arg = {});
   undefined scroll(optional ScrollToOptions options = {});
   undefined scroll(unrestricted double x, unrestricted double y);

package/digital-goods.idl

@@ -0,0 +1,44 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Digital Goods API (https://wicg.github.io/digital-goods/)
+
+partial interface Window {
+  [SecureContext] Promise<DigitalGoodsService> getDigitalGoodsService(
+      DOMString serviceProvider);
+};
+
+[Exposed=Window, SecureContext] interface DigitalGoodsService {
+
+  Promise<sequence<ItemDetails>> getDetails(sequence<DOMString> itemIds);
+
+  Promise<sequence<PurchaseDetails>> listPurchases();
+
+  Promise<sequence<PurchaseDetails>> listPurchaseHistory();
+
+  Promise<undefined> consume(DOMString purchaseToken);
+};
+
+dictionary ItemDetails {
+  required DOMString itemId;
+  required DOMString title;
+  required PaymentCurrencyAmount price;
+  ItemType type;
+  DOMString description;
+  sequence<DOMString> iconURLs;
+  DOMString subscriptionPeriod;
+  DOMString freeTrialPeriod;
+  PaymentCurrencyAmount introductoryPrice;
+  DOMString introductoryPricePeriod;
+  [EnforceRange] unsigned long long introductoryPriceCycles;
+};
+
+enum ItemType {
+  "product",
+  "subscription",
+};
+
+dictionary PurchaseDetails {
+  required DOMString itemId;
+  required DOMString purchaseToken;
+};

package/html.idl

@@ -116,6 +116,7 @@ interface HTMLElement : Element {
 
   // user interaction
   [CEReactions] attribute boolean hidden;
+  [CEReactions] attribute boolean inert;
   undefined click();
   [CEReactions] attribute DOMString accessKey;
   readonly attribute DOMString accessKeyLabel;
@@ -1480,7 +1481,7 @@ interface mixin CanvasPath {
   undefined bezierCurveTo(unrestricted double cp1x, unrestricted double cp1y, unrestricted double cp2x, unrestricted double cp2y, unrestricted double x, unrestricted double y);
   undefined arcTo(unrestricted double x1, unrestricted double y1, unrestricted double x2, unrestricted double y2, unrestricted double radius);
   undefined rect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h);
-  undefined roundRect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h, optional (unrestricted double or DOMPointInit or sequence<(unrestricted double or DOMPointInit)>) radii = {});
+  undefined roundRect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h, optional (unrestricted double or DOMPointInit or sequence<(unrestricted double or DOMPointInit)>) radii = 0);
   undefined arc(unrestricted double x, unrestricted double y, unrestricted double radius, unrestricted double startAngle, unrestricted double endAngle, optional boolean counterclockwise = false);
   undefined ellipse(unrestricted double x, unrestricted double y, unrestricted double radiusX, unrestricted double radiusY, unrestricted double rotation, unrestricted double startAngle, unrestricted double endAngle, optional boolean counterclockwise = false);
 };

package/navigation-api.idl

@@ -0,0 +1,137 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Navigation API (https://wicg.github.io/navigation-api/)
+
+partial interface Window {
+  [Replaceable] readonly attribute Navigation navigation;
+};
+
+[Exposed=Window]
+interface Navigation : EventTarget {
+  sequence<NavigationHistoryEntry> entries();
+  readonly attribute NavigationHistoryEntry? currentEntry;
+  undefined updateCurrentEntry(NavigationUpdateCurrentEntryOptions options);
+  readonly attribute NavigationTransition? transition;
+
+  readonly attribute boolean canGoBack;
+  readonly attribute boolean canGoForward;
+
+  NavigationResult navigate(USVString url, optional NavigationNavigateOptions options = {});
+  NavigationResult reload(optional NavigationReloadOptions options = {});
+
+  NavigationResult traverseTo(DOMString key, optional NavigationOptions options = {});
+  NavigationResult back(optional NavigationOptions options = {});
+  NavigationResult forward(optional NavigationOptions options = {});
+
+  attribute EventHandler onnavigate;
+  attribute EventHandler onnavigatesuccess;
+  attribute EventHandler onnavigateerror;
+  attribute EventHandler oncurrententrychange;
+};
+
+dictionary NavigationUpdateCurrentEntryOptions {
+  required any state;
+};
+
+dictionary NavigationOptions {
+  any info;
+};
+
+dictionary NavigationNavigateOptions : NavigationOptions {
+  any state;
+  boolean replace = false;
+};
+
+dictionary NavigationReloadOptions : NavigationOptions {
+  any state;
+};
+
+dictionary NavigationResult {
+  Promise<NavigationHistoryEntry> committed;
+  Promise<NavigationHistoryEntry> finished;
+};
+
+[Exposed=Window]
+interface NavigationCurrentEntryChangeEvent : Event {
+  constructor(DOMString type, NavigationCurrentEntryChangeEventInit eventInit);
+
+  readonly attribute NavigationNavigationType? navigationType;
+  readonly attribute NavigationHistoryEntry from;
+};
+
+dictionary NavigationCurrentEntryChangeEventInit : EventInit {
+  NavigationNavigationType? navigationType = null;
+  required NavigationHistoryEntry destination;
+};
+
+[Exposed=Window]
+interface NavigationTransition {
+  readonly attribute NavigationNavigationType navigationType;
+  readonly attribute NavigationHistoryEntry from;
+  readonly attribute Promise<undefined> finished;
+
+  NavigationResult rollback(optional NavigationOptions options = {});
+};
+
+[Exposed=Window]
+interface NavigateEvent : Event {
+  constructor(DOMString type, NavigateEventInit eventInit);
+
+  readonly attribute NavigationNavigationType navigationType;
+  readonly attribute NavigationDestination destination;
+  readonly attribute boolean canTransition;
+  readonly attribute boolean userInitiated;
+  readonly attribute boolean hashChange;
+  readonly attribute AbortSignal signal;
+  readonly attribute FormData? formData;
+  readonly attribute any info;
+
+  undefined transitionWhile(Promise<undefined> newNavigationAction);
+};
+
+dictionary NavigateEventInit : EventInit {
+  NavigationNavigationType navigationType = "push";
+  required NavigationDestination destination;
+  boolean canTransition = false;
+  boolean userInitiated = false;
+  boolean hashChange = false;
+  required AbortSignal signal;
+  FormData? formData = null;
+  any info;
+};
+
+// TODO: rename to NavigationType after https://github.com/w3c/navigation-timing/pull/172 lands.
+enum NavigationNavigationType {
+  "reload",
+  "push",
+  "replace",
+  "traverse"
+};
+
+[Exposed=Window]
+interface NavigationDestination {
+  readonly attribute USVString url;
+  readonly attribute DOMString? key;
+  readonly attribute DOMString? id;
+  readonly attribute long long index;
+  readonly attribute boolean sameDocument;
+
+  any getState();
+};
+
+[Exposed=Window]
+interface NavigationHistoryEntry : EventTarget {
+  readonly attribute USVString? url;
+  readonly attribute DOMString key;
+  readonly attribute DOMString id;
+  readonly attribute long long index;
+  readonly attribute boolean sameDocument;
+
+  any getState();
+
+  attribute EventHandler onnavigateto;
+  attribute EventHandler onnavigatefrom;
+  attribute EventHandler onfinish;
+  attribute EventHandler ondispose;
+};

package/navigation-timing.idl

@@ -5,20 +5,20 @@
 
 [Exposed=Window]
 interface PerformanceNavigationTiming : PerformanceResourceTiming {
-    readonly        attribute DOMHighResTimeStamp unloadEventStart;
-    readonly        attribute DOMHighResTimeStamp unloadEventEnd;
-    readonly        attribute DOMHighResTimeStamp domInteractive;
-    readonly        attribute DOMHighResTimeStamp domContentLoadedEventStart;
-    readonly        attribute DOMHighResTimeStamp domContentLoadedEventEnd;
-    readonly        attribute DOMHighResTimeStamp domComplete;
-    readonly        attribute DOMHighResTimeStamp loadEventStart;
-    readonly        attribute DOMHighResTimeStamp loadEventEnd;
-    readonly        attribute NavigationType      type;
-    readonly        attribute unsigned short      redirectCount;
+    readonly        attribute DOMHighResTimeStamp  unloadEventStart;
+    readonly        attribute DOMHighResTimeStamp  unloadEventEnd;
+    readonly        attribute DOMHighResTimeStamp  domInteractive;
+    readonly        attribute DOMHighResTimeStamp  domContentLoadedEventStart;
+    readonly        attribute DOMHighResTimeStamp  domContentLoadedEventEnd;
+    readonly        attribute DOMHighResTimeStamp  domComplete;
+    readonly        attribute DOMHighResTimeStamp  loadEventStart;
+    readonly        attribute DOMHighResTimeStamp  loadEventEnd;
+    readonly        attribute NavigationTimingType type;
+    readonly        attribute unsigned short       redirectCount;
     [Default] object toJSON();
 };
 
-enum NavigationType {
+enum NavigationTimingType {
     "navigate",
     "reload",
     "back_forward",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@webref/idl",
   "description": "Web IDL definitions of the web platform",
-  "version": "3.2.1",
+  "version": "3.5.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/w3c/webref.git"
@@ -12,6 +12,6 @@
   "license": "MIT",
   "main": "index.js",
   "peerDependencies": {
-    "webidl2": "^24.2.0"
+    "webidl2": "^24.2.1"
   }
 }

package/webgpu.idl

@@ -84,6 +84,7 @@ interface GPUAdapter {
 dictionary GPUDeviceDescriptor : GPUObjectDescriptorBase {
     sequence<GPUFeatureName> requiredFeatures = [];
     record<DOMString, GPUSize64> requiredLimits = {};
+    GPUQueueDescriptor defaultQueue = {};
 };
 
 enum GPUFeatureName {
@@ -375,7 +376,7 @@ dictionary GPUSamplerDescriptor : GPUObjectDescriptorBase {
     GPUAddressMode addressModeW = "clamp-to-edge";
     GPUFilterMode magFilter = "nearest";
     GPUFilterMode minFilter = "nearest";
-    GPUFilterMode mipmapFilter = "nearest";
+    GPUMipmapFilterMode mipmapFilter = "nearest";
     float lodMinClamp = 0;
     float lodMaxClamp = 32;
     GPUCompareFunction compare;
@@ -393,6 +394,11 @@ enum GPUFilterMode {
     "linear",
 };
 
+enum GPUMipmapFilterMode {
+    "nearest",
+    "linear",
+};
+
 enum GPUCompareFunction {
     "never",
     "less",
@@ -1034,6 +1040,9 @@ dictionary GPURenderBundleEncoderDescriptor : GPURenderPassLayout {
     boolean stencilReadOnly = false;
 };
 
+dictionary GPUQueueDescriptor : GPUObjectDescriptorBase {
+};
+
 [Exposed=(Window, DedicatedWorker), SecureContext]
 interface GPUQueue {
     undefined submit(sequence<GPUCommandBuffer> commandBuffers);

package/app-history.idl

@@ -1,136 +0,0 @@
-// GENERATED CONTENT - DO NOT EDIT
-// Content was automatically extracted by Reffy into webref
-// (https://github.com/w3c/webref)
-// Source: App History API (https://wicg.github.io/app-history/)
-
-partial interface Window {
-  readonly attribute AppHistory appHistory;
-};
-
-[Exposed=Window]
-interface AppHistory : EventTarget {
-  sequence<AppHistoryEntry> entries();
-  readonly attribute AppHistoryEntry? current;
-  undefined updateCurrent(AppHistoryUpdateCurrentOptions options);
-  readonly attribute AppHistoryTransition? transition;
-
-  readonly attribute boolean canGoBack;
-  readonly attribute boolean canGoForward;
-
-  AppHistoryResult navigate(USVString url, optional AppHistoryNavigateOptions options = {});
-  AppHistoryResult reload(optional AppHistoryReloadOptions options = {});
-
-  AppHistoryResult goTo(DOMString key, optional AppHistoryNavigationOptions options = {});
-  AppHistoryResult back(optional AppHistoryNavigationOptions options = {});
-  AppHistoryResult forward(optional AppHistoryNavigationOptions options = {});
-
-  attribute EventHandler onnavigate;
-  attribute EventHandler onnavigatesuccess;
-  attribute EventHandler onnavigateerror;
-  attribute EventHandler oncurrentchange;
-};
-
-dictionary AppHistoryUpdateCurrentOptions {
-  required any state;
-};
-
-dictionary AppHistoryNavigationOptions {
-  any info;
-};
-
-dictionary AppHistoryNavigateOptions : AppHistoryNavigationOptions {
-  any state;
-  boolean replace = false;
-};
-
-dictionary AppHistoryReloadOptions : AppHistoryNavigationOptions {
-  any state;
-};
-
-dictionary AppHistoryResult {
-  Promise<AppHistoryEntry> committed;
-  Promise<AppHistoryEntry> finished;
-};
-
-[Exposed=Window]
-interface AppHistoryCurrentChangeEvent : Event {
-  constructor(DOMString type, AppHistoryCurrentChangeEventInit eventInit);
-
-  readonly attribute AppHistoryNavigationType? navigationType;
-  readonly attribute AppHistoryEntry from;
-};
-
-dictionary AppHistoryCurrentChangeEventInit : EventInit {
-  AppHistoryNavigationType? navigationType = null;
-  required AppHistoryEntry destination;
-};
-
-[Exposed=Window]
-interface AppHistoryTransition {
-  readonly attribute AppHistoryNavigationType navigationType;
-  readonly attribute AppHistoryEntry from;
-  readonly attribute Promise<undefined> finished;
-
-  AppHistoryResult rollback(optional AppHistoryNavigationOptions options = {});
-};
-
-[Exposed=Window]
-interface AppHistoryNavigateEvent : Event {
-  constructor(DOMString type, AppHistoryNavigateEventInit eventInit);
-
-  readonly attribute AppHistoryNavigationType navigationType;
-  readonly attribute AppHistoryDestination destination;
-  readonly attribute boolean canTransition;
-  readonly attribute boolean userInitiated;
-  readonly attribute boolean hashChange;
-  readonly attribute AbortSignal signal;
-  readonly attribute FormData? formData;
-  readonly attribute any info;
-
-  undefined transitionWhile(Promise<undefined> newNavigationAction);
-};
-
-dictionary AppHistoryNavigateEventInit : EventInit {
-  AppHistoryNavigationType navigationType = "push";
-  required AppHistoryDestination destination;
-  boolean canTransition = false;
-  boolean userInitiated = false;
-  boolean hashChange = false;
-  required AbortSignal signal;
-  FormData? formData = null;
-  any info;
-};
-
-enum AppHistoryNavigationType {
-  "reload",
-  "push",
-  "replace",
-  "traverse"
-};
-
-[Exposed=Window]
-interface AppHistoryDestination {
-  readonly attribute USVString url;
-  readonly attribute DOMString? key;
-  readonly attribute DOMString? id;
-  readonly attribute long long index;
-  readonly attribute boolean sameDocument;
-
-  any getState();
-};
-
-[Exposed=Window]
-interface AppHistoryEntry : EventTarget {
-  readonly attribute USVString? url;
-  readonly attribute DOMString key;
-  readonly attribute DOMString id;
-  readonly attribute long long index;
-  readonly attribute boolean sameDocument;
-
-  any getState();
-
-  attribute EventHandler onnavigateto;
-  attribute EventHandler onnavigatefrom;
-  attribute EventHandler onfinish;
-  attribute EventHandler ondispose;
-};

package/floc.idl

@@ -1,13 +0,0 @@
-// GENERATED CONTENT - DO NOT EDIT
-// Content was automatically extracted by Reffy into webref
-// (https://github.com/w3c/webref)
-// Source: Federated Learning of Cohorts (https://wicg.github.io/floc/)
-
-dictionary InterestCohort {
-  DOMString id;
-  DOMString version;
-};
-
-partial interface Document {
-    Promise<InterestCohort> interestCohort();
-};