import * as http from "http";
import * as fs from "fs";
import { CancellationTokenSource, CancellationToken } from "prex";
 
function downloadFile(from: string, to: string, token = CancellationToken.none) {
    return new Promise<void>((resolve, reject) => {
        const request = http.get(from);
 
        // abort the request if canceled.
        const registration = token.register(() => {
            request.abort();
            reject(new Error("Operation canceled."));
        });
 
        request.on("error", err => {
            registration.unregister();
            reject(err);
        });
 
        request.on("response", (response: http.IncomingMessage) => {
            response
                .pipe(fs.createWriteStream(to))
                .on("error", err => {
                    registration.unregister();
                    reject(err);
                })
                .on("end", () => {
                    registration.unregister();
                    resolve();
                });
        });
    });
}
 
async function main() {
    const source = new CancellationTokenSource();
 
    // cancel the source if the file takes more than one second to download
    setTimeout(1000, () => source.cancel());
 
    await downloadFile("http://tempuri.org/some/file", "file", source.token);
}

import { Semaphore } from "prex";
 
const criticalResource = new Semaphore(1);
 
async function updateCriticalLocalResource() {
    // Acquire a lock on the critical resource
    await criticalResource.wait();
 
    // Make local changes...
 
    // await a network resources
    await postUpdateToNetworkResource(changes);
 
    // release the lock
    criticalResource.release();
}
 
async function deleteCriticalLocalResource() {
    // Acquire a lock on the critical resource
    await criticalResource.wait();
 
    // Make local changes...
 
    // await a network resources
    await postUpdateToNetworkResource(changes);
 
    // release the lock
    criticalResource.release();
}
 
declare function postUpdateToNetworkResource(changes): Promise<void>;

import { Barrier } from "prex";
 
const barrier = new Barrier(/*participantCount*/ 3);
 
async function processNpcAI() {
    while (true) {
        // process AI activities...
        await barrier.signalAndWait();
    }
}
 
async function processGameRules() {
    while (true) {
        // process game rules
        await barrier.signalAndWait();
    }
}
 
async function processGameInput() {
    while (true) {
        // process user input
        await barrier.signalAndWait();
    }
}
 

import { AsyncQueue } from "prex";
 
const workItems = new AsyncQueue();
 
function queueUserWorkItem(action: () => void) {
    workItems.put(action);
}
 
async function processWorkItems() {
    while (true) {
        const action = await workItems.get();
        try {
            action();
        }
        catch (e) {
            console.error(e);
        }
    }
}