function _rawCallbackContext()

in src/Runtime/CallbackContext.ts [60:129]
56 lines of code
8 McCabe index (conditional complexity)

function _rawCallbackContext(
  client: IRuntimeClient,
  id: string,
  scheduleNext: () => void
): [CallbackFunction, ICallbackContext] {
  const postError = (err: ErrorStringOrUndefined, callback: () => void) => {
    const homogeneousError = _homogeneousError(err);
    console.error("Invoke Error", Errors.toFormatted(homogeneousError));
    client.postInvocationError(err, id, callback);
  };

  const complete = (result: unknown, callback: () => void) => {
    client.postInvocationResponse(result, id, callback);
  };

  let waitForEmptyEventLoop = true;

  const callback = (
    err: ErrorStringOrUndefinedOrNull,
    result: unknown
  ): void => {
    BeforeExitListener.reset();
    if (err !== undefined && err !== null) {
      postError(err, scheduleNext);
    } else {
      complete(result, () => {
        if (!waitForEmptyEventLoop) {
          scheduleNext();
        } else {
          BeforeExitListener.set(scheduleNext);
        }
      });
    }
  };

  const done = (err: ErrorStringOrUndefinedOrNull, result?: unknown) => {
    BeforeExitListener.reset();
    if (err !== undefined && err !== null) {
      postError(err, scheduleNext);
    } else {
      complete(result, scheduleNext);
    }
  };

  const succeed = (result: unknown) => {
    done(null, result);
  };

  const fail = (err: ErrorStringOrUndefinedOrNull) => {
    if (err === undefined || err === null) {
      done("handled");
    } else {
      done(err);
    }
  };

  const callbackContext = {
    get callbackWaitsForEmptyEventLoop(): boolean {
      return waitForEmptyEventLoop;
    },
    set callbackWaitsForEmptyEventLoop(value: boolean) {
      waitForEmptyEventLoop = value;
    },
    succeed,
    fail,
    done,
  };

  return [callback, callbackContext];
}