@mparticle/web-sdk 2.62.0 → 2.64.0

package/src/sdkToEventsApiConverter.ts

@@ -11,7 +11,7 @@ import {
     SDKGDPRConsentState,
     SDKCCPAConsentState,
 } from './consent';
-import Types from './types';
+import Types, { getEventCategoryFromCustomEventType } from './types';
 import { Dictionary, isEmpty } from './utils';
 import { ISDKUserIdentity } from './identity-user-interfaces';
 import { SDKIdentityTypeEnum } from './identity.interfaces';
@@ -795,3 +795,57 @@ export function convertUserIdentityTypeToServerIdentityType(
             return EventsApi.IdentityTypeEnum.phoneNumber3;
     }
 }
+
+export function getEventNameFromBatchEvent(
+    batchEvent: EventsApi.BaseEvent
+): string {
+    if (!batchEvent || !(batchEvent as any).data) {
+        return '';
+    }
+    if ((batchEvent as any).event_type === 'screen_view') {
+        return (batchEvent as any).data.screen_name || '';
+    }
+    return (batchEvent as any).data.event_name || '';
+}
+
+export function getEventCategoryFromBatchEvent(
+    batchEvent: EventsApi.BaseEvent
+): number {
+    if (!batchEvent || !(batchEvent as any).data) {
+        return Types.EventType.Unknown;
+    }
+
+    const data = (batchEvent as any).data;
+
+    if (data.custom_event_type) {
+        return getEventCategoryFromCustomEventType(data.custom_event_type);
+    }
+
+    if ((batchEvent as any).event_type === 'commerce_event') {
+        return getCommerceEventCategory(data);
+    }
+
+    return Types.EventType.Unknown;
+}
+
+function getCommerceEventCategory(data: any): number {
+    if (data.product_action && data.product_action.action) {
+        return getEventCategoryFromCustomEventType(
+            data.product_action.action
+        );
+    }
+
+    const promoAction = data.promotion_action && data.promotion_action.action;
+    if (promoAction === 'view') {
+        return Types.CommerceEventType.PromotionView;
+    }
+    if (promoAction === 'click') {
+        return Types.CommerceEventType.PromotionClick;
+    }
+
+    if (data.product_impressions) {
+        return Types.CommerceEventType.ProductImpression;
+    }
+
+    return Types.EventType.Unknown;
+}

package/src/serverModel.ts

@@ -16,6 +16,7 @@ import {
     parseStringOrNumber,
     Dictionary,
     isValidCustomFlagProperty,
+    extend,
 } from './utils';
 import { IntegrationAttributes, ServerSettings } from './store';
 import { MPID } from '@mparticle/web-sdk';
@@ -379,7 +380,7 @@ export default function ServerModel(
 
             uploadObject.Timestamp = mpInstance._Store.dateLastEventSent.getTime();
 
-            return mpInstance._Helpers.extend({}, eventObject, uploadObject);
+            return extend({}, eventObject, uploadObject);
         }
 
         return null;

package/src/store.ts

@@ -28,9 +28,8 @@ import {
     moveElementToEnd,
     parseNumber,
     returnConvertedBoolean,
-    isValidAttributeValue,
-    findKeyInObject,
     AttributeValue,
+    extend,
 } from './utils';
 import { IMinifiedConsentJSONObject, SDKConsentState } from './consent';
 import { ConfiguredKit, MPForwarder, UnregisteredKit } from './forwarders.interfaces';
@@ -650,7 +649,7 @@ export default function Store(
     this.syncPersistenceData = () => {
         const persistenceData = mpInstance._Persistence.getPersistence();
 
-        this.persistenceData = mpInstance._Helpers.extend(
+        this.persistenceData = extend(
             {},
             this.persistenceData,
             persistenceData,

package/src/types.ts

@@ -397,6 +397,140 @@ export const PerformanceMarkType = {
     JointSdkRoktKitInit: 'mp:jointSdkRoktKitInit' as const,
 }
 
+export function getMessageTypeFromEventType(
+    eventType: string
+): number {
+    switch (eventType) {
+        case 'custom_event':
+            return MessageType.PageEvent;
+        case 'screen_view':
+            return MessageType.PageView;
+        case 'commerce_event':
+            return MessageType.Commerce;
+        case 'session_start':
+            return MessageType.SessionStart;
+        case 'session_end':
+            return MessageType.SessionEnd;
+        case 'crash_report':
+            return MessageType.CrashReport;
+        case 'opt_out':
+            return MessageType.OptOut;
+        case 'application_state_transition':
+            return MessageType.AppStateTransition;
+        case 'user_attribute_change':
+            return MessageType.UserAttributeChange;
+        case 'user_identity_change':
+            return MessageType.UserIdentityChange;
+        default:
+            return -1;
+    }
+}
+
+export function getEventCategoryFromCustomEventType(
+    customEventType: string
+): number {
+    switch (customEventType) {
+        case 'navigation':
+            return EventType.Navigation;
+        case 'location':
+            return EventType.Location;
+        case 'search':
+            return EventType.Search;
+        case 'transaction':
+            return EventType.Transaction;
+        case 'user_content':
+            return EventType.UserContent;
+        case 'user_preference':
+            return EventType.UserPreference;
+        case 'social':
+            return EventType.Social;
+        case 'other':
+            return EventType.Other;
+        case 'media':
+            return EventType.Media;
+        case 'add_to_cart':
+            return CommerceEventType.ProductAddToCart;
+        case 'remove_from_cart':
+            return CommerceEventType.ProductRemoveFromCart;
+        case 'checkout':
+            return CommerceEventType.ProductCheckout;
+        case 'checkout_option':
+            return CommerceEventType.ProductCheckoutOption;
+        case 'click':
+            return CommerceEventType.ProductClick;
+        case 'view_detail':
+            return CommerceEventType.ProductViewDetail;
+        case 'purchase':
+            return CommerceEventType.ProductPurchase;
+        case 'refund':
+            return CommerceEventType.ProductRefund;
+        case 'promotion_view':
+            return CommerceEventType.PromotionView;
+        case 'promotion_click':
+            return CommerceEventType.PromotionClick;
+        case 'add_to_wishlist':
+            return CommerceEventType.ProductAddToWishlist;
+        case 'remove_from_wishlist':
+        case 'remove_from_wish_list':
+            return CommerceEventType.ProductRemoveFromWishlist;
+        case 'impression':
+            return CommerceEventType.ProductImpression;
+        default:
+            return EventType.Unknown;
+    }
+}
+
+export function getIdentityTypeFromBatchKey(
+    key: string
+): number {
+    switch (key) {
+        case 'other':
+            return IdentityType.Other;
+        case 'customer_id':
+            return IdentityType.CustomerId;
+        case 'facebook':
+            return IdentityType.Facebook;
+        case 'twitter':
+            return IdentityType.Twitter;
+        case 'google':
+            return IdentityType.Google;
+        case 'microsoft':
+            return IdentityType.Microsoft;
+        case 'yahoo':
+            return IdentityType.Yahoo;
+        case 'email':
+            return IdentityType.Email;
+        case 'facebook_custom_audience_id':
+            return IdentityType.FacebookCustomAudienceId;
+        case 'other_id_2':
+            return IdentityType.Other2;
+        case 'other_id_3':
+            return IdentityType.Other3;
+        case 'other_id_4':
+            return IdentityType.Other4;
+        case 'other_id_5':
+            return IdentityType.Other5;
+        case 'other_id_6':
+            return IdentityType.Other6;
+        case 'other_id_7':
+            return IdentityType.Other7;
+        case 'other_id_8':
+            return IdentityType.Other8;
+        case 'other_id_9':
+            return IdentityType.Other9;
+        case 'other_id_10':
+            return IdentityType.Other10;
+        case 'mobile_number':
+            return IdentityType.MobileNumber;
+        case 'phone_number_2':
+            return IdentityType.PhoneNumber2;
+        case 'phone_number_3':
+            return IdentityType.PhoneNumber3;
+        default:
+            return -1;
+    }
+}
+
 export default {
     MessageType,
     EventType,

package/src/utils.ts

@@ -491,6 +491,140 @@ const obfuscateData = (value: any): any => {
 const obfuscateDevData = (data: any, isDevelopmentMode?: boolean): any =>
     isDevelopmentMode ? data : obfuscateData(data);
 
+// Standalone version of jQuery.extend, from https://github.com/dansdom/extend
+// https://go.mparticle.com/work/SQDSDKS-6047
+function extend(...args: any[]): any {
+    const objectHelper = {
+        hasOwn: Object.prototype.hasOwnProperty,
+        class2type: {} as Record<string, string>,
+        type(obj: any): string {
+            return obj == null
+                ? String(obj)
+                : objectHelper.class2type[
+                      Object.prototype.toString.call(obj)
+                  ] || 'object';
+        },
+        isPlainObject(obj: any): boolean {
+            if (
+                !obj ||
+                objectHelper.type(obj) !== 'object' ||
+                obj.nodeType ||
+                objectHelper.isWindow(obj)
+            ) {
+                return false;
+            }
+
+            try {
+                if (
+                    obj.constructor &&
+                    !objectHelper.hasOwn.call(obj, 'constructor') &&
+                    !objectHelper.hasOwn.call(
+                        obj.constructor.prototype,
+                        'isPrototypeOf'
+                    )
+                ) {
+                    return false;
+                }
+            } catch (e) {
+                return false;
+            }
+
+            let key;
+            for (key in obj) {
+            } // eslint-disable-line no-empty
+
+            return (
+                key === undefined || objectHelper.hasOwn.call(obj, key)
+            );
+        },
+        isArray:
+            Array.isArray ||
+            function(obj: any): boolean {
+                return objectHelper.type(obj) === 'array';
+            },
+        isFunction(obj: any): boolean {
+            return objectHelper.type(obj) === 'function';
+        },
+        isWindow(obj: any): boolean {
+            return obj != null && obj == obj.window;
+        },
+    };
+
+    let options: any,
+        name: string,
+        src: any,
+        copy: any,
+        copyIsArray: boolean,
+        clone: any,
+        target = args[0] || {},
+        i = 1,
+        deep = false;
+    const length = args.length;
+
+    if (typeof target === 'boolean') {
+        deep = target;
+        target = args[1] || {};
+        i = 2;
+    }
+
+    if (typeof target !== 'object' && !objectHelper.isFunction(target)) {
+        target = {};
+    }
+
+    if (length === i) {
+        target = {};
+        --i;
+    }
+
+    for (; i < length; i++) {
+        if ((options = args[i]) != null) {
+            for (name in options) {
+                if (
+                    name === '__proto__' ||
+                    name === 'constructor' ||
+                    name === 'prototype'
+                ) {
+                    continue;
+                }
+
+                if (!Object.prototype.hasOwnProperty.call(options, name)) {
+                    continue;
+                }
+
+                src = target[name];
+                copy = options[name];
+
+                if (target === copy) {
+                    continue;
+                }
+
+                if (
+                    deep &&
+                    copy &&
+                    (objectHelper.isPlainObject(copy) ||
+                        (copyIsArray = objectHelper.isArray(copy)))
+                ) {
+                    if (copyIsArray) {
+                        copyIsArray = false;
+                        clone = src && objectHelper.isArray(src) ? src : [];
+                    } else {
+                        clone =
+                            src && objectHelper.isPlainObject(src)
+                                ? src
+                                : {};
+                    }
+
+                    target[name] = extend(deep, clone, copy);
+                } else if (copy !== undefined) {
+                    target[name] = copy;
+                }
+            }
+        }
+    }
+
+    return target;
+}
+
 export {
     createCookieString,
     revertCookieString,
@@ -534,4 +668,5 @@ export {
     getHref,
     replaceMPID,
     replaceAmpWithAmpersand,
+    extend,
 };