TypeScript Delay.setEditorTimeout函數代碼示例

const startTimedUpload = function (editor, imageUploadTimerState) {
  const imageUploadTimer = Delay.setEditorTimeout(editor, function () {
    editor.editorUpload.uploadImagesAuto();
  }, editor.settings.images_upload_timeout || 30000);

  imageUploadTimerState.set(imageUploadTimer);
};

 editor.on('keypress', function (e: EditorEvent<KeyboardEvent>) {
   if (KeyHandler.checkCharCode(charCodes, e)) {
     Delay.setEditorTimeout(editor, function () {
       KeyHandler.handleInlineKey(editor, patternsState.get());
     });
   }
 });

const startTimedUpload = function (editor: Editor, imageUploadTimerState) {
  const imageUploadTimer = Delay.setEditorTimeout(editor, function () {
    editor.editorUpload.uploadImagesAuto();
  }, Settings.getUploadTimeout(editor));

  imageUploadTimerState.set(imageUploadTimer);
};

  editor.on('paste', function (e) {
    // Getting content from the Clipboard can take some time
    const clipboardTimer = new Date().getTime();
    const clipboardContent = getClipboardContent(editor, e);
    const clipboardDelay = new Date().getTime() - clipboardTimer;

    const isKeyBoardPaste = (new Date().getTime() - keyboardPasteTimeStamp - clipboardDelay) < 1000;
    const plainTextMode = pasteFormat.get() === 'text' || keyboardPastePlainTextState;
    let internal = hasContentType(clipboardContent, InternalHtml.internalHtmlMime());

    // Reset ephemeral flags
    pasteFormat.set(undefined);
    keyboardPastePlainTextState = false;

    if (e.isDefaultPrevented() || isBrokenAndroidClipboardEvent(e)) {
      pasteBin.remove();
      return;
    }

    if (!hasHtmlOrText(clipboardContent) && pasteImageData(editor, e, getLastRng())) {
      pasteBin.remove();
      return;
    }

    // Not a keyboard paste prevent default paste and try to grab the clipboard contents using different APIs
    if (!isKeyBoardPaste) {
      e.preventDefault();
    }

    // Try IE only method if paste isn't a keyboard paste
    if (Env.ie && (!isKeyBoardPaste || e.ieFake) && !hasContentType(clipboardContent, 'text/html')) {
      pasteBin.create();

      editor.dom.bind(pasteBin.getEl(), 'paste', function (e) {
        e.stopPropagation();
      });

      editor.getDoc().execCommand('Paste', false, null);
      clipboardContent['text/html'] = pasteBin.getHtml();
    }

    // If clipboard API has HTML then use that directly
    if (hasContentType(clipboardContent, 'text/html')) {
      e.preventDefault();

      // if clipboard lacks internal mime type, inspect html for internal markings
      if (!internal) {
        internal = InternalHtml.isMarked(clipboardContent['text/html']);
      }

      insertClipboardContent(clipboardContent, isKeyBoardPaste, plainTextMode, internal);
    } else {
      // Since we never use the pastebin on Red Sweater branch, we want to prevent the default in both cases
      // to avoid a double-paste behavior.
      e.preventDefault();
      Delay.setEditorTimeout(editor, function () {
        insertClipboardContent(clipboardContent, isKeyBoardPaste, plainTextMode, internal);
      }, 0);
    }
  });

  suite.asyncTest('setEditorTimeout', function (_, done) {
    const fakeEditor = {};

    Delay.setEditorTimeout(fakeEditor, function () {
      ok(true, 'setEditorTimeout was executed.');
      done();
    });
  });

 editor.on('focusout', (e) => {
   Delay.setEditorTimeout(editor, () => {
     if (Focus.search(sink.element()).isNone() && Focus.search(contextbar.element()).isNone()) {
       lastAnchor.set(Option.none());
       InlineView.hide(contextbar);
     }
   }, 0);
 });

const delayedConfirm = function (editor: Editor, message: string, callback: (state: boolean) => void) {
  const rng = editor.selection.getRng();

  Delay.setEditorTimeout(editor, function () {
    editor.windowManager.confirm(message, function (state) {
      editor.selection.setRng(rng);
      callback(state);
    });
  });
};

 editor.on('ProgressState', (e) => {
   timer.get().each(Delay.clearTimeout);
   if (Type.isNumber(e.time)) {
     const timerId = Delay.setEditorTimeout(editor, () => toggle(e.state), e.time);
     timer.set(Option.some(timerId));
   } else {
     toggle(e.state);
     timer.set(Option.none());
   }
 });

const wait = (editor: Editor, oldSize: Cell<number>, times: number, interval: number, callback?: Function) => {
  Delay.setEditorTimeout(editor, () => {
    resize(editor, oldSize);

    if (times--) {
      wait(editor, oldSize, times, interval, callback);
    } else if (callback) {
      callback();
    }
  }, interval);
};