@webex/webex-core 3.12.0-webex-services-ready.1 → 3.12.0-webex-services-ready.2

package/dist/lib/services-v2/services-v2.js

@@ -60,8 +60,10 @@ var Services = _webexPlugin.default.extend({
   },
   session: {
     /**
-     * Becomes `true` once services initialization has completed.
-     * This blocks `webex.ready` until services are initialized.
+     * Becomes `true` once the initial catalog collection has completed
+     * (successfully or otherwise) and any in-flight credentials refresh has
+     * settled. Blocks `webex.ready` so consumers can rely on `webex.ready`
+     * implying "catalogs populated AND credential state stable".
      * @instance
      * @memberof Services
      * @type {boolean}
@@ -1362,7 +1364,6 @@ var Services = _webexPlugin.default.extend({
             });
           case 1:
             _this12.ready = true;
-            _this12.trigger('services:initialized');
           case 2:
           case "end":
             return _context3.stop();
@@ -1382,34 +1383,116 @@ var Services = _webexPlugin.default.extend({
     var catalog = new _serviceCatalog.default();
     this._catalogs.set(this.webex, catalog);
 
-    // Listen for configuration changes once.
+    // Listen for configuration changes once. The config is not populated on the
+    // webex instance until the `change:config` event fires, so any decision that
+    // depends on config values (such as the gated-vs-ungated init below) must be
+    // made from within this handler rather than synchronously in `initialize()`.
     this.listenToOnce(this.webex, 'change:config', function () {
+      var _this13$webex$config, _this13$webex$config$;
       _this13.initConfig();
-    });
 
-    // Wait for storage to be loaded before attempting to update the service catalogs.
-    // We listen for 'loaded' instead of 'ready' because services.ready is a dependency
-    // of webex.ready - listening to 'ready' would cause a deadlock.
-    this.listenToOnce(this.webex, 'loaded', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4() {
-      var warmed, supertoken, timeout, email;
+      // Feature flag: when enabled, `webex.ready` is blocked until the initial
+      // catalog collection has settled AND any in-flight credentials refresh has
+      // completed. When disabled (the default), preserves the pre-existing
+      // behavior where `webex.ready` fires as soon as `webex.loaded` does and
+      // the catalog is collected out-of-band.
+      var waitForCatalogInit = ((_this13$webex$config = _this13.webex.config) === null || _this13$webex$config === void 0 ? void 0 : (_this13$webex$config$ = _this13$webex$config.services) === null || _this13$webex$config$ === void 0 ? void 0 : _this13$webex$config$.waitForCatalogInit) === true;
+      if (waitForCatalogInit) {
+        _this13._initializeCatalogsGated(catalog);
+      } else {
+        // Not gating - immediately mark ready so we do not block webex.ready.
+        _this13.ready = true;
+        _this13._initializeCatalogsUngated(catalog);
+      }
+    });
+  },
+  /**
+   * Original (pre-verified-ready) initialization path. Runs on `webex.ready`
+   * and collects catalogs opportunistically without blocking anything.
+   *
+   * @private
+   * @param {ServiceCatalog} catalog
+   * @returns {void}
+   */
+  _initializeCatalogsUngated: function _initializeCatalogsUngated(catalog) {
+    var _this14 = this;
+    // wait for webex instance to be ready before attempting
+    // to update the service catalogs
+    this.listenToOnce(this.webex, 'ready', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4() {
+      var warmed, supertoken, email;
       return _regenerator.default.wrap(function (_context4) {
         while (1) switch (_context4.prev = _context4.next) {
           case 0:
             _context4.next = 1;
-            return _this13._loadCatalogFromCache();
+            return _this14._loadCatalogFromCache();
           case 1:
             warmed = _context4.sent;
             if (!warmed) {
-              _context4.next = 3;
+              _context4.next = 2;
               break;
             }
             catalog.isReady = true;
-            _context4.next = 2;
-            return _this13._finalizeReady();
-          case 2:
             return _context4.abrupt("return");
+          case 2:
+            supertoken = _this14.webex.credentials.supertoken; // Validate if the supertoken exists.
+            if (supertoken && supertoken.access_token) {
+              _this14.initServiceCatalogs().then(function () {
+                catalog.isReady = true;
+              }).catch(function (error) {
+                _this14.initFailed = true;
+                _this14.logger.error("services: failed to init initial services when credentials available, ".concat(error === null || error === void 0 ? void 0 : error.message));
+              });
+            } else {
+              email = _this14.webex.config.email;
+              _this14.collectPreauthCatalog(email ? {
+                email: email
+              } : undefined).catch(function (error) {
+                _this14.initFailed = true;
+                _this14.logger.error("services: failed to init initial services when no credentials available, ".concat(error === null || error === void 0 ? void 0 : error.message));
+              });
+            }
+          case 3:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    })));
+  },
+  /**
+   * Verified-ready initialization path. Blocks `webex.ready` until the initial
+   * catalog fetch has settled (or timed out) AND any in-flight credentials
+   * refresh has completed. Also handles the fresh-login case where OAuth
+   * completes after `loaded` fires.
+   *
+   * @private
+   * @param {ServiceCatalog} catalog
+   * @returns {void}
+   */
+  _initializeCatalogsGated: function _initializeCatalogsGated(catalog) {
+    var _this15 = this;
+    // Wait for storage to be loaded before attempting to update the service
+    // catalogs. We listen for 'loaded' instead of 'ready' because `services.ready`
+    // now blocks `webex.ready` - listening to 'ready' would deadlock.
+    this.listenToOnce(this.webex, 'loaded', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5() {
+      var warmed, supertoken, timeout, email;
+      return _regenerator.default.wrap(function (_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            _context5.next = 1;
+            return _this15._loadCatalogFromCache();
+          case 1:
+            warmed = _context5.sent;
+            if (!warmed) {
+              _context5.next = 3;
+              break;
+            }
+            catalog.isReady = true;
+            _context5.next = 2;
+            return _this15._finalizeReady();
+          case 2:
+            return _context5.abrupt("return");
           case 3:
-            supertoken = _this13.webex.credentials.supertoken; // Race init against a hard timeout so a hung request never leaves
+            supertoken = _this15.webex.credentials.supertoken; // Race init against a hard timeout so a hung request never leaves
             // `services.ready` false forever - that would stall `webex.ready` and
             // leave the app on a permanent spinner.
             timeout = new _promise.default(function (_, reject) {
@@ -1418,44 +1501,43 @@ var Services = _webexPlugin.default.extend({
               }, SERVICES_INIT_TIMEOUT_MS);
             }); // Validate if the supertoken exists.
             if (supertoken && supertoken.access_token) {
-              _promise.default.race([_this13.initServiceCatalogs(), timeout]).then(function () {
+              _promise.default.race([_this15.initServiceCatalogs(), timeout]).then(function () {
                 catalog.isReady = true;
               }).catch(function (error) {
-                _this13.initFailed = true;
-                _this13.logger.error("services: failed to init initial services when credentials available, ".concat(error === null || error === void 0 ? void 0 : error.message));
+                _this15.initFailed = true;
+                _this15.logger.error("services: failed to init initial services when credentials available, ".concat(error === null || error === void 0 ? void 0 : error.message));
               }).finally(function () {
-                return _this13._finalizeReady();
+                return _this15._finalizeReady();
               });
             } else {
-              email = _this13.webex.config.email;
-              _promise.default.race([_this13.collectPreauthCatalog(email ? {
+              email = _this15.webex.config.email;
+              _promise.default.race([_this15.collectPreauthCatalog(email ? {
                 email: email
               } : undefined), timeout]).catch(function (error) {
-                _this13.initFailed = true;
-                _this13.logger.error("services: failed to init initial services when no credentials available, ".concat(error === null || error === void 0 ? void 0 : error.message));
+                _this15.initFailed = true;
+                _this15.logger.error("services: failed to init initial services when no credentials available, ".concat(error === null || error === void 0 ? void 0 : error.message));
               }).finally(function () {
-                return _this13._finalizeReady();
+                return _this15._finalizeReady();
               });
-              // Listen for when credentials become available to fetch the full catalog.
-              // This handles fresh login where 'loaded' fires before OAuth completes.
-              _this13.listenToOnce(_this13.webex, 'change:canAuthorize', function () {
-                if (_this13.webex.canAuthorize && !catalog.status.postauth.ready) {
-                  _this13.initServiceCatalogs().then(function () {
-                    catalog.isReady = true;
-                  }).catch(function (error) {
-                    _this13.logger.error("services: failed to init service catalogs after auth, ".concat(error === null || error === void 0 ? void 0 : error.message));
+
+              // Handle fresh login: 'loaded' fires before OAuth completes, so listen
+              // for `canAuthorize` flipping true and then collect the postauth catalog.
+              _this15.listenToOnce(_this15.webex, 'change:canAuthorize', function () {
+                if (_this15.webex.canAuthorize && !catalog.status.postauth.ready) {
+                  _this15.initServiceCatalogs().catch(function (error) {
+                    _this15.logger.error("services: failed to init service catalogs after auth, ".concat(error === null || error === void 0 ? void 0 : error.message));
                   });
                 }
               });
             }
           case 4:
           case "end":
-            return _context4.stop();
+            return _context5.stop();
         }
-      }, _callee4);
+      }, _callee5);
     })));
   },
-  version: "3.12.0-webex-services-ready.1"
+  version: "3.12.0-webex-services-ready.2"
 });
 /* eslint-enable no-underscore-dangle */
 var _default = exports.default = Services;