Javascript 如何等到问询者的问题得到回答后再运行下一个函数

我正在使用JavaScript中的inquirer。我的想法是，使用从express middleware next function中获得灵感的责任链模式在其上添加一层，以使提示问题在状态（或旧答案）上动态且可靠。 我的代码提供了一个ask函数，它接受一个回调，该回调将观察者、上一个状态和下一个函数作为参数。 我面临的问题是，一旦第一个回调调用next，就直接调用next函数，而不是等待用户首先响应

使用的技术：

• 可观测
• 询问者

下面是我的代码：

const inquirer = require("inquirer");
const { Observable } = require("rxjs");
// const debounce = require("lodash.debounce");

class Prompt {
  constructor() {
    this.observable = null;
    this.observer = null;
    this.state = {};
    this.middlewares = [];
  }

  ask(middleware) {
    const isFunc = typeof middleware === "function";
    // const isObj = typeof middleware === "object";
    if (!isFunc) {
      throw new Error("Midlleware must be a function");
    }
    this.middlewares.push(middleware);
  }

  listen(cb) {
    const handler = (observer) => {
      this.observer = observer;
      this.handle(observer, (err) => {
        if (err) {
          console.log("Error 1", err);
          throw new Error(err);
        }
        observer.complete();
      });
    };
    this.observable = new Observable(handler);
    inquirer.prompt(this.observable).ui.process.subscribe(
      (ans) => {
        console.log("I was called", ans);
        this.state[ans.name] = ans.answer;
      },
      (err) => console.log("Error 2", err),
      cb
    );
  }

  handle(observer, cb) {
    let idx = 0;
    // console.log("this.handle just been called");
    // console.log(
    //   "middlewares length",
    //   this.middlewares.length
    // );
    const next = () =>
      setImmediate((err) => {
        if (err != null) {
          return setImmediate(() => cb(err));
        }
        if (idx >= this.middlewares.length) {
          return setImmediate(() => cb());
        }
        const layer = this.middlewares[idx++];
        setImmediate(async () => {
          try {
            console.log(`called ${idx}`);
            layer(observer, this.state, next);
          } catch (err) {
            next(err);
          }
        });
      });
    next();
  }
}

const prompt = new Prompt();

prompt.ask((observer, state, next) => {
  observer.next({
    type: "confirm",
    name: "confirm",
    message: "confirm please",
  });
  next();
});

prompt.ask((observer, state, next) => {
  observer.next({
    type: "input",
    name: "inputName",
    message: "input something",
  });
  console.log(state);
});

prompt.listen(() => {
  console.log("Everything completed");
});

我尝试过的想法： 我尝试过使用去Bouncing和events来处理呼叫，但没有成功。 这主要是由于inquirer如何将请求发送到提示符，在后端链接请求，但不使其异步性可用

我考虑过的想法： 我考虑过监听state对象的变化，并且只在subscribe方法中的状态发生变化时调用next。最终得到的代码非常糟糕，只在第一次回调时有效，然后再次出错