ArrayAsynchornousIteratorcomposes programs sequentially with a single input
AsynchornousIteratorundefinedAsynchornousIteratorcreates an iterator whose values are filtered from another
AsynchornousIteratorcreates an iterator whose values are reduced from another
AsynchornousIteratorcreates an iterator whose values are reduced from another
Promisereturns a resolved promise after a given amount of time useful for pausing asynchronous programs
AsyncTransformercomposes two asynchoronous transformers
PushPaircreate a queue iterator
PushPaircreate a stack iterator
PushPairidentity program that outputs what ever is input Like "queue", but accepts program as input
PushPairidentity program that outputs what ever is input Like "queue", but accepts program as input
Promise.<Array>extract items from iterator as array
Promise.<Array>extract first set of items that match a given condition as an array
AsynchronousIteratorprogram that outputs what ever is put throught
AsynchronousIteratorprogram that takes no input and contiuously outputs result of calling function
AsyncRenderFunctioncreates a render function that renders yeilded results from programs to any number of target functions. If no targets are given, objects will be rendered using "console.log" Can be used as a "passthrough" (see "createQueue" example)
AsyncRenderFunctioncreates a render function whos's values are teed on to given It may be advantageous to use this along side a programQueue
send input typed into console to a PairedRespond function
send input piped to console to a PairedRespond function
Promise.<*>a function that receives it's response from a paired PairedRespond function
functiona function that sends it's input to a paired PairedRequest function
*stateless asynchronous function that transforms input without side effects
AsynchronousIteratoran iteractive program
functiona function that renders values from a given [Asynchronous] Iterator
Arrayan iterator and a paired function to add to it
Array
**Kind**: global class
**Extends**: Array
### new AsyncArray()
An Asynchronous Array
**Example**
```js
import {AsyncArray} from "async-endpoint";
const input = new AsyncArray();
const main = async()=>{
setTimeout(()=>{
input.push("hello world");
})
const {value} = await input.next();
console.log(value);
}
main();
//logs "hello world"
```
**Example**
```js
import {AsyncArray} from "async-endpoint";
const input = new AsyncArray();
const main = async()=>{
setTimeout(()=>{
input.push("hello");
input.push("world");
})
for await(const value of input){
console.log(vaue);
}
}
main();
//logs "hello"
//logs "world"
```
## composePrograms(request, ...programs) ⇒ AsynchornousIterator
composes programs sequentially with a single input
**Kind**: global function
**Returns**: AsynchornousIterator - resulting iterator
| Param | Type | Description |
| --- | --- | --- |
| request | function | request function for input |
| ...programs | [Program](#Program) | programs to be composed sequentially |
**Example**
```js
import {composePrograms, AsyncArray} from "async-endpoint";
import porgram1, program1, program3 from "....js";
const channel = new AsyncArray();
const respond = channel.push.bind(channel),
request = async () => (await channel.next()).value;
const program = composePrograms(request, program1, program2, program3);
window.respond = respond;
```
## creates an iterator whose values are mapped from another(iterator, mapper) ⇒ AsynchornousIterator
**Kind**: global function
**Returns**: AsynchornousIterator - resulting iterator
| Param | Type | Description |
| --- | --- | --- |
| iterator | AsynchornousIterator | iterator to be mapped |
| mapper | [AsyncTransformer](#AsyncTransformer) | transformation for individual items |
**Example**
```js
import {map, continuousOutput}, from "async-endpoint";
let i = 0;
const mapped = map(continuousOutput(()=>i++), (n) => n + 2);
const main = async ()=>{
for await(item of mapped){
console.log(item);
}
}
main();
logs "2"
logs "3"
logs "4"
...
```
## executes a provided funcition for each item of an iterator(iterator, handler) ⇒ undefined
**Kind**: global function
| Param | Type | Description |
| --- | --- | --- |
| iterator | AsynchornousIterator | iterator |
| handler | [AsyncTransformer](#AsyncTransformer) | provided function |
**Example**
```js
import {forEach, continuousOutput}, from "async-endpoint";
let i = 0;
forEach(continuousOutput(()=>i++, console.log));
main();
logs "2"
logs "3"
logs "4"
...
```
## filter(iterator, filterer) ⇒ AsynchornousIterator
creates an iterator whose values are filtered from another
**Kind**: global function
**Returns**: AsynchornousIterator - filtered iterator
| Param | Type | Description |
| --- | --- | --- |
| iterator | AsynchornousIterator | iterator to be filtered |
| filterer | function | boolean filtering function |
**Example**
```js
import {filter, continuousOutput} from "async-endpoint";
let i = 0;
const filtered =filter(continuousOutput(()=>i++), (n)=>n%2);
const main = async ()=>{
for await(item of filtered){
console.log(item);
}
}
main();
logs "1"
logs "3"
logs "5"
```
## reduce(iterator, reducer, [inital], [condition], [resetInitial]) ⇒ AsynchornousIterator
creates an iterator whose values are reduced from another
**Kind**: global function
**Returns**: AsynchornousIterator - reduced iterator
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| iterator | AsynchornousIterator | | iterator to be reduced |
| reducer | function | | reducing function |
| [inital] | \* | | initial object to reduce into |
| [condition] | function | (item, initial) => false | boolean filtering function indicating when to start new reduction phase |
| [resetInitial] | function | ()=>initial | method to reset/replace initial reduction object |
**Example**
```js
import {reduce, continuousOutput} from "async-endpoint";
let i = 0;
const reduced = reduce(continuousOutput(()=>i++) , (previous, current)=>previous.push(current),[], (x)=!(x%5), ()=>([]));
const main = async ()=>{
for await(item of reduced){
console.log(item);
}
}
main();
logs "[0]"
logs "[1, 2, 3, 4, 5]"
...
```
## reduceRight(iterator, reducer, [inital], [condition], [resetInitial]) ⇒ AsynchornousIterator
creates an iterator whose values are reduced from another
**Kind**: global function
**Returns**: AsynchornousIterator - reduced iterator
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| iterator | AsynchornousIterator | | iterator to be reduced |
| reducer | function | | reducing function |
| [inital] | \* | | initial object to reduce into |
| [condition] | function | (item, initial) => false | boolean filtering function indicating when to start new reduction phase |
| [resetInitial] | function | ()=>initial | method to reset/replace initial reduction object |
**Example**
```js
import {reduce, continuousOutput} from "async-endpoint";
let i = 0;
const reduced = reduce(continuousOutput(()=>i++) , (previous, current)=>previous.push(current),[], (x)=!(x%5), ()=>([]));
const main = async ()=>{
for await(item of reduced){
console.log(item);
}
}
main();
logs "[0]"
logs "[1, 2, 3, 4, 5]"
...
```
## pause(milliseconds, value) ⇒ Promise
returns a resolved promise after a given amount of time
useful for pausing asynchronous programs
**Kind**: global function
**Returns**: Promise - promise fulfilled with value
| Param | Type | Description |
| --- | --- | --- |
| milliseconds | Number | time to pause |
| value | \* | optional returned value |
**Example**
```js
import {pause} from "async-endopint.js";
const main = async ()=>{
console.log("hello");
await pause(1000);
console.log("goodbye");
}
main();
//logs "hello"
//logs "goodbye" (after 1 second)
```
## composeAsyncTransformer(last, first) ⇒ [AsyncTransformer](#AsyncTransformer)
composes two asynchoronous transformers
**Kind**: global function
**Returns**: [AsyncTransformer](#AsyncTransformer) - asynchonous compositon of current and pre
| Param | Type | Description |
| --- | --- | --- |
| last | [AsyncTransformer](#AsyncTransformer) | transformer to apply last |
| first | [AsyncTransformer](#AsyncTransformer) | transformer to apply first |
**Example**
```js
import {composeAsyncTransformer} from "async-endopint.js";
const t1 = async (x)=>`<${x}>`;
const t2 = async (x)=>`[${x}]`;
const t = composeAsyncTransformer(t1, t2);
t("hello").then(console.log);
//logs "<[hello]>"
```
## createQueue(...initial) ⇒ [PushPair](#PushPair)
create a queue iterator
**Kind**: global function
**Returns**: [PushPair](#PushPair) - queue and push function
| Param | Type | Description |
| --- | --- | --- |
| ...initial | \* | initial items in queue |
**Example**
```js
import {createQueue, renderer, renderer as createPassThrough} from "async-endpoint";
import porgram1, program1, program3 from "....js";
const [queue, push] = createQueue();
const passthrough = createPassThrough(push);
passthrough(porgram1(), program2(), program3());
const render = renderer();
render(queue);
```
## createStack(...initial) ⇒ [PushPair](#PushPair)
create a stack iterator
**Kind**: global function
**Returns**: [PushPair](#PushPair) - stack and push function
| Param | Type | Description |
| --- | --- | --- |
| ...initial | \* | initial items on stack |
**Example**
```js
import {createStack, renderer, renderer as createPassThrough} from "async-endpoint";
import porgram1, program1, program3 from "....js";
const [stack, push] = createStack();
const passthrough = createPassThrough(push);
passthrough(porgram1(), program2(), program3());
const render = renderer();
render(stack);
```
## createProgramQueue() ⇒ [PushPair](#PushPair)
identity program that outputs what ever is input
Like "queue", but accepts program as input
**Kind**: global function
**Returns**: [PushPair](#PushPair) - iterator and push function
**Example**
```js
import {createProgramQueue, renderer} from "async-endpoint";
import porgram1, program1, program3 from "....js";
const [queue, push] = createProgramQueue();
push(porgram1(), program2(), program3());
const render = renderer();
render(queue);
```
## createProgramStack() ⇒ [PushPair](#PushPair)
identity program that outputs what ever is input
Like "queue", but accepts program as input
**Kind**: global function
**Returns**: [PushPair](#PushPair) - iterator and push function
**Example**
```js
import {createProgramStack, renderer} from "async-endpoint";
import porgram1, program1, program3 from "....js";
const [stack, push] = createProgramStack();
push(porgram1(), program2(), program3());
const render = renderer();
render(stack);
```
## take(iterator, num, [skip]) ⇒ Promise.<Array>
extract items from iterator as array
**Kind**: global function
**Returns**: Promise.<Array> - stack and push function
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| iterator | AsynchronousIterator | | iterator from which to take |
| num | Number | | number of items to take from iterator |
| [skip] | Number | 0 | number of items to skip before taking |
**Example**
```js
import {take, continuousOutput} from "async-endpoint";
let i = 0;
take(continuousOutput(()=>i++), 3,1).then(taken=>console.log(taken));
//logs "[1,2,3]"
```
## takeWhile(iterator, accept, [skip]) ⇒ Promise.<Array>
extract first set of items that match a given condition as an array
**Kind**: global function
**Returns**: Promise.<Array> - stack and push function
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| iterator | AsynchronousIterator | | iterator from which to take |
| accept | function | | boolean filtering function indicating whether to allow item |
| [skip] | Number | 0 | number of items to skip before taking |
**Example**
```js
import {takeWhile, continuousOutput} from "async-endpoint";
let i = 0;
takeWhile(continuousOutput(()=>i++), x => x < 5, 2).then(taken=>console.log(taken));
//logs "[2,3,4]"
```
## identity([delay], request) ⇒ AsynchronousIterator
program that outputs what ever is put throught
**Kind**: global function
**Returns**: AsynchronousIterator - resulting iterator
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| [delay] | \* | 0 | delay between sending output |
| request | [PairedRequest](#PairedRequest) | | request function for input |
**Example**
```js
import {identity, renderer, AsyncArray} from "async-endpoint";
const channel = new AsyncArray();
const respond = channel.push.bind(channel),
request = async () => (await channel.next()).value;
identity(undefined, request);
window.respond = respond
```
## continuousOutput([sample]) ⇒ AsynchronousIterator
program that takes no input and contiuously outputs result of calling function
**Kind**: global function
**Returns**: AsynchronousIterator - resulting iterator
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| [sample] | \* | ()=>{} | function whose result to output |
**Example**
```js
import {continuousOutput, renderer} from "async-endpoint";
const render = renderer();
render(continuousOutput(()=>"hello"))
logs "hello" (continously)
...
```
## renderer([...targets]) ⇒ [AsyncRenderFunction](#AsyncRenderFunction)
creates a render function that renders yeilded results from programs
to any number of target functions. If no targets are given, objects will be rendered
using "console.log"
Can be used as a "passthrough" (see "createQueue" example)
**Kind**: global function
**Returns**: [AsyncRenderFunction](#AsyncRenderFunction) - asychronous render function
| Param | Type | Description |
| --- | --- | --- |
| [...targets] | function | request function for input |
**Example**
```js
import {renderer, continuousOutput} from "async-input.js";
const render = renderer();
render(continuousOutput);
//logs "0"
//logs "1"
...
```
## tee(...programs) ⇒ [AsyncRenderFunction](#AsyncRenderFunction)
creates a render function whos's values are teed on to given
It may be advantageous to use this along side a programQueue
**Kind**: global function
**Returns**: [AsyncRenderFunction](#AsyncRenderFunction) - asychronous render function
| Param | Type | Description |
| --- | --- | --- |
| ...programs | [Program](#Program) | programs to be sent values |
**Example**
```js
import {tee, continousOutput, renderer} from "async-endpoint";
import porgram1, program1, program3 from "....js";
const instance1 = program1();
const instance2 = program2();
const instance3 = program3();
const render = renderer();
render(instance1, instance2, instance3)
const renderTee = tee(porgram1, program1, program3)
renderTee(continousOutput())
```
## inputConsole(respond)
send input typed into console to a PairedRespond function
**Kind**: global function
| Param | Type | Description |
| --- | --- | --- |
| respond | [PairedRespond](#PairedRespond) | request function for input |
**Example**
```js
import {identity, AsyncArray, renderer} from "async-endpoint";
import inputConsole from "async-endpoint/input/console";
const channel = new AsyncArray();
const respond = channel.push.bind(channel),
request = async () => (await channel.next()).value;
const render = renderer();
render(identity(undefined, request))
inputConsole(respond);
```
## inputPipe(respond)
send input piped to console to a PairedRespond function
**Kind**: global function
| Param | Type | Description |
| --- | --- | --- |
| respond | [PairedRespond](#PairedRespond) | request function for input |
**Example**
```js
import {identity, renderer, AsyncArray} from "async-endpoint";
import inputPipe from "async-endpoint/input/pipe";
const channel = new AsyncArray();
const respond = channel.push.bind(channel),
request = async () => (await channel.next()).value;
const render = renderer();
render(identity(undefined, request))
inputPipe(respond);
```
## PairedRequest ⇒ Promise.<\*>
a function that receives it's response from a paired PairedRespond function
**Kind**: global typedef
**Returns**: Promise.<\*> - response from respond reunction
## PairedRespond : function
a function that sends it's input to a paired PairedRequest function
**Kind**: global typedef
| Param | Type | Description |
| --- | --- | --- |
| response | \* | response for request function |
## AsyncTransformer ⇒ \*
stateless asynchronous function that transforms input without side effects
**Kind**: global typedef
**Returns**: \* - transformed input
| Param | Type | Description |
| --- | --- | --- |
| input | \* | input |
## Program ⇒ AsynchronousIterator
an iteractive program
**Kind**: global typedef
**Returns**: AsynchronousIterator - asynchronous iterator result
| Param | Type | Description |
| --- | --- | --- |
| init | \* | |
| request | [PairedRequest](#PairedRequest) | request function for input |
## AsyncRenderFunction : function
a function that renders values from a given [Asynchronous] Iterator
**Kind**: global typedef
| Param | Type |
| --- | --- |
| program_return; | AsynchronousIterator |
## ~~PushPair : Array~~
***Deprecated***
an iterator and a paired function to add to it
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| 0 | AsynchornousIterator | iterator |
| 1 | function | function used to add to iterator |