repo_id
stringlengths 22
103
| file_path
stringlengths 41
147
| content
stringlengths 181
193k
| __index_level_0__
int64 0
0
|
|---|---|---|---|
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/displaysurface/index.md | ---
title: "MediaTrackSettings: displaySurface property"
short-title: displaySurface
slug: Web/API/MediaTrackSettings/displaySurface
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.displaySurface
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's
**`displaySurface`** property indicates the type of display
surface being captured.
## Value
The value of `displaySurface` is a string that comes from the `DisplayCaptureSurfaceType` enumerated type, and is one of the following:
- `browser`
- : The stream's video track presents the entire contents of a single browser tab which the user selected during the {{domxref("MediaDevices.getDisplayMedia","getDisplayMedia()")}} call.
- `monitor`
- : The video track in the stream presents the complete contents of one or more of the
user's screens. Any empty space (if the displays are of different dimensions) is
filled with a backdrop chosen by the user agent.
- `window`
- : The stream's video track presents the contents of a single window selected by the user.
The window may be from any application, not necessarily just from within the user agent.
Not all user agents support all of these surface types.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Screen Capture API](/en-US/docs/Web/API/Screen_Capture_API)
- [Using the screen capture API](/en-US/docs/Web/API/Screen_Capture_API/Using_Screen_Capture)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaDevices.getDisplayMedia()")}}
- {{domxref("MediaStreamTrack.getConstraints()")}}
- {{domxref("MediaStreamTrack.applyConstraints()")}}
- {{domxref("MediaStreamTrack.getSettings()")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/groupid/index.md | ---
title: "MediaTrackSettings: groupId property"
short-title: groupId
slug: Web/API/MediaTrackSettings/groupId
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.groupId
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's
**`groupId`** property is a browsing-session unique
string which identifies the group of devices which includes the source
for the {{domxref("MediaStreamTrack")}}. This lets you determine what value was selected
to comply with your specified constraints for this property's value as described in the
{{domxref("MediaTrackConstraints.groupId")}} property you provided when calling either
{{domxref("MediaDevices.getUserMedia", "getUserMedia()")}}.
If needed, you can determine whether or not this constraint is supported by checking
the value of {{domxref("MediaTrackSupportedConstraints.groupId")}} as returned by a call
to {{domxref("MediaDevices.getSupportedConstraints()")}}. However, typically this is
unnecessary since browsers will ignore any constraints they're unfamiliar with.
Because {{Glossary("RTP")}} doesn't include this information, tracks associated with a
[WebRTC](/en-US/docs/Web/API/WebRTC_API) {{domxref("RTCPeerConnection")}}
will never include this property.
## Value
A string whose value is a browsing-session unique identifier for a
group of devices which includes the source of the track's contents. Two devices share
the same group ID if they belong to the same physical hardware device. For example, a
headset has two devices on it: a microphone which can serve as a source for audio tracks
and a speaker which can serve as an output for audio.
The group ID is not usable across multiple browsing sessions. However, it can be used
to ensure that audio input and output are both being performed on the same headset, for
example, or to ensure that the built-in camera and microphone on a phone are being used
for video conferencing purposes.
The actual value of the string, however, is determined by the source of the track, and
there is no guarantee what form it will take, although the specification does recommend
it be a GUID.
Since this property isn't stable across browsing sessions, its usefulness when calling
{{domxref("MediaDevices.getUserMedia", "getUserMedia()")}} is generally limited to
ensuring that tasks performed during the same browsing session use devices from the same
group (or that they don't use devices from the same group). There is no situation in
which the groupId is useful when calling `applyConstraints()`, since the
value can't be changed.
## Examples
See the [Constraint exerciser](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints#example_constraint_exerciser) example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Media Capture and Streams API](/en-US/docs/Web/API/Media_Capture_and_Streams_API)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaTrackSettings.deviceId")}}
- {{domxref("MediaTrackConstraints.groupId")}}
- {{domxref("MediaTrackSettings")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/samplerate/index.md | ---
title: "MediaTrackSettings: sampleRate property"
short-title: sampleRate
slug: Web/API/MediaTrackSettings/sampleRate
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.sampleRate
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's
**`sampleRate`** property is an integer indicating how many
audio samples per second the {{domxref("MediaStreamTrack")}} is currently configured
for. This lets you determine what value was selected to comply with your specified
constraints for this property's value as described in the
{{domxref("MediaTrackConstraints.sampleRate")}} property you provided when calling
either {{domxref("MediaDevices.getUserMedia", "getUserMedia()")}} or
{{domxref("MediaStreamTrack.applyConstraints()")}}.
If needed, you can determine whether or not this constraint is supported by checking
the value of {{domxref("MediaTrackSupportedConstraints.sampleRate")}} as returned by a
call to {{domxref("MediaDevices.getSupportedConstraints()")}}. However, typically this
is unnecessary since browsers will ignore any constraints they're unfamiliar with.
## Value
An integer value indicating how many samples each second of audio data includes. Common
values include 44,100 (standard CD audio), 48,000 (standard digital audio), 96,000
(commonly used in audio mastering and post-production), and 192,000 (used for
high-resolution audio in professional recording and mastering sessions). However, lower
values are often used to reduce bandwidth requirements; 8,000 samples per second is
adequate for comprehensible albeit imperfect human speech, and both 11,025 FPS and
22,050 FPS are often used for low-bandwidth, reduced quality sound and music.
## Examples
See the [Constraint exerciser](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints#example_constraint_exerciser) example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Media Capture and Streams API](/en-US/docs/Web/API/Media_Capture_and_Streams_API)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaTrackConstraints.sampleRate")}}
- {{domxref("MediaTrackSettings")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/aspectratio/index.md | ---
title: "MediaTrackSettings: aspectRatio property"
short-title: aspectRatio
slug: Web/API/MediaTrackSettings/aspectRatio
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.aspectRatio
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's **`aspectRatio`** property is a double-precision floating-point number indicating the aspect ratio of the {{domxref("MediaStreamTrack")}} as currently configured.
This lets you determine what value was selected to comply with your specified constraints for this property's value as described in the {{domxref("MediaTrackConstraints.aspectRatio")}} property you provided when calling either {{domxref("MediaDevices.getUserMedia", "getUserMedia()")}} or {{domxref("MediaStreamTrack.applyConstraints()")}}.
If needed, you can determine whether or not this constraint is supported by checking
the value of {{domxref("MediaTrackSupportedConstraints.aspectRatio")}} as returned by a
call to {{domxref("MediaDevices.getSupportedConstraints()")}}. However, typically this
is unnecessary since browsers will ignore any constraints they're unfamiliar with.
## Value
A double-precision floating-point number indicating the current configuration of the
track's aspect ratio. The aspect ratio is computed by taking the track's width, dividing
by its height, and rounding the result to ten decimal places. For example, the standard
16:9 high-definition aspect ratio can be computed as 1920/1080, or 1.7777777778.
## Examples
See the [Constraint exerciser](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints#example_constraint_exerciser) example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Media Capture and Streams API](/en-US/docs/Web/API/Media_Capture_and_Streams_API)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaTrackConstraints.aspectRatio")}}
- {{domxref("MediaTrackSettings")}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/idbobjectstore/index.md | ---
title: IDBObjectStore
slug: Web/API/IDBObjectStore
page-type: web-api-interface
browser-compat: api.IDBObjectStore
---
{{APIRef("IndexedDB")}}
The **`IDBObjectStore`** interface of the [IndexedDB API](/en-US/docs/Web/API/IndexedDB_API) represents an object store in a database. Records within an object store are sorted according to their keys. This sorting enables fast insertion, look-up, and ordered retrieval.
{{AvailableInWorkers}}
## Instance properties
- {{domxref("IDBObjectStore.indexNames")}} {{ReadOnlyInline}}
- : A list of the names of [indexes](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#index) on objects in this object store.
- {{domxref("IDBObjectStore.keyPath")}} {{ReadOnlyInline}}
- : The [key path](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#key_path) of this object store. If this attribute is `null`, the application must provide a key for each modification operation.
- {{domxref("IDBObjectStore.name")}}
- : The name of this object store.
- {{domxref("IDBObjectStore.transaction")}} {{ReadOnlyInline}}
- : The {{domxref("IDBTransaction")}} object to which this object store belongs.
- {{domxref("IDBObjectStore.autoIncrement")}} {{ReadOnlyInline}}
- : The value of the auto increment flag for this object store.
## Instance methods
- {{domxref("IDBObjectStore.add()")}}
- : Returns an {{domxref("IDBRequest")}} object, and, in a separate thread, creates a [structured clone](https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#structured-clone) of the `value`, and stores the cloned value in the object store. This is for adding new records to an object store.
- {{domxref("IDBObjectStore.clear()")}}
- : Creates and immediately returns an {{domxref("IDBRequest")}} object, and clears this object store in a separate thread. This is for deleting all current records out of an object store.
- {{domxref("IDBObjectStore.count()")}}
- : Returns an {{domxref("IDBRequest")}} object, and, in a separate thread, returns the total number of records that match the provided key or {{domxref("IDBKeyRange")}}. If no arguments are provided, it returns the total number of records in the store.
- {{domxref("IDBObjectStore.createIndex()")}}
- : Creates a new index during a version upgrade, returning a new {{domxref("IDBIndex")}} object in the connected database.
- {{domxref("IDBObjectStore.delete()")}}
- : returns an {{domxref("IDBRequest")}} object, and, in a separate thread, deletes the store object selected by the specified key. This is for deleting individual records out of an object store.
- {{domxref("IDBObjectStore.deleteIndex()")}}
- : Destroys the specified index in the connected database, used during a version upgrade.
- {{domxref("IDBObjectStore.get()")}}
- : Returns an {{domxref("IDBRequest")}} object, and, in a separate thread, returns the store object store selected by the specified key. This is for retrieving specific records from an object store.
- {{domxref("IDBObjectStore.getKey()")}}
- : Returns an {{domxref("IDBRequest")}} object, and, in a separate thread retrieves and returns the record key for the object in the object stored matching the specified parameter.
- {{domxref("IDBObjectStore.getAll()")}}
- : Returns an {{domxref("IDBRequest")}} object retrieves all objects in the object store matching the specified parameter or all objects in the store if no parameters are given.
- {{domxref("IDBObjectStore.getAllKeys()")}}
- : Returns an {{domxref("IDBRequest")}} object retrieves record keys for all objects in the object store matching the specified parameter or all objects in the store if no parameters are given.
- {{domxref("IDBObjectStore.index()")}}
- : Opens an index from this object store after which it can, for example, be used to return a sequence of records sorted by that index using a cursor.
- {{domxref("IDBObjectStore.openCursor()")}}
- : Returns an {{domxref("IDBRequest")}} object, and, in a separate thread, returns a new {{domxref("IDBCursorWithValue")}} object. Used for iterating through an object store by primary key with a cursor.
- {{domxref("IDBObjectStore.openKeyCursor()")}}
- : Returns an {{domxref("IDBRequest")}} object, and, in a separate thread, returns a new {{domxref("IDBCursor")}}. Used for iterating through an object store with a key.
- {{domxref("IDBObjectStore.put()")}}
- : Returns an {{domxref("IDBRequest")}} object, and, in a separate thread, creates a [structured clone](https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#structured-clone) of the `value`, and stores the cloned value in the object store. This is for updating existing records in an object store when the transaction's mode is `readwrite`.
## Example
This example shows a variety of different uses of object stores, from updating the data structure with {{domxref("IDBObjectStore.createIndex")}} inside an `onupgradeneeded` function, to adding a new item to our object store with {{domxref("IDBObjectStore.add")}}. For a full working example, see our [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) app ([view example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
```js
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4);
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in db.
db = DBOpenRequest.result;
};
// This event handles the event whereby a new version of
// the database needs to be created Either one has not
// been created before, or a new version number has been
// submitted via the window.indexedDB.open line above
DBOpenRequest.onupgradeneeded = (event) => {
const db = event.target.result;
db.onerror = (event) => {
note.innerHTML += "<li>Error loading database.</li>";
};
// Create an objectStore for this database
const objectStore = db.createObjectStore("toDoList", {
keyPath: "taskTitle",
});
// define what data items the objectStore will contain
objectStore.createIndex("hours", "hours", { unique: false });
objectStore.createIndex("minutes", "minutes", { unique: false });
objectStore.createIndex("day", "day", { unique: false });
objectStore.createIndex("month", "month", { unique: false });
objectStore.createIndex("year", "year", { unique: false });
objectStore.createIndex("notified", "notified", { unique: false });
note.innerHTML += "<li>Object store created.</li>";
};
// Create a new item to add in to the object store
const newItem = [
{
taskTitle: "Walk dog",
hours: 19,
minutes: 30,
day: 24,
month: "December",
year: 2013,
notified: "no",
},
];
// open a read/write db transaction, ready for adding the data
const transaction = db.transaction(["toDoList"], "readwrite");
// report on the success of the transaction completing, when everything is done
transaction.oncomplete = (event) => {
note.innerHTML += "<li>Transaction completed.</li>";
};
transaction.onerror = (event) => {
note.innerHTML +=
"<li>Transaction not opened due to error. Duplicate items not allowed.</li>";
};
// create an object store on the transaction
const objectStore = transaction.objectStore("toDoList");
// make a request to add our newItem object to the object store
const objectStoreRequest = objectStore.add(newItem[0]);
objectStoreRequest.onsuccess = (event) => {
note.innerHTML += "<li>Request successful .</li>";
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/name/index.md | ---
title: "IDBObjectStore: name property"
short-title: name
slug: Web/API/IDBObjectStore/name
page-type: web-api-instance-property
browser-compat: api.IDBObjectStore.name
---
{{ APIRef("IndexedDB") }}
The **`name`** property of the {{domxref("IDBObjectStore")}}
interface indicates the name of this object store.
{{AvailableInWorkers}}
## Value
A string containing the object
store's name.
### Exceptions
There are a several exceptions that can occur when you attempt to change an object
store's name.
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if either the object store has been deleted or the current transaction is not an
upgrade transaction; you can only rename indexes during upgrade transactions; that is,
when the mode is `versionchange`.
- `TransactionInactiveError` {{domxref("DOMException")}}
- : Thrown if the current transaction is not active.
- `ConstraintError` {{domxref("DOMException")}}
- : Thrown if an object store is already using the specified `name`.
## Examples
In the following code snippet, we open a read/write transaction on our database and add
some data to an object store using `add()`. After the object store has been
created, we log `objectStore.name` to
the console. For a full working example, see
our [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) app
(>[view example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
```js
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4);
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in the db variable.
// This is used a lot below
db = DBOpenRequest.result;
// Run the addData() function to add the data to the database
addData();
};
function addData() {
// Create a new object ready to insert into the IDB
const newItem = [
{
taskTitle: "Walk dog",
hours: 19,
minutes: 30,
day: 24,
month: "December",
year: 2013,
notified: "no",
},
];
// open a read/write db transaction, ready for adding the data
const transaction = db.transaction(["toDoList"], "readwrite");
// report on the success of the transaction completing, when everything is done
transaction.oncomplete = (event) => {
note.innerHTML += "<li>Transaction completed.</li>";
};
transaction.onerror = (event) => {
note.innerHTML +=
"<li>Transaction not opened due to error. Duplicate items not allowed.</li>";
};
// create an object store on the transaction
const objectStore = transaction.objectStore("toDoList");
console.log(objectStore.name);
// Make a request to add our newItem object to the object store
const objectStoreRequest = objectStore.add(newItem[0]);
objectStoreRequest.onsuccess = (event) => {
// report the success of our request
note.innerHTML += "<li>Request successful.</li>";
};
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/createindex/index.md | ---
title: "IDBObjectStore: createIndex() method"
short-title: createIndex()
slug: Web/API/IDBObjectStore/createIndex
page-type: web-api-instance-method
browser-compat: api.IDBObjectStore.createIndex
---
{{ APIRef("IndexedDB") }}
The **`createIndex()`** method of the
{{domxref("IDBObjectStore")}} interface creates and returns a new
{{domxref("IDBIndex")}} object in the connected database. It creates a new
field/column defining a new data point for each database record to contain.
Bear in mind that IndexedDB indexes can contain _any_ JavaScript data type;
IndexedDB uses the [structured clone algorithm](/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm) to serialize stored objects, which allows for storage of simple
and complex objects.
Note that this method must be called only from a `VersionChange` transaction
mode callback.
{{AvailableInWorkers}}
## Syntax
```js-nolint
createIndex(indexName, keyPath)
createIndex(indexName, keyPath, options)
```
### Parameters
- `indexName`
- : The name of the index to create. Note that it is possible to create an index with an empty name.
- `keyPath`
- : The key path for the index to use. Note that it is possible to create an index with an empty `keyPath`, and also to pass in a sequence (array) as a `keyPath`.
- `options` {{optional_inline}}
- : An object which can include the following
properties:
- `unique`
- : If `true`, the index will not allow duplicate values for a single key. Defaults to `false`.
- `multiEntry`
- : If `true`, the index will add an entry in the index for each array element when the `keyPath` resolves to an array.
If `false`, it will add one single entry containing the array. Defaults to `false`.
- `locale` {{non-standard_inline}} {{deprecated_inline}}
- : Allows you to specify a locale for the index.
Any sorting operations performed on the data via key ranges will then obey sorting rules of that locale
(see [locale-aware sorting](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB#locale-aware_sorting)).
You can specify its value in one of three ways:
- `string`: A string containing a specific locale code, e.g. `en-US`, or `pl`.
- `auto`: The platform default locale will be used (may be changed by user agent settings).
- `null` or `undefined`: If no locale is specified, normal JavaScript sorting will be used — not locale-aware.
### Return value
An {{domxref("IDBIndex")}} object: the newly created index.
### Exceptions
This method may raise a {{domxref("DOMException")}} of one of the following types:
- `ConstraintError` {{domxref("DOMException")}}
- : Thrown if an index with the same name already exists in the database. Index names are case-sensitive.
- `InvalidAccessError` {{domxref("DOMException")}}
- : Thrown if the provided key path is a sequence, and `multiEntry` is set to `true` in the `objectParameters` object.
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if:
- The method was not called from a `versionchange` transaction mode callback, i.e. from inside a {{domxref("IDBOpenDBRequest.upgradeneeded_event", "onupgradeneeded")}} handler.
- The object store has been deleted.
- `SyntaxError` {{domxref("DOMException")}}
- : Thrown if the provided `keyPath` is not a <a href="https://www.w3.org/TR/IndexedDB/#dfn-valid-key-path">valid key path</a>.
- `TransactionInactiveError` {{domxref("DOMException")}}
- : Thrown if the transaction this {{domxref("IDBObjectStore")}}
belongs to is not active (e.g. has been deleted or removed.) In Firefox
previous to version 41, an `InvalidStateError` was raised in
this case as well, which was misleading; this has now been fixed (see
[Firefox bug 1176165](https://bugzil.la/1176165).)
## Examples
In the following example you can see
the {{domxref("IDBOpenDBRequest.upgradeneeded_event", "onupgradeneeded")}} handler being used to update the
database structure if a database with a higher version number is loaded.
`createIndex()` is used to create new indexes on the object store. For a
full working example, see our [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) app ([view example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
```js
let db;
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4);
// Two event handlers for opening the database.
DBOpenRequest.onerror = (event) => {
note.innerHTML += "<li>Error loading database.</li>";
};
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in the db variable.
// This is used a lot below.
db = request.result;
// Run the displayData() function to populate the task list with
// all the to-do list data already in the IDB
displayData();
};
// This handler fires when a new database is created and indicates
// either that one has not been created before, or a new version
// was submitted with window.indexedDB.open(). (See above.)
// It is only implemented in recent browsers.
DBOpenRequest.onupgradeneeded = (event) => {
const db = event.target.result;
db.onerror = (event) => {
note.innerHTML += "<li>Error loading database.</li>";
};
// Create an objectStore for this database
const objectStore = db.createObjectStore("toDoList", {
keyPath: "taskTitle",
});
// define what data items the objectStore will contain
objectStore.createIndex("hours", "hours", { unique: false });
objectStore.createIndex("minutes", "minutes", { unique: false });
objectStore.createIndex("day", "day", { unique: false });
objectStore.createIndex("month", "month", { unique: false });
objectStore.createIndex("year", "year", { unique: false });
objectStore.createIndex("notified", "notified", { unique: false });
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/openkeycursor/index.md | ---
title: "IDBObjectStore: openKeyCursor() method"
short-title: openKeyCursor()
slug: Web/API/IDBObjectStore/openKeyCursor
page-type: web-api-instance-method
browser-compat: api.IDBObjectStore.openKeyCursor
---
{{ APIRef("IndexedDB") }}
The **`openKeyCursor()`** method of the
{{domxref("IDBObjectStore")}} interface returns an {{domxref("IDBRequest")}} object
whose result will be set to an {{domxref("IDBCursor")}} that can be used to iterate
through matching results. Used for iterating through the keys of an object store with
a cursor.
To determine if the add operation has completed successfully, listen for the
results's `success` event.
## Syntax
```js-nolint
openKeyCursor()
openKeyCursor(query)
openKeyCursor(query, direction)
```
### Parameters
- `query` {{optional_inline}}
- : The key range to be queried. If a single valid key is passed, this will default to a
range containing only that key. If nothing is passed, this will default to a key range
that selects all the records in this object store.
- `direction` {{optional_inline}}
- : An [`IDBCursorDirection`](https://w3c.github.io/IndexedDB/#enumdef-idbcursordirection) telling the cursor what direction to travel.
Valid values are `"next"`, `"nextunique"`, `"prev"`,
and `"prevunique"`. The default is `"next"`.
### Return value
An {{domxref("IDBRequest")}} object on which subsequent events related to this operation are fired.
If the operation is successful, the value of the request's {{domxref("IDBRequest.result", "result")}} property is:
- an {{domxref("IDBCursor")}} object pointing at the first record matching the given query
- `null` if no matching records were found.
### Exceptions
This method may raise a {{domxref("DOMException")}} of one of the following types:
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if this {{domxref("IDBObjectStore")}} or {{domxref("IDBIndex")}} has been deleted.
- `TransactionInactiveError` {{domxref("DOMException")}}
- : Thrown if this {{domxref("IDBObjectStore")}}'s transaction is inactive.
- `DataError` {{domxref("DOMException")}}
- : Thrown if the specified key or key range is invalid.
## Examples
In this simple fragment we create a transaction, retrieve an object store, then use a
cursor to iterate through all the records in the object store:
```js
const transaction = db.transaction("name", "readonly");
const objectStore = transaction.objectStore("name");
const request = objectStore.openKeyCursor();
request.onsuccess = (event) => {
const cursor = event.target.result;
if (cursor) {
// cursor.key contains the key of the current record being iterated through
// note that there is no cursor.value, unlike for openCursor
// this is where you'd do something with the result
cursor.continue();
} else {
// no more results
}
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/transaction/index.md | ---
title: "IDBObjectStore: transaction property"
short-title: transaction
slug: Web/API/IDBObjectStore/transaction
page-type: web-api-instance-property
browser-compat: api.IDBObjectStore.transaction
---
{{ APIRef("IndexedDB") }}
The **`transaction`** read-only property of the
{{domxref("IDBObjectStore")}} interface returns the transaction object to which this
object store belongs.
{{AvailableInWorkers}}
## Value
An {{domxref("IDBTransaction")}} object.
## Examples
In the following code snippet, we open a read/write transaction on our database and add
some data to an object store using `add()`. After the object store has been
created, we log `objectStore.transaction` to
the console. For a full working example, see our [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) app
([view example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
```js
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4);
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in the db variable.
// This is used a lot below
db = DBOpenRequest.result;
// Run the addData() function to add the data to the database
addData();
};
function addData() {
// Create a new object ready to insert into the IDB
const newItem = [
{
taskTitle: "Walk dog",
hours: 19,
minutes: 30,
day: 24,
month: "December",
year: 2013,
notified: "no",
},
];
// open a read/write db transaction, ready for adding the data
const transaction = db.transaction(["toDoList"], "readwrite");
// report on the success of the transaction completing, when everything is done
transaction.oncomplete = (event) => {
note.innerHTML += "<li>Transaction completed.</li>";
};
transaction.onerror = (event) => {
note.innerHTML +=
"<li>Transaction not opened due to error. Duplicate items not allowed.</li>";
};
// create an object store on the transaction
const objectStore = transaction.objectStore("toDoList");
console.log(objectStore.transaction);
// Make a request to add our newItem object to the object store
const objectStoreRequest = objectStore.add(newItem[0]);
objectStoreRequest.onsuccess = (event) => {
// report the success of our request
note.innerHTML += "<li>Request successful.</li>";
};
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/get/index.md | ---
title: "IDBObjectStore: get() method"
short-title: get()
slug: Web/API/IDBObjectStore/get
page-type: web-api-instance-method
browser-compat: api.IDBObjectStore.get
---
{{ APIRef("IndexedDB") }}
The **`get()`** method of the {{domxref("IDBObjectStore")}}
interface returns an {{domxref("IDBRequest")}} object, and, in a separate thread,
returns the object selected by the specified key. This is for retrieving
specific records from an object store.
If a value is successfully found, then a structured clone of it is created and set as
the [`result`](/en-US/docs/Web/API/IDBRequest#attr_result) of the
request object.
> **Note:** This method produces the same result for: a) a record that doesn't exist in the database and b) a record that has an undefined value.
> To tell these situations apart, call the `openCursor()` method with the same key. That method provides a cursor if the record exists, and no cursor if it does not.
{{AvailableInWorkers}}
## Syntax
```js-nolint
get(key)
```
### Parameters
- `key`
- : The key or key range that identifies the record to be retrieved.
### Return value
An {{domxref("IDBRequest")}} object on which subsequent events related to this operation are fired.
If the operation is successful, the value of the request's {{domxref("IDBRequest.result", "result")}} property is the value of the first record matching the given key or key range.
### Exceptions
This method may raise a {{domxref("DOMException")}} of one of the following types:
- `TransactionInactiveError` {{domxref("DOMException")}}
- : Thrown if this {{domxref("IDBObjectStore")}}'s transaction is inactive.
- `DataError` {{domxref("DOMException")}}
- : Thrown if key or key range provided contains an invalid key.
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the {{domxref("IDBObjectStore")}} has been deleted or removed.
## Examples
In the following code snippet, we open a read/write transaction on our database and get
one specific record from object store using `get()` — a sample record with
the key "Walk dog". Once this data object is retrieved, you could then update it using
normal JavaScript, then put it back into the database using a
{{domxref("IDBObjectStore.put")}} operation. For a full working example, see our [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) app
([view example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
```js
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4);
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in the db variable.
// This is used a lot below
db = DBOpenRequest.result;
// Run the getData() function to get the data from the database
getData();
};
function getData() {
// open a read/write db transaction, ready for retrieving the data
const transaction = db.transaction(["toDoList"], "readwrite");
// report on the success of the transaction completing, when everything is done
transaction.oncomplete = (event) => {
note.innerHTML += "<li>Transaction completed.</li>";
};
transaction.onerror = (event) => {
note.innerHTML += `<li>Transaction not opened due to error: ${transaction.error}</li>`;
};
// create an object store on the transaction
const objectStore = transaction.objectStore("toDoList");
// Make a request to get a record by key from the object store
const objectStoreRequest = objectStore.get("Walk dog");
objectStoreRequest.onsuccess = (event) => {
// report the success of our request
note.innerHTML += "<li>Request successful.</li>";
const myRecord = objectStoreRequest.result;
};
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/add/index.md | ---
title: "IDBObjectStore: add() method"
short-title: add()
slug: Web/API/IDBObjectStore/add
page-type: web-api-instance-method
browser-compat: api.IDBObjectStore.add
---
{{ APIRef("IndexedDB") }}
The **`add()`** method of the {{domxref("IDBObjectStore")}} interface returns an {{domxref("IDBRequest")}} object, and, in a separate thread, creates a [structured clone](https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#structured-clone) of the value, and stores the cloned value in the object store. This is for adding new records to an object store.
To determine if the add operation has completed successfully, listen for the
transaction's `complete` event in addition to the
`IDBObjectStore.add` request's `success` event, because the
transaction may still fail after the success event fires. In other words, the success
event is only triggered when the transaction has been successfully queued.
The add method is an _insert only_ method. If a
record already exists in the object store with the `key` parameter as its
key, then an error `ConstraintError` event is fired on the returned request
object. For updating existing records, you should use the
{{domxref("IDBObjectStore.put")}} method instead.
{{AvailableInWorkers}}
## Syntax
```js-nolint
add(value)
add(value, key)
```
### Parameters
- `value`
- : The value to be stored.
- `key` {{optional_inline}}
- : The key to use to identify the record. If unspecified, it results to null.
### Return value
An {{domxref("IDBRequest")}} object on which subsequent events related to this operation are fired.
If the operation is successful, the value of the request's {{domxref("IDBRequest.result", "result")}} property is the key for the new record.
### Exceptions
This method may raise a {{domxref("DOMException")}} of
one of the following types:
- `ReadOnlyError` {{domxref("DOMException")}}
- : Thrown if the transaction associated with this operation is in read-only <a href="/en-US/docs/Web/API/IDBTransaction#mode_constants">mode</a>.
- `TransactionInactiveError` {{domxref("DOMException")}}
- : Thrown if this {{domxref("IDBObjectStore")}}'s transaction is inactive.
- `DataError` {{domxref("DOMException")}}
- : Thrown if any of the following conditions apply:
- The object store uses in-line keys or has a key generator, and a key parameter was provided.
- The object store uses out-of-line keys and has no key generator, and no key parameter was provided.
- The object store uses in-line keys but no key generator, and the object store's key path does not yield a valid key.
- The key parameter was provided but does not contain a valid key.
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the {{domxref("IDBObjectStore")}} has been deleted or removed.
- `DataCloneError` {{domxref("DOMException")}}
- : Thrown if the data being stored could not be cloned by the internal structured cloning algorithm.
- `ConstraintError` {{domxref("DOMException")}}
- : Thrown if an insert operation failed because the primary key constraint was
violated (due to an already existing record with the same primary key
value).
## Examples
In the following code snippet, we open a read/write transaction on our database and add
some data to an object store using `add()`. Note also the functions attached
to transaction event handlers to report on the outcome of the transaction opening in the
event of success or failure. For a full working example, see our [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) app ([view example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
```js
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4);
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in the db variable.
// This is used a lot below
db = DBOpenRequest.result;
// Run the addData() function to add the data to the database
addData();
};
function addData() {
// Create a new object ready to insert into the IDB
const newItem = [
{
taskTitle: "Walk dog",
hours: 19,
minutes: 30,
day: 24,
month: "December",
year: 2013,
notified: "no",
},
];
// open a read/write db transaction, ready for adding the data
const transaction = db.transaction(["toDoList"], "readwrite");
// report on the success of the transaction completing, when everything is done
transaction.oncomplete = (event) => {
note.innerHTML += "<li>Transaction completed.</li>";
};
transaction.onerror = (event) => {
note.innerHTML +=
"<li>Transaction not opened due to error. Duplicate items not allowed.</li>";
};
// create an object store on the transaction
const objectStore = transaction.objectStore("toDoList");
// Make a request to add our newItem object to the object store
const objectStoreRequest = objectStore.add(newItem[0]);
objectStoreRequest.onsuccess = (event) => {
// report the success of our request
note.innerHTML += "<li>Request successful.</li>";
};
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/deleteindex/index.md | ---
title: "IDBObjectStore: deleteIndex() method"
short-title: deleteIndex()
slug: Web/API/IDBObjectStore/deleteIndex
page-type: web-api-instance-method
browser-compat: api.IDBObjectStore.deleteIndex
---
{{ APIRef("IndexedDB") }}
The **`deleteIndex()`** method of the
{{domxref("IDBObjectStore")}} interface destroys the index with the specified name in
the connected database, used during a version upgrade.
Note that this method must be called only from a `VersionChange` transaction
mode callback. Note that this method synchronously modifies the
{{domxref("IDBObjectStore.indexNames")}} property.
{{AvailableInWorkers}}
## Syntax
```js-nolint
deleteIndex(indexName)
```
### Parameters
- `indexName`
- : The name of the existing index to remove.
### Return value
None ({{jsxref("undefined")}}).
### Exceptions
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the method was not called from a `versionchange` transaction mode callback.
- `TransactionInactiveError` {{domxref("DOMException")}}
- : Thrown if the transaction this {{domxref("IDBObjectStore")}} belongs to is not active (e.g. has been deleted or removed.)
- `NotFoundError` {{domxref("DOMException")}}
- : Thrown if there is no index with the given name (case-sensitive) in the database.
## Examples
In the following example you can see
the {{domxref("IDBOpenDBRequest.upgradeneeded_event", "onupgradeneeded")}} handler being used to update the
database structure if a database with a higher version number is loaded.
{{domxref("IDBObjectStore.createIndex")}} is used to create new indexes on the object
store, after which we delete the unneeded old indexes with `deleteIndex()`.
For a full working example, see our
[To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) app ([view example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
```js
let db;
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4);
// these two event handlers act on the database being opened successfully, or not
DBOpenRequest.onerror = (event) => {
note.innerHTML += "<li>Error loading database.</li>";
};
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in the db variable. This is used a lot below
db = event.target.result;
// Run the displayData() function to populate the task list with all the to-do list data already in the IDB
displayData();
};
// This event handles the event whereby a new version of the database needs to be created
// Either one has not been created before, or a new version number has been submitted via the
// window.indexedDB.open line above
//it is only implemented in recent browsers
DBOpenRequest.onupgradeneeded = (event) => {
const db = event.target.result;
db.onerror = (event) => {
note.innerHTML += "<li>Error loading database.</li>";
};
// Create an objectStore for this database
const objectStore = db.createObjectStore("toDoList", {
keyPath: "taskTitle",
});
// define what data items the objectStore will contain
objectStore.createIndex("hours", "hours", { unique: false });
objectStore.createIndex("minutes", "minutes", { unique: false });
objectStore.createIndex("day", "day", { unique: false });
objectStore.createIndex("month", "month", { unique: false });
objectStore.createIndex("year", "year", { unique: false });
objectStore.createIndex("notified", "notified", { unique: false });
objectStore.deleteIndex("seconds");
objectStore.deleteIndex("contact");
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/clear/index.md | ---
title: "IDBObjectStore: clear() method"
short-title: clear()
slug: Web/API/IDBObjectStore/clear
page-type: web-api-instance-method
browser-compat: api.IDBObjectStore.clear
---
{{ APIRef("IndexedDB") }}
The **`clear()`** method of the {{domxref("IDBObjectStore")}}
interface creates and immediately returns an {{domxref("IDBRequest")}} object, and
clears this object store in a separate thread. This is for deleting all the current
data out of an object store.
Clearing an object store consists of removing all records from the object store and
removing all records in indexes that reference the object store. To remove only some of
the records in a store, use {{domxref("IDBObjectStore.delete")}} passing a key
or {{domxref("IDBKeyRange")}}.
{{AvailableInWorkers}}
## Syntax
```js-nolint
clear()
```
### Parameters
None.
### Return value
An {{domxref("IDBRequest")}} object on which subsequent events related to this operation are fired.
If the operation is successful, the value of the request's {{domxref("IDBRequest.result", "result")}} property is `undefined`.
### Exceptions
- `ReadOnlyError` {{domxref("DOMException")}}
- : Thrown if the transaction associated with this operation is in read-only [mode](/en-US/docs/Web/API/IDBTransaction/mode).
- `TransactionInactiveError` {{domxref("DOMException")}}
- : Thrown if this {{domxref("IDBObjectStore")}}'s transaction is inactive.
## Examples
In the following code snippet, we open a read/write transaction on our database and
clear all the current data out of the object store using `clear()`. For a
full working example, see our [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) app
([view example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
```js
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4);
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in the db variable.
// This is used a lot below
db = DBOpenRequest.result;
// Clear all the data from the object store
clearData();
};
function clearData() {
// open a read/write db transaction, ready for clearing the data
const transaction = db.transaction(["toDoList"], "readwrite");
// report on the success of the transaction completing, when everything is done
transaction.oncomplete = (event) => {
note.innerHTML += "<li>Transaction completed.</li>";
};
transaction.onerror = (event) => {
note.innerHTML += `<li>Transaction not opened due to error: ${transaction.error}</li>`;
};
// create an object store on the transaction
const objectStore = transaction.objectStore("toDoList");
// Make a request to clear all the data out of the object store
const objectStoreRequest = objectStore.clear();
objectStoreRequest.onsuccess = (event) => {
// report the success of our request
note.innerHTML += "<li>Request successful.</li>";
};
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/getkey/index.md | ---
title: "IDBObjectStore: getKey() method"
short-title: getKey()
slug: Web/API/IDBObjectStore/getKey
page-type: web-api-instance-method
browser-compat: api.IDBObjectStore.getKey
---
{{ APIRef("IndexedDB") }}
The **`getKey()`** method of the
{{domxref("IDBObjectStore")}} interface returns an {{domxref("IDBRequest")}} object,
and, in a separate thread, returns the key selected by the specified query. This is
for retrieving specific records from an object store.
If a key is successfully found, then a structured clone of it is created and set as the
result of the request object.
{{AvailableInWorkers}}
## Syntax
```js-nolint
getKey(key)
```
### Parameters
- `key`
- : The key or key range that identifies the record to be retrieved.
### Return Value
An {{domxref("IDBRequest")}} object on which subsequent events related to this operation are fired.
If the operation is successful, the value of the request's {{domxref("IDBRequest.result", "result")}} property is the key for the first record matching the given key or key range.
### Exceptions
This method may raise a {{domxref("DOMException")}} of one of the following types:
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the {{domxref("IDBObjectStore")}} has been deleted or removed.
- `TransactionInactiveError` {{domxref("DOMException")}}
- : Thrown if this {{domxref("IDBObjectStore")}}'s transaction is inactive.
- `DataError` {{domxref("DOMException")}}
- : Thrown if the key or key range provided contains an invalid key.
## Example
```js
let openRequest = indexedDB.open("telemetry");
openRequest.onsuccess = (event) => {
let db = event.target.result;
let store = db.transaction("netlogs").objectStore("netlogs");
let today = new Date();
let yesterday = new Date(today);
yesterday.setDate(today.getDate() - 1);
let request = store.getKey(IDBKeyRange(yesterday, today));
request.onsuccess = (event) => {
let when = event.target.result;
alert(`The 1st activity in last 24 hours was occurred at ${when}`);
};
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/getallkeys/index.md | ---
title: "IDBObjectStore: getAllKeys() method"
short-title: getAllKeys()
slug: Web/API/IDBObjectStore/getAllKeys
page-type: web-api-instance-method
browser-compat: api.IDBObjectStore.getAllKeys
---
{{ APIRef("IndexedDB") }}
The `getAllKeys()` method of the {{domxref("IDBObjectStore")}}
interface returns an {{domxref("IDBRequest")}} object retrieves record keys for all
objects in the object store matching the specified parameter or all objects in the
store if no parameters are given.
If a value is successfully found, then a structured clone of it is created and set as
the result of the request object.
This method produces the same result for:
- a record that doesn't exist in the database
- a record that has an undefined value
To tell these situations apart, you need to call the
{{domxref("IDBObjectStore.openCursor","openCursor()")}} method with the same key. That
method provides a cursor if the record exists, and no cursor if it does not.
## Syntax
```js-nolint
getAllKeys()
getAllKeys(query)
getAllKeys(query, count)
```
### Parameters
- `query` {{optional_inline}}
- : A value that is or resolves to an {{domxref("IDBKeyRange")}}.
- `count` {{optional_inline}}
- : Specifies the number of values to return if more than one is found. If it is lower
than `0` or greater than `2^32 - 1` a
{{jsxref("TypeError")}} exception will be thrown.
### Return value
An {{domxref("IDBRequest")}} object on which subsequent events related to this operation are fired.
If the operation is successful, the value of the request's {{domxref("IDBRequest.result", "result")}} property is an {{jsxref("Array")}} of the keys for all records matching the given query, up to the value of `count`, if `count` was supplied.
### Exceptions
This method may raise a {{domxref("DOMException")}} of one of the following types:
- `TransactionInactiveError` {{domxref("DOMException")}}
- : Thrown if this {{domxref("IDBObjectStore")}}'s transaction is inactive.
- `DataError` {{domxref("DOMException")}}
- : Thrown if the key or key range provided contains an invalid key or is null.
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the {{domxref("IDBObjectStore")}} has been deleted or removed.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/autoincrement/index.md | ---
title: "IDBObjectStore: autoIncrement property"
short-title: autoIncrement
slug: Web/API/IDBObjectStore/autoIncrement
page-type: web-api-instance-property
browser-compat: api.IDBObjectStore.autoIncrement
---
{{ APIRef("IndexedDB") }}
The **`autoIncrement`** read-only property of the
{{domxref("IDBObjectStore")}} interface returns the value of the auto increment flag
for this object store.
Note that every object store has its own separate auto increment counter.
{{AvailableInWorkers}}
## Value
A boolean value:
| Value | Meaning |
| ------- | ----------------------------------------- |
| `true` | The object store auto increments. |
| `false` | The object store does not auto increment. |
## Examples
In the following code snippet, we open a read/write transaction on our database and add
some data to an object store using `add()`. After the object store has been
created, we log `objectStore.autoIncrement` to
the console. For a full working example, see
our [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) app
([view example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
```js
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4);
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in the db variable.
// This is used a lot below
db = DBOpenRequest.result;
// Run the addData() function to add the data to the database
addData();
};
function addData() {
// Create a new object ready to insert into the IDB
const newItem = [
{
taskTitle: "Walk dog",
hours: 19,
minutes: 30,
day: 24,
month: "December",
year: 2013,
notified: "no",
},
];
// open a read/write db transaction, ready for adding the data
const transaction = db.transaction(["toDoList"], "readwrite");
// report on the success of the transaction completing, when everything is done
transaction.oncomplete = (event) => {
note.innerHTML += "<li>Transaction completed.</li>";
};
transaction.onerror = (event) => {
note.innerHTML +=
"<li>Transaction not opened due to error. Duplicate items not allowed.</li>";
};
// create an object store on the transaction
const objectStore = transaction.objectStore("toDoList");
console.log(objectStore.autoIncrement);
// Make a request to add our newItem object to the object store
const objectStoreRequest = objectStore.add(newItem[0]);
objectStoreRequest.onsuccess = (event) => {
// report the success of our request
note.innerHTML += "<li>Request successful.</li>";
};
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/indexnames/index.md | ---
title: "IDBObjectStore: indexNames property"
short-title: indexNames
slug: Web/API/IDBObjectStore/indexNames
page-type: web-api-instance-property
browser-compat: api.IDBObjectStore.indexNames
---
{{ APIRef("IndexedDB") }}
The **`indexNames`** read-only property of the
{{domxref("IDBObjectStore")}} interface returns a list of the names of [indexes](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#index) on objects
in this object store.
{{AvailableInWorkers}}
## Value
A {{domxref("DOMStringList")}}.
## Examples
In the following code snippet, we open a read/write transaction on our database and add
some data to an object store using `add()`. After the object store has been
created, we log `objectStore.indexNames` to the console. For a full working example, see
our [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) app
([view example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
```js
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4);
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in the db variable.
// This is used a lot below
db = this.result;
// Run the addData() function to add the data to the database
addData();
};
function addData() {
// Create a new object ready to insert into the IDB
const newItem = [
{
taskTitle: "Walk dog",
hours: 19,
minutes: 30,
day: 24,
month: "December",
year: 2013,
notified: "no",
},
];
// open a read/write db transaction, ready for adding the data
const transaction = db.transaction(["toDoList"], "readwrite");
// report on the success of the transaction completing, when everything is done
transaction.oncomplete = (event) => {
note.innerHTML += "<li>Transaction completed.</li>";
};
transaction.onerror = (event) => {
note.innerHTML +=
"<li>Transaction not opened due to error. Duplicate items not allowed.</li>";
};
// create an object store on the transaction
const objectStore = transaction.objectStore("toDoList");
console.log(objectStore.indexNames);
// Make a request to add our newItem object to the object store
const objectStoreRequest = objectStore.add(newItem[0]);
objectStoreRequest.onsuccess = (event) => {
// report the success of our request
note.innerHTML += "<li>Request successful.</li>";
};
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/delete/index.md | ---
title: "IDBObjectStore: delete() method"
short-title: delete()
slug: Web/API/IDBObjectStore/delete
page-type: web-api-instance-method
browser-compat: api.IDBObjectStore.delete
---
{{APIRef("IndexedDB")}}
The **`delete()`** method of the
{{domxref("IDBObjectStore")}} interface returns an {{domxref("IDBRequest")}} object,
and, in a separate thread, deletes the specified record or records.
Either a key or an {{domxref("IDBKeyRange")}} can be passed, allowing one or multiple
records to be deleted from a store. To delete all records in a store, use
{{domxref("IDBObjectStore.clear")}}.
Bear in mind that if you are using a {{domxref("IDBCursor", "IDBCursor")}}, you can use
the {{domxref("IDBCursor.delete()")}} method to more efficiently delete the current
record — without having to explicitly look up the record's key.
{{AvailableInWorkers}}
## Syntax
```js-nolint
delete(key)
```
### Parameters
- `key`
- : The key of the record to be deleted, or an {{domxref("IDBKeyRange")}} to delete all
records with keys in range.
### Return value
An {{domxref("IDBRequest")}} object on which subsequent events related to this operation are fired.
If the operation is successful, the value of the request's {{domxref("IDBRequest.result", "result")}} property is `undefined`.
### Exceptions
This method may raise a {{domxref("DOMException")}} of the following types:
- `TransactionInactiveError` {{domxref("DOMException")}}
- : Thrown if this object store's transaction is inactive.
- `ReadOnlyError` {{domxref("DOMException")}}
- : Thrown if the object store's transaction mode is read-only.
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the object store has been deleted.
- `DataError` {{domxref("DOMException")}}
- : Thrown if `key` is not a [valid key](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#key) or a [key range](/en-US/docs/Web/API/IDBKeyRange).
## Examples
The following code snippet shows the `deleteItem()` function,
which is part of the To-do Notifications example app. This app stores to-do
list items using IndexedDB. You can
[see the app's complete code on GitHub](https://github.com/mdn/dom-examples/tree/main/to-do-notifications), and
[try out the app live](https://mdn.github.io/dom-examples/to-do-notifications/).
The `deleteItem()` function is called when the user clicks the
button to delete a to-do list item. The item key is set in the button's
`'data-task'` data attribute, so the function
knows which item to delete. The function opens a database transaction in
which to delete the item, supplying its key. When the transaction completes,
the function updates the app UI to report that the item was deleted.
Note that in this function `db` is a global variable
referring to an {{domxref("IDBDatabase")}} object that is initialized when
the app loads.
```js
function deleteItem(event) {
// retrieve the name of the task we want to delete
let dataTask = event.target.getAttribute("data-task");
// open a database transaction and delete the task, finding it by the name we retrieved above
let transaction = db.transaction(["toDoList"], "readwrite");
let request = transaction.objectStore("toDoList").delete(dataTask);
// report that the data item has been deleted
transaction.oncomplete = () => {
// delete the parent of the button, which is the list item, so it no longer is displayed
event.target.parentNode.parentNode.removeChild(event.target.parentNode);
note.innerHTML += `<li>Task "${dataTask}" deleted.</li>`;
};
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/getall/index.md | ---
title: "IDBObjectStore: getAll() method"
short-title: getAll()
slug: Web/API/IDBObjectStore/getAll
page-type: web-api-instance-method
browser-compat: api.IDBObjectStore.getAll
---
{{ APIRef("IndexedDB") }}
The **`getAll()`** method of the
{{domxref("IDBObjectStore")}} interface returns an {{domxref("IDBRequest")}} object
containing all objects in the object store matching the specified parameter or all
objects in the store if no parameters are given.
If a value is successfully found, then a structured clone of it is created and set as
the result of the request object.
This method produces the same result for:
- a record that doesn't exist in the database
- a record that has an undefined value
To tell these situations apart, you either call
1. the {{domxref("IDBObjectStore.openCursor","openCursor()")}} method with the same
key. That method provides a cursor if the record exists, and no cursor if it does not.
2. the {{domxref("IDBObjectStore.count","count()")}} method with the same key, which
will return 1 if the row exists and 0 if it doesn't.
## Syntax
```js-nolint
getAll()
getAll(query)
getAll(query, count)
```
### Parameters
- `query` {{optional_inline}}
- : A key or {{domxref("IDBKeyRange")}} to be queried. If nothing is passed, this will
default to a key range that selects all the records in this object store.
- `count` {{optional_inline}}
- : Specifies the number of values to return if more than one is found. If it is lower
than `0` or greater than `2^32 - 1` a
{{jsxref("TypeError")}} exception will be thrown.
### Return value
An {{domxref("IDBRequest")}} object on which subsequent events related to this operation are fired.
If the operation is successful, the value of the request's {{domxref("IDBRequest.result", "result")}} property is an {{jsxref("Array")}} of the values of all records matching the given query, up to the value of `count`, if `count` was supplied.
### Exceptions
This method may raise a {{domxref("DOMException")}} of one of the following types:
- `TransactionInactiveError` {{domxref("DOMException")}}
- : Thrown if this {{domxref("IDBObjectStore")}}'s transaction is inactive.
- `DataError` {{domxref("DOMException")}}
- : Thrown if key or key range provided contains an invalid key or is null.
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the {{domxref("IDBObjectStore")}} has been deleted or removed.
- {{jsxref("TypeError")}}
- : Thrown if the `count` parameter is not between `0` and `2^32 - 1` included.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/opencursor/index.md | ---
title: "IDBObjectStore: openCursor() method"
short-title: openCursor()
slug: Web/API/IDBObjectStore/openCursor
page-type: web-api-instance-method
browser-compat: api.IDBObjectStore.openCursor
---
{{ APIRef("IndexedDB") }}
The **`openCursor()`** method of the
{{domxref("IDBObjectStore")}} interface returns an {{domxref("IDBRequest")}} object,
and, in a separate thread, returns a new {{domxref("IDBCursorWithValue")}} object.
Used for iterating through an object store with a cursor.
To determine if the add operation has completed successfully, listen for the results's
`success` event.
{{AvailableInWorkers}}
## Syntax
```js-nolint
openCursor()
openCursor(query)
openCursor(query, direction)
```
### Parameters
- `query` {{optional_inline}}
- : A key or {{domxref("IDBKeyRange")}} to be queried. If a single valid key is passed,
this will default to a range containing only that key. If nothing is passed, this will
default to a key range that selects all the records in this object store.
- `direction` {{optional_inline}}
- : A string telling the cursor which direction to travel. The default is `next`. Valid values are:
- `next`
- : The cursor is opened at the start of the store; then, the cursor returns all records, even duplicates,
in the increasing order of keys.
- `nextunique`
- : The cursor is opened at the start of the store; then, the cursor returns all records, that are not duplicates,
in the increasing order of keys.
- `prev`
- : The cursor is opened at the start of the store; then, the cursor returns all records, even duplicates,
in the decreasing order of keys.
- `prevunique`
- : The cursor is opened at the start of the store; then, the cursor returns all records, that are not duplicates,
in the decreasing order of keys.
### Return value
An {{domxref("IDBRequest")}} object on which subsequent events related to this operation are fired.
If the operation is successful, the value of the request's {{domxref("IDBRequest.result", "result")}} property is:
- an {{domxref("IDBCursorWithValue")}} object pointing at the first record matching the given query
- `null` if no matching records were found.
### Exceptions
This method may raise a {{domxref("DOMException")}} of one of the following types:
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if this {{domxref("IDBObjectStore")}} or {{domxref("IDBIndex")}} has been deleted.
- `TransactionInactiveError` {{domxref("DOMException")}}
- : Thrown if this {{domxref("IDBObjectStore")}}'s transaction is inactive.
- `DataError` {{domxref("DOMException")}}
- : Thrown if the specified key or key range is invalid.
## Examples
In this simple fragment we create a transaction, retrieve an object store, then use a
cursor to iterate through all the records in the object store:
```js
const transaction = db.transaction("name", "readonly");
const objectStore = transaction.objectStore("name");
const request = objectStore.openCursor();
request.onsuccess = (event) => {
const cursor = event.target.result;
if (cursor) {
// cursor.value contains the current record being iterated through
// this is where you'd do something with the result
cursor.continue();
} else {
// no more results
}
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/index/index.md | ---
title: "IDBObjectStore: index() method"
short-title: index()
slug: Web/API/IDBObjectStore/index
page-type: web-api-instance-method
browser-compat: api.IDBObjectStore.index
---
{{ APIRef("IndexedDB") }}
The **`index()`** method of the {{domxref("IDBObjectStore")}}
interface opens a named index in the current object store, after which it can be used
to, for example, return a series of records sorted by that index using a cursor.
{{AvailableInWorkers}}
## Syntax
```js-nolint
index(name)
```
### Parameters
- `name`
- : The name of the index to open.
### Return value
An {{domxref("IDBIndex")}} object for accessing the index.
### Exceptions
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the source object store has been deleted, or the transaction for the object store has finished.
- `NotFoundError` {{domxref("DOMException")}}
- : Thrown if there is no index with the given name (case-sensitive) in the database.
## Examples
In the following example we open a transaction and an object store, then get the index
`lName` from a simple contacts database. We then open a basic cursor on the
index using {{domxref("IDBIndex.openCursor")}} — this works the same as opening a cursor
directly on an `ObjectStore` using {{domxref("IDBObjectStore.openCursor")}}
except that the returned records are sorted based on the index, not the primary key.
Finally, we iterate through each record, and insert the data into an HTML table. For a
complete working example, see our [IDBIndex example in IndexedDB-examples demo repo](https://github.com/mdn/dom-examples/tree/main/indexeddb-examples/idbindex) ([View the example live](https://mdn.github.io/dom-examples/indexeddb-examples/idbindex/).)
```js
function displayDataByIndex() {
tableEntry.innerHTML = "";
const transaction = db.transaction(["contactsList"], "readonly");
const objectStore = transaction.objectStore("contactsList");
const myIndex = objectStore.index("lName");
myIndex.openCursor().onsuccess = (event) => {
const cursor = event.target.result;
if (cursor) {
const tableRow = document.createElement("tr");
tableRow.innerHTML =
`<td>${cursor.value.id}</td>` +
`<td>${cursor.value.lName}</td>` +
`<td>${cursor.value.fName}</td>` +
`<td>${cursor.value.jTitle}</td>` +
`<td>${cursor.value.company}</td>` +
`<td>${cursor.value.eMail}</td>` +
`<td>${cursor.value.phone}</td>` +
`<td>${cursor.value.age}</td>`;
tableEntry.appendChild(tableRow);
cursor.continue();
} else {
console.log("Entries all displayed.");
}
};
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/put/index.md | ---
title: "IDBObjectStore: put() method"
short-title: put()
slug: Web/API/IDBObjectStore/put
page-type: web-api-instance-method
browser-compat: api.IDBObjectStore.put
---
{{ APIRef("IndexedDB") }}
The **`put()`** method of the {{domxref("IDBObjectStore")}} interface updates a given record in a database, or inserts a new record if the given item does not already exist.
It returns an {{domxref("IDBRequest")}} object, and, in a separate thread, creates a [structured clone](https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#structured-clone) of the value and stores the cloned value in the object store. This is for adding new records, or updating existing records in an object store when the transaction's mode is `readwrite`. If the record is successfully stored, then a success event is fired on the returned request object with the `result` set to the key for the stored record, and the `transaction` set to the transaction in which this object store is opened.
The put method is an _update or insert_ method.
See the {{domxref("IDBObjectStore.add")}} method for an _insert only_ method.
Bear in mind that if you have a {{domxref("IDBCursor","IDBCursor")}} to the record you
want to update, updating it with {{domxref("IDBCursor.update()")}} is preferable to
using {{domxref("IDBObjectStore.put()")}}. Doing so makes it clear that an existing
record will be updated, instead of a new record being inserted.
{{AvailableInWorkers}}
## Syntax
```js-nolint
put(item)
put(item, key)
```
### Parameters
- `item`
- : The item you wish to update (or insert).
- `key` {{optional_inline}}
- : The primary key of the record you want to update (e.g. from
{{domxref("IDBCursor.primaryKey")}}).
### Return value
An {{domxref("IDBRequest")}} object on which subsequent events related to this operation are fired.
If the operation is successful, the value of the request's {{domxref("IDBRequest.result", "result")}} property is the key for the new or updated record.
### Exceptions
This method may raise a {{domxref("DOMException")}} of one of the following types:
- `ReadOnlyError` {{domxref("DOMException")}}
- : Thrown if the transaction associated with this operation is in read-only <a href="/en-US/docs/Web/API/IDBTransaction#mode_constants">mode</a>.
- `TransactionInactiveError` {{domxref("DOMException")}}
- : Thrown if this {{domxref("IDBObjectStore")}}'s transaction is inactive.
- `DataError` {{domxref("DOMException")}}
- : Thrown if any of the following conditions apply:
- The object store uses [in-line keys](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#in-line_key) or has a [key generator](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#key_generator), and a `key` parameter was provided.
- The object store uses out-of-line keys and has no key generator, and no `key` parameter was provided.
- The object store uses in-line keys but no `key` generator, and the object store's [key path](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#key_path) does not yield a valid key.
- The `key` parameter was provided but does not contain a valid key.
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the {{domxref("IDBObjectStore")}} has been deleted or removed.
- `DataCloneError` {{domxref("DOMException")}}
- : Thrown if the data being stored could not be cloned by the internal structured cloning algorithm.
## Examples
The following example requests a given record title; when that request is successful
the `onsuccess` function gets the associated record from the
{{domxref("IDBObjectStore")}} (made available
as `objectStoreTitleRequest.result`), updates
one property of the record, and then puts the updated record back into the object
store in another request with `put()`. For a full working example, see
our [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) app
([view example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
```js
const title = "Walk dog";
// Open up a transaction as usual
const objectStore = db
.transaction(["toDoList"], "readwrite")
.objectStore("toDoList");
// Get the to-do list object that has this title as it's title
const objectStoreTitleRequest = objectStore.get(title);
objectStoreTitleRequest.onsuccess = () => {
// Grab the data object returned as the result
const data = objectStoreTitleRequest.result;
// Update the notified value in the object to "yes"
data.notified = "yes";
// Create another request that inserts the item back into the database
const updateTitleRequest = objectStore.put(data);
// Log the transaction that originated this request
console.log(
`The transaction that originated this request is ${updateTitleRequest.transaction}`,
);
// When this new request succeeds, run the displayData() function again to update the display
updateTitleRequest.onsuccess = () => {
displayData();
};
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/count/index.md | ---
title: "IDBObjectStore: count() method"
short-title: count()
slug: Web/API/IDBObjectStore/count
page-type: web-api-instance-method
browser-compat: api.IDBObjectStore.count
---
{{ APIRef("IndexedDB") }}
The **`count()`** method of the {{domxref("IDBObjectStore")}}
interface returns an {{domxref("IDBRequest")}} object, and, in a separate thread,
returns the total number of records that match the provided key or
{{domxref("IDBKeyRange")}}. If no arguments are provided, it returns the total number
of records in the store.
{{AvailableInWorkers}}
## Syntax
```js-nolint
count()
count(query)
```
### Parameters
- `query` {{optional_inline}}
- : A key or {{domxref("IDBKeyRange")}} object that specifies a range of records you
want to count.
### Return value
An {{domxref("IDBRequest")}} object on which subsequent events related to this operation are fired.
If the operation is successful, the value of the request's {{domxref("IDBRequest.result", "result")}} property is the number of records that match the given query.
### Exceptions
This method may raise a {{domxref("DOMException")}} of one of the following types:
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if this {{domxref("IDBObjectStore")}} has been deleted.
- `TransactionInactiveError` {{domxref("DOMException")}}
- : Thrown if this {{domxref("IDBObjectStore")}}'s transaction is inactive.
- `DataError` {{domxref("DOMException")}}
- : Thrown if the specified key or key range is invalid.
## Examples
In this simple fragment we create a transaction, retrieve an object store, then count
the number of records in the store using `count()` — when the success handler
fires, we log the count value (an integer) to the console.
```js
const transaction = db.transaction(["fThings"], "readonly");
const objectStore = transaction.objectStore("fThings");
const countRequest = objectStore.count();
countRequest.onsuccess = () => {
console.log(countRequest.result);
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbobjectstore | data/mdn-content/files/en-us/web/api/idbobjectstore/keypath/index.md | ---
title: "IDBObjectStore: keyPath property"
short-title: keyPath
slug: Web/API/IDBObjectStore/keyPath
page-type: web-api-instance-property
browser-compat: api.IDBObjectStore.keyPath
---
{{ APIRef("IndexedDB") }}
The **`keyPath`** read-only property of the
{{domxref("IDBObjectStore")}} interface returns the [key path](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#key_path) of this object store.
If this property is null, the application must provide a key for each modification
operation.
{{AvailableInWorkers}}
## Value
Any value type.
## Examples
In the following code snippet, we open a read/write transaction on our database and add
some data to an object store using `add()`. After the object store has been
created, we log `objectStore.keyPath` to
the console. For a full working example, see our [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) app
([view example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
```js
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4);
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in the db variable.
// This is used a lot below
db = DBOpenRequest.result;
// Run the addData() function to add the data to the database
addData();
};
function addData() {
// Create a new object ready to insert into the IDB
const newItem = [
{
taskTitle: "Walk dog",
hours: 19,
minutes: 30,
day: 24,
month: "December",
year: 2013,
notified: "no",
},
];
// open a read/write db transaction, ready for adding the data
const transaction = db.transaction(["toDoList"], "readwrite");
// report on the success of the transaction completing, when everything is done
transaction.oncomplete = (event) => {
note.innerHTML += "<li>Transaction completed.</li>";
};
transaction.onerror = (event) => {
note.innerHTML +=
"<li>Transaction not opened due to error. Duplicate items not allowed.</li>";
};
// create an object store on the transaction
const objectStore = transaction.objectStore("toDoList");
console.log(objectStore.keyPath);
// Make a request to add our newItem object to the object store
const objectStoreRequest = objectStore.add(newItem[0]);
objectStoreRequest.onsuccess = (event) => {
// report the success of our request
note.innerHTML += "<li>Request successful.</li>";
};
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/svgstopelement/index.md | ---
title: SVGStopElement
slug: Web/API/SVGStopElement
page-type: web-api-interface
browser-compat: api.SVGStopElement
---
{{APIRef("SVG")}}
The **`SVGStopElement`** interface corresponds to the {{SVGElement("stop")}} element.
{{InheritanceDiagram}}
## Instance properties
_This interface also inherits properties from its parent interface, {{domxref("SVGElement")}}._
- {{domxref("SVGStopElement.offset")}} {{ReadOnlyInline}}
- : An {{domxref("SVGAnimatedNumber")}} corresponding to the {{SVGAttr("offset")}} of the given element.
## Instance methods
_This interface doesn't implement any specific methods, but inherits methods from its parent interface, {{domxref("SVGElement")}}._
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/hmackeygenparams/index.md | ---
title: HmacKeyGenParams
slug: Web/API/HmacKeyGenParams
page-type: web-api-interface
spec-urls: https://w3c.github.io/webcrypto/#dfn-HmacKeyGenParams
---
{{ APIRef("Web Crypto API") }}
The **`HmacKeyGenParams`** dictionary of the [Web Crypto API](/en-US/docs/Web/API/Web_Crypto_API) represents the object that should be passed as the `algorithm` parameter into {{domxref("SubtleCrypto.generateKey()")}}, when generating a key for the [HMAC](/en-US/docs/Web/API/SubtleCrypto/sign#hmac) algorithm.
## Instance properties
- `name`
- : A string. This should be set to `HMAC`.
- `hash`
- : A string representing the name of the [digest function](/en-US/docs/Web/API/SubtleCrypto/digest#supported_algorithms) to use. You can pass any of `SHA-1`, `SHA-256`, `SHA-384`, or `SHA-512` here.
- `length` {{optional_inline}}
- : A `Number` — the length in bits of the key. If this is omitted, the length of the key is equal to the block size of the hash function you have chosen. Unless you have a good reason to use a different length, omit this property and use the default.
## Examples
See the examples for {{domxref("SubtleCrypto.generateKey()")}}.
## Specifications
{{Specifications}}
## Browser compatibility
Browsers that support the "HMAC" algorithm for the {{domxref("SubtleCrypto.generateKey()")}} method will support this type.
## See also
- {{domxref("SubtleCrypto.generateKey()")}}.
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/web_authentication_api/index.md | ---
title: Web Authentication API
slug: Web/API/Web_Authentication_API
page-type: web-api-overview
browser-compat: api.PublicKeyCredential
---
{{securecontext_header}}{{DefaultAPISidebar("Web Authentication API")}}
The Web Authentication API (WebAuthn) is an extension of the [Credential Management API](/en-US/docs/Web/API/Credential_Management_API) that enables strong authentication with public key cryptography, enabling passwordless authentication and secure multi-factor authentication (MFA) without SMS texts.
> **Note:** [Passkeys](https://passkeys.dev/) are a significant use case for web authentication; see [Create a passkey for passwordless logins](https://web.dev/articles/passkey-registration) and [Sign in with a passkey through form autofill](https://web.dev/articles/passkey-form-autofill) for implementation details. See also [Google Identity > Passwordless login with passkeys](https://developers.google.com/identity/passkeys).
## WebAuthn concepts and usage
WebAuthn uses [asymmetric (public-key) cryptography](https://en.wikipedia.org/wiki/Public-key_cryptography) instead of passwords or SMS texts for registering, authenticating, and [multi-factor authentication](https://en.wikipedia.org/wiki/Multi-factor_authentication) with websites. This has some benefits:
- **Protection against phishing:** An attacker who creates a fake login website can't login as the user because the signature changes with the [origin](/en-US/docs/Glossary/Origin) of the website.
- **Reduced impact of data breaches:** Developers don't need to hash the public key, and if an attacker gets access to the public key used to verify the authentication, it can't authenticate because it needs the private key.
- **Invulnerable to password attacks:** Some users might reuse passwords, and an attacker may obtain the user's password for another website (e.g. via a data breach). Also, text passwords are much easier to brute-force than a digital signature.
Many websites already have pages that allow users to register new accounts or sign into an existing account, and WebAuthn acts as a replacement or enhancement for the authentication part of the system. It extends the [Credential Management API](/en-US/docs/Web/API/Credential_Management_API), abstracting communication between the user agent and an authenticator and providing the following new functionality:
- When {{domxref("CredentialsContainer.create()", "navigator.credentials.create()")}} is used with the `publicKey` option, the user agent creates new credentials via an authenticator — either for registering a new account or for associating a new asymmetric key pair with an existing account.
- When registering a new account, these credentials are stored on a server (also referred to as a service or a [relying party](https://en.wikipedia.org/wiki/Relying_party)) and can be subsequently used to log a user in.
- The asymmetric key pair is stored in the authenticator, which can then be used to authenticate a user with a relying party for example during MFA. The authenticator may be embedded into the user agent, into an operating system, such as Windows Hello, or it may be a physical token, such as a USB or Bluetooth Security Key.
- When {{domxref("CredentialsContainer.get()", "navigator.credentials.get()")}} is used with the `publicKey` option, the user agent uses an existing set of credentials to authenticate to a relying party (either as the primary login or to provide an additional factor during MFA as described above).
In their most basic forms, both `create()` and `get()` receive a very large random number called the "challenge" from the server and return the challenge signed by the private key back to the server. This proves to the server that a user has the private key required for authentication without revealing any secrets over the network.
> **Note:** The "challenge" must be a buffer of random information at least 16 bytes in size.
### Creating a key pair and registering a user
To illustrate how the credential creation process works, let's describe the typical flow that occurs when a user wants to register a credential to a relying party:
1. The relying party server sends user and relying party information to the web app handling the registration process, along with the "challenge", using an appropriate secure mechanism (for example [Fetch](/en-US/docs/Web/API/Fetch_API) or [XMLHttpRequest](/en-US/docs/Web/API/XMLHttpRequest)).
> **Note:** The format for sharing information between the relying party server and the web app is up to the application.
> A recommended approach is to exchange {{glossary("JSON type representation")}} objects for credentials and credential options.
> Convenience methods have been created in `PublicKeyCredential` for converting from the JSON representations to the form required by the authentication APIs: {{domxref("PublicKeyCredential.parseCreationOptionsFromJSON_static", "parseCreationOptionsFromJSON()")}}, {{domxref("PublicKeyCredential.parseRequestOptionsFromJSON_static", "parseRequestOptionsFromJSON()")}} and {{domxref("PublicKeyCredential.toJSON()")}}.
2. The web app initiates generation of a new credential via the authenticator, on behalf of the relying party, via a {{domxref("CredentialsContainer.create()", "navigator.credentials.create()")}} call. This call is passed a `publicKey` option specifying device capabilities, e.g., whether the device provides its own user authentication (for example with biometrics).
A typical `create()` call might look like so:
```js
let credential = await navigator.credentials.create({
publicKey: {
challenge: new Uint8Array([117, 61, 252, 231, 191, 241, ...]),
rp: { id: "acme.com", name: "ACME Corporation" },
user: {
id: new Uint8Array([79, 252, 83, 72, 214, 7, 89, 26]),
name: "jamiedoe",
displayName: "Jamie Doe"
},
pubKeyCredParams: [ {type: "public-key", alg: -7} ]
}
});
```
The parameters of the `create()` call are passed to the authenticator, along with a SHA-256 hash that is signed to ensure that it isn't tampered with.
3. After the authenticator obtains user consent, it generates a key pair and returns the public key and optional signed attestation to the web app. This is provided when the {{jsxref("Promise")}} returned by the `create()` call fulfills, in the form of a {{domxref("PublicKeyCredential")}} object instance (the {{domxref("PublicKeyCredential.response")}} property contains the attestation information).
4. The web app forwards the {{domxref("PublicKeyCredential")}} to the server, again using an appropriate mechanism.
5. The server stores the public key, coupled with the user identity, to remember the credential for future authentications. During this process, it performs a series of checks to ensure that the registration was complete and not tampered with. These include:
1. Verifying that the challenge is the same as the challenge that was sent.
2. Ensuring that the origin was the origin expected.
3. Validating that the signature and attestation are using the correct certificate chain for the specific model of the authenticator used to generated the key par in the first place.
> **Warning:** Attestation provides a way for a relying party to determine the provenance of an authenticator. Relying parties should not attempt to maintain allowlists of authenticators.
### Authenticating a user
After a user has registered with WebAuthn, they can authenticate (i.e., login) with the service. The authentication flow looks similar to the registration flow, the main differences being that authentication:
1. Doesn't require user or relying party information
2. Creates an assertion using the previously-generated key pair for the service, rather than the authenticator's key pair.
A typical authentication flow is as follows:
1. The relying party generates a "challenge" and sends it to the user agent using an appropriate secure mechanism, along with a list of relying party and user credentials. It can also indicate where to look for the credential, e.g., on a local built-in authenticator, or on an external one over USB, BLE, etc.
2. The browser asks the authenticator to sign the challenge via a {{domxref("CredentialsContainer.get()", "navigator.credentials.get()")}} call, which is passed the credentials in a `publicKey` option.
A typical `get()` call might look like so:
```js
let credential = await navigator.credentials.get({
publicKey: {
challenge: new Uint8Array([139, 66, 181, 87, 7, 203, ...]),
rpId: "acme.com",
allowCredentials: [{
type: "public-key",
id: new Uint8Array([64, 66, 25, 78, 168, 226, 174, ...])
}],
userVerification: "required",
}
});
```
The parameters of the `get()` call are passed to the authenticator to handle the authentication.
3. If the authenticator contains one of the given credentials and is able to successfully sign the challenge, it returns a signed assertion to the web app after receiving user consent. This is provided when the {{jsxref("Promise")}} returned by the `get()` call fulfills, in the form of a {{domxref("PublicKeyCredential")}} object instance (the {{domxref("PublicKeyCredential.response")}} property contains the assertion information).
4. The web app forwards the signed assertion to the relying party server for the relying party to validate. The validation checks include:
1. Using the public key that was stored during the registration request to validate the signature by the authenticator.
2. Ensuring that the challenge that was signed by the authenticator matches the challenge that was generated by the server.
3. Checking that the Relying Party ID is the one expected for this service.
5. Once verified by the server, the authentication flow is considered successful.
## Controlling access to the API
The availability of WebAuthn can be controlled using a [Permissions Policy](/en-US/docs/Web/HTTP/Permissions_Policy), specifying two directives in particular:
- {{httpheader("Permissions-Policy/publickey-credentials-create", "publickey-credentials-create")}}: Controls the availability of {{domxref("CredentialsContainer.create", "navigator.credentials.create()")}} with the `publicKey` option.
- {{httpheader("Permissions-Policy/publickey-credentials-get", "publickey-credentials-get")}}: Controls the availability of {{domxref("CredentialsContainer.get", "navigator.credentials.get()")}} with the `publicKey` option.
Both directives have a default allowlist value of `"self"`, meaning that by default these methods can be used in top-level document contexts.
In addition, `get()` can be used in nested browsing contexts loaded from the same origin as the top-most document.
`get()` and `create()` can be used in nested browsing contexts loaded from the different origins to the top-most document (i.e. in cross-origin `<iframes>`), if allowed by the [`publickey-credentials-get`](/en-US/docs/Web/HTTP/Headers/Permissions-Policy/publickey-credentials-get) and [`publickey-credentials-create`](/en-US/docs/Web/HTTP/Headers/Permissions-Policy/publickey-credentials-create) `Permission-Policy` directives, respectively.
For cross-origin `create()` calls, where the permission was granted by [`allow=` on an iframe](/en-US/docs/Web/HTTP/Headers/Permissions-Policy#iframes), the frame must also have {{glossary("Transient activation")}}.
> **Note:** Where a policy forbids use of these methods, the {{jsxref("Promise", "promises", "", "nocode")}} returned by them will reject with a `NotAllowedError` {{domxref("DOMException")}}.
### Basic access control
If you wish to allow access to a specific subdomain only, you could provide it like this:
```http
Permissions-Policy: publickey-credentials-get=("https://subdomain.example.com")
Permissions-Policy: publickey-credentials-create=("https://subdomain.example.com")
```
### Allowing embedded `create` and `get()` calls in an `<iframe>`
If you wish to authenticate with `get()` or `create()` in an `<iframe>`, there are a couple of steps to follow:
1. The site embedding the relying party site must provide permission via an `allow` attribute:
- If using `get()`:
```html
<iframe
src="https://auth.provider.com"
allow="publickey-credentials-get *">
</iframe>
```
- If using `create()`:
```html
<iframe
src="https://auth.provider.com"
allow="publickey-credentials-create 'self' https://a.auth.provider.com https://b.auth.provider.com">
</iframe>
```
The `<iframe>` must also have {{glossary("Transient activation")}} if `create()` is called cross-origin.
2. The relying party site must provide permission for the above access via a `Permissions-Policy` header:
```http
Permissions-Policy: publickey-credentials-get=*
Permissions-Policy: publickey-credentials-create=*
```
Or to allow only a specific URL to embed the relying party site in an `<iframe>`:
```http
Permissions-Policy: publickey-credentials-get=("https://subdomain.example.com")
Permissions-Policy: publickey-credentials-create=("https://*.auth.provider.com")
```
## Interfaces
- {{domxref("AuthenticatorAssertionResponse")}}
- : Provides proof to a service that an authenticator has the necessary key pair to successfully handle an authentication request initiated by a {{domxref("CredentialsContainer.get()")}} call. Available in the {{domxref("PublicKeyCredential.response", "response")}} property of the {{domxref("PublicKeyCredential")}} instance obtained when the `get()` {{jsxref("Promise")}} fulfills.
- {{domxref("AuthenticatorAttestationResponse")}}
- : The result of a WebAuthn credential registration (i.e., a {{domxref("CredentialsContainer.create()")}} call). It contains information about the credential that the server needs to perform WebAuthn assertions, such as its credential ID and public key. Available in the {{domxref("PublicKeyCredential.response", "response")}} property of the {{domxref("PublicKeyCredential")}} instance obtained when the `create()` {{jsxref("Promise")}} fulfills.
- {{domxref("AuthenticatorResponse")}}
- : The base interface for {{domxref("AuthenticatorAttestationResponse")}} and {{domxref("AuthenticatorAssertionResponse")}}.
- {{domxref("PublicKeyCredential")}}
- : Provides information about a public key / private key pair, which is a credential for logging in to a service using an un-phishable and data-breach resistant asymmetric key pair instead of a password. Obtained when the {{jsxref("Promise")}} returned via a {{domxref("CredentialsContainer.create", "create()")}} or {{domxref("CredentialsContainer.get", "get()")}} call fulfills.
## Extensions to other interfaces
- {{domxref("CredentialsContainer.create()")}}, the `publicKey` option
- : Calling `create()` with a `publicKey` option initiates the creation of new asymmetric key credentials via an authenticator, as explained above.
- {{domxref("CredentialsContainer.get()")}}, the `publicKey` option
- : Calling `get()` with a `publicKey` option instructs the user agent uses an existing set of credentials to authenticate to a relying party.
## Examples
### Demo sites
- [Mozilla Demo](https://webauthn.bin.coffee/) website and its [source code](https://github.com/jcjones/webauthn.bin.coffee).
- [Google Demo](https://try-webauthn.appspot.com/) website and its [source code](https://github.com/google/webauthndemo).
- [WebAuthn.io demo](https://webauthn.io/) website and its [source code](https://github.com/duo-labs/webauthn.io).
- [github.com/webauthn-open-source](https://github.com/webauthn-open-source) and its [client source code](https://github.com/webauthn-open-source/webauthn-simple-app) and [server source code](https://github.com/webauthn-open-source/fido2-lib)
### Usage example
> **Note:** For security reasons, the Web Authentication API calls ({{domxref("CredentialsContainer.create", "create()")}} and {{domxref("CredentialsContainer.get","get()")}}) are canceled if the browser window loses focus while the call is pending.
```js
// sample arguments for registration
const createCredentialDefaultArgs = {
publicKey: {
// Relying Party (a.k.a. - Service):
rp: {
name: "Acme",
},
// User:
user: {
id: new Uint8Array(16),
name: "[email protected]",
displayName: "Carina P. Anand",
},
pubKeyCredParams: [
{
type: "public-key",
alg: -7,
},
],
attestation: "direct",
timeout: 60000,
challenge: new Uint8Array([
// must be a cryptographically random number sent from a server
0x8c, 0x0a, 0x26, 0xff, 0x22, 0x91, 0xc1, 0xe9, 0xb9, 0x4e, 0x2e, 0x17, 0x1a,
0x98, 0x6a, 0x73, 0x71, 0x9d, 0x43, 0x48, 0xd5, 0xa7, 0x6a, 0x15, 0x7e, 0x38,
0x94, 0x52, 0x77, 0x97, 0x0f, 0xef,
]).buffer,
},
};
// sample arguments for login
const getCredentialDefaultArgs = {
publicKey: {
timeout: 60000,
// allowCredentials: [newCredential] // see below
challenge: new Uint8Array([
// must be a cryptographically random number sent from a server
0x79, 0x50, 0x68, 0x71, 0xda, 0xee, 0xee, 0xb9, 0x94, 0xc3, 0xc2, 0x15, 0x67,
0x65, 0x26, 0x22, 0xe3, 0xf3, 0xab, 0x3b, 0x78, 0x2e, 0xd5, 0x6f, 0x81, 0x26,
0xe2, 0xa6, 0x01, 0x7d, 0x74, 0x50,
]).buffer,
},
};
// register / create a new credential
navigator.credentials
.create(createCredentialDefaultArgs)
.then((cred) => {
console.log("NEW CREDENTIAL", cred);
// normally the credential IDs available for an account would come from a server
// but we can just copy them from above…
const idList = [
{
id: cred.rawId,
transports: ["usb", "nfc", "ble"],
type: "public-key",
},
];
getCredentialDefaultArgs.publicKey.allowCredentials = idList;
return navigator.credentials.get(getCredentialDefaultArgs);
})
.then((assertion) => {
console.log("ASSERTION", assertion);
})
.catch((err) => {
console.log("ERROR", err);
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/web_authentication_api | data/mdn-content/files/en-us/web/api/web_authentication_api/webauthn_extensions/index.md | ---
title: Web Authentication extensions
slug: Web/API/Web_Authentication_API/WebAuthn_extensions
page-type: guide
browser-compat:
- api.CredentialsContainer.create.publicKey_option.extensions
- api.CredentialsContainer.get.publicKey_option.extensions
---
{{DefaultAPISidebar("Web Authentication API")}}
The [Web Authentication API](/en-US/docs/Web/API/Web_Authentication_API) has a system of extensions — extra functionality that can be requested during credential creation ({{domxref("CredentialsContainer.create()", "navigator.credentials.create()")}}) or authentication ({{domxref("CredentialsContainer.get()", "navigator.credentials.get()")}}) operations. This article explains how to request WebAuthn extensions, retrieve information about the responses from those requests, and the available extensions — including browser support and expected inputs and outputs.
## How to use WebAuthn extensions
When invoking {{domxref("CredentialsContainer.create()", "navigator.credentials.create()")}} or {{domxref("CredentialsContainer.get()", "navigator.credentials.get()")}}, the `publicKey` object parameter required to initiate a WebAuthn flow can include an `extensions` property. The value of `extensions` is itself an object, the properties of which are the input values for any extensions the relying party wishes to request the use of in the method you call.
Behind the scenes, the inputs are processed by the user agent and/or the authenticator.
For example, in a `publicKey` object for a `create()` call, we might want to request the use of two extensions:
1. The `credProps` extension. Relying parties set `credProps` to request that the browser tells the relying party whether the credential is resident/discoverable after registration. This is useful when calling `create()` with `publicKey.authenticatorSelection.residentKey = "preferred"`. To request it, you also need to set `publicKey.extensions.credProps = true` when the browser makes a credential and, depending on the type of authenticator used, it will be discoverable (for example, the FIDO2 authenticator would typically make it discoverable; FIDO1/U2F security key would be non-discoverable). `credProps` is processed by the user agent only.
2. The `minPinLength` extension allows relying parties to request the authenticator's minimum PIN length. This requires `extensions.minPinLength` to be set to `true`. `minPinLength` is processed by the authenticator, with the user agent only serving to pass the input data along to it.
```js
const publicKey = {
challenge: new Uint8Array([117, 61, 252, 231, 191, 241, ...]),
rp: { id: "acme.com", name: "ACME Corporation" },
user: {
id: new Uint8Array([79, 252, 83, 72, 214, 7, 89, 26]),
name: "jamiedoe",
displayName: "Jamie Doe"
},
pubKeyCredParams: [ {type: "public-key", alg: -7} ],
authenticatorSelection: {
residentKey: "preferred"
},
extensions: {
credProps: true,
minPinLength: true
}
}
```
We can then pass the `publicKey` object into a `create()` call to initiate the credential creation flow:
```js
navigator.credentials.create({ publicKey });
```
## Retrieving extension request results
If successful, the `create()` call will return a {{jsxref("Promise")}} that resolves with a {{domxref("PublicKeyCredential")}} object. Once extension processing has completed, the results of the processing are communicated in the response (although not in all cases — it is possible for extensions to have no output).
```js
navigator.credentials
.create({ publicKey })
.then((publicKeyCred) => {
const myClientExtResults = publicKeyCred.getClientExtensionResults();
// myClientExtResults will contain the output of processing
// the "credProps" extension
const authData = publicKeyCred.response.getAuthenticatorData();
// authData will contain authenticator data, which will include
// authenticator extension processing results, i.e., minPinLength
})
.catch((err) => {
console.error(err);
});
```
As demonstrated by the above code snippet, there are two different places to find your output extension results:
1. You can find the results of client (user agent) extension processing by calling the {{domxref("PublicKeyCredential.getClientExtensionResults()")}} method. This returns a {{jsxref("Map", "map")}}, with each entry being an extensions' identifier string as the key, and the output from the processing of the extension by the client as the value. In the example above, if the browser supported the `credProps` extension and it was processed correctly, the `myClientExtResults` map object would contain one entry, `"credProps"`, with a value of `{ rk: true }`. This would verify that the created credential is indeed discoverable.
2. You can find the results of authenticator extension processing in the authenticator data for the operation:
- In the case of `PublicKeyCredential`s returned from successful `create()` calls, this can be returned via a call to {{domxref("AuthenticatorAttestationResponse.getAuthenticatorData", "publicKeyCredential.response.getAuthenticatorData()")}}.
- In the case of `PublicKeyCredential`s returned from successful `get()` calls, this can be found in the {{domxref("AuthenticatorAssertionResponse.authenticatorData", "publicKeyCredential.response.authenticatorData")}} property.
Authenticator data takes the form of an {{jsxref("ArrayBuffer")}} with a consistent structure — see [authenticator data](/en-US/docs/Web/API/Web_Authentication_API/Authenticator_data). The authenticator extension results data is always found in a section at the end, as a [CBOR map](https://cbor.io/) representing the results. See {{domxref("AuthenticatorAssertionResponse.authenticatorData")}} for a detailed description of the complete authenticator data structure.
Back to our example, if the relying party is authorized to receive the `minPinLength` value, the authenticator data would contain a representation of it in the following form: `"minPinLength": uint`.
## Available extensions
The extensions below do not represent an exhaustive list of all the extensions available. We have elected to document extensions that we know to be standardized and supported by at least one rendering engine.
### `appid`
- Usable in: Authentication ({{domxref("CredentialsContainer.get()","get()")}})
- Processed by: User agent
- Specification: [FIDO AppID Extension (appid)](https://w3c.github.io/webauthn/#sctn-appid-extension)
Allows a relying party to request an assertion for a credential previously registered using the legacy FIDO U2F JavaScript API, avoiding the hassle of re-registering the credential. The `appid` is that API's equivalent to the `rpId` in WebAuthn (although bear in mind that `appid`s are in the form of URLs, whereas `rpId`s are in the form of domains).
#### Input
The `publicKey`'s `extensions` property must contain an `appid` property, the value of which is the application identifier used in the legacy API. For example:
```js
extensions: {
appid: "https://accounts.example.com";
}
```
You must also list the FIDO U2F credential IDs in the `publicKey`'s `allowCredentials` property, for example:
```js
allowCredentials: {
[
id: arrayBuffer, // needs to contain decoded binary form of id
transports: ["nfc", "usb"]
type: "public-key"
]
}
```
#### Output
Outputs `appid: true` if the `appid` was successfully used for the assertion, or `appid: false` otherwise.
### `appidExclude`
- Usable in: Registration ({{domxref("CredentialsContainer.create()","create()")}})
- Processed by: User agent
- Specification: [FIDO AppID Exclusion Extension (appidExclude)](https://w3c.github.io/webauthn/#sctn-appid-exclude-extension)
Allows a relying party to exclude authenticators containing specified credentials previously registered using the legacy FIDO U2F JavaScript API during registration. This is required because by default the contents of the `excludeCredentials` field are assumed to be WebAuthn credentials. When using this extension, you can include legacy FIDO U2F credentials inside `excludeCredentials`, and they will be recognized as such.
#### Input
The `publicKey`'s `extensions` property must contain an `appidExclude` property, the value of which is the identifier of the relying party requesting to exclude authenticators by legacy FIDO U2F credentials. For example:
```js
extensions: {
appidExclude: "https://accounts.example.com";
}
```
You can then list FIDO U2F credentials in the `publicKey`'s `excludeCredentials` property, for example:
```js
excludeCredentials: {
[
id: arrayBuffer, // needs to contain decoded binary form of id
transports: ["nfc", "usb"]
type: "public-key"
]
}
```
#### Output
Outputs `appidExclude: true` if the extension was acted upon, or `appidExclude: false` otherwise.
### `credProps`
- Usable in: Registration ({{domxref("CredentialsContainer.create()","create()")}})
- Processed by: User agent
- Specification: [Credential Properties Extension (credProps)](https://w3c.github.io/webauthn/#sctn-authenticator-credential-properties-extension)
Allows a relying party to request additional information/properties about the credential that was created. This is currently only useful when calling `create()` with `publicKey.authenticatorSelection.residentKey = "preferred"`; it requests information on whether the created credential is discoverable.
#### Input
The `publicKey`'s `extensions` property must contain a `credProps` property with a value of `true`:
```js
extensions: {
credProps: true;
}
```
You must also set `authenticatorSelection.requireResidentKey` to `true`, which indicates that a resident key is required.
```js
authenticatorSelection: {
requireResidentKey: true;
}
```
#### Output
Outputs the following if the registered {{domxref("PublicKeyCredential")}} is a client-side discoverable credential:
```js
credProps: {
rk: true;
}
```
If `rk` is set to `false` in the output, the credential is a server-side credential. If `rk` is not present in the output, then it is not known whether the credential is client-side discoverable or server-side.
### `credProtect`
- Usable in: Registration ({{domxref("CredentialsContainer.create()","create()")}})
- Processed by: Authenticator
- Specification: [Credential Protection (credProtect)](https://fidoalliance.org/specs/fido-v2.1-ps-20210615/fido-client-to-authenticator-protocol-v2.1-ps-20210615.html#sctn-credProtect-extension)
Allows a relying party to specify a minimum credential protection policy when creating a credential.
#### Input
The `publicKey`'s `extensions` property must contain a `credentialProtectionPolicy` property specifying the protection level of the credential to be created, and a boolean `enforceCredentialProtectionPolicy` property specifying whether the `create()` call should fail rather than creating a credential that does not conform to the specified policy:
```js
extensions: {
credentialProtectionPolicy: "userVerificationOptional",
enforceCredentialProtectionPolicy: true
}
```
The available `credentialProtectionPolicy` values are as follows:
- `"userVerificationOptional"` {{Experimental_Inline}}
- : User verification is optional. The equivalent `credProtect` value sent to the authenticator for processing is `0x01`.
- `"userVerificationOptionalWithCredentialIDList"`
- : User verification is optional only if the credential is discoverable (i.e., it is client-side discoverable). The equivalent `credProtect` value sent to the authenticator for processing is `0x02`.
- `"userVerificationRequired"`
- : User verification is always required. The equivalent `credProtect` value sent to the authenticator for processing is `0x03`.
> **Note:**
> Chromium will default to `userVerificationOptionalWithCredentialIDList` or `userVerificationRequired`, depending on the type of request:
>
> - Chromium will request a protection level of `userVerificationOptionalWithCredentialIDList` when creating a credential if `residentKey` is set to `preferred` or `required`. (Setting `requireResidentKey` is treated the same as required.) This ensures that simple physical possession of a security key does not allow the presence of a discoverable credential for a given `rpId` to be queried.
> - Additionally, if `residentKey` is `required` and `userVerification` is preferred, the protection level will be increased to `userVerificationRequired`. This ensures that physical possession of a security key does not allow sign-in to a site that doesn't require user verification. (This is not complete protection; sites should still carefully consider the security of their users.)
> - If the site requests an explicit `credProtect` level, that will override these defaults. These defaults never cause the protection level to be lower than the security key's default if that is higher.
>
> Suppose the `enforceCredentialProtectionPolicy` value is `true`. In that case, the `create()` call will fail if the policy cannot be adhered to (for example, it requires user verification, but the authenticator does not support user verification). If it is `false`, the system will make the best attempt to create a credential that conforms to the policy, but it will still create one that conforms as closely as it can if this is not possible.
#### Output
If the `create()` call is successful, the authenticator data will contain a representation of the `credProtect` value representing the set policy in the following form:
```js
{ "credProtect": 0x01 }
```
### `largeBlob`
- Usable in: Registration ({{domxref("CredentialsContainer.create()","create()")}}) and authentication ({{domxref("CredentialsContainer.get()","get()")}})
- Processed by: User agent
- Specification: [Large blob storage extension (largeBlob)](https://w3c.github.io/webauthn/#sctn-large-blob-extension)
Allows a relying party to store blobs associated with a credential on the authenticator — for example, it may wish to directly store certificates rather than run a centralized authentication service.
#### Input
During a `create()` call, the `publicKey`'s `extensions` property must contain a `largeBlob` property with the following object structure:
```js
extensions: {
largeBlob: {
support: "required";
}
}
```
The `support` property's value is a string, which can be one of the following:
- `"preferred"`: The credential will be created with an authenticator that can store blobs if possible, but it will still create one if not. The output' supported' property reports the authenticator's ability to store blobs.
- `"required"`: The credential will be created with an authenticator to store blobs. The `create()` call will fail if this is impossible.
During a `get()` call, the `publicKey`'s `extensions` property must contain a `largeBlob` property with one of two sub-properties — `read` or `write` (`get()` fails if both are present):
The `read` property is a boolean. A value of `true` indicates that the relying party would like to fetch a previously-written blob associated with the asserted credential:
```js
extensions: {
largeBlob: {
read: true;
}
}
```
The `write` property takes as a value an {{jsxref("ArrayBuffer")}}, {{jsxref("TypedArray")}}, or {{jsxref("DataView")}} representing a blob that the relying party wants to store alongside an existing credential:
```js
extensions: {
largeBlob: {
write: arrayBuffer;
}
}
```
> **Note:** For a write authentication operation to be successful, `publicKey.allowCredentials` must contain only a single element representing the credential you want the blob stored alongside.
#### Output
A successful `create()` call provides the following extension output if the registered credential is capable of storing blobs:
```js
largeBlob: {
supported: true; // false if it cannot store blobs
}
```
A `get()` read call makes the blob available as an {{jsxref("ArrayBuffer")}} in the extension output if successful:
```js
largeBlob: {
blob: arrayBuffer;
}
```
> **Note:** if unsuccessful, the `largeBlob` object will be returned, but `blob` will not be present.
A `get()` write call indicates whether the write operation was successful with a `written` boolean value in the extension output. A `true` value means it was written successfully to the associated authenticator, and `false` means it was unsuccessful.
```js
largeBlob: {
written: true;
}
```
### `minPinLength`
- Usable in: Registration ({{domxref("CredentialsContainer.create()","create()")}})
- Processed by: Authenticator
- Specification: [Minimum PIN Length Extension (minPinLength)](https://fidoalliance.org/specs/fido-v2.1-ps-20210615/fido-client-to-authenticator-protocol-v2.1-ps-20210615.html#sctn-minpinlength-extension)
Allows relying parties to request the authenticator's minimum PIN length.
#### Input
The `publicKey`'s `extensions` property must contain a `minPinLength` property with a value of `true`:
```js
extensions: {
minPinLength: true;
}
```
#### Output
If the relying party is authorized to receive the `minPinLength` value (if its `rpId` is present on the authenticator's authorized relying party list), the authenticator data will contain a representation of it in the following form:
```js
{"minPinLength": uint}
```
If the relying party is not authorized, the extension is ignored, and no `"minPinLength"` output value is provided.
### `payment`
- Usable in: Registration ({{domxref("CredentialsContainer.create()","create()")}})
- Processed by: User agent
- Specification: [Secure Payment Confirmation](https://w3c.github.io/secure-payment-confirmation/)
Allows a relying party to request the creation of a WebAuthn credential that may be used – by both the Relying Party and other parties – with Secure Payment Confirmation; see [Using Secure Payment Confirmation](/en-US/docs/Web/API/Payment_Request_API/Using_secure_payment_confirmation).
#### Input
The inputs for the `payment` extension are defined in the [AuthenticationExtensionsPaymentInputs dictionary](https://w3c.github.io/secure-payment-confirmation/#dictdef-authenticationextensionspaymentinputs)
- `isPayment`
- : A boolean that indicates that the extension is active.
- `rpID`
- : The [Relying Party](https://w3c.github.io/webauthn/#relying-party) id of the credential(s) being used. Only used at authentication time; not registration.
- `topOrigin`
- : The origin of the top-level frame. Only used at authentication time; not registration.
- `payeeName`
- : The payee name, if present, that was displayed to the user. Only used at authentication time; not registration.
- `payeeOrigin`
- : The payee origin, if present, that was displayed to the user. Only used at authentication time; not registration.
- `total`
- : The transaction amount that was displayed to the user. Only used at authentication time; not registration. The total is of type [PaymentCurrencyAmount](https://w3c.github.io/payment-request/#dom-paymentcurrencyamount).
- `instrument`
- : The instrument details that were displayed to the user. Only used at authentication time; not registration. The instrument is of type [PaymentCredentialInstrument](https://w3c.github.io/secure-payment-confirmation/#dictdef-paymentcredentialinstrument).
#### Output
None
## Specifications
There are a number of places that WebAuthn extensions are specified. IANA's [WebAuthn Extension Identifiers](https://www.iana.org/assignments/webauthn/webauthn.xhtml#webauthn-extension-ids) provides a registry of all extensions, but bear in mind that some may be deprecated.
Places where extensions are specified:
- [Web Authentication Level 3, Section 10: Defined extensions](https://w3c.github.io/webauthn/#sctn-defined-extensions)
- [Client to Authenticator Protocol (CTAP) 2, Section 12: Defined Extensions](https://fidoalliance.org/specs/fido-v2.1-ps-20210615/fido-client-to-authenticator-protocol-v2.1-ps-20210615.html#sctn-defined-extensions)
## Browser compatibility
The compatibility data for WebAuthn extensions has been broken down into two tables — extensions that can be used during credential registration ({{domxref("CredentialsContainer.create()","create()")}}), and extensions that can be used during authentication ({{domxref("CredentialsContainer.get()","get()")}}). Some extensions are usable during both operations.
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/web_authentication_api | data/mdn-content/files/en-us/web/api/web_authentication_api/attestation_and_assertion/index.md | ---
title: Attestation and Assertion
slug: Web/API/Web_Authentication_API/Attestation_and_Assertion
page-type: guide
---
{{DefaultAPISidebar("Web Authentication API")}}
There are two different types of certificates used in WebAuthn for registration and authentication. They have similar names and similar purposes, but understanding the differences may be an initial point of confusion. The sections below describe attestation, which happens during registration, and assertion which happens during authentication.
## Attestation
When an authenticator registers a new key pair with a service, the authenticator signs the public key with an attestation certificate. The attestation certificate is built into the authenticator during manufacturing time and is specific to a device model. That is, all "Samsung Galaxy S8" phones, manufactured at a specific time or particular manufacturing run, have the same attestation certificate.
The attestation is returned through the WebAuthn API as the [AuthenticatorAttestationResponse](/en-US/docs/Web/API/AuthenticatorAttestationResponse). The attestation format contains two basic {{jsxref("ArrayBuffer")}} objects:
- **clientDataJSON** - An ArrayBuffer that contains a JSON representation of what the browser saw when being asked to authenticate.
- [attestationObject](/en-US/docs/Web/API/AuthenticatorAttestationResponse/attestationObject) - Cryptographic attestation that a newly generated keypair was created by that authenticator. This contains:
- [Authenticator data](/en-US/docs/Web/API/Web_Authentication_API/Authenticator_data) containing an `attestedCredentialData` field, which in turn contains the `credentialId` and `credentialPublicKey`. The `attestedCredentialData` is an optional field used in attestation. It is not included when used in the AuthenticatorAssertionResponse.
- An attestation statement, which is optionally present depending on whether the relying party requests attestation. In general, relying parties aren't encouraged to request attestation, so it's more likely that this statement won't be present.
Different devices have different attestation formats. The [pre-defined attestation formats in WebAuthn](https://www.w3.org/TR/webauthn/#defined-attestation-formats) are:
- **Packed** - a generic attestation format that is commonly used by devices whose sole function is as a WebAuthn authenticator, such as security keys.
- **TPM** - the Trusted Platform Module (TPM) is a set of specifications from the Trusted Platform Group (TPG). This attestation format is commonly found in desktop computers and is used by Windows Hello as its preferred attestation format.
- **Android Key Attestation** - one of the features added in Android O was Android Key Attestation, which enables the Android operating system to attest to keys.
- **Android SafetyNet** -prior to Android Key Attestation, the only option for Android devices was to create Android SafetyNet attestations.
- **FIDO U2F** - security keys that implement the FIDO U2F standard use this format.
- **none** - browsers may prompt users whether they want a site to be allowed to see their attestation data and/or may remove attestation data from the authenticator's response if the `attestation` parameter in `navigator.credentials.create()` is set to `none`.
The purpose of attestation is to cryptographically prove that a newly generated key pair came from a specific device. This provides a root of trust for a newly generated key pair as well as being able to identify the attributes of a device being used (how the private key is protected; if / what kind of biometric is being used; whether a device has been certified; etc.). It should be noted that while attestation provides the capability for a root of trust, validating the root of trust is frequently not necessary. When registering an authenticator for a new account, typically a Trust On First Use (TOFU) model applies; and when adding an authenticator to an existing account, a user has already been authenticated and has established a secure session.
## Assertion
When a user chooses to log into a service, the server sends a challenge and the authenticator signs over it with a key pair previously registered to that service. This creates an assertion. Unlike the attestation, the format of the assertion is always the same regardless of the device being used.
The assertion is returned through the WebAuthn API as the [AuthenticatorAssertionResponse](/en-US/docs/Web/API/AuthenticatorAssertionResponse). The assertion format is fairly simple as it contains four basic ArrayBuffers:
- [clientDataJSON](/en-US/docs/Web/API/AuthenticatorResponse/clientDataJSON) - The same as in attestation. An ArrayBuffer that contains a JSON representation of what the browser saw when being asked to authenticate.
- [authenticatorData](/en-US/docs/Web/API/AuthenticatorAssertionResponse/authenticatorData) - data created and/or used by the authenticator (see also [authenticator data](/en-US/docs/Web/API/Web_Authentication_API/Authenticator_data)).
- **signature** - a signature over the clientDataJSON and authenticatorData that can be verified with the public key that was created during registration.
- **userHandle** - Optional. (Nullable) A user identifier. This may be a username, or a hash of a username, etc. Used by a service to give a scope to credentials. Maximum length of 64 bytes. Older authenticators (U2F) do not support this output.
It's important to highlight that the signature for assertion uses a different key pair than attestation. An assertion is signed using the key pair for a service, which was generated during registration. An attestation is signed using the attestation private key and attestation certificate that were burned into all models of the same device. (Except in the case of self-attestation.)
| 0 |
data/mdn-content/files/en-us/web/api/web_authentication_api | data/mdn-content/files/en-us/web/api/web_authentication_api/authenticator_data/index.md | ---
title: Authenticator data
slug: Web/API/Web_Authentication_API/Authenticator_data
page-type: guide
---
{{DefaultAPISidebar("Web Authentication API")}}
The authenticator data structure contains information from the authenticator about the processing of a credential creation or authentication request — such as the Relying Party ID Hash (`rpIdHash`), a signature counter, test of user presence, user verification flags, and any extensions processed by the authenticator. This page explains what is contained in the data structure.
## Accessing authenticator data
Authenticator data is made available to the browser as an {{jsxref("ArrayBuffer")}}, and can be accessed in multiple ways. The two most convenient are:
- In the {{domxref("AuthenticatorAssertionResponse.authenticatorData", "PublicKeyCredential.response.authenticatorData")}} property made available on the {{domxref("PublicKeyCredential")}} returned from a successful {{domxref("CredentialsContainer.create", "navigator.credentials.create()")}} (credential creation) call.
- Via the {{domxref("AuthenticatorAttestationResponse.getAuthenticatorData", "PublicKeyCredential.response.getAuthenticatorData()")}} method made available on the {{domxref("PublicKeyCredential")}} returned from a successful {{domxref("CredentialsContainer.get", "navigator.credentials.get()")}} (authentication) call.
## Data structure
An authenticator data {{jsxref("ArrayBuffer")}} is at least 37 bytes in length, and contains the following fields:
- **rpIdHash** (32 bytes)
- : The SHA-256 hash of the [Relying Party ID](https://w3c.github.io/webauthn/#relying-party-identifier) that the credential is scoped to. The server will ensure that this hash matches the SHA256 hash of its own relying party ID in order to prevent phishing or other man-in-the-middle attacks.
- **flags** (1 bytes)
- : A bitfield that indicates various attributes that were asserted by the authenticator. The bits are as follows, where Bit 0 is the least significant bit and all bits not specifically mentioned below are "reserved for future use":
- Bit 0, User Presence (UP): If set (i.e., to `1`), the authenticator validated that the user was present through some Test of User Presence (TUP), such as touching a button on the authenticator.
- Bit 2, User Verification (UV): If set, the authenticator verified the actual user through a biometric, PIN, or other method.
- Bit 3, Backup Eligibility (BE): If set, the public key credential source used by the authenticator to generate an assertion is backup-eligible. This means that it can be backed up in some fashion (for example via cloud or local network sync) and as such may become present on an authenticator other than its generating authenticator. Backup-eligible credential sources are therefore also known as multi-device credentials.
- Bit 4, Backup State (BS): If set, the public key credential source is currently backed up (see Bit 3 for context).
- Bit 6, Attested Credential Data (AT): If set, the attested credential data will immediately follow the first 37 bytes of this `authenticatorData`.
- Bit 7, Extension Data (ED): If set, extension data is present. Extension data will follow attested credential data if it is present, or will immediately follow the first 37 bytes of the `authenticatorData` if no attested credential data is present.
- **signCount** (4 bytes)
- : A signature counter, if supported by the authenticator (set to 0 otherwise). Servers may optionally use this counter to detect authenticator cloning.
- **attestedCredentialData** (variable length)
- : The credential that was created. This is only present during a {{domxref("CredentialsContainer.create", "navigator.credentials.create()")}} call. This is a sequence of bytes with the following format:
- **AAGUID** (16 bytes): The Authenticator Attestation Globally Unique Identifier, a unique number that identifies the model of the authenticator (not the specific instance of the authenticator). A relying party can use this to find out the characteristics of the authenticator by looking up its metadata statement via the [FIDO metadata service](https://fidoalliance.org/metadata/). This is relevant in certain situations such as enterprise deployments or where regulatory requirements dictate a certain type of authenticator be used; it should be ignored otherwise.
- **_credentialIdLength_** (2 bytes): The length of the credential ID that immediately follows these bytes.
- **_credentialId_** (variable length): A unique identifier for this credential so that it can be requested for future authentications. The credential is "_credentialIdLength_" bytes long.
- **credentialPublicKey** (variable length): A [COSE](https://datatracker.ietf.org/doc/html/rfc8152)-encoded public key. This public key will be stored on the server associated with a user's account and be used for future authentications. Relying parties can retrieve the DER-encoded form of it without parsing the COSE-encoded authenticator data via the {{domxref("AuthenticatorAttestationResponse.getPublicKey()")}} method.
- **extensions** (variable length)
- : An optional [CBOR](https://datatracker.ietf.org/doc/html/rfc7049) map containing the response outputs from extensions processed by the authenticator
Extensions are optional and different browsers may recognize different extensions. Processing extensions is always optional for the browser: if a browser does not recognize a given extension, it will just ignore it. For information on using extensions, and which ones are supported by which browsers, see [Web Authentication extensions](/en-US/docs/Web/API/Web_Authentication_API/WebAuthn_extensions).
> **Note:** The authenticator data only contains the results from extensions processed by the authenticator. The results from extensions processed by the browser (client) can be accessed via {{domxref("PublicKeyCredential.getClientExtensionResults")}}.
## See also
[Authenticator data definition in the WebAuthn specification](https://w3c.github.io/webauthn/#sctn-authenticator-data)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/videoencoder/index.md | ---
title: VideoEncoder
slug: Web/API/VideoEncoder
page-type: web-api-interface
browser-compat: api.VideoEncoder
---
{{APIRef("WebCodecs API")}}{{SecureContext_Header}}
The **`VideoEncoder`** interface of the {{domxref('WebCodecs API', '', '', 1)}} encodes {{domxref("VideoFrame")}} objects into {{domxref("EncodedVideoChunk")}}s.
{{InheritanceDiagram}}
## Constructor
- {{domxref("VideoEncoder.VideoEncoder", "VideoEncoder()")}}
- : Creates a new `VideoEncoder` object.
## Instance properties
_Inherits properties from its parent, {{DOMxRef("EventTarget")}}._
- {{domxref("VideoEncoder.encodeQueueSize")}} {{ReadOnlyInline}}
- : An integer representing the number of encode queue requests.
- {{domxref("VideoEncoder.state")}} {{ReadOnlyInline}}
- : Represents the state of the underlying codec and whether it is configured for encoding.
### Events
- {{domxref("VideoEncoder.dequeue_event", "dequeue")}}
- : Fires to signal a decrease in {{domxref("VideoEncoder.encodeQueueSize")}}.
## Static methods
- {{domxref("VideoEncoder.isConfigSupported_static", "VideoEncoder.isConfigSupported()")}}
- : Returns a promise indicating whether the provided `VideoEncoderConfig` is supported.
## Instance methods
_Inherits methods from its parent, {{DOMxRef("EventTarget")}}._
- {{domxref("VideoEncoder.configure()")}}
- : Asynchronously prepares the encoder to accept video frames for encoding with the specified parameters.
- {{domxref("VideoEncoder.encode()")}}
- : Asynchronously encodes a {{domxref("VideoFrame")}}.
- {{domxref("VideoEncoder.flush()")}}
- : Returns a promise that resolves once all pending encodes have been completed.
- {{domxref("VideoEncoder.reset()")}}
- : Cancels all pending encodes and callbacks.
- {{domxref("VideoEncoder.close()")}}
- : Ends all pending work and releases system resources.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
[Video processing with WebCodecs](https://developer.chrome.com/docs/web-platform/best-practices/webcodecs)
| 0 |
data/mdn-content/files/en-us/web/api/videoencoder | data/mdn-content/files/en-us/web/api/videoencoder/configure/index.md | ---
title: "VideoEncoder: configure() method"
short-title: configure()
slug: Web/API/VideoEncoder/configure
page-type: web-api-instance-method
browser-compat: api.VideoEncoder.configure
---
{{APIRef("WebCodecs API")}}{{SecureContext_Header}}
The **`configure()`** method of the {{domxref("VideoEncoder")}} interface changes the {{domxref("VideoEncoder.state", "state")}} of the encoder to "configured" and asynchronously prepares the encoder to accept {{domxref("VideoEncoder")}}s for encoding with the specified parameters. If the encoder doesn't support the specified parameters or can't be initialized for other reasons an error will be reported via the error callback provided to the {{domxref("VideoEncoder")}} constructor.
If the {{domxref("VideoEncoder")}} has been previously configured, the new configuration will not be applied until all previous tasks have completed.
## Syntax
```js-nolint
configure(config)
```
### Parameters
- `config`
- : A dictionary object containing the following members:
- `codec`
- : A string containing a [valid codec string](https://www.w3.org/TR/webcodecs-codec-registry/#audio-codec-registry). See ["codecs" parameter](/en-US/docs/Web/Media/Formats/codecs_parameter#codec_options_by_container) for details on codec string construction.
- `width` {{optional_inline}}
- : An integer representing the width of each output {{domxref("EncodedVideoChunk")}} in pixels, before any ratio adjustments.
- `height` {{optional_inline}}
- : An integer representing the height of each output {{domxref("EncodedVideoChunk")}} in pixels, before any ratio adjustments.
- `displayWidth` {{optional_inline}}
- : An integer representing the intended display width of each output {{domxref("EncodedVideoChunk")}} in pixels when displayed.
- `displayHeight` {{optional_inline}}
- : An integer representing the vertical dimension of each output {{domxref("EncodedVideoChunk")}} in pixels when displayed.
- `hardwareAcceleration`
- : A hint that configures the hardware acceleration method of this codec. One of:
- `"no-preference"`
- `"prefer-hardware"`
- `"prefer-software"`
- `bitrate`
- : An integer containing the average bitrate of the encoded video in units of bits per second.
- `framerate`
- : An integer containing the expected frame rate in frames per second.
- `alpha`
- : A string indicating whether the alpha component of the `VideoFrame` inputs should be kept or discarded prior to encoding. One of:
- `"discard"` (default)
- `"keep"`
- `scalabilityMode`
- : A string containing an encoding scalability mode identifier as defined in [WebRTC](https://w3c.github.io/webrtc-svc/#scalabilitymodes*).
- `bitrateMode` {{optional_inline}}
- : A string containing a bitrate mode. One of:
- `"constant"`
- : The encoder will target constant bitrate.
- `"variable"` (default)
- : The encoder will target a variable bitrate, allowing more space to be used for complex signals and less space for less complex signals.
- `"quantizer"`
- : The encoder will disregard the `bitrate` option and instead it will use codec-specific quantizer values specified for each frame in the `options` parameter to {{domxref("VideoEncoder.encode()")}}.
- `latencyMode` {{optional_inline}}
- : A string containing a value that configures the latency behavior of this codec. One of:
- `"quality"` (default)
- : The encoder should optimize for encoding quality.
- `"realtime"`
- : The encoder should optimize for low latency and may even drop frames to honor `framerate`.
### Return value
None ({{jsxref("undefined")}}).
### Exceptions
- {{jsxref("TypeError")}}
- : Thrown if the provided `config` is invalid.
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the {{domxref("VideoEncoder.state","state")}} is `"closed"`.
- `NotSupportedError` {{domxref("DOMException")}}
- : Thrown if the provided `config` is valid but the user agent cannot provide a codec that can decode this profile.
## Examples
The following example creates a new {{domxref("VideoEncoder")}} and configures it with some of the available options.
```js
const init = {
output: handleChunk,
error: (e) => {
console.log(e.message);
},
};
let config = {
codec: "vp8",
width: 640,
height: 480,
bitrate: 2_000_000, // 2 Mbps
framerate: 30,
};
let encoder = new VideoEncoder(init);
encoder.configure(config);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/videoencoder | data/mdn-content/files/en-us/web/api/videoencoder/dequeue_event/index.md | ---
title: "VideoEncoder: dequeue event"
short-title: dequeue
slug: Web/API/VideoEncoder/dequeue_event
page-type: web-api-event
browser-compat: api.VideoEncoder.dequeue_event
---
{{securecontext_header}}{{APIRef("WebCodecs API")}}
The **`dequeue`** event of the {{domxref("VideoEncoder")}} interface fires to signal a decrease in {{domxref("VideoEncoder.encodeQueueSize")}}.
This eliminates the need for developers to use a {{domxref("setTimeout()")}} poll to determine when the queue has decreased, and more work should be queued up.
## Syntax
Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property.
```js
addEventListener("dequeue", (event) => {});
ondequeue = (event) => {};
```
## Example
```js
videoEncoder.addEventListener("dequeue", (event) => {
// Queue up more encoding work
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/videoencoder | data/mdn-content/files/en-us/web/api/videoencoder/encodequeuesize/index.md | ---
title: "VideoEncoder: encodeQueueSize property"
short-title: encodeQueueSize
slug: Web/API/VideoEncoder/encodeQueueSize
page-type: web-api-instance-property
browser-compat: api.VideoEncoder.encodeQueueSize
---
{{APIRef("WebCodecs API")}}{{SecureContext_Header}}
The **`encodeQueueSize`** read-only property of the {{domxref("VideoEncoder")}} interface returns the number of pending encode requests in the queue.
## Value
An integer containing the number of requests.
## Examples
The following example prints the size of the queue to the console.
```js
console.log(VideoEncoder.encodeQueueSize);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/videoencoder | data/mdn-content/files/en-us/web/api/videoencoder/videoencoder/index.md | ---
title: "VideoEncoder: VideoEncoder() constructor"
short-title: VideoEncoder()
slug: Web/API/VideoEncoder/VideoEncoder
page-type: web-api-constructor
browser-compat: api.VideoEncoder.VideoEncoder
---
{{APIRef("WebCodecs API")}}{{SecureContext_Header}}
The **`VideoEncoder()`** constructor creates a new {{domxref("VideoEncoder")}} object with the provided `options.output` callback assigned as the output callback, the provided `options.error` callback as the error callback, and sets the {{domxref("VideoEncoder.state")}} to `"unconfigured"`.
## Syntax
```js-nolint
new VideoEncoder(options)
```
### Parameters
- `options`
- : An object containing two required callbacks.
- `output`
- : A callback which takes an {{domxref("EncodedVideoChunk")}} object as the first argument, and an optional metadata object as the second. The metadata object has three members:
- `decoderConfig` {{Optional_Inline}}
- : An object containing:
- `codec`
- : A string containing a [valid codec string](https://www.w3.org/TR/webcodecs-codec-registry/#video-codec-registry).
- `description` {{Optional_Inline}}
- : An {{jsxref("ArrayBuffer")}}, a {{jsxref("TypedArray")}}, or a {{jsxref("DataView")}} containing a sequence of codec-specific bytes, commonly known as "extradata".
- `codedWidth` {{Optional_Inline}}
- : An integer representing the width of the {{domxref("VideoFrame")}} in pixels, potentially including non-visible padding, and prior to considering potential ratio adjustments.
- `codedHeight` {{Optional_Inline}}
- : An integer representing the height of the {{domxref("VideoFrame")}} in pixels, potentially including non-visible padding, and prior to considering potential ratio adjustments.
- `displayAspectWidth` {{Optional_Inline}}
- : An integer representing the horizontal dimension of the {{domxref("VideoFrame")}}'s aspect ratio when displayed.
- `displayAspectHeight` {{Optional_Inline}}
- : An integer representing the vertical dimension of the {{domxref("VideoFrame")}}'s aspect ratio when displayed.
- `colorSpace` {{Optional_Inline}}
- : An object you pass to the {{domxref("VideoColorSpace")}} constructor as the `init` argument, configuring the {{domxref("VideoFrame.colorSpace")}} for {{domxref("VideoFrame","VideoFrames")}} associated with this `decoderConfig` object. If `colorSpace` exists, the provided values will override any in-band values from the bitstream.
- `hardwareAcceleration` {{Optional_Inline}}
- : A string that configures hardware acceleration for this codec. Defaults to `"no-preference"`. Options are:
- `"no-preference"`
- `"prefer-hardware"`
- `"prefer-software"`
- `optimizeForLatency` {{Optional_Inline}}
- : A boolean representing whether the selected decoder should be configured to minimize the number of {{domxref("EncodedVideoChunk","EncodedVideoChunks")}} that have to be decoded before a {{domxref("VideoFrame")}} is output.
- `svc` {{Optional_Inline}}
- : An optional object with only one member: `temporalLayerId`, which is a number that identifies the [temporal layer](https://w3c.github.io/webcodecs/#temporal-layer) for the associated {{domxref("EncodedVideoChunk")}}.
- `alphaSideData` {{Optional_Inline}}
- : An {{jsxref("ArrayBuffer")}}, a {{jsxref("TypedArray")}}, or a {{jsxref("DataView")}}
that contains the {{domxref("EncodedVideoChunk")}}'s extra alpha channel data.
- `error`
- : A callback which takes an {{jsxref("Error")}} object as its only argument.
## Examples
In the following example a `VideoEncoder` is created with the two required callback functions, one to deal with the encoded frame and the other to handle errors.
```js
const videoEncoder = new VideoEncoder({
output(chunk, metadata) {
console.log(chunk.timestamp);
console.log(chunk.byteLength);
console.log(JSON.stringify(metadata));
},
error(error) {
console.log(error);
},
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/videoencoder | data/mdn-content/files/en-us/web/api/videoencoder/flush/index.md | ---
title: "VideoEncoder: flush() method"
short-title: flush()
slug: Web/API/VideoEncoder/flush
page-type: web-api-instance-method
browser-compat: api.VideoEncoder.flush
---
{{APIRef("WebCodecs API")}}{{SecureContext_Header}}
The **`flush()`** method of the {{domxref("VideoEncoder")}} interface forces all pending encodes to complete.
## Syntax
```js-nolint
flush()
```
### Parameters
None.
### Return value
A {{jsxref("Promise")}} that resolves once the encoder's initialization is completed and all pending {{domxref("EncodedVideoChunk")}}s are returned.
### Exceptions
- `InvalidStateError` {{domxref("DOMException")}}
- : Returned if the Promise is rejected because the {{domxref("VideoEncoder.state","state")}} is not `configured`.
## Examples
The following example flushes the `VideoEncoder`.
```js
VideoEncoder.flush();
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/videoencoder | data/mdn-content/files/en-us/web/api/videoencoder/isconfigsupported_static/index.md | ---
title: "VideoEncoder: isConfigSupported() static method"
short-title: isConfigSupported()
slug: Web/API/VideoEncoder/isConfigSupported_static
page-type: web-api-static-method
browser-compat: api.VideoEncoder.isConfigSupported_static
---
{{APIRef("WebCodecs API")}}{{SecureContext_Header}}
The **`isConfigSupported()`** static method of the {{domxref("VideoEncoder")}} interface checks if {{domxref("VideoEncoder")}} can be successfully configured with the given config.
## Syntax
```js-nolint
VideoEncoder.isConfigSupported(config)
```
### Parameters
- `config`
- : The dictionary object accepted by {{domxref("VideoEncoder.configure")}}
### Return value
A {{jsxref("Promise")}} that resolves with an object containing the following members:
- `supported`
- : A boolean value which is `true` if the given config is supported by the encoder.
- `config`
- : A copy of the given config with all the fields recognized by the encoder.
### Exceptions
- {{jsxref("TypeError")}}
- : Thrown if the provided `config` is invalid; that is, if doesn't have required values (such as an empty `codec` field) or has invalid values (such as a negative `width`)
## Examples
The following example tests if the browser supports accelerated and un-accelerated
versions of several video codecs.
```js
const codecs = ["avc1.42001E", "vp8", "vp09.00.10.08", "av01.0.04M.08"];
const accelerations = ["prefer-hardware", "prefer-software"];
const configs = [];
for (const codec of codecs) {
for (const acceleration of accelerations) {
configs.push({
codec,
hardwareAcceleration: acceleration,
width: 1280,
height: 720,
bitrate: 2_000_000,
bitrateMode: "constant",
framerate: 30,
not_supported_field: 123,
});
}
}
for (const config of configs) {
const support = await VideoEncoder.isConfigSupported(config);
console.log(
`VideoEncoder's config ${JSON.stringify(support.config)} support: ${
support.supported
}`,
);
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/videoencoder | data/mdn-content/files/en-us/web/api/videoencoder/state/index.md | ---
title: "VideoEncoder: state property"
short-title: state
slug: Web/API/VideoEncoder/state
page-type: web-api-instance-property
browser-compat: api.VideoEncoder.state
---
{{APIRef("WebCodecs API")}}{{SecureContext_Header}}
The **`state`** read-only property of the {{domxref("VideoEncoder")}} interface returns the current state of the underlying codec.
## Value
A string containing one of the following values:
- `"unconfigured"`
- : The codec is not configured for decoding.
- `"configured"`
- : The codec has a valid configuration and is ready.
- `"closed"`
- : The codec is no longer usable and system resources have been released.
## Examples
The following example prints the state of the `VideoEncoder` to the console.
```js
console.log(VideoEncoder.state);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/videoencoder | data/mdn-content/files/en-us/web/api/videoencoder/reset/index.md | ---
title: "VideoEncoder: reset() method"
short-title: reset()
slug: Web/API/VideoEncoder/reset
page-type: web-api-instance-method
browser-compat: api.VideoEncoder.reset
---
{{APIRef("WebCodecs API")}}{{SecureContext_Header}}
The **`reset()`** method of the {{domxref("VideoEncoder")}} interface synchronously cancels all pending encodes and callbacks, frees all underlying resources and sets the {{domxref("VideoEncoder.state", "state")}} to "unconfigured".
After calling {{domxref("VideoEncoder.reset()", "reset()")}}, {{domxref("VideoEncoder.configure()", "configure()")}} must be called before resuming {{domxref("VideoEncoder.encode()", "encode()")}} calls.
> **Note:** To avoid discarding frames queued via {{domxref("VideoEncoder.encode()", "encode()")}}, {{domxref("VideoEncoder.flush()", "flush()")}} should be called and completed before calling {{domxref("VideoEncoder.reset()", "reset()")}}.
## Syntax
```js-nolint
reset()
```
### Parameters
None.
### Return value
None ({{jsxref("undefined")}}).
### Exceptions
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the {{domxref("VideoEncoder.state","state")}} is `"closed"`.
## Examples
The following example resets the `VideoEncoder`.
```js
VideoEncoder.reset();
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/videoencoder | data/mdn-content/files/en-us/web/api/videoencoder/encode/index.md | ---
title: "VideoEncoder: encode() method"
short-title: encode()
slug: Web/API/VideoEncoder/encode
page-type: web-api-instance-method
browser-compat: api.VideoEncoder.encode
---
{{APIRef("WebCodecs API")}}{{SecureContext_Header}}
The **`encode()`** method of the {{domxref("VideoEncoder")}} interface asynchronously encodes a {{domxref("VideoFrame")}}.
Encoded data ({{domxref("EncodedVideoChunk")}}) or an error will eventually be returned via the callbacks provided to the {{domxref("VideoEncoder")}} constructor.
## Syntax
```js-nolint
encode(frame)
encode(frame, options)
```
### Parameters
- `frame`
- : A {{domxref("VideoFrame")}} object.
- `options` {{optional_inline}}
- : An object containing the following members:
- `keyFrame` {{optional_inline}}
- : A {{jsxref("boolean")}}, defaulting to `false` giving the user agent flexibility to decide if this frame should be encoded as a key frame. If `true` this indicates that the given frame must be encoded as a key frame.
- `vp9` {{optional_inline}}
- : Encode options for the [VP9](/en-US/docs/Web/Media/Formats/Video_codecs#vp9) codec.
- `quantizer`
- : Frame quantizer value 0 to 63. Only effective if {{domxref("VideoEncoder")}} was configured with `quantizer` bitrate mode.
- `av1` {{optional_inline}}
- : Encode options for the [AV1](/en-US/docs/Web/Media/Formats/Video_codecs#av1) codec.
- `quantizer`
- : Frame quantizer value 0 to 63. Only effective if {{domxref("VideoEncoder")}} was configured with `quantizer` bitrate mode.
- `avc` {{optional_inline}}
- : Encode options for the [AVC (H.264)](/en-US/docs/Web/Media/Formats/Video_codecs#avc_h.264) codec.
- `quantizer`
- : Frame quantizer value 0 to 51. Only effective if {{domxref("VideoEncoder")}} was configured with `quantizer` bitrate mode.
### Return value
None ({{jsxref("undefined")}}).
### Exceptions
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the {{domxref("VideoEncoder.state","state")}} is not `"configured"`.
- `DataError` {{domxref("DOMException")}}
- : Thrown if the `chunk` cannot be decoded due to relying on other frames for decoding.
## Examples
In the following example `encode` is passed a `VideoFrame`, and the options parameter indicating that this frame should be considered a keyframe.
```js
encoder.encode(frame, { keyFrame: true });
```
Setting per-frame QP value for encoding individual frames.
```js
const encoder = new VideoEncoder(init);
const encoderConfig = {
codec: "vp09.00.10.08",
width: 800,
height: 600,
bitrateMode: "quantizer",
framerate: 30,
latencyMode: "realtime",
};
encoder.configure(encoderConfig);
const encodeOptions = { keyFrame: false };
const qp = calculateQp(codec, frame);
if (codec.includes("vp09")) {
encodeOptions.vp9 = { quantizer: qp };
} else if (codec.includes("av01")) {
encodeOptions.av1 = { quantizer: qp };
} else if (codec.includes("avc")) {
encodeOptions.avc = { quantizer: qp };
}
encoder.encode(frame, encodeOptions);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/videoencoder | data/mdn-content/files/en-us/web/api/videoencoder/close/index.md | ---
title: "VideoEncoder: close() method"
short-title: close()
slug: Web/API/VideoEncoder/close
page-type: web-api-instance-method
browser-compat: api.VideoEncoder.close
---
{{APIRef("WebCodecs API")}}{{SecureContext_Header}}
The **`close()`** method of the {{domxref("VideoEncoder")}} interface ends all pending work and releases system resources.
## Syntax
```js-nolint
close()
```
### Parameters
None.
### Return value
None ({{jsxref("undefined")}}).
## Examples
The following example closes the `VideoEncoder`.
```js
VideoEncoder.close();
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/cssimagevalue/index.md | ---
title: CSSImageValue
slug: Web/API/CSSImageValue
page-type: web-api-interface
browser-compat: api.CSSImageValue
---
{{APIRef("CSS Typed Object Model API")}}
The **`CSSImageValue`** interface of the [CSS Typed Object Model API](/en-US/docs/Web/API/CSS_Object_Model#css_typed_object_model) represents values for properties that take an image, for example {{cssxref('background-image')}}, {{cssxref('list-style-image')}}, or {{cssxref('border-image-source')}}.
The CSSImageValue object represents an [`<image>`](/en-US/docs/Web/CSS/image) that involves a URL, such as [`url()`](/en-US/docs/Web/CSS/url) or [`image()`](/en-US/docs/Web/CSS/image), but not [`linear-gradient()`](/en-US/docs/Web/CSS/gradient/linear-gradient) or [`element()`](/en-US/docs/Web/CSS/element).
{{InheritanceDiagram}}
## Instance properties
None.
## Instance methods
_Inherits methods from {{domxref('CSSStyleValue')}}._
## Examples
We create an element
```html
<button>Magic Wand</button>
```
We add some CSS, including a background image requesting a binary file:
```css
button {
display: inline-block;
min-height: 100px;
min-width: 100px;
background: no-repeat 5% center url(magicwand.png) aqua;
}
```
We get the element's style map. We then get() the background-image from the stylemap and stringify it:
```js
// get the element
const button = document.querySelector("button");
// Retrieve all computed styles with computedStyleMap()
const allComputedStyles = button.computedStyleMap();
// Return the CSSImageValue Example
console.log(allComputedStyles.get("background-image"));
console.log(allComputedStyles.get("background-image").toString());
```
{{EmbedLiveSample("Examples", 120, 300)}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref('CSSKeywordValue')}}
- {{domxref('CSSNumericValue')}}
- {{domxref('CSSPositionValue')}}
- {{domxref('CSSTransformValue')}}
- {{domxref('CSSUnparsedValue')}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/mediaelementaudiosourcenode/index.md | ---
title: MediaElementAudioSourceNode
slug: Web/API/MediaElementAudioSourceNode
page-type: web-api-interface
browser-compat: api.MediaElementAudioSourceNode
---
{{APIRef("Web Audio API")}}
The `MediaElementAudioSourceNode` interface represents an audio source consisting of an HTML {{ htmlelement("audio") }} or {{ htmlelement("video") }} element. It is an {{domxref("AudioNode")}} that acts as an audio source.
A `MediaElementAudioSourceNode` has no inputs and exactly one output, and is created using the {{domxref("AudioContext.createMediaElementSource()")}} method. The number of channels in the output equals the number of channels of the audio referenced by the {{domxref("HTMLMediaElement")}} used in the creation of the node, or is 1 if the {{domxref("HTMLMediaElement")}} has no audio.
{{InheritanceDiagram}}
<table class="properties">
<tbody>
<tr>
<th scope="row">Number of inputs</th>
<td><code>0</code></td>
</tr>
<tr>
<th scope="row">Number of outputs</th>
<td><code>1</code></td>
</tr>
<tr>
<th scope="row">Channel count</th>
<td>
2 (but note that {{domxref("AudioNode.channelCount")}} is only used for up-mixing and down-mixing {{domxref("AudioNode")}} inputs, and {{domxref("MediaElementAudioSourceNode")}} doesn't have any input)
</td>
</tr>
</tbody>
</table>
## Constructor
- {{domxref("MediaElementAudioSourceNode.MediaElementAudioSourceNode", "MediaElementAudioSourceNode()")}}
- : Creates a new `MediaElementAudioSourceNode` object instance.
## Instance properties
_Inherits properties from its parent, {{domxref("AudioNode")}}_.
- {{domxref("MediaElementAudioSourceNode.mediaElement", "mediaElement")}} {{ReadOnlyInline}}
- : The {{domxref("HTMLMediaElement")}} used when constructing this `MediaStreamAudioSourceNode`.
## Instance methods
_Inherits methods from its parent, {{domxref("AudioNode")}}_.
## Example
See [`AudioContext.createMediaElementSource()`](/en-US/docs/Web/API/AudioContext/createMediaElementSource#examples) for example code.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using the Web Audio API](/en-US/docs/Web/API/Web_Audio_API/Using_Web_Audio_API)
| 0 |
data/mdn-content/files/en-us/web/api/mediaelementaudiosourcenode | data/mdn-content/files/en-us/web/api/mediaelementaudiosourcenode/mediaelementaudiosourcenode/index.md | ---
title: "MediaElementAudioSourceNode: MediaElementAudioSourceNode() constructor"
short-title: MediaElementAudioSourceNode()
slug: Web/API/MediaElementAudioSourceNode/MediaElementAudioSourceNode
page-type: web-api-constructor
browser-compat: api.MediaElementAudioSourceNode.MediaElementAudioSourceNode
---
{{APIRef("Web Audio API")}}
The **`MediaElementAudioSourceNode()`** constructor creates a new {{domxref("MediaElementAudioSourceNode")}} object instance.
## Syntax
```js-nolint
new MediaElementAudioSourceNode(context, options)
```
### Parameters
- `context`
- : An {{domxref("AudioContext")}} representing the audio context you want the node to be associated with.
- `options`
- : An object defining the properties you want the `MediaElementAudioSourceNode` to have:
- `mediaElement`
- : An {{domxref("HTMLMediaElement")}} that will be used as the source for the audio.
- `channelCount`
- : An integer used to determine how many channels are used when [up-mixing and down-mixing](/en-US/docs/Web/API/Web_Audio_API/Basic_concepts_behind_Web_Audio_API#up-mixing_and_down-mixing) connections to any inputs to the node. (See
{{domxref("AudioNode.channelCount")}} for more information.) Its usage and precise
definition depend on the value of `channelCountMode`.
- `channelCountMode`
- : A string describing the way channels must be matched between
the node's inputs and outputs. (See {{domxref("AudioNode.channelCountMode")}} for more
information including default values.)
- `channelInterpretation`
- : A string describing the meaning of the channels. This
interpretation will define how audio [up-mixing and down-mixing](/en-US/docs/Web/API/Web_Audio_API/Basic_concepts_behind_Web_Audio_API#up-mixing_and_down-mixing) will happen.
The possible values are `"speakers"` or `"discrete"`. (See
{{domxref("AudioNode.channelInterpretation")}} for more information including default
values.)
### Return value
A new {{domxref("MediaElementAudioSourceNode")}} object instance.
## Examples
```js
const ac = new AudioContext();
const mediaElement = document.createElement("audio");
const myAudioSource = new MediaElementAudioSourceNode(ac, {
mediaElement,
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/mediaelementaudiosourcenode | data/mdn-content/files/en-us/web/api/mediaelementaudiosourcenode/mediaelement/index.md | ---
title: "MediaElementAudioSourceNode: mediaElement property"
short-title: mediaElement
slug: Web/API/MediaElementAudioSourceNode/mediaElement
page-type: web-api-instance-property
browser-compat: api.MediaElementAudioSourceNode.mediaElement
---
{{APIRef("Web Audio API")}}
The {{domxref("MediaElementAudioSourceNode")}} interface's
read-only **`mediaElement`** property indicates the
{{domxref("HTMLMediaElement")}} that contains the audio track from which the node is
receiving audio.
This stream was specified when the node was first created,
either using the {{domxref("MediaElementAudioSourceNode.MediaElementAudioSourceNode",
"MediaElementAudioSourceNode()")}} constructor or the
{{domxref("AudioContext.createMediaElementSource()")}} method.
## Value
An {{domxref("HTMLMediaElement")}} representing the element which contains the source
of audio for the node.
## Examples
```js
const audioCtx = new window.AudioContext();
const audioElem = document.querySelector("audio");
let options = {
mediaElement: audioElem,
};
let source = new MediaElementAudioSourceNode(audioCtx, options);
console.log(source.mediaElement);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/device_memory_api/index.md | ---
title: Device Memory API
slug: Web/API/Device_Memory_API
page-type: web-api-overview
browser-compat:
- api.Navigator.deviceMemory
- api.WorkerNavigator.deviceMemory
- http.headers.Device-Memory
spec-urls: https://www.w3.org/TR/device-memory/
---
{{DefaultAPISidebar("Device Memory API")}}{{securecontext_header}}{{AvailableInWorkers}}
The capabilities of a client device largely depend on the amount of available RAM. Traditionally, developers had to use heuristics and either benchmark a device or infer device capabilities based on other factors like the device manufacturer or User Agent strings.
## Determining device memory
There are two ways to determine the approximate amount of RAM a device has: use the Device Memory JavaScript API or accept Client Hints.
### JavaScript API
You may query the approximate amount of RAM a device has by retrieving {{DOMxRef("Navigator.deviceMemory")}} or {{DOMxRef("WorkerNavigator.deviceMemory")}}.
```js
const RAM = navigator.deviceMemory;
```
### Client Hints
You may also use the [Client Hints](/en-US/docs/Web/HTTP/Client_hints) HTTP Header with the `Device-Memory` directive to retrieve the same approximate RAM capacity.
## Interfaces
### Extensions to other interfaces
- {{domxref("Navigator.deviceMemory")}} {{ReadOnlyInline}}
- : Returns the approximate amount of device memory in gigabytes.
- {{domxref("WorkerNavigator.deviceMemory")}} {{ReadOnlyInline}}
- : Returns the approximate amount of device memory in gigabytes.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{HTTPHeader("Device-Memory")}} header
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/domrect/index.md | ---
title: DOMRect
slug: Web/API/DOMRect
page-type: web-api-interface
browser-compat: api.DOMRect
---
{{APIRef("Geometry Interfaces")}}
A **`DOMRect`** describes the size and position of a rectangle.
The type of box represented by the `DOMRect` is specified by the method or property that returned it. For example, {{domxref("Range.getBoundingClientRect()")}} specifies the rectangle that bounds the content of the range using such objects.
It inherits from its parent, {{domxref("DOMRectReadOnly")}}.
{{InheritanceDiagram}}
## Constructor
- {{domxref("DOMRect.DOMRect","DOMRect()")}}
- : Creates a new `DOMRect` object.
## Instance properties
_`DOMRect` inherits properties from its parent, {{domxref("DOMRectReadOnly")}}. The difference is that they are not read-only anymore._
- {{domxref("DOMRectReadOnly.x")}}
- : The x coordinate of the `DOMRect`'s origin (typically the top-left corner of the rectangle).
- {{domxref("DOMRectReadOnly.y")}}
- : The y coordinate of the `DOMRect`'s origin (typically the top-left corner of the rectangle).
- {{domxref("DOMRectReadOnly.width")}}
- : The width of the `DOMRect`.
- {{domxref("DOMRectReadOnly.height")}}
- : The height of the `DOMRect`.
- {{domxref("DOMRectReadOnly.top")}}
- : Returns the top coordinate value of the `DOMRect` (has the same value as `y`, or `y + height` if `height` is negative).
- {{domxref("DOMRectReadOnly.right")}}
- : Returns the right coordinate value of the `DOMRect` (has the same value as `x + width`, or `x` if `width` is negative).
- {{domxref("DOMRectReadOnly.bottom")}}
- : Returns the bottom coordinate value of the `DOMRect` (has the same value as `y + height`, or `y` if `height` is negative).
- {{domxref("DOMRectReadOnly.left")}}
- : Returns the left coordinate value of the `DOMRect` (has the same value as `x`, or `x + width` if `width` is negative).
## Static methods
_`DOMRect` may also inherit static methods from its parent, {{domxref("DOMRectReadOnly")}}._
- {{domxref("DOMRect/fromRect_static", "DOMRect.fromRect()")}}
- : Creates a new `DOMRect` object with a given location and dimensions.
## Instance methods
_`DOMRect` may inherit methods from its parent, {{domxref("DOMRectReadOnly")}}._
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("DOMPoint")}}
| 0 |
data/mdn-content/files/en-us/web/api/domrect | data/mdn-content/files/en-us/web/api/domrect/domrect/index.md | ---
title: "DOMRect: DOMRect() constructor"
short-title: DOMRect()
slug: Web/API/DOMRect/DOMRect
page-type: web-api-constructor
browser-compat: api.DOMRect.DOMRect
---
{{APIRef("Geometry Interfaces")}}
The **`DOMRect()`** constructor creates a new {{domxref("DOMRect")}} object.
## Syntax
```js-nolint
new DOMRect(x, y, width, height)
```
### Parameters
- `x`
- : The `x` coordinate of the `DOMRect`'s origin.
- `y`
- : The `y` coordinate of the `DOMRect`'s origin.
- `width`
- : The width of the `DOMRect`.
- `height`
- : The height of the `DOMRect`.
### Return value
A new {{domxref("DOMRect")}} object.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("DOMPoint")}}
- {{domxref("DOMRect")}}
- {{domxref("DOMRect.fromRect_static", "DOMRect.fromRect()")}}
| 0 |
data/mdn-content/files/en-us/web/api/domrect | data/mdn-content/files/en-us/web/api/domrect/fromrect_static/index.md | ---
title: "DOMRect: fromRect() static method"
short-title: fromRect()
slug: Web/API/DOMRect/fromRect_static
page-type: web-api-static-method
browser-compat: api.DOMRect.fromRect_static
---
{{APIRef("Geometry Interfaces")}}
The **`fromRect()`** static method of the
{{domxref("DOMRect")}} object creates a new `DOMRect`
object with a given location and dimensions.
## Syntax
```js-nolint
DOMRect.fromRect()
DOMRect.fromRect(rectangle)
```
### Parameters
- `rectangle` {{optional_inline}}
- : An object specifying the location and dimensions of a rectangle. All properties
default to `0`. The properties are:
- `x`: The coordinate of the left side of the rectangle.
- `y`: The coordinate of the top side of the rectangle.
- `width`: The width of the rectangle.
- `height`: The height of the rectangle.
### Return value
An instance of {{domxref("DOMRect")}}.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/cssnamespacerule/index.md | ---
title: CSSNamespaceRule
slug: Web/API/CSSNamespaceRule
page-type: web-api-interface
browser-compat: api.CSSNamespaceRule
---
{{APIRef("CSSOM")}}
The **`CSSNamespaceRule`** interface describes an object representing a single CSS {{ cssxref("@namespace") }} [at-rule](/en-US/docs/Web/CSS/At-rule).
{{InheritanceDiagram}}
## Instance properties
_Inherits properties from its ancestor {{domxref("CSSRule")}}._
- {{domxref("CSSNamespaceRule.namespaceURI")}}
- : Returns a string containing the text of the URI of the given namespace.
- {{domxref("CSSNamespaceRule.prefix")}}
- : Returns a string with the name of the prefix associated to this namespace. If there is no such prefix, returns an empty string.
## Instance methods
_Inherits methods from its ancestor {{domxref("CSSRule")}}._
## Examples
The stylesheet includes a namespace as the only rule. Therefore the first {{domxref("CSSRule")}} returned will be a `CSSNamespaceRule`.
```css
@namespace url(http://www.w3.org/1999/xhtml);
```
```js
let myRules = document.styleSheets[0].cssRules;
console.log(myRules[0]); //a CSSNamespaceRule
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/cssnamespacerule | data/mdn-content/files/en-us/web/api/cssnamespacerule/namespaceuri/index.md | ---
title: "CSSNamespaceRule: namespaceURI property"
short-title: namespaceURI
slug: Web/API/CSSNamespaceRule/namespaceURI
page-type: web-api-instance-property
browser-compat: api.CSSNamespaceRule.namespaceURI
---
{{ APIRef("CSSOM") }}
The read-only **`namespaceURI`** property of the {{domxref("CSSNamespaceRule")}} returns a string containing the text of the URI of the given namespace.
## Value
A string containing a URI.
## Examples
The stylesheet includes a namespace as the only rule. Therefore the first {{domxref("CSSRule")}} returned will be a `CSSNamespaceRule`. The value of the `namespaceURI` property will be `http://www.w3.org/1999/xhtml`.
```css
@namespace url(http://www.w3.org/1999/xhtml);
```
```js
let myRules = document.styleSheets[0].cssRules;
console.log(myRules[0].namespaceURI); //http://www.w3.org/1999/xhtml
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/cssnamespacerule | data/mdn-content/files/en-us/web/api/cssnamespacerule/prefix/index.md | ---
title: "CSSNamespaceRule: prefix property"
short-title: prefix
slug: Web/API/CSSNamespaceRule/prefix
page-type: web-api-instance-property
browser-compat: api.CSSNamespaceRule.prefix
---
{{ APIRef("CSSOM") }}
The read-only **`prefix`** property of the {{domxref("CSSNamespaceRule")}} returns a string with the name of the prefix associated to this namespace. If there is no such prefix, it returns an empty string.
## Value
A string containing the prefix associated to this namespace. If there is no prefix an empty string.
## Examples
The stylesheet includes two namespace rules. The first has no prefix the second the prefix `svg`. Two `CSSNamespaceRule` objects will be returned. The value of the `prefix` property for the first will be an empty string, for the second `svg`.
```css
@namespace url(http://www.w3.org/1999/xhtml);
@namespace svg url(http://www.w3.org/2000/svg);
```
```js
let myRules = document.styleSheets[0].cssRules;
console.log(myRules[0].namespaceURI); // an empty string ""
console.log(myRules[1].namespaceURI); // "svg"
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/cssmathmin/index.md | ---
title: CSSMathMin
slug: Web/API/CSSMathMin
page-type: web-api-interface
browser-compat: api.CSSMathMin
---
{{APIRef("CSS Typed Object Model API")}}
The **`CSSMathMin`** interface of the {{domxref('CSS_Object_Model#css_typed_object_model','','',' ')}} represents the CSS {{CSSXref('min','min()')}} function. It inherits properties and methods from its parent {{domxref('CSSNumericValue')}}.
{{InheritanceDiagram}}
## Constructor
- {{domxref("CSSMathMin.CSSMathMin", "CSSMathMin()")}} {{Experimental_Inline}}
- : Creates a new `CSSMathMin` object.
## Instance properties
- {{domxref('CSSMathMin.values')}} {{ReadOnlyInline}}
- : Returns a {{domxref('CSSNumericArray')}} object which contains one or more {{domxref('CSSNumericValue')}} objects.
## Static methods
_The interface may also inherit methods from its parent interface, {{domxref("CSSMathValue")}}._
## Instance methods
_The interface may also inherit methods from its parent interface, {{domxref("CSSMathValue")}}._
## Examples
To do
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/cssmathmin | data/mdn-content/files/en-us/web/api/cssmathmin/cssmathmin/index.md | ---
title: "CSSMathMin: CSSMathMin() constructor"
short-title: CSSMathMin()
slug: Web/API/CSSMathMin/CSSMathMin
page-type: web-api-constructor
status:
- experimental
browser-compat: api.CSSMathMin.CSSMathMin
---
{{SeeCompatTable}}{{APIRef("CSS Typed Object Model API")}}
The **`CSSMathMin()`** constructor creates a
new {{domxref("CSSMathMin")}} object which represents the CSS
{{CSSXref('min','min()')}} function.
## Syntax
```js-nolint
new CSSMathMin(args)
```
### Parameters
- `args`
- : A list of values for the {{domxref('CSSMathProduct')}} object to be either a double
integer or a {{domxref('CSSNumericValue')}}.
### Exceptions
- [`TypeError`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError)
- : Thrown if there is a _failure_ when adding all of the values in args.
## Examples
To do
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/cssmathmin | data/mdn-content/files/en-us/web/api/cssmathmin/values/index.md | ---
title: "CSSMathMin: values property"
short-title: values
slug: Web/API/CSSMathMin/values
page-type: web-api-instance-property
browser-compat: api.CSSMathMin.values
---
{{APIRef("CSS Typed Object Model API")}}
The CSSMathMin.values read-only property of the
{{domxref("CSSMathMin")}} interface returns a {{domxref('CSSNumericArray')}} object
which contains one or more {{domxref('CSSNumericValue')}} objects.
## Value
A {{domxref('CSSNumericArray')}}.
## Examples
To do
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/visibilitystateentry/index.md | ---
title: VisibilityStateEntry
slug: Web/API/VisibilityStateEntry
page-type: web-api-interface
status:
- experimental
browser-compat: api.VisibilityStateEntry
---
{{APIRef("Performance API")}}{{seecompattable}}
The **`VisibilityStateEntry`** interface provides timings of page visibility state changes, i.e., when a tab changes from the foreground to the background or vice versa.
This can be used to pinpoint visibility changes on the performance timeline, and cross-reference them against other performance entries such as "first-contentful-paint" (see {{domxref("PerformancePaintTiming")}}).
There are two key visibility state change times that this API reports on:
- `visible`: The time when the page becomes visible (i.e. when its tab moves into the foreground).
- `hidden`: The time when the pages become hidden (i.e. when its tab moves into the background).
The performance timeline will always have a "`visibility-state`" entry with a `startTime` of `0` and a `name` representing the initial page visibility state.
> **Note:** Like other Performance APIs, this API extends {{domxref("PerformanceEntry")}}.
{{InheritanceDiagram}}
## Instance properties
This interface has no properties but it extends the properties of {{domxref("PerformanceEntry")}} by qualifying and constraining them as follows:
- {{domxref("PerformanceEntry.entryType")}} {{experimental_inline}}
- : Returns "`visibility-state`".
- {{domxref("PerformanceEntry.name")}} {{experimental_inline}}
- : Returns either `"visible"` or `"hidden"`.
- {{domxref("PerformanceEntry.startTime")}} {{experimental_inline}}
- : Returns the {{domxref("DOMHighResTimeStamp","timestamp")}} when the visibility state change occurred.
- {{domxref("PerformanceEntry.duration")}} {{experimental_inline}}
- : Returns 0.
## Instance methods
This interface has no methods.
## Examples
### Basic usage
The following function could be used to log a table of all "`visibility-state`" performance entries to the console:
```js
function getVisibilityStateEntries() {
const visibilityStateEntries =
performance.getEntriesByType("visibility-state");
console.table(visibilityStateEntries);
}
```
### Correlating visibility state changes with paint timing
The below function gets a reference to all "`visibility-state`" entries and the "`first-contentful-paint`" entry, then uses {{jsxref("Array.some()")}} to test whether any of the "`hidden`" visibility entries occurred before the first contentful paint:
```js
function wasHiddenBeforeFirstContentfulPaint() {
const fcpEntry = performance.getEntriesByName("first-contentful-paint")[0];
const visibilityStateEntries =
performance.getEntriesByType("visibility-state");
return visibilityStateEntries.some(
(e) => e.startTime < fcpEntry.startTime && e.name === "hidden",
);
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
[Page Visibility API](/en-US/docs/Web/API/Page_Visibility_API)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/svganimatednumberlist/index.md | ---
title: SVGAnimatedNumberList
slug: Web/API/SVGAnimatedNumberList
page-type: web-api-interface
browser-compat: api.SVGAnimatedNumberList
---
{{APIRef("SVG")}}
## SVG animated number list interface
The `SVGAnimatedNumber` interface is used for attributes which take a list of numbers and which can be animated.
### Interface overview
<table class="standard-table">
<tbody>
<tr>
<th scope="row">Also implement</th>
<td><em>None</em></td>
</tr>
<tr>
<th scope="row">Methods</th>
<td><em>None</em></td>
</tr>
<tr>
<th scope="row">Properties</th>
<td>
<ul>
<li>
readonly {{ domxref("SVGNumberList") }}
<code>baseVal</code>
</li>
<li>
readonly {{ domxref("SVGNumberList") }}
<code>animVal</code>
</li>
</ul>
</td>
</tr>
<tr>
<th scope="row">Normative document</th>
<td>
<a
href="https://www.w3.org/TR/SVG11/types.html#InterfaceSVGAnimatedAngle"
>SVG 1.1 (2nd Edition)</a
>
</td>
</tr>
</tbody>
</table>
## Instance properties
- {{domxref("SVGAnimatedNumberList.baseVal")}} {{ReadOnlyInline}}
- : A {{domxref("SVGNumberList")}} that represents the base value of the given attribute before applying any animations.
- {{domxref("SVGAnimatedNumberList.animVal")}} {{ReadOnlyInline}}
- : A read only {{ domxref("SVGNumberList") }} that represents the current animated value of the given attribute. If the given attribute is not currently being animated, then the {{ domxref("SVGNumberList") }} will have the same contents as `baseVal`. The object referenced by `animVal` will always be distinct from the one referenced by `baseVal`, even when the attribute is not animated.
## Instance methods
The `SVGAnimatedNumberList` interface do not provide any specific methods.
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/wgsllanguagefeatures/index.md | ---
title: WGSLLanguageFeatures
slug: Web/API/WGSLLanguageFeatures
page-type: web-api-interface
status:
- experimental
browser-compat: api.WGSLLanguageFeatures
---
{{APIRef("WebGPU API")}}{{SeeCompatTable}}{{SecureContext_Header}}
The **`WGSLLanguageFeatures`** interface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} is a [setlike](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) object that reports the [WGSL language extensions](https://gpuweb.github.io/gpuweb/wgsl/#language-extension) supported by the WebGPU implementation.
The `WGSLLanguageFeatures` object is accessed via the {{domxref("GPU.wgslLanguageFeatures")}} property.
> **Note:** Not all WGSL language extensions are available to WebGPU in all browsers that support the API. We recommend you thoroughly test any extensions you choose to use.
{{InheritanceDiagram}}
## Available features
The available WGSL language extensions can vary across implementations and physical devices and may also change over time; we have therefore not listed them here. For a complete list, refer to [WGSL language extensions](https://gpuweb.github.io/gpuweb/wgsl/#language-extension) in the WGSL specification.
## Instance properties
The following property is available to all read-only [setlike](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) objects:
- {{jsxref("Set.prototype.size", "size")}} {{Experimental_Inline}}
- : Returns the number of values in the set.
## Instance methods
The following methods are available to all read-only [setlike](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) objects:
- {{jsxref("Set.prototype.has()", "has()")}} {{Experimental_Inline}}
- : Returns a boolean asserting whether or not an element with the given value is present in the set.
- {{jsxref("Set.prototype.values()", "values()")}} {{Experimental_Inline}}
- : Returns a new iterator object that yields **values** for each element in the set in insertion order.
- {{jsxref("Set.prototype.keys()", "keys()")}} {{Experimental_Inline}}
- : An alias for {{jsxref("Set.prototype.values()", "values()")}}.
- {{jsxref("Set.prototype.entries()", "entries()")}} {{Experimental_Inline}}
- : Returns a new iterator object that contains **an array of `[value, value]`** for each element in the set in insertion order.
- {{jsxref("Set.prototype.forEach()", "forEach()")}} {{Experimental_Inline}}
- : Calls the provided callback function once for each value present in the set in insertion order.
## Examples
```js
if (!navigator.gpu) {
throw Error("WebGPU not supported.");
}
const wgslFeatures = navigator.gpu.wgslLanguageFeatures;
// Return the size of the set
console.log(wgslFeatures.size);
// Iterate through all the set values using values()
const valueIterator = wgslFeatures.values();
for (const value of valueIterator) {
console.log(value);
}
// ...
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [WebGPU API](/en-US/docs/Web/API/WebGPU_API)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/rtcencodedvideoframe/index.md | ---
title: RTCEncodedVideoFrame
slug: Web/API/RTCEncodedVideoFrame
page-type: web-api-interface
browser-compat: api.RTCEncodedVideoFrame
---
{{APIRef("WebRTC")}}
The **`RTCEncodedVideoFrame`** of the [WebRTC API](/en-US/docs/Web/API/WebRTC_API) represents an encoded video frame in the WebRTC receiver or sender pipeline, which may be modified using a [WebRTC Encoded Transform](/en-US/docs/Web/API/WebRTC_API/Using_Encoded_Transforms).
> **Note:** This feature is available in [_Dedicated_ Web Workers](/en-US/docs/Web/API/Web_Workers_API#worker_types).
## Instance properties
- {{domxref("RTCEncodedVideoFrame.type")}} {{ReadOnlyInline}}
- : Returns whether the current frame is a key frame, delta frame, or empty frame.
- {{domxref("RTCEncodedVideoFrame.timestamp")}} {{ReadOnlyInline}}
- : Returns the timestamp at which sampling of the frame started.
- {{domxref("RTCEncodedVideoFrame.data")}}
- : Return a buffer containing the encoded frame data.
## Instance methods
- {{DOMxRef("RTCEncodedVideoFrame.getMetadata()")}}
- : Returns the metadata associated with the frame.
## Description
Raw video data is generated as a sequence of frames, where each frame is a 2 dimensional array of pixel values.
Video encoders transform this raw input into a compressed representation of the original for transmission and storage.
A common approach is to send "key frames" that contain enough information to reproduce a whole image at a relatively low rate, and between key frames to send many much smaller "delta frames" that just encode the changes since the previous frame.
There are many different codecs, such as H.264, VP8, and VP9, each that have a different encoding processes and configuration, which offer different trade-offs between compression efficiency and video quality.
The **`RTCEncodedVideoFrame`** represents a single frame encoded with a particular video encoder.
The {{domxref("RTCEncodedVideoFrame.type","type")}} property indicates whether the frame is a "key" or "delta" frame, and you can use the {{DOMxRef("RTCEncodedVideoFrame.getMetadata()","getMetadata()")}} method to get other details about the encoding method.
The {{domxref("RTCEncodedVideoFrame.data", "data")}} property provides access to the encoded image data for the frame, which can then be modified ("transformed") when frames are sent or received.
## Examples
This code snippet shows a handler for the `rtctransform` event in a {{domxref("Worker")}} that implements a {{domxref("TransformStream")}}, and pipes encoded frames through it from the `event.transformer.readable` to `event.transformer.writable` (`event.transformer` is a {{domxref("RTCRtpScriptTransformer")}}, the worker-side counterpart of {{domxref("RTCRtpScriptTransform")}}).
If the tranformer is inserted into a video stream, the `transform()` method is called with a `RTCEncodedVideoFrame` whenever a new frame is enqueued on `event.transformer.readable`.
The `transform()` method shows how this might be read, modified by inverting the bits, and then enqueued on the controller (this ultimately pipes it through to the `event.transformer.writable`, and then back into the WebRTC pipline).
```js
addEventListener("rtctransform", (event) => {
const async transform = new TransformStream({
async transform(encodedFrame, controller) {
// Reconstruct the original frame.
const view = new DataView(encodedFrame.data);
// Construct a new buffer
const newData = new ArrayBuffer(encodedFrame.data.byteLength);
const newView = new DataView(newData);
// Negate all bits in the incoming frame
for (let i = 0; i < encodedFrame.data.byteLength; ++i) {
newView.setInt8(i, ~view.getInt8(i));
}
encodedFrame.data = newData;
controller.enqueue(encodedFrame);
},
});
event.transformer.readable
.pipeThrough(transform)
.pipeTo(event.transformer.writable);
});
```
Note that more complete examples are provided in [Using WebRTC Encoded Transforms](/en-US/docs/Web/API/WebRTC_API/Using_Encoded_Transforms).
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using WebRTC Encoded Transforms](/en-US/docs/Web/API/WebRTC_API/Using_Encoded_Transforms)
- {{domxref("TransformStream")}}
- {{DOMxRef("RTCRtpScriptTransformer")}}
- {{DOMxRef("RTCEncodedAudioFrame")}}
| 0 |
data/mdn-content/files/en-us/web/api/rtcencodedvideoframe | data/mdn-content/files/en-us/web/api/rtcencodedvideoframe/data/index.md | ---
title: "RTCEncodedVideoFrame: data property"
short-title: data
slug: Web/API/RTCEncodedVideoFrame/data
page-type: web-api-instance-property
browser-compat: api.RTCEncodedVideoFrame.data
---
{{APIRef("WebRTC")}}
The **`data`** property of the {{domxref("RTCEncodedVideoFrame")}} interface returns a buffer containing the frame data.
## Value
An {{jsxref("ArrayBuffer")}}.
## Examples
This example [WebRTC encoded transform](/en-US/docs/Web/API/WebRTC_API/Using_Encoded_Transforms) shows how you might get the frame data in a {{domxref("TransformStream")}} `transform()` function and negate all the bits.
The `transform()` function constructs a {{jsxref("DataView")}} on the buffer in the frame `data` property, and also creates a view on a new {{jsxref("ArrayBuffer")}}.
It then writes the inverted bytes in the original data to the new buffer, assigns the buffer to the encoded frame `data` property, and enqueues the modified frame on the stream.
```js
addEventListener("rtctransform", (event) => {
const transform = new TransformStream({
async transform(encodedFrame, controller) {
// Reconstruct the original frame.
const view = new DataView(encodedFrame.data);
// Construct a new buffer
const newData = new ArrayBuffer(encodedFrame.data.byteLength);
const newView = new DataView(newData);
// Negate all bits in the incoming frame
for (let i = 0; i < encodedFrame.data.byteLength; ++i) {
newView.setInt8(i, ~view.getInt8(i));
}
encodedFrame.data = newData;
controller.enqueue(encodedFrame);
},
});
event.transformer.readable
.pipeThrough(transform)
.pipeTo(event.transformer.writable);
});
```
Note that the surrounding code shown here is described in [Using WebRTC Encoded Transforms](/en-US/docs/Web/API/WebRTC_API/Using_Encoded_Transforms).
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using WebRTC Encoded Transforms](/en-US/docs/Web/API/WebRTC_API/Using_Encoded_Transforms)
| 0 |
data/mdn-content/files/en-us/web/api/rtcencodedvideoframe | data/mdn-content/files/en-us/web/api/rtcencodedvideoframe/getmetadata/index.md | ---
title: "RTCEncodedVideoFrame: getMetadata() method"
short-title: getMetadata()
slug: Web/API/RTCEncodedVideoFrame/getMetadata
page-type: web-api-instance-method
browser-compat: api.RTCEncodedVideoFrame.getMetadata
---
{{APIRef("WebRTC")}}
The **`getMetadata()`** method of the {{domxref("RTCEncodedVideoFrame")}} interface returns an object containing the metadata associated with the frame.
This includes information about the frame, including its size, video encoding, other frames needed to construct a full image, timestamp, and other information.
## Syntax
```js-nolint
getMetadata()
```
### Parameters
None.
### Return value
An object with the following properties:
- `frameId`
- : A positive integer value indicating the id of this frame.
- `dependencies`
- : An {{jsxref("Array")}} of positive integers indicating the frameIds of frames on which this frame depends.
For a key frame this will be empty, as a key frame contains all the information it needs to construct the image.
For a delta frame this will list all the frames needed to render this frame.
The type of frame can be determined using {{domxref("RTCEncodedVideoFrame.type")}}.
- `width`
- : A positive integer indicating the width of the frame.
The maximum value is 65535.
- `height`
- : A positive integer indicating the height of the frame.
The maximum value is 65535.
- `spatialIndex`
- : A positive integer indicating the spatial index of the frame.
Some codecs allow generation of layers of frames with different layers of resolutions.
Frames in higher layers can be selectively dropped in order to reduce bit rate when needed, while maintaining acceptable video quality.
- `temporalIndex`
- : A positive integer indicating the temporal index of the frame.
Some codecs group frames in layers, based on whether dropping the a frame will prevent others from being decoded.
Frames in higher layers can be selectively dropped in order to reduce bit rate when needed, while maintaining acceptable video quality.
- `synchronizationSource`
- : A positive integer value indicating synchronization source ("ssrc") of the stream of RTP packets that are described by this encoded video frame.
A source might be something like a camera or microphone, or some kind of mixer app that combines multiple sources.
All packets from the same source share the same time source and sequence space, and so can be ordered relative to each other.
Note two frames with the same value refer to the same source (for more information see [`RTCRtpStreamStats.ssrc`](/en-US/docs/Web/API/RTCRtpStreamStats/ssrc)).
- `payloadType`
- : A positive integer value in the range from 0 to 127 that describes the format of the RTP payload.
The mappings of values to formats is defined in RFC3550.
- `contributingSources`
- : An {{jsxref("Array")}} of sources (ssrc) that have contributed to the frame.
Consider the case of a conferencing application that combines the audio and video from multiple users.
The `synchronizationSource` would include the ssrc of the application, while `contributingSources` would include the ssrc values of all the individual video and audio sources.
- `timestamp`
- : The [media presentation timestamp (PTS)](https://en.wikipedia.org/wiki/Presentation_timestamp) in microseconds of raw frame, matching the timestamp for raw frames which correspond to this frame.
This is used to synchronize separate video, audio, subtitle and other streams belonging to the same presentation.
## Examples
This example [WebRTC encoded transform](/en-US/docs/Web/API/WebRTC_API/Using_Encoded_Transforms) implementation shows how you might get the frame metadata in a `transform()` function and log it.
```js
addEventListener("rtctransform", (event) => {
const async transform = new TransformStream({
async transform(encodedFrame, controller) {
// Get the metadata and log
const frameMetaData = encodedFrame.getMetadata();
console.log(frameMetaData)
// Enqueue the frame without modifying
controller.enqueue(encodedFrame);
},
});
event.transformer.readable
.pipeThrough(transform)
.pipeTo(event.transformer.writable);
});
```
The resulting object from a local webcam might look like the one shown below.
Note that there are no contributing sources because there is just one source.
```js
{
"contributingSources": [],
"dependencies": [
405
],
"frameId": 406,
"height": 480,
"payloadType": 120,
"spatialIndex": 0,
"synchronizationSource": 3956716931,
"temporalIndex": 0,
"width": 640
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using WebRTC Encoded Transforms](/en-US/docs/Web/API/WebRTC_API/Using_Encoded_Transforms)
| 0 |
data/mdn-content/files/en-us/web/api/rtcencodedvideoframe | data/mdn-content/files/en-us/web/api/rtcencodedvideoframe/type/index.md | ---
title: "RTCEncodedVideoFrame: type property"
short-title: type
slug: Web/API/RTCEncodedVideoFrame/type
page-type: web-api-instance-property
browser-compat: api.RTCEncodedVideoFrame.type
---
{{APIRef("WebRTC")}}
The readonly **`type`** property of the {{domxref("RTCEncodedVideoFrame")}} interface indicates whether this frame is a key frame, delta frame, or empty frame.
## Value
The type can have one of the following values:
- `key`
- : This is a "key frame", which contains all the information needed to render an image.
It can be decoded without reference to any other frames.
- `delta`
- : This is a "delta frame", which contains changes to an image relative to some previous frame.
The frame cannot be decoded without access to the frame(s) that it references.
- `empty`
- : This frame contains no data.
This value is unexpected, and may indicate that the transform is holding a reference to frames after they have been transformed and piped to {{domxref("RTCRtpScriptTransformer.writable")}} (after transferring back to the main-thread WebRTC pipeline the worker side frame object will have no data).
## Examples
The implementation of a `transform()` function in a [WebRTC Encoded Transform](/en-US/docs/Web/API/WebRTC_API/Using_Encoded_Transforms) can look at the `type` and modify the transform code based on whether it is dealing with a key frame or delta frame:
```js
const transformer = new TransformStream({
transform: async (encodedFrame, controller) => {
if (encodedFrame.type === "key") {
// Apply key frame transformation
} else if (encodedFrame.type === "delta") {
// Apply delta frame transformation
} else {
// Empty
// Check transform is not holding reference to frames after processing!
}
controller.enqueue(encodedFrame);
},
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using WebRTC Encoded Transforms](/en-US/docs/Web/API/WebRTC_API/Using_Encoded_Transforms)
| 0 |
data/mdn-content/files/en-us/web/api/rtcencodedvideoframe | data/mdn-content/files/en-us/web/api/rtcencodedvideoframe/timestamp/index.md | ---
title: "RTCEncodedVideoFrame: timestamp property"
short-title: timestamp
slug: Web/API/RTCEncodedVideoFrame/timestamp
page-type: web-api-instance-property
browser-compat: api.RTCEncodedVideoFrame.timestamp
---
{{APIRef("WebRTC")}}
The readonly **`timestamp`** property of the {{domxref("RTCEncodedVideoFrame")}} interface indicates the time at which frame sampling started.
## Value
A positive integer containing the sampling instant of the first byte in this frame, in microseconds.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using WebRTC Encoded Transforms](/en-US/docs/Web/API/WebRTC_API/Using_Encoded_Transforms)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/htmldatalistelement/index.md | ---
title: HTMLDataListElement
slug: Web/API/HTMLDataListElement
page-type: web-api-interface
browser-compat: api.HTMLDataListElement
---
{{APIRef("HTML DOM")}}
The **`HTMLDataListElement`** interface provides special properties (beyond the {{domxref("HTMLElement")}} object interface it also has available to it by inheritance) to manipulate {{ HTMLElement("datalist") }} elements and their content.
{{InheritanceDiagram}}
## Instance properties
_Inherits properties from its parent, {{domxref("HTMLElement")}}_.
- {{domxref("HTMLDataListElement.options")}} {{ReadOnlyInline}}
- : A {{domxref("HTMLCollection")}} representing a collection of the contained option elements.
## Instance methods
_No specific method; inherits methods from its parent, {{domxref("HTMLElement")}}._
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The HTML element implementing this interface: {{ HTMLElement("datalist") }}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/webgpu_api/index.md | ---
title: WebGPU API
slug: Web/API/WebGPU_API
page-type: web-api-overview
status:
- experimental
browser-compat: api.GPU
---
{{DefaultAPISidebar("WebGPU API")}}{{SeeCompatTable}}{{securecontext_header}}
The **WebGPU API** enables web developers to use the underlying system's GPU (Graphics Processing Unit) to carry out high-performance computations and draw complex images that can be rendered in the browser.
WebGPU is the successor to {{domxref("WebGL_API", "WebGL", "", "nocode")}}, providing better compatibility with modern GPUs, support for general-purpose GPU computations, faster operations, and access to more advanced GPU features.
## Concepts and usage
It is fair to say that {{domxref("WebGL_API", "WebGL", "", "nocode")}} revolutionized the web in terms of graphical capabilities after it first appeared around 2011. WebGL is a JavaScript port of the [OpenGL ES 2.0](https://registry.khronos.org/OpenGL-Refpages/es2.0/) graphics library, allowing web pages to pass rendering computations directly to the device's GPU to be processed at very high speeds, and render the result inside a {{htmlelement("canvas")}} element.
WebGL and the [GLSL](<https://www.khronos.org/opengl/wiki/Core_Language_(GLSL)>) language used to write WebGL shader code are complex, so several WebGL libraries have been created to make WebGL apps easier to write: Popular examples include [Three.js](https://threejs.org/), [Babylon.js](https://www.babylonjs.com/), and [PlayCanvas](https://playcanvas.com/). Developers have used these tools to build immersive web-based 3D games, music videos, training and modeling tools, VR and AR experiences, and more.
However, WebGL has some fundamental issues that needed addressing:
- Since WebGL's release, a new generation of native GPU APIs have appeared — the most popular being [Microsoft's Direct3D 12](https://docs.microsoft.com/en-us/windows/win32/direct3d12/direct3d-12-graphics), [Apple's Metal](https://developer.apple.com/metal/), and [The Khronos Group's Vulkan](https://www.vulkan.org/) — which provide a multitude of new features. There are no more updates planned to OpenGL (and therefore WebGL), so it won't get any of these new features. WebGPU on the other hand will have new features added to it going forwards.
- WebGL is based wholly around the use case of drawing graphics and rendering them to a canvas. It does not handle general-purpose GPU (GPGPU) computations very well. GPGPU computations are becoming more and more important for many different use cases, for example those based on machine learning models.
- 3D graphics apps are becoming increasingly demanding, both in terms of the number of objects to be rendered simultaneously, and usage of new rendering features.
WebGPU addresses these issues, providing an updated general-purpose architecture compatible with modern GPU APIs, which feels more "webby". It supports graphic rendering, but also has first-class support for GPGPU computations. Rendering of individual objects is significantly cheaper on the CPU side, and it supports modern GPU rendering features such as compute-based particles and post-processing filters like color effects, sharpening, and depth-of-field simulation. In addition, it can handle expensive computations such as culling and skinned model transformation directly on the GPU.
## General model
There are several layers of abstraction between a device GPU and a web browser running the WebGPU API. It is useful to understand these as you begin to learn WebGPU:
- Physical devices have GPUs. Most devices only have one GPU, but some have more than one. Different GPU types are available:
- Integrated GPUs, which live on the same board as the CPU and share its memory.
- Discrete GPUs, which live on their own board, separate from the CPU.
- Software "GPUs", implemented on the CPU.
> **Note:** The above diagram assumes a device with only one GPU.
- A native GPU API, which is part of the OS (e.g. Metal on macOS), is a programming interface allowing native applications to use the capabilities of the GPU. API instructions are sent to the GPU (and responses received) via a driver. It is possible for a system to have multiple native OS APIs and drivers available to communicate with the GPU, although the above diagram assumes a device with only one native API/driver.
- A browser's WebGPU implementation handles communicating with the GPU via a native GPU API driver. A WebGPU adapter effectively represents a physical GPU and driver available on the underlying system, in your code.
- A logical device is an abstraction via which a single web app can access GPU capabilities in a compartmentalized way. Logical devices are required to provide multiplexing capabilities. A physical device's GPU is used by many applications and processes concurrently, including potentially many web apps. Each web app needs to be able to access WebGPU in isolation for security and logic reasons.
## Accessing a device
A logical device — represented by a {{domxref("GPUDevice")}} object instance — is the basis from which a web app accesses all WebGPU functionality. Accessing a device is done as follows:
1. The {{domxref("Navigator.gpu")}} property (or {{domxref("WorkerNavigator.gpu")}} if you are using WebGPU functionality from inside a worker) returns the {{domxref("GPU")}} object for the current context.
2. You access an adapter via the {{domxref("GPU.requestAdapter", "GPU.requestAdapter()")}} method. This method accepts an optional settings object allowing you to request for example a high-performance or low-energy adapter. If this is not included, the device will provide access to the default adapter, which is good enough for most purposes.
3. A device can be requested via {{domxref("GPUAdapter.requestDevice()")}}. This method also accepts an options object (referred to as a descriptor), which can be used to specify the exact features and limits you want the logical device to have. If this is not included, the supplied device will have a reasonable general-purpose spec that is good enough for most purposes.
Putting this together with some feature detection checks, the above process could be achieved as follows:
```js
async function init() {
if (!navigator.gpu) {
throw Error("WebGPU not supported.");
}
const adapter = await navigator.gpu.requestAdapter();
if (!adapter) {
throw Error("Couldn't request WebGPU adapter.");
}
const device = await adapter.requestDevice();
//...
}
```
## Pipelines and shaders: WebGPU app structure
A pipeline is a logical structure containing programmable stages that are completed to get your program's work done. WebGPU is currently able to handle two types of pipeline:
- A render pipeline renders graphics, typically into a {{htmlelement("canvas")}} element, but it could also render graphics offscreen. It has two main stages:
- A vertex stage, in which a vertex shader takes positioning data fed into the GPU and uses it to position a series of vertices in 3D space by applying specified effects like rotation, translation, or perspective. The vertices are then assembled into primitives such as triangles (the basic building block of rendered graphics) and rasterized by the GPU to figure out what pixels each one should cover on the drawing canvas.
- A fragment stage, in which a fragment shader computes the color for each pixel covered by the primitives produced by the vertex shader. These computations frequently use inputs such as images (in the form of textures) that provide surface details and the position and color of virtual lights.
- A compute pipeline is for general computation. A compute pipeline contains a single compute stage in which a compute shader takes general data, processes it in parallel across a specified number of workgroups, then returns the result in one or more buffers. The buffers can contain any kind of data.
The shaders mentioned above are sets of instructions processed by the GPU. WebGPU shaders are written in a low-level Rust-like language called [WebGPU Shader Language](https://gpuweb.github.io/gpuweb/wgsl/) (WGSL).
There are several different ways in which you could architect a WebGPU app, but the process will likely contain the following steps:
1. [Create shader modules](#create_shader_modules): Write your shader code in WGSL and package it into one or more shader modules.
2. [Get and configure the canvas context](#get_and_configure_the_canvas_context): Get the `webgpu` context of a `<canvas>` element and configure it to receive information on what graphics to render from your GPU logical device. This step is not necessary if your app has no graphical output, such as one that only uses compute pipelines.
3. [Create resources containing your data](#create_a_buffer_and_write_our_triangle_data_into_it): The data that you want processed by your pipelines needs to be stored in GPU buffers or textures to be accessed by your app.
4. [Create pipelines](#define_and_create_the_render_pipeline): Define pipeline descriptors that describe the desired pipelines in detail, including the required data structure, bindings, shaders, and resource layouts, then create pipelines from them. Our basic demos only contain a single pipeline, but non-trivial apps will usually contain multiple pipelines for different purposes.
5. [Run a compute/rendering pass](#running_a_rendering_pass): This involves a number of substeps:
1. Create a command encoder that can encode a set of commands to be passed to the GPU to execute.
2. Create a pass encoder object on which compute/render commands are issued.
3. Run commands to specify which pipelines to use, what buffer(s) to get the required data from, how many drawing operations to run (in the case of render pipelines), etc.
4. Finalize the command list and encapsulate it in a command buffer.
5. Submit the command buffer to the GPU via the logical device's command queue.
In the sections below, we will examine a basic render pipeline demo, to allow you to explore what it requires. Later on, we'll also examine a [basic compute pipeline](#basic_compute_pipeline) example, looking at how it differs from the render pipeline.
## Basic render pipeline
In our [basic render demo](https://mdn.github.io/dom-examples/webgpu-render-demo/) we give a `<canvas>` element a solid blue background and draw a triangle onto it.
### Create shader modules
We are using the following shader code. The vertex shader stage (`@vertex` block) accepts a chunk of data containing a position and a color, positions the vertex according to the given position, interpolates the color, then passes the data along to the fragment shader stage. The fragment shader stage (`@fragment` block) accepts the data from the vertex shader stage and colors the vertex according to the given color.
```js
const shaders = `
struct VertexOut {
@builtin(position) position : vec4f,
@location(0) color : vec4f
}
@vertex
fn vertex_main(@location(0) position: vec4f,
@location(1) color: vec4f) -> VertexOut
{
var output : VertexOut;
output.position = position;
output.color = color;
return output;
}
@fragment
fn fragment_main(fragData: VertexOut) -> @location(0) vec4f
{
return fragData.color;
}
`;
```
> **Note:** In our demos we are storing our shader code inside a template literal, but you can store it anywhere from which it can easily be retrieved as text to be fed into your WebGPU program. For example, another common practice is to store shaders inside a {{htmlelement("script")}} element and retrieve the contents using {{domxref("Node.textContent")}}. The correct mime type to use for WGSL is `text/wgsl`.
To make your shader code available to WebGPU, you have to put it inside a {{domxref("GPUShaderModule")}} via a {{domxref("GPUDevice.createShaderModule()")}} call, passing your shader code as a property inside a descriptor object. For example:
```js
const shaderModule = device.createShaderModule({
code: shaders,
});
```
### Get and configure the canvas context
In a render pipeline, we need to specify somewhere to render the graphics to. In this case we are getting a reference to an onscreen `<canvas>` element then calling {{domxref("HTMLCanvasElement.getContext()")}} with a parameter of `webgpu` to return its GPU context (a {{domxref("GPUCanvasContext")}} instance).
From there, we configure the context with a call to {{domxref("GPUCanvasContext.configure()")}}, passing it an options object containing the {{domxref("GPUDevice")}} that the rendering information will come from, the format the textures will have, and the alpha mode to use when rendering semi-transparent textures.
```js
const canvas = document.querySelector("#gpuCanvas");
const context = canvas.getContext("webgpu");
context.configure({
device: device,
format: navigator.gpu.getPreferredCanvasFormat(),
alphaMode: "premultiplied",
});
```
> **Note:** The best practice for determining the texture format is to use the {{domxref("GPU.getPreferredCanvasFormat()")}} method; this selects the most efficient format (either `bgra8unorm` or `rgba8unorm`) for the user's device.
### Create a buffer and write our triangle data into it
Next we will provide our WebGPU program with our data, in a form it can use. Our data is initially provided in a {{jsxref("Float32Array")}}, which contains 8 data points for each triangle vertex — X, Y, Z, W for position, and R, G, B, A for color.
```js
const vertices = new Float32Array([
0.0, 0.6, 0, 1, 1, 0, 0, 1, -0.5, -0.6, 0, 1, 0, 1, 0, 1, 0.5, -0.6, 0, 1, 0,
0, 1, 1,
]);
```
However, we've got an issue here. We need to get our data into a {{domxref("GPUBuffer")}}. Behind the scenes, this type of buffer is stored in memory very tightly integrated with the GPU's cores to allow for the desired high performance processing. As a side effect, this memory can't be accessed by processes running on the host system, like the browser.
The {{domxref("GPUBuffer")}} is created via a call to {{domxref("GPUDevice.createBuffer()")}}. We give it a size equal to the length of the `vertices` array so it can contain all the data, and `VERTEX` and `COPY_DST` usage flags to indicate that the buffer will be used as a vertex buffer and the destination of copy operations.
```js
const vertexBuffer = device.createBuffer({
size: vertices.byteLength, // make it big enough to store vertices in
usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
});
```
We could handle getting our data into the `GPUBuffer` using a mapping operation, like we use in the [compute pipeline example](#basic_compute_pipeline) to read data from the GPU back to JavaScript. However, in this case we are going to use the handy {{domxref("GPUQueue.writeBuffer()")}} convenience method, which takes as its parameters the buffer to write to, the data source to write from, an offset value for each, and the size of data to write (we've specified the whole length of the array). The browser then works out the most efficient way to handle writing the data.
```js
device.queue.writeBuffer(vertexBuffer, 0, vertices, 0, vertices.length);
```
### Define and create the render pipeline
Now we've got our data into a buffer, the next part of the setup is to actually create our pipeline, ready to be used for rendering.
First of all, we create an object that describes the required layout of our vertex data. This perfectly describes what we saw earlier on in our `vertices` array and vertex shader stage — each vertex has position and color data. Both are formatted in `float32x4` format (which maps to the WGSL `vec4<f32>` type), and the color data starts at an offset of 16 bytes into each vertex. `arrayStride` specifies the stride, meaning the number of bytes making up each vertex, and `stepMode` specifies that the data should be fetched per-vertex.
```js
const vertexBuffers = [
{
attributes: [
{
shaderLocation: 0, // position
offset: 0,
format: "float32x4",
},
{
shaderLocation: 1, // color
offset: 16,
format: "float32x4",
},
],
arrayStride: 32,
stepMode: "vertex",
},
];
```
Next, we create a descriptor object that specifies the configuration of our render pipeline stages. For both the shader stages, we specify the {{domxref("GPUShaderModule")}} that the relevant code can be found in (`shaderModule`), and the name of the function that acts as the entry point for each stage.
In addition, in the case of the vertex shader stage we provide our `vertexBuffers` object to provide the expected state of our vertex data. And in the case of our fragment shader stage, we provide an array of color target states that indicate the specified rendering format (this matches the format specified in our canvas context config earlier).
We also specify a `primitive` state, which in this case just states the type of primitive we will be drawing, and a `layout` of `auto`. The `layout` property defines the layout (structure, purpose, and type) of all the GPU resources (buffers, textures, etc.) used during the execution of the pipeline. In more complex apps, this would take the form of a {{domxref("GPUPipelineLayout")}} object, created using {{domxref("GPUDevice.createPipelineLayout()")}} (you can see an example in our [Basic compute pipeline](#basic_compute_pipeline)), which allows the GPU to figure out how to run the pipeline most efficiently ahead of time. Here however we are specifying the `auto` value, which will cause the pipeline to generate an implicit bind group layout based on any bindings defined in the shader code.
```js
const pipelineDescriptor = {
vertex: {
module: shaderModule,
entryPoint: "vertex_main",
buffers: vertexBuffers,
},
fragment: {
module: shaderModule,
entryPoint: "fragment_main",
targets: [
{
format: navigator.gpu.getPreferredCanvasFormat(),
},
],
},
primitive: {
topology: "triangle-list",
},
layout: "auto",
};
```
Finally, we can create a {{domxref("GPURenderPipeline")}} based on our `pipelineDescriptor` object, by passing it in as a parameter to a {{domxref("GPUDevice.createRenderPipeline()")}} method call.
```js
const renderPipeline = device.createRenderPipeline(pipelineDescriptor);
```
### Running a rendering pass
Now that all the setup is done, we can actually run a rendering pass and draw something onto our `<canvas>`. To encode any commands to be later issued to the GPU, you need to create a {{domxref("GPUCommandEncoder")}} instance, which is done using a {{domxref("GPUDevice.createCommandEncoder()")}} call.
```js
const commandEncoder = device.createCommandEncoder();
```
Next up we start the rendering pass running by creating a {{domxref("GPURenderPassEncoder")}} instance with a {{domxref("GPUCommandEncoder.beginRenderPass()")}} call. This method takes a descriptor object as a parameter, the only mandatory property of which is a `colorAttachments` array. In this case, we specify:
1. A texture view to render into; we create a new view from the `<canvas>` via {{domxref("GPUTexture.createView", "context.getCurrentTexture().createView()")}}.
2. That the view should be "cleared" to a specified color once loaded and before any drawing takes place. This is what causes the blue background behind the triangle.
3. That the value of the current rendering pass should be stored for this color attachment.
```js
const clearColor = { r: 0.0, g: 0.5, b: 1.0, a: 1.0 };
const renderPassDescriptor = {
colorAttachments: [
{
clearValue: clearColor,
loadOp: "clear",
storeOp: "store",
view: context.getCurrentTexture().createView(),
},
],
};
const passEncoder = commandEncoder.beginRenderPass(renderPassDescriptor);
```
Now we can invoke methods of the rendering pass encoder to draw our triangle:
1. {{domxref("GPURenderPassEncoder.setPipeline()")}} is called with our `renderPipeline` object as a parameter to specify the pipeline to use for the rendering pass.
2. {{domxref("GPURenderPassEncoder.setVertexBuffer()")}} is called with our `vertexBuffer` object as a parameter to act as the data source to pass to the pipeline to render. The first parameter is the slot to set the vertex buffer for, and is a reference to the index of the element in the `vertexBuffers` array which describes this buffer's layout.
3. {{domxref("GPURenderPassEncoder.draw()")}} sets the drawing in motion. There is data for three vertices inside our `vertexBuffer`, so we set a vertex count value of `3` to draw them all.
```js
passEncoder.setPipeline(renderPipeline);
passEncoder.setVertexBuffer(0, vertexBuffer);
passEncoder.draw(3);
```
To finish encoding the sequence of commands and issue them to the GPU, three more steps are needed.
1. We invoke the {{domxref("GPURenderPassEncoder.end()")}} method to signal the end of the render pass command list.
2. We invoke the {{domxref("GPUCommandEncoder.finish()")}} method to complete recording of the issued command sequence and encapsulate it into a {{domxref("GPUCommandBuffer")}} object instance.
3. We submit the {{domxref("GPUCommandBuffer")}} to the device's command queue (represented by a {{domxref("GPUQueue")}} instance) to be sent to the GPU. The device's queue is available via the {{domxref("GPUDevice.queue")}} property, and an array of {{domxref("GPUCommandBuffer")}} instances can be added to the queue via a {{domxref("GPUQueue.submit()")}} call.
These three steps can be achieved via the following two lines:
```js
passEncoder.end();
device.queue.submit([commandEncoder.finish()]);
```
## Basic compute pipeline
In our [basic compute demo](https://mdn.github.io/dom-examples/webgpu-compute-demo/), we get the GPU to calculate some values, store them in an output buffer, copy the data across to a staging buffer, then map that staging buffer so that the data can be read out to JavaScript and logged to the console.
The app follows a similar structure to the basic rendering demo. We create a {{domxref("GPUDevice")}} reference in the same way as before, and encapsulate our shader code into a {{domxref("GPUShaderModule")}} via a {{domxref("GPUDevice.createShaderModule()")}} call. The difference here is that our shader code only has one shader stage, a `@compute` stage:
```js
// Define global buffer size
const BUFFER_SIZE = 1000;
const shader = `
@group(0) @binding(0)
var<storage, read_write> output: array<f32>;
@compute @workgroup_size(64)
fn main(
@builtin(global_invocation_id)
global_id : vec3u,
@builtin(local_invocation_id)
local_id : vec3u,
) {
// Avoid accessing the buffer out of bounds
if (global_id.x >= ${BUFFER_SIZE}) {
return;
}
output[global_id.x] =
f32(global_id.x) * 1000. + f32(local_id.x);
}
`;
```
### Create buffers to handle our data
In this example we create two {{domxref("GPUBuffer")}} instances to handle our data, an `output` buffer to write the GPU calculation results to at high speed, and a `stagingBuffer` that we'll copy the `output` contents to, which can be mapped to allow JavaScript to access the values.
- `output` is specified as a storage buffer that will be the source of a copy operation.
- `stagingBuffer` is specified as a buffer that can be mapped for reading by JavaScript, and will be the destination of a copy operation.
```js
const output = device.createBuffer({
size: BUFFER_SIZE,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
});
const stagingBuffer = device.createBuffer({
size: BUFFER_SIZE,
usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
});
```
### Create a bind group layout
When the pipeline is created, we specify a bind group to use for the pipeline. This involves first creating a {{domxref("GPUBindGroupLayout")}} (via a call to {{domxref("GPUDevice.createBindGroupLayout()")}}) that defines the structure and purpose of GPU resources such as buffers that will be used in this pipeline. This layout is used as a template for bind groups to adhere to. In this case we give the pipeline access to a single memory buffer, tied to binding slot 0 (this matches the relevant binding number in our shader code — `@binding(0)`), usable in the compute stage of the pipeline, and with the buffer's purpose defined as `storage`.
```js
const bindGroupLayout = device.createBindGroupLayout({
entries: [
{
binding: 0,
visibility: GPUShaderStage.COMPUTE,
buffer: {
type: "storage",
},
},
],
});
```
Next we create a {{domxref("GPUBindGroup")}} by calling {{domxref("GPUDevice.createBindGroup()")}}. We pass this method call a descriptor object that specifies the bind group layout to base this bind group on, and the details of the variable to bind to the slot defined in the layout. In this case, we are declaring binding 0, and specifying that the `output` buffer we defined earlier should be bound to it.
```js
const bindGroup = device.createBindGroup({
layout: bindGroupLayout,
entries: [
{
binding: 0,
resource: {
buffer: output,
},
},
],
});
```
> **Note:** You could retrieve an implicit layout to use when creating a bind group by calling the {{domxref("GPUComputePipeline.getBindGroupLayout()")}} method. There is also a version available for render pipelines: see {{domxref("GPURenderPipeline.getBindGroupLayout()")}}.
### Create a compute pipeline
With the above all in place, we can now create a compute pipeline by calling {{domxref("GPUDevice.createComputePipeline()")}}, passing it a pipeline descriptor object. This works in a similar way to creating a render pipeline. We describe the compute shader, specifying what module to find the code in and what the entry point is. We also specify a `layout` for the pipeline, in this case creating a layout based on the `bindGroupLayout` we defined earlier via a {{domxref("GPUDevice.createPipelineLayout()")}} call.
```js
const computePipeline = device.createComputePipeline({
layout: device.createPipelineLayout({
bindGroupLayouts: [bindGroupLayout],
}),
compute: {
module: shaderModule,
entryPoint: "main",
},
});
```
One difference here from the render pipeline layout is that we are not specifying a primitive type, as we are not drawing anything.
### Running a compute pass
Running a compute pass is similar in structure to running a rendering pass, with some different commands. For a start, the pass encoder is created using {{domxref("GPUCommandEncoder.beginComputePass()")}}.
When issuing the commands, we specify the pipeline to use in the same way as before, using {{domxref("GPUComputePassEncoder.setPipeline()")}}. We then however use {{domxref("GPUComputePassEncoder.setBindGroup()")}} to specify that we want to use our `bindGroup` to specify the data to use in the calculation, and {{domxref("GPUComputePassEncoder.dispatchWorkgroups()")}} to specify the number of GPU workgroups to use to run the calculations.
We then signal the end of the render pass command list using {{domxref("GPURenderPassEncoder.end()")}}.
```js
passEncoder.setPipeline(computePipeline);
passEncoder.setBindGroup(0, bindGroup);
passEncoder.dispatchWorkgroups(Math.ceil(BUFFER_SIZE / 64));
passEncoder.end();
```
### Reading the results back to JavaScript
Before submitting the encoded commands to the GPU for execution using {{domxref("GPUQueue.submit()")}}, we copy the contents of the `output` buffer to the `stagingBuffer` buffer using {{domxref("GPUCommandEncoder.copyBufferToBuffer()")}}.
```js
// Copy output buffer to staging buffer
commandEncoder.copyBufferToBuffer(
output,
0, // Source offset
stagingBuffer,
0, // Destination offset
BUFFER_SIZE,
);
// End frame by passing array of command buffers to command queue for execution
device.queue.submit([commandEncoder.finish()]);
```
Once the output data is available in the `stagingBuffer`, we use the {{domxref("GPUBuffer.mapAsync()")}} method to map the data to intermediate memory, grab a reference to the mapped range using {{domxref("GPUBuffer.getMappedRange()")}}, copy the data into JavaScript, and then log it to the console. We also unmap the `stagingBuffer` once we are finished with it.
```js
// map staging buffer to read results back to JS
await stagingBuffer.mapAsync(
GPUMapMode.READ,
0, // Offset
BUFFER_SIZE, // Length
);
const copyArrayBuffer = stagingBuffer.getMappedRange(0, BUFFER_SIZE);
const data = copyArrayBuffer.slice();
stagingBuffer.unmap();
console.log(new Float32Array(data));
```
## GPU error handling
WebGPU calls are validated asynchronously in the GPU process. If errors are found, the problem call is marked as invalid on the GPU side. If another call is made that relies on the return value of an invalidated call, that object will also be marked as invalid, and so on. For this reason, errors in WebGPU are referred to as "contagious".
Each {{domxref("GPUDevice")}} instance maintains its own error scope stack. This stack is initially empty, but you can start pushing an error scope to the stack by invoking {{domxref("GPUDevice.pushErrorScope()")}} to capture errors of a particular type.
Once you are done capturing errors, you can end capture by invoking {{domxref("GPUDevice.popErrorScope()")}}. This pops the scope from the stack and returns a {{jsxref("Promise")}} that resolves to an object ({{domxref("GPUInternalError")}}, {{domxref("GPUOutOfMemoryError")}}, or {{domxref("GPUValidationError")}}) describing the first error captured in the scope, or `null` if no errors were captured.
We have attempted to provide useful information to help you understand why errors are occurring in your WebGPU code in "Validation" sections where appropriate, which list criteria to meet to avoid errors. See for example the [`GPUDevice.createBindGroup()` Validation section](/en-US/docs/Web/API/GPUDevice/createBindGroup#validation). Some of this information is complex; rather than repeat the spec, we have decided to just list error criteria that are:
- Non-obvious, for example combinations of descriptor properties that produce validation errors. There is no point telling you to make sure you use the correct descriptor object structure. That is both obvious and vague.
- Developer-controlled. Some of the error criteria are purely based on internals and not really relevant to web developers.
You can find more information about WebGPU error handling in the explainer — see [Object validity and destroyed-ness](https://gpuweb.github.io/gpuweb/explainer/#invalid-and-destroyed) and [Errors](https://gpuweb.github.io/gpuweb/explainer/#errors). [WebGPU Error Handling best practices](https://toji.dev/webgpu-best-practices/error-handling) provides useful real-world examples and advice.
> **Note:** The historic way of handling errors in WebGL is to provide a {{domxref("WebGLRenderingContext.getError", "getError()")}} method to return error information. This is problematic in that it returns errors synchronously, which is bad for performance — each call requires a round-trip to the GPU and requires all previously issued operations to be finished. Its state model is also flat, meaning that errors can leak between unrelated code. The creators of WebGPU were determined to improve on this.
## Interfaces
### Entry point for the API
- {{domxref("Navigator.gpu")}} / {{domxref("WorkerNavigator.gpu")}}
- : The entry point for the API — returns the {{domxref("GPU")}} object for the current context.
- {{domxref("GPU")}}
- : The starting point for using WebGPU. It can be used to return a {{domxref("GPUAdapter")}}.
- {{domxref("GPUAdapter")}}
- : Represents a GPU adapter. From this you can request a {{domxref("GPUDevice")}}, adapter info, features, and limits.
- {{domxref("GPUAdapterInfo")}}
- : Contains identifying information about an adapter.
### Configuring GPUDevices
- {{domxref("GPUDevice")}}
- : Represents a logical GPU device. This is the main interface through which the majority of WebGPU functionality is accessed.
- {{domxref("GPUSupportedFeatures")}}
- : A [setlike](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) object that describes additional functionality supported by a {{domxref("GPUAdapter")}} or {{domxref("GPUDevice")}}.
- {{domxref("GPUSupportedLimits")}}
- : Describes the limits supported by a {{domxref("GPUAdapter")}} or {{domxref("GPUDevice")}}.
### Configuring a rendering `<canvas>`
- {{domxref("HTMLCanvasElement.getContext()")}} — the `"webgpu"` `contextType`
- : Invoking `getContext()` with the `"webgpu"` `contextType` returns a {{domxref("GPUCanvasContext")}} object instance, which can then be configured with {{domxref("GPUCanvasContext.configure()")}}.
- {{domxref("GPUCanvasContext")}}
- : Represents the WebGPU rendering context of an {{htmlelement("canvas")}} element.
### Representing pipeline resources
- {{domxref("GPUBuffer")}}
- : Represents a block of memory that can be used to store raw data to use in GPU operations.
- {{domxref("GPUExternalTexture")}}
- : A wrapper object containing an {{domxref("HTMLVideoElement")}} snapshot that can be used as a texture in GPU rendering operations.
- {{domxref("GPUSampler")}}
- : Controls how shaders transform and filter texture resource data.
- {{domxref("GPUShaderModule")}}
- : A reference to an internal shader module object, a container for WGSL shader code that can be submitted to the GPU to execution by a pipeline.
- {{domxref("GPUTexture")}}
- : A container used to store 1D, 2D, or 3D arrays of data, such as images, to use in GPU rendering operations.
- {{domxref("GPUTextureView")}}
- : A view onto some subset of the texture subresources defined by a particular {{domxref("GPUTexture")}}.
### Representing pipelines
- {{domxref("GPUBindGroup")}}
- : Based on a {{domxref("GPUBindGroupLayout")}}, a `GPUBindGroup` defines a set of resources to be bound together in a group and how those resources are used in shader stages.
- {{domxref("GPUBindGroupLayout")}}
- : Defines the structure and purpose of related GPU resources such as buffers that will be used in a pipeline, and is used as a template when creating {{domxref("GPUBindGroup")}}s.
- {{domxref("GPUComputePipeline")}}
- : Controls the compute shader stage and can be used in a {{domxref("GPUComputePassEncoder")}}.
- {{domxref("GPUPipelineLayout")}}
- : Defines the {{domxref("GPUBindGroupLayout")}}s used by a pipeline. {{domxref("GPUBindGroup")}}s used with the pipeline during command encoding must have compatible {{domxref("GPUBindGroupLayout")}}s.
- {{domxref("GPURenderPipeline")}}
- : Controls the vertex and fragment shader stages and can be used in a {{domxref("GPURenderPassEncoder")}} or {{domxref("GPURenderBundleEncoder")}}.
### Encoding and submitting commands to the GPU
- {{domxref("GPUCommandBuffer")}}
- : Represents a recorded list of GPU commands that can be submitted to a {{domxref("GPUQueue")}} for execution.
- {{domxref("GPUCommandEncoder")}}
- : Represents a command encoder, used to encode commands to be issued to the GPU.
- {{domxref("GPUComputePassEncoder")}}
- : Encodes commands related to controlling the compute shader stage, as issued by a {{domxref("GPUComputePipeline")}}. Part of the overall encoding activity of a {{domxref("GPUCommandEncoder")}}.
- {{domxref("GPUQueue")}}
- : controls execution of encoded commands on the GPU.
- {{domxref("GPURenderBundle")}}
- : A container for pre-recorded bundles of commands (see {{domxref("GPURenderBundleEncoder")}}).
- {{domxref("GPURenderBundleEncoder")}}
- : Used to pre-record bundles of commands. These can be reused in {{domxref("GPURenderPassEncoder")}}s via the {{domxref("GPURenderPassEncoder.executeBundles", "executeBundles()")}} method, as many times as required.
- {{domxref("GPURenderPassEncoder")}}
- : Encodes commands related to controlling the vertex and fragment shader stages, as issued by a {{domxref("GPURenderPipeline")}}. Part of the overall encoding activity of a {{domxref("GPUCommandEncoder")}}.
### Running queries on rendering passes
- {{domxref("GPUQuerySet")}}
- : Used to record the results of queries on passes, such as occlusion or timestamp queries.
### Debugging errors
- {{domxref("GPUCompilationInfo")}}
- : An array of {{domxref("GPUCompilationMessage")}} objects, generated by the GPU shader module compiler to help diagnose problems with shader code.
- {{domxref("GPUCompilationMessage")}}
- : Represents a single informational, warning, or error message generated by the GPU shader module compiler.
- {{domxref("GPUDeviceLostInfo")}}
- : Returned when the {{domxref("GPUDevice.lost")}} {{jsxref("Promise")}} resolves, providing information as to why the device was lost.
- {{domxref("GPUError")}}
- : The base interface for errors surfaced by {{domxref("GPUDevice.popErrorScope")}} and the {{domxref("GPUDevice.uncapturederror_event", "uncapturederror")}} event.
- {{domxref("GPUInternalError")}}
- : One of the types of errors surfaced by {{domxref("GPUDevice.popErrorScope")}} and the {{domxref("GPUDevice")}} {{domxref("GPUDevice.uncapturederror_event", "uncapturederror")}} event. Indicates that an operation failed for a system or implementation-specific reason, even when all validation requirements were satisfied.
- {{domxref("GPUOutOfMemoryError")}}
- : One of the types of errors surfaced by {{domxref("GPUDevice.popErrorScope")}} and the {{domxref("GPUDevice")}} {{domxref("GPUDevice.uncapturederror_event", "uncapturederror")}} event. Indicates that there was not enough free memory to complete the requested operation.
- {{domxref("GPUPipelineError")}}
- : Describes a pipeline failure. The value received when a {{jsxref("Promise")}} returned by a {{domxref("GPUDevice.createComputePipelineAsync()")}} or {{domxref("GPUDevice.createRenderPipelineAsync()")}} call rejects.
- {{domxref("GPUUncapturedErrorEvent")}}
- : The event object type for the {{domxref("GPUDevice")}} {{domxref("GPUDevice.uncapturederror_event", "uncapturederror")}} event.
- {{domxref("GPUValidationError")}}
- : One of the types of errors surfaced by {{domxref("GPUDevice.popErrorScope")}} and the {{domxref("GPUDevice")}} {{domxref("GPUDevice.uncapturederror_event", "uncapturederror")}} event. Describes an application error indicating that an operation did not pass the WebGPU API's validation constraints.
## Security requirements
The whole API is available only in a [secure context](/en-US/docs/Web/Security/Secure_Contexts).
## Examples
- [Basic compute demo](https://mdn.github.io/dom-examples/webgpu-compute-demo/)
- [Basic render demo](https://mdn.github.io/dom-examples/webgpu-render-demo/)
- [WebGPU samples](https://webgpu.github.io/webgpu-samples/)
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [WebGPU best practices](https://toji.dev/webgpu-best-practices/)
- [WebGPU explainer](https://gpuweb.github.io/gpuweb/explainer)
- [WebGPU — All of the cores, none of the canvas](https://surma.dev/things/webgpu/)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/extendablemessageevent/index.md | ---
title: ExtendableMessageEvent
slug: Web/API/ExtendableMessageEvent
page-type: web-api-interface
browser-compat: api.ExtendableMessageEvent
---
{{APIRef("Service Workers API")}}
The **`ExtendableMessageEvent`** interface of the [Service Worker API](/en-US/docs/Web/API/Service_Worker_API) represents the event object of a {{domxref("ServiceWorkerGlobalScope/message_event", "message")}} event fired on a service worker (when a message is received on the {{domxref("ServiceWorkerGlobalScope")}} from another context) — extends the lifetime of such events.
This interface inherits from the {{domxref("ExtendableEvent")}} interface.
{{InheritanceDiagram}}
## Constructor
- {{domxref("ExtendableMessageEvent.ExtendableMessageEvent","ExtendableMessageEvent()")}}
- : Creates a new `ExtendableMessageEvent` object instance.
## Instance properties
_Inherits properties from its parent, {{domxref("ExtendableEvent")}}_.
- {{domxref("ExtendableMessageEvent.data")}} {{ReadOnlyInline}}
- : Returns the event's data. It can be any data type. If dispatched in `messageerror` event, the property will be `null`.
- {{domxref("ExtendableMessageEvent.origin")}} {{ReadOnlyInline}}
- : Returns the origin of the {{domxref("Client")}} that sent the message.
- {{domxref("ExtendableMessageEvent.lastEventId")}} {{ReadOnlyInline}}
- : Represents, in [server-sent events](/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events), the last event ID of the event source.
- {{domxref("ExtendableMessageEvent.source")}} {{ReadOnlyInline}}
- : Returns a reference to the {{domxref("Client")}} object that sent the message.
- {{domxref("ExtendableMessageEvent.ports")}} {{ReadOnlyInline}}
- : Returns the array containing the {{domxref("MessagePort")}} objects representing the ports of the associated message channel.
## Instance methods
_Inherits methods from its parent, {{domxref("ExtendableEvent")}}_.
## Examples
In the below example a page gets a handle to the {{domxref("ServiceWorker")}} object via {{domxref("ServiceWorkerRegistration.active")}}, and then calls its `postMessage()` function.
```js
// in the page being controlled
if (navigator.serviceWorker) {
navigator.serviceWorker.register("service-worker.js");
navigator.serviceWorker.addEventListener("message", (event) => {
// event is a MessageEvent object
console.log(`The service worker sent me a message: ${event.data}`);
});
navigator.serviceWorker.ready.then((registration) => {
registration.active.postMessage("Hi service worker");
});
}
```
The service worker can receive the message by listening to the `message` event:
```js
// in the service worker
addEventListener("message", (event) => {
// event is an ExtendableMessageEvent object
console.log(`The client sent me a message: ${event.data}`);
event.source.postMessage("Hi client");
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Service Workers](/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers)
- [Service workers basic code example](https://github.com/mdn/dom-examples/tree/main/service-worker/simple-service-worker)
- [Channel Messaging](/en-US/docs/Web/API/Channel_Messaging_API)
| 0 |
data/mdn-content/files/en-us/web/api/extendablemessageevent | data/mdn-content/files/en-us/web/api/extendablemessageevent/origin/index.md | ---
title: "ExtendableMessageEvent: origin property"
short-title: origin
slug: Web/API/ExtendableMessageEvent/origin
page-type: web-api-instance-property
browser-compat: api.ExtendableMessageEvent.origin
---
{{APIRef("Service Workers API")}}
The **`origin`** read-only property of the
{{domxref("ExtendableMessageEvent")}} interface returns the origin of the
{{domxref("Client")}} that sent the message.
## Value
A string.
## Examples
When the following code is used inside a service worker to respond to a push messages
by sending the data received via {{domxref("PushMessageData")}} to the main context via
a [channel message](/en-US/docs/Web/API/Channel_Messaging_API), the event
object of `onmessage` will be a `ExtendableMessageEvent`.
```js
let port;
self.addEventListener("push", (e) => {
const obj = e.data.json();
if (obj.action === "subscribe" || obj.action === "unsubscribe") {
port.postMessage(obj);
} else if (obj.action === "init" || obj.action === "chatMsg") {
port.postMessage(obj);
}
});
self.onmessage = (e) => {
console.log(e.origin);
port = e.ports[0];
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Service Workers](/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers)
- [Service workers basic code example](https://github.com/mdn/dom-examples/tree/main/service-worker/simple-service-worker)
- [Channel Messaging](/en-US/docs/Web/API/Channel_Messaging_API)
| 0 |
data/mdn-content/files/en-us/web/api/extendablemessageevent | data/mdn-content/files/en-us/web/api/extendablemessageevent/source/index.md | ---
title: "ExtendableMessageEvent: source property"
short-title: source
slug: Web/API/ExtendableMessageEvent/source
page-type: web-api-instance-property
browser-compat: api.ExtendableMessageEvent.source
---
{{APIRef("Service Workers API")}}
The **`source`** read-only property of the
{{domxref("ExtendableMessageEvent")}} interface returns a reference to the
{{domxref("Client")}} object from which the message was sent.
## Value
A {{domxref("Client")}}, {{domxref("ServiceWorker")}} or {{domxref("MessagePort")}}
object.
## Examples
When the following code is used inside a service worker to respond to a push messages
by sending the data received via {{domxref("PushMessageData")}} to the main context via
a [channel message](/en-US/docs/Web/API/Channel_Messaging_API), the event
object of `onmessage` will be a `ExtendableMessageEvent`.
```js
let port;
self.addEventListener("push", (e) => {
const obj = e.data.json();
if (obj.action === "subscribe" || obj.action === "unsubscribe") {
port.postMessage(obj);
} else if (obj.action === "init" || obj.action === "chatMsg") {
port.postMessage(obj);
}
});
self.onmessage = (e) => {
console.log(e.source);
port = e.ports[0];
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Service Workers](/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers)
- [Service workers basic code example](https://github.com/mdn/dom-examples/tree/main/service-worker/simple-service-worker)
- [Channel Messaging](/en-US/docs/Web/API/Channel_Messaging_API)
| 0 |
data/mdn-content/files/en-us/web/api/extendablemessageevent | data/mdn-content/files/en-us/web/api/extendablemessageevent/data/index.md | ---
title: "ExtendableMessageEvent: data property"
short-title: data
slug: Web/API/ExtendableMessageEvent/data
page-type: web-api-instance-property
browser-compat: api.ExtendableMessageEvent.data
---
{{APIRef("Service Workers API")}}
The **`data`** read-only property of the
{{domxref("ExtendableMessageEvent")}} interface returns the event's data. It can be any
data type.
## Value
Any data type.
## Examples
When the following code is used inside a service worker to respond to a push messages
by sending the data received via {{domxref("PushMessageData")}} to the main context via
a [channel message](/en-US/docs/Web/API/Channel_Messaging_API), the event
object of `onmessage` will be a `ExtendableMessageEvent`.
```js
let port;
self.addEventListener("push", (e) => {
const obj = e.data.json();
if (obj.action === "subscribe" || obj.action === "unsubscribe") {
port.postMessage(obj);
} else if (obj.action === "init" || obj.action === "chatMsg") {
port.postMessage(obj);
}
});
self.onmessage = (e) => {
console.log(e.data);
port = e.ports[0];
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Service Workers](/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers)
- [Service workers basic code example](https://github.com/mdn/dom-examples/tree/main/service-worker/simple-service-worker)
- [Channel Messaging](/en-US/docs/Web/API/Channel_Messaging_API)
| 0 |
data/mdn-content/files/en-us/web/api/extendablemessageevent | data/mdn-content/files/en-us/web/api/extendablemessageevent/lasteventid/index.md | ---
title: "ExtendableMessageEvent: lastEventId property"
short-title: lastEventId
slug: Web/API/ExtendableMessageEvent/lastEventId
page-type: web-api-instance-property
browser-compat: api.ExtendableMessageEvent.lastEventId
---
{{APIRef("Service Workers API")}}
The **`lastEventID`** read-only property of the
{{domxref("ExtendableMessageEvent")}} interface represents, in [server-sent events](/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events), the last event ID of the event source. This is an empty string.
## Value
A string.
## Examples
When the following code is used inside a service worker to respond to a push messages
by sending the data received via {{domxref("PushMessageData")}} to the main context via
a [channel message](/en-US/docs/Web/API/Channel_Messaging_API), the event
object of `onmessage` will be a `ExtendableMessageEvent`.
```js
let port;
self.addEventListener("push", (e) => {
const obj = e.data.json();
if (obj.action === "subscribe" || obj.action === "unsubscribe") {
port.postMessage(obj);
} else if (obj.action === "init" || obj.action === "chatMsg") {
port.postMessage(obj);
}
});
self.onmessage = (e) => {
console.log(e.lastEventId);
port = e.ports[0];
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Service Workers](/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers)
- [Service workers basic code example](https://github.com/mdn/dom-examples/tree/main/service-worker/simple-service-worker)
- [Channel Messaging](/en-US/docs/Web/API/Channel_Messaging_API)
| 0 |
data/mdn-content/files/en-us/web/api/extendablemessageevent | data/mdn-content/files/en-us/web/api/extendablemessageevent/extendablemessageevent/index.md | ---
title: "ExtendableMessageEvent: ExtendableMessageEvent() constructor"
short-title: ExtendableMessageEvent()
slug: Web/API/ExtendableMessageEvent/ExtendableMessageEvent
page-type: web-api-constructor
browser-compat: api.ExtendableMessageEvent.ExtendableMessageEvent
---
{{APIRef("Service Workers API")}}
The **`ExtendableMessageEvent()`** constructor creates a new {{domxref("ExtendableMessageEvent")}} object.
## Syntax
```js-nolint
new ExtendableMessageEvent(type)
new ExtendableMessageEvent(type, options)
```
### Parameters
- `type`
- : A string with the name of the event.
It is case-sensitive and browsers set it to `messageerror` or `message`.
- `options` {{optional_inline}}
- : An object that, _in addition of the properties defined in {{domxref("ExtendableEvent/ExtendableEvent", "ExtendableEvent()")}}_, can have the following properties:
- `data` {{optional_inline}}
- : The event's data; this can be any data type. It defaults to `null`.
- `origin` {{optional_inline}}
- : A string that defines the origin of the corresponding service worker's environment settings object.
It defaults to `""`.
- `lastEventId` {{optional_inline}}
- : A string that defines the last event ID of the event source. It defaults to `""`.
- `source` {{optional_inline}}
- : The {{domxref("Client")}}, {{domxref("ServiceWorker")}} or {{domxref("MessagePort")}} that sent the message.
It defaults to `null`.
- `ports` {{optional_inline}}
- : An array containing the {{domxref("MessagePort")}} objects connected to the channel sending the message.
It defaults to an empty array.
### Return value
A new {{domxref("ExtendableMessageEvent")}} object.
## Examples
```js
const options = {
data: "hello message",
source: MessagePortReference,
ports: MessagePortListReference,
};
const myEME = new ExtendableMessageEvent("message", init);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Service Workers](/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers)
- [Service workers basic code example](https://github.com/mdn/dom-examples/tree/main/service-worker/simple-service-worker)
- [Channel Messaging](/en-US/docs/Web/API/Channel_Messaging_API)
| 0 |
data/mdn-content/files/en-us/web/api/extendablemessageevent | data/mdn-content/files/en-us/web/api/extendablemessageevent/ports/index.md | ---
title: "ExtendableMessageEvent: ports property"
short-title: ports
slug: Web/API/ExtendableMessageEvent/ports
page-type: web-api-instance-property
browser-compat: api.ExtendableMessageEvent.ports
---
{{APIRef("Service Workers API")}}
The **`ports`** read-only property of the
{{domxref("ExtendableMessageEvent")}} interface returns the array containing the
{{domxref("MessagePort")}} objects representing the ports of the associated message
channel (the channel the message is being sent through.)
## Value
An array of {{domxref("MessagePort")}} objects.
## Examples
When the following code is used inside a service worker to respond to a push messages
by sending the data received via {{domxref("PushMessageData")}} to the main context via
a [channel message](/en-US/docs/Web/API/Channel_Messaging_API), the event
object of `onmessage` will be a `ExtendableMessageEvent`.
```js
let port;
self.addEventListener("push", (e) => {
const obj = e.data.json();
if (obj.action === "subscribe" || obj.action === "unsubscribe") {
port.postMessage(obj);
} else if (obj.action === "init" || obj.action === "chatMsg") {
port.postMessage(obj);
}
});
self.onmessage = (e) => {
port = e.ports[0];
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Service Workers](/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers)
- [Service workers basic code example](https://github.com/mdn/dom-examples/tree/main/service-worker/simple-service-worker)
- [Channel Messaging](/en-US/docs/Web/API/Channel_Messaging_API)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/ext_frag_depth/index.md | ---
title: EXT_frag_depth extension
short-title: EXT_frag_depth
slug: Web/API/EXT_frag_depth
page-type: webgl-extension
browser-compat: api.EXT_frag_depth
---
{{APIRef("WebGL")}}
The **`EXT_frag_depth`** extension is part of the [WebGL API](/en-US/docs/Web/API/WebGL_API) and enables to set a depth value of a fragment from within the fragment shader.
WebGL extensions are available using the {{domxref("WebGLRenderingContext.getExtension()")}} method. For more information, see also [Using Extensions](/en-US/docs/Web/API/WebGL_API/Using_Extensions) in the [WebGL tutorial](/en-US/docs/Web/API/WebGL_API/Tutorial).
> **Note:** This extension is only available to {{domxref("WebGLRenderingContext", "WebGL1", "", 1)}} contexts. In {{domxref("WebGL2RenderingContext", "WebGL2", "", 1)}}, the functionality of this extension is available on the WebGL2 context by default. It requires GLSL `#version 300 es`.
## Examples
Enable the extension:
```js
gl.getExtension("EXT_frag_depth");
```
Now the output variable `gl_FragDepthEXT` is available to set a depth value of a fragment from within the fragment shader:
```html
<script type="x-shader/x-fragment">
void main() {
gl_FragColor = vec4(1.0, 0.0, 1.0, 1.0);
gl_FragDepthEXT = 0.5;
}
</script>
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("WebGLRenderingContext.getExtension()")}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/beforeinstallpromptevent/index.md | ---
title: BeforeInstallPromptEvent
slug: Web/API/BeforeInstallPromptEvent
page-type: web-api-interface
status:
- experimental
- non-standard
browser-compat: api.BeforeInstallPromptEvent
---
{{APIRef}}{{SeeCompatTable}}{{Non-standard_header}}
The **`BeforeInstallPromptEvent`** is the interface of the {{domxref("Window.beforeinstallprompt_event", "beforeinstallprompt")}} event fired at the {{domxref("Window")}} object before a user is prompted to "install" a website to a home screen on mobile.
This interface inherits from the {{domxref("Event")}} interface.
{{InheritanceDiagram}}
## Constructor
- {{domxref("BeforeInstallPromptEvent.BeforeInstallPromptEvent","BeforeInstallPromptEvent()")}}{{Non-standard_Inline}} {{Experimental_Inline}}
- : Creates a new `BeforeInstallPromptEvent` object.
## Instance properties
_Inherits properties from its parent, {{domxref("Event")}}._
- {{domxref("BeforeInstallPromptEvent.platforms")}} {{ReadOnlyInline}}{{Non-standard_Inline}} {{Experimental_Inline}}
- : Returns an array of string items containing the platforms on which the event was dispatched. This is provided for user agents that want to present a choice of versions to the user such as, for example, "web" or "play" which would allow the user to choose between a web version or an Android version.
- {{domxref("BeforeInstallPromptEvent.userChoice")}} {{ReadOnlyInline}}{{Non-standard_Inline}} {{Experimental_Inline}}
- : Returns a {{jsxref("Promise")}} that resolves to an object describing the user's choice when they were prompted to install the app.
## Instance methods
- {{domxref("BeforeInstallPromptEvent.prompt()")}}{{Non-standard_Inline}} {{Experimental_Inline}}
- : Show a prompt asking the user if they want to install the app. This method returns a {{jsxref("Promise")}} that resolves to an object describing the user's choice when they were prompted to install the app.
## Examples
In the following example an app provides its own install button, which has an `id` of `"install"`. Initially the button is hidden.
```html
<button id="install" hidden>Install</button>
```
The `beforeinstallprompt` handler:
- Cancels the event, which prevents the browser displaying its own install UI on some platforms
- Assigns the `BeforeInstallPromptEvent` object to a variable, so it can be used later
- Reveals the app's install button.
```js
let installPrompt = null;
const installButton = document.querySelector("#install");
window.addEventListener("beforeinstallprompt", (event) => {
event.preventDefault();
installPrompt = event;
installButton.removeAttribute("hidden");
});
```
When clicked, the app's install button:
- Calls the {{domxref("BeforeInstallPromptEvent.prompt()", "prompt()")}} method of the stored event object, to trigger the installation prompt.
- Resets its state by clearing the `installPrompt` variable and hiding itself again.
```js
installButton.addEventListener("click", async () => {
if (!installPrompt) {
return;
}
const result = await installPrompt.prompt();
console.log(`Install prompt was: ${result.outcome}`);
installPrompt = null;
installButton.setAttribute("hidden", "");
});
```
## Browser compatibility
{{Compat}}
## See also
- [Making PWAs installable](/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable)
- [How to provide your own in-app install experience](https://web.dev/articles/customize-install) on web.dev (2021)
| 0 |
data/mdn-content/files/en-us/web/api/beforeinstallpromptevent | data/mdn-content/files/en-us/web/api/beforeinstallpromptevent/userchoice/index.md | ---
title: "BeforeInstallPromptEvent: userChoice property"
short-title: userChoice
slug: Web/API/BeforeInstallPromptEvent/userChoice
page-type: web-api-instance-property
status:
- experimental
- non-standard
browser-compat: api.BeforeInstallPromptEvent.userChoice
---
{{APIRef}}{{SeeCompatTable}}{{Non-standard_header}}
The **`userChoice`** property of the {{domxref("BeforeInstallPromptEvent")}} interface represents the installation choice that the user made, when they were prompted to install the app.
## Value
A {{jsxref("Promise")}} which resolves to an object containing two properties:
- `outcome` {{experimental_inline}} {{non-standard_inline}}
- : A string indicating whether the user chose to install the app or not. It must be one of the following values:
- `"accepted"`: The user installed the app.
- `"dismissed"`: The user did not install the app.
- `platform` {{experimental_inline}} {{non-standard_inline}}
- : If the user chose to install the app, this is a string naming the selected platform, which is one of the values from the {{domxref("BeforeInstallPromptEvent.platforms")}} property. If the user chose not to install the app, this is an empty string.
## Browser compatibility
{{Compat}}
## See also
- [Making PWAs installable](/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable)
- [How to provide your own in-app install experience](https://web.dev/articles/customize-install) on web.dev (2021)
| 0 |
data/mdn-content/files/en-us/web/api/beforeinstallpromptevent | data/mdn-content/files/en-us/web/api/beforeinstallpromptevent/prompt/index.md | ---
title: "BeforeInstallPromptEvent: prompt() method"
short-title: prompt()
slug: Web/API/BeforeInstallPromptEvent/prompt
page-type: web-api-instance-method
status:
- experimental
- non-standard
browser-compat: api.BeforeInstallPromptEvent.prompt
---
{{APIRef}}{{SeeCompatTable}}{{Non-standard_header}}
The **`prompt()`** method of the {{domxref("BeforeInstallPromptEvent")}} interface allows a developer to show the
install prompt at a time of their own choosing. Typically this will be called in the event handler for the app's custom install UI.
This method must be called in the event handler for a user action (such as a button click) and may only be called once on a given `BeforeInstallPromptEvent` instance.
## Syntax
```js-nolint
prompt()
```
### Parameters
None.
### Return value
A {{jsxref("Promise")}} resolving to an object containing the following properties:
- `outcome` {{experimental_inline}} {{non-standard_inline}}
- : A string indicating whether the user chose to install the app or not. It must be one of the following values:
- `"accepted"`: The user installed the app.
- `"dismissed"`: The user did not install the app.
- `platform` {{experimental_inline}} {{non-standard_inline}}
- : If the user chose to install the app, this is a string naming the selected platform, which is one of the values from the {{domxref("BeforeInstallPromptEvent.platforms")}} property. If the user chose not to install the app, this is an empty string.
## Examples
See the [example for the `BeforeInstallPromptEvent` interface](/en-US/docs/Web/API/BeforeInstallPromptEvent#examples).
## Browser compatibility
{{Compat}}
## See also
- [Making PWAs installable](/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable)
- [How to provide your own in-app install experience](https://web.dev/articles/customize-install) on web.dev (2021)
| 0 |
data/mdn-content/files/en-us/web/api/beforeinstallpromptevent | data/mdn-content/files/en-us/web/api/beforeinstallpromptevent/beforeinstallpromptevent/index.md | ---
title: "BeforeInstallPromptEvent: BeforeInstallPromptEvent() constructor"
short-title: BeforeInstallPromptEvent()
slug: Web/API/BeforeInstallPromptEvent/BeforeInstallPromptEvent
page-type: web-api-constructor
status:
- experimental
- non-standard
browser-compat: api.BeforeInstallPromptEvent.BeforeInstallPromptEvent
---
{{APIRef}}{{SeeCompatTable}}{{Non-standard_header}}
The **`BeforeInstallPromptEvent()`** constructor creates a new {{domxref("BeforeInstallPromptEvent")}} object.
## Syntax
```js-nolint
new BeforeInstallPromptEvent(type)
new BeforeInstallPromptEvent(type, eventInitDict)
```
### Parameters
- `type`
- : A string with the name of the event, set to `beforeinstallpromptevent`.
- `eventInitDict` {{optional_inline}}
- : An object with a single optional property `platforms`, which is an array of strings, listing the platforms on which the event will be dispatched.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Making PWAs installable](/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable)
- [How to provide your own in-app install experience](https://web.dev/articles/customize-install) on web.dev (2021)
| 0 |
data/mdn-content/files/en-us/web/api/beforeinstallpromptevent | data/mdn-content/files/en-us/web/api/beforeinstallpromptevent/platforms/index.md | ---
title: "BeforeInstallPromptEvent: platforms property"
short-title: platforms
slug: Web/API/BeforeInstallPromptEvent/platforms
page-type: web-api-instance-property
status:
- experimental
- non-standard
browser-compat: api.BeforeInstallPromptEvent.platforms
---
{{APIRef}}{{SeeCompatTable}}{{Non-standard_header}}
The **`platforms`** property of the {{domxref("BeforeInstallPromptEvent")}} interface lists the platforms on which the event was dispatched. This is provided for user agents that want to present a choice of versions to the user such as, for example, "web" or "play" which would allow the user to choose between a web version or an Android version.
## Value
An array of strings, in which each string identifies a target platform for the installation.
## Browser compatibility
{{Compat}}
## See also
- [Making PWAs installable](/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable)
- [How to provide your own in-app install experience](https://web.dev/articles/customize-install) on web.dev (2021)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/crypto/index.md | ---
title: Crypto
slug: Web/API/Crypto
page-type: web-api-interface
browser-compat: api.Crypto
---
{{APIRef("Web Crypto API")}}
The **`Crypto`** interface represents basic cryptography features available in the current context.
It allows access to a cryptographically strong random number generator and to cryptographic primitives.
{{AvailableInWorkers}}
The [Web Crypto API](/en-US/docs/Web/API/Web_Crypto_API) is accessed through the global {{domxref("crypto_property", "crypto")}} property, which is a `Crypto` object.
## Instance properties
_This interface implements properties defined on {{domxref("Crypto/getRandomValues", "RandomSource")}}._
- {{domxref("Crypto.subtle")}} {{ReadOnlyInline}} {{SecureContext_inline}}
- : Returns a {{domxref("SubtleCrypto")}} object providing access to common cryptographic primitives, like hashing, signing, encryption, or decryption.
## Instance methods
_This interface implements methods defined on {{domxref("Crypto/getRandomValues", "RandomSource")}}._
- {{domxref("Crypto.getRandomValues()")}}
- : Fills the passed {{ jsxref("TypedArray") }} with cryptographically sound random values.
- {{domxref("Crypto.randomUUID()")}} {{SecureContext_inline}}
- : Returns a randomly generated, 36 character long v4 UUID.
## Usage notes
You should avoid using the Web Crypto API on insecure contexts, even though the `Crypto` interface is present on insecure contexts, as is the {{domxref("crypto_property", "crypto")}} property.
In addition, the `Crypto` method {{domxref("Crypto.getRandomValues", "getRandomValues()")}} is available on insecure contexts, but the {{domxref("Crypto.subtle", "subtle")}} property is not.
In general, you probably should just treat `Crypto` as available only on secure contexts.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Web security](/en-US/docs/Web/Security)
- [Secure contexts](/en-US/docs/Web/Security/Secure_Contexts)
- [Features restricted to secure contexts](/en-US/docs/Web/Security/Secure_Contexts/features_restricted_to_secure_contexts)
- [Transport Layer Security](/en-US/docs/Web/Security/Transport_Layer_Security)
- [Strict-Transport-Security](/en-US/docs/Web/HTTP/Headers/Strict-Transport-Security)
| 0 |
data/mdn-content/files/en-us/web/api/crypto | data/mdn-content/files/en-us/web/api/crypto/getrandomvalues/index.md | ---
title: "Crypto: getRandomValues() method"
short-title: getRandomValues()
slug: Web/API/Crypto/getRandomValues
page-type: web-api-instance-method
browser-compat: api.Crypto.getRandomValues
---
{{APIRef("Web Crypto API")}}
The **`Crypto.getRandomValues()`** method lets you get cryptographically strong random values.
The array given as the parameter is filled with random numbers (random in its cryptographic meaning).
To guarantee enough performance, implementations are not using a truly random number generator, but they are using a pseudo-random number generator _seeded_ with a value with enough entropy.
The pseudo-random number generator algorithm (PRNG) may vary across {{Glossary("user agent", "user agents")}}, but is suitable for cryptographic purposes.
`getRandomValues()` is the only member of the `Crypto` interface which can be used from an insecure context.
## Syntax
```js-nolint
getRandomValues(typedArray)
```
### Parameters
- `typedArray`
- : An integer-based {{jsxref("TypedArray")}}, that is one of: {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}},
{{jsxref("Uint8ClampedArray")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}},
{{jsxref("Int32Array")}}, {{jsxref("Uint32Array")}}, {{jsxref("BigInt64Array")}},
{{jsxref("BigUint64Array")}} (but **not** `Float32Array` nor `Float64Array`).
All elements in the array will be overwritten with random numbers.
### Return value
The same array passed as `typedArray` but with its contents replaced with the newly generated random numbers.
Note that `typedArray` is modified in-place, and no copy is made.
### Exceptions
- `QuotaExceededError` {{domxref("DOMException")}}
- : Thrown if the {{jsxref("TypedArray.byteLength", "byteLength")}} of `typedArray` exceeds 65,536.
## Usage notes
Don't use `getRandomValues()` to generate encryption keys.
Instead, use the {{domxref("SubtleCrypto.generateKey", "generateKey()")}} method.
There are a few reasons for this; for example, `getRandomValues()` is not guaranteed to be running in a secure context.
There is no minimum degree of entropy mandated by the Web Cryptography specification.
User agents are instead urged to provide the best entropy they can when generating random numbers,
using a well-defined, efficient pseudorandom number generator built into the user agent itself,
but seeded with values taken from an external source of pseudorandom numbers, such as a platform-specific random number function,
the Unix `/dev/urandom` device, or other source of random or pseudorandom data.
## Examples
```js
const array = new Uint32Array(10);
self.crypto.getRandomValues(array);
console.log("Your lucky numbers:");
for (const num of array) {
console.log(num);
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Web Crypto API](/en-US/docs/Web/API/Web_Crypto_API)
- {{domxref("crypto_property", "crypto")}} to get a {{domxref("Crypto")}} object.
- {{jsxref("Math.random")}}, a non-cryptographic source of random numbers.
| 0 |
data/mdn-content/files/en-us/web/api/crypto | data/mdn-content/files/en-us/web/api/crypto/randomuuid/index.md | ---
title: "Crypto: randomUUID() method"
short-title: randomUUID()
slug: Web/API/Crypto/randomUUID
page-type: web-api-instance-method
browser-compat: api.Crypto.randomUUID
---
{{APIRef("Web Crypto API")}}{{SecureContext_header}}
The **`randomUUID()`** method of the {{domxref("Crypto")}} interface is used to generate a v4 {{Glossary("UUID")}} using a cryptographically secure random number generator.
## Syntax
```js-nolint
randomUUID()
```
### Parameters
None.
### Return value
A string containing a randomly generated, 36 character long v4 UUID.
## Examples
The method is accessed through the global {{domxref("crypto_property", "crypto")}} property.
```js
/* Assuming that self.crypto.randomUUID() is available */
let uuid = self.crypto.randomUUID();
console.log(uuid); // for example "36b8f84d-df4e-4d49-b662-bcde71a8764f"
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{ domxref("Web Crypto API") }}
- {{ domxref("crypto_property", "crypto") }} to get a {{domxref("Crypto")}} object.
- {{ domxref("Crypto.getRandomValues") }}, a source for arbitrary amounts of secure random bytes.
| 0 |
data/mdn-content/files/en-us/web/api/crypto | data/mdn-content/files/en-us/web/api/crypto/subtle/index.md | ---
title: "Crypto: subtle property"
short-title: subtle
slug: Web/API/Crypto/subtle
page-type: web-api-instance-property
browser-compat: api.Crypto.subtle
---
{{APIRef("Web Crypto API")}}{{SecureContext_header}}
The **`Crypto.subtle`** read-only property returns a
{{domxref("SubtleCrypto")}} which can then be used to perform low-level
cryptographic operations.
## Value
A {{domxref("SubtleCrypto")}} object you can use to interact with the Web Crypto API's
low-level cryptography features.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Crypto")}}.
- {{domxref("SubtleCrypto")}}.
- [Compatibility test page](https://vibornoff.github.io/webcrypto-examples/index.html).
- [Shim for IE11 and Safari](https://github.com/vibornoff/webcrypto-shim).
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/lockmanager/index.md | ---
title: LockManager
slug: Web/API/LockManager
page-type: web-api-interface
browser-compat: api.LockManager
---
{{APIRef("Web Locks API")}}{{securecontext_header}}
The **`LockManager`** interface of the [Web Locks API](/en-US/docs/Web/API/Web_Locks_API) provides methods for requesting a new {{domxref('Lock')}} object and querying for an existing `Lock` object. To get an instance of `LockManager`, call {{domxref('navigator.locks')}}.
{{AvailableInWorkers}}
## Instance methods
- {{domxref('LockManager.request()')}}
- : Requests a {{domxref('Lock')}} object with parameters specifying its name and characteristics.
- {{domxref('LockManager.query()')}}
- : Returns a {{jsxref('Promise')}} that resolves with an object that contains information about held and pending locks.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/lockmanager | data/mdn-content/files/en-us/web/api/lockmanager/request/index.md | ---
title: "LockManager: request() method"
short-title: request()
slug: Web/API/LockManager/request
page-type: web-api-instance-method
browser-compat: api.LockManager.request
---
{{APIRef("Web Locks API")}}{{securecontext_header}}
The **`request()`** method of the {{domxref("LockManager")}} interface requests a {{domxref('Lock')}} object with parameters specifying its name and characteristics.
The requested `Lock` is passed to a callback, while the function itself returns a {{jsxref('Promise')}} that resolves (or rejects) with the result of the callback after the lock is released, or rejects if the request is aborted.
The `mode` property of the `options` parameter may be either `"exclusive"` or `"shared"`.
Request an `"exclusive"` lock when it should only be held by one code instance at a time.
This applies to code in both tabs and workers. Use this to represent mutually exclusive access to a resource.
When an `"exclusive"` lock for a given name is held, no other lock with the same name can be held.
Request a `"shared"` lock when multiple instances of the code can share access to a resource.
When a `"shared"` lock for a given name is held, other `"shared"` locks for the same name can be granted, but no `"exclusive"` locks with that name can be held or granted.
This shared/exclusive lock pattern is common in database transaction architecture, for example to allow multiple simultaneous readers (each requests a `"shared"` lock) but only one writer (a single `"exclusive"` lock).
This is known as the readers-writer pattern.
In the [IndexedDB API](/en-US/docs/Web/API/IndexedDB_API), this is exposed as `"readonly"` and `"readwrite"` transactions which have the same semantics.
{{AvailableInWorkers}}
## Syntax
```js-nolint
request(name, callback)
request(name, options, callback)
```
### Parameters
- `name`
- : An identifier for the lock you want to request.
- `options` {{optional_inline}}
- : An object describing characteristics of the lock you want to create.
Valid values are:
- `mode` {{optional_inline}}
- : Either `"exclusive"` or `"shared"`.
The default value is `"exclusive"`.
- `ifAvailable` {{optional_inline}}
- : If `true`, the lock request will only be granted if it is not already held.
If it cannot be granted, the callback will be invoked with `null` instead of a `Lock` instance.
The default value is `false`.
- `steal` {{optional_inline}}
- : If `true`, then any held locks with the same name will be released, and the request will be granted, preempting any queued requests for it.
The default value is `false`.
> **Warning:** Use with care!
> Code that was previously running inside the lock continues to run, and may clash with the code that now holds the lock.
- `signal` {{optional_inline}}
- : An {{domxref("AbortSignal")}} (the {{domxref("AbortController.signal", "signal")}} property of an {{domxref("AbortController")}});
if specified and the {{domxref("AbortController")}} is aborted, the lock request is dropped if it was not already granted.
- `callback`
- : Method called when the lock is granted.
The lock is automatically released when the callback returns (or an exception is thrown).
Usually the callback is an async function, which causes the lock to be released only when the async function has completely finished.
### Return value
A {{jsxref('Promise')}} that resolves (or rejects) with the result of the callback after the lock is released, or rejects if the request is aborted.
### Exceptions
This method may return a promise rejected with a {{domxref("DOMException")}} of one of the following types:
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the environments document is not fully active.
- `SecurityError` {{domxref("DOMException")}}
- : Thrown if a lock manager cannot be obtained for the current environment.
- `NotSupportedError` {{domxref("DOMException")}}
- : Thrown if `name` starts with a hyphen (`-`), both options `steal` and `ifAvailable` are `true`, or if option `signal` exists and _either_ option `steal` or `ifAvailable` is `true`.
- `AbortError` {{domxref("DOMException")}}
- : Thrown if the option `signal` exists and is aborted.
## Examples
### General Example
The following example shows the basic use of the `request()` method with an asynchronous function as the callback.
Once the callback is invoked, no other running code on this origin can hold `my_resource` until the callback returns.
```js
await navigator.locks.request("my_resource", async (lock) => {
// The lock was granted.
});
```
### `mode` example
The following example shows how to use the `mode` option for readers and writers.
Notice that both functions use a lock called `my_resource`.
The `do_read()` requests a lock in `'shared'` mode meaning that multiple calls may occur simultaneously across different event handlers, tabs, or workers.
```js
async function do_read() {
await navigator.locks.request(
"my_resource",
{ mode: "shared" },
async (lock) => {
// Read code here.
},
);
}
```
The `do_write()` function use the same lock but in `'exclusive'` mode which will delay invocation of the `request()` call in `do_read()` until the write operation has completed.
This applies across event handlers, tabs, or workers.
```js
async function do_write() {
await navigator.locks.request(
"my_resource",
{ mode: "exclusive" },
async (lock) => {
// Write code here.
},
);
}
```
### `ifAvailable` example
To grab a lock only if it isn't already being held, use the `ifAvailable` option.
In this function `await` means the method will not return until the callback is complete.
Since the lock is only granted if it was available, this call avoids needing to wait on the lock being released elsewhere.
```js
await navigator.locks.request(
"my_resource",
{ ifAvailable: true },
async (lock) => {
if (!lock) {
// The lock was not granted - get out fast.
return;
}
// The lock was granted, and no other running code in this origin is holding
// the 'my_res_lock' lock until this returns.
},
);
```
### `signal` example
To only wait for a lock for a short period of time, use the `signal` option.
```js
const controller = new AbortController();
// Wait at most 200ms.
setTimeout(() => controller.abort(), 200);
try {
await navigator.locks.request(
"my_resource",
{ signal: controller.signal },
async (lock) => {
// The lock was acquired!
},
);
} catch (ex) {
if (ex.name === "AbortError") {
// The request aborted before it could be granted.
}
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/lockmanager | data/mdn-content/files/en-us/web/api/lockmanager/query/index.md | ---
title: "LockManager: query() method"
short-title: query()
slug: Web/API/LockManager/query
page-type: web-api-instance-method
browser-compat: api.LockManager.query
---
{{APIRef("Web Locks API")}}{{securecontext_header}}
The **`query()`** method of the {{domxref("LockManager")}} interface returns a {{jsxref('Promise')}} that resolves with an object containing information about held and pending locks.
{{AvailableInWorkers}}
## Syntax
```js-nolint
query()
```
### Parameters
None.
### Return value
A {{jsxref('Promise')}} that resolves with an object containing a snapshot of the {{domxref("LockManager")}} state.
The object has the following properties:
- `held`
- : An array of `LockInfo` objects for held locks.
- `pending`
- : An array of `LockInfo` objects for pending lock requests.
The `LockInfo` object can have the following properties:
- `name`
- : The name passed to {{domxref("LockManager.request()")}} when the lock was requested.
- `mode`
- : The access mode passed to {{domxref("LockManager.request()")}} when the lock was requested. The mode is either `"exclusive"` or `"shared"`.
- `clientId`
- : The unique identity of the context where {{domxref("LockManager.request()")}} is called. This is the same value as {{domxref("Client.id")}}.
### Exceptions
This method may return a promise rejected with a {{domxref("DOMException")}} of one of the following types:
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the environments document is not fully active.
- `SecurityError` {{domxref("DOMException")}}
- : Thrown if a lock manager cannot be obtained for the current environment.
## Examples
```js
const state = await navigator.locks.query();
for (const lock of state.held) {
console.log(`held lock: name ${lock.name}, mode ${lock.mode}`);
}
for (const request of state.pending) {
console.log(`requested lock: name ${request.name}, mode ${request.mode}`);
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/svgsetelement/index.md | ---
title: SVGSetElement
slug: Web/API/SVGSetElement
page-type: web-api-interface
browser-compat: api.SVGSetElement
---
{{APIRef("SVG")}}
The **`SVGSetElement`** interface corresponds to the {{SVGElement("set")}} element.
{{InheritanceDiagram}}
## Instance properties
_This interface doesn't implement any specific properties, but inherits properties from its parent interface, {{domxref("SVGAnimationElement")}}._
## Instance methods
_This interface doesn't implement any specific methods, but inherits methods from its parent interface, {{domxref("SVGAnimationElement")}}._
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/svgnumberlist/index.md | ---
title: SVGNumberList
slug: Web/API/SVGNumberList
page-type: web-api-interface
browser-compat: api.SVGNumberList
---
{{APIRef("SVG")}}
## SVG number list interface
The `SVGNumberList` defines a list of {{ domxref("SVGNumber") }} objects.
An `SVGNumberList` object can be designated as read only, which means that attempts to modify the object will result in an exception being thrown.
An `SVGNumberList` is indexable and can be accessed like an array.
### Interface overview
<table class="standard-table">
<tbody>
<tr>
<th scope="row">Also implement</th>
<td>None</td>
</tr>
<tr>
<th scope="row">Methods</th>
<td>
<ul>
<li><code>void clear()</code></li>
<li>
{{ domxref("SVGNumber") }}
<code
>initialize(in {{ domxref("SVGNumber") }}
<var>newItem</var>)</code
>
</li>
<li>
{{ domxref("SVGNumber") }}
<code>getItem(in unsigned long <var>index</var>)</code>
</li>
<li>
{{ domxref("SVGNumber") }}
<code
>insertItemBefore(in {{ domxref("SVGNumber") }}
<var>newItem</var>, in unsigned long <var>index</var>)</code
>
</li>
<li>
{{ domxref("SVGNumber") }}
<code
>replaceItem(in {{ domxref("SVGNumber") }}
<var>newItem</var>, in unsigned long <var>index</var>)</code
>
</li>
<li>
{{ domxref("SVGNumber") }}
<code>removeItem(in unsigned long <var>index</var>)</code>
</li>
<li>
{{ domxref("SVGNumber") }}
<code
>appendItem(in {{ domxref("SVGNumber") }}
<var>newItem</var>)</code
>
</li>
</ul>
</td>
</tr>
<tr>
<th scope="row">Properties</th>
<td>
<ul>
<li>readonly unsigned long <code>numberOfItems</code></li>
<li>
readonly unsigned long
<code>length</code> {{ non-standard_inline() }}
</li>
</ul>
</td>
</tr>
<tr>
<th scope="row">Normative document</th>
<td>
<a href="https://www.w3.org/TR/SVG/types.html#InterfaceSVGNumberList"
>SVG 1.1 (2nd Edition)</a
>
</td>
</tr>
</tbody>
</table>
## Instance properties
| Name | Type | Description |
| ------------------------------------ | ------------- | -------------------------------- |
| `numberOfItems` | unsigned long | The number of items in the list. |
| `length` {{ non-standard_inline() }} | unsigned long | The number of items in the list. |
## Instance methods
<table class="standard-table">
<thead>
<tr>
<th>Name & Arguments</th>
<th>Return</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>
<code><strong>clear</strong>()</code>
</td>
<td><var>void</var></td>
<td>
<p>
Clears all existing current items from the list, with the result being
an empty list.
</p>
<p><strong>Exceptions:</strong></p>
<ul>
<li>
a {{ domxref("DOMException") }} with code
<code>NO_MODIFICATION_ALLOWED_ERR</code> is raised when the list
corresponds to a read only attribute or when the object itself is
read only.
</li>
</ul>
</td>
</tr>
<tr>
<td>
<code
><strong>initialize</strong>(in {{ domxref("SVGNumber") }}
<var>newItem</var>)</code
>
</td>
<td>{{ domxref("SVGNumber") }}</td>
<td>
<p>
Clears all existing current items from the list and re-initializes the
list to hold the single item specified by
<code><var>newItem</var></code
>. If the inserted item is already in a list, it is removed from its
previous list before it is inserted into this list. The inserted item
is the item itself and not a copy. The return value is the item
inserted into the list.
</p>
<p><strong>Exceptions:</strong></p>
<ul>
<li>
a {{ domxref("DOMException") }} with code
<code>NO_MODIFICATION_ALLOWED_ERR</code> is raised when the list
corresponds to a read only attribute or when the object itself is
read only.
</li>
</ul>
</td>
</tr>
<tr>
<td>
<code><strong>getItem</strong>(in unsigned long <var>index</var>)</code>
</td>
<td>{{ domxref("SVGNumber") }}</td>
<td>
<p>
Returns the specified item from the list. The returned item is the
item itself and not a copy. Any changes made to the item are
immediately reflected in the list. The first item is
number <code>0</code>.
</p>
<p><strong>Exceptions:</strong></p>
<ul>
<li>
a {{ domxref("DOMException") }} with code
<code>NO_MODIFICATION_ALLOWED_ERR</code> is raised when the list
corresponds to a read only attribute or when the object itself is
read only.
</li>
</ul>
</td>
</tr>
<tr>
<td>
<code
><strong>insertItemBefore</strong>(in
{{ domxref("SVGNumber") }} <var>newItem</var>, in unsigned
long <var>index</var>)</code
>
</td>
<td>{{ domxref("SVGNumber") }}</td>
<td>
<p>
Inserts a new item into the list at the specified position. The first
item is number <code>0</code>.
</p>
<p>
If <code><var>newItem</var></code> is already in a list, it is removed
from its previous list before it is inserted into this list. The
inserted item is the item itself and not a copy. If the item is
already in this list, note that the index of the item to insert before
is before the removal of the item.
</p>
<p>
If the <code><var>index</var></code> is equal to <code>0</code>, then
the new item is inserted at the front of the list. If the index is
greater than or equal to <code>numberOfItems</code>, then the new item
is appended to the end of the list.
</p>
<p><strong>Exceptions:</strong></p>
<ul>
<li>
a {{ domxref("DOMException") }} with code
<code>NO_MODIFICATION_ALLOWED_ERR</code> is raised when the list
corresponds to a read only attribute or when the object itself is
read only.
</li>
</ul>
</td>
</tr>
<tr>
<td>
<code
><strong>replaceItem</strong>(in {{ domxref("SVGNumber") }}
<var>newItem</var>, in unsigned long <var>index</var>)</code
>
</td>
<td>{{ domxref("SVGNumber") }}</td>
<td>
<p>
Replaces an existing item in the list with a new item. If
<code><var>newItem</var></code> is already in a list, it is removed
from its previous list before it is inserted into this list. The
inserted item is the item itself and not a copy. If the item is
already in this list, note that the index of the item to replace is
before the removal of the item.
</p>
<p><strong>Exceptions:</strong></p>
<ul>
<li>
a {{ domxref("DOMException") }} with code
<code>NO_MODIFICATION_ALLOWED_ERR</code> is raised when the list
corresponds to a read only attribute or when the object itself is
read only.
</li>
<li>
a {{ domxref("DOMException") }} with code
<code>INDEX_SIZE_ERR</code> is raised if
<code><var>index</var></code
> is greater than or equal to <code>numberOfItems</code>.
</li>
</ul>
</td>
</tr>
<tr>
<td>
<code
><strong>removeItem</strong>(in unsigned long <var>index</var>)</code
>
</td>
<td>{{ domxref("SVGNumber") }}</td>
<td>
<p>Removes an existing item from the list.</p>
<p><strong>Exceptions:</strong></p>
<ul>
<li>
a {{ domxref("DOMException") }} with code
<code>NO_MODIFICATION_ALLOWED_ERR</code> is raised when the list
corresponds to a read only attribute or when the object itself is
read only.
</li>
<li>
a {{ domxref("DOMException") }} with code
<code>INDEX_SIZE_ERR</code> is raised if
<code><var>index</var></code
> is greater than or equal to <code>numberOfItems</code>.
</li>
</ul>
</td>
</tr>
<tr>
<td>
<code
><strong>appendItem</strong>(in {{ domxref("SVGNumber") }}
<var>newItem</var>)</code
>
</td>
<td>{{ domxref("SVGNumber") }}</td>
<td>
<p>
Inserts a new item at the end of the list. If
<code><var>newItem</var></code> is already in a list, it is removed
from its previous list before it is inserted into this list. The
inserted item is the item itself and not a copy.
</p>
<p><strong>Exceptions:</strong></p>
<ul>
<li>
a {{ domxref("DOMException") }} with code
<code>NO_MODIFICATION_ALLOWED_ERR</code> is raised when the list
corresponds to a read only attribute or when the object itself is
read only.
</li>
</ul>
</td>
</tr>
</tbody>
</table>
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/securepaymentconfirmationrequest/index.md | ---
title: SecurePaymentConfirmationRequest
slug: Web/API/SecurePaymentConfirmationRequest
page-type: web-api-interface
spec-urls: https://w3c.github.io/secure-payment-confirmation/#sctn-securepaymentconfirmationrequest-dictionary
---
{{APIRef("Payment Request API")}}
The **`SecurePaymentConfirmationRequest`** dictionary describes input to the [Payment Request API](/en-US/docs/Web/API/Payment_Request_API) when used to authenticate a user during an e-commerce transaction [using SPC with Payment Request API](/en-US/docs/Web/API/Payment_Request_API/Using_secure_payment_confirmation).
An instance of this dictionary must be passed into the {{domxref("PaymentRequest.PaymentRequest()", "PaymentRequest()")}} constructor as the value of the [`data`](/en-US/docs/Web/API/PaymentRequest/PaymentRequest#data) field corresponding to a [`supportedMethods`](/en-US/docs/Web/API/PaymentRequest/PaymentRequest#supportedmethods) value of `"secure-payment-confirmation"`.
## Instance properties
- `challenge`
- : An {{jsxref("ArrayBuffer")}}, {{jsxref("TypedArray")}}, or {{jsxref("DataView")}} provided by the relying party's server and used as a [cryptographic challenge](https://en.wikipedia.org/wiki/Challenge%E2%80%93response_authentication). This value will be signed by the authenticator and the signature will be sent back as part of {{domxref("AuthenticatorAttestationResponse.attestationObject")}}. This helps prevent replay attacks.
- `credentialIds`
- : A list of {{jsxref("ArrayBuffer")}}, {{jsxref("TypedArray")}}, or {{jsxref("DataView")}}. These [Credential IDs](https://www.w3.org/TR/webauthn-2/#credential-id) represent Web Authentication credentials that have been registered with the relying party for authenticating during a payment with the associated `instrument`.
- `extensions` {{optional_inline}}
- : Any [WebAuthn extensions](/en-US/docs/Web/API/Web_Authentication_API/WebAuthn_extensions) that should be used for the passed credential(s). The caller does not need to specify the [`payment` extension](/en-US/docs/Web/API/Web_Authentication_API/WebAuthn_extensions#payment); this is added automatically.
- `instrument`
- : The description of the instrument name and icon to display during registration and to be signed along with the transaction details. This is an object with the following properties:
- `displayName`
- : A string containing the payment instrument's name, which will be displayed to the user.
- `icon`
- : A string containing the URL of the payment instrument's icon.
- `iconMustBeShown` {{optional_inline}}
- : A boolean value indicating whether the icon must be successfully fetched and shown for the request to succeed. Defaults to `true`.
- `locale` {{optional_inline}}
- : An optional list of well-formed {{RFC(5646, "Tags for Identifying Languages (also known as BCP 47)")}} language tags, in descending order of priority, that identify the local preferences of the website. That is, this represents a language priority list {{RFC(4647, "Matching of Language Tags")}}, which the user agent can use to perform [language negotiation](/en-US/docs/Web/HTTP/Content_negotiation) and locale-affected formatting with the caller.
> **Note:** The locale is distinct from language or direction metadata associated with specific input members, in that it represents the caller's requested localized experience rather than assertion about a specific string value. See [SPC internationalization Considerations](https://w3c.github.io/secure-payment-confirmation/#sctn-i18n-considerations) for more discussion.
- `payeeName` {{optional_inline}}
- : A string that serves as the display name of the payee that this SPC call is for (e.g., the merchant). Optional, may be provided alongside or instead of `payeeOrigin`.
- `payeeOrigin` {{optional_inline}}
- : A string that is the origin of the payee that this SPC call is for (e.g., the merchant). Optional, may be provided alongside or instead of `payeeName`.
- `rpId`
- : A string that specifies the relying party's identifier (for example "login.example.org").
- `showOptOut` {{optional_inline}}
- : A boolean indicating whether the user should be given a chance to opt-out during the [transaction dialog UX](/en-US/docs/Web/API/Payment_Request_API/Using_secure_payment_confirmation#authenticating_a_payment). Defaults to `false`.
- `timeout` {{optional_inline}}
- : The number of milliseconds before the request to sign the transaction details times out. At most 1 hour.
## Specifications
{{Specifications}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/push_api/index.md | ---
title: Push API
slug: Web/API/Push_API
page-type: web-api-overview
browser-compat:
- api.PushEvent
- api.PushMessageData
---
{{DefaultAPISidebar("Push API")}}
The **Push API** gives web applications the ability to receive messages pushed to them from a server, whether or not the web app is in the foreground, or even currently loaded, on a user agent. This lets developers deliver asynchronous notifications and updates to users that opt in, resulting in better engagement with timely new content.
## Push concepts and usage
> **Warning:** When implementing PushManager subscriptions, it is vitally important that you protect against CSRF/XSRF issues in your app. See the following articles for more information:
>
> - [Cross-Site Request Forgery (CSRF) Prevention Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Cross-Site_Request_Forgery_Prevention_Cheat_Sheet.html)
> - [Preventing CSRF and XSRF Attacks](https://blog.codinghorror.com/preventing-csrf-and-xsrf-attacks/)
For an app to receive push messages, it has to have an active [service worker](/en-US/docs/Web/API/Service_Worker_API). When the service worker is active, it can subscribe to push notifications, using {{domxref("PushManager.subscribe()")}}.
The resulting {{domxref("PushSubscription")}} includes all the information that the application needs to send a push message: an endpoint and the encryption key needed for sending data.
The service worker will be started as necessary to handle incoming push messages, which are delivered to the {{domxref("ServiceWorkerGlobalScope.push_event", "onpush")}} event handler. This allows apps to react to push messages being received, for example, by displaying a notification (using {{domxref("ServiceWorkerRegistration.showNotification()")}}.)
Each subscription is unique to a service worker. The endpoint for the subscription is a unique [capability URL](https://www.w3.org/TR/capability-urls/): knowledge of the endpoint is all that is necessary to send a message to your application. The endpoint URL therefore needs to be kept secret, or other applications might be able to send push messages to your application.
Activating a service worker to deliver a push message can result in increased resource usage, particularly of the battery. Different browsers have different schemes for handling this, there is currently no standard mechanism. Firefox allows a limited number (quota) of push messages to be sent to an application, although Push messages that generate notifications are exempt from this limit. The limit is refreshed each time the site is visited. In Chrome there are no limits.
## Interfaces
- {{domxref("PushEvent")}}
- : Represents a push action, sent to the [global scope](/en-US/docs/Web/API/ServiceWorkerGlobalScope) of a {{domxref("ServiceWorker")}}. It contains information sent from an application to a {{domxref("PushSubscription")}}.
- {{domxref("PushManager")}}
- : Provides a way to receive notifications from third-party servers, as well as request URLs for push notifications.
- {{domxref("PushMessageData")}}
- : Provides access to push data sent by a server, and includes methods to manipulate the received data.
- {{domxref("PushSubscription")}}
- : Provides a subscription's URL endpoint, and allows unsubscribing from a push service.
- {{domxref("PushSubscriptionOptions")}}
- : Represents the options associated with the push subscription.
## Service worker additions
The following additions to the [Service Worker API](/en-US/docs/Web/API/Service_Worker_API) have been specified in the Push API spec to provide an entry point for using Push messages. They also monitor and respond to push and subscription change events.
- {{domxref("ServiceWorkerRegistration.pushManager")}} {{ReadOnlyInline}}
- : Returns a reference to the {{domxref("PushManager")}} interface for managing push subscriptions including subscribing, getting an active subscription, and accessing push permission status. This is the entry point into using Push messaging.
- {{domxref("ServiceWorkerGlobalScope.push_event", "onpush")}}
- : An event handler fired whenever a {{domxref("ServiceWorkerGlobalScope/push_event", "push")}} event occurs; that is, whenever a server push message is received.
- {{domxref("ServiceWorkerGlobalScope.pushsubscriptionchange_event", "onpushsubscriptionchange")}}
- : An event handler fired whenever a {{domxref("ServiceWorkerGlobalScope/pushsubscriptionchange_event", "pushsubscriptionchange")}} event occurs; for example, when a push subscription has been invalidated, or is about to be invalidated (e.g. when a push service sets an expiration time.)
## Examples
Mozilla's [ServiceWorker Cookbook](https://github.com/mdn/serviceworker-cookbook) contains many useful Push examples.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Sending VAPID identified WebPush Notifications via Mozilla's Push Service](https://blog.mozilla.org/services/2016/08/23/sending-vapid-identified-webpush-notifications-via-mozillas-push-service/)
- [Push notifications overview](https://web.dev/articles/push-notifications-overview)
- [Service Worker API](/en-US/docs/Web/API/Service_Worker_API)
| 0 |
data/mdn-content/files/en-us/web/api/push_api | data/mdn-content/files/en-us/web/api/push_api/best_practices/index.md | ---
title: Web Push API Notifications best practices
slug: Web/API/Push_API/Best_Practices
page-type: guide
---
{{DefaultAPISidebar("Push API") }}
This article provides a useful summary of best practices to keep in mind when developing websites and applications that use Push Notifications for user engagement.
> "If done well, it's nice to have, but if not done well, it's really annoying." — Overheard conversation between two browser developers discussing the ethics of push notifications.
## Overview of web push notifications
Web Push Notifications (created using a combination of the [Notifications](/en-US/docs/Web/API/Notifications_API), [Push](/en-US/docs/Web/API/Push_API), and [Service Worker](/en-US/docs/Web/API/Service_Worker_API) APIs) are part of the rising noise that product developers and marketers are using to get attention for their sites. Searching the web for "web push notifications," you'll find articles from marketing experts who believe you should use push to re-engage people who have left your site so they can complete a purchase, or be sent the latest news, or receive links to recommended products.
### The dark side
Their novelty provides a new and unexploited opportunity for enterprising sites to reach potential customers. Has the customer switched tabs to answer an email? Win them back with an expiring offer of free shipping that they can't ignore!
But really, is this the best use of push notifications? Or is it a new iteration on the old and tired pop-up ad?
> "Web push doesn't risk ending up in the spam folder. Nor can it be blocked by ad blockers. It shows right up on your desktop even when the website is shut. In mobile, it shows up in the notification tray, just like app push notifications, even when the browser is not running." — an unnamed marketing site
### Positive uses of push
But there's a bright and useful side to push notifications, too. Let's say you and your team commonly use a chat program to communicate, but today you're happily working somewhere, and problem comes up. Say your program manager found a hiccup in the approvals and wants to get your feedback on something before she proceeds.
After a few failed attempts to get your attention, they send you an email, and your email app produces a push notification that successfully alerts you, even though your mail web app is not open.
In this document, we'll talk about the ethical use of web push notifications. Sometimes they can eliminate frustration and annoyance, and sometimes they can cause them, and it's up to you as a developer to make wise recommendations (and decisions) about the use of push notifications.
## What are you hoping to achieve with this push notification?
As with everything, with great power comes great responsibility. Every push notification should be useful and time-sensitive, and the user should always be asked for permission before sending the first one, and be offered an easy way to opt out of getting more in the future.
There are some basic questions you can answer to determine if a push notification is needed:
- Is there someone waiting in real-time for a response? In our above example, the program manager is awaiting your response and so a push notification is appropriate.
- Is up-to-the minute updating necessary? I use a service that aggregates different social media news sources. When a story I'm interested in is trending, I'd like to get a notification!
- Is there breaking news that is timely? This is where it gets a little tricky. Sometimes news sites request push notifications so they can essentially say "Look at me! Look at me!" It all comes down to what the user wants, and you can use behavior to determine intent. For example, if the user views more than one article, or lingers on your page for several minutes, they may be interested in receiving updates.
In addition to the question of whether a push notification is required at all, there are many different types of push notifications, ranging from casual-and-disappearing to persistent-and-requiring-interaction.
We caution you to use the interaction-requiring ones very sparingly, since they can be the most annoying. Your notifications should be assistive, not disruptive.
## Building trust
Some studies have shown that as many as 60% of push notifications are blocked. Allowing your site to push notifications in realtime requires trust. You can build trust by having a well-designed website that provides good content that shows respect for the user, and a clear value to accepting push notifications.
## Browser mitigations
Because of abuses of push notifications in the past, web browser developers have begun to implement strategies to help mitigate this problem. For example, Safari 12.1 now requires—and other browsers either already do, or are planning to do so—that the user interact with the page in some way before the page can request permission to perform push notifications. This at least prevents the user from getting spontaneously asked this question on web pages that they've only glanced at once may rarely if ever look at again.
In the case of Firefox, see [Firefox bug 1524619](https://bugzil.la/1524619), in which we find that Firefox 68 implements this, disabled by default, behind the preference `dom.webnotifications.requireuserinteraction`.
## See also
- [Notifications API](/en-US/docs/Web/API/Notifications_API)
- [Using the Notifications API](/en-US/docs/Web/API/Notifications_API/Using_the_Notifications_API)
- [Push API](/en-US/docs/Web/API/Push_API)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/storage_api/index.md | ---
title: Storage API
slug: Web/API/Storage_API
page-type: web-api-overview
browser-compat: api.StorageManager
---
{{securecontext_header}}{{DefaultAPISidebar("Storage")}}
The [Storage Standard](https://storage.spec.whatwg.org) defines a shared storage system designed to be used by all APIs and technologies that websites can use to store data in a user's browser.
The data stored for a website which is managed by the Storage Standard usually includes [IndexedDB databases](/en-US/docs/Web/API/IndexedDB_API) and [Cache API data](/en-US/docs/Web/API/Cache), but may include other kind of site-accessible data such as [Web Storage API data](/en-US/docs/Web/API/Web_Storage_API).
The Storage API gives websites the ability to find out how much space they can use, how much they are already using, and even control whether or not they need to be alerted before the {{Glossary("user agent")}} disposes of data in order to make room for other things.
This article gives an overview of the way user agents store and maintain websites' data. For more information about storage limits and eviction, see [Browser storage quotas and eviction criteria](/en-US/docs/Web/API/Storage_API/Storage_quotas_and_eviction_criteria).
This article also gives an overview of the {{domxref("StorageManager")}} interface used to estimate available storage for a site.
{{AvailableInWorkers}}
## Concepts and usage
### Storage buckets
The storage system described by the Storage Standard, where site data is stored, usually consists of a single _bucket_ for each {{Glossary("origin")}}.
In essence, every website has its own storage space into which its data gets placed. In some cases however, user agents may decide to store a single origin's data in multiple different buckets, for example when this origin is embedded in different third-party origins.
To learn more, see [How browsers separate data from different websites?](/en-US/docs/Web/API/Storage_API/Storage_quotas_and_eviction_criteria#how_browsers_separate_data_from_different_websites)
### Bucket modes
Each site storage bucket has a _mode_ that describes the data retention policy for that bucket. There are two modes:
- `"best-effort"`
- : The user agent will try to retain the data contained in the bucket for as long as it can, _but will not warn users_ if storage space runs low and it becomes necessary to clear the bucket in order to relieve the storage pressure.
- `"persistent"`
- : The user agent will retain the data as long as possible, clearing all `"best-effort"` buckets before considering clearing a bucket marked `"persistent"`. If it becomes necessary to consider clearing persistent buckets, the user agent will notify the user and provide a way to clear one or more persistent buckets as needed.
You can change an origin's storage bucket mode by using the {{domxref("StorageManager.persist", "navigator.storage.persist()")}} method, which requires the `"persistent-storage"` [user permission](/en-US/docs/Web/API/Permissions_API).
```js
if (navigator.storage && navigator.storage.persist) {
navigator.storage.persist().then((persistent) => {
if (persistent) {
console.log("Storage will not be cleared except by explicit user action");
} else {
console.log("Storage may be cleared by the UA under storage pressure.");
}
});
}
```
You can also use the {{domxref("StorageManager.persisted", "navigator.storage.persisted()")}} method to know whether an origin's storage is persistent or not:
```js
if (navigator.storage && navigator.storage.persist) {
navigator.storage.persisted().then((persistent) => {
if (persistent) {
console.log("Storage will not be cleared except by explicit user action");
} else {
console.log("Storage may be cleared by the UA under storage pressure.");
}
});
}
```
To learn more, see [Does browser-stored data persist?](/en-US/docs/Web/API/Storage_API/Storage_quotas_and_eviction_criteria#does_browser-stored_data_persist).
### Quotas and usage estimates
The user agent determines, using whatever mechanism it chooses, the maximum amount of storage a given site can use. This maximum is the origin's **quota**. The amount of this space which is in use by the site is called its **usage**. Both of these values are estimates; there are several reasons why they're not precise:
- User agents are encouraged to obscure the exact size of the data used by a given origin, to prevent these values from being used for [fingerprinting](/en-US/docs/Glossary/Fingerprinting) purposes.
- De-duplication, compression, and other methods to reduce the physical size of the stored data may be used.
- Quotas are conservative estimates of the space available for the origin's use, and should be less than the available space on the device to help prevent overruns.
To determine the estimated quota and usage values for a given origin, use the {{domxref("StorageManager.estimate", "navigator.storage.estimate()")}} method, which returns a promise that, when resolved, receives an object that contains these figures. For example:
```js
navigator.storage.estimate().then((estimate) => {
// estimate.quota is the estimated quota
// estimate.usage is the estimated number of bytes used
});
```
For more information about how much data an origin can store, see [How much data can be stored?](/en-US/docs/Web/API/Storage_API/Storage_quotas_and_eviction_criteria#how_much_data_can_be_stored).
### Data eviction
Data eviction is the process by which a user agent deletes an origin's stored data. This can happen, for example, when the device used to store the data is running low on storage space.
When clearing the data stored by an origin, the origin's bucket is treated as a single entity. The entire data stored by this origin is cleared.
If a bucket is marked as `"persistent"`, the contents won't be cleared by the user agent without either the data's origin itself or the user specifically doing so. This includes scenarios such as the user selecting a "Clear Caches" or "Clear Recent History" option. The user will be asked specifically for permission to remove persistent site storage buckets.
To learn more, see [When is data evicted?](/en-US/docs/Web/API/Storage_API/Storage_quotas_and_eviction_criteria#when_is_data_evicted).
## Interfaces
- {{domxref("StorageManager")}}
- : Provides an interface for managing persistence permissions and estimating available storage.
### Extensions to other interfaces
- {{domxref("Navigator.storage")}} {{ReadOnlyInline}}
- : Returns the singleton {{domxref("StorageManager")}} object used for managing persistence permissions and estimating available storage on a site-by-site/app-by-app basis.
- {{domxref("WorkerNavigator.storage")}} {{ReadOnlyInline}}
- : Returns a {{domxref("StorageManager")}} interface for managing persistence permissions and estimating available storage.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using the Permissions API](/en-US/docs/Web/API/Permissions_API/Using_the_Permissions_API)
- [Storage for the web on web.dev](https://web.dev/articles/storage-for-the-web)
- [Persistent storage on web.dev](https://web.dev/articles/persistent-storage)
- [Chrome Web Storage and Quota Concepts](https://docs.google.com/document/d/19QemRTdIxYaJ4gkHYf2WWBNPbpuZQDNMpUVf8dQxj4U/edit)
| 0 |
data/mdn-content/files/en-us/web/api/storage_api | data/mdn-content/files/en-us/web/api/storage_api/storage_quotas_and_eviction_criteria/index.md | ---
title: Storage quotas and eviction criteria
slug: Web/API/Storage_API/Storage_quotas_and_eviction_criteria
page-type: guide
---
{{DefaultAPISidebar("Storage")}}
Web developers can use a number of technologies to store data in the user's browser (i.e., on the local disk of the device the user is using to view the website).
The amount of data browsers allow websites to store and the mechanisms they use to delete data when that limit is reached differs between browsers.
This article describes the web technologies that can be used to store data, the quotas that browsers have in place to limit websites from storing too much data, and the mechanisms they use to delete data when needed.
## How do browsers separate data from different websites?
Browsers store the data from websites in different places, also called buckets, to reduce the risk of users being tracked across the web. In most cases, browsers manage stored data _per origin_.
The term _{{Glossary("origin")}}_ is therefore important to understand this article. An origin is defined by a scheme (such as HTTPS), a hostname, and a port. For example, `https://example.com` and `https://example.com/app/index.html` belong to the same origin because they have the same scheme (`https`), hostname (`example.com`), and default port.
The quotas and eviction criteria described in this article apply to an entire origin, even if this origin is used to run several websites, such as `https://example.com/site1/` and `https://example.com/site2/`.
In some cases, however, browsers can decide to further separate the data stored by an origin in different partitions, for example in cases where an origin is loaded within an {{HTMLElement('iframe')}} element in multiple different third-party origins. However, for simplicity reasons, this article assumes that data is always stored per origin.
## What technologies store data in the browser?
Web developers can use the following web technologies to store data in the browser:
| Technology | Description |
| --------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Cookies](/en-US/docs/Web/HTTP/Cookies) | An HTTP cookie is a small piece of data that the web server and browser send each other to remember stateful information across page navigation. |
| [Web Storage](/en-US/docs/Web/API/Web_Storage_API) | The Web Storage API provides mechanisms for webpages to store string-only key/value pairs, including [`localStorage`](/en-US/docs/Web/API/Window/localStorage) and [`sessionStorage`](/en-US/docs/Web/API/Window/sessionStorage). |
| [IndexedDB](/en-US/docs/Web/API/IndexedDB_API) | IndexedDB is a Web API for storing large data structures in the browser and indexing them for high-performance searching. |
| [Cache API](/en-US/docs/Web/API/Cache) | The Cache API provides a persistent storage mechanism for HTTP request and response object pairs that's used to make webpages load faster. |
| [Origin Private File System (OPFS)](/en-US/docs/Web/API/File_System_API/Origin_private_file_system) | OPFS provides a file system that's private to the origin of the page and can be used to read and write directories and files. |
Note that, in addition to the above, browsers will store other types of data in the browser for an origin, such as [WebAssembly](/en-US/docs/WebAssembly) code caching.
## Does browser-stored data persist?
Data for an origin can be stored in two ways in a browser, _persistent_ and _best-effort_:
- Best-effort: this is the way that data is stored by default. Best-effort data persists as long as the origin is below its quota, the device has enough storage space, and the user doesn't choose to delete the data via their browser's settings.
- Persistent: an origin can opt-in to store its data in a persistent way. Data stored this way is only evicted, or deleted, if the user chooses to, by using their browser's settings. To learn more, see [When is data evicted](#when_is_data_evicted).
The data stored in the browser by an origin is best-effort by default. When using web technologies such as IndexedDB or Cache, the data is stored transparently without asking for the user's permission. Similarly, when the browser needs to evict best-effort data, it does so without interrupting the user.
If, for any reason, developers need persistent storage (e.g., when building a web app that relies on critical data that isn't persisted anywhere else), they can do so by using the {{domxref("StorageManager.persist()", "navigator.storage.persist()")}} method of the {{domxref("Storage_API", "Storage API", "", "nocode")}}.
In Firefox, when a site chooses to use persistent storage, the user is notified with a UI popup that their permission is requested.
Safari and most Chromium-based browsers, such as Chrome or Edge, automatically approve or deny the request based on the user's history of interaction with the site and do not show any prompts to the user.
Note that [research from the Chrome team](https://web.dev/articles/persistent-storage) shows that data is very rarely deleted by the browser. If a user visits a website regularly, there is very little chance that its stored data, even in best-effort mode, will get evicted by the browser.
### Private browsing
Note that in private browsing mode (also called _Incognito_ in Chrome, and _InPrivate_ in Edge), browsers may apply different quotas, and stored data is usually deleted when the private browsing mode ends.
## How much data can be stored?
### Cookies
Different browsers have different rules around how many cookies are allowed per origin and how much space these cookies can use on the disk. While cookies are useful for preserving some small shared state between the browser and the web server across page navigation, using cookies for storing data in the browser is not advised. Cookies are sent with each and every HTTP request, so storing data in cookies that could be stored by using another web technology unnecessarily increases the size of requests.
Because cookies should not be used for storing data in the browser, cookie storage browser limits are not covered here.
### Web Storage
Web Storage, which can be accessed by using the {{domxref("Window.localStorage", "localStorage")}} and {{domxref("Window.sessionStorage", "sessionStorage")}} properties of the {{domxref("window")}} object, is limited to 10 MiB of data maximum on all browsers.
Browsers can store up to 5 MiB of local storage, and 5 MiB of session storage per origin.
Once this limit is reached, browsers throw a `QuotaExceededError` exception which should be handled by using a {{jsxref("Statements/try...catch","try...catch")}} block.
### Other web technologies
The data that's stored by using other web technologies, such as IndexedDB, Cache API, or File System API (which defines the Origin Private File System), is managed by a storage management system that's specific to each browser.
This system regulates all of the data that an origin stores using these APIs.
Each browser determines, using whatever mechanism it chooses, the maximum amount of storage a given origin can use.
#### Firefox
In Firefox, the maximum storage space an origin can use in best-effort mode is whichever is the smaller of:
- 10% of the total disk size where the profile of the user is stored.
- Or 10 GiB, which is the _group limit_ that Firefox applies to all origins that are part of the same {{Glossary("eTLD", "eTLD+1 domain")}}.
Origins for which persistent storage has been granted can store up to 50% of the total disk size, capped at 8 TiB, and are not subject to the eTLD+1 group limit.
For example, if the device has a 500 GiB hard drive, Firefox will allow an origin to store up to:
- In best-effort mode: 10 GiB of data, which is the eTLD+1 group limit.
- In persistent mode: 250 GiB, which is 50% of the total disk size.
Note that it might not actually be possible for the origin to reach its quota because it is calculated based on the hard drive **total** size, not the currently available disk space. This is done for security reasons, to avoid {{Glossary("fingerprinting")}}.
#### Chrome and Chromium-based browsers
In browsers based on the [Chromium open-source project](https://www.chromium.org/Home/), including Chrome and Edge, an origin can store up to 60% of the total disk size in both persistent and best-effort modes.
For example, if the device has a 1 TiB hard drive, the browser will allow an origin to use up to 600 GiB.
Like with Firefox, because this quota is calculated based on the hard drive total size to avoid fingerprinting, an origin might not actually be able to reach its quota.
#### Safari
Starting with macOS 14 and iOS 17, Safari allots up to around 20% of the total disk space for each origin. If the user has saved it as a web app on the Home Screen or the Dock, this limit is increased to up to 60% of the disk size. For privacy reasons, {{Glossary("Same-origin policy", "cross-origin")}} frames have a separate quota, amounting to roughly 1/10 of their parents.
For instance, a macOS device with a 1 TiB drive will limit each origin to around 200 GiB. If the user stores a web app on its Dock, that will be alloted a greater limit of around 600 GiB.
Like other browsers, the exact limits enforced by the quota may vary as to avoid fingerprinting. Additionally, Safari also enforces an overall quota that stored data across all origins cannot grow beyond: 80% of disk size for each browser and web app, and 15% of disk size for each non-browser app that displays web content. More info on Safari's storage policies can be found on the [Webkit blog](https://www.webkit.org/blog/14403/updates-to-storage-policy/).
In earlier versions of Safari, an origin is given an initial 1 GiB quota. Once the origin reaches this limit, Safari asks the user for permission to let the origin store more data. This happens whether the origin stores data in best-effort mode or persistent mode.
## How to check the available space?
Web developers can check how much space is available for their origin and how much is being used by the origin with the {{domxref("StorageManager.estimate()", "navigator.storage.estimate()")}} method of the {{domxref("Storage_API", "Storage API", "", "nocode")}}.
Note that this method only returns the estimated usage value, not the actual value. Some of the resources that are stored by an origin may be coming from other origins and browsers voluntarily pad the size of the cross-origin data when reporting total usage value.
## What happens when an origin fills its quota?
Attempting to store more than an origin's quota using IndexedDB, Cache, or OPFS, for example, fails with a `QuotaExceededError` exception.
Web developers should wrap JavaScript that writes to browser storage within {{jsxref("Statements/try...catch","try...catch")}} blocks. Freeing up space by deleting data before storing new data is also recommended.
## When is data evicted?
Data eviction is the process by which a browser deletes an origin's stored data.
Data eviction can happen in multiple cases:
- When the device is running low on storage space, also known as _storage pressure_.
- When all of the data stored in the browser (across all origins) exceeds the total amount of space the browser is willing to use on the device.
- Proactively, for origins that aren't used regularly, which happens only in Safari.
### Storage pressure eviction
When a device is running low on storage space, also known as _storage pressure_, there may come a point when the browser has less available space than it needs to store all of the origin's stored data.
Browsers use a Least Recently Used (LRU) policy to deal with this scenario. The data from the least recently used origin is deleted. If storage pressure continues, the browser moves on to the second least recently used origin, and so on, until the problem is resolved.
This eviction mechanism only applies to origins that are not persistent and skips over origins that have been granted data persistence by using {{domxref("StorageManager.persist()", "navigator.storage.persist()")}}.
### Browser maximum storage exceeded eviction
Some browsers define a maximum storage space that they can use on the device's hard disk. For example, Chrome currently uses at most 80% of the total disk size.
This maximum storage size means that there may come a point at which the data stored by all of the combined origins exceeds the maximum size without any one origin being above its individual quota.
When this happens, the browser starts evicting best-effort origins as described in [Storage pressure eviction](#storage_pressure_eviction).
### Proactive eviction
Safari proactively evicts data when cross-site tracking prevention is turned on. If an origin has no user interaction, such as click or tap, in the last seven days of browser use, its data created from script will be deleted. Cookies set by server are exempt from this eviction.
## How is data evicted?
When an origin's data is evicted by the browser, all of its data, not parts of it, is deleted at the same time. If the origin had stored data by using IndexedDB and the Cache API for example, then both types of data are deleted.
Only deleting some of the origin's data could cause inconsistency problems.
## See also
- [Storage for the web on web.dev](https://web.dev/articles/storage-for-the-web)
- [Persistent storage on web.dev](https://web.dev/articles/persistent-storage)
- [Chrome Web Storage and Quota Concepts](https://docs.google.com/document/d/19QemRTdIxYaJ4gkHYf2WWBNPbpuZQDNMpUVf8dQxj4U/edit)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/audiolistener/index.md | ---
title: AudioListener
slug: Web/API/AudioListener
page-type: web-api-interface
browser-compat: api.AudioListener
---
{{ APIRef("Web Audio API") }}
The `AudioListener` interface represents the position and orientation of the unique person listening to the audio scene, and is used in [audio spatialization](/en-US/docs/Web/API/Web_Audio_API/Web_audio_spatialization_basics). All {{domxref("PannerNode")}}s spatialize in relation to the `AudioListener` stored in the {{domxref("BaseAudioContext.listener")}} attribute.
It is important to note that there is only one listener per context and that it isn't an {{domxref("AudioNode")}}.
## Instance properties
> **Note:** The position, forward, and up value are set and retrieved using different syntaxes. Retrieval is done by accessing, for example, `AudioListener.positionX`, while setting the same property is done with `AudioListener.positionX.value`. This is why these values are not marked read only, which is how they appear in the specification's IDL.
- {{domxref("AudioListener.positionX")}}
- : Represents the horizontal position of the listener in a right-hand cartesian coordinate system. The default is 0.
- {{domxref("AudioListener.positionY")}}
- : Represents the vertical position of the listener in a right-hand cartesian coordinate system. The default is 0.
- {{domxref("AudioListener.positionZ")}}
- : Represents the longitudinal (back and forth) position of the listener in a right-hand cartesian coordinate system. The default is 0.
- {{domxref("AudioListener.forwardX")}}
- : Represents the horizontal position of the listener's forward direction in the same cartesian coordinate system as the position (`positionX`, `positionY`, and `positionZ`) values. The forward and up values are linearly independent of each other. The default is 0.
- {{domxref("AudioListener.forwardY")}}
- : Represents the vertical position of the listener's forward direction in the same cartesian coordinate system as the position (`positionX`, `positionY`, and `positionZ`) values. The forward and up values are linearly independent of each other. The default is 0.
- {{domxref("AudioListener.forwardZ")}}
- : Represents the longitudinal (back and forth) position of the listener's forward direction in the same cartesian coordinate system as the position (`positionX`, `positionY`, and `positionZ`) values. The forward and up values are linearly independent of each other. The default is -1.
- {{domxref("AudioListener.upX")}}
- : Represents the horizontal position of the top of the listener's head in the same cartesian coordinate system as the position (`positionX`, `positionY`, and `positionZ`) values. The forward and up values are linearly independent of each other. The default is 0.
- {{domxref("AudioListener.upY")}}
- : Represents the vertical position of the top of the listener's head in the same cartesian coordinate system as the position (`positionX`, `positionY`, and `positionZ`) values. The forward and up values are linearly independent of each other. The default is 1.
- {{domxref("AudioListener.upZ")}}
- : Represents the longitudinal (back and forth) position of the top of the listener's head in the same cartesian coordinate system as the position (`positionX`, `positionY`, and `positionZ`) values. The forward and up values are linearly independent of each other. The default is 0.
## Instance methods
- {{domxref("AudioListener.setOrientation()")}} {{deprecated_inline}}
- : Sets the orientation of the listener.
- {{domxref("AudioListener.setPosition()")}} {{deprecated_inline}}
- : Sets the position of the listener.
> **Note:** Although these methods are deprecated they are currently the only way to set the orientation and position in Firefox.
## Deprecated features
The `setOrientation()` and `setPosition()` methods have been replaced by setting their property value equivalents. For example `setPosition(x, y, z)` can be achieved by setting `positionX.value`, `positionY.value`, and `positionZ.value` respectively.
## Example
See [`BaseAudioContext.createPanner()`](/en-US/docs/Web/API/BaseAudioContext/createPanner#examples) for example code.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using the Web Audio API](/en-US/docs/Web/API/Web_Audio_API/Using_Web_Audio_API)
| 0 |
data/mdn-content/files/en-us/web/api/audiolistener | data/mdn-content/files/en-us/web/api/audiolistener/setorientation/index.md | ---
title: "AudioListener: setOrientation() method"
short-title: setOrientation()
slug: Web/API/AudioListener/setOrientation
page-type: web-api-instance-method
status:
- deprecated
browser-compat: api.AudioListener.setOrientation
---
{{ APIRef("Web Audio API") }}{{deprecated_header}}
The `setOrientation()` method of the {{ domxref("AudioListener") }} interface defines the orientation of the listener.
It consists of two direction vectors:
- The _front vector_, defined by the three unitless parameters `x`, `y` and `z`, describes the direction of the face of the listener, that is the direction the nose of the person is pointing towards. The front vector's default value is `(0, 0, -1)`.
- The _up vector_, defined by three unitless parameters `xUp`, `yUp` and `zUp`, describes the direction of the top of the listener's head. The up vector's default value is `(0, 1, 0)`.
The two vectors must be separated by an angle of 90° — in linear analysis terms, they must be perpendicular to each other.
## Syntax
```js-nolint
setOrientation(x, y, z, xUp, yUp, zUp)
```
### Parameters
- `x`
- : The x value of the front vector of the listener.
- `y`
- : The y value of the front vector of the listener.
- `z`
- : The z value of the front vector of the listener.
- `xUp`
- : The x value of the up vector of the listener.
- `yUp`
- : The y value of the up vector of the listener.
- `zUp`
- : The z value of the up vector of the listener.
### Return value
None ({{jsxref("undefined")}}).
## Examples
See [`BaseAudioContext.createPanner()`](/en-US/docs/Web/API/BaseAudioContext/createPanner#examples) for example code.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using the Web Audio API](/en-US/docs/Web/API/Web_Audio_API/Using_Web_Audio_API)
| 0 |
data/mdn-content/files/en-us/web/api/audiolistener | data/mdn-content/files/en-us/web/api/audiolistener/forwardy/index.md | ---
title: "AudioListener: forwardY property"
short-title: forwardY
slug: Web/API/AudioListener/forwardY
page-type: web-api-instance-property
browser-compat: api.AudioListener.forwardY
---
{{ APIRef("Web Audio API") }}
The `forwardY` read-only property of the {{ domxref("AudioListener") }} interface is an {{domxref("AudioParam")}} representing the y value of the direction vector defining the forward direction the listener is pointing in.
> **Note:** The parameter is _a-rate_ when used with a {{domxref("PannerNode")}} whose {{domxref("PannerNode.panningModel", "panningModel")}} is set to equalpower, or _k-rate_ otherwise.
## Value
An {{domxref("AudioParam")}}. Its default value is 0, and it can range between positive and negative infinity.
## Examples
See [BaseAudioContext.createPanner()](/en-US/docs/Web/API/BaseAudioContext/createPanner#examples) for example code.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using the Web Audio API](/en-US/docs/Web/API/Web_Audio_API/Using_Web_Audio_API)
| 0 |
data/mdn-content/files/en-us/web/api/audiolistener | data/mdn-content/files/en-us/web/api/audiolistener/forwardz/index.md | ---
title: "AudioListener: forwardZ property"
short-title: forwardZ
slug: Web/API/AudioListener/forwardZ
page-type: web-api-instance-property
browser-compat: api.AudioListener.forwardZ
---
{{ APIRef("Web Audio API") }}
The `forwardZ` read-only property of the {{ domxref("AudioListener") }} interface is an {{domxref("AudioParam")}} representing the z value of the direction vector defining the forward direction the listener is pointing in.
> **Note:** The parameter is _a-rate_ when used with a {{domxref("PannerNode")}} whose {{domxref("PannerNode.panningModel", "panningModel")}} is set to equalpower, or _k-rate_ otherwise.
## Value
An {{domxref("AudioParam")}}. Its default value is -1, and it can range between positive and negative infinity.
## Examples
See [`BaseAudioContext.createPanner()`](/en-US/docs/Web/API/BaseAudioContext/createPanner#examples) for example code.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using the Web Audio API](/en-US/docs/Web/API/Web_Audio_API/Using_Web_Audio_API)
| 0 |
data/mdn-content/files/en-us/web/api/audiolistener | data/mdn-content/files/en-us/web/api/audiolistener/forwardx/index.md | ---
title: "AudioListener: forwardX property"
short-title: forwardX
slug: Web/API/AudioListener/forwardX
page-type: web-api-instance-property
browser-compat: api.AudioListener.forwardX
---
{{ APIRef("Web Audio API") }}
The `forwardX` read-only property of the {{ domxref("AudioListener") }} interface is an {{domxref("AudioParam")}} representing the x value of the direction vector defining the forward direction the listener is pointing in.
> **Note:** The parameter is _a-rate_ when used with a {{domxref("PannerNode")}} whose {{domxref("PannerNode.panningModel", "panningModel")}} is set to equalpower, or _k-rate_ otherwise.
## Value
An {{domxref("AudioParam")}}. Its default value is 0, and it can range between positive and negative infinity.
## Examples
See [`BaseAudioContext.createPanner()`](/en-US/docs/Web/API/BaseAudioContext/createPanner#examples) for example code.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using the Web Audio API](/en-US/docs/Web/API/Web_Audio_API/Using_Web_Audio_API)
| 0 |
data/mdn-content/files/en-us/web/api/audiolistener | data/mdn-content/files/en-us/web/api/audiolistener/setposition/index.md | ---
title: "AudioListener: setPosition() method"
short-title: setPosition()
slug: Web/API/AudioListener/setPosition
page-type: web-api-instance-method
status:
- deprecated
browser-compat: api.AudioListener.setPosition
---
{{ APIRef("Web Audio API") }} {{deprecated_header}}
The `setPosition()` method of the {{ domxref("AudioListener") }} Interface defines the position of the listener.
The three parameters `x`, `y` and `z` are unitless and describe the listener's position in 3D space according to the right-hand Cartesian coordinate system. {{domxref("PannerNode")}} objects use this position relative to individual audio sources for spatialization.
The default value of the position vector is `(0, 0, 0)`.
> **Note:** As this method is deprecated, use the three {{domxref("AudioListener.positionX", "positionX")}}, {{domxref("AudioListener.positionY", "positionY")}}, and {{domxref("AudioListener.positionZ", "positionZ")}} properties instead.
## Syntax
```js-nolint
setPosition(x, y, z)
```
### Parameters
- `x`
- : The x position of the listener in 3D space.
- `y`
- : The y position of the listener in 3D space.
- `z`
- : The z position of the listener in 3D space.
### Return value
None ({{jsxref("undefined")}}).
## Examples
See [`BaseAudioContext.createPanner()`](/en-US/docs/Web/API/BaseAudioContext/createPanner#examples) for example code.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using the Web Audio API](/en-US/docs/Web/API/Web_Audio_API/Using_Web_Audio_API)
| 0 |
data/mdn-content/files/en-us/web/api/audiolistener | data/mdn-content/files/en-us/web/api/audiolistener/positionz/index.md | ---
title: "AudioListener: positionZ property"
short-title: positionZ
slug: Web/API/AudioListener/positionZ
page-type: web-api-instance-property
browser-compat: api.AudioListener.positionZ
---
{{ APIRef("Web Audio API") }}
The `positionZ` read-only property of the {{ domxref("AudioListener") }} interface is an {{domxref("AudioParam")}} representing the z position of the listener in 3D cartesian space.
> **Note:** The parameter is _a-rate_ when used with a {{domxref("PannerNode")}} whose {{domxref("PannerNode.panningModel", "PannerNode")}} is set to equalpower, or _k-rate_ otherwise.
## Value
An {{domxref("AudioParam")}}. Its default value is 0, and it can range between positive and negative infinity.
## Examples
See [`BaseAudioContext.createPanner()`](/en-US/docs/Web/API/BaseAudioContext/createPanner#examples) for example code.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using the Web Audio API](/en-US/docs/Web/API/Web_Audio_API/Using_Web_Audio_API)
| 0 |
data/mdn-content/files/en-us/web/api/audiolistener | data/mdn-content/files/en-us/web/api/audiolistener/upz/index.md | ---
title: "AudioListener: upZ property"
short-title: upZ
slug: Web/API/AudioListener/upZ
page-type: web-api-instance-property
browser-compat: api.AudioListener.upZ
---
{{ APIRef("Web Audio API") }}
The `upZ` read-only property of the {{ domxref("AudioListener") }} interface is an {{domxref("AudioParam")}} representing the z value of the direction vector defining the up direction the listener is pointing in.
> **Note:** The parameter is _a-rate_ when used with a {{domxref("PannerNode")}} whose {{domxref("PannerNode.panningModel", "PannerNode")}} is set to equalpower, or _k-rate_ otherwise.
## Value
An {{domxref("AudioParam")}}. Its default value is 0, and it can range between positive and negative infinity.
## Examples
See [`BaseAudioContext.createPanner()`](/en-US/docs/Web/API/BaseAudioContext/createPanner#examples) for example code.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using the Web Audio API](/en-US/docs/Web/API/Web_Audio_API/Using_Web_Audio_API)
| 0 |
Subsets and Splits