@genkit-ai/core/lib/async.mjs

Genkit AI framework core libraries.

function createTask() {
  let resolve, reject;
  const promise = new Promise(
    (res, rej) => [resolve, reject] = [res, rej]
  );
  return {
    resolve,
    reject,
    promise
  };
}
const DONE = /* @__PURE__ */ Symbol("channel-done");
class Channel {
  ready = createTask();
  buffer = [];
  err = null;
  done = false;
  send(value) {
    this.buffer.push(value);
    this.ready.resolve();
  }
  close() {
    this.buffer.push(DONE);
    this.ready.resolve();
  }
  error(err) {
    this.err = err;
    this.ready.reject(err);
  }
  [Symbol.asyncIterator]() {
    return {
      next: async () => {
        if (this.done) {
          return { value: void 0, done: true };
        }
        if (this.err) {
          throw this.err;
        }
        if (!this.buffer.length) {
          await this.ready.promise;
        }
        const value = this.buffer.shift();
        if (!this.buffer.length) {
          this.ready = createTask();
        }
        if (value === DONE) {
          this.done = true;
          return {
            value: void 0,
            done: true
          };
        }
        return {
          value,
          done: false
        };
      }
    };
  }
}
class LazyPromise {
  executor;
  promise;
  constructor(executor) {
    this.executor = executor;
  }
  then(onfulfilled, onrejected) {
    this.promise ??= new Promise(this.executor);
    return this.promise.then(onfulfilled, onrejected);
  }
}
function lazy(fn) {
  return new LazyPromise((resolve, reject) => {
    try {
      resolve(fn());
    } catch (e) {
      reject(e);
    }
  });
}
class AsyncTaskQueue {
  last = Promise.resolve();
  options;
  constructor(options) {
    this.options = options || {};
  }
  /**
   * Adds a task to the queue.
   * The task will be executed when its turn comes up in the queue.
   * @param task A function that returns a value or a PromiseLike.
   */
  enqueue(task) {
    if (this.options.stopOnError) {
      this.last = this.last.then(() => lazy(task)).then((res) => res);
    } else {
      this.last = this.last.catch(() => {
      }).then(() => lazy(task)).then((res) => res);
    }
    this.last.catch(() => {
    });
  }
  /**
   * Waits for all tasks currently in the queue to complete.
   */
  async merge() {
    await this.last;
  }
}
class EventEmitter {
  listeners = {};
  on(event, listener) {
    if (!this.listeners[event]) {
      this.listeners[event] = [];
    }
    this.listeners[event].push(listener);
  }
  off(event, listener) {
    if (!this.listeners[event]) return;
    this.listeners[event] = this.listeners[event].filter((l) => l !== listener);
  }
  emit(event, ...args) {
    if (!this.listeners[event]) return;
    this.listeners[event].forEach((l) => l(...args));
  }
}
export {
  AsyncTaskQueue,
  Channel,
  EventEmitter,
  LazyPromise,
  createTask,
  lazy
};
//# sourceMappingURL=async.mjs.map