@webex/plugin-meetings 3.12.0-next.20 → 3.12.0-next.22

package/dist/interpretation/index.js

@@ -372,7 +372,7 @@ var SimultaneousInterpretation = _webexCore.WebexPlugin.extend({
       throw error;
     });
   },
-  version: "3.12.0-next.20"
+  version: "3.12.0-next.22"
 });
 var _default = exports.default = SimultaneousInterpretation;
 //# sourceMappingURL=index.js.map

package/dist/interpretation/siLanguage.js

@@ -18,7 +18,7 @@ var SILanguage = _webexCore.WebexPlugin.extend({
     languageCode: 'number',
     languageName: 'string'
   },
-  version: "3.12.0-next.20"
+  version: "3.12.0-next.22"
 });
 var _default = exports.default = SILanguage;
 //# sourceMappingURL=siLanguage.js.map

package/dist/locus-info/index.js

@@ -53,7 +53,7 @@ var _hashTreeParser2 = _interopRequireWildcard(require("../hashTree/hashTreePars
 var _types = require("../hashTree/types");
 var _utils = require("../hashTree/utils");
 var _util = _interopRequireDefault(require("../meetings/util"));
-function _interopRequireWildcard(e, t) { if ("function" == typeof _WeakMap) var r = new _WeakMap(), n = new _WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = _Object$defineProperty) && _Object$getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
+function _interopRequireWildcard(e, t) { if ("function" == typeof _WeakMap) var r = new _WeakMap(), n = new _WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t3 in e) "default" !== _t3 && {}.hasOwnProperty.call(e, _t3) && ((i = (o = _Object$defineProperty) && _Object$getOwnPropertyDescriptor(e, _t3)) && (i.get || i.set) ? o(f, _t3, i) : f[_t3] = e[_t3]); return f; })(e, t); }
 function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? _Reflect$construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
 function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 function ownKeys(e, r) { var t = _Object$keys2(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
@@ -676,7 +676,19 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
       var isWrapped = 'locus' in responseBody;
       var locusUrl = isWrapped ? (_responseBody$locus = responseBody.locus) === null || _responseBody$locus === void 0 ? void 0 : _responseBody$locus.url : responseBody.url;
       var hashTreeParserEntry = locusUrl && this.hashTreeParsers.get(locusUrl);
-      if (hashTreeParserEntry) {
+      var locus = isWrapped ? responseBody.locus : responseBody;
+      if (this.hashTreeParsers.size > 0) {
+        // We are in hash tree mode. Check if we need to create/reactivate a parser for this locusUrl.
+        if (!hashTreeParserEntry || hashTreeParserEntry.parser.state === 'stopped') {
+          if (!locusUrl) {
+            _loggerProxy.default.logger.warn('Locus-info:index#handleLocusAPIResponse --> API response has no locusUrl, cannot handle hash tree parser switch');
+            return;
+          }
+          this.handleHashTreeParserSwitchForAPIResponse(locusUrl, locus);
+          return;
+        }
+
+        // Active parser found - pass the API response to it
         if (isWrapped) {
           if (!responseBody.dataSets) {
             this.sendClassicVsHashTreeMismatchMetric(meeting, "expected hash tree dataSets in API response but they are missing");
@@ -686,19 +698,21 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
           // update the data in our hash trees
           hashTreeParserEntry.parser.handleLocusUpdate(responseBody);
         } else {
-          // LocusDTO without wrapper - pass it through as if it had no dataSets
+          // LocusDTO without wrapper - pass it through as if it had no dataSets nor metadata
           hashTreeParserEntry.parser.handleLocusUpdate({
             locus: responseBody
           });
         }
-      } else {
-        if (isWrapped && responseBody.dataSets) {
-          this.sendClassicVsHashTreeMismatchMetric(meeting, "unexpected hash tree dataSets in API response");
-        }
-        // classic Locus delta
-        var locus = isWrapped ? responseBody.locus : responseBody;
-        this.handleLocusDelta(locus, meeting);
+        return;
       }
+
+      // No hash tree parsers - classic Locus mode
+      if (isWrapped && responseBody.dataSets) {
+        this.sendClassicVsHashTreeMismatchMetric(meeting, "unexpected hash tree dataSets in API response");
+      }
+
+      // classic Locus delta
+      this.handleLocusDelta(locus, meeting);
     }
 
     /**
@@ -881,6 +895,81 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
       }
     }
 
+    /**
+     * Helper that handles the common logic for reactivating a stopped HashTreeParser when
+     * a newer "replaces" is detected. Used by both the message and API response parser switch methods.
+     *
+     * @param {string} callerName - name of the calling method, used in log messages
+     * @param {string} locusUrl - the locus URL of the stopped parser
+     * @param {HashTreeParserEntry} stoppedEntry - the stopped parser entry
+     * @param {ReplacesInfo} replaces - replacement info extracted from self
+     * @param {Function} resumeCallback - callback to invoke after reactivation to resume the parser
+     * @returns {void}
+     */
+  }, {
+    key: "resumeStoppedParser",
+    value: function resumeStoppedParser(callerName, locusUrl, stoppedEntry, replaces, resumeCallback) {
+      // this check is just for typescript, it should never happen, replaces should always be defined
+      if (!replaces) {
+        _loggerProxy.default.logger.info("Locus-info:index#".concat(callerName, " --> received data for stopped HashTreeParser with locusUrl ").concat(locusUrl, ", but no replaces info provided, so not re-activating the parser"));
+        return;
+      }
+      if (replaces.replacedAt <= (stoppedEntry.replacedAt || '')) {
+        _loggerProxy.default.logger.info("Locus-info:index#".concat(callerName, " --> received data for stopped HashTreeParser with locusUrl ").concat(locusUrl, ", but replaces info provided is not newer, so not re-activating the parser"));
+        return;
+      }
+      _loggerProxy.default.logger.info("Locus-info:index#".concat(callerName, " --> reactivating HashTreeParser for locusUrl=").concat(locusUrl, ", which replaces ").concat(replaces.locusUrl));
+      var replacedEntry = this.hashTreeParsers.get(replaces.locusUrl);
+      if (replacedEntry) {
+        replacedEntry.replacedAt = replaces.replacedAt;
+        replacedEntry.parser.stop();
+      } else {
+        _loggerProxy.default.logger.warn("Locus-info:index#".concat(callerName, " --> the parser that is supposed to be replaced with the currently reactivated parser is not found, locusUrl=").concat(replaces.locusUrl));
+      }
+      stoppedEntry.initializedFromHashTree = false;
+      this.hashTreeObjectId2ParticipantId.clear();
+      resumeCallback();
+    }
+
+    /**
+     * Handles an API response whose locusUrl doesn't match any active HashTreeParser
+     * (either no entry exists, or the existing entry is stopped).
+     * Creates a new parser or reactivates a stopped one using initializeFromGetLociResponse.
+     *
+     * @param {string} locusUrl - the locus URL from the API response
+     * @param {LocusDTO} locus - the locus DTO from the API response
+     * @returns {void}
+     */
+  }, {
+    key: "handleHashTreeParserSwitchForAPIResponse",
+    value: function handleHashTreeParserSwitchForAPIResponse(locusUrl, locus) {
+      var entry = this.hashTreeParsers.get(locusUrl);
+      var replaces = getReplaceInfoFromSelf(locus.self,
+      // @ts-ignore
+      this.webex.internal.device.url);
+      if (!entry) {
+        _loggerProxy.default.logger.info("Locus-info:index#handleHashTreeParserSwitchForAPIResponse --> no parser for locusUrl ".concat(locusUrl, ", creating a new one"));
+        var parser = this.createHashTreeParser({
+          locusUrl: locusUrl,
+          initialLocus: {
+            locus: null,
+            dataSets: []
+          },
+          metadata: null,
+          replacedAt: replaces === null || replaces === void 0 ? void 0 : replaces.replacedAt
+        });
+        parser.initializeFromGetLociResponse(locus);
+        return;
+      }
+      if (entry.parser.state !== 'stopped') {
+        _loggerProxy.default.logger.warn("Locus-info:index#handleHashTreeParserSwitchForAPIResponse --> unexpected parser state \"".concat(entry.parser.state, "\" for locusUrl ").concat(locusUrl));
+        return;
+      }
+      this.resumeStoppedParser('handleHashTreeParserSwitchForAPIResponse', locusUrl, entry, replaces, function () {
+        return entry.parser.resumeFromApiResponse(locus);
+      });
+    }
+
     /**
      * Checks if the hash tree message should trigger a switch to a different HashTreeParser
      *
@@ -928,25 +1017,9 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
       if (entry.parser.state === 'stopped') {
         // the message matches a stopped parser, we need to check if maybe this is a new "replacement" and we need to re-activate the parser
         // this happens when you move from breakout A -> breakout B -> back to breakout A
-        if (replaces) {
-          if (replaces.replacedAt > (entry.replacedAt || '')) {
-            _loggerProxy.default.logger.info("Locus-info:index#handleHashTreeParserSwitch --> resuming a HashTreeParser for locusUrl=".concat(message.locusUrl, ", which replaces ").concat(replaces.locusUrl));
-            var replacedEntry = this.hashTreeParsers.get(replaces.locusUrl);
-            if (replacedEntry) {
-              replacedEntry.replacedAt = replaces.replacedAt;
-              entry.initializedFromHashTree = false;
-              this.hashTreeObjectId2ParticipantId.clear();
-              replacedEntry.parser.stop();
-              entry.parser.resume(message);
-            } else {
-              _loggerProxy.default.logger.warn("Locus-info:index#handleHashTreeParserSwitch --> the parser that is supposed to be replaced with the currently resumed parser is not found, locusUrl=".concat(replaces.locusUrl));
-            }
-          } else {
-            _loggerProxy.default.logger.info("Locus-info:index#handleHashTreeParserSwitch --> received message for stopped HashTreeParser with locusUrl ".concat(message.locusUrl, ", but replaces info provided is not newer, so not re-activating the parser"));
-          }
-          return true;
-        }
-        _loggerProxy.default.logger.info("Locus-info:index#handleHashTreeParserSwitch --> received message for stopped HashTreeParser with locusUrl ".concat(message.locusUrl, ", but no replaces info provided, so not re-activating the parser"));
+        this.resumeStoppedParser('handleHashTreeParserSwitch', message.locusUrl, entry, replaces, function () {
+          return entry.parser.resumeFromMessage(message);
+        });
         return true;
       }
       return false;
@@ -979,6 +1052,60 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
       }
     }
 
+    /**
+     * Triggers a sync of all hash tree datasets for all hash tree parsers associated with this meeting.
+     * The syncs are executed sequentially within each parser.
+     *
+     * @returns {Promise<void>}
+     */
+  }, {
+    key: "syncAllHashTreeDatasets",
+    value: (function () {
+      var _syncAllHashTreeDatasets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2() {
+        var _iterator3, _step3, _step3$value, entry, _t2;
+        return _regenerator.default.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _iterator3 = _createForOfIteratorHelper(this.hashTreeParsers);
+              _context2.prev = 1;
+              _iterator3.s();
+            case 2:
+              if ((_step3 = _iterator3.n()).done) {
+                _context2.next = 4;
+                break;
+              }
+              _step3$value = (0, _slicedToArray2.default)(_step3.value, 2), entry = _step3$value[1];
+              if (!entry.parser) {
+                _context2.next = 3;
+                break;
+              }
+              _context2.next = 3;
+              return entry.parser.syncAllDatasets();
+            case 3:
+              _context2.next = 2;
+              break;
+            case 4:
+              _context2.next = 6;
+              break;
+            case 5:
+              _context2.prev = 5;
+              _t2 = _context2["catch"](1);
+              _iterator3.e(_t2);
+            case 6:
+              _context2.prev = 6;
+              _iterator3.f();
+              return _context2.finish(6);
+            case 7:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[1, 5, 6, 7]]);
+      }));
+      function syncAllHashTreeDatasets() {
+        return _syncAllHashTreeDatasets.apply(this, arguments);
+      }
+      return syncAllHashTreeDatasets;
+    }()
     /**
      * Callback registered with HashTreeParser to receive locus info updates.
      * Updates our locus info based on the data parsed by the hash tree parser.
@@ -987,6 +1114,7 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
      * @param {LocusInfoUpdate} update - Details about the update.
      * @returns {void}
      */
+    )
   }, {
     key: "updateFromHashTree",
     value: function updateFromHashTree(locusUrl, update) {
@@ -1097,7 +1225,13 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
     key: "parse",
     value: function parse(meeting, data) {
       if (this.hashTreeParsers.size > 0) {
-        this.handleHashTreeMessage(meeting, data.eventType, data.stateElementsMessage);
+        if (data.eventType === _constants.LOCUSEVENT.SDK_LOCUS_FROM_SYNC_MEETINGS) {
+          // sync meetings response follows the format of "not wrapped" locus API responses,
+          // so has no dataSets nor Metadata
+          this.handleLocusAPIResponse(meeting, _objectSpread({}, data.locus));
+        } else {
+          this.handleHashTreeMessage(meeting, data.eventType, data.stateElementsMessage);
+        }
       } else {
         var eventType = data.eventType;
         if (eventType === _constants.LOCUSEVENT.HASH_TREE_DATA_UPDATED) {
@@ -1590,11 +1724,11 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
         isReplace: isReplace
       });
       if (participants && (0, _isArray.default)(participants) && participants.length > 0) {
-        var _iterator3 = _createForOfIteratorHelper(participants),
-          _step3;
+        var _iterator4 = _createForOfIteratorHelper(participants),
+          _step4;
         try {
-          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-            var participant = _step3.value;
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var participant = _step4.value;
             if (participant && (participant === null || participant === void 0 ? void 0 : participant.reason) === 'FAILURE') {
               var _participant$person;
               this.emitScoped({
@@ -1606,9 +1740,9 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
             }
           }
         } catch (err) {
-          _iterator3.e(err);
+          _iterator4.e(err);
         } finally {
-          _iterator3.f();
+          _iterator4.f();
         }
       }
     }