https://github.com/jwplayer/overwait
A lightweight library to supercharge the await operator!
https://github.com/jwplayer/overwait
Last synced: about 1 year ago
JSON representation
A lightweight library to supercharge the await operator!
- Host: GitHub
- URL: https://github.com/jwplayer/overwait
- Owner: jwplayer
- License: apache-2.0
- Created: 2023-09-30T18:55:40.000Z (almost 3 years ago)
- Default Branch: master
- Last Pushed: 2023-10-06T06:10:27.000Z (almost 3 years ago)
- Last Synced: 2025-03-22T03:51:12.939Z (over 1 year ago)
- Language: JavaScript
- Size: 86.9 KB
- Stars: 3
- Watchers: 3
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE.txt
- Code of conduct: CODE_OF_CONDUCT.md
Awesome Lists containing this project
README
# Overwait
A lightweight library to supercharge the await operator!
## Description
Overwait takes your objects (and functions) and wraps them in a `Proxy` that automatically distributes the `await` operator down every step during property lookups, function return values, etc.
### What does that mean?
In practice, overwait transforms `await a.b.c` into `await (await (await a).b).c`.
## Usage
`overwait` is a single function. Simply pass it an object or a function and it'll return a `Proxy` that wraps the original object and intercepts property accesses. For example:
```js
import overwait from 'overwait';
// Wrap the fetch function to make it less tedious
const fetchy = overwait(fetch);
```
Here are some _before_ and _afters_ to give you an idea of the kind of code transformations that `overwait` enables:
Before...
...with Overwait!
```js
const res = await fetch('https://x.com');
const body = await res.json();
```
```js
const body = await fetchy('https://x.com').json();
```
```js
// Not a specific db library, just an example
const conn = await db.conn('mydb');
const cursor = await conn.query('SELECT A');
const row = await cursor.getRow();
const value = await row.A;
```
```js
const value = await db.conn('mydb')
.query('SELECT A')
.getRow().A;
```
```js
const [fileHandle] = await showOpenFilePicker();
const file = await fileHandle.getFile();
```
```js
const file = await showOpenFilePicker()[0].getFile();
```
### Other cool things!
When using `overwait` to traverse a property chain, we automatically wrap the `this` value in functions that are executed as a part of that traversal.
This fact allows you to write code like this:
```js
const getValueFooBar = async function() {
// We don't need concern ourselves if
// `this`, `foo`, or `bar` are some mix of promises:
return await this.foo.bar;
};
```
Then when using that function in an object, it just works:
```js
const obj = overwait({
foo: Promise.resolve({
bar: Promise.resolve('hi there!')
})
value: getValueFooBar
});
await obj.value(); //=> 'hi there!';
```
## But, Jon, I don't want to use `await`!
No `await`? No problem!
Because `await` is just syntactic sugar for `then`, the way the library works actually allows you to `then` to your hearts content.
What this means is that to `overwait` this:
```js
await promise1.promise2.promise3;
/*...stuff what comes after...*/
```
Is identical to this:
```js
promise1.promise2.promise3.then(() => {
/*...stuff what comes after...*/
});
```
...and it just works!