const animate = function (getCurrent, destination, amount, increment, doFinish, rate) {
    let finished = false;

    const finish = function (v) {
      finished = true;
      doFinish(v);
    };

    Delay.clearInterval(interval);

    const abort = function (v) {
      Delay.clearInterval(interval);
      finish(v);
    };

    interval = Delay.setInterval(function () {
      const value = getCurrent();
      adjust(value, destination, amount).fold(function () {
        Delay.clearInterval(interval);
        finish(destination);
      }, function (s) {
        increment(s, abort);
        if (! finished) {
          const newValue = getCurrent();
          // Jump to the end if the increment is no longer working.
          if (newValue !== s || Math.abs(newValue - destination) > Math.abs(value - destination)) {
            Delay.clearInterval(interval);
            finish(destination);
          }
        }
      });
    }, rate);
  };

  suite.test('clearTimeout', function () {
    let id;

    id = Delay.setInterval(function () {
      throw new Error('clearInterval didn\'t work.');
    });

    Delay.clearInterval(id);
    ok(true, 'clearInterval works.');
  });

const startStoreDraft = (editor: Editor, started: Cell<boolean>) => {
  const interval = Settings.getAutoSaveInterval(editor);

  if (!started.get()) {
    Delay.setInterval(() => {
      if (!editor.removed) {
        storeDraft(editor);
      }
    }, interval);

    started.set(true);
  }
};

const onOrientationReady = function (outerWindow, refreshView) {
  // When rotating into portrait, the page (and toolbar) is off the top of the screen (pageYOffset > 0)
  // when the view settles, the toolbar will readjust to be visible/fixed to the top (pageYOffset = 0)
  // wait for the toolbar to recover before refreshing the view and scrolling cursor into view
  // done here instead of nomad toolbar fixup since that is tied to window scroll, which does not
  // fire on landscape
  const scrollNotZero = Delay.setInterval(function () {
    if (outerWindow.pageYOffset === 0) {
      Delay.clearInterval(scrollNotZero);
      refreshView();
    }
  }, 100);
};

 init: (e) => new Promise((resolve) => {
   const intervalId = Delay.setInterval(() => {
     if (resolveInit.get()) {
       Delay.clearInterval(intervalId);
       Class.add(Element.fromDom(e), 'my-custom-editor');
       resolve({
         setValue(s) { customEditorValue.set(s); },
         getValue() { return customEditorValue.get(); },
         destroy() {}
       });
     }
   }, 500);
 })

 return new Promise((resolve, reject) => {
   let numRetries = 3;
   const interval = Delay.setInterval(() => {
     if (hasLoaded()) {
       Delay.clearInterval(interval);
       resolve(true);
     } else {
       numRetries--;
       if (numRetries < 0) {
         console.log('Could not load emojis from url: ' + databaseUrl);
         Delay.clearInterval(interval);
         reject(false);
       }
     }
   }, 500);
 });

  const onAdjustment = function (f) {
    // If a developer is spamming orientation events in the simulator, clear our last check
    Delay.clearInterval(poller);

    const flag = outerWindow.innerHeight;
    let insurance = 0;
    poller = Delay.setInterval(function () {
      if (flag !== outerWindow.innerHeight) {
        Delay.clearInterval(poller);
        f(Option.some(outerWindow.innerHeight));
      } else if (insurance > INSURANCE) {
        Delay.clearInterval(poller);
        f(Option.none());
      }
      insurance++;
    }, INTERVAL);
  };

function handleWindowResize() {
  if (!Env.desktop) {
    let lastSize = {
      w: window.innerWidth,
      h: window.innerHeight
    };

    Delay.setInterval(function () {
      const w = window.innerWidth,
        h = window.innerHeight;

      if (lastSize.w !== w || lastSize.h !== h) {
        lastSize = {
          w,
          h
        };

        DomQuery(window).trigger('resize');
      }
    }, 100);
  }

  function reposition() {
    let i;
    const rect = DomUtils.getWindowSize();
    let layoutRect;

    for (i = 0; i < windows.length; i++) {
      layoutRect = windows[i].layoutRect();

      windows[i].moveTo(
        windows[i].settings.x || Math.max(0, rect.w / 2 - layoutRect.w / 2),
        windows[i].settings.y || Math.max(0, rect.h / 2 - layoutRect.h / 2)
      );
    }
  }

  DomQuery(window).on('resize', reposition);
}