more prefixing of methods

Author: fadi-george

package.json

@@ -84,12 +84,12 @@
     },
     {
       "path": "./build/releases/OneSignalSDK.page.es6.js",
-      "limit": "47.565 kB",
+      "limit": "47.44 kB",
       "gzip": true
     },
     {
       "path": "./build/releases/OneSignalSDK.sw.js",
-      "limit": "13.624 kB",
+      "limit": "13.58 kB",
       "gzip": true
     },
     {

src/core/modelRepo/ModelStore.ts

@@ -96,7 +96,7 @@ export abstract class ModelStore<
 
   _onChanged(args: ModelChangedArgs, tag: string): void {
     this._persist();
-    this._changeSubscription.fire((handler) =>
+    this._changeSubscription._fire((handler) =>
       handler._onModelUpdated(args, tag),
     );
   }
@@ -116,7 +116,7 @@ export abstract class ModelStore<
     for (const item of this._models) {
       // no longer listen for changes to this model
       item._unsubscribe(this);
-      this._changeSubscription.fire((handler) =>
+      this._changeSubscription._fire((handler) =>
         handler._onModelRemoved(item, tag),
       );
       db.delete(this._modelName, item._modelId);
@@ -136,7 +136,7 @@ export abstract class ModelStore<
     model._subscribe(this);
     this._persist();
 
-    this._changeSubscription.fire((handler) =>
+    this._changeSubscription._fire((handler) =>
       handler._onModelAdded(model, tag),
     );
   }
@@ -151,7 +151,7 @@ export abstract class ModelStore<
     await db.delete(this._modelName, model._modelId);
     this._persist();
 
-    this._changeSubscription.fire((handler) =>
+    this._changeSubscription._fire((handler) =>
       handler._onModelRemoved(model, tag),
     );
   }

src/core/modelStores/SingletonModelStore.ts

@@ -39,7 +39,7 @@ export class SingletonModelStore<TModel extends Model>
     const existingModel = this.model;
     existingModel._initializeFromModel(existingModel._modelId, model);
     this.store._persist();
-    this.changeSubscription.fire((handler) =>
+    this.changeSubscription._fire((handler) =>
       handler._onModelReplaced(existingModel, tag),
     );
   }
@@ -65,7 +65,7 @@ export class SingletonModelStore<TModel extends Model>
   }
 
   _onModelUpdated(args: ModelChangedArgs, tag: ModelChangeTagValue): void {
-    this.changeSubscription.fire((handler) =>
+    this.changeSubscription._fire((handler) =>
       handler._onModelUpdated(args, tag),
     );
   }

src/core/models/Model.ts

@@ -182,7 +182,9 @@ export class Model<U extends object = object, T extends U & object = U & object>
       oldValue,
       newValue,
     };
-    this._changeNotifier.fire((handler) => handler._onChanged(changeArgs, tag));
+    this._changeNotifier._fire((handler) =>
+      handler._onChanged(changeArgs, tag),
+    );
   }
 
   /**

src/onesignal/SessionNamespace.ts

@@ -27,13 +27,13 @@ export class SessionNamespace {
       return;
     }
 
-    if (!(await outcomesHelper.beforeOutcomeSend())) {
+    if (!(await outcomesHelper._beforeOutcomeSend())) {
       return;
     }
 
-    const outcomeAttribution = await outcomesHelper.getAttribution();
+    const outcomeAttribution = await outcomesHelper._getAttribution();
 
-    await outcomesHelper.send({
+    await outcomesHelper._send({
       type: outcomeAttribution.type,
       notificationIds: outcomeAttribution.notificationIds,
       weight: outcomeWeight,
@@ -54,10 +54,10 @@ export class SessionNamespace {
       true,
     );
 
-    if (!(await outcomesHelper.beforeOutcomeSend())) {
+    if (!(await outcomesHelper._beforeOutcomeSend())) {
       return;
     }
-    const outcomeAttribution = await outcomesHelper.getAttribution();
+    const outcomeAttribution = await outcomesHelper._getAttribution();
 
     if (outcomeAttribution.type === OutcomeAttributionType.NotSupported) {
       Log._warn(
@@ -70,12 +70,12 @@ export class SessionNamespace {
     const { notificationIds } = outcomeAttribution;
     // only new notifs that ought to be attributed
     const newNotifsToAttributeWithOutcome =
-      await outcomesHelper.getNotifsToAttributeWithUniqueOutcome(
+      await outcomesHelper._getNotifsToAttributeWithUniqueOutcome(
         notificationIds,
       );
 
     if (
-      !outcomesHelper.shouldSendUnique(
+      !outcomesHelper._shouldSendUnique(
         outcomeAttribution,
         newNotifsToAttributeWithOutcome,
       )
@@ -84,7 +84,7 @@ export class SessionNamespace {
       return;
     }
 
-    await outcomesHelper.send({
+    await outcomesHelper._send({
       type: outcomeAttribution.type,
       notificationIds: newNotifsToAttributeWithOutcome,
     });

src/shared/helpers/EventProducer.ts

@@ -1,40 +1,26 @@
 import type { IEventNotifier } from 'src/core/types/models';
 
 export class EventProducer<THandler> implements IEventNotifier<THandler> {
-  private subscribers: THandler[] = [];
+  private _subscribers: THandler[] = [];
 
   get _hasSubscribers(): boolean {
-    return this.subscribers.length > 0;
+    return this._subscribers.length > 0;
   }
 
   _subscribe(handler: THandler): void {
-    this.subscribers.push(handler);
+    this._subscribers.push(handler);
   }
 
   _unsubscribe(handler: THandler): void {
-    const index = this.subscribers.indexOf(handler);
+    const index = this._subscribers.indexOf(handler);
     if (index !== -1) {
-      this.subscribers.splice(index, 1);
+      this._subscribers.splice(index, 1);
     }
   }
 
-  subscribeAll(from: EventProducer<THandler>): void {
-    for (const handler of from.subscribers) {
-      this._subscribe(handler);
-    }
-  }
-
-  fire(callback: (handler: THandler) => void): void {
-    for (const handler of this.subscribers) {
+  _fire(callback: (handler: THandler) => void): void {
+    for (const handler of this._subscribers) {
       callback(handler);
     }
   }
-
-  async suspendingFire(
-    callback: (handler: THandler) => Promise<void>,
-  ): Promise<void> {
-    for (const handler of this.subscribers) {
-      await callback(handler);
-    }
-  }
 }

src/shared/helpers/OutcomesHelper.ts

@@ -19,10 +19,10 @@ const SEND_OUTCOME = 'sendOutcome';
 const SEND_UNIQUE_OUTCOME = 'sendUniqueOutcome';
 
 export default class OutcomesHelper {
-  private outcomeName: string;
-  private config: OutcomesConfig;
-  private appId: string;
-  private isUnique: boolean;
+  private _outcomeName: string;
+  private _config: OutcomesConfig;
+  private _appId: string;
+  private _isUnique: boolean;
 
   /**
    * @param  {string} appId
@@ -36,10 +36,10 @@ export default class OutcomesHelper {
     outcomeName: string,
     isUnique: boolean,
   ) {
-    this.outcomeName = outcomeName;
-    this.config = config;
-    this.appId = appId;
-    this.isUnique = isUnique;
+    this._outcomeName = outcomeName;
+    this._config = config;
+    this._appId = appId;
+    this._isUnique = isUnique;
   }
   /**
    * Returns `OutcomeAttribution` object which includes
@@ -50,27 +50,27 @@ export default class OutcomesHelper {
    *       does not check if they have been previously attributed (used in both sendOutcome & sendUniqueOutcome)
    * @returns Promise
    */
-  async getAttribution(): Promise<OutcomeAttribution> {
-    return await getConfigAttribution(this.config);
+  async _getAttribution(): Promise<OutcomeAttribution> {
+    return await getConfigAttribution(this._config);
   }
 
   /**
    * Performs logging of method call and returns whether Outcomes are supported
    * @param  {boolean} isUnique
    * @returns Promise
    */
-  async beforeOutcomeSend(): Promise<boolean> {
-    const outcomeMethodString = this.isUnique
+  async _beforeOutcomeSend(): Promise<boolean> {
+    const outcomeMethodString = this._isUnique
       ? SEND_UNIQUE_OUTCOME
       : SEND_OUTCOME;
-    logMethodCall(outcomeMethodString, this.outcomeName);
+    logMethodCall(outcomeMethodString, this._outcomeName);
 
-    if (!this.config) {
+    if (!this._config) {
       Log._debug('Outcomes feature not supported by main application yet.');
       return false;
     }
 
-    if (!this.outcomeName) {
+    if (!this._outcomeName) {
       Log._error('Outcome name is required');
       return false;
     }
@@ -91,10 +91,10 @@ export default class OutcomesHelper {
    * @param  {string} outcomeName
    * @returns Promise
    */
-  async getAttributedNotifsByUniqueOutcomeName(): Promise<string[]> {
+  async _getAttributedNotifsByUniqueOutcomeName(): Promise<string[]> {
     const sentOutcomes = await db.getAll('SentUniqueOutcome');
     return sentOutcomes
-      .filter((o) => o.outcomeName === this.outcomeName)
+      .filter((o) => o.outcomeName === this._outcomeName)
       .reduce((acc: string[], curr: SentUniqueOutcome) => {
         const notificationIds = curr.notificationIds || [];
         return [...acc, ...notificationIds];
@@ -106,25 +106,28 @@ export default class OutcomesHelper {
    * @param  {string} outcomeName
    * @param  {string[]} notificationIds
    */
-  async getNotifsToAttributeWithUniqueOutcome(notificationIds: string[]) {
+  async _getNotifsToAttributeWithUniqueOutcome(notificationIds: string[]) {
     const previouslyAttributedArr: string[] =
-      await this.getAttributedNotifsByUniqueOutcomeName();
+      await this._getAttributedNotifsByUniqueOutcomeName();
 
     return notificationIds.filter(
       (id) => previouslyAttributedArr.indexOf(id) === -1,
     );
   }
 
-  shouldSendUnique(outcomeAttribution: OutcomeAttribution, notifArr: string[]) {
+  _shouldSendUnique(
+    outcomeAttribution: OutcomeAttribution,
+    notifArr: string[],
+  ) {
     // we should only send if type is unattributed OR there are notifs to attribute
     if (outcomeAttribution.type === OutcomeAttributionType.Unattributed) {
       return true;
     }
     return notifArr.length > 0;
   }
 
-  async saveSentUniqueOutcome(newNotificationIds: string[]): Promise<void> {
-    const outcomeName = this.outcomeName;
+  async _saveSentUniqueOutcome(newNotificationIds: string[]): Promise<void> {
+    const outcomeName = this._outcomeName;
     const existingSentOutcome = await db.get('SentUniqueOutcome', outcomeName);
     const currentSession = await getCurrentSession();
 
@@ -141,8 +144,8 @@ export default class OutcomesHelper {
     });
   }
 
-  async wasSentDuringSession() {
-    const sentOutcome = await db.get('SentUniqueOutcome', this.outcomeName);
+  async _wasSentDuringSession() {
+    const sentOutcome = await db.get('SentUniqueOutcome', this._outcomeName);
 
     if (!sentOutcome) {
       return false;
@@ -160,45 +163,45 @@ export default class OutcomesHelper {
     );
   }
 
-  async send(outcomeProps: OutcomeProps): Promise<void> {
+  async _send(outcomeProps: OutcomeProps): Promise<void> {
     const { type, notificationIds, weight } = outcomeProps;
 
     switch (type) {
       case OutcomeAttributionType.Direct:
-        if (this.isUnique) {
-          await this.saveSentUniqueOutcome(notificationIds);
+        if (this._isUnique) {
+          await this._saveSentUniqueOutcome(notificationIds);
         }
         await OneSignal._context._updateManager._sendOutcomeDirect(
-          this.appId,
+          this._appId,
           notificationIds,
-          this.outcomeName,
+          this._outcomeName,
           weight,
         );
         return;
       case OutcomeAttributionType.Indirect:
-        if (this.isUnique) {
-          await this.saveSentUniqueOutcome(notificationIds);
+        if (this._isUnique) {
+          await this._saveSentUniqueOutcome(notificationIds);
         }
         await OneSignal._context._updateManager._sendOutcomeInfluenced(
-          this.appId,
+          this._appId,
           notificationIds,
-          this.outcomeName,
+          this._outcomeName,
           weight,
         );
         return;
       case OutcomeAttributionType.Unattributed:
-        if (this.isUnique) {
-          if (await this.wasSentDuringSession()) {
+        if (this._isUnique) {
+          if (await this._wasSentDuringSession()) {
             Log._warn(
               `(Unattributed) unique outcome was already sent during this session`,
             );
             return;
           }
-          await this.saveSentUniqueOutcome([]);
+          await this._saveSentUniqueOutcome([]);
         }
         await OneSignal._context._updateManager._sendOutcomeUnattributed(
-          this.appId,
-          this.outcomeName,
+          this._appId,
+          this._outcomeName,
           weight,
         );
         return;
@@ -209,8 +212,6 @@ export default class OutcomesHelper {
         return;
     }
   }
-
-  // statics
 }
 
 /**