iureiure 1.0.0

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

@@ -0,0 +1,175 @@
+/* eslint-disable func-names */
+/* eslint-disable class-methods-use-this */
+/* eslint-disable no-undef */
+/* eslint-disable no-underscore-dangle */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Fullstory/constants';
+import Logger from '../../utils/logger';
+import camelcase from '../../utils/camelcase';
+import { getDestinationOptions } from './utils';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Fullstory {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.fs_org = config.fs_org;
+    this.fs_debug_mode = config.fs_debug_mode;
+    this.fs_host = config.fs_host || 'fullstory.com';
+    this.name = NAME;
+    this.analytics = analytics;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  static getFSProperties(properties) {
+    const fsProperties = {};
+    Object.keys(properties).forEach(key => {
+      fsProperties[key === 'displayName' || key === 'email' ? key : Fullstory.camelCaseField(key)] =
+        properties[key];
+    });
+    return fsProperties;
+  }
+
+  static camelCaseField(fieldName) {
+    // Do not camel case across type suffixes.
+    const parts = fieldName.split('_');
+    if (parts.length > 1) {
+      const typeSuffix = parts.pop();
+      switch (typeSuffix) {
+        case 'str':
+        case 'int':
+        case 'date':
+        case 'real':
+        case 'bool':
+        case 'strs':
+        case 'ints':
+        case 'dates':
+        case 'reals':
+        case 'bools':
+          return `${camelcase(parts.join('_'))}_${typeSuffix}`;
+        default: // passthrough
+      }
+    }
+    // No type suffix found. Camel case the whole field name.
+    return camelcase(fieldName);
+  }
+
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  init() {
+    loadNativeSdk(this.fs_debug_mode, this.fs_host, this.fs_org);
+    const fullstoryIntgConfig = getDestinationOptions(this.analytics.loadOnlyIntegrations);
+    // Checking if crossDomainSupport is their or not.
+    if (fullstoryIntgConfig?.crossDomainSupport === true) {
+      // This function will check if the customer hash is available or not in localStorage
+      window._fs_identity = function () {
+        if (window.localStorage) {
+          const { tata_customer_hash: tataCustomerHash } = window.localStorage;
+          if (tataCustomerHash) {
+            return {
+              uid: tataCustomerHash,
+              displayName: tataCustomerHash,
+            };
+          }
+        } else {
+          logger.info('Unable to access localStorage');
+        }
+
+        return null;
+      };
+
+      (function () {
+        function fs(api) {
+          if (!window._fs_namespace) {
+            logger.error(`FullStory unavailable, window["_fs_namespace"] must be defined`);
+            return undefined;
+          }
+          return api ? window[window._fs_namespace][api] : window[window._fs_namespace];
+        }
+        function waitUntil(predicateFn, callbackFn, timeout, timeoutFn) {
+          let totalTime = 0;
+          let delay = 64;
+          const resultFn = function () {
+            if (typeof predicateFn === 'function' && predicateFn()) {
+              callbackFn();
+              return;
+            }
+            delay = Math.min(delay * 2, 1024);
+            if (totalTime > timeout && timeoutFn) {
+              timeoutFn();
+            }
+            totalTime += delay;
+            setTimeout(resultFn, delay);
+          };
+          resultFn();
+        }
+        // Checking if timeout is provided or not.
+        const timeout = fullstoryIntgConfig.timeout || 2000;
+
+        function identify() {
+          if (typeof window._fs_identity === 'function') {
+            const userVars = window._fs_identity();
+            if (typeof userVars === 'object' && typeof userVars.uid === 'string') {
+              fs('setUserVars')(userVars);
+              fs('restart')();
+            } else {
+              fs('log')('error', 'FS.setUserVars requires an object that contains uid');
+            }
+          } else {
+            fs('log')('error', 'window["_fs_identity"] function not found');
+          }
+        }
+        fs('shutdown')();
+        waitUntil(window._fs_identity, identify, timeout, fs('restart'));
+      })();
+    }
+  }
+
+  isLoaded() {
+    return !!window.FS;
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  page(rudderElement) {
+
+    const rudderMessage = rudderElement.message;
+    const pageName = rudderMessage.name;
+    const props = {
+      name: pageName,
+      ...rudderMessage.properties,
+    };
+
+    window.FS.event('Viewed a Page', Fullstory.getFSProperties(props));
+  }
+
+  identify(rudderElement) {
+    let { userId } = rudderElement.message;
+    const { context, anonymousId } = rudderElement.message;
+    const { traits } = context;
+
+    if (!userId) userId = anonymousId;
+    if (Object.keys(traits).length === 0 && traits.constructor === Object)
+      window.FS.identify(userId);
+    else window.FS.identify(userId, Fullstory.getFSProperties(traits));
+  }
+
+  track(rudderElement) {
+    window.FS.event(
+      rudderElement.message.event,
+      Fullstory.getFSProperties(rudderElement.message.properties),
+    );
+  }
+}
+
+export default Fullstory;

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

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

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

@@ -0,0 +1,69 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadNativeSdk(fs_debug_mode, fs_host, fs_org) {
+  window._fs_debug = fs_debug_mode;
+  window._fs_host = fs_host;
+  window._fs_script = 'edge.fullstory.com/s/fs.js';
+  window._fs_org = fs_org;
+  window._fs_namespace = 'FS';
+
+  (function (m, n, e, t, l, o, g, y) {
+    if (e in m) {
+      if (m.console && m.console.log) {
+        m.console.log('FullStory namespace conflict. Please set window["_fs_namespace"].');
+      }
+      return;
+    }
+    g = m[e] = function (a, b, s) {
+      g.q ? g.q.push([a, b, s]) : g._api(a, b, s);
+    };
+    g.q = [];
+    o = n.createElement(t);
+    o.async = 1;
+    o.crossOrigin = 'anonymous';
+    o.src = `https://${_fs_script}`;
+    o.setAttribute('data-loader', LOAD_ORIGIN);
+    y = n.getElementsByTagName(t)[0];
+    y.parentNode.insertBefore(o, y);
+    g.identify = function (i, v, s) {
+      g(l, { uid: i }, s);
+      if (v) g(l, v, s);
+    };
+    g.setUserVars = function (v, s) {
+      g(l, v, s);
+    };
+    g.event = function (i, v, s) {
+      g('event', { n: i, p: v }, s);
+    };
+    g.shutdown = function () {
+      g('rec', !1);
+    };
+    g.restart = function () {
+      g('rec', !0);
+    };
+    g.log = function (a, b) {
+      g('log', [a, b]);
+    };
+    g.consent = function (a) {
+      g('consent', !arguments.length || a);
+    };
+    g.identifyAccount = function (i, v) {
+      o = 'account';
+      v = v || {};
+      v.acctId = i;
+      g(o, v);
+    };
+    g.clearUserCookie = function () {};
+    g._w = {};
+    y = 'XMLHttpRequest';
+    g._w[y] = m[y];
+    y = 'fetch';
+    g._w[y] = m[y];
+    if (m[y])
+      m[y] = function () {
+        return g._w[y].apply(this, arguments);
+      };
+  })(window, document, window._fs_namespace, 'script', 'user');
+}
+
+export { loadNativeSdk };

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

@@ -0,0 +1,17 @@
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Fullstory/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]);
+
+export { getDestinationOptions };