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/videocolorspace | data/mdn-content/files/en-us/web/api/videocolorspace/tojson/index.md | ---
title: "VideoColorSpace: toJSON() method"
short-title: toJSON()
slug: Web/API/VideoColorSpace/toJSON
page-type: web-api-instance-method
browser-compat: api.VideoColorSpace.toJSON
---
{{DefaultAPISidebar("WebCodecs API")}}
The **`toJSON()`** method of the {{domxref("VideoColorSpace")}} interface is a _serializer_ that returns a JSON representation of the `VideoColorSpace` object.
## Syntax
```js-nolint
toJSON()
```
### Parameters
None.
### Return value
A JSON object.
## Examples
In the following example, `colorSpace` is a `VideoColorSpace` object returned from {{domxref("VideoFrame")}}. This object is then printed to the console as JSON.
```js
let colorSpace = VideoFrame.colorSpace;
console.log(colorSpace.toJSON());
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/encodedaudiochunk/index.md | ---
title: EncodedAudioChunk
slug: Web/API/EncodedAudioChunk
page-type: web-api-interface
status:
- experimental
browser-compat: api.EncodedAudioChunk
---
{{APIRef("WebCodecs API")}}{{SeeCompatTable}}
The **`EncodedAudioChunk`** interface of the {{domxref('WebCodecs API','','',' ')}} represents a chunk of encoded audio data.
## Constructor
- {{domxref("EncodedAudioChunk.EncodedAudioChunk", "EncodedAudioChunk()")}} {{Experimental_Inline}}
- : Creates a new `EncodedAudioChunk` object.
## Instance properties
- {{domxref("EncodedAudioChunk.type")}} {{ReadOnlyInline}} {{Experimental_Inline}}
- : Returns a string indicating whether this chunk of data is a key chunk.
- {{domxref("EncodedAudioChunk.timestamp")}} {{ReadOnlyInline}} {{Experimental_Inline}}
- : Returns an integer representing the timestamp of the audio in microseconds.
- {{domxref("EncodedAudioChunk.duration")}} {{ReadOnlyInline}} {{Experimental_Inline}}
- : Returns an integer representing the duration of the audio in microseconds.
- {{domxref("EncodedAudioChunk.byteLength")}} {{ReadOnlyInline}} {{Experimental_Inline}}
- : Returns an integer representing the length of the audio in bytes.
## Instance methods
- {{domxref("EncodedAudioChunk.copyTo()")}} {{Experimental_Inline}}
- : Copies the encoded audio data.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/encodedaudiochunk | data/mdn-content/files/en-us/web/api/encodedaudiochunk/copyto/index.md | ---
title: "EncodedAudioChunk: copyTo() method"
short-title: copyTo()
slug: Web/API/EncodedAudioChunk/copyTo
page-type: web-api-instance-method
status:
- experimental
browser-compat: api.EncodedAudioChunk.copyTo
---
{{APIRef("WebCodecs API")}}{{SeeCompatTable}}
The **`copyTo()`** method of the {{domxref("EncodedAudioChunk")}} interface copies the encoded chunk of audio data.
## Syntax
```js-nolint
copyTo(destination)
```
### Parameters
- `destination`
- : An {{jsxref("ArrayBuffer")}}, a {{jsxref("TypedArray")}}, or a {{jsxref("DataView")}} that the data can be copied to.
### Return value
None ({{jsxref("undefined")}}).
## Examples
In the following example an {{domxref("EncodedAudioChunk")}} is created then copied.
```js
const init = {
type: "key",
data: audioBuffer,
timestamp: 23000000,
duration: 2000000,
};
chunk = EncodedAudioChunk(init);
chunk.copyTo(newBuffer);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/encodedaudiochunk | data/mdn-content/files/en-us/web/api/encodedaudiochunk/encodedaudiochunk/index.md | ---
title: "EncodedAudioChunk: EncodedAudioChunk() constructor"
short-title: EncodedAudioChunk()
slug: Web/API/EncodedAudioChunk/EncodedAudioChunk
page-type: web-api-constructor
status:
- experimental
browser-compat: api.EncodedAudioChunk.EncodedAudioChunk
---
{{APIRef("WebCodecs API")}}{{SeeCompatTable}}
The **`EncodedAudioChunk()`** constructor creates a new {{domxref("EncodedAudioChunk")}} object representing a chunk of encoded audio.
## Syntax
```js-nolint
new EncodedAudioChunk(options)
```
### Parameters
- `options`
- : An object containing the following members:
- `type`
- : Indicates if the chunk is a key chunk that does not rely on other frames for encoding. One of:
- `"key"`
- : The data is a key chunk.
- `"delta"`
- : The data is not a key chunk.
- `timestamp`
- : An integer representing the timestamp of the audio in microseconds.
- `duration`
- : An integer representing the length of the audio in microseconds.
- `data`
- : An {{jsxref("ArrayBuffer")}}, a {{jsxref("TypedArray")}}, or a {{jsxref("DataView")}} containing the audio data.
- `transfer`
- : An array of {{jsxref("ArrayBuffer")}}s that `EncodedAudioChunk` will detach and take ownership of. If the array contains the {{jsxref("ArrayBuffer")}} backing `data`, `EncodedAudioChunk` will use that buffer directly instead of copying from it.
## Examples
In the following example a new `EncodedAudioChunk` is created.
```js
const init = {
type: "key",
data: audioBuffer,
timestamp: 23000000,
duration: 2000000,
transfer: [audioBuffer],
};
chunk = new EncodedAudioChunk(init);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/encodedaudiochunk | data/mdn-content/files/en-us/web/api/encodedaudiochunk/bytelength/index.md | ---
title: "EncodedAudioChunk: byteLength property"
short-title: byteLength
slug: Web/API/EncodedAudioChunk/byteLength
page-type: web-api-instance-property
status:
- experimental
browser-compat: api.EncodedAudioChunk.byteLength
---
{{APIRef("WebCodecs API")}}{{SeeCompatTable}}
The **`byteLength`** read-only property of the {{domxref("EncodedAudioChunk")}} interface returns the length in bytes of the encoded audio data.
## Value
An integer.
## Examples
In the following example the `byteLength` is printed to the console.
```js
const init = {
type: "key",
data: audioBuffer,
timestamp: 23000000,
duration: 2000000,
};
chunk = EncodedAudioChunk(init);
console.log(chunk.byteLength); //352800
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/encodedaudiochunk | data/mdn-content/files/en-us/web/api/encodedaudiochunk/type/index.md | ---
title: "EncodedAudioChunk: type property"
short-title: type
slug: Web/API/EncodedAudioChunk/type
page-type: web-api-instance-property
status:
- experimental
browser-compat: api.EncodedAudioChunk.type
---
{{APIRef("WebCodecs API")}}{{SeeCompatTable}}
The **`type`** read-only property of the {{domxref("EncodedAudioChunk")}} interface returns a value indicating whether the audio chunk is a key chunk, which does not relying on other frames for decoding.
## Value
A string, one of:
- `"key"`
- : The data is a key chunk.
- `"delta"`
- : The data is not a key chunk.
## Examples
In the following example the `type` is printed to the console.
```js
const init = {
type: "key",
data: audioBuffer,
timestamp: 23000000,
duration: 2000000,
};
chunk = EncodedAudioChunk(init);
console.log(chunk.type); //"key"
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/encodedaudiochunk | data/mdn-content/files/en-us/web/api/encodedaudiochunk/timestamp/index.md | ---
title: "EncodedAudioChunk: timestamp property"
short-title: timestamp
slug: Web/API/EncodedAudioChunk/timestamp
page-type: web-api-instance-property
status:
- experimental
browser-compat: api.EncodedAudioChunk.timestamp
---
{{APIRef("WebCodecs API")}}{{SeeCompatTable}}
The **`timestamp`** read-only property of the {{domxref("EncodedAudioChunk")}} interface returns an integer indicating the timestamp of the audio in microseconds.
## Value
An integer.
## Examples
In the following example the `timestamp` is printed to the console.
```js
const init = {
type: "key",
data: audioBuffer,
timestamp: 23000000,
duration: 2000000,
};
chunk = EncodedAudioChunk(init);
console.log(chunk.timestamp); //23000000
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/encodedaudiochunk | data/mdn-content/files/en-us/web/api/encodedaudiochunk/duration/index.md | ---
title: "EncodedAudioChunk: duration property"
short-title: duration
slug: Web/API/EncodedAudioChunk/duration
page-type: web-api-instance-property
status:
- experimental
browser-compat: api.EncodedAudioChunk.duration
---
{{APIRef("WebCodecs API")}}{{SeeCompatTable}}
The **`duration`** read-only property of the {{domxref("EncodedAudioChunk")}} interface returns an integer indicating the duration of the audio in microseconds.
## Value
An integer.
## Examples
In the following example the `duration` is printed to the console.
```js
const init = {
type: "key",
data: audioBuffer,
timestamp: 23000000,
duration: 2000000,
};
chunk = EncodedAudioChunk(init);
console.log(chunk.duration); //2000000
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/taskcontroller/index.md | ---
title: TaskController
slug: Web/API/TaskController
page-type: web-api-interface
browser-compat: api.TaskController
---
{{APIRef("Prioritized Task Scheduling API")}}
The **`TaskController`** interface of the [Prioritized Task Scheduling API](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API) represents a controller object that can be used to both abort and change the [priority](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API#task_priorities) of one or more prioritized tasks.
If there is no need to change task priorities, then {{domxref("AbortController")}} can be used instead.
A new `TaskController` instance is created using the {{domxref("TaskController.TaskController()", "TaskController()")}} constructor, optionally specifying a [priority](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API#task_priorities) for its associated signal (a {{domxref("TaskSignal")}}).
If not specified, the signal will have a priority of [`"user-visible"`](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API#user-visible) by default.
The controller's signal can be passed as an argument to the {{domxref("Scheduler.postTask()")}} method for one or more tasks.
For [mutable tasks](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API#mutable_and_immutable_task_priority) (only) the task is initialized with the signal priority, and can later be changed by calling {{domxref('TaskController.setPriority()')}}.
For immutable tasks, any priority initialized or set by the controller is ignored.
Tasks can be aborted by calling {{domxref("AbortController.abort()","abort()")}} on the controller.
{{InheritanceDiagram}}
## Constructor
- {{domxref("TaskController.TaskController", "TaskController()")}}
- : Creates a new `TaskController` object, optionally specifying the priority of its associated [`signal`](#taskcontroller.signal).
## Instance methods
_This interface also inherits the methods of its parent, {{domxref("AbortController")}}._
- {{domxref('TaskController.setPriority()')}}
- : Sets the priority of the controller's [`signal`](#taskcontroller.signal), and hence the priority of any tasks with which it is associated.
This notifies observers of the priority change by dispatching a [`prioritychange`](/en-US/docs/Web/API/TaskSignal/prioritychange_event) event.
## Instance properties
_This interface also inherits the properties of its parent, {{domxref("AbortController")}}._
- `TaskController.signal` {{ReadOnlyInline}}
- : Returns a {{domxref("TaskSignal")}} object instance.
The signal is passed to tasks so that they can be aborted or re-prioritized by the controller.
The property is inherited from [`AbortController`](/en-US/docs/Web/API/AbortController#abortcontroller.signal).
## Examples
> **Note:** Additional "live" examples can be found in: [Prioritized Task Scheduling API Examples](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API#examples).
First we create a task controller, setting the priority of its associated signal to `user-blocking`.
```js
// Create a TaskController, setting its signal priority to 'user-blocking'
const controller = new TaskController({ priority: "user-blocking" });
```
We then add an event listener for [`prioritychange`](/en-US/docs/Web/API/TaskSignal/prioritychange_event) events (here `addEventListener()` is called, but we could instead assign a handler to `TaskSignal.onprioritychange`).
The handler uses [previousPolicy](/en-US/docs/Web/API/TaskPriorityChangeEvent/previousPriority) on the event to get the original priority and {{domxref("TaskSignal.priority")}} on the event target to get the new priority.
```js
// Listen for 'prioritychange' events on the controller's signal.
controller.signal.addEventListener("prioritychange", (event) => {
const previousPriority = event.previousPriority;
const newPriority = event.target.priority;
console.log(`Priority changed from ${previousPriority} to ${newPriority}.`);
});
```
We can also listen for [`abort`](/en-US/docs/Web/API/AbortSignal/abort_event) events as shown below.
This same approach would be used if the controller was an `AbortController`.
```js
controller.signal.addEventListener("abort", (event) => {
console.log("Task aborted");
});
```
Next we post the task, passing the controller signal in the optional argument.
In this case the task is just an arrow function that resolves the promise by returning some text.
We use `then` and `catch` to handle when the task resolves or is rejected, logging the return text or the error in each case.
Note that in a later code block we abort the task, so only the `catch()` block will actually be run!
```js
// Post task using the controller's signal.
// The signal priority sets the initial priority of the task
scheduler
.postTask(() => "Task execute", { signal: controller.signal })
.then((taskResult) => {
console.log(`${taskResult}`);
}) // Aborted (won't run)
.catch((error) => {
console.log(`Catch error: ${error}`);
}); // Log error
```
We can use the controller to manage the task.
Here we can change the priority using {{domxref('TaskController.setPriority()')}}.
This will trigger the associated `prioritychange` event.
```js
// Change the priority to 'background' using the controller
controller.setPriority("background");
```
Finally, the task can be aborted by calling {{domxref("AbortController.abort()","abort()")}} on the controller.
```js
// Abort the task
controller.abort();
```
The console output of this example would be:
```plain
The priority changed from user-blocking to background.
Task aborted
Catch error: AbortError
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/taskcontroller | data/mdn-content/files/en-us/web/api/taskcontroller/setpriority/index.md | ---
title: "TaskController: setPriority() method"
short-title: setPriority()
slug: Web/API/TaskController/setPriority
page-type: web-api-instance-method
browser-compat: api.TaskController.setPriority
---
{{APIRef("Prioritized Task Scheduling API")}}
The **`setPriority()`** method of the {{domxref("TaskController")}} interface can be called to set a new [priority](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API#task_priorities) for this controller's [`signal`](/en-US/docs/Web/API/TaskController#taskcontroller.signal).
If a prioritized task is [configured](/en-US/docs/Web/API/Scheduler/postTask#signal) to use the signal, this will also change the task priority.
Observers are notified of priority changes by dispatching a [`prioritychange`](/en-US/docs/Web/API/TaskSignal/prioritychange_event) event.
The method will only notify if the priority actually changes (the event is not fired if the priority would not be changed by the call).
Note that task priority can only be changed for [tasks with mutable priorities](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API#mutable_and_immutable_task_priority).
If the task is immutable, the function call is ignored.
## Syntax
```js-nolint
setPriority(priority)
```
### Parameters
- `priority`
- : The [priority](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API#task_priorities) of the task.
One of: [`"user-blocking"`](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API#user-blocking), [`"user-visible"`](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API#user-visible), [`"background"`](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API#background).
### Return Value
None ({{jsxref("undefined")}}).
### Exceptions
- `NotAllowedError` {{domxref("DOMException")}}
- : A priority change has been started when one is already running.
## Examples
First we create a task controller.
In this case we don't specify a priority, so it will default to `user-visible`.
```js
// Create a TaskController with default priority: 'user-visible'
const controller = new TaskController();
```
Then we pass the controller's signal to the [`Scheduler.postTask()`](/en-US/docs/Web/API/Scheduler/postTask#signal) method.
```js
// Post task passing the controller's signal.
// The signal priority sets the initial priority of the task
scheduler
.postTask(() => "Task execute", { signal: controller.signal })
.then((taskResult) => {
console.log(`${taskResult}`);
}) // Run on success)
.catch((error) => {
console.log(`Catch error: ${error}`);
}); // Run on fail
```
The controller can then be used to change the priority
```js
// Change the priority to 'background' using the controller
controller.setPriority("background");
```
Additional examples, including showing how to handle the event that results from changing the priority, can be found in: [Prioritized Task Scheduling API > Examples](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API#examples).
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/taskcontroller | data/mdn-content/files/en-us/web/api/taskcontroller/taskcontroller/index.md | ---
title: "TaskController: TaskController() constructor"
short-title: TaskController()
slug: Web/API/TaskController/TaskController
page-type: web-api-constructor
browser-compat: api.TaskController.TaskController
---
{{APIRef("Prioritized Task Scheduling API")}}
The **`TaskController()`** constructor creates a new {{domxref("TaskController")}} object, optionally setting the initial [priority](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API#task_priorities) of its associated [`signal`](/en-US/docs/Web/API/TaskController#taskcontroller.signal).
If no priority is set, the signal priority defaults to [`user-visible`](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API#user-visible)
## Syntax
```js-nolint
new TaskController()
new TaskController(options)
```
### Parameters
- `options` {{optional_inline}}
- : An object with the following properties:
- `priority` {{optional_inline}}
- : The [priority](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API#task_priorities) of the signal associated with this `TaskController`.
One of: `"user-blocking"`, `"user-visible"` (default), `"background"`.
## Examples
This code shows how to construct a task controller that has a signal with default priority (`user-visible`).
```js
const controller = new TaskController();
```
To construct a task controller that has a specific signal priority, pass the `priority` as a property of the optional argument.
```js
controller2 = new TaskController({ priority: "user-blocking" });
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/directoryentrysync/index.md | ---
title: DirectoryEntrySync
slug: Web/API/DirectoryEntrySync
page-type: web-api-interface
status:
- deprecated
- non-standard
browser-compat: api.DirectoryEntrySync
---
{{APIRef("File and Directory Entries API")}}{{Non-standard_Header}}{{Deprecated_Header}}
The `DirectoryEntrySync` interface represents a directory in a file system. It includes methods for creating, reading, looking up, and recursively removing files in a directory.
> **Warning:** This interface is deprecated and is no more on the standard track.
> _Do not use it anymore._ Use the [File and Directory Entries API](/en-US/docs/Web/API/File_and_Directory_Entries_API) instead.
## Basic concepts
If you want to create subdirectories, you have to create each child directory in sequence. If you try to create a directory using a full path that includes parent directories that do not exist yet, you get an error. So create the hierarchy by recursively adding a new path after creating the parent directory.
### Example
The `getFile()` method returns a `FileEntrySync`, which represents a file in the file system. The following creates an empty file called `logs.txt` in the root directory.
```js
const fileEntry = fs.root.getFile("logs.txt", { create: true });
```
The `getDirectory()` method returns a `DirectoryEntrySync`, which represents a file in the file system. The following creates a new directory called `project_dir` in the root directory.
```js
const dirEntry = fs.root.getDirectory("project_dir", { create: true });
```
## Method overview
- <a href="#createreader">createReader()</a>
- <a href="#getfile">getFile()</a>
- <a href="#getdirectory">getDirectory()</a>
- <a href="#removerecursively">removeRecursively()</a>
## Instance methods
### createReader()
Creates a new `DirectoryReaderSync` to read entries from this directory.
#### Syntax
```js
createReader();
```
##### Returns
- [`DirectoryReaderSync`](/en-US/docs/Web/API/DirectoryReaderSync)
- : Represents a directory in a file system.
##### Parameter
None
##### Exceptions
This method can raise a {{domxref("DOMException")}} with the following codes:
| Exception | Description |
| --------------- | ------------------------------------------------------------------------------------------ |
| `NOT_FOUND_ERR` | The directory does not exist. |
| `SECURITY_ERR` | The browser determined that it was not safe to look up the metadata. [ todo: Explain why ] |
### getFile()
Depending on how you've set the `options` parameter, the method either creates a file or looks up an existing file.
#### Syntax
```js-nolint
getFile(path)
getFile(path, options)
```
##### Parameter
- `path`
- : Either an absolute path or a relative path from the directory to the file to be looked up or created. You cannot create a file whose immediate parent does not exist. Create the parent directory first.
- `options`
- : (optional) An object literal describing the behavior of the method. If the file does not exist, it is created.
<table class="no-markdown">
<thead>
<tr>
<th scope="col">Object literal</th>
<th scope="col">Condition</th>
<th scope="col">Result</th>
</tr>
<tr>
<td><code>create: true</code><br /><code>exclusive: true</code></td>
<td>Path already exists</td>
<td>An error is thrown.</td>
</tr>
</thead>
<tbody>
<tr>
<td><code>create: true</code><br /><code>exclusive: false</code></td>
<td>Path doesn't exist and no other error occurs</td>
<td>A file is created. If a file already exists, no error is thrown.</td>
</tr>
<tr>
<td>
<code>create: false</code><br />(<code>exclusive</code> is ignored)
</td>
<td>Path exists</td>
<td>The file is returned.</td>
</tr>
<tr>
<td>
<code>create: false</code><br />(<code>exclusive</code> is ignored)
</td>
<td>Path doesn't exist</td>
<td>An error is thrown.</td>
</tr>
<tr>
<td>
<code>create: false</code><br />(<code>exclusive</code> is ignored)
</td>
<td>Path exists, but is a directory</td>
<td>An error is thrown.</td>
</tr>
</tbody>
</table>
##### Returns
- [`FileEntrySync`](/en-US/docs/Web/API/FileEntrySync)
- : Represents a file in a file system.
##### Exceptions
This method can raise a {{domxref("DOMException")}} with the following codes:
| Exception | Description |
| ----------------------------- | --------------------------------------------------------------------------------------------------------- |
| `ENCODING_ERR` | The path supplied is invalid. |
| `NOT_FOUND_ERR` | The path was structurally correct, but refers to a resource that does not exist. |
| `NO_MODIFICATION_ALLOWED_ERR` | This is a permission issue. The target directory or file is not writable. |
| `PATH_EXISTS_ERR` | The file already exists. You cannot create another one with the same path. |
| `QUOTA_EXCEEDED_ERROR` | The operation would cause the application to exceed its storage quota. |
| `SECURITY_ERR` | The application does not have permission to access the element referred to by path. [ todo: Explain why ] |
| `TYPE_MISMATCH_ERR` | The path supplied exists, but it is not a directory. |
### getDirectory()
Creates or looks up a directory. The method is similar to `getFile()` with DirectoryEntrySync being passed.
#### Syntax
```js-nolint
getDirectory(path)
getDirectory(path, options)
```
##### Parameter
- `path`
- : Either an absolute path or a relative path from the directory to the file to be looked up or created. You cannot create a file whose immediate parent does not exist. Create the parent directory first.
- `options`
- : (optional) An object literal describing the behavior of the method if the file does not exist.
<table class="no-markdown">
<thead>
<tr>
<th scope="col">Object literal</th>
<th scope="col">Condition</th>
<th scope="col">Result</th>
</tr>
<tr>
<td><code>create: true</code><br /><code>exclusive: true</code></td>
<td>Path already exists</td>
<td>An error is thrown.</td>
</tr>
</thead>
<tbody>
<tr>
<td><code>create: true</code><br /><code>exclusive: false</code></td>
<td>Path doesn't exist and no other error occurs</td>
<td>
A directory is created. If a file already exists, no error is thrown.
</td>
</tr>
<tr>
<td>
<code>create: false</code><br />(<code>exclusive</code> is ignored)
</td>
<td>Path exists</td>
<td>The directory is returned.</td>
</tr>
<tr>
<td>
<code>create: false</code><br />(<code>exclusive</code> is ignored)
</td>
<td>Path doesn't exist</td>
<td>An error is thrown.</td>
</tr>
<tr>
<td>
<code>create: false</code><br />(<code>exclusive</code> is ignored)
</td>
<td>Path exists, but is a directory</td>
<td>An error is thrown.</td>
</tr>
</tbody>
</table>
##### Returns
- [`DirectoryEntrySync`](/en-US/docs/Web/API/DirectoryReaderSync)
- : Represents a directory in a file system.
##### Exceptions
This method can raise a {{domxref("DOMException")}} with the following codes:
| Exception | Description |
| ----------------------------- | --------------------------------------------------------------------------------------------------------- |
| `ENCODING_ERR` | The path supplied is invalid. |
| `NOT_FOUND_ERR` | The path was structurally correct, but refers to a resource that does not exist. |
| `NO_MODIFICATION_ALLOWED_ERR` | This is a permission issue. The target directory or file is not writable. |
| `PATH_EXISTS_ERR` | The file already exists. You cannot create another one with the same path. |
| `QUOTA_EXCEEDED_ERROR` | The operation would cause the application to exceed its storage quota. |
| `SECURITY_ERR` | The application does not have permission to access the element referred to by path. [ todo: Explain why ] |
| `TYPE_MISMATCH_ERR` | The path supplied exists, but it is not a directory. |
### removeRecursively()
Deletes a directory and all of its contents. You cannot delete the root directory of a file system.
If you delete a directory that contains a file that cannot be removed or if an error occurs while the deletion is in progress, some of the contents might not be deleted. Catch these cases with error callbacks and retry the deletion.
#### Syntax
```js-nolint
removeRecursively()
```
##### Parameter
None
##### Returns
{{jsxref('undefined')}}
##### Exceptions
This method can raise a {{domxref("DOMException")}} with the following codes:
<table class="no-markdown">
<thead>
<tr>
<th scope="col">Exception</th>
<th scope="col">Description</th>
</tr>
<tr>
<td><code>NOT_FOUND_ERR</code></td>
<td>The target directory does not exist.</td>
</tr>
</thead>
<tbody>
<tr>
<td><code>INVALID_STATE_ERR</code></td>
<td>
This directory is not longer valid for some reason other than being
deleted.
<p>[todo: Explain more ]</p>
</td>
</tr>
<tr>
<td><code>NO_MODIFICATION_ALLOWED_ERR</code></td>
<td>
One of the following is not writable: the directory, its parent
directory, and some of the content in the directory.
</td>
</tr>
<tr>
<td><code>SECURITY_ERR</code></td>
<td>
The application does not have permission to access the target directory,
its parent, or some of its contents.
</td>
</tr>
</tbody>
</table>
## Specifications
This feature is not part of any current specification. It is no longer on track to become a standard.
Use the [File and Directory Entries API](/en-US/docs/Web/API/File_and_Directory_Entries_API) instead.
## Browser compatibility
{{Compat}}
## See also
- [File and Directory Entries API](/en-US/docs/Web/API/File_and_Directory_Entries_API)
- [Introduction to the File and Directory Entries API](/en-US/docs/Web/API/File_and_Directory_Entries_API/Introduction)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/selection/index.md | ---
title: Selection
slug: Web/API/Selection
page-type: web-api-interface
browser-compat: api.Selection
---
{{ApiRef("Selection API")}}
A **`Selection`** object represents the range of text selected by the user or the current position of the caret. To obtain a `Selection` object for examination or manipulation, call {{DOMxRef("window.getSelection()")}}.
A user may make a selection from left to right (in document order) or right to left (reverse of document order). The **_anchor_** is where the user began the selection and the **_focus_** is where the user ends the selection. If you make a selection with a desktop mouse, the anchor is placed where you pressed the mouse button, and the focus is placed where you released the mouse button.
> **Note:** _Anchor_ and _focus_ should not be confused with the _start_ and _end_ positions of a selection. The anchor can be placed before the focus or vice versa, depending on the direction you made your selection.
## Instance properties
- {{DOMxRef("Selection.anchorNode")}} {{ReadOnlyInline}}
- : Returns the {{DOMxRef("Node")}} in which the selection begins. Can return `null` if selection never existed in the document (e.g., an iframe that was never clicked on).
- {{DOMxRef("Selection.anchorOffset")}} {{ReadOnlyInline}}
- : Returns a number representing the offset of the selection's anchor within the `anchorNode`. If `anchorNode` is a text node, this is the number of characters within anchorNode preceding the anchor. If `anchorNode` is an element, this is the number of child nodes of the `anchorNode` preceding the anchor.
- {{DOMxRef("Selection.focusNode")}} {{ReadOnlyInline}}
- : Returns the {{DOMxRef("Node")}} in which the selection ends. Can return `null` if selection never existed in the document (for example, in an `iframe` that was never clicked on).
- {{DOMxRef("Selection.focusOffset")}} {{ReadOnlyInline}}
- : Returns a number representing the offset of the selection's anchor within the `focusNode`. If `focusNode` is a text node, this is the number of characters within `focusNode` preceding the focus. If `focusNode` is an element, this is the number of child nodes of the `focusNode` preceding the focus.
- {{DOMxRef("Selection.isCollapsed")}} {{ReadOnlyInline}}
- : Returns a Boolean indicating whether the selection's start and end points are at the same position.
- {{DOMxRef("Selection.rangeCount")}} {{ReadOnlyInline}}
- : Returns the number of ranges in the selection.
- {{DOMxRef("Selection.type")}} {{ReadOnlyInline}}
- : Returns a string describing the type of the current selection.
## Instance methods
- {{DOMxRef("Selection.addRange()")}}
- : A {{DOMxRef("Range")}} object that will be added to the selection.
- {{DOMxRef("Selection.collapse()")}}
- : Collapses the current selection to a single point.
- {{DOMxRef("Selection.collapseToEnd()")}}
- : Collapses the selection to the end of the last range in the selection.
- {{DOMxRef("Selection.collapseToStart()")}}
- : Collapses the selection to the start of the first range in the selection.
- {{DOMxRef("Selection.containsNode()")}}
- : Indicates if a certain node is part of the selection.
- {{DOMxRef("Selection.deleteFromDocument()")}}
- : Deletes the selection's content from the document.
- {{DOMxRef("Selection.extend()")}}
- : Moves the focus of the selection to a specified point.
- {{DOMxRef("Selection.getRangeAt()")}}
- : Returns a {{DOMxRef("Range")}} object representing one of the ranges currently selected.
- {{DOMxRef("Selection.modify()")}}
- : Changes the current selection.
- {{DOMxRef("Selection.removeRange()")}}
- : Removes a range from the selection.
- {{DOMxRef("Selection.removeAllRanges()")}}
- : Removes all ranges from the selection.
- {{DOMxRef("Selection.selectAllChildren()")}}
- : Adds all the children of the specified node to the selection.
- {{DOMxRef("Selection.setBaseAndExtent()")}}
- : Sets the selection to be a range including all or parts of two specified DOM nodes, and any content located between them.
- {{DOMxRef("Selection.toString()")}}
- : Returns a string currently being represented by the selection object, i.e. the currently selected text.
## Notes
### String representation of a selection
Calling the {{DOMxRef("Selection.toString()")}} method returns the text contained within the selection, e.g.:
```js
const selObj = window.getSelection();
window.alert(selObj);
```
Note that using a selection object as the argument to `window.alert` will call the object's `toString` method.
### Multiple ranges in a selection
A selection object represents the {{DOMxRef("Range")}}s that the user has selected. Typically, it holds only one range, accessed as follows:
```js
const selObj = window.getSelection();
const range = selObj.getRangeAt(0);
```
- `selObj` is a Selection object
- `range` is a {{DOMxRef("Range")}} object
As the [Selection API specification notes](https://www.w3.org/TR/selection-api/#h_note_15), the Selection API was initially created by Netscape and allowed multiple ranges (for instance, to allow the user to select a column from a {{HTMLElement("table")}}). However, browsers other than Gecko did not implement multiple ranges, and the specification also requires the selection to always have a single range.
### Selection and input focus
Selection and input focus (indicated by {{DOMxRef("Document.activeElement")}}) have a complex relationship that varies by browser. In cross-browser compatible code, it's better to handle them separately.
Safari and Chrome (unlike Firefox) currently focus the element containing selection when modifying the selection programmatically; it's possible that this may change in the future (see [W3C bug 14383](https://www.w3.org/Bugs/Public/show_bug.cgi?id=14383) and [Webkit bug 38696](https://webkit.org/b/38696)).
### Behavior of Selection API in terms of editing host focus changes
The Selection API has a common behavior (i.e., shared between browsers) that governs how focus behavior changes for _editing hosts_ after certain methods are called.
The behavior is as follows:
1. An editing host gains focus if the previous selection was outside of it.
2. A Selection API method is called, causing a new selection to be made with the selection range inside the editing host.
3. Focus then moves to the editing host.
> **Note:** The Selection API methods may only move focus to an editing host, not to other focusable elements (e.g., {{HTMLElement("a")}}).
The above behavior applies to selections made using the following methods:
- {{DOMxRef("Selection.collapse()")}}
- {{DOMxRef("Selection.collapseToStart()")}}
- {{DOMxRef("Selection.collapseToEnd()")}}
- {{DOMxRef("Selection.extend()")}}
- {{DOMxRef("Selection.selectAllChildren()")}}
- {{DOMxRef("Selection.addRange()")}}
- {{DOMxRef("Selection.setBaseAndExtent()")}}
And when the {{DOMxRef("Range")}} is modified using the following methods:
- {{DOMxRef("Range.setStart()")}}
- {{DOMxRef("Range.setEnd()")}}
- {{DOMxRef("Range.setStartBefore()")}}
- {{DOMxRef("Range.setStartAfter()")}}
- {{DOMxRef("Range.setEndBefore()")}}
- {{DOMxRef("Range.setEndAfter()")}}
- {{DOMxRef("Range.collapse()")}}
- {{DOMxRef("Range.selectNode()")}}
- {{DOMxRef("Range.selectNodeContents()")}}
### Glossary
Other key terms used in this section.
- `anchor`
- : The anchor of a selection is the beginning point of the selection. When making a selection with a mouse, the anchor is where in the document the mouse button is initially pressed. As the user changes the selection using the mouse or the keyboard, the anchor does not move.
- `editing host`
- : An editable element (e.g., an HTML element with [`contenteditable`](/en-US/docs/Web/HTML/Global_attributes#contenteditable) set, or the HTML child of a document that has {{DOMxRef("Document.designMode", "designMode")}} enabled).
- `focus of a selection`
- : The _focus_ of a selection is the end point of the selection. When making a selection with a mouse, the focus is where in the document the mouse button is released. As the user changes the selection using the mouse or the keyboard, the focus is the end of the selection that moves.
> **Note:** This is not the same as the focused _element_ of the document, as returned by {{DOMxRef("document.activeElement")}}.
- `range`
- : A _range_ is a contiguous part of a document. A range can contain entire nodes as well as portions of nodes (such as a portion of a text node). A user will normally only select a single range at a time, but it's possible for a user to select multiple ranges (e.g., by using the <kbd>Control</kbd> key). A range can be retrieved from a selection as a {{DOMxRef("range")}} object. Range objects can also be created via the DOM and programmatically added or removed from a selection.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{DOMxRef("Window.getSelection")}}, {{DOMxRef("Document.getSelection")}}, {{DOMxRef("Range")}}
- Selection-related events: {{domxref("Document/selectionchange_event", "selectionchange")}} and {{domxref("Node/selectstart_event", "selectstart")}}
- HTML inputs provide simpler helper APIs for working with selection (see {{DOMxRef("HTMLInputElement.setSelectionRange()")}})
- {{DOMxRef("Document.activeElement")}}, {{DOMxRef("HTMLElement.focus")}}, and {{DOMxRef("HTMLElement.blur")}}
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/focusnode/index.md | ---
title: "Selection: focusNode property"
short-title: focusNode
slug: Web/API/Selection/focusNode
page-type: web-api-instance-property
browser-compat: api.Selection.focusNode
---
{{ ApiRef("DOM") }}
The **`Selection.focusNode`** read-only property returns the
{{domxref("Node")}} in which the selection ends.
A user may make a selection from left to right (in document order) or right to left
(reverse of document order). The focus is where the user ended the selection. This can
be visualized by holding the <kbd>Shift</kbd> key and pressing the arrow keys on your
keyboard to modify the current selection. The selection's focus moves, but the
selection's anchor, the other end of the selection, does not move.
## Value
A {{domxref("Node")}} object.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}, the interface it belongs to.
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/empty/index.md | ---
title: "Selection: empty() method"
short-title: empty()
slug: Web/API/Selection/empty
page-type: web-api-instance-method
browser-compat: api.Selection.empty
---
{{ ApiRef("DOM") }}
The **`Selection.empty()`** method removes all ranges from the selection, leaving the {{domxref("Selection.anchorNode", "anchorNode")}} and {{domxref("Selection.focusNode","focusNode")}} properties equal to `null` and nothing selected. When this method is called, a {{domxref("Document/selectionchange_event", "selectionchange")}} event is fired at the document.
> **Note:** This method is an alias for the {{domxref("Selection.removeAllRanges()")}} method.
## Syntax
```js-nolint
empty()
```
### Parameters
None.
### Return value
None ({{jsxref("undefined")}}).
## Examples
This example displays a message when something is selected on the page or not. It does this by listening to the {{domxref("Document/selectionchange_event", "selectionchange")}} event on the document. There also is a button that clears any selection by calling `Selection.empty()`. When this happens, the selection is changed and the message is updated.
```html
<p>
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse laoreet
urna eget sapien venenatis, eget facilisis diam mattis.
</p>
<button>Clear selection</button>
<pre id="log"></pre>
```
```js
const log = document.getElementById("log");
// The selection object is a singleton associated with the document
const selection = document.getSelection();
// Logs if there is a selection or not
function newSelectionHandler() {
if (selection.rangeCount !== 0) {
log.textContent = "Some text is selected.";
} else {
log.textContent = "No selection on this document.";
}
}
document.addEventListener("selectionchange", () => {
newSelectionHandler();
});
newSelectionHandler();
// The button cancel all selection ranges
const button = document.querySelector("button");
button.addEventListener("click", () => {
selection.empty();
});
```
{{EmbedLiveSample("Examples", "100%", "200px")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection.removeAllRanges()")}}
- {{domxref("Document/selectionchange_event", "selectionchange")}}
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/collapse/index.md | ---
title: "Selection: collapse() method"
short-title: collapse()
slug: Web/API/Selection/collapse
page-type: web-api-instance-method
browser-compat: api.Selection.collapse
---
{{ApiRef("DOM")}}
The **`Selection.collapse()`** method collapses the current selection to a single point. The document is not modified. If the content is focused and editable, the caret will blink there.
> **Note:** This method is an alias for the {{domxref("Selection.setPosition()")}} method.
## Syntax
```js-nolint
collapse(node)
collapse(node, offset)
```
### Parameters
- `node`
- : The caret location will be within this node. This value can also be set to
`null` — if `null` is specified, the method will behave like
{{domxref("Selection.removeAllRanges()")}}, i.e. all ranges will be removed from the
selection.
- `offset` {{optional_inline}}
- : The offset in `node` to which the selection will be collapsed. If not
specified, the default value `0` is used.
### Return value
None ({{jsxref("undefined")}}).
## Examples
```js
// Place the caret at the beginning of an HTML document's body.
const body = document.querySelector("body");
window.getSelection().collapse(body, 0);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection.setPosition()")}}
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/removerange/index.md | ---
title: "Selection: removeRange() method"
short-title: removeRange()
slug: Web/API/Selection/removeRange
page-type: web-api-instance-method
browser-compat: api.Selection.removeRange
---
{{ ApiRef("DOM") }}
The **`Selection.removeRange()`** method removes a range from a
selection.
## Syntax
```js-nolint
removeRange(range)
```
### Parameters
- `range`
- : A range object that will be removed to the selection.
### Return value
None ({{jsxref("undefined")}}).
## Examples
```js
/* Programmatically, more than one range can be selected.
* This will remove all ranges except the first. */
const s = window.getSelection();
if (s.rangeCount > 1) {
for (let i = 1; i < s.rangeCount; i++) {
s.removeRange(s.getRangeAt(i));
}
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}, the interface it belongs to.
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/modify/index.md | ---
title: "Selection: modify() method"
short-title: modify()
slug: Web/API/Selection/modify
page-type: web-api-instance-method
browser-compat: api.Selection.modify
---
{{APIRef("DOM")}}
The **`Selection.modify()`** method applies a change to the
current selection or cursor position, using simple textual commands.
## Syntax
```js-nolint
modify(alter, direction, granularity)
```
### Parameters
- `alter`
- : The type of change to apply. Specify `"move"` to move the current cursor
position or `"extend"` to extend the current selection.
- `direction`
- : The direction in which to adjust the current selection. You can specify
`"forward"` or `"backward"` to adjust in the appropriate
direction based on the language at the selection point. If you want to adjust in a
specific direction, you can specify `"left"` or `"right"`.
- `granularity`
- : The distance to adjust the current selection or cursor position. You can move by
`"character"`, `"word"`, `"sentence"`,
`"line"`, `"paragraph"`, `"lineboundary"`,
`"sentenceboundary"`, `"paragraphboundary"`, or
`"documentboundary"`.
> **Note:** Firefox does **not** implement
> `"sentence"`, `"paragraph"`, `"sentenceboundary"`,
> `"paragraphboundary"`, or `"documentboundary"`. WebKit and Blink
> do.
> **Note:** Starting in Firefox 5, the `"word"`
> granularity no longer includes the following space, regardless of the default platform
> behavior. This makes the behavior more consistent, as well as making it work the same
> way WebKit used to work, but unfortunately they have recently changed their behavior.
### Return value
None ({{jsxref("undefined")}}).
## Examples
This example demonstrates the various `granularity` options for modifying a
selection. Click somewhere inside the example (optionally selecting some text), and then
click the button to expand the selection.
### HTML
```html
<p>
Click somewhere in this example. Then click the button below to expand the
selection. Watch what happens!
</p>
<p>
Et harum quidem rerum facilis est et expedita distinctio. Nam libero tempore,
cum soluta nobis est eligendi optio cumque nihil impedit quo minus id quod
maxime placeat facere possimus, omnis voluptas assumenda est, omnis dolor
repellendus.
</p>
<label for="granularity">Granularity:</label>
<select id="granularity">
<option value="character">Character</option>
<option value="word">Word</option>
<option value="sentence">Sentence</option>
<option value="line">Line</option>
<option value="paragraph">Paragraph</option>
<option value="lineboundary">Line Boundary</option>
<option value="sentenceboundary">Sentence Boundary</option>
<option value="paragraphboundary">Paragraph Boundary</option>
<option value="documentboundary">Document Boundary</option>
</select>
<br /><br />
<button>Extend selection</button>
```
### JavaScript
```js
let select = document.querySelector("select");
let button = document.querySelector("button");
button.addEventListener("click", modify);
function modify() {
let selection = window.getSelection();
selection.modify("extend", "forward", select.value);
}
```
### Result
{{EmbedLiveSample("Examples", 700, 200)}}
## Specifications
_This method is not part of any specification._
## Browser compatibility
{{Compat}}
## See also
- {{DOMxRef("Selection")}}, the interface it belongs to.
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/tostring/index.md | ---
title: "Selection: toString() method"
short-title: toString()
slug: Web/API/Selection/toString
page-type: web-api-instance-method
browser-compat: api.Selection.toString
---
{{ ApiRef("DOM") }}
The **`Selection.toString()`** method returns a string
currently being represented by the selection object, i.e. the currently selected text.
## Syntax
```js-nolint
toString()
```
### Parameters
None.
### Return value
A string representing the selection.
## Description
This method returns the currently selected text.
In [JavaScript](/en-US/docs/Web/JavaScript), this method is called automatically when
a function the selection object is passed to requires a string:
```js
alert(window.getSelection()); // What is called
alert(window.getSelection().toString()); // What is actually being effectively called.
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}, the interface it belongs to.
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/addrange/index.md | ---
title: "Selection: addRange() method"
short-title: addRange()
slug: Web/API/Selection/addRange
page-type: web-api-instance-method
browser-compat: api.Selection.addRange
---
{{ ApiRef("DOM") }}
The **`Selection.addRange()`** method adds a
{{domxref("Range")}} to a {{domxref("Selection")}}.
## Syntax
```js-nolint
addRange(range)
```
### Parameters
- `range`
- : A {{ domxref("Range") }} object that will be added to the {{ domxref("Selection")
}}.
### Return value
None ({{jsxref("undefined")}}).
## Examples
> **Note:** Currently only Firefox supports multiple selection ranges, other browsers will not
> add new ranges to the selection if it already contains one.
### HTML
```html
<p>
I <strong>insist</strong> that you <strong>try</strong> selecting the
<strong>strong words</strong>.
</p>
<button>Select strong words</button>
```
### JavaScript
```js
let button = document.querySelector("button");
button.addEventListener("click", () => {
const selection = window.getSelection();
const strongs = document.getElementsByTagName("strong");
if (selection.rangeCount > 0) {
selection.removeAllRanges();
}
for (const node of strongs) {
const range = document.createRange();
range.selectNode(node);
selection.addRange(range);
}
});
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}, the interface this method belongs to
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/containsnode/index.md | ---
title: "Selection: containsNode() method"
short-title: containsNode()
slug: Web/API/Selection/containsNode
page-type: web-api-instance-method
browser-compat: api.Selection.containsNode
---
{{ ApiRef("DOM") }}
The **`Selection.containsNode()`** method indicates whether a
specified node is part of the selection.
## Syntax
```js-nolint
containsNode(node)
containsNode(node)
containsNode(node, partialContainment)
```
### Parameters
- `node`
- : The node that is being looked for in the selection.
- `partialContainment` {{optional_inline}}
- : When `true`, `containsNode()` returns `true` when a
part of the node is part of the selection. When `false`,
`containsNode()` only returns `true` when the entire node is
part of the selection. If not specified, the default value `false` is used.
### Return value
Returns `true` if the given node is part of the selection, and `false` otherwise.
## Examples
### Check for selection
This snippet checks whether anything inside the body element is selected.
```js
console.log(window.getSelection().containsNode(document.body, true));
```
### Find the hidden word
In this example, a message appears when you select the secret word. It uses
{{domxref("EventTarget/addEventListener", "addEventListener()")}} to check for
{{domxref("Document/selectionchange_event", "selectionchange")}} events.
#### HTML
```html
<p>Can you find the secret word?</p>
<p>
Hmm, where <span id="secret" style="color:transparent">SECRET</span> could it
be?
</p>
<p id="win" hidden>You found it!</p>
```
#### JavaScript
```js
const secret = document.getElementById("secret");
const win = document.getElementById("win");
// Listen for selection changes
document.addEventListener("selectionchange", () => {
const selection = window.getSelection();
const found = selection.containsNode(secret);
win.toggleAttribute("hidden", !found);
});
```
#### Result
{{EmbedLiveSample("Find_the_hidden_word")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}, the interface it belongs to.
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/setposition/index.md | ---
title: "Selection: setPosition() method"
short-title: setPosition()
slug: Web/API/Selection/setPosition
page-type: web-api-instance-method
browser-compat: api.Selection.setPosition
---
{{ApiRef("DOM")}}
The **`Selection.setPosition()`** method collapses the current selection to a single point. The document is not modified. If the content is focused and editable, the caret will blink there.
> **Note:** This method is an alias for the {{domxref("Selection.collapse()")}} method.
## Syntax
```js-nolint
setPosition(node)
setPosition(node, offset)
```
### Parameters
- `node`
- : The caret location will be within this node. This value can also be set to
`null` — if `null` is specified, the method will behave like
{{domxref("Selection.removeAllRanges()")}}, i.e. all ranges will be removed from the
selection.
- `offset` {{optional_inline}}
- : The offset in `node` to which the selection will be collapsed. If not
specified, the default value `0` is used.
### Return value
None ({{jsxref("undefined")}}).
## Examples
```js
// Place the caret at the beginning of an HTML document's body.
const body = document.querySelector("body");
window.getSelection().setPosition(body, 0);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection.collapse()")}}
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/deletefromdocument/index.md | ---
title: "Selection: deleteFromDocument() method"
short-title: deleteFromDocument()
slug: Web/API/Selection/deleteFromDocument
page-type: web-api-instance-method
browser-compat: api.Selection.deleteFromDocument
---
{{ ApiRef("DOM") }}
The **`deleteFromDocument()`** method of the
{{domxref("Selection")}} interface deletes the selected text from the document's DOM.
## Syntax
```js-nolint
deleteFromDocument()
```
### Parameters
None.
### Return value
None ({{jsxref("undefined")}}).
## Examples
This example lets you delete selected text by clicking a button. Upon clicking the
button, the
{{domxref("Window.getSelection()")}} method gets the selected text, and the
`deleteFromDocument()` method removes it.
### HTML
```html
<p>
Try highlighting some of the text in this paragraph. Once you do, you can
remove the selected content by clicking the button below.
</p>
<button>Delete selected text</button>
```
### JavaScript
```js
let button = document.querySelector("button");
button.addEventListener("click", deleteSelection);
function deleteSelection() {
let selection = window.getSelection();
selection.deleteFromDocument();
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}, the interface defining this method
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/extend/index.md | ---
title: "Selection: extend() method"
short-title: extend()
slug: Web/API/Selection/extend
page-type: web-api-instance-method
browser-compat: api.Selection.extend
---
{{ ApiRef("DOM") }}
The **`Selection.extend()`** method moves the focus of the
selection to a specified point. The anchor of the selection does not move. The selection
will be from the anchor to the new focus, regardless of direction.
## Syntax
```js-nolint
extend(node)
extend(node, offset)
```
### Parameters
- `node`
- : The node within which the focus will be moved.
- `offset` {{optional_inline}}
- : The offset position within `node` where the focus will be moved to. If
not specified, the default value `0` is used.
### Return value
None ({{jsxref("undefined")}}).
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}, the interface it belongs to.
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/getrangeat/index.md | ---
title: "Selection: getRangeAt() method"
short-title: getRangeAt()
slug: Web/API/Selection/getRangeAt
page-type: web-api-instance-method
browser-compat: api.Selection.getRangeAt
---
{{ ApiRef("DOM") }}
The **`Selection.getRangeAt()`** method returns a range object
representing one of the ranges currently selected.
## Syntax
```js-nolint
getRangeAt(index)
```
### Parameters
- `index`
- : The zero-based index of the range to return. A negative number or a number greater
than or equal to {{domxref("Selection.rangeCount")}} will result in an error.
### Return value
The specified {{domxref("Range")}} object.
## Examples
```js
let ranges = [];
sel = window.getSelection();
for (let i = 0; i < sel.rangeCount; i++) {
ranges[i] = sel.getRangeAt(i);
}
/* Each item in the ranges array is now
* a range object representing one of the
* ranges in the current selection */
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}, the interface it belongs to.
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/anchornode/index.md | ---
title: "Selection: anchorNode property"
short-title: anchorNode
slug: Web/API/Selection/anchorNode
page-type: web-api-instance-property
browser-compat: api.Selection.anchorNode
---
{{ ApiRef("DOM") }}
The **`Selection.anchorNode`** read-only property returns the
{{domxref("Node")}} in which the selection begins.
A user may make a selection from left to right (in document order) or right to left
(reverse of document order). The anchor is where the user began the selection. This can
be visualized by holding the Shift key and pressing the arrow keys on your keyboard. The
selection's anchor does not move, but the selection's focus, the other end of the
selection, does move.
## Value
A {{domxref("Node")}} object.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}, the interface it belongs to.
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/setbaseandextent/index.md | ---
title: "Selection: setBaseAndExtent() method"
short-title: setBaseAndExtent()
slug: Web/API/Selection/setBaseAndExtent
page-type: web-api-instance-method
browser-compat: api.Selection.setBaseAndExtent
---
{{ ApiRef("DOM") }}
The **`setBaseAndExtent()`** method of the
{{domxref("Selection")}} interface sets the selection to be a range including all or
parts of two specified DOM nodes, and any content located between them.
## Syntax
```js-nolint
setBaseAndExtent(anchorNode, anchorOffset, focusNode, focusOffset)
```
### Parameters
- `anchorNode`
- : The node at the start of the selection.
- `anchorOffset`
- : The number of child nodes from the start of the anchor node that should be excluded
from the selection. So for example, if the value is 0 the whole node is included. If
the value is 1, the whole node minus the first child node is included. And so on.
If `anchorNode` is a {{domxref("Text")}} node, the offset refers to the number of
characters from the start of the {{domxref("Node.textContent")}} that should be
excluded from the selection.
- `focusNode`
- : The node at the end of the selection.
- `focusOffset`
- : The number of child nodes from the start of the focus node that should be included
in the selection. So for example, if the value is 0 the whole node is excluded. If the
value is 1, the first child node is included. And so on.
If `focusNode` is a {{domxref("Text")}} node, the offset refers to the number of
characters from the start of the {{domxref("Node.textContent")}} that should be
included in the selection.
> **Note:** If the focus position appears before the anchor position in
> the document, the direction of the selection is reversed — the caret is placed at the
> beginning of the text rather the end, which matters for any keyboard command that
> might follow. For example, <kbd>Shift</kbd> + <kbd>➡︎</kbd> would cause the selection
> to narrow from the beginning rather than grow at the end.
### Return value
None ({{jsxref("undefined")}}).
### Exceptions
- `IndexSizeError` {{domxref("DOMException")}}
- : Thrown if `anchorOffset` is larger than the number of child nodes inside `anchorNode`, or if `focusOffset` is larger than the number of child nodes inside `focusNode`.
## Examples
In this example, we have two paragraphs containing spans, each one containing a single
word. The first one is set as the `anchorNode` and the second is set as the
`focusNode`. We also have an additional paragraph that sits in between the
two nodes.
Next, we have two form inputs that allow you to set the `anchorOffset` and
`focusOffset` — they both have a default value of 0.
We also have a button that when pressed invokes a function that runs the
`setBaseAndExtent()` method with the specified offsets, and copies the
selection into the output paragraph at the very bottom of the HTML.
```html
<h1>setBaseAndExtent example</h1>
<div>
<p class="one">
<span>Fish</span><span>Dog</span><span>Cat</span><span>Bird</span>
</p>
<p>MIDDLE</p>
<p class="two">
<span>Car</span><span>Bike</span><span>Boat</span><span>Plane</span>
</p>
</div>
<div>
<p>
<label for="aOffset">Anchor offset</label>
<input id="aOffset" name="aOffset" type="number" value="0" />
</p>
<p>
<label for="fOffset">Focus offset</label>
<input id="fOffset" name="fOffset" type="number" value="0" />
</p>
<p><button>Capture selection</button></p>
</div>
<p><strong>Output</strong>: <span class="output"></span></p>
```
> **Note:** There is intentionally no [whitespace](/en-US/docs/Web/API/Document_Object_Model/Whitespace) between the `<p class="one">` and `<p class="two">` start tags and the `<span>` start tags which follow them — to avoid the presence of text nodes that would affect the number of child nodes expected. (Even though those text nodes would be whitespace-only, they would still be additional child nodes; find out more from the [`Node.firstChild` example](/en-US/docs/Web/API/Node/firstChild#example)).
The JavaScript looks like so:
```js
const one = document.querySelector(".one");
const two = document.querySelector(".two");
const aOffset = document.getElementById("aOffset");
const fOffset = document.getElementById("fOffset");
const button = document.querySelector("button");
const output = document.querySelector(".output");
let selection;
button.onclick = () => {
try {
selection = document.getSelection();
selection.setBaseAndExtent(one, aOffset.value, two, fOffset.value);
const text = selection.toString();
output.textContent = text;
} catch (e) {
output.textContent = e.message;
}
};
```
Play with the live example below, setting different offset values to see how this
affects the selection.
{{ EmbedLiveSample('Examples', '100%', 370) }}
> **Note:** You can find this [example on GitHub](https://github.com/chrisdavidmills/selection-api-examples/blob/master/setBaseAndExtent.html) ([see it live also](https://chrisdavidmills.github.io/selection-api-examples/setBaseAndExtent.html).)
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/rangecount/index.md | ---
title: "Selection: rangeCount property"
short-title: rangeCount
slug: Web/API/Selection/rangeCount
page-type: web-api-instance-property
browser-compat: api.Selection.rangeCount
---
{{ ApiRef("DOM") }}
The **`Selection.rangeCount`** read-only property returns the
number of ranges in the selection.
Before the user has clicked a freshly loaded page, the `rangeCount` is
`0`. After the user clicks on the page, `rangeCount` is
`1`, even if no selection is visible.
A user can normally only select one range at a time, so the `rangeCount`
will usually be `1`. Scripting can be used to make the selection contain more
than one range.
Gecko browsers allow multiple selections across table cells. Firefox allows to select
multiple ranges in the document by using Ctrl+click (unless the click occurs within an
element that has the `display: table-cell` CSS property assigned).
## Value
A number.
## Examples
The following example will show the `rangeCount` every second. Select text
in the browser to see it change.
### HTML
```html
<table>
<tr>
<td>a.1</td>
<td>a.2</td>
</tr>
<tr>
<td>b.1</td>
<td>b.2</td>
</tr>
<tr>
<td>c.1</td>
<td>c.2</td>
</tr>
</table>
```
### JavaScript
```js
setInterval(() => {
console.log(window.getSelection().rangeCount);
}, 1000);
```
### Result
Open your console to see how many ranges are in the selection. In Gecko browsers, you
can select multiple ranges across table cells by holding down <kbd>Ctrl</kbd> (or <kbd>Cmd</kbd> on MacOS) while
dragging with the mouse.
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}, the interface it belongs to.
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/collapsetoend/index.md | ---
title: "Selection: collapseToEnd() method"
short-title: collapseToEnd()
slug: Web/API/Selection/collapseToEnd
page-type: web-api-instance-method
browser-compat: api.Selection.collapseToEnd
---
{{ ApiRef("DOM") }}
The **`Selection.collapseToEnd()`** method collapses the
selection to the end of the last range in the selection. If the content of the selection
is focused and editable, the caret will blink there.
## Syntax
```js-nolint
collapseToEnd()
```
### Parameters
None.
### Return value
None ({{jsxref("undefined")}}).
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}, the interface it belongs to.
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/anchoroffset/index.md | ---
title: "Selection: anchorOffset property"
short-title: anchorOffset
slug: Web/API/Selection/anchorOffset
page-type: web-api-instance-property
browser-compat: api.Selection.anchorOffset
---
{{ ApiRef("DOM") }}
The **`Selection.anchorOffset`** read-only property returns the
number of characters that the selection's anchor is offset within the
{{domxref("Selection.anchorNode")}}.
This number is zero-based. If the selection begins with the first character in the
{{domxref("Selection.anchorNode")}}, `0` is returned.
## Value
A number.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}, the interface it belongs to.
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/type/index.md | ---
title: "Selection: type property"
short-title: type
slug: Web/API/Selection/type
page-type: web-api-instance-property
browser-compat: api.Selection.type
---
{{APIRef("DOM")}}
The **`type`** read-only property of the
{{domxref("Selection")}} interface returns a string describing the
type of the current selection.
## Value
A string describing the type of the current selection. Possible
values are:
- `None`
- : No selection has currently been made.
- `Caret`
- : The selection is collapsed (i.e. the caret is placed on some
text, but no range has been selected).
- `Range`
- : A range has been selected.
## Examples
In this example, the event handler will fire each time a new selection is made.
`console.log(selection.type)` will return `Caret` or
`Range` depending on whether the caret is placed at a single point in the
text, or a range has been selected.
```js
let selection;
document.onselectionchange = () => {
console.log("New selection made");
selection = document.getSelection();
console.log(selection.type);
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/removeallranges/index.md | ---
title: "Selection: removeAllRanges() method"
short-title: removeAllRanges()
slug: Web/API/Selection/removeAllRanges
page-type: web-api-instance-method
browser-compat: api.Selection.removeAllRanges
---
{{ ApiRef("DOM") }}
The **`Selection.removeAllRanges()`** method removes all ranges from the selection, leaving the {{domxref("Selection.anchorNode", "anchorNode")}} and {{domxref("Selection.focusNode","focusNode")}} properties equal to `null` and nothing selected. When this method is called, a {{domxref("Document/selectionchange_event", "selectionchange")}} event is fired at the document.
> **Note:** This method is an alias for the {{domxref("Selection.empty()")}} method.
## Syntax
```js-nolint
removeAllRanges()
```
### Parameters
None.
### Return value
None ({{jsxref("undefined")}}).
## Examples
This example displays a message when something is selected on the page or not. It does this by listening to the {{domxref("Document/selectionchange_event", "selectionchange")}} event on the document. There also is a button that clears any selection by calling `Selection.removeAllRanges()`. When this happens, the selection is changed and the message is updated.
```html
<p>
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse laoreet
urna eget sapien venenatis, eget facilisis diam mattis.
</p>
<button>Clear selection</button>
<pre id="log"></pre>
```
```js
const log = document.getElementById("log");
// The selection object is a singleton associated with the document
const selection = document.getSelection();
// Logs if there is a selection or not
function newSelectionHandler() {
if (selection.rangeCount !== 0) {
log.textContent = "Some text is selected.";
} else {
log.textContent = "No selection on this document.";
}
}
document.addEventListener("selectionchange", () => {
newSelectionHandler();
});
newSelectionHandler();
// The button cancel all selection ranges
const button = document.querySelector("button");
button.addEventListener("click", () => {
selection.removeAllRanges();
});
```
{{EmbedLiveSample("Examples", "100%", "200px")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection.empty()")}}
- {{domxref("Document/selectionchange_event", "selectionchange")}}
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/selectallchildren/index.md | ---
title: "Selection: selectAllChildren() method"
short-title: selectAllChildren()
slug: Web/API/Selection/selectAllChildren
page-type: web-api-instance-method
browser-compat: api.Selection.selectAllChildren
---
{{ ApiRef("DOM") }}
The **`Selection.selectAllChildren()`** method adds all the
children of the specified node to the selection. Previous selection is lost.
## Syntax
```js-nolint
selectAllChildren(parentNode)
```
### Parameters
- `parentNode`
- : All children of `parentNode` will be selected. `parentNode`
itself is not part of the selection.
### Return value
None ({{jsxref("undefined")}}).
## Examples
### HTML
```html
<main>
<button>Select Footer</button>
<p>Welcome to my website.</p>
<p>I hope you enjoy your visit.</p>
</main>
<footer>
<address>[email protected]</address>
<p>© 2019</p>
</footer>
```
### JavaScript
```js
const button = document.querySelector("button");
const footer = document.querySelector("footer");
button.addEventListener("click", (e) => {
window.getSelection().selectAllChildren(footer);
});
```
### Result
{{EmbedLiveSample("Examples", 700, 200)}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}, the interface it belongs to.
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/focusoffset/index.md | ---
title: "Selection: focusOffset property"
short-title: focusOffset
slug: Web/API/Selection/focusOffset
page-type: web-api-instance-property
browser-compat: api.Selection.focusOffset
---
{{ ApiRef("DOM") }}
The **`Selection.focusOffset`** read-only property returns the
number of characters that the selection's focus is offset within the
{{domxref("Selection.focusNode")}}.
This number is zero-based. If the selection ends with the first character in the
{{domxref("Selection.focusNode")}}, `0` is returned.
## Value
A number.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}, the interface it belongs to.
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/collapsetostart/index.md | ---
title: "Selection: collapseToStart() method"
short-title: collapseToStart()
slug: Web/API/Selection/collapseToStart
page-type: web-api-instance-method
browser-compat: api.Selection.collapseToStart
---
{{ ApiRef("DOM") }}
The **`Selection.collapseToStart()`** method collapses the
selection to the start of the first range in the selection. If the content of the
selection is focused and editable, the caret will blink there.
## Syntax
```js-nolint
collapseToStart()
```
### Parameters
None.
### Return value
None ({{jsxref("undefined")}}).
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}, the interface it belongs to.
| 0 |
data/mdn-content/files/en-us/web/api/selection | data/mdn-content/files/en-us/web/api/selection/iscollapsed/index.md | ---
title: "Selection: isCollapsed property"
short-title: isCollapsed
slug: Web/API/Selection/isCollapsed
page-type: web-api-instance-property
browser-compat: api.Selection.isCollapsed
---
{{ ApiRef("DOM") }}
The **`Selection.isCollapsed`** read-only property returns a
boolean value which indicates whether or not there is currently any text
selected. No text is selected when the selection's start and end points are at the same
position in the content.
Keep in mind that a collapsed selection may still have one (or more, in Gecko)
{{domxref("Range")}}s, so {{domxref("Selection.rangeCount")}} may not be zero. In that
scenario, calling a {{domxref("Selection")}} object's {{domxref("Selection.getRangeAt",
"getRangeAt()")}} method may return a `Range` object which is collapsed.
## Value
A boolean.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("Selection")}}
- {{domxref("Range")}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/report/index.md | ---
title: Report
slug: Web/API/Report
page-type: web-api-interface
browser-compat: api.Report
---
{{APIRef("Reporting API")}}
The `Report` interface of the [Reporting API](/en-US/docs/Web/API/Reporting_API) represents a single report.
Reports can be accessed in a number of ways:
- Via the {{domxref("ReportingObserver.takeRecords()")}} method — this returns all reports in an observer's report queue, and then empties the queue.
- Via the `reports` parameter of the callback function passed into the [`ReportingObserver()`](/en-US/docs/Web/API/ReportingObserver/ReportingObserver) constructor upon creation of a new observer instance. This contains the list of reports currently contained in the observer's report queue.
- By sending requests to the endpoints defined via the {{httpheader("Report-To")}} HTTP header.
## Instance properties
- {{domxref("Report.body")}} {{ReadOnlyInline}}
- : The body of the report, which is a `ReportBody` object containing the detailed report information.
- {{domxref("Report.type")}} {{ReadOnlyInline}}
- : The type of report generated, e.g. `deprecation` or `intervention`.
- {{domxref("Report.url")}} {{ReadOnlyInline}}
- : The URL of the document that generated the report.
## Instance methods
_This interface has no methods defined on it._
## Events
_This interface has no events that fire on it._
## Examples
In our [deprecation_report.html](https://mdn.github.io/dom-examples/reporting-api/deprecation_report.html) example, we create a simple reporting observer to observe usage of deprecated features on our web page:
```js
const options = {
types: ["deprecation"],
buffered: true,
};
const observer = new ReportingObserver((reports, observer) => {
reportBtn.onclick = () => displayReports(reports);
}, options);
```
We then tell it to start observing reports using {{domxref("ReportingObserver.observe()")}}; this tells the observer to start collecting reports in its report queue, and runs the callback function specified inside the constructor:
```js
observer.observe();
```
Because of the event handler we set up inside the `ReportingObserver()` constructor, we can now click the button to display the report details.
The report details are displayed via the `displayReports()` function, which takes the observer callback's `reports` parameter as its parameter:
```js
function displayReports(reports) {
const outputElem = document.querySelector(".output");
const list = document.createElement("ul");
outputElem.appendChild(list);
reports.forEach((report, i) => {
let listItem = document.createElement("li");
let textNode = document.createTextNode(
`Report ${i + 1}, type: ${report.type}`,
);
listItem.appendChild(textNode);
let innerList = document.createElement("ul");
listItem.appendChild(innerList);
list.appendChild(listItem);
for (const key in report.body) {
const innerListItem = document.createElement("li");
const keyValue = report.body[key];
innerListItem.textContent = `${key}: ${keyValue}`;
innerList.appendChild(innerListItem);
}
});
}
```
The `reports` parameter contains an array of all the reports in the observer's report queue. We loop over each report using a [`forEach()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) loop, then iterate over each entry of in the report's body using a [`for...in`](/en-US/docs/Web/JavaScript/Reference/Statements/for...in) structure, displaying each key/value pair inside a list item.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Reporting API](/en-US/docs/Web/API/Reporting_API)
| 0 |
data/mdn-content/files/en-us/web/api/report | data/mdn-content/files/en-us/web/api/report/body/index.md | ---
title: "Report: body property"
short-title: body
slug: Web/API/Report/body
page-type: web-api-instance-property
browser-compat: api.Report.body
---
{{APIRef("Reporting API")}}
The **`body`** read-only property of the {{domxref("Report")}}
interface returns the body of the report, which is a `ReportBody` object
containing the detailed report information.
## Value
A `ReportBody` object containing the detailed report information. Depending
on what `type` the {{domxref("Report")}} is, the object returned will
actually be a
{{domxref("DeprecationReportBody")}}, {{domxref("InterventionReportBody")}},
{{domxref("CSPViolationReportBody")}}, or {{domxref("FeaturePolicyViolationReportBody")}}.
These all inherit from the base `ReportBody` class — study their reference
pages for more information on what the particular report body types contain.
## Examples
```js
const options = {
types: ["deprecation"],
buffered: true,
};
const observer = new ReportingObserver(([firstReport], observer) => {
// Log the first report's report body, i.e. a DeprecationReportBody object
console.log(firstReport.body);
}, options);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Reporting API](/en-US/docs/Web/API/Reporting_API)
| 0 |
data/mdn-content/files/en-us/web/api/report | data/mdn-content/files/en-us/web/api/report/url/index.md | ---
title: "Report: url property"
short-title: url
slug: Web/API/Report/url
page-type: web-api-instance-property
browser-compat: api.Report.url
---
{{APIRef("Reporting API")}}
The **`url`** read-only property of the {{domxref("Report")}}
interface returns the URL of the document that generated the report.
## Value
A string representing the URL of the document that generated the report.
## Examples
```js
const options = {
types: ["deprecation"],
buffered: true,
};
const observer = new ReportingObserver(([firstReport], observer) => {
// Log the URL of the document that generated the first report
// e.g. "https://www.example.com/cats.html"
console.log(firstReport.url);
}, options);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Reporting API](/en-US/docs/Web/API/Reporting_API)
| 0 |
data/mdn-content/files/en-us/web/api/report | data/mdn-content/files/en-us/web/api/report/type/index.md | ---
title: "Report: type property"
short-title: type
slug: Web/API/Report/type
page-type: web-api-instance-property
browser-compat: api.Report.type
---
{{APIRef("Reporting API")}}
The **`type`** read-only property of the {{domxref("Report")}}
interface returns the type of report generated, e.g. `deprecation` or
`intervention`.
## Value
A string representing the type of the report. Currently the available types are
`deprecation`, `intervention`, and `crash`.
## Examples
```js
const options = {
types: ["deprecation"],
buffered: true,
};
const observer = new ReportingObserver(([firstReport], observer) => {
// Log the first report's report type, i.e. "deprecation"
console.log(firstReport.type);
}, options);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Reporting API](/en-US/docs/Web/API/Reporting_API)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/imagebitmap/index.md | ---
title: ImageBitmap
slug: Web/API/ImageBitmap
page-type: web-api-interface
browser-compat: api.ImageBitmap
---
{{APIRef("Canvas API")}}
The **`ImageBitmap`** interface represents a bitmap image which can be drawn to a {{HTMLElement("canvas")}} without undue latency. It can be created from a variety of source objects using the {{domxref("createImageBitmap()")}} factory method. `ImageBitmap` provides an asynchronous and resource efficient pathway to prepare textures for rendering in WebGL.
`ImageBitmap` is a [transferable object](/en-US/docs/Web/API/Web_Workers_API/Transferable_objects).
## Instance properties
- {{domxref("ImageBitmap.height")}} {{ReadOnlyInline}}
- : An `unsigned long` representing the height, in CSS pixels, of the `ImageData`.
- {{domxref("ImageBitmap.width")}} {{ReadOnlyInline}}
- : An `unsigned long` representing the width, in CSS pixels, of the `ImageData`.
## Instance methods
- {{domxref("ImageBitmap.close()")}}
- : Disposes of all graphical resources associated with an `ImageBitmap`.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("createImageBitmap()")}}
- {{domxref("CanvasRenderingContext2D.drawImage()")}}
- {{domxref("WebGLRenderingContext.texImage2D()")}}
- {{domxref("OffscreenCanvas.transferToImageBitmap()")}}
| 0 |
data/mdn-content/files/en-us/web/api/imagebitmap | data/mdn-content/files/en-us/web/api/imagebitmap/width/index.md | ---
title: "ImageBitmap: width property"
short-title: width
slug: Web/API/ImageBitmap/width
page-type: web-api-instance-property
browser-compat: api.ImageBitmap.width
---
{{APIRef("Canvas API")}}
The read-only **`ImageBitmap.width`** property returns the {{domxref("ImageBitmap")}} object's width in CSS pixels.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/imagebitmap | data/mdn-content/files/en-us/web/api/imagebitmap/height/index.md | ---
title: "ImageBitmap: height property"
short-title: height
slug: Web/API/ImageBitmap/height
page-type: web-api-instance-property
browser-compat: api.ImageBitmap.height
---
{{APIRef("Canvas API")}}
The read-only **`ImageBitmap.height`** property returns the {{domxref("ImageBitmap")}} object's height in CSS pixels.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/imagebitmap | data/mdn-content/files/en-us/web/api/imagebitmap/close/index.md | ---
title: "ImageBitmap: close() method"
short-title: close()
slug: Web/API/ImageBitmap/close
page-type: web-api-instance-method
browser-compat: api.ImageBitmap.close
---
{{APIRef("Canvas API")}}
The **`ImageBitmap.close()`**
method disposes of all graphical resources associated with an `ImageBitmap`.
## Syntax
```js-nolint
close()
```
### Parameters
None.
### Return value
None ({{jsxref("undefined")}}).
## Examples
```js
const offscreen = new OffscreenCanvas(256, 256);
const gl = offscreen.getContext("webgl");
// Perform some drawing using the gl context
const bitmap = offscreen.transferToImageBitmap();
// ImageBitmap { width: 256, height: 256 }
bitmap.close();
// ImageBitmap { width: 0, height: 0 } — disposed
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The interface defining this method, {{domxref("ImageBitmap")}}.
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/reportbody/index.md | ---
title: ReportBody
slug: Web/API/ReportBody
page-type: web-api-interface
browser-compat: api.ReportBody
---
{{APIRef("Reporting API")}}
The **`ReportBody`** interface of the {{domxref('Reporting API','','',' ')}} represents the body of a report. Individual report types inherit from this interface, adding specific attributes relevant to the particular report.
### Reports that inherit from `ReportBody`
- {{domxref("CSPViolationReportBody")}}
- {{domxref("DeprecationReportBody")}}
- {{domxref("InterventionReportBody")}}
An instance of `ReportBody` is returned as the value of {{domxref("Report.body")}}. The interface has no constructor.
## Instance methods
- {{domxref("ReportBody.toJSON()")}}
- : A _serializer_ which returns a JSON representation of the `ReportBody` object.
## Examples
In this example we create a new {{domxref("ReportingObserver")}} to observe intervention reports. The {{domxref("InterventionReportBody")}} interface inherits from `ReportBody`.
```js
const options = {
types: ["intervention"],
buffered: true,
};
const observer = new ReportingObserver(([firstReport], observer) => {
console.log(firstReport.type); // intervention
}, options);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/reportbody | data/mdn-content/files/en-us/web/api/reportbody/tojson/index.md | ---
title: "ReportBody: toJSON() method"
short-title: toJSON()
slug: Web/API/ReportBody/toJSON
page-type: web-api-instance-method
browser-compat: api.ReportBody.toJSON
---
{{APIRef("Reporting API")}}
The **`toJSON()`** method of the {{domxref("ReportBody")}} interface is a _serializer_, and returns a JSON representation of the `ReportBody` object.
## Syntax
```js-nolint
toJSON()
```
### Parameters
None.
### Return value
A JSON object that is the serialization of the {{domxref("ReportBody")}} object.
## Examples
In this example we create a new {{domxref("ReportingObserver")}} to observe intervention reports, then return a JSON representation of the first entry. The report, and therefore the JSON object returned will be an instance of {{domxref("InterventionReportBody")}} which inherits from `ReportBody`.
```js
const options = {
types: ["intervention"],
buffered: true,
};
const observer = new ReportingObserver(([firstReport], observer) => {
console.log(firstReport.toJSON());
}, options);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/rtcicetransport/index.md | ---
title: RTCIceTransport
slug: Web/API/RTCIceTransport
page-type: web-api-interface
browser-compat: api.RTCIceTransport
---
{{APIRef("WebRTC")}}
The **`RTCIceTransport`** interface provides access to information about the {{Glossary("ICE")}} transport layer over which the data is being sent and received.
This is particularly useful if you need to access state information about the connection.
{{InheritanceDiagram}}
## Instance properties
_The `RTCIceTransport` interface inherits properties from its parent, {{domxref("EventTarget")}}. It also offers the following properties:_
- {{domxref("RTCIceTransport.component", "component")}} {{ReadOnlyInline}}
- : The ICE component being used by the transport. The value is one of the strings from the {{domxref("RTCIceTransport")}} enumerated type: `{{Glossary("RTP", '"RTP"')}}` or `"RTSP"`.
- {{domxref("RTCIceTransport.gatheringState", "gatheringState")}} {{ReadOnlyInline}}
- : A string indicating which current gathering state of the ICE agent: `"new"`, `"gathering"`, or `"complete"`.
- {{domxref("RTCIceTransport.role", "role")}} {{ReadOnlyInline}}
- : Returns a string whose value is either `"controlling"` or `"controlled"`; this indicates whether the ICE agent is the one that makes the final decision as to the candidate pair to use or not.
- {{domxref("RTCIceTransport.state", "state")}} {{ReadOnlyInline}}
- : A string indicating what the current state of the ICE agent is. The value of `state` can be used to determine whether the ICE agent has made an initial connection using a viable candidate pair (`"connected"`), made its final selection of candidate pairs (`"completed"`), or in an error state (`"failed"`), among other states.
## Instance methods
_Also includes methods from {{domxref("EventTarget")}}, the parent interface._
- {{domxref("RTCIceTransport.getLocalCandidates", "getLocalCandidates()")}}
- : Returns an array of {{domxref("RTCIceCandidate")}} objects, each describing one of the ICE candidates that have been gathered so far for the local device. These are the same candidates which have already been sent to the remote peer by sending an {{domxref("RTCPeerConnection.icecandidate_event", "icecandidate")}} event to the {{domxref("RTCPeerConnection")}} for transmission.
- {{domxref("RTCIceTransport.getLocalParameters", "getLocalParameters()")}}
- : Returns a {{domxref("RTCIceParameters")}} object describing the ICE parameters established by a call to the {{domxref("RTCPeerConnection.setLocalDescription()")}} method. Returns `null` if parameters have not yet been received.
- {{domxref("RTCIceTransport.getRemoteCandidates", "getRemoteCandidates()")}}
- : Returns an array of {{domxref("RTCIceCandidate")}} objects, one for each of the remote device's ICE candidates that have been received by the local end of the {{domxref("RTCPeerConnection")}} and delivered to ICE by calling {{domxref("RTCPeerConnection.addIceCandidate()", "addIceCandidate()")}}.
- {{domxref("RTCIceTransport.getRemoteParameters", "getRemoteParameters()")}}
- : Returns a {{domxref("RTCIceParameters")}} object containing the ICE parameters for the remote device, as set by a call to {{domxref("RTCPeerConnection.setRemoteDescription()")}}. If `setRemoteDescription()` hasn't been called yet, the return value is `null`.
- {{domxref("RTCIceTransport.getSelectedCandidatePair", "getSelectedCandidatePair()")}}
- : Returns a {{domxref("RTCIceCandidatePair")}} object that identifies the two candidates—one for each end of the connection—that have been selected so far. It's possible that a better pair will be found and selected later; if you need to keep up with this, watch for the {{domxref("RTCIceTransport.selectedcandidatepairchange_event", "selectedcandidatepairchange")}} event. If no candidate pair has been selected yet, the return value is `null`.
## Events
Listen to these events using {{domxref("EventTarget.addEventListener", "addEventListener()")}} or by assigning an event listener to the `oneventname` property of this interface.
- {{domxref("RTCIceTransport.gatheringstatechange_event", "gatheringstatechange")}}
- : Sent to the {{domxref("RTCIceTransport")}} object to indicate that the value of the {{domxref("RTCIceTransport.gatheringState", "gatheringState")}} property has changed, indicating a change in this transport's ICE candidate negotiation process.
Also available through the {{domxref("RTCIceTransport.gatheringstatechange_event", "ongatheringstatechange")}} event handler property.
- {{domxref("RTCIceTransport.selectedcandidatepairchange_event", "selectedcandidatepairchange")}}
- : Sent to the `RTCIceTransport` when a new, better pair of candidates has been selected to describe the connectivity between the two peers. This occurs during negotiation or renegotiation, including after an ICE restart, which reuses the existing `RTCIceTransport` objects. The current candidate pair can be obtained using {{domxref("RTCIceTransport.getSelectedCandidatePair", "getSelectedCandidatePair()")}}.
Also available using the {{domxref("RTCIceTransport.selectedcandidatepairchange_event", "onselectedcandidatepairchange")}} event handler property.
- {{domxref("RTCIceTransport.statechange_event", "statechange")}}
- : Sent to the `RTCIceTransport` instance when the value of the {{domxref("RTCIceTransport.state", "state")}} property has changed, indicating that the ICE gathering process has changed state.
Also available through the {{domxref("RTCIceTransport.statechange_event", "onstatechange")}} event handler property.
## Examples
tbd
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/rtcicetransport | data/mdn-content/files/en-us/web/api/rtcicetransport/component/index.md | ---
title: "RTCIceTransport: component property"
short-title: component
slug: Web/API/RTCIceTransport/component
page-type: web-api-instance-property
browser-compat: api.RTCIceTransport.component
---
{{APIRef("WebRTC")}}
The read-only **{{domxref("RTCIceTransport")}}**
property **`component`** specifies whether the object is
serving to transport {{Glossary("RTP")}} or {{Glossary("RTCP")}}.
## Value
A string which is one of the following:
- `rtp`
- : Identifies an ICE transport which is being used for the [Real-time Transport Protocol](/en-US/docs/Web/API/WebRTC_API/Intro_to_RTP) (RTP), or for RTP multiplexed with the RTP Control Protocol (RTCP). RTP is defined in {{RFC(3550)}}. This value corresponds to the component ID field in the `candidate` a-line with the value 1.
- `rtcp`
- : Identifies an ICE transport being used for RTCP, which is defined in {{RFC(3550, "", 6)}}. This value corresponds to the component ID 2.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/rtcicetransport | data/mdn-content/files/en-us/web/api/rtcicetransport/getlocalcandidates/index.md | ---
title: "RTCIceTransport: getLocalCandidates() method"
short-title: getLocalCandidates()
slug: Web/API/RTCIceTransport/getLocalCandidates
page-type: web-api-instance-method
browser-compat: api.RTCIceTransport.getLocalCandidates
---
{{APIRef("WebRTC")}}
The **{{domxref("RTCIceTransport")}}** method
**`getLocalCandidates()`** returns an array of
{{domxref("RTCIceCandidate")}} objects, one for each of the candidates that have been
gathered by the local device during the current {{Glossary("ICE")}} agent
session.
The local candidates are placed in this list by the ICE agent prior to being delivered
to the local client's code in an {{domxref("RTCPeerConnection.icecandidate_event", "icecandidate")}} event so that the client can
forward the candidates to the remote peer.
## Syntax
```js-nolint
getLocalCandidates()
```
### Parameters
None.
### Return value
A JavaScript {{jsxref("Array")}} containing one {{domxref("RTCIceCandidate")}} object
for each candidate that has been identified so far during the ICE candidate gathering
session.
You can't correlate these local candidates with matching remote candidates. To find the
best match found so far, call {{domxref("RTCIceTransport.getSelectedCandidatePair()")}}.
## Examples
This simple example gets the local candidate list from the
{{domxref("RTCIceTransport")}} for the first {{domxref("RTCRtpSender")}} on the
{{domxref("RTCPeerConnection")}}, then outputs to the console all of the candidates in
the list.
```js
const localCandidates = pc
.getSenders()[0]
.transport.transport.getLocalCandidates();
localCandidates.forEach((candidate, index) => {
console.log(`Candidate ${index}: ${candidate.candidate}`);
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/rtcicetransport | data/mdn-content/files/en-us/web/api/rtcicetransport/getselectedcandidatepair/index.md | ---
title: "RTCIceTransport: getSelectedCandidatePair() method"
short-title: getSelectedCandidatePair()
slug: Web/API/RTCIceTransport/getSelectedCandidatePair
page-type: web-api-instance-method
browser-compat: api.RTCIceTransport.getSelectedCandidatePair
---
{{APIRef("WebRTC")}}
The {{domxref("RTCIceTransport")}} method
**`getSelectedCandidatePair()`** returns an
{{domxref("RTCIceCandidatePair")}} object containing the current best-choice pair
of {{Glossary("ICE")}} candidates describing the configuration of the endpoints of the transport.
## Syntax
```js-nolint
getSelectedCandidatePair()
```
### Parameters
None.
### Return value
A {{domxref("RTCIceCandidatePair")}} object describing the configurations of the
currently-selected candidate pair's two endpoints.
{{domxref("RTCIceCandidatePair.local", "local")}} describes the configuration of the
local end of the connection, while {{domxref("RTCIceCandidatePair.remote", "remote")}}
describes the remote peer's configuration.
The return value is `null` if no pair of candidates has been selected yet.
## Usage notes
As the ICE agent performs negotiation of a {{domxref("RTCPeerConnection")}}, it gathers
and analyzes candidate configurations from each the two peers. As soon as it finds an
acceptable matching pair of candidates, meeting the requirements for the connection, a
{{domxref("RTCIceTransport.selectedcandidatepairchange_event", "selectedcandidatepairchange")}} event is fired at the
{{domxref("RTCIceTransport")}}. From that time forward, the best matching pair of
candidates will always be available by calling
`getSelectedCandidatePair()`.
As ICE negotiation continues, any time a pair of candidates is discovered that is
better than the currently-selected pair, the new pair is selected, replacing the
previous pairing, and the `selectedcandidatepairchange` event is fired again.
> **Note:** It's possible for one of the configurations in the selected candidate pair to remain unchanged when a new pairing is chosen.
## Examples
See [`RTCIceTransport.onselectedcandidatepairchange`](/en-US/docs/Web/API/RTCIceTransport/selectedcandidatepairchange_event#examples) for example code.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/rtcicetransport | data/mdn-content/files/en-us/web/api/rtcicetransport/getremoteparameters/index.md | ---
title: "RTCIceTransport: getRemoteParameters() method"
short-title: getRemoteParameters()
slug: Web/API/RTCIceTransport/getRemoteParameters
page-type: web-api-instance-method
browser-compat: api.RTCIceTransport.getRemoteParameters
---
{{APIRef("WebRTC")}}
The **{{domxref("RTCIceTransport")}}** method
**`getRemoteParameters()`** returns an
{{domxref("RTCIceParameters")}} object which provides information uniquely
identifying the remote peer for the duration of the ICE session.
The remote peer's parameters are received during ICE signaling and delivered to the
transport when the client calls
{{domxref("RTCPeerConnection.setRemoteDescription()")}}.
## Syntax
```js-nolint
getRemoteParameters()
```
### Parameters
None.
### Return value
An {{domxref("RTCIceParameters")}} object indicating the
{{domxref("RTCIceParameters.usernameFragment", "usernameFragment")}} and
{{domxref("RTCIceParameters.password", "password")}} which uniquely identify the
remote peer for the duration of the ICE session.
Returns `null` if the parameters haven't been received yet.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/rtcicetransport | data/mdn-content/files/en-us/web/api/rtcicetransport/gatheringstatechange_event/index.md | ---
title: "RTCIceTransport: gatheringstatechange event"
short-title: gatheringstatechange
slug: Web/API/RTCIceTransport/gatheringstatechange_event
page-type: web-api-event
browser-compat: api.RTCIceTransport.gatheringstatechange_event
---
{{APIRef("WebRTC")}}
A **`gatheringstatechange`** event is sent to an {{domxref("RTCIceTransport")}} when its {{Glossary("ICE")}} candidate gathering state changes.
The gathering state, whose actual status can be found in the transport object's {{domxref("RTCIceTransport.gatheringState", "gatheringState")}} property, indicates whether or not the ICE agent has begun gathering candidates, and if so, if it has finished doing so.
The key difference between `gatheringstatechange` and {{domxref("RTCPeerConnection.icegatheringstatechange_event", "icegatheringstatechange")}} is that the latter represents the overall state of the connection including every {{domxref("RTCIceTransport")}} used by every {{domxref("RTCRtpSender")}} and every {{domxref("RTCRtpReceiver")}} on the entire connection. In contrast, `gatheringstatechange` represents changes to the candidate gathering state for a single transport.
This event is not cancelable and does not bubble.
## Syntax
Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property.
```js
addEventListener("gatheringstatechange", (event) => {});
ongatheringstatechange = (event) => {};
```
## Event type
A generic {{domxref("Event")}}.
## Examples
This example creates a handler for `gatheringstatechange` events on each {{domxref("RTCRtpSender")}} associated with a given {{domxref("RTCPeerConnection")}}. Here, the {{domxref("EventTarget.addEventListener", "addEventListener()")}} method is called to add a listener for `gatheringstatechange` events:
```js
pc.getSenders().forEach((sender) => {
sender.transport.iceTransport.addEventListener(
"gatheringstatechange",
(ev) => {
let transport = ev.target;
if (transport.gatheringState === "complete") {
/* this transport has finished gathering candidates,
but others may still be working on it */
}
},
false,
);
});
```
Likewise, you can use the `ongatheringstatechange` event handler property:
```js
pc.getSenders().forEach((sender) => {
sender.transport.iceTransport.ongatheringstatechange = (ev) => {
let transport = ev.target;
if (transport.gatheringState === "complete") {
/* this transport has finished gathering candidates,
but others may still be working on it */
}
};
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [WebRTC API](/en-US/docs/Web/API/WebRTC_API)
- [WebRTC connectivity](/en-US/docs/Web/API/WebRTC_API/Connectivity)
### Related RTCIceTransport events
- {{domxref("RTCIceTransport/statechange_event", "statechange")}}
- {{domxref("RTCIceTransport.selectedcandidatepairchange_event", "selectedcandidatepairchange")}}
### Related RTCPeerConnection events
- {{domxref("RTCPeerConnection.negotiationneeded_event", "negotiationneeded")}}
- {{domxref("RTCPeerConnection.signalingstatechange_event", "signalingstatechange")}}
- {{domxref("RTCPeerConnection.iceconnectionstatechange_event", "iceconnectionstatechange")}}
- {{domxref("RTCPeerConnection.icegatheringstatechange_event", "icegatheringstatechange")}}
- {{domxref("RTCPeerConnection.connectionstatechange_event", "connectionstatechange")}}
| 0 |
data/mdn-content/files/en-us/web/api/rtcicetransport | data/mdn-content/files/en-us/web/api/rtcicetransport/getremotecandidates/index.md | ---
title: "RTCIceTransport: getRemoteCandidates() method"
short-title: getRemoteCandidates()
slug: Web/API/RTCIceTransport/getRemoteCandidates
page-type: web-api-instance-method
browser-compat: api.RTCIceTransport.getRemoteCandidates
---
{{APIRef("WebRTC")}}
The **{{domxref("RTCIceTransport")}}** method
**`getRemoteCandidates()`** returns an array which contains
one {{domxref("RTCIceCandidate")}} for each of the candidates that have been received
from the remote peer so far during the current {{Glossary("ICE")}} gathering
session.
Each time your signaling code calls {{domxref("RTCPeerConnection.addIceCandidate()")}}
to add a received candidate to the ICE session, the ICE agent places it in the list
returned by this function.
## Syntax
```js-nolint
getRemoteCandidates()
```
### Parameters
None.
### Return value
An array containing one {{domxref("RTCIceCandidate")}} object for each candidate that
has been received so far from the remote peer during the current ICE candidate gathering
session.
It's important to keep in mind that there's no way to correlate these remote candidates
with compatible local candidates. To find the best match found so far, call
{{domxref("RTCIceTransport.getSelectedCandidatePair()")}}.
## Example
This simple example gets the remote candidate list from the
{{domxref("RTCIceTransport")}} for the first {{domxref("RTCRtpSender")}} on the
{{domxref("RTCPeerConnection")}}, then outputs to the console all of the candidates in
the list.
```js
const remoteCandidates = pc
.getSenders()[0]
.transport.transport.getRemoteCandidates();
remoteCandidates.forEach((candidate, index) => {
console.log(`Candidate ${index}: ${candidate.candidate}`);
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/rtcicetransport | data/mdn-content/files/en-us/web/api/rtcicetransport/role/index.md | ---
title: "RTCIceTransport: role property"
short-title: role
slug: Web/API/RTCIceTransport/role
page-type: web-api-instance-property
browser-compat: api.RTCIceTransport.role
---
{{APIRef("WebRTC")}}
The read-only **{{domxref("RTCIceTransport")}}**
property **`role`** indicates which {{Glossary("ICE")}} role
the transport is fulfilling: that of the controlling agent, or the agent that is being
controlled.
You can learn more about ICE roles in
[Choosing a candidate pair](/en-US/docs/Web/API/WebRTC_API/Connectivity#choosing_a_candidate_pair).
## Value
A string specifying whether the {{domxref("RTCIceTransport")}} represents the controlling agent or the controlled agent.
The value must be one of the following:
- `"controlled"`
- : The transport is the controlled agent.
- `"controlling"`
- : The {{domxref("RTCIceTransport")}} object is serving as the controlling agent.
- `"unknown"`
- : The role has not yet been determined.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/rtcicetransport | data/mdn-content/files/en-us/web/api/rtcicetransport/statechange_event/index.md | ---
title: "RTCIceTransport: statechange event"
short-title: statechange
slug: Web/API/RTCIceTransport/statechange_event
page-type: web-api-event
browser-compat: api.RTCIceTransport.statechange_event
---
{{APIRef("WebRTC")}}
A **`statechange`** event occurs when the {{domxref("RTCIceTransport")}} changes state. The {{domxref("RTCIceTransport.state", "state")}} can be used to determine how far through the process of examining, verifying, and selecting a valid candidate pair is prior to successfully connecting the two peers for WebRTC communications.
This event is not cancelable and does not bubble.
## Syntax
Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property.
```js
addEventListener("statechange", (event) => {});
onstatechange = (event) => {};
```
## Event type
A generic {{domxref("Event")}}.
## Examples
Given an {{domxref("RTCPeerConnection")}}, `pc`, the following code creates an event handler that calls a function named `handleFailure()` if the ICE transport enters a failure state.
```js
let iceTransport = pc.getSenders()[0].transport.iceTransport;
iceTransport.addEventListener(
"statechange",
(ev) => {
if (iceTransport.state === "failed") {
handleFailure(pc);
}
},
false,
);
```
The same code, using the `onstatechange` event handler property, looks like this:
```js
let iceTransport = pc.getSenders()[0].transport.iceTransport;
iceTransport.onstatechange = (ev) => {
if (iceTransport.state === "failed") {
handleFailure(pc);
}
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [WebRTC API](/en-US/docs/Web/API/WebRTC_API)
- [WebRTC connectivity](/en-US/docs/Web/API/WebRTC_API/Connectivity)
### Related RTCIceTransport events
- {{domxref("RTCIceTransport.gatheringstatechange_event", "gatheringstatechange")}}
- {{domxref("RTCIceTransport.selectedcandidatepairchange_event", "selectedcandidatepairchange")}}
### Related RTCPeerConnection events
- {{domxref("RTCPeerConnection.negotiationneeded_event", "negotiationneeded")}}
- {{domxref("RTCPeerConnection.signalingstatechange_event", "signalingstatechange")}}
- {{domxref("RTCPeerConnection.iceconnectionstatechange_event", "iceconnectionstatechange")}}
- {{domxref("RTCPeerConnection.icegatheringstatechange_event", "icegatheringstatechange")}}
- {{domxref("RTCPeerConnection.connectionstatechange_event", "connectionstatechange")}}
| 0 |
data/mdn-content/files/en-us/web/api/rtcicetransport | data/mdn-content/files/en-us/web/api/rtcicetransport/state/index.md | ---
title: "RTCIceTransport: state property"
short-title: state
slug: Web/API/RTCIceTransport/state
page-type: web-api-instance-property
browser-compat: api.RTCIceTransport.state
---
{{APIRef("WebRTC")}}
The read-only **{{domxref("RTCIceTransport")}}**
property **`state`** returns the current state of the ICE
transport, so you can determine the state of ICE gathering in which the ICE agent
currently is operating.
This differs from the {{domxref("RTCIceTransport.gatheringState", "gatheringState")}},
which only indicates whether or not ICE gathering is currently underway.
## Value
A string whose value is one of the following:
- `"new"`
- : The {{domxref("RTCIceTransport")}} is currently gathering local candidates, or is waiting for the remote device to begin to transmit the remote candidates, or both. In this state, checking of candidates to look for those which might be acceptable has not yet begun.
- `"checking"`
- : At least one remote candidate has been received, and the `RTCIceTransport` has begun examining pairings of remote and local candidates in order to attempt to identify viable pairs that could be used to establish a connection. Keep in mind that gathering of local candidates may still be underway, and, similarly, the remote device also may still be gathering candidates of its own.
- `"connected"`
- : A viable candidate pair has been found and selected, and the `RTCIceTransport` has connected the two peers together using that pair. However, there are still candidates pairings to consider, and there may still be gathering underway on one or both of the two devices.
The transport may revert from the `"connected"` state to the `"checking"` state if either peer decides to cancel consent to use the selected candidate pair, and may revert to `"disconnected"` if there are no candidates left to check but one or both clients are still gathering candidates.
- `"completed"`
- : The transport has finished gathering local candidates and has received a notification from the remote peer that no more candidates will be sent. In addition, all candidate pairs have been considered and a pair has been selected for use. If consent checks fail on all successful candidate pairs, the transport state will change to `"failed"`.
- `"disconnected"`
- : The ICE agent has determined that connectivity has been lost for this {{domxref("RTCIceTransport")}}. This is not a failure state (that's `"failed"`). A value of `"disconnected"` means that a transient issue has occurred that has broken the connection, but that should resolve itself automatically without your code having to take any action. See [The disconnected state](#the_disconnected_state) for additional details.
- `"failed"`
- : The `RTCIceTransport` has finished the gathering process, has received the "no more candidates" notification from the remote peer, and has finished checking pairs of candidates, without successfully finding a pair that is both valid and for which consent can be obtained. _This is a terminal state, indicating that the connection cannot be achieved or maintained._
- `"closed"`
- : The transport has shut down and is no longer responding to STUN requests.
## Usage notes
If an ICE restart occurs, the candidate gathering and connectivity check process is started over again; this will cause a transition from the `"connected"` state if the restart occurred while the state was `"completed"`. If the restart occurred during a transient `"disconnected"` state, the state transitions to `"checking"`
### The disconnected state
`"disconnected"` is a transient state that occurs when the connection between the two peers fails in a manner that the WebRTC infrastructure can automatically correct once the connection is available again. It is _not_ a failure state. Instead, you can think of `"disconnected"` as being similar to `"checking"` but with the added information that the connection had been working but at the moment is not.
Every {{Glossary("user agent")}} and platform may have its own scenarios that can trigger the `"disconnected"` state. Possible causes include:
- The network interface being used by the connection has gone offline.
- {{Glossary("STUN")}} requests being sent to the remote device have gone unanswered repeatedly.
The `"disconnected"` state can also occur when the transport has finished checking all existing candidate pairs and has not found a pair that will work—or a valid pair was found but rejected due to consent to use the pair being denied. In this scenario, the transport is still continuing to gather candidates, and/or to wait for candidates to be sent by the remote peer.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/rtcicetransport | data/mdn-content/files/en-us/web/api/rtcicetransport/getlocalparameters/index.md | ---
title: "RTCIceTransport: getLocalParameters() method"
short-title: getLocalParameters()
slug: Web/API/RTCIceTransport/getLocalParameters
page-type: web-api-instance-method
browser-compat: api.RTCIceTransport.getLocalParameters
---
{{APIRef("WebRTC")}}
The **{{domxref("RTCIceTransport")}}** method
**`getLocalParameters()`** returns an
{{domxref("RTCIceParameters")}} object which provides information uniquely identifying
the local peer for the duration of the ICE session.
The local peer's parameters are obtained during ICE signaling and delivered to the
transport when the client calls {{domxref("RTCPeerConnection.setLocalDescription()")}}.
## Syntax
```js-nolint
getLocalParameters()
```
### Parameters
None.
### Return value
An {{domxref("RTCIceParameters")}} object indicating the
{{domxref("RTCIceParameters.usernameFragment", "usernameFragment")}} and
{{domxref("RTCIceParameters.password", "password")}} which uniquely identify the local
peer for the duration of the ICE session.
Returns `null` if the parameters have not yet been received.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/rtcicetransport | data/mdn-content/files/en-us/web/api/rtcicetransport/gatheringstate/index.md | ---
title: "RTCIceTransport: gatheringState property"
short-title: gatheringState
slug: Web/API/RTCIceTransport/gatheringState
page-type: web-api-instance-property
browser-compat: api.RTCIceTransport.gatheringState
---
{{APIRef("WebRTC")}}
The read-only property **`gatheringState`** property of the {{domxref("RTCIceTransport")}} interface returns a string that indicates the current gathering state of the ICE agent: `"new"`, `"gathering"`, or `"complete"`.
## Value
A string that indicates the current state of the ICE agent's candidate gathering process:
- `"new"`
- : The {{domxref("RTCIceTransport")}} is newly created and has not yet started to gather ICE candidates.
- `"gathering"`
- : The transport is in the process of gathering candidates.
- `"complete"`
- : The transport has finished gathering ICE candidates and has sent the end-of-candidates indicator to the remote device. The transport won't gather any further candidates unless an [ICE restart](/en-US/docs/Web/API/WebRTC_API/Session_lifetime#ice_restart) occurs, at which point the gathering process starts over from scratch.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/rtcicetransport | data/mdn-content/files/en-us/web/api/rtcicetransport/selectedcandidatepairchange_event/index.md | ---
title: "RTCIceTransport: selectedcandidatepairchange event"
short-title: selectedcandidatepairchange
slug: Web/API/RTCIceTransport/selectedcandidatepairchange_event
page-type: web-api-event
browser-compat: api.RTCIceTransport.selectedcandidatepairchange_event
---
{{APIRef("WebRTC")}}
A **`selectedcandidatepairchange`** event is sent to an {{domxref("RTCIceTransport")}} when the {{Glossary("ICE")}} agent selects a new pair of candidates that describe the endpoints of a viable connection.
The pair of candidates is in turn described by an {{domxref("RTCIceCandidatePair")}} object which contains one {{domxref("RTCIceCandidate")}} representing the local end of the connection, and another representing the remote end of the connection.
Together, the candidates can be used to establish a connection to be used by the {{domxref("RTCIceTransport")}}, and, by extension, by an {{domxref("RTCPeerConnection")}}.
This event is not cancelable and does not bubble.
## Syntax
Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property.
```js
addEventListener("selectedcandidatepairchange", (event) => {});
onselectedcandidatepairchange = (event) => {};
```
## Event type
A generic {{domxref("Event")}}.
## Examples
This example creates an event handler for `selectedcandidatepairchange` that updates a display providing the user information about the progress of the ICE negotiation for an {{domxref("RTCPeerConnection")}} called `pc`.
```js
let iceTransport = pc.getSenders[0].transport.iceTransport;
let localProtoElem = document.getElementById("local-protocol");
let remoteProtoElem = document.getElementById("remote-protocol");
iceTransport.addEventListener(
"selectedcandidatepairchange",
(ev) => {
let pair = iceTransport.getSelectedCandidatePair();
localProtoElem.innerText = pair.local.protocol.toUpperCase();
remoteProtoElem.innerText = pair.remote.protocol.toUpperCase();
},
false,
);
```
This can also be done by setting the `onselectedcandidatepairchange` event handler property directly.
```js
let iceTransport = pc.getSenders[0].transport.iceTransport;
let localProtoElem = document.getElementById("local-protocol");
let remoteProtoElem = document.getElementById("remote-protocol");
iceTransport.onselectedcandidatepairchange = (ev) => {
let pair = iceTransport.getSelectedCandidatePair();
localProtoElem.innerText = pair.local.protocol.toUpperCase();
remoteProtoElem.innerText = pair.remote.protocol.toUpperCase();
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [WebRTC API](/en-US/docs/Web/API/WebRTC_API)
- [WebRTC connectivity](/en-US/docs/Web/API/WebRTC_API/Connectivity)
### Related RTCIceTransport events
- {{domxref("RTCIceTransport/statechange_event", "statechange")}}
- {{domxref("RTCIceTransport.gatheringstatechange_event", "gatheringstatechange")}}
### Related RTCPeerConnection events
- {{domxref("RTCPeerConnection.negotiationneeded_event", "negotiationneeded")}}
- {{domxref("RTCPeerConnection.signalingstatechange_event", "signalingstatechange")}}
- {{domxref("RTCPeerConnection.iceconnectionstatechange_event", "iceconnectionstatechange")}}
- {{domxref("RTCPeerConnection.icegatheringstatechange_event", "icegatheringstatechange")}}
- {{domxref("RTCPeerConnection.connectionstatechange_event", "connectionstatechange")}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/filesystemsyncaccesshandle/index.md | ---
title: FileSystemSyncAccessHandle
slug: Web/API/FileSystemSyncAccessHandle
page-type: web-api-interface
browser-compat: api.FileSystemSyncAccessHandle
---
{{securecontext_header}}{{APIRef("File System API")}}
The **`FileSystemSyncAccessHandle`** interface of the {{domxref("File System API", "File System API", "", "nocode")}} represents a synchronous handle to a file system entry.
This class is only accessible inside dedicated [Web Workers](/en-US/docs/Web/API/Web_Workers_API) (so that its methods do not block execution on the main thread) for files within the [origin private file system](/en-US/docs/Web/API/File_System_API/Origin_private_file_system), which is not visible to end-users.
As a result, its methods are not subject to the same security checks as methods running on files within the user-visible file system, and so are much more performant. This makes them suitable for significant, large-scale file updates such as [SQLite](https://www.sqlite.org/wasm) database modifications.
The interface is accessed through the {{domxref('FileSystemFileHandle.createSyncAccessHandle()')}} method.
> **Note:** In earlier versions of the spec, {{domxref("FileSystemSyncAccessHandle.close()", "close()")}}, {{domxref("FileSystemSyncAccessHandle.flush()", "flush()")}}, {{domxref("FileSystemSyncAccessHandle.getSize()", "getSize()")}}, and {{domxref("FileSystemSyncAccessHandle.truncate()", "truncate()")}} were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.
## Instance properties
None.
## Instance methods
- {{domxref('FileSystemSyncAccessHandle.close', 'close()')}}
- : Closes an open synchronous file handle, disabling any further operations on it and releasing the exclusive lock previously put on the file associated with the file handle.
- {{domxref('FileSystemSyncAccessHandle.flush', 'flush()')}}
- : Persists any changes made to the file associated with the handle via the {{domxref('FileSystemSyncAccessHandle.write', 'write()')}} method to disk.
- {{domxref('FileSystemSyncAccessHandle.getSize', 'getSize()')}}
- : Returns the size of the file associated with the handle in bytes.
- {{domxref('FileSystemSyncAccessHandle.read', 'read()')}}
- : Reads the content of the file associated with the handle into a specified buffer, optionally at a given offset.
- {{domxref('FileSystemSyncAccessHandle.truncate', 'truncate()')}}
- : Resizes the file associated with the handle to a specified number of bytes.
- {{domxref('FileSystemSyncAccessHandle.write', 'write()')}}
- : Writes the content of a specified buffer to the file associated with the handle, optionally at a given offset.
## Examples
The following asynchronous event handler function is contained inside a Web Worker. On receiving a message from the main thread it:
- Creates a synchronous file access handle.
- Gets the size of the file and creates an {{jsxref("ArrayBuffer")}} to contain it.
- Reads the file contents into the buffer.
- Encodes the message and writes it to the end of the file.
- Persists the changes to disk and closes the access handle.
```js
onmessage = async (e) => {
// Retrieve message sent to work from main script
const message = e.data;
// Get handle to draft file
const root = await navigator.storage.getDirectory();
const draftHandle = await root.getFileHandle("draft.txt", { create: true });
// Get sync access handle
const accessHandle = await draftHandle.createSyncAccessHandle();
// Get size of the file.
const fileSize = accessHandle.getSize();
// Read file content to a buffer.
const buffer = new DataView(new ArrayBuffer(fileSize));
const readBuffer = accessHandle.read(buffer, { at: 0 });
// Write the message to the end of the file.
const encoder = new TextEncoder();
const encodedMessage = encoder.encode(message);
const writeBuffer = accessHandle.write(encodedMessage, { at: readBuffer });
// Persist changes to disk.
accessHandle.flush();
// Always close FileSystemSyncAccessHandle if done.
accessHandle.close();
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [File System API](/en-US/docs/Web/API/File_System_API)
- [The File System Access API: simplifying access to local files](https://developer.chrome.com/docs/capabilities/web-apis/file-system-access)
| 0 |
data/mdn-content/files/en-us/web/api/filesystemsyncaccesshandle | data/mdn-content/files/en-us/web/api/filesystemsyncaccesshandle/truncate/index.md | ---
title: "FileSystemSyncAccessHandle: truncate() method"
short-title: truncate()
slug: Web/API/FileSystemSyncAccessHandle/truncate
page-type: web-api-instance-method
browser-compat: api.FileSystemSyncAccessHandle.truncate
---
{{securecontext_header}}{{APIRef("File System API")}}
The **`truncate()`** method of the
{{domxref("FileSystemSyncAccessHandle")}} interface resizes the file associated with the handle to a specified number of bytes.
> **Note:** In earlier versions of the spec, {{domxref("FileSystemSyncAccessHandle.close()", "close()")}}, {{domxref("FileSystemSyncAccessHandle.flush()", "flush()")}}, {{domxref("FileSystemSyncAccessHandle.getSize()", "getSize()")}}, and `truncate()` were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.
## Syntax
```js-nolint
truncate(newSize)
```
### Parameters
- `newSize`
- : The number of bytes to resize the file to.
### Return value
None ({{jsxref('undefined')}}).
### Exceptions
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the associated access handle is already closed, or if the modification of the file's binary data otherwise fails.
- `QuotaExceededError` {{domxref("DOMException")}}
- : Thrown if the `newSize` is larger than the original size of the file, and exceeds the browser's [storage quota](/en-US/docs/Web/API/Storage_API/Storage_quotas_and_eviction_criteria).
- {{jsxref("TypeError")}}
- : Thrown if the underlying file system does not support setting the file size to the new size.
## Examples
```js
async function truncateFile() {
// Get handle to draft file
const root = await navigator.storage.getDirectory();
const draftHandle = await root.getFileHandle("draft.txt", { create: true });
// Get sync access handle
const accessHandle = await draftHandle.createSyncAccessHandle();
// Truncate the file to 0 bytes
accessHandle.truncate(0);
// Persist changes to disk.
accessHandle.flush();
// Always close FileSystemSyncAccessHandle if done.
accessHandle.close();
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [File System API](/en-US/docs/Web/API/File_System_API)
- [The File System Access API: simplifying access to local files](https://developer.chrome.com/docs/capabilities/web-apis/file-system-access)
| 0 |
data/mdn-content/files/en-us/web/api/filesystemsyncaccesshandle | data/mdn-content/files/en-us/web/api/filesystemsyncaccesshandle/flush/index.md | ---
title: "FileSystemSyncAccessHandle: flush() method"
short-title: flush()
slug: Web/API/FileSystemSyncAccessHandle/flush
page-type: web-api-instance-method
browser-compat: api.FileSystemSyncAccessHandle.flush
---
{{securecontext_header}}{{APIRef("File System API")}}
The **`flush()`** method of the
{{domxref("FileSystemSyncAccessHandle")}} interface persists any changes made to the file associated with the handle via the {{domxref('FileSystemSyncAccessHandle.write', 'write()')}} method to disk.
Bear in mind that you only need to call this method if you need the changes committed to disk at a specific time, otherwise you can leave the underlying operating system to handle this when it sees fit, which should be OK in most cases.
> **Note:** In earlier versions of the spec, {{domxref("FileSystemSyncAccessHandle.close()", "close()")}}, `flush()`, {{domxref("FileSystemSyncAccessHandle.getSize()", "getSize()")}}, and {{domxref("FileSystemSyncAccessHandle.truncate()", "truncate()")}} were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.
## Syntax
```js-nolint
flush()
```
### Parameters
None.
### Return value
None ({{jsxref('undefined')}}).
### Exceptions
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the associated access handle is already closed.
## Examples
The following asynchronous event handler function is contained inside a Web Worker. On receiving a message from the main thread it:
- Creates a synchronous file access handle.
- Gets the size of the file and creates an {{jsxref("ArrayBuffer")}} to contain it.
- Reads the file contents into the buffer.
- Encodes the message and writes it to the end of the file.
- Persists the changes to disk and closes the access handle.
```js
onmessage = async (e) => {
// Retrieve message sent to work from main script
const message = e.data;
// Get handle to draft file
const root = await navigator.storage.getDirectory();
const draftHandle = await root.getFileHandle("draft.txt", { create: true });
// Get sync access handle
const accessHandle = await draftHandle.createSyncAccessHandle();
// Get size of the file.
const fileSize = accessHandle.getSize();
// Read file content to a buffer.
const buffer = new DataView(new ArrayBuffer(fileSize));
const readBuffer = accessHandle.read(buffer, { at: 0 });
// Write the message to the end of the file.
const encoder = new TextEncoder();
const encodedMessage = encoder.encode(message);
const writeBuffer = accessHandle.write(encodedMessage, { at: readBuffer });
// Persist changes to disk.
accessHandle.flush();
// Always close FileSystemSyncAccessHandle if done.
accessHandle.close();
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [File System API](/en-US/docs/Web/API/File_System_API)
- [The File System Access API: simplifying access to local files](https://developer.chrome.com/docs/capabilities/web-apis/file-system-access)
| 0 |
data/mdn-content/files/en-us/web/api/filesystemsyncaccesshandle | data/mdn-content/files/en-us/web/api/filesystemsyncaccesshandle/read/index.md | ---
title: "FileSystemSyncAccessHandle: read() method"
short-title: read()
slug: Web/API/FileSystemSyncAccessHandle/read
page-type: web-api-instance-method
browser-compat: api.FileSystemSyncAccessHandle.read
---
{{securecontext_header}}{{APIRef("File System API")}}
The **`read()`** method of the
{{domxref("FileSystemSyncAccessHandle")}} interface reads the content of the file associated with the handle into a specified buffer, optionally at a given offset.
## Syntax
```js-nolint
read(buffer, options)
```
### Parameters
- `buffer`
- : An {{jsxref("ArrayBuffer")}} or `ArrayBufferView` (such as a {{jsxref("DataView")}}) representing the buffer that the file content should be read into. Note that you cannot directly manipulate the contents of an `ArrayBuffer`. Instead, you create one of the typed array objects like an {{jsxref("Int8Array")}} or a {{jsxref("DataView")}} object which represents the buffer in a specific format, and use that to read and write the contents of the buffer.
- `options` {{optional_inline}}
- : An options object containing the following properties:
- `at`
- : A number representing the offset in bytes that the file should be read from.
### Return value
A number representing the number of bytes read from the file.
### Exceptions
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the associated access handle is already closed.
- {{jsxref("TypeError")}}
- : Thrown if the underlying file system does not support reading the file from the specified file offset.
## Examples
The following asynchronous event handler function is contained inside a Web Worker. On receiving a message from the main thread it:
- Creates a synchronous file access handle.
- Gets the size of the file and creates an {{jsxref("ArrayBuffer")}} to contain it.
- Reads the file contents into the buffer.
- Encodes the message and writes it to the end of the file.
- Persists the changes to disk and closes the access handle.
```js
onmessage = async (e) => {
// Retrieve message sent to work from main script
const message = e.data;
// Get handle to draft file
const root = await navigator.storage.getDirectory();
const draftHandle = await root.getFileHandle("draft.txt", { create: true });
// Get sync access handle
const accessHandle = await draftHandle.createSyncAccessHandle();
// Get size of the file.
const fileSize = accessHandle.getSize();
// Read file content to a buffer.
const buffer = new DataView(new ArrayBuffer(fileSize));
const readBuffer = accessHandle.read(buffer, { at: 0 });
// Write the message to the end of the file.
const encoder = new TextEncoder();
const encodedMessage = encoder.encode(message);
const writeBuffer = accessHandle.write(encodedMessage, { at: readBuffer });
// Persist changes to disk.
accessHandle.flush();
// Always close FileSystemSyncAccessHandle if done.
accessHandle.close();
};
```
> **Note:** In earlier versions of the spec, {{domxref("FileSystemSyncAccessHandle.close()", "close()")}}, {{domxref("FileSystemSyncAccessHandle.flush()", "flush()")}}, {{domxref("FileSystemSyncAccessHandle.getSize()", "getSize()")}}, and {{domxref("FileSystemSyncAccessHandle.truncate()", "truncate()")}} were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [File System API](/en-US/docs/Web/API/File_System_API)
- [The File System Access API: simplifying access to local files](https://developer.chrome.com/docs/capabilities/web-apis/file-system-access)
| 0 |
data/mdn-content/files/en-us/web/api/filesystemsyncaccesshandle | data/mdn-content/files/en-us/web/api/filesystemsyncaccesshandle/write/index.md | ---
title: "FileSystemSyncAccessHandle: write() method"
short-title: write()
slug: Web/API/FileSystemSyncAccessHandle/write
page-type: web-api-instance-method
browser-compat: api.FileSystemSyncAccessHandle.write
---
{{securecontext_header}}{{APIRef("File System API")}}
The **`write()`** method of the
{{domxref("FileSystemSyncAccessHandle")}} interface writes the content of a specified buffer to the file associated with the handle, optionally at a given offset.
Files within the [origin private file system](/en-US/docs/Web/API/File_System_API/Origin_private_file_system) are not visible to end-users, therefore are not subject to the same security checks as methods running on files within the user-visible file system. As a result, writes performed using `FileSystemSyncAccessHandle.write()` are much more performant. This makes them suitable for significant, large-scale file updates such as [SQLite](https://www.sqlite.org/wasm) database modifications.
## Syntax
```js-nolint
write(buffer, options)
```
### Parameters
- `buffer`
- : An {{jsxref("ArrayBuffer")}} or `ArrayBufferView` (such as a {{jsxref("DataView")}}) representing the buffer to be written to the file.
- `options` {{optional_inline}}
- : An options object containing the following properties:
- `at`
- : A number representing the offset in bytes from the start of the file that the buffer should be written at.
> **Note:** You cannot directly manipulate the contents of an `ArrayBuffer`. Instead, you create a typed array object like an {{jsxref("Int8Array")}} or a {{jsxref("DataView")}} object, which represents the buffer in a specific format, and use that to read and write the contents of the buffer.
### Return value
A number representing the number of bytes written to the file.
### Exceptions
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the associated access handle is already closed, or if the modification of the file's binary data completely fails.
- `QuotaExceededError` {{domxref("DOMException")}}
- : Thrown if the increased data capacity exceeds the browser's [storage quota](/en-US/docs/Web/API/Storage_API/Storage_quotas_and_eviction_criteria).
- {{jsxref("TypeError")}}
- : Thrown if the underlying file system does not support writing the file from the specified file offset.
## Examples
The following asynchronous event handler function is contained inside a Web Worker. On receiving a message from the main thread it:
- Creates a synchronous file access handle.
- Gets the size of the file and creates an {{jsxref("ArrayBuffer")}} to contain it.
- Reads the file contents into the buffer.
- Encodes the message and writes it to the end of the file.
- Persists the changes to disk and closes the access handle.
```js
onmessage = async (e) => {
// Retrieve message sent to work from main script
const message = e.data;
// Get handle to draft file
const root = await navigator.storage.getDirectory();
const draftHandle = await root.getFileHandle("draft.txt", { create: true });
// Get sync access handle
const accessHandle = await draftHandle.createSyncAccessHandle();
// Get size of the file.
const fileSize = accessHandle.getSize();
// Read file content to a buffer.
const buffer = new DataView(new ArrayBuffer(fileSize));
const readBuffer = accessHandle.read(buffer, { at: 0 });
// Write the message to the end of the file.
const encoder = new TextEncoder();
const encodedMessage = encoder.encode(message);
const writeBuffer = accessHandle.write(encodedMessage, { at: readBuffer });
// Persist changes to disk.
accessHandle.flush();
// Always close FileSystemSyncAccessHandle if done.
accessHandle.close();
};
```
> **Note:** In earlier versions of the spec, {{domxref("FileSystemSyncAccessHandle.close()", "close()")}}, {{domxref("FileSystemSyncAccessHandle.flush()", "flush()")}}, {{domxref("FileSystemSyncAccessHandle.getSize()", "getSize()")}}, and {{domxref("FileSystemSyncAccessHandle.truncate()", "truncate()")}} were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [File System API](/en-US/docs/Web/API/File_System_API)
- [The File System Access API: simplifying access to local files](https://developer.chrome.com/docs/capabilities/web-apis/file-system-access)
| 0 |
data/mdn-content/files/en-us/web/api/filesystemsyncaccesshandle | data/mdn-content/files/en-us/web/api/filesystemsyncaccesshandle/getsize/index.md | ---
title: "FileSystemSyncAccessHandle: getSize() method"
short-title: getSize()
slug: Web/API/FileSystemSyncAccessHandle/getSize
page-type: web-api-instance-method
browser-compat: api.FileSystemSyncAccessHandle.getSize
---
{{securecontext_header}}{{APIRef("File System API")}}
The **`getSize()`** method of the
{{domxref("FileSystemSyncAccessHandle")}} interface returns the size of the file associated with the handle in bytes.
> **Note:** In earlier versions of the spec, {{domxref("FileSystemSyncAccessHandle.close()", "close()")}}, {{domxref("FileSystemSyncAccessHandle.flush()", "flush()")}}, `getSize()`, and {{domxref("FileSystemSyncAccessHandle.truncate()", "truncate()")}} were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.
## Syntax
```js-nolint
getSize()
```
### Parameters
None.
### Return value
A number representing the size of the file in bytes.
### Exceptions
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the associated access handle is already closed.
## Examples
The following asynchronous event handler function is contained inside a Web Worker. On receiving a message from the main thread it:
- Creates a synchronous file access handle.
- Gets the size of the file and creates an {{jsxref("ArrayBuffer")}} to contain it.
- Reads the file contents into the buffer.
- Encodes the message and writes it to the end of the file.
- Persists the changes to disk and closes the access handle.
```js
onmessage = async (e) => {
// Retrieve message sent to work from main script
const message = e.data;
// Get handle to draft file
const root = await navigator.storage.getDirectory();
const draftHandle = await root.getFileHandle("draft.txt", { create: true });
// Get sync access handle
const accessHandle = await draftHandle.createSyncAccessHandle();
// Get size of the file.
const fileSize = accessHandle.getSize();
// Read file content to a buffer.
const buffer = new DataView(new ArrayBuffer(fileSize));
const readBuffer = accessHandle.read(buffer, { at: 0 });
// Write the message to the end of the file.
const encoder = new TextEncoder();
const encodedMessage = encoder.encode(message);
const writeBuffer = accessHandle.write(encodedMessage, { at: readBuffer });
// Persist changes to disk.
accessHandle.flush();
// Always close FileSystemSyncAccessHandle if done.
accessHandle.close();
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [File System API](/en-US/docs/Web/API/File_System_API)
- [The File System Access API: simplifying access to local files](https://developer.chrome.com/docs/capabilities/web-apis/file-system-access)
| 0 |
data/mdn-content/files/en-us/web/api/filesystemsyncaccesshandle | data/mdn-content/files/en-us/web/api/filesystemsyncaccesshandle/close/index.md | ---
title: "FileSystemSyncAccessHandle: close() method"
short-title: close()
slug: Web/API/FileSystemSyncAccessHandle/close
page-type: web-api-instance-method
browser-compat: api.FileSystemSyncAccessHandle.close
---
{{securecontext_header}}{{APIRef("File System API")}}
The **`close()`** method of the
{{domxref("FileSystemSyncAccessHandle")}} interface closes an open synchronous file handle, disabling any further operations on it and releasing the exclusive lock previously put on the file associated with the file handle.
> **Note:** In earlier versions of the spec, `close()`, {{domxref("FileSystemSyncAccessHandle.flush()", "flush()")}}, {{domxref("FileSystemSyncAccessHandle.getSize()", "getSize()")}}, and {{domxref("FileSystemSyncAccessHandle.truncate()", "truncate()")}} were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.
## Syntax
```js-nolint
close()
```
### Parameters
None.
### Return value
None ({{jsxref('undefined')}}).
### Exceptions
None.
## Examples
The following asynchronous event handler function is contained inside a Web Worker. On receiving a message from the main thread it:
- Creates a synchronous file access handle.
- Gets the size of the file and creates an {{jsxref("ArrayBuffer")}} to contain it.
- Reads the file contents into the buffer.
- Encodes the message and writes it to the end of the file.
- Persists the changes to disk and closes the access handle.
```js
onmessage = async (e) => {
// Retrieve message sent to work from main script
const message = e.data;
// Get handle to draft file
const root = await navigator.storage.getDirectory();
const draftHandle = await root.getFileHandle("draft.txt", { create: true });
// Get sync access handle
const accessHandle = await draftHandle.createSyncAccessHandle();
// Get size of the file.
const fileSize = accessHandle.getSize();
// Read file content to a buffer.
const buffer = new DataView(new ArrayBuffer(fileSize));
const readBuffer = accessHandle.read(buffer, { at: 0 });
// Write the message to the end of the file.
const encoder = new TextEncoder();
const encodedMessage = encoder.encode(message);
const writeBuffer = accessHandle.write(encodedMessage, { at: readBuffer });
// Persist changes to disk.
accessHandle.flush();
// Always close FileSystemSyncAccessHandle if done.
accessHandle.close();
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [File System API](/en-US/docs/Web/API/File_System_API)
- [The File System Access API: simplifying access to local files](https://developer.chrome.com/docs/capabilities/web-apis/file-system-access)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/fetch/index.md | ---
title: fetch() global function
short-title: fetch()
slug: Web/API/fetch
page-type: web-api-global-function
browser-compat: api.fetch
---
{{APIRef("Fetch API")}}{{AvailableInWorkers}}
The global **`fetch()`** method starts the process of fetching a resource from the network, returning a promise that is fulfilled once the response is available.
The promise resolves to the {{domxref("Response")}} object representing the response to your request.
A {{domxref("fetch()")}} promise only rejects when a network error is encountered (which is usually when there's a permissions issue or similar).
A {{domxref("fetch()")}} promise _does not_ reject on HTTP errors (`404`, etc.).
Instead, a `then()` handler must check the {{domxref("Response.ok")}} and/or {{domxref("Response.status")}} properties.
The `fetch()` method is controlled by the `connect-src` directive of [Content Security Policy](/en-US/docs/Web/HTTP/Headers/Content-Security-Policy) rather than the directive of the resources it's retrieving.
> **Note:** The `fetch()` method's parameters are identical to those of the {{domxref("Request.Request","Request()")}} constructor.
## Syntax
```js-nolint
fetch(resource)
fetch(resource, options)
```
### Parameters
- `resource`
- : This defines the resource that you wish to fetch. This can either be:
- A string or any other object with a {{Glossary("stringifier")}} — including a {{domxref("URL")}} object — that provides the URL of the resource you want to fetch.
- A {{domxref("Request")}} object.
- `options` {{optional_inline}}
- : An object containing any custom settings you want to apply to the request.
The possible options are:
- `method`
- : The request method, e.g., `"GET"`, `"POST"`.
The default is `"GET"`.
Note that the {{httpheader("Origin")}} header is not set on Fetch requests with a method of {{HTTPMethod("HEAD")}} or {{HTTPMethod("GET")}}.
Any string that is a case-insensitive match for one of the methods in [RFC 9110](https://www.rfc-editor.org/rfc/rfc9110#name-overview) will be uppercased automatically.
If you want to use a custom method (like `PATCH`), you should uppercase it yourself.
- `headers`
- : Any headers you want to add to your request, contained within a {{domxref("Headers")}} object or an object literal with {{jsxref("String")}} values.
Note that [some names are forbidden](/en-US/docs/Glossary/Forbidden_header_name).
> **Note:** The [`Authorization`](/en-US/docs/Web/HTTP/Headers/Authorization) HTTP header may be added to a request, but will be removed if the request is redirected cross-origin.
- `body`
- : Any body that you want to add to your request:
this can be a {{domxref("Blob")}}, an {{jsxref("ArrayBuffer")}}, a {{jsxref("TypedArray")}}, a {{jsxref("DataView")}},
a {{domxref("FormData")}}, a {{domxref("URLSearchParams")}}, string object or literal,
or a {{domxref("ReadableStream")}} object. This latest possibility is still experimental; check the [compatibility information](/en-US/docs/Web/API/Request#browser_compatibility) to verify you can use it.
Note that a request using the `GET` or `HEAD` method cannot have a body.
- `mode`
- : The [mode](/en-US/docs/Web/API/Request/mode) you want to use for the request, e.g., `cors`,
`no-cors`, or `same-origin`.
- `credentials`
- : Controls what browsers do with credentials ([cookies](/en-US/docs/Web/HTTP/Cookies), [HTTP authentication](/en-US/docs/Web/HTTP/Authentication) entries, and TLS client certificates). Must be one of the following strings:
- `omit`
- : Tells browsers to exclude credentials from the request, and ignore any credentials sent back in the response (e.g., any {{HTTPHeader("Set-Cookie")}} header).
- `same-origin`
- : Tells browsers to include credentials with requests to same-origin URLs, and use any credentials sent back in responses from same-origin URLs. **This is the default value.**
- `include`
- : Tells browsers to include credentials in both same- and cross-origin requests, and always use any credentials sent back in responses.
> **Note:** Credentials may be included in simple and "final" cross-origin requests, but should not be included in [CORS preflight requests](/en-US/docs/Web/HTTP/CORS#preflight_requests_and_credentials).
- `cache`
- : A string indicating how the request will interact with the browser's [HTTP cache](/en-US/docs/Web/HTTP/Caching). The possible values, `default`, `no-store`, `reload`, `no-cache`, `force-cache`, and `only-if-cached`, are documented in the article for the {{domxref("Request/cache", "cache")}} property of the {{domxref("Request")}} object.
- `redirect`
- : How to handle a `redirect` response:
- `follow`
- : Automatically follow redirects. Unless otherwise stated the redirect mode is set to `follow`.
- `error`
- : Abort with an error if a redirect occurs.
- `manual`
- : Caller intends to process the response in another context.
See [WHATWG fetch standard](https://fetch.spec.whatwg.org/#concept-request-redirect-mode) for more information.
- `referrer`
- : A string specifying the referrer of the request. This can be a
same-origin URL, `about:client`, or an empty string.
- `referrerPolicy`
- : Specifies the [referrer policy](https://w3c.github.io/webappsec-referrer-policy/#referrer-policies) to use for the request. May be one of `no-referrer`,
`no-referrer-when-downgrade`, `same-origin`,
`origin`, `strict-origin`,
`origin-when-cross-origin`,
`strict-origin-when-cross-origin`, or `unsafe-url`.
- `integrity`
- : Contains the [subresource integrity](/en-US/docs/Web/Security/Subresource_Integrity)
value of the request (e.g., `sha256-BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=`).
- `keepalive`
- : The `keepalive` option can be used to allow the request to outlive the page.
Fetch with the `keepalive` flag is a replacement for the {{domxref("Navigator.sendBeacon()")}} API.
- `signal`
- : An {{domxref("AbortSignal")}} object instance; allows you to communicate with a
fetch request and abort it if desired via an {{domxref("AbortController")}}.
- `priority`
- : Specifies the priority of the fetch request relative to other requests of the same type. Must be one of the following strings:
- `high`
- : A high-priority fetch request relative to other requests of the same type.
- `low`
- : A low-priority fetch request relative to other requests of the same type.
- `auto`
- : Automatically determine the priority of the fetch request relative to other requests of the same type (default).
### Return value
A {{jsxref("Promise")}} that resolves to a {{domxref("Response")}} object.
### Exceptions
- `AbortError` {{domxref("DOMException")}}
- : The request was aborted due to a call to the {{domxref("AbortController")}}
{{domxref("AbortController.abort", "abort()")}} method.
- {{jsxref("TypeError")}}
- : Can occur for the following reasons:
<table>
<thead>
<tr>
<th scope="col">Reason</th>
<th scope="col">Failing examples</th>
</tr>
</thead>
<tbody>
<tr>
<td>Invalid header name.</td>
<td>
<pre>
// space in "C ontent-Type"
const headers = {
'C ontent-Type': 'text/xml',
'Breaking-Bad': '<3',
};
fetch('https://example.com/', { headers });
</pre>
</td>
</tr>
<tr>
<td>
Invalid header value. The header object must contain exactly two elements.
</td>
<td>
<pre>
const headers = [
['Content-Type', 'text/html', 'extra'],
['Accept'],
];
fetch('https://example.com/', { headers });
</pre>
</td>
</tr>
<tr>
<td>
Invalid URL or scheme, or using a scheme that fetch does not support, or using a scheme that is not supported for a particular request mode.
</td>
<td>
<pre>
fetch('blob://example.com/', { mode: 'cors' });
</pre>
</td>
</tr>
<td>URL includes credentials.</td>
<td>
<pre>
fetch('https://user:[email protected]/');
</pre>
</td>
<tr>
<td>Invalid referrer URL.</td>
<td>
<pre>
fetch('https://example.com/', { referrer: './abc\u0000df' });
</pre>
</td>
</tr>
<tr>
<td>Invalid modes (<code>navigate</code> and <code>websocket</code>).</td>
<td>
<pre>
fetch('https://example.com/', { mode: 'navigate' });
</pre>
</td>
</tr>
<tr>
<td>
If the request cache mode is "only-if-cached" and the request mode is other than "same-origin".
</td>
<td>
<pre>
fetch('https://example.com/', {
cache: 'only-if-cached',
mode: 'no-cors',
});
</pre>
</td>
</tr>
<tr>
<td>
If the request method is an invalid name token or one of the forbidden headers
(<code>'CONNECT'</code>, <code>'TRACE'</code> or <code>'TRACK'</code>).
</td>
<td>
<pre>
fetch('https://example.com/', { method: 'CONNECT' });
</pre>
</td>
</tr>
<tr>
<td>
If the request mode is "no-cors" and the request method is not a CORS-safe-listed method
(<code>'GET'</code>, <code>'HEAD'</code>, or <code>'POST'</code>).
</td>
<td>
<pre>
fetch('https://example.com/', {
method: 'CONNECT',
mode: 'no-cors',
});
</pre>
</td>
</tr>
<tr>
<td>
If the request method is <code>'GET'</code> or <code>'HEAD'</code> and the body is non-null or not undefined.
</td>
<td>
<pre>
fetch('https://example.com/', {
method: 'GET',
body: new FormData(),
});
</pre>
</td>
</tr>
<tr>
<td>If fetch throws a network error.</td>
<td></td>
</tr>
</tbody>
</table>
## Examples
In our [Fetch Request example](https://github.com/mdn/dom-examples/tree/main/fetch/fetch-request) (see [Fetch Request live](https://mdn.github.io/dom-examples/fetch/fetch-request/)) we
create a new {{domxref("Request")}} object using the relevant constructor, then fetch it
using a `fetch()` call. Since we are fetching an image, we run
{{domxref("Response.blob()")}} on the response to give it the proper MIME type so it will be
handled properly, then create an Object URL of it and display it in an
{{htmlelement("img")}} element.
```js
const myImage = document.querySelector("img");
const myRequest = new Request("flowers.jpg");
fetch(myRequest)
.then((response) => {
if (!response.ok) {
throw new Error(`HTTP error! Status: ${response.status}`);
}
return response.blob();
})
.then((response) => {
myImage.src = URL.createObjectURL(response);
});
```
In the [Fetch with init then Request example](https://github.com/mdn/dom-examples/tree/main/fetch/fetch-with-init-then-request/index.html) (see [Fetch Request init live](https://mdn.github.io/dom-examples/fetch/fetch-with-init-then-request/)), we do the same thing except that we pass in an
`init` object when we invoke `fetch()`:
```js
const myImage = document.querySelector("img");
const myHeaders = new Headers();
myHeaders.append("Accept", "image/jpeg");
const myInit = {
method: "GET",
headers: myHeaders,
mode: "cors",
cache: "default",
};
const myRequest = new Request("flowers.jpg");
fetch(myRequest, myInit).then((response) => {
// …
});
```
You could also pass the `init` object in with the
`Request` constructor to get the same effect:
```js
const myRequest = new Request("flowers.jpg", myInit);
```
You can also use an object literal as `headers` in
`init`.
```js
const myInit = {
method: "GET",
headers: {
Accept: "image/jpeg",
},
mode: "cors",
cache: "default",
};
const myRequest = new Request("flowers.jpg", myInit);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Fetch API](/en-US/docs/Web/API/Fetch_API)
- [ServiceWorker API](/en-US/docs/Web/API/Service_Worker_API)
- [HTTP access control (CORS)](/en-US/docs/Web/HTTP/CORS)
- [HTTP](/en-US/docs/Web/HTTP)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/channelsplitternode/index.md | ---
title: ChannelSplitterNode
slug: Web/API/ChannelSplitterNode
page-type: web-api-interface
browser-compat: api.ChannelSplitterNode
---
{{APIRef("Web Audio API")}}
The `ChannelSplitterNode` interface, often used in conjunction with its opposite, {{domxref("ChannelMergerNode")}}, separates the different channels of an audio source into a set of mono outputs. This is useful for accessing each channel separately, e.g. for performing channel mixing where gain must be separately controlled on each channel.
If your `ChannelSplitterNode` always has one single input, the amount of outputs is defined by a parameter on its constructor and the call to {{domxref("BaseAudioContext/createChannelSplitter", "AudioContext.createChannelSplitter()")}}. In the case that no value is given, it will default to `6`. If there are fewer channels in the input than there are outputs, supernumerary outputs are silent.
{{InheritanceDiagram}}
<table class="properties">
<tbody>
<tr>
<th scope="row">Number of inputs</th>
<td><code>1</code></td>
</tr>
<tr>
<th scope="row">Number of outputs</th>
<td>variable; default to <code>6</code>.</td>
</tr>
<tr>
<th scope="row">Channel count mode</th>
<td>
<code>"explicit"</code> Older implementations, as per earlier versions
of the spec use <code>"max"</code>.
</td>
</tr>
<tr>
<th scope="row">Channel count</th>
<td>
Fixed to the number of outputs. Older implementations, as per earlier
versions of the spec use <code>2 </code>(not used in the default count
mode).
</td>
</tr>
<tr>
<th scope="row">Channel interpretation</th>
<td><code>"discrete"</code></td>
</tr>
</tbody>
</table>
## Constructor
- {{domxref("ChannelSplitterNode.ChannelSplitterNode()","ChannelSplitterNode()")}}
- : Creates a new `ChannelSplitterNode` object instance.
## Instance properties
_No specific property; inherits properties from its parent, {{domxref("AudioNode")}}_.
## Instance methods
_No specific method; inherits methods from its parent, {{domxref("AudioNode")}}_.
## Example
See [`BaseAudioContext.createChannelSplitter()`](/en-US/docs/Web/API/BaseAudioContext/createChannelSplitter#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/channelsplitternode | data/mdn-content/files/en-us/web/api/channelsplitternode/channelsplitternode/index.md | ---
title: "ChannelSplitterNode: ChannelSplitterNode() constructor"
short-title: ChannelSplitterNode()
slug: Web/API/ChannelSplitterNode/ChannelSplitterNode
page-type: web-api-constructor
browser-compat: api.ChannelSplitterNode.ChannelSplitterNode
---
{{APIRef("Web Audio API")}}
The **`ChannelSplitterNode()`** constructor of the [Web Audio API](/en-US/docs/Web/API/Web_Audio_API) creates a new {{domxref("ChannelSplitterNode")}} object instance, representing a node that splits the input into a separate output for each of the source node's audio channels.
## Syntax
```js-nolint
new ChannelSplitterNode(context)
new ChannelSplitterNode(context, options)
```
### Parameters
- `context`
- : A {{domxref("BaseAudioContext")}} representing the audio context you want the node to be associated with.
- `options` {{optional_inline}}
- : An object defining the properties you want the `ChannelSplitterNode` to have:
- `numberOfOutputs` {{optional_inline}}
- : A number defining the number of outputs the {{domxref("ChannelSplitterNode")}} should have. If not specified, the default value used is 6.
- `channelCount` {{optional_inline}}
- : 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` {{optional_inline}}
- : 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` {{optional_inline}}
- : 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.channelCountMode")}} for more information including default values.)
### Return value
A new {{domxref("ChannelSplitterNode")}} object instance.
## Examples
```js
const ac = new AudioContext();
const options = {
numberOfOutputs: 2,
};
const mySplitter = new ChannelSplitterNode(ac, options);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/dompoint/index.md | ---
title: DOMPoint
slug: Web/API/DOMPoint
page-type: web-api-interface
browser-compat: api.DOMPoint
---
{{APIRef("Geometry Interfaces")}}
A **`DOMPoint`** object represents a 2D or 3D point in a coordinate system; it includes values for the coordinates in up to three dimensions, as well as an optional perspective value. `DOMPoint` is based on {{domxref("DOMPointReadOnly")}} but allows its properties' values to be changed.
In general, a positive `x` component represents a position to the right of the origin, a positive `y` component is downward from the origin, and a positive `z` component extends outward from the screen (in other words, toward the user).
{{InheritanceDiagram}}
## Constructor
- {{domxref("DOMPoint.DOMPoint","DOMPoint()")}}
- : Creates and returns a new `DOMPoint` object given the values of zero or more of its coordinate components and optionally the `w` perspective value. You can also use an existing `DOMPoint` or `DOMPointReadOnly` or an object to create a new point by calling the {{domxref("DOMPoint.fromPoint_static", "DOMPoint.fromPoint()")}} static method.
## Instance properties
_`DOMPoint` may also inherit properties from its parent, {{domxref("DOMPointReadOnly")}}._
- {{domxref("DOMPoint.x")}}
- : The `x` coordinate of the `DOMPoint`.
- {{domxref("DOMPoint.y")}}
- : The `y` coordinate of the `DOMPoint`.
- {{domxref("DOMPoint.z")}}
- : The `z` coordinate of the `DOMPoint`.
- {{domxref("DOMPoint.w")}}
- : The perspective value of the `DOMPoint`.
## Instance methods
_`DOMPoint` inherits instance methods from its parent, {{domxref("DOMPointReadOnly")}}._
## Static methods
_`DOMPoint` may also inherit static methods from its parent, {{domxref("DOMPointReadOnly")}}._
- {{domxref("DOMPoint/fromPoint_static", "DOMPoint.fromPoint()")}}
- : Creates a new mutable `DOMPoint` object given an existing point (or an object containing matching properties), which provides the values for its properties.
## Examples
In the [WebXR Device API](/en-US/docs/Web/API/WebXR_Device_API), `DOMPointReadOnly` values represent positions and orientations. In the following snippet, the pose of the XR device (such as a VR headset or phone with AR capabilities) can be retrieved by calling using {{domxref("XRFrame.getViewerPose()")}} during an {{domxref("XRSession")}} animation frame, then accessing the resulting {{domxref("XRPose")}}'s {{domxref("XRPose.transform","transform")}} property, which contains two `DOMPointReadOnly` attributes: {{domxref("XRRigidTransform.position","position")}} as a vector and {{domxref("XRRigidTransform.orientation.orientation","orientation")}} as a quaternion.
```js
function onXRFrame(time, xrFrame) {
let viewerPose = xrFrame.getViewerPose(xrReferenceSpace);
if (viewerPose) {
let position = viewerPose.transform.position;
let orientation = viewerPose.transform.orientation;
console.log(
`XR Viewer Position: {x: ${roundToTwo(position.x)}, y: ${roundToTwo(
position.y,
)}, z: ${roundToTwo(position.z)}`,
);
console.log(
`XR Viewer Orientation: {x: ${roundToTwo(orientation.x)}, y: ${roundToTwo(
orientation.y,
)}, z: ${roundToTwo(orientation.z)}, w: ${roundToTwo(orientation.w)}`,
);
}
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("DOMRect")}}
- {{domxref("DOMMatrix")}}
| 0 |
data/mdn-content/files/en-us/web/api/dompoint | data/mdn-content/files/en-us/web/api/dompoint/z/index.md | ---
title: "DOMPoint: z property"
short-title: z
slug: Web/API/DOMPoint/z
page-type: web-api-instance-property
browser-compat: api.DOMPoint.z
---
{{APIRef("DOM")}}
The **`DOMPoint`** interface's
**`z`** property specifies the depth coordinate of a point in
space.
Unless transforms have changed the orientation, a `z` of 0 is
the plane of the screen, with positive values extending outward toward the user from the
screen, and negative values receding into the distance behind the screen.
## Value
A double-precision floating-point value indicating the _z_ coordinate's value
for the point. This value is **unrestricted**, meaning that it is allowed
to be infinite or invalid (that is, its value may be {{jsxref("NaN")}} or
{{jsxref("Infinity", "±Infinity")}}).
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The other coordinate properties: {{domxref("DOMPoint.x", "x")}},
{{domxref("DOMPoint.y", "y")}}, and the perspective value, {{domxref("DOMPoint.w",
"w")}}.
| 0 |
data/mdn-content/files/en-us/web/api/dompoint | data/mdn-content/files/en-us/web/api/dompoint/y/index.md | ---
title: "DOMPoint: y property"
short-title: "y"
slug: Web/API/DOMPoint/y
page-type: web-api-instance-property
browser-compat: api.DOMPoint.y
---
{{APIRef("DOM")}}
The **`DOMPoint`** interface's
**`y`** property holds the vertical coordinate, _y_,
for a point in space.
Unless transforms have been applied to alter the
orientation, the value of `y` increases downward and decreases upward.
## Value
A double-precision floating-point value indicating the _y_ coordinate's value
for the point. This value is **unrestricted**, meaning that it is allowed
to be infinite or invalid (that is, its value may be {{jsxref("NaN")}} or
{{jsxref("Infinity", "±Infinity")}}).
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The other coordinate properties: {{domxref("DOMPoint.x", "x")}},
{{domxref("DOMPoint.z", "z")}}, and the perspective value, {{domxref("DOMPoint.w",
"w")}}.
| 0 |
data/mdn-content/files/en-us/web/api/dompoint | data/mdn-content/files/en-us/web/api/dompoint/x/index.md | ---
title: "DOMPoint: x property"
short-title: x
slug: Web/API/DOMPoint/x
page-type: web-api-instance-property
browser-compat: api.DOMPoint.x
---
{{APIRef("DOM")}}
The **`DOMPoint`** interface's
**`x`** property holds the horizontal coordinate, x, for a
point in space.
In general, positive values `x` mean to the right,
and negative values of `x` means to the left, barring any transforms that may
have altered the orientation of the axes.
## Value
A double-precision floating-point value indicating the x coordinate's value for the
point. This value is **unrestricted**, meaning that it is allowed to be
infinite or invalid (that is, its value may be {{jsxref("NaN")}} or {{jsxref("Infinity",
"±Infinity")}}).
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The other coordinate properties: {{domxref("DOMPoint.y", "y")}},
{{domxref("DOMPoint.z", "z")}}, and the perspective value, {{domxref("DOMPoint.w",
"w")}}.
| 0 |
data/mdn-content/files/en-us/web/api/dompoint | data/mdn-content/files/en-us/web/api/dompoint/dompoint/index.md | ---
title: "DOMPoint: DOMPoint() constructor"
short-title: DOMPoint()
slug: Web/API/DOMPoint/DOMPoint
page-type: web-api-constructor
browser-compat: api.DOMPoint.DOMPoint
---
{{APIRef("DOM")}}
The **`DOMPoint()`** constructor
creates and returns a new {{domxref("DOMPoint")}} object, given the values for some or
all of its properties.
You can also create a `DOMPoint` by calling the
{{domxref("DOMPoint.fromPoint_static", "DOMPoint.fromPoint()")}} static function. That function accepts any object with the required parameters, including a `DOMPoint` or
{{domxref("DOMPointReadOnly")}}.
## Syntax
```js-nolint
new DOMPoint()
new DOMPoint(x)
new DOMPoint(x, y)
new DOMPoint(x, y, z)
new DOMPoint(x, y, z, w)
```
### Parameters
- `x` {{optional_inline}}
- : The `x` coordinate for the new `DOMPoint`.
- `y` {{optional_inline}}
- : The `y` coordinate for the new `DOMPoint`.
- `z` {{optional_inline}}
- : The `z` coordinate for the new `DOMPoint`.
- `w` {{optional_inline}}
- : The perspective value of the new `DOMPoint`.
## Examples
This example creates a `DOMPoint` representing the top-left corner of the
current window, then creates a second point based on the first, which is then offset by
100 pixels both vertically and horizontally.
```js
const windTopLeft = new DOMPoint(window.screenX, window.screenY);
const newTopLeft = DOMPoint.fromPoint(windTopLeft);
newTopLeft.x += 100;
newTopLeft.y += 100;
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("DOMPointReadOnly.DOMPointReadOnly", "DOMPointReadOnly()")}}
- {{domxref("DOMRect")}}
- {{domxref("DOMMatrix")}}
| 0 |
data/mdn-content/files/en-us/web/api/dompoint | data/mdn-content/files/en-us/web/api/dompoint/w/index.md | ---
title: "DOMPoint: w property"
short-title: w
slug: Web/API/DOMPoint/w
page-type: web-api-instance-property
browser-compat: api.DOMPoint.w
---
{{APIRef("DOM")}}
The **`DOMPoint`** interface's
**`w`** property holds the point's perspective value, w, for a
point in space.
## Value
A double-precision floating-point value indicating the _w_ perspective value for
the point. This value is **unrestricted**, meaning that it is allowed to be
infinite or invalid (that is, its value may be {{jsxref("NaN")}} or {{jsxref("Infinity",
"±Infinity")}}). The default is 1.0.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The other coordinate properties: {{domxref("DOMPoint.x", "x")}},
{{domxref("DOMPoint.y", "y")}}, and {{domxref("DOMPoint.z", "z")}}.
| 0 |
data/mdn-content/files/en-us/web/api/dompoint | data/mdn-content/files/en-us/web/api/dompoint/frompoint_static/index.md | ---
title: "DOMPoint: fromPoint() static method"
short-title: fromPoint()
slug: Web/API/DOMPoint/fromPoint_static
page-type: web-api-static-method
browser-compat: api.DOMPoint.fromPoint_static
---
{{APIRef("DOM")}}
The **{{domxref("DOMPoint")}}** static method
`fromPoint()` creates and returns a new mutable `DOMPoint`
object given a source point.
You can also create a new `DOMPoint` object using the
{{domxref("DOMPoint.DOMPoint", "new DOMPoint()")}} constructor.
Although this interface is based on `DOMPointReadOnly`, it is not read-only;
the properties within may be changed at will.
## Syntax
```js-nolint
DOMPoint.fromPoint(sourcePoint)
```
### Parameters
- `sourcePoint`
- : A {{domxref("DOMPoint")}} or {{domxref("DOMPointReadOnly")}} instance, or an object containing the following properties, from which to take the
values of the new point's properties:
- `x`
- : An unrestricted floating-point value indicating the `x`-coordinate of the point in space. This is generally the horizontal coordinate, with positive values being to the right and negative values to the left. The default value is `0`.
- `y`
- : An unrestricted floating-point number providing the point's `y`-coordinate. This is the vertical coordinate, and barring any transforms applied to the coordinate system, positive values are downward and negative values upward toward the top of the screen. The default is `0`.
- `z`
- : An unrestricted floating-point value which gives the point's `z`-coordinate, which is (assuming no transformations that alter the situation) the depth coordinate; positive values are closer to the user and negative values retreat back into the screen. The default value is `0`.
- `w`
- : The point's `w` perspective value, given as an unrestricted floating-point number. The default is `1`.
### Return value
A new {{domxref("DOMPoint")}} object whose coordinate and perspective values are
identical to those in the source point. The point's properties are mutable and may be
changed at any time.
## Examples
### Creating a mutable point from a read-only point
If you have a {{domxref("DOMPointReadOnly")}} object, you can easily create a mutable
copy of that point:
```js
const mutablePoint = DOMPoint.fromPoint(readOnlyPoint);
```
### Creating a 2D point
This sample creates a 2D point, specifying an inline object that includes the values to
use for {{domxref("DOMPointReadOnly.x", "x")}} and {{domxref("DOMPointReadOnly.y",
"y")}}. The _z_ and _w_ properties are allowed to keep their default
values (0 and 1 respectively).
```js
const center = DOMPoint.fromPoint({ x: 75, y: -50, z: -55, w: 0.25 });
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/gpucomputepassencoder/index.md | ---
title: GPUComputePassEncoder
slug: Web/API/GPUComputePassEncoder
page-type: web-api-interface
status:
- experimental
browser-compat: api.GPUComputePassEncoder
---
{{APIRef("WebGPU API")}}{{SeeCompatTable}}{{SecureContext_Header}}
The **`GPUComputePassEncoder`** interface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} encodes commands related to controlling the compute shader stage, as issued by a {{domxref("GPUComputePipeline")}}. It forms part of the overall encoding activity of a {{domxref("GPUCommandEncoder")}}.
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.
A `GPUComputePassEncoder` object instance is created via the {{domxref("GPUCommandEncoder.beginComputePass()")}} property.
{{InheritanceDiagram}}
## Instance properties
- {{domxref("GPUComputePassEncoder.label", "label")}} {{Experimental_Inline}}
- : A string providing a label that can be used to identify the object, for example in {{domxref("GPUError")}} messages or console warnings.
## Instance methods
- {{domxref("GPUComputePassEncoder.dispatchWorkgroups", "dispatchWorkgroups()")}} {{Experimental_Inline}}
- : Dispatches a specific grid of workgroups to perform the work being done by the current {{domxref("GPUComputePipeline")}}.
- {{domxref("GPUComputePassEncoder.dispatchWorkgroupsIndirect", "dispatchWorkgroupsIndirect()")}} {{Experimental_Inline}}
- : Dispatches a grid of workgroups, defined by the parameters of a {{domxref("GPUBuffer")}}, to perform the work being done by the current {{domxref("GPUComputePipeline")}}.
- {{domxref("GPUComputePassEncoder.end", "end()")}} {{Experimental_Inline}}
- : Completes recording of the current compute pass command sequence.
- {{domxref("GPUComputePassEncoder.insertDebugMarker", "insertDebugMarker()")}} {{Experimental_Inline}}
- : Marks a specific point in a series of encoded commands with a label.
- {{domxref("GPUComputePassEncoder.popDebugGroup", "popDebugGroup()")}} {{Experimental_Inline}}
- : Ends a debug group, which is begun with a {{domxref("GPUComputePassEncoder.pushDebugGroup", "pushDebugGroup()")}} call.
- {{domxref("GPUComputePassEncoder.pushDebugGroup", "pushDebugGroup()")}} {{Experimental_Inline}}
- : Begins a debug group, which is marked with a specified label, and will contain all subsequent encoded commands up until a {{domxref("GPUComputePassEncoder.popDebugGroup", "popDebugGroup()")}} method is invoked.
- {{domxref("GPUComputePassEncoder.setBindGroup", "setBindGroup()")}} {{Experimental_Inline}}
- : Sets the {{domxref("GPUBindGroup")}} to use for subsequent compute commands, for a given index.
- {{domxref("GPUComputePassEncoder.setPipeline", "setPipeline()")}} {{Experimental_Inline}}
- : Sets the {{domxref("GPUComputePipeline")}} to use for this compute pass.
## Examples
In our [basic compute demo](https://mdn.github.io/dom-examples/webgpu-compute-demo/), several commands are recorded via a {{domxref("GPUCommandEncoder")}}. Most of these commands originate from the `GPUComputePassEncoder` created via {{domxref("GPUCommandEncoder.beginComputePass()")}}.
```js
// ...
// Create GPUCommandEncoder to encode commands to issue to the GPU
const commandEncoder = device.createCommandEncoder();
// Create GPUComputePassEncoder to initiate compute pass
const passEncoder = commandEncoder.beginComputePass();
// Issue commands
passEncoder.setPipeline(computePipeline);
passEncoder.setBindGroup(0, bindGroup);
passEncoder.dispatchWorkgroups(Math.ceil(BUFFER_SIZE / 64));
// End the compute pass
passEncoder.end();
// 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()]);
// ...
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The [WebGPU API](/en-US/docs/Web/API/WebGPU_API)
| 0 |
data/mdn-content/files/en-us/web/api/gpucomputepassencoder | data/mdn-content/files/en-us/web/api/gpucomputepassencoder/pushdebuggroup/index.md | ---
title: "GPUComputePassEncoder: pushDebugGroup() method"
short-title: pushDebugGroup()
slug: Web/API/GPUComputePassEncoder/pushDebugGroup
page-type: web-api-instance-method
status:
- experimental
browser-compat: api.GPUComputePassEncoder.pushDebugGroup
---
{{APIRef("WebGPU API")}}{{SeeCompatTable}}{{SecureContext_Header}}
The **`pushDebugGroup()`** method of the
{{domxref("GPUComputePassEncoder")}} interface begins a compute pass debug group, which is marked with a specified label, and will contain all subsequent encoded commands up until a {{domxref("GPUComputePassEncoder.popDebugGroup", "popDebugGroup()")}} method is invoked.
This could be used for telemetry, or may be utilized in {{domxref("GPUError")}} messages, browser dev tools, or other services in the future to help with debugging.
## Syntax
```js-nolint
pushDebugGroup(groupLabel)
```
### Parameters
- `groupLabel`
- : A string representing the label for the debug group.
### Return value
None ({{jsxref("Undefined")}}).
## Examples
```js
// ...
const passEncoder = commandEncoder.beginComputePass();
passEncoder.pushDebugGroup("mygroupmarker"); // Start labeled debug group
passEncoder.setPipeline(computePipeline);
passEncoder.setBindGroup(0, bindGroup);
passEncoder.dispatchWorkgroups(Math.ceil(BUFFER_SIZE / 64));
passEncoder.popDebugGroup();
// ...
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The [WebGPU API](/en-US/docs/Web/API/WebGPU_API)
| 0 |
data/mdn-content/files/en-us/web/api/gpucomputepassencoder | data/mdn-content/files/en-us/web/api/gpucomputepassencoder/insertdebugmarker/index.md | ---
title: "GPUComputePassEncoder: insertDebugMarker() method"
short-title: insertDebugMarker()
slug: Web/API/GPUComputePassEncoder/insertDebugMarker
page-type: web-api-instance-method
status:
- experimental
browser-compat: api.GPUComputePassEncoder.insertDebugMarker
---
{{APIRef("WebGPU API")}}{{SeeCompatTable}}{{SecureContext_Header}}
The **`insertDebugMarker()`** method of the
{{domxref("GPUComputePassEncoder")}} interface marks a specific point in a series of encoded compute pass commands with a label.
This could be used for telemetry, or may be utilized in {{domxref("GPUError")}} messages, browser dev tools, or other services in the future to help with debugging.
## Syntax
```js-nolint
insertDebugMarker(markerLabel)
```
### Parameters
- `markerLabel`
- : A string representing the label to insert.
### Return value
None ({{jsxref("Undefined")}}).
## Examples
```js
// ...
passEncoder.insertDebugMarker("mymarker");
// ...
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The [WebGPU API](/en-US/docs/Web/API/WebGPU_API)
| 0 |
data/mdn-content/files/en-us/web/api/gpucomputepassencoder | data/mdn-content/files/en-us/web/api/gpucomputepassencoder/popdebuggroup/index.md | ---
title: "GPUComputePassEncoder: popDebugGroup() method"
short-title: popDebugGroup()
slug: Web/API/GPUComputePassEncoder/popDebugGroup
page-type: web-api-instance-method
status:
- experimental
browser-compat: api.GPUComputePassEncoder.popDebugGroup
---
{{APIRef("WebGPU API")}}{{SeeCompatTable}}{{SecureContext_Header}}
The **`popDebugGroup()`** method of the
{{domxref("GPUComputePassEncoder")}} interface ends a compute pass debug group, which is begun with a {{domxref("GPUComputePassEncoder.pushDebugGroup", "pushDebugGroup()")}} call.
This could be used for telemetry, or may be utilized in {{domxref("GPUError")}} messages, browser dev tools, or other services in the future to help with debugging.
## Syntax
```js-nolint
popDebugGroup()
```
### Parameters
None.
### Return value
None ({{jsxref("Undefined")}}).
### Validation
The following criteria must be met when calling **`popDebugGroup()`**, otherwise a {{domxref("GPUValidationError")}} is generated and the {{domxref("GPUComputePassEncoder")}} becomes invalid:
- The compute pass encoder's debug stack is not empty (i.e. at least one compute pass debug group was previously started with {{domxref("GPUComputePassEncoder.pushDebugGroup", "pushDebugGroup()")}}).
## Examples
```js
// ...
const passEncoder = commandEncoder.beginComputePass();
passEncoder.pushDebugGroup("mygroupmarker"); // Start labeled debug group
passEncoder.setPipeline(computePipeline);
passEncoder.setBindGroup(0, bindGroup);
passEncoder.dispatchWorkgroups(Math.ceil(BUFFER_SIZE / 64));
passEncoder.popDebugGroup();
// ...
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The [WebGPU API](/en-US/docs/Web/API/WebGPU_API)
| 0 |
data/mdn-content/files/en-us/web/api/gpucomputepassencoder | data/mdn-content/files/en-us/web/api/gpucomputepassencoder/end/index.md | ---
title: "GPUComputePassEncoder: end() method"
short-title: end()
slug: Web/API/GPUComputePassEncoder/end
page-type: web-api-instance-method
status:
- experimental
browser-compat: api.GPUComputePassEncoder.end
---
{{APIRef("WebGPU API")}}{{SeeCompatTable}}{{SecureContext_Header}}
The **`end()`** method of the
{{domxref("GPUComputePassEncoder")}} interface completes recording of the current compute pass command sequence.
## Syntax
```js-nolint
end()
```
### Parameters
None.
### Return value
None ({{jsxref("Undefined")}}).
### Validation
The following criteria must be met when calling **`end()`**, otherwise a {{domxref("GPUValidationError")}} is generated and the {{domxref("GPUComputePassEncoder")}} becomes invalid:
- The {{domxref("GPUComputePassEncoder")}} is open (i.e. not already ended via an `end()` call).
- any {{domxref("GPUComputePassEncoder.pushDebugGroup", "pushDebugGroup()")}} calls made on this encoder have a corresponding {{domxref("GPUComputePassEncoder.popDebugGroup", "popDebugGroup()")}} call before `end()` is called.
## Examples
In our [basic compute demo](https://mdn.github.io/dom-examples/webgpu-compute-demo/), several commands are recorded via a {{domxref("GPUCommandEncoder")}}. Most of these commands originate from the {{domxref("GPUComputePassEncoder")}} created via {{domxref("GPUCommandEncoder.beginComputePass()")}}.
```js
const BUFFER_SIZE = 1000;
// ...
// Create GPUCommandEncoder to encode commands to issue to the GPU
const commandEncoder = device.createCommandEncoder();
// Initiate render pass
const passEncoder = commandEncoder.beginComputePass();
// Issue commands
passEncoder.setPipeline(computePipeline);
passEncoder.setBindGroup(0, bindGroup);
passEncoder.dispatchWorkgroups(Math.ceil(BUFFER_SIZE / 64));
// End the render pass
passEncoder.end();
// 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()]);
// ...
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The [WebGPU API](/en-US/docs/Web/API/WebGPU_API)
| 0 |
data/mdn-content/files/en-us/web/api/gpucomputepassencoder | data/mdn-content/files/en-us/web/api/gpucomputepassencoder/setbindgroup/index.md | ---
title: "GPUComputePassEncoder: setBindGroup() method"
short-title: setBindGroup()
slug: Web/API/GPUComputePassEncoder/setBindGroup
page-type: web-api-instance-method
status:
- experimental
browser-compat: api.GPUComputePassEncoder.setBindGroup
---
{{APIRef("WebGPU API")}}{{SeeCompatTable}}{{SecureContext_Header}}
The **`setBindGroup()`** method of the
{{domxref("GPUComputePassEncoder")}} interface sets the {{domxref("GPUBindGroup")}} to use for subsequent compute commands, for a given index.
## Syntax
```js-nolint
setBindGroup(index, bindGroup)
setBindGroup(index, bindGroup, dynamicOffsets)
setBindGroup(index, bindGroup, dynamicOffsets, dynamicOffsetsStart,
dynamicOffsetsLength)
```
### Parameters
- `index`
- : The index to set the bind group at. This matches the `n` index value of the corresponding [`@group(n)`](https://gpuweb.github.io/gpuweb/wgsl/#attribute-group) attribute in the shader code ({{domxref("GPUShaderModule")}}) used in the related pipeline.
- `bindGroup`
- : The {{domxref("GPUBindGroup")}} to use for subsequent compute commands.
- `dynamicOffsets` {{optional_inline}}
- : A value specifying the offset, in bytes, for each entry in `bindGroup` with `hasDynamicOffset: true` set (i.e. in the descriptor of the {{domxref("GPUDevice.createBindGroupLayout()")}} call that created the {{domxref("GPUBindGroupLayout")}} object that the `bindGroup` is based on). This value can be:
- An array of numbers specifying the different offsets.
- A {{jsxref("Uint32Array")}} containing numbers specifying the offsets.
If a {{jsxref("Uint32Array")}} value is specified for `dynamicOffsets`, both of the following parameters are also required:
- `dynamicOffsetsStart`
- : A number specifying the offset, in array elements, into `dynamicOffsetsData`, where the dynamic offset data begins.
- `dynamicOffsetsLength`
- : A number specifying the number of dynamic offset values to be read from in `dynamicOffsetsData`.
### Return value
None ({{jsxref("Undefined")}}).
### Exceptions
For `setBindGroup()` calls that use a {{jsxref("Uint32Array")}} value for `dynamicOffsets`, the call will throw with a `RangeError` {{domxref("DOMException")}} if:
- `dynamicOffsetsStart` is less than 0.
- `dynamicOffsetsStart` + `dynamicOffsetsLength` is greater than `dynamicOffsets.length`.
### Validation
The following criteria must be met when calling **`dispatchWorkgroups()`**, otherwise a {{domxref("GPUValidationError")}} is generated and the {{domxref("GPUComputePassEncoder")}} becomes invalid:
- `index` is less than or equal to the {{domxref("GPUDevice")}}'s `maxBindGroups` {{domxref("GPUSupportedLimits", "limit", "", "nocode")}}.
- `dynamicOffsets.length` is the same as the number of entries in `bindGroup` with `hasDynamicOffset: true` set.
- For `bindGroup` entries where the bound `buffer`'s `type` is `"uniform"` (see {{domxref("GPUDevice.createBindGroupLayout()")}}), each number in `dynamicOffsets` is a multiple of the {{domxref("GPUDevice")}}'s `minUniformBufferOffsetAlignment` {{domxref("GPUSupportedLimits", "limit", "", "nocode")}}.
- For `bindGroup` entries where the bound `buffer`'s `type` is `"storage"` or `"read-only-storage"` (see {{domxref("GPUDevice.createBindGroupLayout()")}}), each number in `dynamicOffsets` is a multiple of the {{domxref("GPUDevice")}}'s `minStorageBufferOffsetAlignment` {{domxref("GPUSupportedLimits", "limit", "", "nocode")}}.
- For each `bindGroup` entry, the bound `buffer`'s `offset`, plus the corresponding layout entry's `minBindingSize`, plus the corresponding dynamic offset specified in `dynamicOffsets`, is less than or equal to the bound `buffer`'s `size`.
## Examples
In our [basic compute demo](https://mdn.github.io/dom-examples/webgpu-compute-demo/), several commands are recorded via a {{domxref("GPUCommandEncoder")}}. Most of these commands originate from the {{domxref("GPUComputePassEncoder")}} created via `beginComputePass()`. The `setBindGroup()` call used here is the simplest form, just specifying index and bind group.
```js
const BUFFER_SIZE = 1000;
// ...
// Create GPUCommandEncoder to encode commands to issue to the GPU
const commandEncoder = device.createCommandEncoder();
// Initiate render pass
const passEncoder = commandEncoder.beginComputePass();
// Issue commands
passEncoder.setPipeline(computePipeline);
passEncoder.setBindGroup(0, bindGroup);
passEncoder.dispatchWorkgroups(Math.ceil(BUFFER_SIZE / 64));
// End the render pass
passEncoder.end();
// 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()]);
// ...
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The [WebGPU API](/en-US/docs/Web/API/WebGPU_API)
| 0 |
data/mdn-content/files/en-us/web/api/gpucomputepassencoder | data/mdn-content/files/en-us/web/api/gpucomputepassencoder/label/index.md | ---
title: "GPUComputePassEncoder: label property"
short-title: label
slug: Web/API/GPUComputePassEncoder/label
page-type: web-api-instance-property
status:
- experimental
browser-compat: api.GPUComputePassEncoder.label
---
{{APIRef("WebGPU API")}}{{SeeCompatTable}}{{SecureContext_Header}}
The **`label`** read-only property of the
{{domxref("GPUComputePassEncoder")}} interface is a string providing a label that can be used to identify the object, for example in {{domxref("GPUError")}} messages or console warnings.
This can be set by providing a `label` property in the descriptor object passed into the originating {{domxref("GPUCommandEncoder.beginComputePass()")}} call, or you can get and set it directly on the `GPUComputePassEncoder` object.
## Value
A string. If no label value has previously been set, getting the label returns an empty string.
## Examples
Setting and getting a label via `GPUComputePassEncoder.label`:
```js
const commandEncoder = device.createCommandEncoder();
const passEncoder = commandEncoder.beginComputePass();
passEncoder.label = "mycomputepassencoder";
console.log(passEncoder.label); // "mycomputepassencoder"
```
Setting a label via the originating {{domxref("GPUCommandEncoder.beginComputePass()")}} call, and then getting it via `GPUComputePassEncoder.label`:
```js
const commandEncoder = device.createCommandEncoder();
const passEncoder = commandEncoder.beginComputePass({
label: "mycomputepassencoder",
});
console.log(passEncoder.label); // "mycomputepassencoder"
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The [WebGPU API](/en-US/docs/Web/API/WebGPU_API)
| 0 |
data/mdn-content/files/en-us/web/api/gpucomputepassencoder | data/mdn-content/files/en-us/web/api/gpucomputepassencoder/setpipeline/index.md | ---
title: "GPUComputePassEncoder: setPipeline() method"
short-title: setPipeline()
slug: Web/API/GPUComputePassEncoder/setPipeline
page-type: web-api-instance-method
status:
- experimental
browser-compat: api.GPUComputePassEncoder.setPipeline
---
{{APIRef("WebGPU API")}}{{SeeCompatTable}}{{SecureContext_Header}}
The **`setPipeline()`** method of the
{{domxref("GPUComputePassEncoder")}} interface sets the {{domxref("GPUComputePipeline")}} to use for this compute pass.
## Syntax
```js-nolint
setPipeline(pipeline)
```
### Parameters
- `pipeline`
- : The {{domxref("GPUComputePipeline")}} to use for this compute pass.
### Return value
None ({{jsxref("Undefined")}}).
## Examples
In our [basic compute demo](https://mdn.github.io/dom-examples/webgpu-compute-demo/), several commands are recorded via a {{domxref("GPUCommandEncoder")}}. Most of these commands originate from the {{domxref("GPUComputePassEncoder")}} created via `beginComputePass()`. The `setPipeline()` call is used as appropriate to set the pipeline to use for this pass.
```js
const BUFFER_SIZE = 1000;
// ...
// Create GPUCommandEncoder to encode commands to issue to the GPU
const commandEncoder = device.createCommandEncoder();
// Initiate render pass
const passEncoder = commandEncoder.beginComputePass();
// Issue commands
passEncoder.setPipeline(computePipeline);
passEncoder.setBindGroup(0, bindGroup);
passEncoder.dispatchWorkgroups(Math.ceil(BUFFER_SIZE / 64));
// End the render pass
passEncoder.end();
// 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()]);
// ...
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The [WebGPU API](/en-US/docs/Web/API/WebGPU_API)
| 0 |
data/mdn-content/files/en-us/web/api/gpucomputepassencoder | data/mdn-content/files/en-us/web/api/gpucomputepassencoder/dispatchworkgroupsindirect/index.md | ---
title: "GPUComputePassEncoder: dispatchWorkgroupsIndirect() method"
short-title: dispatchWorkgroupsIndirect()
slug: Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect
page-type: web-api-instance-method
status:
- experimental
browser-compat: api.GPUComputePassEncoder.dispatchWorkgroupsIndirect
---
{{APIRef("WebGPU API")}}{{SeeCompatTable}}{{SecureContext_Header}}
The **`dispatchWorkgroupsIndirect()`** method of the
{{domxref("GPUComputePassEncoder")}} interface dispatches a grid of workgroups, defined by the parameters of a {{domxref("GPUBuffer")}}, to perform the work being done by the current {{domxref("GPUComputePipeline")}} (i.e. set via {{domxref("GPUComputePassEncoder.setPipeline()")}}).
## Syntax
```js-nolint
dispatchWorkgroupsIndirect(indirectBuffer, indirectOffset)
```
### Parameters
- `indirectBuffer`
- : A {{domxref("GPUBuffer")}} containing the X, Y, and Z dimensions of the grid of workgroups to dispatch. The buffer must contain a tightly packed block of three 32-bit unsigned integer values representing the dimensions (12 bytes total), given in the same order as the arguments for {{domxref("GPUComputePassEncoder.dispatchWorkgroups()")}}. So for example:
```js
const uint32 = new Uint32Array(3);
uint32[0] = 25; // The X value
uint32[1] = 1; // The Y value
uint32[2] = 1; // The Z value
// Write values into a GPUBuffer
device.queue.writeBuffer(buffer, 0, uint32, 0, uint32.length);
```
- `indirectOffset`
- : The offset, in bytes, into `indirectBuffer` where the dimension data begins.
> **Note:** The X, Y, and Z dimension values passed to {{domxref("GPUComputePassEncoder.dispatchWorkgroups()")}} and `dispatchWorkgroupsIndirect()` are the number of workgroups to dispatch for each dimension, not the number of shader invocations to perform across each dimension. This matches the behavior of modern native GPU APIs, but differs from the behavior of OpenCL. This means that if a {{domxref("GPUShaderModule")}} defines an entry point with `@workgroup_size(4, 4)`, and work is dispatched to it with the call `dispatchWorkgroupsIndirect(indirectBuffer);` with `indirectBuffer` specifying X and Y dimensions of 8 and 8, the entry point will be invoked 1024 times total — Dispatching a 4 x 4 workgroup 8 times along both the X and Y axes. `4 * 4 * 8 * 8 = 1024`.
### Return value
None ({{jsxref("Undefined")}}).
### Validation
The following criteria must be met when calling **`dispatchWorkgroupsIndirect()`**, otherwise a {{domxref("GPUValidationError")}} is generated and the {{domxref("GPUComputePassEncoder")}} becomes invalid:
- `indirectBuffer`'s {{domxref("GPUBuffer.usage")}} contains the `GPUBufferUsage.INDIRECT` flag.
- `indirectOffset` + the total size specified by the `X`, `Y`, and `Z` dimensions is less than or equal to the `indirectBuffer`'s {{domxref("GPUBuffer.size")}}.
- `indirectOffset` is a multiple of 4.
## Examples
```js
// Set global buffer size
const BUFFER_SIZE = 1000;
// Compute shader; note workgroup size of 64
const shader = `
@group(0) @binding(0)
var<storage, read_write> output: array<f32>;
@compute @workgroup_size(64)
...
`;
// ...
// Create GPUCommandEncoder to encode commands to issue to the GPU
const commandEncoder = device.createCommandEncoder();
// Initiate render pass
const passEncoder = commandEncoder.beginComputePass();
// Issue commands
passEncoder.setPipeline(computePipeline);
passEncoder.setBindGroup(0, bindGroup);
const uint32 = new Uint32Array(3);
// Note workgroupCountX is set based on the global buffer size and the shader workgroup count.
uint32[0] = Math.ceil(BUFFER_SIZE / 64);
uint32[1] = 1;
uint32[2] = 1;
const workgroupDimensions = device.createBuffer({
size: 12,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT,
});
device.queue.writeBuffer(workgroupDimensions, 0, uint32, 0, uint32.length);
passEncoder.dispatchWorkgroupsIndirect(workgroupDimensions, 0);
// End the render pass
passEncoder.end();
// 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()]);
// ...
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The [WebGPU API](/en-US/docs/Web/API/WebGPU_API)
| 0 |
data/mdn-content/files/en-us/web/api/gpucomputepassencoder | data/mdn-content/files/en-us/web/api/gpucomputepassencoder/dispatchworkgroups/index.md | ---
title: "GPUComputePassEncoder: dispatchWorkgroups() method"
short-title: dispatchWorkgroups()
slug: Web/API/GPUComputePassEncoder/dispatchWorkgroups
page-type: web-api-instance-method
status:
- experimental
browser-compat: api.GPUComputePassEncoder.dispatchWorkgroups
---
{{APIRef("WebGPU API")}}{{SeeCompatTable}}{{SecureContext_Header}}
The **`dispatchWorkgroups()`** method of the
{{domxref("GPUComputePassEncoder")}} interface dispatches a specific grid of workgroups to perform the work being done by the current {{domxref("GPUComputePipeline")}} (i.e. set via {{domxref("GPUComputePassEncoder.setPipeline()")}}).
## Syntax
```js-nolint
dispatchWorkgroups(workgroupCountX)
dispatchWorkgroups(workgroupCountX, workgroupCountY)
dispatchWorkgroups(workgroupCountX, workgroupCountY, workgroupCountZ)
```
### Parameters
- `workgroupCountX`
- : The X dimension of the grid of workgroups to dispatch.
- `workgroupCountY` {{optional_inline}}
- : The Y dimension of the grid of workgroups to dispatch. If omitted, `workgroupCountY` defaults to 1.
- `workgroupCountZ` {{optional_inline}}
- : The Z dimension of the grid of workgroups to dispatch. If omitted, `workgroupCountZ` defaults to 1.
> **Note:** The X, Y, and Z dimension values passed to `dispatchWorkgroups()` and {{domxref("GPUComputePassEncoder.dispatchWorkgroupsIndirect()")}} are the number of workgroups to dispatch for each dimension, not the number of shader invocations to perform across each dimension. This matches the behavior of modern native GPU APIs, but differs from the behavior of OpenCL. This means that if a {{domxref("GPUShaderModule")}} defines an entry point with `@workgroup_size(4, 4)`, and work is dispatched to it with the call `passEncoder.dispatchWorkgroups(8, 8);`, the entry point will be invoked 1024 times total — Dispatching a 4 x 4 workgroup 8 times along both the X and Y axes. `4 * 4 * 8 * 8 = 1024`.
### Return value
None ({{jsxref("Undefined")}}).
### Validation
The following criteria must be met when calling **`dispatchWorkgroups()`**, otherwise a {{domxref("GPUValidationError")}} is generated and the {{domxref("GPUComputePassEncoder")}} becomes invalid:
- `workgroupCountX`, `workgroupCountY`, and `workgroupCountZ` are all less than or equal to the {{domxref("GPUDevice")}}'s `maxComputeWorkgroupsPerDimension` {{domxref("GPUSupportedLimits", "limit", "", "nocode")}}.
## Examples
In our [basic compute demo](https://mdn.github.io/dom-examples/webgpu-compute-demo/), several commands are recorded via a {{domxref("GPUCommandEncoder")}}. Most of these commands originate from the {{domxref("GPUComputePassEncoder")}} created via `beginComputePass()`.
At the start of the code, we set a global buffer size of 1000. Also, note that the workgroup size in the shader is set to 64.
```js
const BUFFER_SIZE = 1000;
// Compute shader
const shader = `
@group(0) @binding(0)
var<storage, read_write> output: array<f32>;
@compute @workgroup_size(64)
...
`;
```
Later in the code, the `dispatchWorkgroups()` `workgroupCountX` parameter is set based on the global buffer size and the shader workgroup count.
```js
// ...
// Create GPUCommandEncoder to encode commands to issue to the GPU
const commandEncoder = device.createCommandEncoder();
// Initiate render pass
const passEncoder = commandEncoder.beginComputePass();
// Issue commands
passEncoder.setPipeline(computePipeline);
passEncoder.setBindGroup(0, bindGroup);
passEncoder.dispatchWorkgroups(Math.ceil(BUFFER_SIZE / 64));
// End the render pass
passEncoder.end();
// 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()]);
// ...
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The [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/performanceeventtiming/index.md | ---
title: PerformanceEventTiming
slug: Web/API/PerformanceEventTiming
page-type: web-api-interface
browser-compat: api.PerformanceEventTiming
---
{{APIRef("Performance API")}}
The `PerformanceEventTiming` interface of the Event Timing API provides insights into the latency of certain event types triggered by user interaction.
## Description
This API enables visibility into slow events by providing event timestamps and duration for certain event types ([see below](#events_exposed)). For example, you can monitor the time between a user action and the start of its event handler, or the time an event handler takes to run.
This API is particularly useful for measuring the {{Glossary("first input delay")}} (FID): the time from the point when a user first interacts with your app to the point when the browser is actually able to respond to that interaction.
You typically work with `PerformanceEventTiming` objects by creating a {{domxref("PerformanceObserver")}} instance and then calling its [`observe()`](/en-US/docs/Web/API/PerformanceObserver/observe) method, passing in `"event"` or `"first-input"` as the value of the [`type`](/en-US/docs/Web/API/PerformanceEntry/entryType) option. The `PerformanceObserver` object's callback will then be called with a list of `PerformanceEventTiming` objects which you can analyze. See the [example below](#getting_event_timing_information) for more.
By default, `PerformanceEventTiming` entries are exposed when their `duration` is 104ms or greater. Research suggests that user input that is not handled within 100ms is considered slow and 104ms is the first multiple of 8 greater than 100ms (for security reasons, this API is rounded to the nearest multiple of 8ms).
However, you can set the {{domxref("PerformanceObserver")}} to a different threshold using the `durationThreshold` option in the [`observe()`](/en-US/docs/Web/API/PerformanceObserver/observe) method.
This interface inherits methods and properties from its parent, {{domxref("PerformanceEntry")}}:
{{InheritanceDiagram}}
### Events exposed
The following event types are exposed by the Event Timing API:
<table>
<tbody>
<tr>
<th scope="row">Click events</th>
<td>
{{domxref("Element/auxclick_event", "auxclick")}},
{{domxref("Element/click_event", "click")}},
{{domxref("Element/contextmenu_event", "contextmenu")}},
{{domxref("Element/dblclick_event", "dblclick")}}
</td>
</tr>
<tr>
<th scope="row">Composition events</th>
<td>
{{domxref("Element/compositionend_event", "compositionend")}},
{{domxref("Element/compositionstart_event", "compositionstart")}},
{{domxref("Element/compositionupdate_event", "compositionupdate")}}
</td>
</tr>
<tr>
<th scope="row">Drag & drop events</th>
<td>
{{domxref("HTMLElement/dragend_event", "dragend")}},
{{domxref("HTMLElement/dragenter_event", "dragenter")}},
{{domxref("HTMLElement/dragleave_event", "dragleave")}},
{{domxref("HTMLElement/dragover_event", "dragover")}},
{{domxref("HTMLElement/dragstart_event", "dragstart")}},
{{domxref("HTMLElement/drop_event", "drop")}}
</td>
</tr>
<tr>
<th scope="row">Input events</th>
<td>
{{domxref("Element/beforeinput_event", "beforeinput")}},
{{domxref("Element/input_event", "input")}}
</td>
</tr>
<tr>
<th scope="row">Keyboard events</th>
<td>
{{domxref("Element/keydown_event", "keydown")}},
{{domxref("Element/keypress_event", "keypress")}},
{{domxref("Element/keyup_event", "keyup")}}
</td>
</tr>
<tr>
<th scope="row">Mouse events</th>
<td>
{{domxref("Element/mousedown_event", "mousedown")}},
{{domxref("Element/mouseenter_event", "mouseenter")}},
{{domxref("Element/mouseleave_event", "mouseleave")}},
{{domxref("Element/mouseout_event", "mouseout")}},
{{domxref("Element/mouseover_event", "mouseover")}},
{{domxref("Element/mouseup_event", "mouseup")}}
</td>
</tr>
<tr>
<th scope="row">Pointer events</th>
<td>
{{domxref("Element/pointerover_event", "pointerover")}},
{{domxref("Element/pointerenter_event", "pointerenter")}},
{{domxref("Element/pointerdown_event", "pointerdown")}},
{{domxref("Element/pointerup_event", "pointerup")}},
{{domxref("Element/pointercancel_event", "pointercancel")}},
{{domxref("Element/pointerout_event", "pointerout")}},
{{domxref("Element/pointerleave_event", "pointerleave")}},
{{domxref("Element/gotpointercapture_event", "gotpointercapture")}},
{{domxref("Element/lostpointercapture_event", "lostpointercapture")}}
</td>
</tr>
<tr>
<th scope="row">Touch events</th>
<td>
{{domxref("Element/touchstart_event", "touchstart")}},
{{domxref("Element/touchend_event", "touchend")}},
{{domxref("Element/touchcancel_event", "touchcancel")}}
</td>
</tr>
</tbody>
</table>
Note that the following events are not included in the list because they are continuous events and no meaningful event counts or performance metrics can be obtained at this point: {{domxref("Element/mousemove_event", "mousemove")}}, {{domxref("Element/pointermove_event", "pointermove")}},
{{domxref("Element/pointerrawupdate_event", "pointerrawupdate")}}, {{domxref("Element/touchmove_event", "touchmove")}}, {{domxref("Element/wheel_event", "wheel")}}, {{domxref("HTMLElement/drag_event", "drag")}}.
To get a list of all exposed events, you can also look up keys in the {{domxref("performance.eventCounts")}} map:
```js
const exposedEventsList = [...performance.eventCounts.keys()];
```
## Constructor
This interface has no constructor on its own. See the [example below](#getting_event_timing_information) for how to typically get the information the `PerformanceEventTiming` interface holds.
## Instance properties
This interface extends the following {{domxref("PerformanceEntry")}} properties for event timing performance entry types by qualifying them as follows:
- {{domxref("PerformanceEntry.duration")}} {{ReadOnlyInline}}
- : Returns a {{domxref("DOMHighResTimeStamp")}} representing the time from `startTime` to the next rendering paint (rounded to the nearest 8ms).
- {{domxref("PerformanceEntry.entryType")}} {{ReadOnlyInline}}
- : Returns `"event"` (for long events) or `"first-input"` (for the first user interaction).
- {{domxref("PerformanceEntry.name")}} {{ReadOnlyInline}}
- : Returns the associated event's type.
- {{domxref("PerformanceEntry.startTime")}} {{ReadOnlyInline}}
- : Returns a {{domxref("DOMHighResTimeStamp")}} representing the associated event's [`timestamp`](/en-US/docs/Web/API/Event/timeStamp) property. This is the time the event was created and can be considered as a proxy for the time the user interaction occurred.
This interface also supports the following properties:
- {{domxref("PerformanceEventTiming.cancelable")}} {{ReadOnlyInline}}
- : Returns the associated event's [`cancelable`](/en-US/docs/Web/API/Event/cancelable) property.
- {{domxref("PerformanceEventTiming.interactionId")}} {{ReadOnlyInline}} {{Experimental_Inline}}
- : Returns the ID that uniquely identifies the user interaction which triggered the associated event.
- {{domxref("PerformanceEventTiming.processingStart")}} {{ReadOnlyInline}}
- : Returns a {{domxref("DOMHighResTimeStamp")}} representing the time at which event dispatch started. To measure the time between a user action and the time the event handler starts to run, calculate `processingStart-startTime`.
- {{domxref("PerformanceEventTiming.processingEnd")}} {{ReadOnlyInline}}
- : Returns a {{domxref("DOMHighResTimeStamp")}} representing the time at which the event dispatch ended. To measure the time the event handler took to run, calculate `processingEnd-processingStart`.
- {{domxref("PerformanceEventTiming.target")}} {{ReadOnlyInline}}
- : Returns the associated event's last target, if it is not removed.
## Instance methods
- {{domxref("PerformanceEventTiming.toJSON()")}}
- : Returns a JSON representation of the `PerformanceEventTiming` object.
## Examples
### Getting event timing information
To get event timing information, create a {{domxref("PerformanceObserver")}} instance and then call its [`observe()`](/en-US/docs/Web/API/PerformanceObserver/observe) method, passing in `"event"` or `"first-input"` as the value of the [`type`](/en-US/docs/Web/API/PerformanceEntry/entryType) option. You also need to set `buffered` to `true` to get access to events the user agent buffered while constructing the document. The `PerformanceObserver` object's callback will then be called with a list of `PerformanceEventTiming` objects which you can analyze.
```js
const observer = new PerformanceObserver((list) => {
list.getEntries().forEach((entry) => {
// Full duration
const duration = entry.duration;
// Input delay (before processing event)
const delay = entry.processingStart - entry.startTime;
// Synchronous event processing time
// (between start and end dispatch)
const eventHandlerTime = entry.processingEnd - entry.processingStart;
console.log(`Total duration: ${duration}`);
console.log(`Event delay: ${delay}`);
console.log(`Event handler duration: ${eventHandlerTime}`);
});
});
// Register the observer for events
observer.observe({ type: "event", buffered: true });
```
You can also set a different [`durationThreshold`](/en-US/docs/Web/API/PerformanceObserver/observe#durationthreshold). The default is 104ms and the minimum possible duration threshold is 16ms.
```js
observer.observe({ type: "event", durationThreshold: 16, buffered: true });
```
### Reporting the First Input Delay (FID)
The {{Glossary("first input delay")}} or FID, measures the time from when a user first interacts with a page (i.e. when they click a link or tap on a button) to the time when the browser is actually able to begin processing event handlers in response to that interaction.
```js
// Keep track of whether (and when) the page was first hidden, see:
// https://github.com/w3c/page-visibility/issues/29
// NOTE: ideally this check would be performed in the document <head>
// to avoid cases where the visibility state changes before this code runs.
let firstHiddenTime = document.visibilityState === "hidden" ? 0 : Infinity;
document.addEventListener(
"visibilitychange",
(event) => {
firstHiddenTime = Math.min(firstHiddenTime, event.timeStamp);
},
{ once: true },
);
// Sends the passed data to an analytics endpoint. This code
// uses `/analytics`; you can replace it with your own URL.
function sendToAnalytics(data) {
const body = JSON.stringify(data);
// Use `navigator.sendBeacon()` if available,
// falling back to `fetch()`.
(navigator.sendBeacon && navigator.sendBeacon("/analytics", body)) ||
fetch("/analytics", { body, method: "POST", keepalive: true });
}
// Use a try/catch instead of feature detecting `first-input`
// support, since some browsers throw when using the new `type` option.
// https://webkit.org/b/209216
try {
function onFirstInputEntry(entry) {
// Only report FID if the page wasn't hidden prior to
// the entry being dispatched. This typically happens when a
// page is loaded in a background tab.
if (entry.startTime < firstHiddenTime) {
const fid = entry.processingStart - entry.startTime;
// Report the FID value to an analytics endpoint.
sendToAnalytics({ fid });
}
}
// Create a PerformanceObserver that calls
// `onFirstInputEntry` for each entry.
const po = new PerformanceObserver((entryList) => {
entryList.getEntries().forEach(onFirstInputEntry);
});
// Observe entries of type `first-input`, including buffered entries,
// i.e. entries that occurred before calling `observe()` below.
po.observe({
type: "first-input",
buffered: true,
});
} catch (e) {
// Do nothing if the browser doesn't support this API.
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/performanceeventtiming | data/mdn-content/files/en-us/web/api/performanceeventtiming/processingend/index.md | ---
title: "PerformanceEventTiming: processingEnd property"
short-title: processingEnd
slug: Web/API/PerformanceEventTiming/processingEnd
page-type: web-api-instance-property
browser-compat: api.PerformanceEventTiming.processingEnd
---
{{APIRef("Performance API")}}
The read-only **`processingEnd`** property returns the time the last event handler finished executing.
It's equal to {{domxref("PerformanceEventTiming.processingStart")}} when there are no such event handlers.
## Value
A {{domxref("DOMHighResTimeStamp")}} timestamp.
## Examples
### Using the processingEnd property
The `processingEnd` property can be used when observing event-timing entries ({{domxref("PerformanceEventTiming")}}). For example, to calculate input delay or event processing times.
```js
const observer = new PerformanceObserver((list) => {
list.getEntries().forEach((entry) => {
// Full duration
const duration = entry.duration;
// Input delay (before processing event)
const delay = entry.processingStart - entry.startTime;
// Synchronous event processing time
// (between start and end dispatch)
const time = entry.processingEnd - entry.processingStart;
});
});
// Register the observer for events
observer.observe({ type: "event", buffered: true });
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("PerformanceEventTiming.processingStart")}}
| 0 |
data/mdn-content/files/en-us/web/api/performanceeventtiming | data/mdn-content/files/en-us/web/api/performanceeventtiming/processingstart/index.md | ---
title: "PerformanceEventTiming: processingStart property"
short-title: processingStart
slug: Web/API/PerformanceEventTiming/processingStart
page-type: web-api-instance-property
browser-compat: api.PerformanceEventTiming.processingStart
---
{{APIRef("Performance API")}}
The read-only **`processingStart`** property returns the time at which event dispatch started. This is when event handlers are about to be executed.
## Value
A {{domxref("DOMHighResTimeStamp")}} timestamp.
## Examples
### Using the processingStart property
The `processingStart` property can be used when observing event timing entries ({{domxref("PerformanceEventTiming")}}). For example, to calculate input delay or event processing times.
```js
const observer = new PerformanceObserver((list) => {
list.getEntries().forEach((entry) => {
// Full duration
const duration = entry.duration;
// Input delay (before processing event)
const delay = entry.processingStart - entry.startTime;
// Synchronous event processing time
// (between start and end dispatch)
const time = entry.processingEnd - entry.processingStart;
});
});
// Register the observer for events
observer.observe({ type: "event", buffered: true });
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("PerformanceEventTiming.processingEnd")}}
| 0 |
data/mdn-content/files/en-us/web/api/performanceeventtiming | data/mdn-content/files/en-us/web/api/performanceeventtiming/target/index.md | ---
title: "PerformanceEventTiming: target property"
short-title: target
slug: Web/API/PerformanceEventTiming/target
page-type: web-api-instance-property
browser-compat: api.PerformanceEventTiming.target
---
{{APIRef("Performance API")}}
The read-only **`target`** property returns the associated event's last [`target`](/en-US/docs/Web/API/Event/target) which is the node onto which the event was last dispatched.
## Value
A {{domxref("Node")}} onto which the event was last dispatched.
Or [`null`](/en-US/docs/Web/JavaScript/Reference/Operators/null) if the `Node` is disconnected from the document's DOM or is in the [shadow DOM](/en-US/docs/Web/API/Web_components/Using_shadow_DOM).
## Examples
### Observing events with a specific last target
The `target` property can be used when observing event-timing entries ({{domxref("PerformanceEventTiming")}}). For example, to log and measure events for a given last target only.
```js
const observer = new PerformanceObserver((list) => {
list.getEntries().forEach((entry) => {
if (entry.target && entry.target.id === "myNode") {
const delay = entry.processingStart - entry.startTime;
console.log(entry.name, delay);
}
});
});
// Register the observer for events
observer.observe({ type: "event", buffered: true });
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/performanceeventtiming | data/mdn-content/files/en-us/web/api/performanceeventtiming/interactionid/index.md | ---
title: "PerformanceEventTiming: interactionId property"
short-title: interactionId
slug: Web/API/PerformanceEventTiming/interactionId
page-type: web-api-instance-property
status:
- experimental
browser-compat: api.PerformanceEventTiming.interactionId
---
{{APIRef("Performance API")}}{{SeeCompatTable}}
The read-only **`interactionId`** property returns an ID that uniquely identifies a user interaction which triggered a series of associated events.
## Description
When a user interacts with a web page, a user interaction (for example a click) usually triggers a sequence of events, such as `pointerdown`, `pointerup`, and `click` events. To measure the latency of this series of events, the events share the same `interactionId`.
An `interactionId` is only computed for the following event types belonging to a user interaction. It is `0` otherwise.
| Event types | User interaction |
| --------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ |
| {{domxref("Element/pointerdown_event", "pointerdown")}}, {{domxref("Element/pointerup_event", "pointerup")}}, {{domxref("Element/click_event", "click")}} | click / tap / drag |
| {{domxref("Element/keydown_event", "keydown")}}, {{domxref("Element/keyup_event", "keyup")}} | key press |
## Value
A number.
## Examples
### Using interactionId
The following example collects event duration for all events corresponding to an interaction. The `eventLatencies` map can then be used to find events with maximum duration for a user interaction, for example.
```js
// The key is the interaction ID.
let eventLatencies = {};
const observer = new PerformanceObserver((list) => {
list.getEntries().forEach((entry) => {
if (entry.interactionId > 0) {
const interactionId = entry.interactionId;
if (!eventLatencies.has(interactionId)) {
eventLatencies[interactionId] = [];
}
eventLatencies[interactionId].push(entry.duration);
}
});
});
observer.observe({ type: "event", buffered: true });
// Log events with maximum event duration for a user interaction
Object.entries(eventLatencies).forEach(([k, v]) => {
console.log(Math.max(...v));
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/performanceeventtiming | data/mdn-content/files/en-us/web/api/performanceeventtiming/cancelable/index.md | ---
title: "PerformanceEventTiming: cancelable property"
short-title: cancelable
slug: Web/API/PerformanceEventTiming/cancelable
page-type: web-api-instance-property
browser-compat: api.PerformanceEventTiming.cancelable
---
{{APIRef("Performance API")}}
The read-only **`cancelable`** property returns the associated event's [`cancelable`](/en-US/docs/Web/API/Event/cancelable) property, indicating whether the event can be canceled.
## Value
A boolean. `true` if the associated event is cancelable, `false` otherwise.
## Examples
### Observing non-cancelable events
The `cancelable` property can be used when observing event-timing entries ({{domxref("PerformanceEventTiming")}}). For example, to log and measure non-cancelable events only.
```js
const observer = new PerformanceObserver((list) => {
list.getEntries().forEach((entry) => {
if (!entry.cancelable) {
const delay = entry.processingStart - entry.startTime;
console.log(entry.name, delay);
}
});
});
// Register the observer for events
observer.observe({ type: "event", buffered: true });
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/performanceeventtiming | data/mdn-content/files/en-us/web/api/performanceeventtiming/tojson/index.md | ---
title: "PerformanceEventTiming: toJSON() method"
short-title: toJSON()
slug: Web/API/PerformanceEventTiming/toJSON
page-type: web-api-instance-method
browser-compat: api.PerformanceEventTiming.toJSON
---
{{APIRef("Performance API")}}
The **`toJSON()`** method of the {{domxref("PerformanceEventTiming")}} interface is a {{Glossary("Serialization","serializer")}}; it returns a JSON representation of the {{domxref("PerformanceEventTiming")}} object.
## Syntax
```js-nolint
toJSON()
```
### Parameters
None.
### Return value
A {{jsxref("JSON")}} object that is the serialization of the {{domxref("PerformanceEventTiming")}} object.
The JSON doesn't contain the {{domxref("PerformanceEventTiming.target", "target")}} property because it is of type {{domxref("Node")}}, which doesn't provide a `toJSON()` operation.
## Examples
### Using the toJSON method
In this example, calling `entry.toJSON()` returns a JSON representation of the `PerformanceEventTiming` object.
```js
const observer = new PerformanceObserver((list) => {
list.getEntries().forEach((entry) => {
console.log(entry.toJSON());
});
});
observer.observe({ type: "event", buffered: true });
```
This would log a JSON object like so:
```json
{
"name": "dragover",
"entryType": "event",
"startTime": 67090751.599999905,
"duration": 128,
"processingStart": 67090751.70000005,
"processingEnd": 67090751.900000095,
"cancelable": true
}
```
To get a JSON string, you can use [`JSON.stringify(entry)`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify) directly; it will call `toJSON()` automatically.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{jsxref("JSON")}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/batterymanager/index.md | ---
title: BatteryManager
slug: Web/API/BatteryManager
page-type: web-api-interface
browser-compat: api.BatteryManager
---
{{ApiRef("Battery API")}}{{securecontext_header}}
The `BatteryManager` interface of the {{domxref("Battery Status API", "", "", "nocode")}} provides information about the system's battery charge level. The {{domxref("navigator.getBattery()")}} method returns a promise that resolves with a `BatteryManager` interface.
Since Chrome 103, the `BatteryManager` interface of {{domxref("Battery Status API", "", "", "nocode")}} only expose to secure context.
{{InheritanceDiagram}}
## Instance properties
_Also inherits properties from its parent interface, {{domxref("EventTarget")}}._
- {{domxref("BatteryManager.charging")}} {{ReadOnlyInline}}
- : A Boolean value indicating whether the battery is currently being charged.
- {{domxref("BatteryManager.chargingTime")}} {{ReadOnlyInline}}
- : A number representing the remaining time in seconds until the battery is fully charged, or 0 if the battery is already fully charged.
- {{domxref("BatteryManager.dischargingTime")}} {{ReadOnlyInline}}
- : A number representing the remaining time in seconds until the battery is completely discharged and the system suspends.
- {{domxref("BatteryManager.level")}} {{ReadOnlyInline}}
- : A number representing the system's battery charge level scaled to a value between 0.0 and 1.0.
## Instance methods
_Also inherits methods from its parent interface, {{domxref("EventTarget")}}._
## Events
- {{domxref("BatteryManager/chargingchange_event", "chargingchange")}}
- : Fired when the battery charging state (the {{domxref("BatteryManager.charging", "charging")}} property) is updated.
- {{domxref("BatteryManager/chargingtimechange_event", "chargingtimechange")}}
- : Fired when the battery charging time (the {{domxref("BatteryManager.chargingTime", "chargingTime")}} property) is updated.
- {{domxref("BatteryManager/dischargingtimechange_event", "dischargingtimechange")}}
- : Fired when the battery discharging time (the {{domxref("BatteryManager.dischargingTime", "dischargingTime")}} property) is updated.
- {{domxref("BatteryManager/levelchange_event", "levelchange")}}
- : Fired when the battery level (the {{domxref("BatteryManager.level", "level")}} property) is updated.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The {{domxref("Battery Status API", "", "", "nocode")}}
- {{domxref("Navigator.getBattery()")}}
| 0 |
data/mdn-content/files/en-us/web/api/batterymanager | data/mdn-content/files/en-us/web/api/batterymanager/charging/index.md | ---
title: "BatteryManager: charging property"
short-title: charging
slug: Web/API/BatteryManager/charging
page-type: web-api-instance-property
browser-compat: api.BatteryManager.charging
---
{{ApiRef("Battery API")}}{{securecontext_header}}
The **`BatteryManager.charging`** property is a Boolean value indicating whether or not the device's battery is currently being charged. When its value changes, the {{domxref("BatteryManager/chargingchange_event", "chargingchange")}} event is fired.
If the battery is charging or the user agent is unable to report the battery status information, this value is `true`. Otherwise, it is `false`.
## Value
A boolean.
## Examples
### HTML
```html
<div id="charging">(charging state unknown)</div>
```
### JavaScript
```js
navigator.getBattery().then((battery) => {
const charging = battery.charging;
document.querySelector("#charging").textContent = charging;
});
```
{{ EmbedLiveSample('Examples', '100%', 30) }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("BatteryManager")}}
- {{domxref("Navigator.getBattery()")}}
| 0 |
data/mdn-content/files/en-us/web/api/batterymanager | data/mdn-content/files/en-us/web/api/batterymanager/level/index.md | ---
title: "BatteryManager: level property"
short-title: level
slug: Web/API/BatteryManager/level
page-type: web-api-instance-property
browser-compat: api.BatteryManager.level
---
{{ApiRef("Battery API")}}{{securecontext_header}}
The **`BatteryManager.level`** property indicates the current battery charge level as a value between `0.0` and `1.0`.
A value of `0.0` means the battery is empty and the system is about to be suspended.
A value of `1.0` means the battery is full or the user agent is unable to report the battery status information.
When its value changes, the {{domxref("BatteryManager/levelchange_event", "levelchange")}} event is fired.
## Value
A number.
## Examples
### Getting the battery level
#### HTML
```html
<button id="get-level">Get battery level</button>
<div id="output"></div>
```
#### JavaScript
```js
const getLevel = document.querySelector("#get-level");
const output = document.querySelector("#output");
getLevel.addEventListener("click", async () => {
if (!navigator.getBattery) {
output.textContent = "Battery manager is unsupported";
} else {
const manager = await navigator.getBattery();
const level = manager.level;
output.textContent = `Battery level: ${level}`;
}
});
```
#### Result
{{ EmbedLiveSample('Getting the battery level') }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("BatteryManager")}}
- {{domxref("Navigator.getBattery()")}}
| 0 |
data/mdn-content/files/en-us/web/api/batterymanager | data/mdn-content/files/en-us/web/api/batterymanager/chargingchange_event/index.md | ---
title: "BatteryManager: chargingchange event"
short-title: chargingchange
slug: Web/API/BatteryManager/chargingchange_event
page-type: web-api-event
browser-compat: api.BatteryManager.chargingchange_event
---
{{ApiRef("Battery API")}}{{securecontext_header}}
The **`chargingchange`** event of the {{domxref("Battery Status API", "", "", "nocode")}} is fired when the battery {{domxref("BatteryManager.charging", "charging")}} property is updated.
## Syntax
Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property.
```js-nolint
addEventListener("chargingchange", (event) => { })
onchargingchange = (event) => { }
```
## Event type
_A generic {{domxref("Event")}}._
## Example
### HTML
```html
<div id="level">(battery level unknown)</div>
<div id="chargingTime">(charging time unknown)</div>
```
### JavaScript
```js
navigator.getBattery().then((battery) => {
battery.onchargingchange = () => {
document.querySelector("#level").textContent = battery.level;
document.querySelector("#chargingTime").textContent = battery.chargingTime;
};
});
```
{{ EmbedLiveSample('Example', '100%', 40) }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("BatteryManager")}}
- {{domxref("Navigator.getBattery()")}}
| 0 |
data/mdn-content/files/en-us/web/api/batterymanager | data/mdn-content/files/en-us/web/api/batterymanager/dischargingtime/index.md | ---
title: "BatteryManager: dischargingTime property"
short-title: dischargingTime
slug: Web/API/BatteryManager/dischargingTime
page-type: web-api-instance-property
browser-compat: api.BatteryManager.dischargingTime
---
{{ApiRef("Battery API")}}{{securecontext_header}}
The **`BatteryManager.dischargingTime`** property indicates the amount of time, in seconds, that remains until the battery is fully discharged,
or {{jsxref("Infinity")}} if the battery is currently charging rather than discharging or the user agent is unable to report the battery status information.
When its value changes, the {{domxref("BatteryManager/dischargingtimechange_event", "dischargingtimechange")}} event is fired.
> **Note:** Even if the time returned is precise to the second, browsers round them to a higher
> interval (typically to the closest 15 minutes) for privacy reasons.
## Value
A number.
## Examples
### HTML
```html
<div id="dischargingTime">(discharging time unknown)</div>
```
### JavaScript
```js
navigator.getBattery().then((battery) => {
const time = battery.dischargingTime;
document.querySelector("#dischargingTime").textContent =
`Remaining time to fully discharge the battery: ${time}`;
});
```
{{ EmbedLiveSample('Examples', '100%', 30) }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("BatteryManager")}}
- {{domxref("Navigator.getBattery()")}}
| 0 |
data/mdn-content/files/en-us/web/api/batterymanager | data/mdn-content/files/en-us/web/api/batterymanager/chargingtime/index.md | ---
title: "BatteryManager: chargingTime property"
short-title: chargingTime
slug: Web/API/BatteryManager/chargingTime
page-type: web-api-instance-property
browser-compat: api.BatteryManager.chargingTime
---
{{ApiRef("Battery API")}}{{securecontext_header}}
The **`BatteryManager.chargingTime`** property indicates the amount of time, in seconds, that remain until the battery is fully charged, or `0` if the battery is already fully charged or the user agent is unable to report the battery status information.
If the battery is currently discharging, its value is {{jsxref("Infinity")}}.
When its value changes, the {{domxref("BatteryManager/chargingtimechange_event", "chargingtimechange")}} event is fired.
> **Note:** Even if the time returned is precise to the second,
> browsers round them to a higher interval
> (typically to the closest 15 minutes) for privacy reasons.
## Value
A number.
## Examples
### HTML
```html
<div id="chargingTime">(charging time unknown)</div>
```
### JavaScript
```js
navigator.getBattery().then((battery) => {
const time = battery.chargingTime;
document.querySelector("#chargingTime").textContent =
`Time to fully charge the battery: ${time}s`;
});
```
{{ EmbedLiveSample('Examples', '100%', 30) }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("BatteryManager")}}
- {{domxref("Navigator.getBattery()")}}
| 0 |
data/mdn-content/files/en-us/web/api/batterymanager | data/mdn-content/files/en-us/web/api/batterymanager/chargingtimechange_event/index.md | ---
title: "BatteryManager: chargingtimechange event"
short-title: chargingtimechange
slug: Web/API/BatteryManager/chargingtimechange_event
page-type: web-api-event
browser-compat: api.BatteryManager.chargingtimechange_event
---
{{ApiRef("Battery API")}}{{securecontext_header}}
The **`chargingtimechange`** event of the {{domxref("Battery Status API", "", "", "nocode")}} is fired when the battery {{domxref("BatteryManager.chargingTime", "chargingTime")}} property is updated.
## Syntax
Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property.
```js-nolint
addEventListener("chargingtimechange", (event) => { })
onchargingtimechange = (event) => { }
```
## Event type
_A generic {{domxref("Event")}}._
## Example
### HTML
```html
<div id="level">(battery level unknown)</div>
<div id="chargingTime">(charging time unknown)</div>
```
### JavaScript
```js
navigator.getBattery().then((battery) => {
battery.onchargingtimechange = () => {
document.querySelector("#level").textContent = battery.level;
document.querySelector("#chargingTime").textContent = battery.chargingTime;
};
});
```
{{ EmbedLiveSample('Example', '100%', 40) }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("BatteryManager")}}
- {{domxref("Navigator.getBattery()")}}
| 0 |
Subsets and Splits