如何等到询问者问题被回答后才能运行下一个功能

如何解决如何等到询问者问题被回答后才能运行下一个功能

我在JavaScript中使用查询器。我的想法是使用从中间件next函数启发而来的责任链模式在其上放置一层，以便使提示问题动态且可依赖于状态（或更旧的答案）。 我的代码提供了一个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,next) => {
  observer.next({
    type: "input",name: "inputName",message: "input something",});
  console.log(state);
});

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

我尝试过的想法： 我尝试使用反跳和事件来处理呼叫，但均未成功。 这主要是由于查询者如何将请求发送到提示，将它们链接到后端而不是使其异步可用。

我考虑过的想法： 我已经考虑过监听状态对象的更改，并且只有在subscription方法内部状态发生更改时才调用下一步。最终得到非常糟糕的代码，该代码仅适用于第一个回调，然后又出错了。