@launchdarkly/js-sdk-common 2.10.0 → 2.11.0

package/dist/{index.mjs → esm/index.mjs}

@@ -44,23 +44,23 @@ class AttributeReference {
             this.redactionName = refOrLiteral;
             if (refOrLiteral === '' || refOrLiteral === '/' || !validate(refOrLiteral)) {
                 this.isValid = false;
-                this.components = [];
+                this._components = [];
                 return;
             }
             if (isLiteral(refOrLiteral)) {
-                this.components = [refOrLiteral];
+                this._components = [refOrLiteral];
             }
             else if (refOrLiteral.indexOf('/', 1) < 0) {
-                this.components = [unescape(refOrLiteral.slice(1))];
+                this._components = [unescape(refOrLiteral.slice(1))];
             }
             else {
-                this.components = getComponents(refOrLiteral);
+                this._components = getComponents(refOrLiteral);
             }
             // The items inside of '_meta' are not intended to be addressable.
             // Excluding it as a valid reference means that we can make it non-addressable
             // without having to copy all the attributes out of the context object
             // provided by the user.
-            if (this.components[0] === '_meta') {
+            if (this._components[0] === '_meta') {
                 this.isValid = false;
             }
             else {
@@ -69,14 +69,14 @@ class AttributeReference {
         }
         else {
             const literalVal = refOrLiteral;
-            this.components = [literalVal];
+            this._components = [literalVal];
             this.isValid = literalVal !== '';
             // Literals which start with '/' need escaped to prevent ambiguity.
             this.redactionName = literalVal.startsWith('/') ? toRefString(literalVal) : literalVal;
         }
     }
     get(target) {
-        const { components, isValid } = this;
+        const { _components: components, isValid } = this;
         if (!isValid) {
             return undefined;
         }
@@ -103,23 +103,23 @@ class AttributeReference {
         return current;
     }
     getComponent(depth) {
-        return this.components[depth];
+        return this._components[depth];
     }
     get depth() {
-        return this.components.length;
+        return this._components.length;
     }
     get isKind() {
-        return this.components.length === 1 && this.components[0] === 'kind';
+        return this._components.length === 1 && this._components[0] === 'kind';
     }
     compare(other) {
         return (this.depth === other.depth &&
-            this.components.every((value, index) => value === other.getComponent(index)));
+            this._components.every((value, index) => value === other.getComponent(index)));
     }
 }
 /**
  * For use as invalid references when deserializing Flag/Segment data.
  */
-AttributeReference.invalidReference = new AttributeReference('');
+AttributeReference.InvalidReference = new AttributeReference('');
 
 /* eslint-disable class-methods-use-this */
 /* eslint-disable max-classes-per-file */
@@ -144,7 +144,7 @@ class FactoryOrInstance {
  */
 class Type {
     constructor(typeName, example) {
-        this.typeName = typeName;
+        this._typeName = typeName;
         this.typeOf = typeof example;
     }
     is(u) {
@@ -154,7 +154,7 @@ class Type {
         return typeof u === this.typeOf;
     }
     getType() {
-        return this.typeName;
+        return this._typeName;
     }
 }
 /**
@@ -165,7 +165,7 @@ class Type {
  */
 class TypeArray {
     constructor(typeName, example) {
-        this.typeName = typeName;
+        this._typeName = typeName;
         this.typeOf = typeof example;
     }
     is(u) {
@@ -178,7 +178,7 @@ class TypeArray {
         return false;
     }
     getType() {
-        return this.typeName;
+        return this._typeName;
     }
 }
 /**
@@ -448,18 +448,18 @@ class Context {
      * implementation details, so they cannot be free functions.
      */
     constructor(valid, kind, message) {
-        this.isMulti = false;
-        this.isUser = false;
-        this.wasLegacy = false;
-        this.contexts = {};
+        this._isMulti = false;
+        this._isUser = false;
+        this._wasLegacy = false;
+        this._contexts = {};
         this.kind = kind;
         this.valid = valid;
         this.message = message;
     }
-    static contextForError(kind, message) {
+    static _contextForError(kind, message) {
         return new Context(false, kind, message);
     }
-    static getValueFromContext(reference, context) {
+    static _getValueFromContext(reference, context) {
         if (!context || !reference.isValid) {
             return undefined;
         }
@@ -468,23 +468,23 @@ class Context {
         }
         return reference.get(context);
     }
-    contextForKind(kind) {
-        if (this.isMulti) {
-            return this.contexts[kind];
+    _contextForKind(kind) {
+        if (this._isMulti) {
+            return this._contexts[kind];
         }
         if (this.kind === kind) {
-            return this.context;
+            return this._context;
         }
         return undefined;
     }
-    static fromMultiKindContext(context) {
+    static _fromMultiKindContext(context) {
         const kinds = Object.keys(context).filter((key) => key !== 'kind');
         const kindsValid = kinds.every(validKind);
         if (!kinds.length) {
-            return Context.contextForError('multi', 'A multi-kind context must contain at least one kind');
+            return Context._contextForError('multi', 'A multi-kind context must contain at least one kind');
         }
         if (!kindsValid) {
-            return Context.contextForError('multi', 'Context contains invalid kinds');
+            return Context._contextForError('multi', 'Context contains invalid kinds');
         }
         const privateAttributes = {};
         let contextsAreObjects = true;
@@ -501,59 +501,59 @@ class Context {
             return acc;
         }, {});
         if (!contextsAreObjects) {
-            return Context.contextForError('multi', 'Context contained contexts that were not objects');
+            return Context._contextForError('multi', 'Context contained contexts that were not objects');
         }
         if (!Object.values(contexts).every((part) => validKey(part.key))) {
-            return Context.contextForError('multi', 'Context contained invalid keys');
+            return Context._contextForError('multi', 'Context contained invalid keys');
         }
         // There was only a single kind in the multi-kind context.
         // So we can just translate this to a single-kind context.
         if (kinds.length === 1) {
             const kind = kinds[0];
             const created = new Context(true, kind);
-            created.context = { ...contexts[kind], kind };
-            created.privateAttributeReferences = privateAttributes;
-            created.isUser = kind === 'user';
+            created._context = { ...contexts[kind], kind };
+            created._privateAttributeReferences = privateAttributes;
+            created._isUser = kind === 'user';
             return created;
         }
         const created = new Context(true, context.kind);
-        created.contexts = contexts;
-        created.privateAttributeReferences = privateAttributes;
-        created.isMulti = true;
+        created._contexts = contexts;
+        created._privateAttributeReferences = privateAttributes;
+        created._isMulti = true;
         return created;
     }
-    static fromSingleKindContext(context) {
+    static _fromSingleKindContext(context) {
         const { key, kind } = context;
         const kindValid = validKind(kind);
         const keyValid = validKey(key);
         if (!kindValid) {
-            return Context.contextForError(kind ?? 'unknown', 'The kind was not valid for the context');
+            return Context._contextForError(kind ?? 'unknown', 'The kind was not valid for the context');
         }
         if (!keyValid) {
-            return Context.contextForError(kind, 'The key for the context was not valid');
+            return Context._contextForError(kind, 'The key for the context was not valid');
         }
         // The JSON interfaces uses dangling _.
         // eslint-disable-next-line no-underscore-dangle
         const privateAttributeReferences = processPrivateAttributes(context._meta?.privateAttributes);
         const created = new Context(true, kind);
-        created.isUser = kind === 'user';
-        created.context = context;
-        created.privateAttributeReferences = {
+        created._isUser = kind === 'user';
+        created._context = context;
+        created._privateAttributeReferences = {
             [kind]: privateAttributeReferences,
         };
         return created;
     }
-    static fromLegacyUser(context) {
+    static _fromLegacyUser(context) {
         const keyValid = context.key !== undefined && context.key !== null;
         // For legacy users we allow empty keys.
         if (!keyValid) {
-            return Context.contextForError('user', 'The key for the context was not valid');
+            return Context._contextForError('user', 'The key for the context was not valid');
         }
         const created = new Context(true, 'user');
-        created.isUser = true;
-        created.wasLegacy = true;
-        created.context = legacyToSingleKind(context);
-        created.privateAttributeReferences = {
+        created._isUser = true;
+        created._wasLegacy = true;
+        created._context = legacyToSingleKind(context);
+        created._privateAttributeReferences = {
             user: processPrivateAttributes(context.privateAttributeNames, true),
         };
         return created;
@@ -566,18 +566,18 @@ class Context {
      */
     static fromLDContext(context) {
         if (!context) {
-            return Context.contextForError('unknown', 'No context specified. Returning default value');
+            return Context._contextForError('unknown', 'No context specified. Returning default value');
         }
         if (isSingleKind(context)) {
-            return Context.fromSingleKindContext(context);
+            return Context._fromSingleKindContext(context);
         }
         if (isMultiKind(context)) {
-            return Context.fromMultiKindContext(context);
+            return Context._fromMultiKindContext(context);
         }
         if (isLegacyUser(context)) {
-            return Context.fromLegacyUser(context);
+            return Context._fromLegacyUser(context);
         }
-        return Context.contextForError('unknown', 'Context was not of a valid kind');
+        return Context._contextForError('unknown', 'Context was not of a valid kind');
     }
     /**
      * Creates a {@link LDContext} from a {@link Context}.
@@ -589,7 +589,7 @@ class Context {
             return undefined;
         }
         const contexts = context.getContexts();
-        if (!context.isMulti) {
+        if (!context._isMulti) {
             return contexts[0][1];
         }
         const result = {
@@ -612,7 +612,7 @@ class Context {
         if (reference.isKind) {
             return this.kinds;
         }
-        return Context.getValueFromContext(reference, this.contextForKind(kind));
+        return Context._getValueFromContext(reference, this._contextForKind(kind));
     }
     /**
      * Attempt to get a key for the specified kind.
@@ -620,35 +620,35 @@ class Context {
      * @returns The key for the specified kind, or undefined.
      */
     key(kind = DEFAULT_KIND) {
-        return this.contextForKind(kind)?.key;
+        return this._contextForKind(kind)?.key;
     }
     /**
      * True if this is a multi-kind context.
      */
     get isMultiKind() {
-        return this.isMulti;
+        return this._isMulti;
     }
     /**
      * Get the canonical key for this context.
      */
     get canonicalKey() {
-        if (this.isUser) {
-            return this.context.key;
+        if (this._isUser) {
+            return this._context.key;
         }
-        if (this.isMulti) {
-            return Object.keys(this.contexts)
+        if (this._isMulti) {
+            return Object.keys(this._contexts)
                 .sort()
-                .map((key) => `${key}:${encodeKey(this.contexts[key].key)}`)
+                .map((key) => `${key}:${encodeKey(this._contexts[key].key)}`)
                 .join(':');
         }
-        return `${this.kind}:${encodeKey(this.context.key)}`;
+        return `${this.kind}:${encodeKey(this._context.key)}`;
     }
     /**
      * Get the kinds of this context.
      */
     get kinds() {
-        if (this.isMulti) {
-            return Object.keys(this.contexts);
+        if (this._isMulti) {
+            return Object.keys(this._contexts);
         }
         return [this.kind];
     }
@@ -656,13 +656,13 @@ class Context {
      * Get the kinds, and their keys, for this context.
      */
     get kindsAndKeys() {
-        if (this.isMulti) {
-            return Object.entries(this.contexts).reduce((acc, [kind, context]) => {
+        if (this._isMulti) {
+            return Object.entries(this._contexts).reduce((acc, [kind, context]) => {
                 acc[kind] = context.key;
                 return acc;
             }, {});
         }
-        return { [this.kind]: this.context.key };
+        return { [this.kind]: this._context.key };
     }
     /**
      * Get the attribute references.
@@ -670,7 +670,7 @@ class Context {
      * @param kind
      */
     privateAttributes(kind) {
-        return this.privateAttributeReferences?.[kind] || [];
+        return this._privateAttributeReferences?.[kind] || [];
     }
     /**
      * Get the underlying context objects from this context.
@@ -680,16 +680,16 @@ class Context {
      * The returned objects should not be modified.
      */
     getContexts() {
-        if (this.isMulti) {
-            return Object.entries(this.contexts);
+        if (this._isMulti) {
+            return Object.entries(this._contexts);
         }
-        return [[this.kind, this.context]];
+        return [[this.kind, this._context]];
     }
     get legacy() {
-        return this.wasLegacy;
+        return this._wasLegacy;
     }
 }
-Context.userKind = DEFAULT_KIND;
+Context.UserKind = DEFAULT_KIND;
 
 // _meta is part of the specification.
 // These attributes cannot be removed via a private attribute.
@@ -763,31 +763,31 @@ function cloneWithRedactions(target, references) {
     return { cloned, excluded: excluded.sort() };
 }
 class ContextFilter {
-    constructor(allAttributesPrivate, privateAttributes) {
-        this.allAttributesPrivate = allAttributesPrivate;
-        this.privateAttributes = privateAttributes;
+    constructor(_allAttributesPrivate, _privateAttributes) {
+        this._allAttributesPrivate = _allAttributesPrivate;
+        this._privateAttributes = _privateAttributes;
     }
     filter(context, redactAnonymousAttributes = false) {
         const contexts = context.getContexts();
         if (contexts.length === 1) {
-            return this.filterSingleKind(context, contexts[0][1], contexts[0][0], redactAnonymousAttributes);
+            return this._filterSingleKind(context, contexts[0][1], contexts[0][0], redactAnonymousAttributes);
         }
         const filteredMulti = {
             kind: 'multi',
         };
         contexts.forEach(([kind, single]) => {
-            filteredMulti[kind] = this.filterSingleKind(context, single, kind, redactAnonymousAttributes);
+            filteredMulti[kind] = this._filterSingleKind(context, single, kind, redactAnonymousAttributes);
         });
         return filteredMulti;
     }
-    getAttributesToFilter(context, single, kind, redactAllAttributes) {
+    _getAttributesToFilter(context, single, kind, redactAllAttributes) {
         return (redactAllAttributes
             ? Object.keys(single).map((k) => new AttributeReference(k, true))
-            : [...this.privateAttributes, ...context.privateAttributes(kind)]).filter((attr) => !protectedAttributes.some((protectedAttr) => protectedAttr.compare(attr)));
+            : [...this._privateAttributes, ...context.privateAttributes(kind)]).filter((attr) => !protectedAttributes.some((protectedAttr) => protectedAttr.compare(attr)));
     }
-    filterSingleKind(context, single, kind, redactAnonymousAttributes) {
-        const redactAllAttributes = this.allAttributesPrivate || (redactAnonymousAttributes && single.anonymous === true);
-        const { cloned, excluded } = cloneWithRedactions(single, this.getAttributesToFilter(context, single, kind, redactAllAttributes));
+    _filterSingleKind(context, single, kind, redactAnonymousAttributes) {
+        const redactAllAttributes = this._allAttributesPrivate || (redactAnonymousAttributes && single.anonymous === true);
+        const { cloned, excluded } = cloneWithRedactions(single, this._getAttributesToFilter(context, single, kind, redactAllAttributes));
         if (context.legacy) {
             legacyTopLevelCopyAttributes.forEach((name) => {
                 if (name in cloned) {
@@ -979,6 +979,7 @@ const escapes = {
     f: (val) => toFloat(val),
     j: (val) => tryStringify(val),
     o: (val) => tryStringify(val),
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     O: (val) => tryStringify(val),
     c: () => '',
 };
@@ -1065,17 +1066,17 @@ class BasicLogger {
         return new BasicLogger({});
     }
     constructor(options) {
-        this.logLevel = LogPriority[options.level ?? 'info'] ?? LogPriority.info;
-        this.name = options.name ?? 'LaunchDarkly';
+        this._logLevel = LogPriority[options.level ?? 'info'] ?? LogPriority.info;
+        this._name = options.name ?? 'LaunchDarkly';
         // eslint-disable-next-line no-console
-        this.destination = options.destination;
-        this.formatter = options.formatter;
+        this._destination = options.destination;
+        this._formatter = options.formatter;
     }
-    tryFormat(...args) {
+    _tryFormat(...args) {
         try {
-            if (this.formatter) {
+            if (this._formatter) {
                 // In case the provided formatter fails.
-                return this.formatter?.(...args);
+                return this._formatter?.(...args);
             }
             return format(...args);
         }
@@ -1083,21 +1084,21 @@ class BasicLogger {
             return format(...args);
         }
     }
-    tryWrite(msg) {
+    _tryWrite(msg) {
         try {
-            this.destination(msg);
+            this._destination(msg);
         }
         catch {
             // eslint-disable-next-line no-console
             console.error(msg);
         }
     }
-    log(level, args) {
-        if (level >= this.logLevel) {
-            const prefix = `${LevelNames[level]}: [${this.name}]`;
+    _log(level, args) {
+        if (level >= this._logLevel) {
+            const prefix = `${LevelNames[level]}: [${this._name}]`;
             try {
-                if (this.destination) {
-                    this.tryWrite(`${prefix} ${this.tryFormat(...args)}`);
+                if (this._destination) {
+                    this._tryWrite(`${prefix} ${this._tryFormat(...args)}`);
                 }
                 else {
                     // `console.error` has its own formatter.
@@ -1114,16 +1115,16 @@ class BasicLogger {
         }
     }
     error(...args) {
-        this.log(LogPriority.error, args);
+        this._log(LogPriority.error, args);
     }
     warn(...args) {
-        this.log(LogPriority.warn, args);
+        this._log(LogPriority.warn, args);
     }
     info(...args) {
-        this.log(LogPriority.info, args);
+        this._log(LogPriority.info, args);
     }
     debug(...args) {
-        this.log(LogPriority.debug, args);
+        this._log(LogPriority.debug, args);
     }
 }
 
@@ -1160,29 +1161,29 @@ class SafeLogger {
                 // criteria since the SDK calls the logger during nearly all of its operations.
             }
         });
-        this.logger = logger;
-        this.fallback = fallback;
+        this._logger = logger;
+        this._fallback = fallback;
     }
-    log(level, args) {
+    _log(level, args) {
         try {
-            this.logger[level](...args);
+            this._logger[level](...args);
         }
         catch {
             // If all else fails do not break.
-            this.fallback[level](...args);
+            this._fallback[level](...args);
         }
     }
     error(...args) {
-        this.log('error', args);
+        this._log('error', args);
     }
     warn(...args) {
-        this.log('warn', args);
+        this._log('warn', args);
     }
     info(...args) {
-        this.log('info', args);
+        this._log('info', args);
     }
     debug(...args) {
-        this.log('debug', args);
+        this._log('debug', args);
     }
 }
 
@@ -1313,6 +1314,7 @@ class ServiceEndpoints {
         this.payloadFilterKey = payloadFilterKey;
     }
 }
+// eslint-disable-next-line @typescript-eslint/naming-convention
 ServiceEndpoints.DEFAULT_EVENTS = 'https://events.launchdarkly.com';
 function getWithParams(uri, parameters) {
     if (parameters.length === 0) {
@@ -1651,14 +1653,14 @@ const timedPromise = (t, taskName) => new Promise((_res, reject) => {
 });
 
 class DiagnosticsManager {
-    constructor(sdkKey, platform, diagnosticInitConfig) {
-        this.platform = platform;
-        this.diagnosticInitConfig = diagnosticInitConfig;
-        this.streamInits = [];
-        this.startTime = Date.now();
-        this.dataSinceDate = this.startTime;
-        this.id = {
-            diagnosticId: platform.crypto.randomUUID(),
+    constructor(sdkKey, _platform, _diagnosticInitConfig) {
+        this._platform = _platform;
+        this._diagnosticInitConfig = _diagnosticInitConfig;
+        this._streamInits = [];
+        this._startTime = Date.now();
+        this._dataSinceDate = this._startTime;
+        this._id = {
+            diagnosticId: _platform.crypto.randomUUID(),
             sdkKeySuffix: sdkKey.length > 6 ? sdkKey.substring(sdkKey.length - 6) : sdkKey,
         };
     }
@@ -1667,14 +1669,14 @@ class DiagnosticsManager {
      * not be repeated during the lifetime of the SDK client.
      */
     createInitEvent() {
-        const sdkData = this.platform.info.sdkData();
-        const platformData = this.platform.info.platformData();
+        const sdkData = this._platform.info.sdkData();
+        const platformData = this._platform.info.platformData();
         return {
             kind: 'diagnostic-init',
-            id: this.id,
-            creationDate: this.startTime,
+            id: this._id,
+            creationDate: this._startTime,
             sdk: sdkData,
-            configuration: this.diagnosticInitConfig,
+            configuration: this._diagnosticInitConfig,
             platform: {
                 name: platformData.name,
                 osArch: platformData.os?.arch,
@@ -1694,7 +1696,7 @@ class DiagnosticsManager {
      */
     recordStreamInit(timestamp, failed, durationMillis) {
         const item = { timestamp, failed, durationMillis };
-        this.streamInits.push(item);
+        this._streamInits.push(item);
     }
     /**
      * Creates a periodic event containing time-dependent stats, and resets the state of the manager
@@ -1708,16 +1710,16 @@ class DiagnosticsManager {
         const currentTime = Date.now();
         const evt = {
             kind: 'diagnostic',
-            id: this.id,
+            id: this._id,
             creationDate: currentTime,
-            dataSinceDate: this.dataSinceDate,
+            dataSinceDate: this._dataSinceDate,
             droppedEvents,
             deduplicatedUsers,
             eventsInLastBatch,
-            streamInits: this.streamInits,
+            streamInits: this._streamInits,
         };
-        this.streamInits = [];
-        this.dataSinceDate = currentTime;
+        this._streamInits = [];
+        this._dataSinceDate = currentTime;
         return evt;
     }
 }
@@ -1744,25 +1746,25 @@ class ClientMessages {
             ` (${badType}), only numeric metric values are supported.`);
     }
 }
-ClientMessages.missingContextKeyNoEvent = 'Context was unspecified or had no key; event will not be sent';
+ClientMessages.MissingContextKeyNoEvent = 'Context was unspecified or had no key; event will not be sent';
 
 class EventSender {
     constructor(clientContext, baseHeaders) {
         const { basicConfiguration, platform } = clientContext;
         const { serviceEndpoints: { analyticsEventPath, diagnosticEventPath }, } = basicConfiguration;
         const { crypto, requests } = platform;
-        this.defaultHeaders = { ...baseHeaders };
-        this.eventsUri = getEventsUri(basicConfiguration.serviceEndpoints, analyticsEventPath, []);
-        this.diagnosticEventsUri = getEventsUri(basicConfiguration.serviceEndpoints, diagnosticEventPath, []);
-        this.requests = requests;
-        this.crypto = crypto;
+        this._defaultHeaders = { ...baseHeaders };
+        this._eventsUri = getEventsUri(basicConfiguration.serviceEndpoints, analyticsEventPath, []);
+        this._diagnosticEventsUri = getEventsUri(basicConfiguration.serviceEndpoints, diagnosticEventPath, []);
+        this._requests = requests;
+        this._crypto = crypto;
     }
-    async tryPostingEvents(events, uri, payloadId, canRetry) {
+    async _tryPostingEvents(events, uri, payloadId, canRetry) {
         const tryRes = {
             status: LDDeliveryStatus.Succeeded,
         };
         const headers = {
-            ...this.defaultHeaders,
+            ...this._defaultHeaders,
             'content-type': 'application/json',
         };
         if (payloadId) {
@@ -1771,7 +1773,7 @@ class EventSender {
         }
         let error;
         try {
-            const { status, headers: resHeaders } = await this.requests.fetch(uri, {
+            const { status, headers: resHeaders } = await this._requests.fetch(uri, {
                 headers,
                 body: JSON.stringify(events),
                 method: 'POST',
@@ -1813,12 +1815,12 @@ class EventSender {
         }
         // wait 1 second before retrying
         await sleep();
-        return this.tryPostingEvents(events, this.eventsUri, payloadId, false);
+        return this._tryPostingEvents(events, this._eventsUri, payloadId, false);
     }
     async sendEventData(type, data) {
-        const payloadId = type === LDEventType.AnalyticsEvents ? this.crypto.randomUUID() : undefined;
-        const uri = type === LDEventType.AnalyticsEvents ? this.eventsUri : this.diagnosticEventsUri;
-        return this.tryPostingEvents(data, uri, payloadId, true);
+        const payloadId = type === LDEventType.AnalyticsEvents ? this._crypto.randomUUID() : undefined;
+        const uri = type === LDEventType.AnalyticsEvents ? this._eventsUri : this._diagnosticEventsUri;
+        return this._tryPostingEvents(data, uri, payloadId, true);
     }
 }
 
@@ -1857,43 +1859,43 @@ function counterKey(event) {
  */
 class EventSummarizer {
     constructor() {
-        this.startDate = 0;
-        this.endDate = 0;
-        this.counters = {};
-        this.contextKinds = {};
+        this._startDate = 0;
+        this._endDate = 0;
+        this._counters = {};
+        this._contextKinds = {};
     }
     summarizeEvent(event) {
         if (isFeature(event) && !event.excludeFromSummaries) {
             const countKey = counterKey(event);
-            const counter = this.counters[countKey];
-            let kinds = this.contextKinds[event.key];
+            const counter = this._counters[countKey];
+            let kinds = this._contextKinds[event.key];
             if (!kinds) {
                 kinds = new Set();
-                this.contextKinds[event.key] = kinds;
+                this._contextKinds[event.key] = kinds;
             }
             event.context.kinds.forEach((kind) => kinds.add(kind));
             if (counter) {
                 counter.increment();
             }
             else {
-                this.counters[countKey] = new SummaryCounter(1, event.key, event.value, event.default, event.version, event.variation);
+                this._counters[countKey] = new SummaryCounter(1, event.key, event.value, event.default, event.version, event.variation);
             }
-            if (this.startDate === 0 || event.creationDate < this.startDate) {
-                this.startDate = event.creationDate;
+            if (this._startDate === 0 || event.creationDate < this._startDate) {
+                this._startDate = event.creationDate;
             }
-            if (event.creationDate > this.endDate) {
-                this.endDate = event.creationDate;
+            if (event.creationDate > this._endDate) {
+                this._endDate = event.creationDate;
             }
         }
     }
     getSummary() {
-        const features = Object.values(this.counters).reduce((acc, counter) => {
+        const features = Object.values(this._counters).reduce((acc, counter) => {
             let flagSummary = acc[counter.key];
             if (!flagSummary) {
                 flagSummary = {
                     default: counter.default,
                     counters: [],
-                    contextKinds: [...this.contextKinds[counter.key]],
+                    contextKinds: [...this._contextKinds[counter.key]],
                 };
                 acc[counter.key] = flagSummary;
             }
@@ -1914,17 +1916,17 @@ class EventSummarizer {
             return acc;
         }, {});
         return {
-            startDate: this.startDate,
-            endDate: this.endDate,
+            startDate: this._startDate,
+            endDate: this._endDate,
             features,
             kind: 'summary',
         };
     }
     clearSummary() {
-        this.startDate = 0;
-        this.endDate = 0;
-        this.counters = {};
-        this.contextKinds = {};
+        this._startDate = 0;
+        this._endDate = 0;
+        this._counters = {};
+        this._contextKinds = {};
     }
 }
 
@@ -1956,88 +1958,88 @@ function shouldSample(ratio) {
 }
 
 class EventProcessor {
-    constructor(config, clientContext, baseHeaders, contextDeduplicator, diagnosticsManager, start = true) {
-        this.config = config;
-        this.contextDeduplicator = contextDeduplicator;
-        this.diagnosticsManager = diagnosticsManager;
-        this.summarizer = new EventSummarizer();
-        this.queue = [];
-        this.lastKnownPastTime = 0;
-        this.droppedEvents = 0;
-        this.deduplicatedUsers = 0;
-        this.exceededCapacity = false;
-        this.eventsInLastBatch = 0;
-        this.shutdown = false;
-        this.flushUsersTimer = null;
-        this.capacity = config.eventsCapacity;
-        this.logger = clientContext.basicConfiguration.logger;
-        this.eventSender = new EventSender(clientContext, baseHeaders);
-        this.contextFilter = new ContextFilter(config.allAttributesPrivate, config.privateAttributes.map((ref) => new AttributeReference(ref)));
+    constructor(_config, clientContext, baseHeaders, _contextDeduplicator, _diagnosticsManager, start = true) {
+        this._config = _config;
+        this._contextDeduplicator = _contextDeduplicator;
+        this._diagnosticsManager = _diagnosticsManager;
+        this._summarizer = new EventSummarizer();
+        this._queue = [];
+        this._lastKnownPastTime = 0;
+        this._droppedEvents = 0;
+        this._deduplicatedUsers = 0;
+        this._exceededCapacity = false;
+        this._eventsInLastBatch = 0;
+        this._shutdown = false;
+        this._flushUsersTimer = null;
+        this._capacity = _config.eventsCapacity;
+        this._logger = clientContext.basicConfiguration.logger;
+        this._eventSender = new EventSender(clientContext, baseHeaders);
+        this._contextFilter = new ContextFilter(_config.allAttributesPrivate, _config.privateAttributes.map((ref) => new AttributeReference(ref)));
         if (start) {
             this.start();
         }
     }
     start() {
-        if (this.contextDeduplicator?.flushInterval !== undefined) {
-            this.flushUsersTimer = setInterval(() => {
-                this.contextDeduplicator?.flush();
-            }, this.contextDeduplicator.flushInterval * 1000);
+        if (this._contextDeduplicator?.flushInterval !== undefined) {
+            this._flushUsersTimer = setInterval(() => {
+                this._contextDeduplicator?.flush();
+            }, this._contextDeduplicator.flushInterval * 1000);
         }
-        this.flushTimer = setInterval(async () => {
+        this._flushTimer = setInterval(async () => {
             try {
                 await this.flush();
             }
             catch (e) {
                 // Log errors and swallow them
-                this.logger?.debug(`Flush failed: ${e}`);
+                this._logger?.debug(`Flush failed: ${e}`);
             }
-        }, this.config.flushInterval * 1000);
-        if (this.diagnosticsManager) {
-            const initEvent = this.diagnosticsManager.createInitEvent();
-            this.postDiagnosticEvent(initEvent);
-            this.diagnosticsTimer = setInterval(() => {
-                const statsEvent = this.diagnosticsManager.createStatsEventAndReset(this.droppedEvents, this.deduplicatedUsers, this.eventsInLastBatch);
-                this.droppedEvents = 0;
-                this.deduplicatedUsers = 0;
-                this.postDiagnosticEvent(statsEvent);
-            }, this.config.diagnosticRecordingInterval * 1000);
-        }
-        this.logger?.debug('Started EventProcessor.');
-    }
-    postDiagnosticEvent(event) {
-        this.eventSender.sendEventData(LDEventType.DiagnosticEvent, event);
+        }, this._config.flushInterval * 1000);
+        if (this._diagnosticsManager) {
+            const initEvent = this._diagnosticsManager.createInitEvent();
+            this._postDiagnosticEvent(initEvent);
+            this._diagnosticsTimer = setInterval(() => {
+                const statsEvent = this._diagnosticsManager.createStatsEventAndReset(this._droppedEvents, this._deduplicatedUsers, this._eventsInLastBatch);
+                this._droppedEvents = 0;
+                this._deduplicatedUsers = 0;
+                this._postDiagnosticEvent(statsEvent);
+            }, this._config.diagnosticRecordingInterval * 1000);
+        }
+        this._logger?.debug('Started EventProcessor.');
+    }
+    _postDiagnosticEvent(event) {
+        this._eventSender.sendEventData(LDEventType.DiagnosticEvent, event);
     }
     close() {
-        clearInterval(this.flushTimer);
-        if (this.flushUsersTimer) {
-            clearInterval(this.flushUsersTimer);
+        clearInterval(this._flushTimer);
+        if (this._flushUsersTimer) {
+            clearInterval(this._flushUsersTimer);
         }
-        if (this.diagnosticsTimer) {
-            clearInterval(this.diagnosticsTimer);
+        if (this._diagnosticsTimer) {
+            clearInterval(this._diagnosticsTimer);
         }
     }
     async flush() {
-        if (this.shutdown) {
+        if (this._shutdown) {
             throw new LDInvalidSDKKeyError('Events cannot be posted because a permanent error has been encountered. ' +
                 'This is most likely an invalid SDK key. The specific error information ' +
                 'is logged independently.');
         }
-        const eventsToFlush = this.queue;
-        this.queue = [];
-        const summary = this.summarizer.getSummary();
-        this.summarizer.clearSummary();
+        const eventsToFlush = this._queue;
+        this._queue = [];
+        const summary = this._summarizer.getSummary();
+        this._summarizer.clearSummary();
         if (Object.keys(summary.features).length) {
             eventsToFlush.push(summary);
         }
         if (!eventsToFlush.length) {
             return;
         }
-        this.eventsInLastBatch = eventsToFlush.length;
-        this.logger?.debug('Flushing %d events', eventsToFlush.length);
-        await this.tryPostingEvents(eventsToFlush);
+        this._eventsInLastBatch = eventsToFlush.length;
+        this._logger?.debug('Flushing %d events', eventsToFlush.length);
+        await this._tryPostingEvents(eventsToFlush);
     }
     sendEvent(inputEvent) {
-        if (this.shutdown) {
+        if (this._shutdown) {
             return;
         }
         if (isMigration(inputEvent)) {
@@ -2051,25 +2053,25 @@ class EventProcessor {
                 if (migrationEvent.samplingRatio === 1) {
                     delete migrationEvent.samplingRatio;
                 }
-                this.enqueue(migrationEvent);
+                this._enqueue(migrationEvent);
             }
             return;
         }
-        this.summarizer.summarizeEvent(inputEvent);
+        this._summarizer.summarizeEvent(inputEvent);
         const isFeatureEvent = isFeature(inputEvent);
         const addFullEvent = (isFeatureEvent && inputEvent.trackEvents) || !isFeatureEvent;
-        const addDebugEvent = this.shouldDebugEvent(inputEvent);
+        const addDebugEvent = this._shouldDebugEvent(inputEvent);
         const isIdentifyEvent = isIdentify(inputEvent);
-        const shouldNotDeduplicate = this.contextDeduplicator?.processContext(inputEvent.context);
+        const shouldNotDeduplicate = this._contextDeduplicator?.processContext(inputEvent.context);
         // If there is no cache, then it will never be in the cache.
         if (!shouldNotDeduplicate) {
             if (!isIdentifyEvent) {
-                this.deduplicatedUsers += 1;
+                this._deduplicatedUsers += 1;
             }
         }
         const addIndexEvent = shouldNotDeduplicate && !isIdentifyEvent;
         if (addIndexEvent) {
-            this.enqueue(this.makeOutputEvent({
+            this._enqueue(this._makeOutputEvent({
                 kind: 'index',
                 creationDate: inputEvent.creationDate,
                 context: inputEvent.context,
@@ -2077,19 +2079,19 @@ class EventProcessor {
             }, false));
         }
         if (addFullEvent && shouldSample(inputEvent.samplingRatio)) {
-            this.enqueue(this.makeOutputEvent(inputEvent, false));
+            this._enqueue(this._makeOutputEvent(inputEvent, false));
         }
         if (addDebugEvent && shouldSample(inputEvent.samplingRatio)) {
-            this.enqueue(this.makeOutputEvent(inputEvent, true));
+            this._enqueue(this._makeOutputEvent(inputEvent, true));
         }
     }
-    makeOutputEvent(event, debug) {
+    _makeOutputEvent(event, debug) {
         switch (event.kind) {
             case 'feature': {
                 const out = {
                     kind: debug ? 'debug' : 'feature',
                     creationDate: event.creationDate,
-                    context: this.contextFilter.filter(event.context, !debug),
+                    context: this._contextFilter.filter(event.context, !debug),
                     key: event.key,
                     value: event.value,
                     default: event.default,
@@ -2116,7 +2118,7 @@ class EventProcessor {
                 const out = {
                     kind: event.kind,
                     creationDate: event.creationDate,
-                    context: this.contextFilter.filter(event.context),
+                    context: this._contextFilter.filter(event.context),
                 };
                 if (event.samplingRatio !== 1) {
                     out.samplingRatio = event.samplingRatio;
@@ -2170,32 +2172,32 @@ class EventProcessor {
                 return event;
         }
     }
-    enqueue(event) {
-        if (this.queue.length < this.capacity) {
-            this.queue.push(event);
-            this.exceededCapacity = false;
+    _enqueue(event) {
+        if (this._queue.length < this._capacity) {
+            this._queue.push(event);
+            this._exceededCapacity = false;
         }
         else {
-            if (!this.exceededCapacity) {
-                this.exceededCapacity = true;
-                this.logger?.warn('Exceeded event queue capacity. Increase capacity to avoid dropping events.');
+            if (!this._exceededCapacity) {
+                this._exceededCapacity = true;
+                this._logger?.warn('Exceeded event queue capacity. Increase capacity to avoid dropping events.');
             }
-            this.droppedEvents += 1;
+            this._droppedEvents += 1;
         }
     }
-    shouldDebugEvent(event) {
+    _shouldDebugEvent(event) {
         return (isFeature(event) &&
             event.debugEventsUntilDate &&
-            event.debugEventsUntilDate > this.lastKnownPastTime &&
+            event.debugEventsUntilDate > this._lastKnownPastTime &&
             event.debugEventsUntilDate > Date.now());
     }
-    async tryPostingEvents(events) {
-        const res = await this.eventSender.sendEventData(LDEventType.AnalyticsEvents, events);
+    async _tryPostingEvents(events) {
+        const res = await this._eventSender.sendEventData(LDEventType.AnalyticsEvents, events);
         if (res.status === LDDeliveryStatus.FailedAndMustShutDown) {
-            this.shutdown = true;
+            this._shutdown = true;
         }
         if (res.serverTime) {
-            this.lastKnownPastTime = res.serverTime;
+            this._lastKnownPastTime = res.serverTime;
         }
         if (res.error) {
             throw res.error;
@@ -2275,16 +2277,16 @@ class NullEventProcessor {
 }
 
 class EventFactoryBase {
-    constructor(withReasons) {
-        this.withReasons = withReasons;
+    constructor(_withReasons) {
+        this._withReasons = _withReasons;
     }
     evalEvent(e) {
-        return new InputEvalEvent(this.withReasons, e.context, e.flagKey, e.value, e.defaultVal, e.version, 
+        return new InputEvalEvent(this._withReasons, e.context, e.flagKey, e.value, e.defaultVal, e.version, 
         // Exclude null as a possibility.
-        e.variation ?? undefined, e.trackEvents || e.addExperimentData, e.prereqOfFlagKey, this.withReasons || e.addExperimentData ? e.reason : undefined, e.debugEventsUntilDate, e.excludeFromSummaries, e.samplingRatio);
+        e.variation ?? undefined, e.trackEvents || e.addExperimentData, e.prereqOfFlagKey, this._withReasons || e.addExperimentData ? e.reason : undefined, e.debugEventsUntilDate, e.excludeFromSummaries, e.samplingRatio);
     }
     unknownFlagEvent(key, defVal, context) {
-        return new InputEvalEvent(this.withReasons, context, key, defVal, defVal, 
+        return new InputEvalEvent(this._withReasons, context, key, defVal, defVal, 
         // This isn't ideal, but the purpose of the factory is to at least
         // handle this situation.
         undefined, // version
@@ -2314,27 +2316,27 @@ const reportJsonError = (type, data, logger, errorHandler) => {
 };
 // TODO: SDK-156 - Move to Server SDK specific location
 class StreamingProcessor {
-    constructor(clientContext, streamUriPath, parameters, listeners, baseHeaders, diagnosticsManager, errorHandler, streamInitialReconnectDelay = 1) {
-        this.listeners = listeners;
-        this.diagnosticsManager = diagnosticsManager;
-        this.errorHandler = errorHandler;
-        this.streamInitialReconnectDelay = streamInitialReconnectDelay;
+    constructor(clientContext, streamUriPath, parameters, _listeners, baseHeaders, _diagnosticsManager, _errorHandler, _streamInitialReconnectDelay = 1) {
+        this._listeners = _listeners;
+        this._diagnosticsManager = _diagnosticsManager;
+        this._errorHandler = _errorHandler;
+        this._streamInitialReconnectDelay = _streamInitialReconnectDelay;
         const { basicConfiguration, platform } = clientContext;
         const { logger } = basicConfiguration;
         const { requests } = platform;
-        this.headers = { ...baseHeaders };
-        this.logger = logger;
-        this.requests = requests;
-        this.streamUri = getStreamingUri(basicConfiguration.serviceEndpoints, streamUriPath, parameters);
+        this._headers = { ...baseHeaders };
+        this._logger = logger;
+        this._requests = requests;
+        this._streamUri = getStreamingUri(basicConfiguration.serviceEndpoints, streamUriPath, parameters);
     }
-    logConnectionStarted() {
-        this.connectionAttemptStartTime = Date.now();
+    _logConnectionStarted() {
+        this._connectionAttemptStartTime = Date.now();
     }
-    logConnectionResult(success) {
-        if (this.connectionAttemptStartTime && this.diagnosticsManager) {
-            this.diagnosticsManager.recordStreamInit(this.connectionAttemptStartTime, !success, Date.now() - this.connectionAttemptStartTime);
+    _logConnectionResult(success) {
+        if (this._connectionAttemptStartTime && this._diagnosticsManager) {
+            this._diagnosticsManager.recordStreamInit(this._connectionAttemptStartTime, !success, Date.now() - this._connectionAttemptStartTime);
         }
-        this.connectionAttemptStartTime = undefined;
+        this._connectionAttemptStartTime = undefined;
     }
     /**
      * This is a wrapper around the passed errorHandler which adds additional
@@ -2345,63 +2347,63 @@ class StreamingProcessor {
      *
      * @private
      */
-    retryAndHandleError(err) {
+    _retryAndHandleError(err) {
         if (!shouldRetry(err)) {
-            this.logConnectionResult(false);
-            this.errorHandler?.(new LDStreamingError(DataSourceErrorKind.ErrorResponse, err.message, err.status));
-            this.logger?.error(httpErrorMessage(err, 'streaming request'));
+            this._logConnectionResult(false);
+            this._errorHandler?.(new LDStreamingError(DataSourceErrorKind.ErrorResponse, err.message, err.status));
+            this._logger?.error(httpErrorMessage(err, 'streaming request'));
             return false;
         }
-        this.logger?.warn(httpErrorMessage(err, 'streaming request', 'will retry'));
-        this.logConnectionResult(false);
-        this.logConnectionStarted();
+        this._logger?.warn(httpErrorMessage(err, 'streaming request', 'will retry'));
+        this._logConnectionResult(false);
+        this._logConnectionStarted();
         return true;
     }
     start() {
-        this.logConnectionStarted();
+        this._logConnectionStarted();
         // TLS is handled by the platform implementation.
-        const eventSource = this.requests.createEventSource(this.streamUri, {
-            headers: this.headers,
-            errorFilter: (error) => this.retryAndHandleError(error),
-            initialRetryDelayMillis: 1000 * this.streamInitialReconnectDelay,
+        const eventSource = this._requests.createEventSource(this._streamUri, {
+            headers: this._headers,
+            errorFilter: (error) => this._retryAndHandleError(error),
+            initialRetryDelayMillis: 1000 * this._streamInitialReconnectDelay,
             readTimeoutMillis: 5 * 60 * 1000,
             retryResetIntervalMillis: 60 * 1000,
         });
-        this.eventSource = eventSource;
+        this._eventSource = eventSource;
         eventSource.onclose = () => {
-            this.logger?.info('Closed LaunchDarkly stream connection');
+            this._logger?.info('Closed LaunchDarkly stream connection');
         };
         eventSource.onerror = () => {
             // The work is done by `errorFilter`.
         };
         eventSource.onopen = () => {
-            this.logger?.info('Opened LaunchDarkly stream connection');
+            this._logger?.info('Opened LaunchDarkly stream connection');
         };
         eventSource.onretrying = (e) => {
-            this.logger?.info(`Will retry stream connection in ${e.delayMillis} milliseconds`);
+            this._logger?.info(`Will retry stream connection in ${e.delayMillis} milliseconds`);
         };
-        this.listeners.forEach(({ deserializeData, processJson }, eventName) => {
+        this._listeners.forEach(({ deserializeData, processJson }, eventName) => {
             eventSource.addEventListener(eventName, (event) => {
-                this.logger?.debug(`Received ${eventName} event`);
+                this._logger?.debug(`Received ${eventName} event`);
                 if (event?.data) {
-                    this.logConnectionResult(true);
+                    this._logConnectionResult(true);
                     const { data } = event;
                     const dataJson = deserializeData(data);
                     if (!dataJson) {
-                        reportJsonError(eventName, data, this.logger, this.errorHandler);
+                        reportJsonError(eventName, data, this._logger, this._errorHandler);
                         return;
                     }
                     processJson(dataJson);
                 }
                 else {
-                    this.errorHandler?.(new LDStreamingError(DataSourceErrorKind.Unknown, 'Unexpected payload from event stream'));
+                    this._errorHandler?.(new LDStreamingError(DataSourceErrorKind.Unknown, 'Unexpected payload from event stream'));
                 }
             });
         });
     }
     stop() {
-        this.eventSource?.close();
-        this.eventSource = undefined;
+        this._eventSource?.close();
+        this._eventSource = undefined;
     }
     close() {
         this.stop();