@atlaskit/collab-provider 8.1.0 → 8.3.0

package/dist/es2019/channel.js

@@ -1,79 +1,88 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import { utils } from '@atlaskit/util-service-support'; // TODO: Validate if this is actually equivalent to the AnalyticsWebClient in @atlassiansox/analytics-web-client
-
+import { utils } from '@atlaskit/util-service-support';
 import { Emitter } from './emitter';
 import { ErrorCodeMapper } from './error-code-mapper';
 import { createLogger, getProduct, getSubProduct } from './helpers/utils';
 import { MEASURE_NAME, startMeasure, stopMeasure } from './analytics/performance';
-import { triggerAnalyticsEvent } from './analytics';
 import { EVENT_ACTION, EVENT_STATUS } from './helpers/const';
-import { ExperiencePerformanceTypes, ExperienceTypes, UFOExperience } from '@atlaskit/ufo';
+import ReconnectHelper from './connectivity/reconnect-helper';
+import { createDocInitExp } from './analytics/ufo';
+import Network from './connectivity/network';
 const logger = createLogger('Channel', 'green');
 export class Channel extends Emitter {
-  constructor(config) {
+  constructor(config, analyticsHelper) {
     super();
-
     _defineProperty(this, "connected", false);
-
     _defineProperty(this, "socket", null);
-
+    _defineProperty(this, "reconnectHelper", null);
     _defineProperty(this, "initialized", false);
-
-    _defineProperty(this, "initExperience", new UFOExperience('collab-provider.document-init', {
-      type: ExperienceTypes.Load,
-      performanceType: ExperiencePerformanceTypes.Custom,
-      performanceConfig: {
-        histogram: {
-          [ExperiencePerformanceTypes.Custom]: {
-            duration: '250_500_1000_1500_2000_3000_4000'
-          }
-        }
-      }
-    }));
-
+    _defineProperty(this, "network", null);
     _defineProperty(this, "getInitialized", () => this.initialized);
-
     _defineProperty(this, "getConnected", () => this.connected);
-
     _defineProperty(this, "getSocket", () => this.socket);
-
+    _defineProperty(this, "onConnectError", error => {
+      var _this$analyticsHelper, _this$analyticsHelper2;
+      const measure = stopMeasure(MEASURE_NAME.SOCKET_CONNECT, this.analyticsHelper);
+      (_this$analyticsHelper = this.analyticsHelper) === null || _this$analyticsHelper === void 0 ? void 0 : _this$analyticsHelper.sendActionEvent(EVENT_ACTION.CONNECTION, EVENT_STATUS.FAILURE, {
+        latency: measure === null || measure === void 0 ? void 0 : measure.duration
+      });
+      (_this$analyticsHelper2 = this.analyticsHelper) === null || _this$analyticsHelper2 === void 0 ? void 0 : _this$analyticsHelper2.sendErrorEvent(error, 'Error while establishing connection');
+      // If error received with `data`, it means the connection is rejected
+      // by the server on purpose for example no permission, so no need to
+      // keep the underneath connection, need to close. But some error like
+      // `xhr polling error` needs to retry.
+      if (!!error.data) {
+        var _this$socket;
+        (_this$socket = this.socket) === null || _this$socket === void 0 ? void 0 : _this$socket.close();
+      }
+      this.emit('error', {
+        message: error.message,
+        data: error.data
+      });
+    });
+    _defineProperty(this, "onReconnectError", error => {
+      var _this$reconnectHelper, _this$reconnectHelper2;
+      (_this$reconnectHelper = this.reconnectHelper) === null || _this$reconnectHelper === void 0 ? void 0 : _this$reconnectHelper.countReconnectError();
+      if ((_this$reconnectHelper2 = this.reconnectHelper) !== null && _this$reconnectHelper2 !== void 0 && _this$reconnectHelper2.isLikelyNetworkIssue()) {
+        var _this$analyticsHelper3;
+        (_this$analyticsHelper3 = this.analyticsHelper) === null || _this$analyticsHelper3 === void 0 ? void 0 : _this$analyticsHelper3.sendErrorEvent(error, 'Likely network issue while reconnecting the channel');
+        this.emit('error', {
+          message: 'Reconnection failed 8 times when browser was offline, likely there was a network issue.',
+          data: {
+            status: 400,
+            code: 'RECONNECTION_NETWORK_ISSUE'
+          }
+        });
+      }
+    });
     _defineProperty(this, "onConnect", () => {
+      var _this$analyticsHelper4;
       this.connected = true;
       logger('Connected.', this.socket.id);
-      const measure = stopMeasure(MEASURE_NAME.SOCKET_CONNECT);
-      triggerAnalyticsEvent({
-        eventAction: EVENT_ACTION.CONNECTION,
-        attributes: {
-          eventStatus: EVENT_STATUS.SUCCESS,
-          latency: measure === null || measure === void 0 ? void 0 : measure.duration,
-          documentAri: this.config.documentAri
-        }
-      }, this.analyticsClient);
+      const measure = stopMeasure(MEASURE_NAME.SOCKET_CONNECT, this.analyticsHelper);
+      (_this$analyticsHelper4 = this.analyticsHelper) === null || _this$analyticsHelper4 === void 0 ? void 0 : _this$analyticsHelper4.sendActionEvent(EVENT_ACTION.CONNECTION, EVENT_STATUS.SUCCESS, {
+        latency: measure === null || measure === void 0 ? void 0 : measure.duration
+      });
       this.emit('connected', {
         sid: this.socket.id,
         initialized: this.initialized
       });
     });
-
     _defineProperty(this, "onReceiveData", data => {
       logger('Received data', data);
       logger('Session ID is', this.socket.id);
-
       if (data.type === 'initial') {
         if (!this.initialized) {
-          const measure = stopMeasure(MEASURE_NAME.DOCUMENT_INIT);
-          this.initExperience.success();
-          triggerAnalyticsEvent({
-            eventAction: EVENT_ACTION.DOCUMENT_INIT,
-            attributes: {
-              eventStatus: EVENT_STATUS.SUCCESS,
-              // TODO: detect when document init fails and fire corresponding event for it
-              latency: measure === null || measure === void 0 ? void 0 : measure.duration,
-              documentAri: this.config.documentAri,
-              requiredPageRecovery: data === null || data === void 0 ? void 0 : data.requiredPageRecovery,
-              ttlEnabled: data === null || data === void 0 ? void 0 : data.ttlEnabled
-            }
-          }, this.analyticsClient);
+          var _this$initExperience, _this$analyticsHelper5;
+          const measure = stopMeasure(MEASURE_NAME.DOCUMENT_INIT, this.analyticsHelper);
+          (_this$initExperience = this.initExperience) === null || _this$initExperience === void 0 ? void 0 : _this$initExperience.success();
+          (_this$analyticsHelper5 = this.analyticsHelper) === null || _this$analyticsHelper5 === void 0 ? void 0 : _this$analyticsHelper5.sendActionEvent(EVENT_ACTION.DOCUMENT_INIT,
+          // TODO: detect when document init fails and fire corresponding event for it
+          EVENT_STATUS.SUCCESS, {
+            latency: measure === null || measure === void 0 ? void 0 : measure.duration,
+            resetReason: data === null || data === void 0 ? void 0 : data.resetReason,
+            ttlEnabled: data === null || data === void 0 ? void 0 : data.ttlEnabled
+          });
           const {
             doc,
             version,
@@ -106,26 +115,31 @@ export class Channel extends Emitter {
         this.emit('steps:added', data);
       }
     });
-
+    _defineProperty(this, "onOnlineHandler", () => {
+      // Force an immediate reconnect, the socket must first be closed to reset reconnection delay logic
+      if (!this.connected) {
+        var _this$socket2, _this$socket3;
+        (_this$socket2 = this.socket) === null || _this$socket2 === void 0 ? void 0 : _this$socket2.close();
+        (_this$socket3 = this.socket) === null || _this$socket3 === void 0 ? void 0 : _this$socket3.connect();
+      }
+    });
     this.config = config;
+    this.analyticsHelper = analyticsHelper;
+    this.initExperience = createDocInitExp(this.analyticsHelper);
+  }
 
-    if (config.analyticsClient) {
-      this.analyticsClient = config.analyticsClient;
-    }
-  } // read-only getters used for tests
-
+  // read-only getters used for tests
 
   /**
    * Connect to collab service using websockets
    */
   connect() {
-    startMeasure(MEASURE_NAME.SOCKET_CONNECT);
-
+    startMeasure(MEASURE_NAME.SOCKET_CONNECT, this.analyticsHelper);
     if (!this.initialized) {
-      startMeasure(MEASURE_NAME.DOCUMENT_INIT);
-      this.initExperience.start();
+      var _this$initExperience2;
+      startMeasure(MEASURE_NAME.DOCUMENT_INIT, this.analyticsHelper);
+      (_this$initExperience2 = this.initExperience) === null || _this$initExperience2 === void 0 ? void 0 : _this$initExperience2.start();
     }
-
     const {
       documentAri,
       url
@@ -137,11 +151,11 @@ export class Channel extends Emitter {
       permissionTokenRefresh
     } = this.config;
     let authCb = null;
-
     if (permissionTokenRefresh) {
       authCb = cb => {
         permissionTokenRefresh().then(token => {
-          cb({ // The permission token.
+          cb({
+            // The permission token.
             ...(token ? {
               token
             } : {}),
@@ -164,11 +178,11 @@ export class Channel extends Emitter {
         });
       };
     }
+    this.socket = createSocket(`${url}/session/${documentAri}`, authCb, this.config.productInfo);
 
-    this.socket = createSocket(`${url}/session/${documentAri}`, authCb, this.config.productInfo); // Due to https://github.com/socketio/socket.io-client/issues/1473,
+    // Due to https://github.com/socketio/socket.io-client/issues/1473,
     // reconnect no longer fired on the socket.
     // We should use `connect` for better cross platform compatibility(Mobile/Web).
-
     this.socket.on('connect', this.onConnect);
     this.socket.on('data', this.onReceiveData);
     this.socket.on('steps:added', data => {
@@ -201,8 +215,9 @@ export class Channel extends Emitter {
     });
     this.socket.on('metadata:changed', payload => {
       this.emit('metadata:changed', payload);
-    }); // ESS-2916 namespace status event - lock/unlock
+    });
 
+    // ESS-2916 namespace status event - lock/unlock
     this.socket.on('status', data => {
       this.emit('status', data);
     });
@@ -212,50 +227,48 @@ export class Channel extends Emitter {
       this.emit('disconnect', {
         reason
       });
-
       if (reason === 'io server disconnect' && this.socket) {
         // The disconnection was initiated by the server, we need to reconnect manually.
-        this.socket.connect();
+        try {
+          this.socket.connect();
+        } catch (error) {
+          var _this$analyticsHelper6;
+          (_this$analyticsHelper6 = this.analyticsHelper) === null || _this$analyticsHelper6 === void 0 ? void 0 : _this$analyticsHelper6.sendErrorEvent(error, 'Error while reconnecting the channel');
+          this.emit('error', {
+            message: 'Caught error during reconnection.',
+            data: {
+              status: 500,
+              code: 'RECONNECTION_ERROR'
+            }
+          });
+        }
       }
-    }); // Socket error, including errors from `packetMiddleware`, `controllers` and `onconnect` and more. Paramter is a plain JSON object.
+    });
 
+    // Socket error, including errors from `packetMiddleware`, `controllers` and `onconnect` and more. Parameter is a plain JSON object.
     this.socket.on('error', error => {
       this.emit('error', error);
-    }); // `connect_error`'s paramter type is `Error`.
-    // Ensure the error emit to the provider has the same structure, so we can handle them unified.
-
-    this.socket.on('connect_error', error => {
-      const measure = stopMeasure(MEASURE_NAME.SOCKET_CONNECT);
-      triggerAnalyticsEvent({
-        eventAction: EVENT_ACTION.CONNECTION,
-        attributes: {
-          eventStatus: EVENT_STATUS.FAILURE,
-          error: error,
-          latency: measure === null || measure === void 0 ? void 0 : measure.duration,
-          documentAri: this.config.documentAri
-        }
-      }, this.analyticsClient); // If error received with `data`, it means the connection is rejected
-      // by the server on purpose for example no permission, so no need to
-      // keep the underneath connection, need to close. But some error like
-      // `xhr polling error` needs to retry.
-
-      if (!!error.data) {
-        var _this$socket;
+    });
 
-        (_this$socket = this.socket) === null || _this$socket === void 0 ? void 0 : _this$socket.close();
-      }
+    // `connect_error`'s parameter type is `Error`.
+    // Ensure the error emit to the provider has the same structure, so we can handle them unified.
+    this.socket.on('connect_error', this.onConnectError);
 
-      this.emit('error', {
-        message: error.message,
-        data: error.data
+    // To trigger reconnection when browser comes back online
+    if (!this.network) {
+      this.network = new Network({
+        onlineCallback: this.onOnlineHandler
       });
-    });
-  }
+    }
 
+    // Helper class to track reconnection issues, to emit an error if too many failed reconnection attempts happen
+    this.reconnectHelper = new ReconnectHelper();
+    // Fired upon a reconnection attempt error (from Socket.IO Manager)
+    this.socket.io.on('reconnect_error', this.onReconnectError);
+  }
   async fetchCatchup(fromVersion) {
     try {
       var _await$this$config$pe;
-
       const {
         doc,
         version,
@@ -267,7 +280,8 @@ export class Channel extends Emitter {
           version: fromVersion
         },
         requestInit: {
-          headers: { ...(this.config.permissionTokenRefresh ? {
+          headers: {
+            ...(this.config.permissionTokenRefresh ? {
               'x-token': (_await$this$config$pe = await this.config.permissionTokenRefresh()) !== null && _await$this$config$pe !== void 0 ? _await$this$config$pe : undefined
             } : {}),
             'x-product': getProduct(this.config.productInfo),
@@ -282,6 +296,17 @@ export class Channel extends Emitter {
         metadata
       };
     } catch (error) {
+      if (error.code === 404) {
+        const errorNotFound = {
+          message: ErrorCodeMapper.documentNotFound.message,
+          data: {
+            status: error.code,
+            code: ErrorCodeMapper.documentNotFound.code
+          }
+        };
+        this.emit('error', errorNotFound);
+        return {};
+      }
       logger("Can't fetch the catchup", error.message);
       const errorCatchup = {
         message: ErrorCodeMapper.catchupFail.message,
@@ -291,48 +316,44 @@ export class Channel extends Emitter {
         }
       };
       this.emit('error', errorCatchup);
-      return {};
+      throw error;
     }
   }
+
   /**
    * Send message to service. Timestamp will be added server side.
    */
-
-
   broadcast(type, data, callback) {
     if (!this.connected || !this.socket) {
       return;
     }
-
     this.socket.emit('broadcast', {
       type,
       ...data
     }, callback);
   }
-
   sendMetadata(metadata) {
     if (!this.connected || !this.socket) {
       return;
     }
-
     this.socket.emit('metadata', metadata);
   }
-
   sendPresenceJoined() {
     if (!this.connected || !this.socket) {
       return;
     }
-
     this.socket.emit('presence:joined');
   }
-
   disconnect() {
+    var _this$network;
     this.unsubscribeAll();
-
+    (_this$network = this.network) === null || _this$network === void 0 ? void 0 : _this$network.destroy();
+    this.network = null;
     if (this.socket) {
+      var _this$reconnectHelper3;
       this.socket.close();
       this.socket = null;
+      (_this$reconnectHelper3 = this.reconnectHelper) === null || _this$reconnectHelper3 === void 0 ? void 0 : _this$reconnectHelper3.destroy();
     }
   }
-
 }

package/dist/es2019/connectivity/network.js

@@ -0,0 +1,34 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+export let NetworkStatus;
+(function (NetworkStatus) {
+  NetworkStatus["ONLINE"] = "ONLINE";
+  NetworkStatus["OFFLINE"] = "OFFLINE";
+})(NetworkStatus || (NetworkStatus = {}));
+export default class Network {
+  constructor(props) {
+    _defineProperty(this, "offlineHandler", () => {
+      this.status = NetworkStatus.OFFLINE;
+    });
+    _defineProperty(this, "onlineHandler", () => {
+      this.status = NetworkStatus.ONLINE;
+      if (this.onlineCallback) {
+        this.onlineCallback();
+      }
+    });
+    if (props !== null && props !== void 0 && props.initialStatus) {
+      this.status = props.initialStatus;
+    }
+    if (props !== null && props !== void 0 && props.onlineCallback) {
+      this.onlineCallback = props.onlineCallback;
+    }
+    window.addEventListener('offline', this.offlineHandler);
+    window.addEventListener('online', this.onlineHandler);
+  }
+  getStatus() {
+    return this.status || null;
+  }
+  destroy() {
+    window.removeEventListener('offline', this.offlineHandler);
+    window.removeEventListener('online', this.onlineHandler);
+  }
+}

package/dist/es2019/connectivity/reconnect-helper.js

@@ -0,0 +1,29 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { NetworkStatus } from './network';
+import { network } from './singleton';
+
+// Calculation for max 8 offline reconnect attempts, with reconnection delay 200ms, randomization factor 0.5, reconnection delay max 128s
+// Min: 800ms, Avg: 51s, Max: 6m
+const FAILED_RECONNECTS_WHILE_OFFLINE_THRESHOLD = 8;
+export default class ReconnectHelper {
+  constructor() {
+    _defineProperty(this, "failedReconnectCount", 0);
+    _defineProperty(this, "onlineHandler", () => {
+      this.failedReconnectCount = 0;
+    });
+    window.addEventListener('online', this.onlineHandler);
+  }
+  countReconnectError() {
+    // Only count the reconnection attempts when offline
+    if (network.getStatus() === NetworkStatus.OFFLINE) {
+      this.failedReconnectCount++;
+    }
+  }
+  isLikelyNetworkIssue() {
+    const isLikelyNetworkIssue = this.failedReconnectCount >= FAILED_RECONNECTS_WHILE_OFFLINE_THRESHOLD;
+    return isLikelyNetworkIssue;
+  }
+  destroy() {
+    window.removeEventListener('online', this.onlineHandler);
+  }
+}

package/dist/es2019/connectivity/singleton.js

@@ -0,0 +1,7 @@
+import Network, { NetworkStatus } from './network';
+
+// Assume the connection is established at first
+const network = new Network({
+  initialStatus: NetworkStatus.ONLINE
+});
+export { network };

package/dist/es2019/disconnected-reason-mapper.js

@@ -9,10 +9,9 @@ export const socketIOReasons = {
   TRANSPORT_ERROR: 'transport error',
   // The connection was closed (example: the user has lost connection, or the network was changed from WiFi to 4G)
   PING_TIMEOUT: 'ping timeout' // The connection has encountered an error (example: the server was killed during a HTTP long-polling cycle)
-
 };
-export let DisconnectReason;
 
+export let DisconnectReason;
 (function (DisconnectReason) {
   DisconnectReason["CLIENT_DISCONNECT"] = "CLIENT_DISCONNECT";
   DisconnectReason["SERVER_DISCONNECT"] = "SERVER_DISCONNECT";
@@ -20,4 +19,20 @@ export let DisconnectReason;
   DisconnectReason["SOCKET_ERROR"] = "SOCKET_ERROR";
   DisconnectReason["SOCKET_TIMEOUT"] = "SOCKET_TIMEOUT";
   DisconnectReason["UNKNOWN_DISCONNECT"] = "UNKNOWN_DISCONNECT";
-})(DisconnectReason || (DisconnectReason = {}));
+})(DisconnectReason || (DisconnectReason = {}));
+export const disconnectedReasonMapper = reason => {
+  switch (reason) {
+    case socketIOReasons.IO_CLIENT_DISCONNECT:
+      return DisconnectReason.CLIENT_DISCONNECT;
+    case socketIOReasons.IO_SERVER_DISCONNECT:
+      return DisconnectReason.SERVER_DISCONNECT;
+    case socketIOReasons.TRANSPORT_CLOSED:
+      return DisconnectReason.SOCKET_CLOSED;
+    case socketIOReasons.TRANSPORT_ERROR:
+      return DisconnectReason.SOCKET_ERROR;
+    case socketIOReasons.PING_TIMEOUT:
+      return DisconnectReason.SOCKET_TIMEOUT;
+    default:
+      return DisconnectReason.UNKNOWN_DISCONNECT;
+  }
+};

package/dist/es2019/emitter.js

@@ -4,7 +4,6 @@ export class Emitter {
   constructor() {
     _defineProperty(this, "eventEmitter", new EventEmitter2());
   }
-
   /**
    * Emit events to subscribers
    */
@@ -12,32 +11,28 @@ export class Emitter {
     this.eventEmitter.emit(evt, data);
     return this;
   }
+
   /**
    * Subscribe to events emitted by this provider
    */
-
-
   on(evt, handler) {
     this.eventEmitter.on(evt, handler);
     return this;
   }
+
   /**
    * Unsubscribe from events emitted by this provider
    */
-
-
   off(evt, handler) {
     this.eventEmitter.off(evt, handler);
     return this;
   }
+
   /**
    * Unsubscribe from all events emitted by this provider.
    */
-
-
   unsubscribeAll(evt) {
     this.eventEmitter.removeAllListeners(evt);
     return this;
   }
-
 }

package/dist/es2019/error-code-mapper.js

@@ -23,31 +23,33 @@ export const ErrorCodeMapper = {
     code: 'FAIL_TO_SAVE',
     message: 'Collab service is not able to save changes'
   },
+  restoreError: {
+    code: 'DOCUMENT_RESTORE_ERROR',
+    message: 'Collab service unable to restore document'
+  },
   internalError: {
     code: 'INTERNAL_SERVICE_ERROR',
-    message: 'Collab service has return internal server error'
+    message: 'Collab service has experienced an internal server error'
   }
 };
 export const errorCodeMapper = error => {
   var _error$data;
-
   switch ((_error$data = error.data) === null || _error$data === void 0 ? void 0 : _error$data.code) {
     case 'INSUFFICIENT_EDITING_PERMISSION':
       return {
         status: 403,
         code: ErrorCodeMapper.noPermissionError.code,
         message: ErrorCodeMapper.noPermissionError.message,
-        reason: // Typescript magic so it detects the union type
+        reason:
+        // Typescript magic so it detects the union type
         typeof error.data.meta === 'object' ? error.data.meta.reason : undefined
       };
-
     case 'DOCUMENT_NOT_FOUND':
       return {
         status: 404,
         code: ErrorCodeMapper.documentNotFound.code,
         message: ErrorCodeMapper.documentNotFound.message
       };
-
     case 'FAILED_ON_S3':
     case 'DYNAMO_ERROR':
       return {
@@ -55,7 +57,13 @@ export const errorCodeMapper = error => {
         code: ErrorCodeMapper.failToSave.code,
         message: ErrorCodeMapper.failToSave.message
       };
-
+    case 'DOCUMENT_RESTORE_ERROR':
+      return {
+        status: 500,
+        code: ErrorCodeMapper.restoreError.code,
+        message: ErrorCodeMapper.restoreError.message
+      };
+    // Temporarily re-added so we don't emit errors to Confluence by default as they will disconnect the collab provider
     case 'CATCHUP_FAILED':
     case 'GET_QUERY_TIME_OUT':
     case 'INIT_DATA_LOAD_FAILED':
@@ -64,7 +72,6 @@ export const errorCodeMapper = error => {
         code: ErrorCodeMapper.internalError.code,
         message: ErrorCodeMapper.internalError.message
       };
-
     default:
       break;
   }

package/dist/es2019/feature-flags/index.js

@@ -1,26 +1,24 @@
 const defaultNCSFeatureFlags = {
   testFF: false
 };
+
 /**
  * Note that Confluence should have the same FF sets as NCS
  */
-
 const productKeys = {
   confluence: {
     testFF: 'confluence.fe.collab.provider.testFF'
   }
 };
-
 const filterFeatureFlagNames = flags => {
   const pairs = Object.entries(flags);
   return pairs.filter(([_key, value]) => !!value).map(([key]) => key);
 };
+
 /**
  * Takes a record of {NCS Feature Flag Names → boolean} and a supported product name.
  * Returns the corresponding product’s Launch Darkly Keys for each of the flags set as true in the input record.
  * */
-
-
 export const getProductSpecificFeatureFlags = (flags, product) => {
   const ncsFeatureFlags = filterFeatureFlagNames(flags);
   return ncsFeatureFlags.map(key => productKeys[product][key]);
@@ -29,6 +27,5 @@ export function getCollabProviderFeatureFlag(flagName, featureFlags) {
   if (featureFlags) {
     return flagName in featureFlags ? featureFlags[flagName] : defaultNCSFeatureFlags[flagName];
   }
-
   return defaultNCSFeatureFlags[flagName];
 }

package/dist/es2019/feature-flags/types.js

@@ -1,3 +1,5 @@
 // NCS feature flags - type and defaults defined here in one source of truth
+
 // With this type we ensure the object will contain all the flags
+
 export const supportedProducts = ['confluence'];