A clean timeout implementation using promises + bonus track: waitUntil

await-timeout.js

import createDeferred from "./createDeferred";

const awaitTimeout = (miliseconds, onTimeout) => {
  const deferred = createDeferred();

  const timeoutId = setTimeout(
    () => onTimeout(deferred.resolve, deferred.reject),
    miliseconds
  );

  const createClearer = resolver => value => {
    clearTimeout(timeoutId);

    resolver(value);
  };

  return {
    promise: deferred.promise,
    reject: createClearer(deferred.reject),
    resolve: createClearer(deferred.resolve),
  };
};

export default awaitTimeout;

createDeferred.js

const createDeferred = () => {
  const deferred = {};

  deferred.promise = new Promise((resolve, reject) => {
    deferred.resolve = resolve;
    deferred.reject = reject;
  });

  return deferred;
};

export default createDeferred;

example.js

import awaitTimeout from "./waitUntil";
import waitUntil from "./waitUntil";

const getUserStub = id => awaitTimeout(5000, resolve => resolve({
  id,
  name: "John Doe",
});

waitUntil(2000, getUserStub(10)); // it will timeout rejecting promise with Error("Timeout with 2000 ms")

wait-until.js

import awaitTimeout from "./await-timeout";

const waitUntil = (miliseconds, promise) => {
  const timeout = awaitTimeout(
    miliseconds,
    (_, reject) => new Error("Timeout with " + miliseconds + " ms"); // gist doesn't support template literals :| 
  );
  
  promise.then(timeout.resolve, timeout.resolve);
  
  return Promise.race([
    promise,
    timeout,
  ]);
};

export default waitUntil;