iureiure 1.0.0

package/packages/analytics-js-integrations/src/integrations/Klaviyo/util.js

@@ -0,0 +1,91 @@
+/* eslint-disable no-param-reassign */
+import get from 'get-value';
+import { isNotEmpty, removeUndefinedAndNullValues } from '../../utils/commonUtils';
+
+const categoryKey = 'properties.categories';
+
+const itemsPayload = item => {
+  const itemObj = {
+    ProductID: item.product_id,
+    SKU: item.sku,
+    ProductName: item.name,
+    Quantity: item.quantity,
+    ItemPrice: item.price,
+    RowTotal: item.total,
+    ProductURL: item.url,
+    ImageURL: item.image_url,
+    ProductCategories: item.categories,
+  };
+  return itemObj;
+};
+
+/**
+ * Returns items array
+ * @param {*} items
+ * @returns
+ */
+const prepareItemsArray = items => {
+  const itemArr = [];
+  items.forEach(element => {
+    let item = itemsPayload(element);
+    item = removeUndefinedAndNullValues(item);
+    if (isNotEmpty(item)) {
+      itemArr.push(item);
+    }
+  });
+  return itemArr;
+};
+
+const ecommEventPayload = (event, message) => {
+  let payload = {};
+  switch (event) {
+    case 'Viewed Product': {
+      payload.ProductName = get(message, 'properties.name');
+      payload.ProductID = get(message, 'properties.product_id');
+      payload.SKU = get(message, 'properties.sku');
+      payload.ImageURL = get(message, 'properties.image_url');
+      payload.URL = get(message, 'properties.url');
+      payload.Brand = get(message, 'properties.brand');
+      payload.Price = get(message, 'properties.price');
+      payload.CompareAtPrice = get(message, 'properties.compare_at_price');
+      payload.Categories = get(message, categoryKey);
+      break;
+    }
+    case 'Added to Cart': {
+      payload.$value = get(message, 'properties.value');
+      payload.AddedItemProductName = get(message, 'properties.name');
+      payload.AddedItemProductID = get(message, 'properties.product_id');
+      payload.AddedItemSKU = get(message, 'properties.sku');
+      payload.AddedItemImageURL = get(message, 'properties.image_url');
+      payload.AddedItemURL = get(message, 'properties.url');
+      payload.AddedItemPrice = get(message, 'properties.price');
+      payload.AddedItemQuantity = get(message, 'properties.quantity');
+      payload.AddedItemCategories = get(message, categoryKey);
+      payload.ItemNames = get(message, 'properties.item_names');
+      payload.CheckoutURL = get(message, 'properties.checkout_url');
+      if (message.properties.items && Array.isArray(message.properties.items)) {
+        payload.Items = prepareItemsArray(message.properties.items);
+      }
+      break;
+    }
+    case 'Started Checkout': {
+      payload.$event_id = get(message, 'properties.order_id');
+      payload.$value = get(message, 'properties.value');
+      payload.Categories = get(message, categoryKey);
+      payload.CheckoutURL = get(message, 'properties.checkout_url');
+      payload.ItemNames = get(message, 'item_names');
+      if (message.properties.items && Array.isArray(message.properties.items)) {
+        payload.Items = prepareItemsArray(message.properties.items);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  if (payload) {
+    payload = removeUndefinedAndNullValues(payload);
+  }
+  return payload;
+};
+
+export default ecommEventPayload;

package/packages/analytics-js-integrations/src/integrations/LaunchDarkly/browser.js

@@ -0,0 +1,75 @@
+/* eslint-disable class-methods-use-this */
+import { ScriptLoader } from '@rudderstack/analytics-js-common/v1.1/utils/ScriptLoader';
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/LaunchDarkly/constants';
+import Logger from '../../utils/logger';
+import { createUser, getDestinationOptions } from './utils';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class LaunchDarkly {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.clientSideId = config.clientSideId;
+    this.anonymousUsersSharedKey = config.anonymousUsersSharedKey;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    if (!this.clientSideId) {
+      logger.error(
+        `${this.name} :: Unable to initialize destination - clientSideId is missing in config`,
+      );
+      return;
+    }
+    ScriptLoader(null, 'https://unpkg.com/launchdarkly-js-client-sdk@2');
+  }
+
+  isLoaded() {
+    return !!window.LDClient;
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  identify(rudderElement) {
+    const { message } = rudderElement;
+    const launchDarklyIntgConfig = getDestinationOptions(message.integrations);
+    const anonymousUsersSharedKey = launchDarklyIntgConfig?.key || this.anonymousUsersSharedKey;
+    this.launchDarklyUser = createUser(message, anonymousUsersSharedKey);
+
+    if (window.ldclient) {
+      window.ldclient.identify(this.launchDarklyUser);
+    } else {
+      window.ldclient = window.LDClient.initialize(this.clientSideId, this.launchDarklyUser);
+    }
+  }
+
+  track(rudderElement) {
+    const { event, properties } = rudderElement.message;
+    if (window.ldclient) {
+      window.ldclient.track(event, properties);
+    } else logger.error('track is not supported before identify');
+  }
+
+  alias(rudderElement) {
+    const { message } = rudderElement;
+    const newUser = { key: message.userId };
+
+    if (window.ldclient) {
+      window.ldclient.alias(newUser, this.launchDarklyUser);
+    } else logger.error('alias is not supported before identify');
+  }
+}
+export default LaunchDarkly;

package/packages/analytics-js-integrations/src/integrations/LaunchDarkly/index.js

@@ -0,0 +1 @@
+export { default as LaunchDarkly } from './browser';

package/packages/analytics-js-integrations/src/integrations/LaunchDarkly/utils.js

@@ -0,0 +1,40 @@
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/LaunchDarkly/constants';
+
+/**
+ * Get destination specific options from integrations options
+ * By default, it will return options for the destination using its display name
+ * If display name is not present, it will return options for the destination using its name
+ * The fallback is only for backward compatibility with SDK versions < v1.1
+ * @param {object} integrationsOptions Integrations options object
+ * @returns destination specific options
+ */
+const getDestinationOptions = integrationsOptions =>
+  integrationsOptions && (integrationsOptions[DISPLAY_NAME] || integrationsOptions[NAME]);
+
+const createUser = (message, anonymousUsersSharedKey = undefined) => {
+  const user = {
+    key: message.userId || message.anonymousId,
+  };
+  const { traits } = message.context;
+  if (traits.anonymous !== undefined) {
+    user.anonymous = traits.anonymous;
+    if (anonymousUsersSharedKey) user.key = anonymousUsersSharedKey;
+  }
+  if (traits.avatar !== undefined) user.avatar = traits.avatar;
+  if (traits.country !== undefined) user.country = traits.country;
+  if (traits.custom !== undefined) user.custom = traits.custom;
+  if (traits.email !== undefined) user.email = traits.email;
+  if (traits.firstName !== undefined) user.firstName = traits.firstName;
+  if (traits.ip !== undefined) user.ip = traits.ip;
+  if (traits.lastName !== undefined) user.lastName = traits.lastName;
+  if (traits.name !== undefined) user.name = traits.name;
+  if (traits.privateAttributeNames !== undefined)
+    user.privateAttributeNames = traits.privateAttributeNames;
+  if (traits.secondary !== undefined) user.secondary = traits.secondary;
+  return user;
+};
+
+export { getDestinationOptions, createUser };

package/packages/analytics-js-integrations/src/integrations/Lemnisk/browser.js

@@ -0,0 +1,81 @@
+/* eslint-disable class-methods-use-this */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Lemnisk/constants';
+import Logger from '../../utils/logger';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+class Lemnisk {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.accountId = config.accountId;
+    this.sdkWriteKey = config.sdkWriteKey;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    loadNativeSdk(this.accountId, this.sdkWriteKey);
+  }
+
+  isLoaded() {
+    return !!window.lmSMTObj;
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  identify(rudderElement) {
+    const userId = rudderElement.message.userId || rudderElement.message.anonymousId;
+    if (!userId) {
+      logger.error('user id is required');
+      return;
+    }
+    const { message } = rudderElement;
+    const context = message?.context || {};
+    const traits = context?.traits || {};
+    traits.isRudderEvents = true;
+    window.lmSMTObj.identify(userId, traits);
+  }
+
+  track(rudderElement) {
+    const { event, properties } = rudderElement.message;
+
+    if (!event) {
+      logger.error('Event name is missing');
+      return;
+    }
+    if (properties) {
+      properties.isRudderEvents = true;
+      window.lmSMTObj.track(event, properties);
+    } else {
+      window.lmSMTObj.track(event, { isRudderEvents: true });
+    }
+  }
+
+  page(rudderElement) {
+    const { name, properties } = rudderElement.message;
+    if (name && !properties) {
+      window.lmSMTObj.page(name, { isRudderEvents: true });
+    } else if (!name && properties) {
+      properties.isRudderEvents = true;
+      window.lmSMTObj.page(properties);
+    } else if (name && properties) {
+      properties.isRudderEvents = true;
+      window.lmSMTObj.page(name, properties);
+    } else {
+      window.lmSMTObj.page({ isRudderEvents: true });
+    }
+  }
+}
+export default Lemnisk;

package/packages/analytics-js-integrations/src/integrations/Lemnisk/index.js

@@ -0,0 +1 @@
+export { default as Lemnisk } from './browser';

package/packages/analytics-js-integrations/src/integrations/Lemnisk/nativeSdkLoader.js

@@ -0,0 +1,34 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadNativeSdk(accountId, sdkWriteKey) {
+  (function (window, tag, o, a, r) {
+    var methods = ['init', 'page', 'track', 'identify'];
+    window.lmSMTObj = window.lmSMTObj || [];
+
+    for (var i = 0; i < methods.length; i++) {
+      lmSMTObj[methods[i]] = (function (methodName) {
+        return function () {
+          lmSMTObj.push([methodName].concat(Array.prototype.slice.call(arguments)));
+        };
+      })(methods[i]);
+    }
+    // eslint-disable-next-line no-param-reassign
+    a = o.getElementsByTagName('head')[0];
+    // eslint-disable-next-line no-param-reassign
+    r = o.createElement('script');
+    r.setAttribute('data-loader', LOAD_ORIGIN);
+    r.type = 'text/javascript';
+    r.async = 1;
+    r.src = tag;
+    a.appendChild(r);
+  })(
+    window,
+    document.location.protocol === 'https:'
+      ? `https://cdn25.lemnisk.co/ssp/st/${accountId}.js`
+      : `http://cdn25.lemnisk.co/ssp/st/${accountId}.js`,
+    document,
+  );
+  window.lmSMTObj.init(sdkWriteKey);
+}
+
+export { loadNativeSdk };

package/packages/analytics-js-integrations/src/integrations/LinkedInInsightTag/browser.js

@@ -0,0 +1,79 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import { ScriptLoader } from '@rudderstack/analytics-js-common/v1.1/utils/ScriptLoader';
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/LinkedInInsightTag/constants';
+import { isDefinedAndNotNull } from '@rudderstack/analytics-js-common/utilities/checks';
+import Logger from '../../utils/logger';
+import { getHashFromArrayWithDuplicate } from '../../utils/commonUtils';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class LinkedInInsightTag {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.partnerId = config.partnerId;
+    this.eventToConversionIdMap = config.eventToConversionIdMap;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    ScriptLoader('LinkedIn Insight Tag', 'https://snap.licdn.com/li.lms-analytics/insight.min.js');
+    if (!this.partnerId) {
+      return;
+    }
+    window._linkedin_data_partner_id = this.partnerId;
+  }
+
+  isLoaded() {
+    return !!window._linkedin_data_partner_id;
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  track(rudderElement) {
+    const { message } = rudderElement;
+    const { event } = message;
+    if (!isDefinedAndNotNull(event)) {
+      logger.error('Event name is either null or undefined');
+      return;
+    }
+
+    if (typeof event !== 'string') {
+      logger.error('Event name should be a string');
+      return;
+    }
+
+    const trimmedEvent = event.trim();
+    const eventMapping = getHashFromArrayWithDuplicate(
+      this.eventToConversionIdMap,
+      'from',
+      'to',
+      false,
+    );
+    if (!eventMapping[trimmedEvent]) {
+      logger.error(
+        `The "${event}" event is not mapped in the destination dashboard. It'll be skipped`,
+      );
+      return;
+    }
+    const eventArray = eventMapping[trimmedEvent] || [];
+    eventArray.forEach(eventValue => {
+      window.lintrk('track', { conversion_id: eventValue });
+    });
+  }
+}
+
+export default LinkedInInsightTag;

package/packages/analytics-js-integrations/src/integrations/LinkedInInsightTag/index.js

@@ -0,0 +1 @@
+export { default as LinkedInInsightTag } from './browser';

package/packages/analytics-js-integrations/src/integrations/LiveChat/browser.js

@@ -0,0 +1,81 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import get from 'get-value';
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/LiveChat/constants';
+import Logger from '../../utils/logger';
+import { recordingLiveChatEvents } from './util';
+import { isObject } from '../../utils/utils';
+import { flattenJson } from '../../utils/commonUtils';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class LiveChat {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.licenseId = config.licenseId;
+    this.recordLiveChatEvents = config.recordLiveChatEvents;
+    this.eventsToStandard = config.eventsToStandard;
+    this.updateEventNames = config.updateEventNames;
+    this.eventsList = config.eventsList;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    loadNativeSdk(this.licenseId);
+  }
+
+  isLoaded() {
+    return !!(window.LiveChatWidget && isObject(window.LiveChatWidget));
+  }
+
+  isReady() {
+    // Dashboard Other Settings
+    if (this.recordLiveChatEvents) {
+      recordingLiveChatEvents(
+        this.updateEventNames,
+        this.eventsList,
+        this.eventsToStandard,
+        this.analytics,
+      );
+    }
+    return !!window.LiveChatWidget;
+  }
+
+  identify(rudderElement) {
+    const { message } = rudderElement;
+    const { userId, context } = message;
+    const { traits } = context;
+    const email = get(message, 'context.traits.email');
+
+    if (email) {
+      window.LiveChatWidget.call('set_customer_email', email);
+    } else {
+      logger.error('User parameter (email) ,required for identify call, not found');
+    }
+
+    const name = get(message, 'context.traits.name');
+
+    if (name) {
+      window.LiveChatWidget.call('set_customer_name', name);
+    }
+    if (traits) {
+      const flattenTraits = flattenJson(traits);
+      if (userId) flattenTraits.userId = userId;
+      window.LiveChatWidget.call('set_session_variables', flattenTraits);
+    }
+  }
+}
+
+export default LiveChat;

package/packages/analytics-js-integrations/src/integrations/LiveChat/index.js

@@ -0,0 +1 @@
+export { default as LiveChat } from './browser';

package/packages/analytics-js-integrations/src/integrations/LiveChat/nativeSdkLoader.js

@@ -0,0 +1,40 @@
+function loadNativeSdk(licenseId) {
+  window.__lc = window.__lc || {};
+  window.__lc.license = licenseId;
+  (function (n, t, c) {
+    function i(n) {
+      return e._h ? e._h.apply(null, n) : e._q.push(n);
+    }
+    var e = {
+      _q: [],
+      _h: null,
+      _v: '2.0',
+      on: function () {
+        i(['on', c.call(arguments)]);
+      },
+      once: function () {
+        i(['once', c.call(arguments)]);
+      },
+      off: function () {
+        i(['off', c.call(arguments)]);
+      },
+      get: function () {
+        if (!e._h) throw new Error("[LiveChatWidget] You can't use getters before load.");
+        return i(['get', c.call(arguments)]);
+      },
+      call: function () {
+        i(['call', c.call(arguments)]);
+      },
+      init: function () {
+        var n = t.createElement('script');
+        (n.async = !0),
+          (n.type = 'text/javascript'),
+          (n.src = 'https://cdn.livechatinc.com/tracking.js'),
+          t.head.appendChild(n);
+      },
+    };
+    !n.__lc.asyncInit && e.init(), (n.LiveChatWidget = n.LiveChatWidget || e);
+  })(window, document, [].slice);
+}
+
+export { loadNativeSdk };

package/packages/analytics-js-integrations/src/integrations/LiveChat/util.js

@@ -0,0 +1,71 @@
+/* eslint-disable func-names */
+import { getHashFromArray } from '../../utils/commonUtils';
+
+const integrationContext = {
+  name: 'LiveChat',
+  version: '1.0.0',
+};
+
+/**
+ * This function is used to trigger a callback.
+ * @param {*} standardEventsMap mapping of events done by the user
+ * @param {*} eventName standard event name
+ * @param {*} updateEventNames boolean variable to change eventName.
+ * @param {*} analytics rudderanalytics object
+ */
+const makeACall = (standardEventsMap, eventName, updateEventNames, analytics) => {
+  // Updating the event name with any mapping from the webapp if available else
+  // storing default event name in the updatedEvent
+  const updatedEvent =
+    standardEventsMap[eventName] && updateEventNames ? standardEventsMap[eventName] : eventName;
+
+  analytics.track(`${updatedEvent}`, {}, { context: { integration: integrationContext } });
+};
+
+const swapKeyValuePairs = standardEventsMap => {
+  const swappedEventsMap = {};
+  Object.keys(standardEventsMap).forEach(key => {
+    swappedEventsMap[standardEventsMap[key]] = key;
+  });
+  return swappedEventsMap;
+};
+
+/**
+ * This function has event listeners for the occurring events and to make a call for the event after
+ * collecting the data.
+ * @param {*} updateEventNames variable to Update event name .
+ * @param {*} userDefinedEventsList List of requested events by the user.
+ * @param {*} userDefinedEventsMapping Mapping of events in the webapp by the user
+ * @param {*} analytics rudderanalytics object
+ */
+function recordingLiveChatEvents(
+  updateEventNames,
+  userDefinedEventsList,
+  userDefinedEventsMapping,
+  analytics,
+) {
+  let standardEventsMap = getHashFromArray(userDefinedEventsMapping);
+  standardEventsMap = swapKeyValuePairs(standardEventsMap);
+  (function (api) {
+    [
+      'ready',
+      'new_event',
+      'form_submitted',
+      'greeting_hidden',
+      'rating_submitted',
+      'visibility_changed',
+      'greeting_displayed',
+      'availability_changed',
+      'customer_status_changed',
+      'rich_message_button_clicked',
+    ].forEach(eventName => {
+      if (userDefinedEventsList.includes(eventName)) {
+        api.on(eventName, () => {
+          makeACall(standardEventsMap, eventName, updateEventNames, analytics);
+        });
+      }
+    });
+  })(window.LiveChatWidget);
+}
+
+export { integrationContext, recordingLiveChatEvents };

package/packages/analytics-js-integrations/src/integrations/Lotame/LotameStorage.js

@@ -0,0 +1,21 @@
+import { Storage } from '@rudderstack/analytics-js-common/v1.1/utils/storage';
+
+const defaults = {
+  lotame_synch_time_key: 'lt_synch_timestamp',
+};
+
+class LotameStorage {
+  constructor() {
+    this.storage = Storage;
+  }
+
+  setLotameSynchTime(value) {
+    this.storage.setItem(defaults.lotame_synch_time_key, value);
+  }
+
+  getLotameSynchTime() {
+    return this.storage.getItem(defaults.lotame_synch_time_key);
+  }
+}
+const lotameStorage = new LotameStorage();
+export { lotameStorage as LotameStorage };