chore(build): Generate latest bundle [skip ci]

Author: mparticle-automation

dist/mparticle.common.js

@@ -203,7 +203,7 @@ var mParticle = (function () {
       Base64: Base64$1
     };
 
-    var version = "2.61.0";
+    var version = "2.62.0";
 
     var Constants = {
       sdkVersion: version,

dist/mparticle.esm.js

@@ -0,0 +1,34 @@
+import { BatchUploader } from './batchUploader';
+import { SDKEvent, SDKDataPlan } from './sdkRuntimeModels';
+import KitBlocker from './kitBlocking';
+import { Dictionary } from './utils';
+import { IUploadObject } from './serverModel';
+import { MPForwarder } from './forwarders.interfaces';
+import { IMParticleUser, ISDKUserAttributes } from './identity-user-interfaces';
+import { AsyncUploader } from './uploaders';
+import { IMParticleWebSDKInstance } from './mp-instance';
+export interface IAPIClient {
+    uploader: BatchUploader | null;
+    queueEventForBatchUpload: (event: SDKEvent) => void;
+    processQueuedEvents: () => void;
+    appendUserInfoToEvents: (user: IMParticleUser, events: SDKEvent[]) => void;
+    sendEventToServer: (event: SDKEvent, _options?: Dictionary<any>) => void;
+    sendSingleEventToServer: (event: SDKEvent) => void;
+    sendBatchForwardingStatsToServer: (forwardingStatsData: IForwardingStatsData, xhr: XMLHttpRequest) => void;
+    initializeForwarderStatsUploader: () => AsyncUploader;
+    prepareForwardingStats: (forwarder: MPForwarder, event: IUploadObject) => void;
+}
+export interface IForwardingStatsData {
+    mid: number;
+    esid: number;
+    n: string;
+    attrs: ISDKUserAttributes;
+    sdk: string;
+    dt: number;
+    et: number;
+    dbg: boolean;
+    ct: number;
+    eec: number;
+    dp: SDKDataPlan;
+}
+export default function APIClient(this: IAPIClient, mpInstance: IMParticleWebSDKInstance, kitBlocker: KitBlocker): void;

dist/mparticle.js

@@ -0,0 +1,4 @@
+export default class Audience {
+    audience_id: number;
+    constructor(audience_id: number);
+}

dist/types/src/apiClient.d.ts

@@ -0,0 +1,19 @@
+import { SDKLoggerApi } from './sdkRuntimeModels';
+import { AsyncUploader } from './uploaders';
+import Audience from './audience';
+export interface IAudienceMembershipsServerResponse {
+    dt: 'cam';
+    ct: number;
+    id: string;
+    audience_memberships: Audience[];
+}
+export interface IAudienceMemberships {
+    currentAudienceMemberships: Audience[];
+}
+export default class AudienceManager {
+    url: string;
+    userAudienceAPI: AsyncUploader;
+    logger: SDKLoggerApi;
+    constructor(userAudienceUrl: string, apiKey: string, logger: SDKLoggerApi);
+    sendGetUserAudienceRequest(mpid: string, callback: (userAudiences: IAudienceMemberships) => void): Promise<void>;
+}

dist/types/src/audience.d.ts

@@ -0,0 +1,72 @@
+import { Batch } from '@mparticle/event-models';
+import { SDKEvent } from './sdkRuntimeModels';
+import { IMParticleWebSDKInstance } from './mp-instance';
+/**
+ * BatchUploader contains all the logic to store/retrieve events and batches
+ * to/from persistence, and upload batches to mParticle.
+ * It queues events as they come in, storing them in persistence, then at set
+ * intervals turns them into batches and transfers between event and batch
+ * persistence.
+ * It then attempts to upload them to mParticle, purging batch persistence if
+ * the upload is successful
+ *
+ * These uploads happen on an interval basis using window.fetch or XHR
+ * requests, depending on what is available in the browser.
+ *
+ * Uploads can also be triggered on browser visibility/focus changes via an
+ * event listener, which then uploads to mPartice via the browser's Beacon API.
+ */
+export declare class BatchUploader {
+    static readonly CONTENT_TYPE: string;
+    static readonly MINIMUM_INTERVAL_MILLIS: number;
+    uploadIntervalMillis: number;
+    eventsQueuedForProcessing: SDKEvent[];
+    batchesQueuedForProcessing: Batch[];
+    mpInstance: IMParticleWebSDKInstance;
+    uploadUrl: string;
+    batchingEnabled: boolean;
+    private eventVault;
+    private batchVault;
+    private offlineStorageEnabled;
+    private uploader;
+    private lastASTEventTime;
+    private readonly AST_DEBOUNCE_MS;
+    /**
+     * Creates an instance of a BatchUploader
+     * @param {IMParticleWebSDKInstance} mpInstance - the mParticle SDK instance
+     * @param {number} uploadInterval - the desired upload interval in milliseconds
+     */
+    constructor(mpInstance: IMParticleWebSDKInstance, uploadInterval: number);
+    private isOfflineStorageAvailable;
+    private shouldDebounceAndUpdateLastASTTime;
+    private createBackgroundASTEvent;
+    private addEventListeners;
+    private isBeaconAvailable;
+    private triggerUploadInterval;
+    /**
+     * This method will queue a single Event which will eventually be processed into a Batch
+     * @param event event that should be queued
+     */
+    queueEvent(event: SDKEvent): void;
+    private shouldTriggerImmediateUpload;
+    /**
+     * This implements crucial logic to:
+     * - bucket pending events by MPID, and then by Session, and upload individual batches for each bucket.
+     *
+     * In the future this should enforce other requirements such as maximum batch size.
+     *
+     * @param sdkEvents current pending events
+     * @param defaultUser the user to reference for events that are missing data
+     */
+    private static createNewBatches;
+    /**
+     * This is the main loop function:
+     *  - take all pending events and turn them into batches
+     *  - attempt to upload each batch
+     *
+     * @param triggerFuture whether to trigger the loop again - for manual/forced uploads this should be false
+     * @param useBeacon whether to use the beacon API - used when the page is being unloaded
+     */
+    prepareAndUpload(triggerFuture?: boolean, useBeacon?: boolean): Promise<void>;
+    private uploadBatches;
+}