https://github.com/jfet97/aww
Async Iterables Interfaces for Web Workers
https://github.com/jfet97/aww
async es2018 es6 iterables javascript webworkers
Last synced: 4 days ago
JSON representation
Async Iterables Interfaces for Web Workers
- Host: GitHub
- URL: https://github.com/jfet97/aww
- Owner: jfet97
- License: mit
- Created: 2019-08-31T19:07:59.000Z (almost 7 years ago)
- Default Branch: master
- Last Pushed: 2023-01-04T08:37:22.000Z (over 3 years ago)
- Last Synced: 2026-06-17T20:38:34.358Z (4 days ago)
- Topics: async, es2018, es6, iterables, javascript, webworkers
- Language: JavaScript
- Size: 45.9 KB
- Stars: 111
- Watchers: 3
- Forks: 3
- Open Issues: 5
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# aww
__Async Iterables Interfaces for Web Workers__
This is a proof of concept library that enables async iteration with web workers. Errors handling is not yet supported.
```sh
npm i -S aww
```
Do not use the `postMessage` method of my wrappers while you are async iterating: use the `reply` method instead.
## How to iterate over the invoker's incoming data (from the worker perspective)
### worker.js
```js
import { AISource } from 'aww';
const delay = (ms, v) => new Promise(res => setTimeout(res, ms, v));
;(async () => {
// will handle onmessage events and other stuff
// it's an async iterable
const source = new AISource();
for await(const msg of source) {
console.log(`${msg.data} received inside worker`);
await delay(2000, msg); // fake long task
// next messages from the main will be handled by the async iteration
// no sense making this awaitable
// DO NOT USE postMessage!
source.reply("It's all good from worker!");
}
})();
```
### main.js
```js
import { AIWorker } from 'aww';
const delay = (ms, v) => new Promise(res => setTimeout(res, ms, v));
;(async () => {
const myWorker = new AIWorker(new Worker('./worker.js'));
let i = 0;
while(true) {
await delay(1000);
// you can await the response from the worker, but it is not mandatory
await myWorker.postMessage(i++).then(({data}) => console.log(data));
/*
alternative syntax
const { data } = await myWorker.postMessage(i++);
console.log(data);
*/
}
})();
```
## How to iterate over the worker's incoming data (from the invoker perspective)
### main.js
```js
import { AIWorker } from 'aww';
const delay = (ms, v) => new Promise(res => setTimeout(res, ms, v));
;(async () => {
const myWorker = new AIWorker(new Worker('./worker.js'));
// will handle onmessage events and other stuff
// it's an async iterable
for await(const msg of myWorker) {
console.log(`${msg.data} received inside main`);
await delay(2000, msg); // fake long task
// next messages from the main will be handled by the async iteration
// no sense making this awaitable
// DO NOT USE postMessage!
myWorker.reply("It's all good from main!");
}
})();
```
### worker.js
```js
import { AISource } from 'aww';
const delay = (ms, v) => new Promise(res => setTimeout(res, ms, v));
;(async () => {
const source = new AISource();
let i = 0;
while(true) {
await delay(1000);
// you can await the response from the main, but it is not mandatory
await source.postMessage(i++).then(({data}) => console.log(data));
/*
alternative syntax
const { data } = await source.postMessage(i++);
console.log(data);
*/
}
})();
```
## How to iterate over both at the same time
### main.js
```js
import { AIWorker } from 'aww';
const delay = (ms, v) => new Promise(res => setTimeout(res, ms, v));
;(async () => {
const myWorker = new AIWorker(new Worker('./worker.js'));
// start the iteration posting a message
// because both the main and the worker are waiting to start the iteration
// not awaitable because the subsequent async iteration will handle worker's messages
// DO NOT USE postMessage!
myWorker.reply("Please start!");
for await(const msg of myWorker) {
console.log(`${msg.data} received inside main`);
await delay(1000, msg); // fake long task
// next messages from the main will be handled by the async iteration
// no sense making this awaitable
// DO NOT USE postMessage!
myWorker.reply("It's all good from main!");
}
})();
```
### worker.js
```js
import { AISource } from 'aww';
const delay = (ms, v) => new Promise(res => setTimeout(res, ms, v));
;(async () => {
const source = new AISource();
for await(const msg of source) {
console.log(`${msg.data} received inside worker`);
await delay(2000, msg); // fake long task
// next messages from the main will be handled by the async iteration
// no sense making this awaitable
// DO NOT USE postMessage!
source.reply("It's all good from worker!");
}
})();
```
