cbcore-ts/compiledScripts/CBSocketCallbackHolder.js

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

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var CBSocketCallbackHolder_exports = {};
__export(CBSocketCallbackHolder_exports, {
  CBSocketCallbackHolder: () => CBSocketCallbackHolder
});
module.exports = __toCommonJS(CBSocketCallbackHolder_exports);
var import_object_hash = __toESM(require("object-hash"));
var import_uicore_ts = require("../../uicore-ts");
var import_CBSocketClient = require("./CBSocketClient");
class CBSocketCallbackHolder extends import_uicore_ts.UIObject {
  constructor(socketClient, previousCallbackHolder) {
    super();
    this.messageDescriptors = {};
    this.handlers = {};
    this.onetimeHandlers = {};
    this.keysForIdentifiers = {};
    this.isValid = import_uicore_ts.YES;
    this._storeableResponseKeys = [];
    this._storedResponseHashesDictionary = {};
    this._verifiedResponseHashesDictionary = {};
    this._socketClient = socketClient;
    if ((0, import_uicore_ts.IS)(previousCallbackHolder)) {
      this.handlers = previousCallbackHolder.handlers;
      this._verifiedResponseHashesDictionary = previousCallbackHolder._verifiedResponseHashesDictionary;
    }
  }
  triggerDisconnectHandlers() {
    this.messageDescriptors.forEach(function(descriptor, key) {
      if (descriptor.mainResponseReceived) {
        descriptor.completionFunction(import_CBSocketClient.CBSocketClient.disconnectionMessage, import_uicore_ts.nil);
      }
    });
  }
  registerHandler(key, handlerFunction) {
    if (!this.handlers[key]) {
      this.handlers[key] = [];
    }
    this.handlers[key].push(handlerFunction);
  }
  registerOnetimeHandler(key, handlerFunction) {
    if (!this.onetimeHandlers[key]) {
      this.onetimeHandlers[key] = [];
    }
    this.onetimeHandlers[key].push(handlerFunction);
  }
  get storedResponseHashesDictionary() {
    if ((0, import_uicore_ts.IS_NOT)(this._storedResponseHashesDictionary)) {
      this._storedResponseHashesDictionary = JSON.parse(localStorage["CBSocketResponseHashesDictionary"] || "{}");
    }
    return this._storedResponseHashesDictionary;
  }
  storedResponseHashObjectForKey(requestKey, requestDataHash) {
    const localStorageKey = this.keyForRequestKeyAndRequestDataHash(requestKey, requestDataHash);
    const hashObject = this.storedResponseHashesDictionary[localStorageKey];
    const result = (0, import_uicore_ts.FIRST)(hashObject, {});
    return result;
  }
  storedResponseForKey(requestKey, requestDataHash) {
    const localStorageKey = this.keyForRequestKeyAndRequestDataHash(requestKey, requestDataHash);
    const storedObject = JSON.parse(localStorage[localStorageKey] || "{}");
    return storedObject.responseMessageData;
  }
  keyForRequestKeyAndRequestDataHash(requestKey, requestDataHash) {
    const result = "_CBSCH_LS_key_" + requestKey + "_" + requestDataHash;
    return result;
  }
  storeResponse(requestKey, requestDataHash, responseMessage, responseDataHash) {
    if (!responseMessage.canBeStoredAsResponse || (0, import_uicore_ts.IS_NOT)(responseMessage.messageData) && (0, import_uicore_ts.IS_NOT)(responseMessage.messageDataHash)) {
      return;
    }
    const localStorageKey = this.keyForRequestKeyAndRequestDataHash(requestKey, requestDataHash);
    var validityDate;
    if (responseMessage.responseValidityDuration) {
      validityDate = Date.now() + responseMessage.responseValidityDuration;
    }
    const storedResponseHashesDictionary = this.storedResponseHashesDictionary;
    storedResponseHashesDictionary[localStorageKey] = {
      hash: responseDataHash,
      validityDate
    };
    this.saveInLocalStorage(localStorageKey, {
      responseMessageData: responseMessage.messageData,
      responseHash: responseDataHash
    });
    this.saveStoredResponseHashesDictionary(storedResponseHashesDictionary);
  }
  saveStoredResponseHashesDictionary(storedResponseHashesDictionary) {
    this.saveInLocalStorage("CBSocketResponseHashesDictionary", storedResponseHashesDictionary);
  }
  saveInLocalStorage(key, object) {
    const stringToSave = JSON.stringify(object);
    if (stringToSave != localStorage[key]) {
      localStorage[key] = stringToSave;
    }
  }
  socketShouldSendMessage(key, message, completionPolicy, completionFunction) {
    var result = import_uicore_ts.YES;
    var triggerStoredResponseImmediately = import_uicore_ts.NO;
    const messageDataHash = (0, import_object_hash.default)(message.messageData || import_uicore_ts.nil);
    const descriptorKey = "socketMessageDescriptor_" + key + messageDataHash;
    this.messageDescriptors[descriptorKey] = this.messageDescriptors[descriptorKey] || [];
    const hashObject = this.storedResponseHashObjectForKey(key, messageDataHash);
    message.storedResponseHash = hashObject.hash;
    if (completionPolicy == import_CBSocketClient.CBSocketClient.completionPolicy.first) {
      const descriptorsForKey = this.messageDescriptors[descriptorKey] || [];
      const matchingDescriptor = descriptorsForKey.find(function(descriptor, index, array) {
        return descriptor.messageDataHash == messageDataHash;
      });
      if (matchingDescriptor) {
        result = import_uicore_ts.NO;
      }
    }
    if (completionPolicy == import_CBSocketClient.CBSocketClient.completionPolicy.storedOrFirst) {
      const descriptorsForKey = this.messageDescriptors[descriptorKey] || [];
      const matchingDescriptor = descriptorsForKey.find(function(descriptor, index, array) {
        return descriptor.messageDataHash == messageDataHash;
      });
      const storedResponse = (0, import_uicore_ts.IS)(message.storedResponseHash);
      if (matchingDescriptor || storedResponse && this._verifiedResponseHashesDictionary[message.storedResponseHash]) {
        result = import_uicore_ts.NO;
        triggerStoredResponseImmediately = import_uicore_ts.YES;
      }
    }
    if (completionPolicy == import_CBSocketClient.CBSocketClient.completionPolicy.firstOnly) {
      const descriptorsForKey = this.messageDescriptors[descriptorKey] || [];
      const matchingDescriptor = descriptorsForKey.find(function(descriptor, index, array) {
        return descriptor.messageDataHash == messageDataHash;
      });
      if (matchingDescriptor) {
        return import_uicore_ts.NO;
      }
    }
    if (hashObject && hashObject.hash && hashObject.validityDate && message.storedResponseHash && this._verifiedResponseHashesDictionary[message.storedResponseHash] && hashObject.validityDate > Date.now()) {
      result = import_uicore_ts.NO;
      triggerStoredResponseImmediately = import_uicore_ts.YES;
    }
    if ((0, import_uicore_ts.IS)(completionFunction)) {
      this.messageDescriptors[descriptorKey].push({
        key,
        message: {
          identifier: message.identifier,
          inResponseToIdentifier: message.inResponseToIdentifier,
          keepWaitingForResponses: message.keepWaitingForResponses
        },
        sentAtTime: Date.now(),
        //completionTriggered: NO,
        messageDataHash,
        mainResponseReceived: import_uicore_ts.NO,
        anyMainResponseReceived: import_uicore_ts.NO,
        completionPolicy,
        completionFunction
      });
      this.keysForIdentifiers[message.identifier] = descriptorKey;
    }
    if (triggerStoredResponseImmediately) {
      this.socketDidReceiveMessageForKey(
        import_CBSocketClient.CBSocketClient.responseMessageKey,
        {
          identifier: import_uicore_ts.nil,
          messageData: import_uicore_ts.nil,
          completionPolicy: import_CBSocketClient.CBSocketClient.completionPolicy.directOnly,
          inResponseToIdentifier: message.identifier,
          useStoredResponse: import_uicore_ts.YES
        },
        import_uicore_ts.nil
      );
    }
    return result;
  }
  static defaultMultipleMessagecompletionFunction(responseMessages, callcompletionFunctions) {
    callcompletionFunctions();
  }
  socketWillSendMultipleMessage(messageToSend, completionFunction = CBSocketCallbackHolder.defaultMultipleMessagecompletionFunction) {
    const key = import_CBSocketClient.CBSocketClient.multipleMessageKey;
    const messageDataHash = (0, import_object_hash.default)(messageToSend.messageData || import_uicore_ts.nil);
    const descriptorKey = "socketMessageDescriptor_" + key + messageDataHash;
    this.messageDescriptors[descriptorKey] = this.messageDescriptors[descriptorKey] || [];
    messageToSend.storedResponseHash = this.storedResponseHashObjectForKey(key, messageDataHash).hash;
    this.messageDescriptors[descriptorKey].push({
      key,
      message: {
        identifier: messageToSend.identifier,
        inResponseToIdentifier: messageToSend.inResponseToIdentifier,
        keepWaitingForResponses: messageToSend.keepWaitingForResponses
      },
      sentAtTime: Date.now(),
      //completionTriggered: NO,
      messageDataHash,
      mainResponseReceived: import_uicore_ts.NO,
      anyMainResponseReceived: import_uicore_ts.NO,
      completionPolicy: import_CBSocketClient.CBSocketClient.completionPolicy.directOnly,
      completionFunction: function(responseMessage, respondWithMessage) {
        completionFunction(
          responseMessage.map(function(messageObject, index, array) {
            return messageObject.message.messageData;
          }),
          function() {
            responseMessage.forEach(function(messageObject, index, array) {
              this._socketClient.didReceiveMessageForKey(messageObject.key, messageObject.message);
            }.bind(this));
          }.bind(this)
        );
      }.bind(this)
    });
    this.keysForIdentifiers[messageToSend.identifier] = descriptorKey;
  }
  socketDidReceiveMessageForKey(key, message, sendResponseFunction) {
    if (!this.isValid) {
      return;
    }
    if (this.handlers[key]) {
      this.handlers[key].forEach(function(handler, index, array) {
        handler(message.messageData, sendResponseFunction);
      }.bind(this));
    }
    if (this.onetimeHandlers[key]) {
      this.onetimeHandlers[key].forEach(function(handler) {
        handler(message.messageData, sendResponseFunction);
      }.bind(this));
      delete this.onetimeHandlers[key];
    }
    if (message.inResponseToIdentifier && (import_CBSocketClient.CBSocketClient.responseMessageKey == key || import_CBSocketClient.CBSocketClient.multipleMessageKey == key)) {
      const descriptorKey = this.keysForIdentifiers[message.inResponseToIdentifier];
      const descriptorsForKey = this.messageDescriptors[descriptorKey] || [];
      const responseDataHash = message.messageDataHash;
      if (!message.keepWaitingForResponses) {
        delete this.keysForIdentifiers[message.inResponseToIdentifier];
        delete this.messageDescriptors[descriptorKey];
      }
      const callCompletionFunction = (descriptor, storedResponseCondition = import_uicore_ts.NO) => {
        var messageData = message.messageData;
        if (message.useStoredResponse && storedResponseCondition) {
          messageData = this.storedResponseForKey(descriptor.key, descriptor.messageDataHash);
          const responseHash = this.storedResponseHashObjectForKey(
            descriptor.key,
            descriptor.messageDataHash
          ).hash;
          const localStorageKey = this.keyForRequestKeyAndRequestDataHash(
            descriptor.key,
            descriptor.messageDataHash
          );
          if (message.responseValidityDuration && this.storedResponseHashesDictionary[localStorageKey]) {
            this.storedResponseHashesDictionary[localStorageKey].validityDate = Date.now() + message.responseValidityDuration;
            this.saveStoredResponseHashesDictionary(this.storedResponseHashesDictionary);
          }
          this._verifiedResponseHashesDictionary[responseHash] = import_uicore_ts.YES;
          console.log("Using stored response.");
        }
        descriptor.completionFunction(messageData, sendResponseFunction);
        descriptor.responseDataHash = responseDataHash;
      };
      descriptorsForKey.copy().forEach(function(descriptor, index, array) {
        if (descriptor.completionPolicy == import_CBSocketClient.CBSocketClient.completionPolicy.directOnly && descriptor.message.identifier == message.inResponseToIdentifier || descriptor.completionPolicy == import_CBSocketClient.CBSocketClient.completionPolicy.first || descriptor.completionPolicy == import_CBSocketClient.CBSocketClient.completionPolicy.firstOnly || descriptor.completionPolicy == import_CBSocketClient.CBSocketClient.completionPolicy.storedOrFirst) {
          if (!message.keepWaitingForResponses) {
            this.storeResponse(descriptor.key, descriptor.messageDataHash, message, responseDataHash);
            descriptorsForKey.removeElement(descriptor);
            sendResponseFunction.respondingToMainResponse = import_uicore_ts.YES;
          }
          callCompletionFunction(descriptor, !message.keepWaitingForResponses);
        } else if (descriptor.completionPolicy == import_CBSocketClient.CBSocketClient.completionPolicy.all) {
          callCompletionFunction(descriptor, !message.keepWaitingForResponses);
          if (!message.keepWaitingForResponses) {
            if (message.inResponseToIdentifier == descriptor.message.identifier) {
              sendResponseFunction.respondingToMainResponse = import_uicore_ts.YES;
              descriptor.mainResponseReceived = import_uicore_ts.YES;
              descriptorsForKey.removeElement(descriptor);
            }
            descriptor.anyMainResponseReceived = import_uicore_ts.YES;
          }
        } else if (descriptor.completionPolicy == import_CBSocketClient.CBSocketClient.completionPolicy.allDifferent) {
          if (descriptor.responseDataHash != responseDataHash) {
            callCompletionFunction(descriptor, !message.keepWaitingForResponses);
          }
          if (!message.keepWaitingForResponses) {
            if (message.inResponseToIdentifier == descriptor.message.identifier) {
              sendResponseFunction.respondingToMainResponse = import_uicore_ts.YES;
              descriptor.mainResponseReceived = import_uicore_ts.YES;
              descriptorsForKey.removeElement(descriptor);
            }
            descriptor.anyMainResponseReceived = import_uicore_ts.YES;
          }
        } else if (descriptor.completionPolicy == import_CBSocketClient.CBSocketClient.completionPolicy.last && descriptor.message.identifier == message.inResponseToIdentifier) {
          if (!message.keepWaitingForResponses) {
            descriptor.mainResponseReceived = import_uicore_ts.YES;
            descriptor.anyMainResponseReceived = import_uicore_ts.YES;
            sendResponseFunction.respondingToMainResponse = import_uicore_ts.YES;
          } else {
            descriptor.completionFunction(message.messageData, sendResponseFunction);
          }
        } else if (descriptor.completionPolicy == import_CBSocketClient.CBSocketClient.completionPolicy.firstAndLast || descriptor.completionPolicy == import_CBSocketClient.CBSocketClient.completionPolicy.firstAndLastIfDifferent) {
          if (!message.keepWaitingForResponses) {
            if (!descriptor.anyMainResponseReceived) {
              callCompletionFunction(descriptor, !message.keepWaitingForResponses);
            }
            if (descriptor.message.identifier == message.inResponseToIdentifier) {
              descriptor.mainResponseReceived = import_uicore_ts.YES;
              sendResponseFunction.respondingToMainResponse = import_uicore_ts.YES;
            }
            descriptor.anyMainResponseReceived = import_uicore_ts.YES;
          } else if (descriptor.message.identifier == message.inResponseToIdentifier && message.keepWaitingForResponses) {
            descriptor.completionFunction(message.messageData, sendResponseFunction);
          }
        }
      }.bind(this));
      const allResponsesReceived = descriptorsForKey.allMatch(function(descriptorObject, index, array) {
        return descriptorObject.mainResponseReceived;
      });
      descriptorsForKey.copy().forEach(function(descriptor, index, array) {
        if ((descriptor.completionPolicy == import_CBSocketClient.CBSocketClient.completionPolicy.last || descriptor.completionPolicy == import_CBSocketClient.CBSocketClient.completionPolicy.firstAndLast) && allResponsesReceived && !message.keepWaitingForResponses) {
          callCompletionFunction(descriptor, !message.keepWaitingForResponses);
          descriptorsForKey.removeElement(descriptor);
        } else if (descriptor.completionPolicy == import_CBSocketClient.CBSocketClient.completionPolicy.firstAndLastIfDifferent && allResponsesReceived && !message.keepWaitingForResponses) {
          if (descriptor.responseDataHash != responseDataHash) {
            callCompletionFunction(descriptor, !message.keepWaitingForResponses);
          }
          descriptorsForKey.removeElement(descriptor);
        }
      }.bind(this));
    }
  }
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  CBSocketCallbackHolder
});
//# sourceMappingURL=CBSocketCallbackHolder.js.map