cbcore-ts/compiledScripts/CBSocketClient.js

CBCore is a library to build web applications using pure Typescript.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var CBSocketClient_exports = {};
__export(CBSocketClient_exports, {
  CBSocketClient: () => CBSocketClient,
  IS_NOT_SOCKET_ERROR: () => IS_NOT_SOCKET_ERROR,
  IS_SOCKET_ERROR: () => IS_SOCKET_ERROR,
  SocketClient: () => SocketClient
});
module.exports = __toCommonJS(CBSocketClient_exports);
var import_socket = require("socket.io-client");
var import_uicore_ts = require("../../uicore-ts");
var import_CBCore = require("./CBCore");
var import_CBSocketCallbackHolder = require("./CBSocketCallbackHolder");
function IS_SOCKET_ERROR(object) {
  const result = (0, import_uicore_ts.IS)(object) && object._isCBSocketErrorMessage;
  return result;
}
function IS_NOT_SOCKET_ERROR(object) {
  return !IS_SOCKET_ERROR(object);
}
const _CBSocketClient = class _CBSocketClient extends import_uicore_ts.UIObject {
  constructor(core) {
    super();
    this._socket = (0, import_socket.io)();
    this._isConnectionEstablished = import_uicore_ts.NO;
    this._collectMessagesToSendLater = import_uicore_ts.NO;
    this._messagesToBeSent = [];
    this._subscribedKeys = {};
    this._callbackHolder = new import_CBSocketCallbackHolder.CBSocketCallbackHolder(this);
    this._core = core;
    this.socket.on("connect", () => {
      var _a, _b;
      console.log("Socket.io connected to server. clientID = ", this.socket, " socketID = ", this.socket);
      const isInstanceIdentifierAllowed = localStorage.getItem("IsInstanceIdentifierAllowed") == "true";
      let instanceIdentifier = (0, import_uicore_ts.IF)(isInstanceIdentifierAllowed)(
        () => localStorage.getItem("InstanceIdentifier")
      ).ELSE(
        () => ""
      );
      if ((0, import_uicore_ts.IS_NOT)(instanceIdentifier) && isInstanceIdentifierAllowed) {
        instanceIdentifier = (0, import_uicore_ts.MAKE_ID)();
        localStorage.setItem("InstanceIdentifier", instanceIdentifier);
      }
      const handshakeMessage = {
        accessToken: (_a = localStorage.getItem("CBUserAccessToken")) != null ? _a : void 0,
        userID: (_b = this._core.userProfile) == null ? void 0 : _b._id,
        inquiryAccessKey: void 0,
        instanceIdentifier
      };
      this.socket.emit("CBSocketHandshakeInitMessage", {
        identifier: (0, import_uicore_ts.MAKE_ID)(),
        messageData: handshakeMessage
      });
    });
    this.socket.on(
      "CBSocketHandshakeResponseMessage",
      (message) => {
        var _a;
        this._isConnectionEstablished = message.messageData.accepted;
        if (!message.messageData.accepted) {
          console.log("SocketIO connection failed.");
          this._core.dialogViewShowerClass.alert(
            "Failed to establish connection to server.",
            () => {
            }
          );
        } else {
          console.log("SocketIO connection handshake completed.");
          this._callbackHolder = new import_CBSocketCallbackHolder.CBSocketCallbackHolder(this, this._callbackHolder);
          core.userProfile = (_a = message.messageData.userProfile) != null ? _a : {};
          this.sendUnsentMessages();
        }
      }
    );
    this.socket.on("disconnect", () => {
      console.log("Socket.io disconnected from server. clientID = ", this.socket);
      this._isConnectionEstablished = import_uicore_ts.NO;
      this._callbackHolder.isValid = import_uicore_ts.NO;
      this._callbackHolder.triggerDisconnectHandlers();
    });
    this.socket.on("CBPerformReconnect", (message) => {
      console.log("Performing socket reconnection.");
      core.reloadSocketConnection();
      if (message) {
        this._core.dialogViewShowerClass.alert(message);
      }
    });
    this._socket.on(
      _CBSocketClient.responseMessageKey,
      (message) => {
        this.didReceiveMessageForKey(_CBSocketClient.responseMessageKey, message);
      }
    );
    this._socket.on(
      _CBSocketClient.multipleMessageKey,
      (message) => {
        console.log("Received " + message.messageData.length + " messages.");
        this.didReceiveMessageForKey(_CBSocketClient.multipleMessageKey, message);
      }
    );
  }
  get socket() {
    return this._socket;
  }
  cancelUnsentMessages(messagesToCancel) {
    this._messagesToBeSent = this._messagesToBeSent.filter((messageObject, index, array) => !messagesToCancel.contains(messageObject));
  }
  sendUnsentMessages(receiveResponsesTogether = import_uicore_ts.NO, completion) {
    if (!this._isConnectionEstablished || this._collectMessagesToSendLater) {
      return;
    }
    const groupedMessages = [];
    const didSendFunctions = [];
    this._messagesToBeSent.copy().forEach((messageToBeSentObject) => {
      if (this._isConnectionEstablished) {
        var message = messageToBeSentObject.message;
        if ((0, import_uicore_ts.IS_NOT)(message)) {
          message = "";
        }
        const identifier = (0, import_uicore_ts.MAKE_ID)();
        const completion2 = messageToBeSentObject.completion;
        const messageObject2 = {
          messageData: message,
          identifier,
          keepWaitingForResponses: messageToBeSentObject.keepWaitingForResponses,
          inResponseToIdentifier: messageToBeSentObject.inResponseToMessage.identifier,
          completionPolicy: messageToBeSentObject.completionPolicy
        };
        const shouldSendMessage = this._callbackHolder.socketShouldSendMessage(
          messageToBeSentObject.key,
          messageObject2,
          messageToBeSentObject.completionPolicy,
          completion2
        );
        if (shouldSendMessage) {
          groupedMessages.push({
            key: messageToBeSentObject.key,
            message: messageObject2
          });
        }
        didSendFunctions.push(messageToBeSentObject.didSendFunction);
      }
    });
    this._messagesToBeSent = [];
    if ((0, import_uicore_ts.IS_NOT)(groupedMessages.length)) {
      return;
    }
    if (groupedMessages.length == 1) {
      console.log("sending 1 unsent message.");
    } else {
      console.log("Sending " + groupedMessages.length + " unsent messages.");
    }
    const messageObject = {
      messageData: groupedMessages,
      identifier: (0, import_uicore_ts.MAKE_ID)(),
      completionPolicy: _CBSocketClient.completionPolicy.all,
      shouldGroupResponses: receiveResponsesTogether
    };
    this._callbackHolder.socketWillSendMultipleMessage(messageObject, completion);
    this.socket.emit(_CBSocketClient.multipleMessageKey, messageObject);
    didSendFunctions.forEach((didSendFunction, index, array) => {
      didSendFunction();
    });
  }
  sendUserBoundMessageForKeyWithPolicy(key, message, completionPolicy, completion) {
    this._sendMessageForKey(key, message, void 0, import_uicore_ts.NO, completionPolicy, import_uicore_ts.YES, import_uicore_ts.nil, completion);
  }
  sendUserBoundMessageForKey(key, message, completion) {
    this._sendMessageForKey(key, message, void 0, import_uicore_ts.NO, void 0, import_uicore_ts.YES, import_uicore_ts.nil, completion);
  }
  sendMessageForKeyWithPolicy(key, message, completionPolicy, completion) {
    this._sendMessageForKey(key, message, void 0, import_uicore_ts.NO, completionPolicy, import_uicore_ts.NO, import_uicore_ts.nil, completion);
  }
  sendMessageForKey(key, message, completion) {
    this._sendMessageForKey(key, message, void 0, import_uicore_ts.NO, void 0, import_uicore_ts.NO, import_uicore_ts.nil, completion);
  }
  resultForMessageForKey(key, message, completionPolicy, isUserBound = import_uicore_ts.NO) {
    const result = new Promise((resolve, reject) => {
      this._sendMessageForKey(
        key,
        message,
        void 0,
        import_uicore_ts.NO,
        completionPolicy,
        isUserBound,
        import_uicore_ts.nil,
        (responseMessage, respondWithMessage) => resolve({
          responseMessage,
          result: (0, import_uicore_ts.IF)(IS_NOT_SOCKET_ERROR(responseMessage))(() => responseMessage).ELSE((0, import_uicore_ts.RETURNER)(void 0)),
          errorResult: (0, import_uicore_ts.IF)(IS_SOCKET_ERROR(responseMessage))(() => responseMessage).ELSE((0, import_uicore_ts.RETURNER)(void 0)),
          respondWithMessage
        })
      );
    });
    return result;
  }
  _sendMessageForKey(key, message, inResponseToMessage = {}, keepMessageConnectionOpen = import_uicore_ts.NO, completionPolicy = _CBSocketClient.completionPolicy.directOnly, isUserBound = import_uicore_ts.NO, didSendFunction = import_uicore_ts.nil, completion = import_uicore_ts.nil) {
    if ((0, import_uicore_ts.IS_NIL)(message)) {
      message = "";
    }
    if (this._isConnectionEstablished && !this._collectMessagesToSendLater) {
      const identifier = (0, import_uicore_ts.MAKE_ID)();
      const messageObject = {
        messageData: message,
        identifier,
        keepWaitingForResponses: keepMessageConnectionOpen,
        inResponseToIdentifier: inResponseToMessage.identifier,
        completionPolicy
      };
      const shouldSendMessage = this._callbackHolder.socketShouldSendMessage(
        key,
        messageObject,
        completionPolicy,
        completion
      );
      if (shouldSendMessage) {
        this.socket.emit(key, messageObject);
      }
      didSendFunction();
    } else {
      this._messagesToBeSent.push({
        key,
        message,
        inResponseToMessage,
        keepWaitingForResponses: keepMessageConnectionOpen,
        completionPolicy,
        isBoundToUserWithID: (0, import_uicore_ts.IF)(isUserBound)((0, import_uicore_ts.RETURNER)((0, import_uicore_ts.FIRST_OR_NIL)(import_CBCore.CBCore.sharedInstance.userProfile._id)))(),
        didSendFunction,
        completion
      });
      return this._messagesToBeSent.lastElement;
    }
  }
  sendMessagesAsGroup(functionToCall) {
    const collectMessagesToSendLater = this._collectMessagesToSendLater;
    this._collectMessagesToSendLater = import_uicore_ts.YES;
    var result = functionToCall();
    this._collectMessagesToSendLater = collectMessagesToSendLater;
    this.sendUnsentMessages();
    return result;
  }
  sendAndReceiveMessagesAsGroup(functionToCall, completion) {
    const collectMessagesToSendLater = this._collectMessagesToSendLater;
    this._collectMessagesToSendLater = import_uicore_ts.YES;
    var result = functionToCall();
    this._collectMessagesToSendLater = collectMessagesToSendLater;
    this.sendUnsentMessages(import_uicore_ts.YES, completion);
    return result;
  }
  didReceiveMessageForKey(key, message) {
    const sendResponseFunction = function(responseMessage, completion) {
      this._sendMessageForKey(
        _CBSocketClient.responseMessageKey,
        responseMessage,
        message,
        import_uicore_ts.NO,
        void 0,
        import_uicore_ts.NO,
        import_uicore_ts.nil,
        completion
      );
    }.bind(this);
    sendResponseFunction.sendIntermediateResponse = function(updateMessage, completion) {
      this._sendMessageForKey(
        _CBSocketClient.responseMessageKey,
        updateMessage,
        message,
        import_uicore_ts.YES,
        void 0,
        import_uicore_ts.NO,
        import_uicore_ts.nil,
        completion
      );
    }.bind(this);
    const sendUserBoundResponseFunction = function(responseMessage, completion) {
      this._sendMessageForKey(
        _CBSocketClient.responseMessageKey,
        responseMessage,
        message,
        import_uicore_ts.NO,
        void 0,
        import_uicore_ts.YES,
        import_uicore_ts.nil,
        completion
      );
    }.bind(this);
    sendUserBoundResponseFunction.sendIntermediateResponse = function(updateMessage, completion) {
      this._sendMessageForKey(
        _CBSocketClient.responseMessageKey,
        updateMessage,
        message,
        import_uicore_ts.YES,
        void 0,
        import_uicore_ts.YES,
        import_uicore_ts.nil,
        completion
      );
    }.bind(this);
    if (IS_SOCKET_ERROR(message.messageData)) {
      console.log("CBSocketClient did receive error message.");
      console.log(message.messageData);
    }
    this._callbackHolder.socketDidReceiveMessageForKey(key, message, sendResponseFunction);
  }
  addTargetForMessagesForKeys(keys, handlerFunction) {
    keys.forEach(function(key, index, array) {
      this.addTargetForMessagesForKey(key, handlerFunction);
    }.bind(this));
  }
  addTargetForMessagesForKey(key, handlerFunction) {
    this._callbackHolder.registerHandler(key, handlerFunction);
    if ((0, import_uicore_ts.IS_NOT)(this._subscribedKeys[key])) {
      this._socket.on(key, function(message) {
        this.didReceiveMessageForKey(key, message);
      }.bind(this));
      this._subscribedKeys[key] = true;
    }
  }
  addTargetForOneMessageForKey(key, handlerFunction) {
    this._callbackHolder.registerOnetimeHandler(key, handlerFunction);
    if ((0, import_uicore_ts.IS_NOT)(this._subscribedKeys[key])) {
      this._socket.on(key, function(message) {
        this.didReceiveMessageForKey(key, message);
      }.bind(this));
      this._subscribedKeys[key] = true;
    }
  }
};
_CBSocketClient.responseMessageKey = "CBSocketResponseMessage";
_CBSocketClient.multipleMessageKey = "CBSocketMultipleMessage";
_CBSocketClient.disconnectionMessage = {
  _isCBSocketErrorMessage: import_uicore_ts.YES,
  messageData: "Server disconnected"
};
_CBSocketClient.completionPolicy = {
  "all": "all",
  "allDifferent": "allDifferent",
  "first": "first",
  "last": "last",
  "firstAndLast": "firstAndLast",
  "firstAndLastIfDifferent": "firstAndLastIfDifferent",
  "directOnly": "directOnly",
  "firstOnly": "firstOnly",
  "storedOrFirst": "storedOrFirst"
};
let CBSocketClient = _CBSocketClient;
const SocketClient = new Proxy({ "name": "SocketClient" }, {
  get(target, key) {
    const result = (messageData, completionPolicy, isUserBound) => import_CBCore.CBCore.sharedInstance.socketClient.resultForMessageForKey(
      key,
      messageData,
      completionPolicy,
      isUserBound
    );
    return result;
  }
});
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  CBSocketClient,
  IS_NOT_SOCKET_ERROR,
  IS_SOCKET_ERROR,
  SocketClient
});
//# sourceMappingURL=CBSocketClient.js.map