docs: document ".finally()"

Author: kettanaito

README.md

@@ -18,6 +18,7 @@ npm install @open-draft/deferred-promise
   - [`deferredProimse.result`](#deferredpromiseresult)
   - [`deferredPromise.resolve()`](#deferredpromiseresolve)
   - [`deferredPromies.reject()`](#deferredpromisereject)
+  - [`deferredPromise.finally()`](#deferredpromisefinally)
 
 ## Class: `DeferredPromise`
 
@@ -26,9 +27,9 @@ npm install @open-draft/deferred-promise
 Creates a new instance of a deferred promise.
 
 ```js
-import { DeferredPromise } from '@open-draft/deferred-promise'
+import { DeferredPromise } from "@open-draft/deferred-promise";
 
-const promise = new DeferredPromise()
+const promise = new DeferredPromise();
 ```
 
 Unlike the regular `Promise`, a deferred promise does not accept the callback function. Instead, you should use [`.resolve()`](#deferredpromiseresolve) and [`.reject()`](#deferredpromisereject) to resolve and reject the promise respectively.
@@ -40,33 +41,33 @@ A deferred promise is fully compatible with the native `Promise`, which means yo
 - `<"pending" | "resolved" | "rejected">` **Default:** `"pending"`
 
 ```js
-const promise = new DeferredPromise()
-console.log(promise.state) // "pending"
+const promise = new DeferredPromise();
+console.log(promise.state); // "pending"
 
-promise.resolve()
-console.log(promise.state) // "resolved"
+promise.resolve();
+console.log(promise.state); // "resolved"
 ```
 
 ### `deferredPromise.result`
 
 Returns the value that has resolved the promise. If no value has been provided to the `.resolve()` call, `undefined` is returned instead.
 
 ```js
-const promise = new DeferredPromise()
-promise.resolve('John')
+const promise = new DeferredPromise();
+promise.resolve("John");
 
-console.log(promise.result) // "John"
+console.log(promise.result); // "John"
 ```
 
 ### `deferredPromise.rejectionReason`
 
 Returns the reason that has rejected the promise. If no reason has been provided to the `.reject()` call, `undefined` is returned instead.
 
 ```js
-const promise = new DeferredPromise()
-promise.reject(new Error('Internal Server Error'))
+const promise = new DeferredPromise();
+promise.reject(new Error("Internal Server Error"));
 
-console.log(promise.rejectionReason) // Error
+console.log(promise.rejectionReason); // Error
 ```
 
 ### `deferredPromise.resolve()`
@@ -75,21 +76,21 @@ Resolves the deferred promise with a given value.
 
 ```js
 function startServer() {
-  const serverReady = new DeferredPromise()
+  const serverReady = new DeferredPromise();
 
   new http.Server().listen(() => {
     // Resolve the deferred promise with the server address
     // once the server is ready.
-    serverReady.resolve('http://localhost:8080')
-  })
+    serverReady.resolve("http://localhost:8080");
+  });
 
   // Return the deferred promise to the consumer.
-  return serverReady
+  return serverReady;
 }
 
 startServer().then((address) => {
-  console.log('Server is running at "%s"', address)
-})
+  console.log('Server is running at "%s"', address);
+});
 ```
 
 ### `deferredPromise.reject()`
@@ -98,17 +99,30 @@ Rejects the deferred promise with a given reason.
 
 ```js
 function createBroadcast() {
-  const runtimePromise = new DeferredPromise()
+  const runtimePromise = new DeferredPromise();
 
-  receiver.on('error', (error) => {
+  receiver.on("error", (error) => {
     // Reject the deferred promise in response
     // to the incoming "error" event.
-    runtimePromise.reject(error)
-  })
+    runtimePromise.reject(error);
+  });
 
   // This deferred promise will be pending forever
   // unless the broadcast channel receives the
   // "error" event that rejects it.
-  return runtimePromise
+  return runtimePromise;
 }
 ```
+
+### `deferredPromise.finally()`
+
+Attaches a callback that executes when the deferred promise is settled (resolved or rejected).
+
+```js
+const channelReady = new DeferredPromise();
+
+channelReady.finally(async () => {
+  // Perform a cleanup side-effect once we're done.
+  await channel.close();
+});
+```