iureiure 1.0.0

package/packages/analytics-js-integrations/rollup.config.mjs

@@ -0,0 +1,151 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import path from "path";
+import babel from '@rollup/plugin-babel';
+import commonjs from '@rollup/plugin-commonjs';
+import resolve from '@rollup/plugin-node-resolve';
+import replace from '@rollup/plugin-replace';
+import terser from '@rollup/plugin-terser';
+import json from '@rollup/plugin-json';
+import { visualizer } from 'rollup-plugin-visualizer';
+import filesize from 'rollup-plugin-filesize';
+import typescript from 'rollup-plugin-typescript2';
+import nodePolyfills from 'rollup-plugin-polyfill-node';
+import { DEFAULT_EXTENSIONS } from '@babel/core';
+import alias from '@rollup/plugin-alias';
+import * as dotenv from 'dotenv';
+import pkg from './package.json' assert { type: 'json' };
+
+dotenv.config();
+
+const INTG_SUFFIX = '_RS';
+const isLegacyBuild = process.env.BROWSERSLIST_ENV !== 'modern';
+const variantSubfolder = isLegacyBuild ? '/legacy' : '/modern';
+const sourceMapType =
+  process.env.PROD_DEBUG === 'inline' ? 'inline' : process.env.PROD_DEBUG === 'true';
+const outDirNpmRoot = `dist/npm`;
+const outDirCDNRoot = `dist/cdn`;
+const outDirNpm = `${outDirNpmRoot}${variantSubfolder}/js-integrations`;
+const outDirCDN = `${outDirCDNRoot}${variantSubfolder}/js-integrations`;
+const distName = process.env.INTG_NAME;
+const modName = `${process.env.INTG_NAME}${INTG_SUFFIX}`;
+
+export function getOutputFilePath(dirPath, distName) {
+  const fileNamePrefix = `${distName}`;
+  const fileNameSuffix = process.env.PROD_DEBUG === 'inline' ? '-map' : '';
+  let outFilePath = '';
+
+  if (process.env.ENV === 'prod') {
+    outFilePath = `${dirPath}/${fileNamePrefix}${fileNameSuffix}.min.js`;
+  } else {
+    outFilePath = `${dirPath}/${fileNamePrefix}.js`;
+  }
+  return outFilePath;
+}
+
+export function getDefaultConfig(distName, moduleType = 'cdn') {
+  const version = process.env.VERSION || 'dev-snapshot';
+  // TODO: was: const moduleType = process.env.NPM === 'true' ? 'npm' : 'cdn';
+  const isNpmPackageBuild = moduleType === 'npm';
+  const isCDNPackageBuild = moduleType === 'cdn';
+  const sourceMapType =
+    process.env.PROD_DEBUG === 'inline' ? 'inline' : process.env.PROD_DEBUG === 'true';
+
+  return {
+    watch: {
+      include: ['src/**'],
+    },
+    external: [...Object.keys(pkg.peerDependencies || {})],
+    onwarn(warning, warn) {
+      // Silence 'this' has been rewritten to 'undefined' warning
+      // https://rollupjs.org/guide/en/#error-this-is-undefined
+      if (warning.code === 'THIS_IS_UNDEFINED') {
+        return;
+      }
+
+      warn(warning);
+    },
+    plugins: [
+      replace({
+        preventAssignment: true,
+        __PACKAGE_VERSION__: version,
+        __MODULE_TYPE__: moduleType,
+      }),
+      alias({
+        entries: [
+          {
+            find: '@rudderstack/analytics-js-common',
+            replacement: path.resolve('../analytics-js-common/src'),
+          }
+        ]
+      }),
+      nodePolyfills(),
+      resolve({
+        jsnext: true,
+        browser: true,
+        preferBuiltins: false,
+        extensions: ['.js', '.ts', '.mjs'],
+      }),
+      commonjs({
+        include: /node_modules/,
+        requireReturnsDefault: 'auto',
+      }),
+      json(),
+      typescript({
+        tsconfig: './tsconfig.json',
+        useTsconfigDeclarationDir: true,
+      }),
+      babel({
+        compact: true,
+        babelHelpers: 'bundled',
+        exclude: ['node_modules/@babel/**', 'node_modules/core-js/**'],
+        extensions: [...DEFAULT_EXTENSIONS, '.ts'],
+        sourcemap: sourceMapType,
+      }),
+      process.env.UGLIFY === 'true' &&
+        terser({
+          safari10: isLegacyBuild,
+          ecma: isLegacyBuild ? 2015 : 2017,
+          format: {
+            comments: false,
+          },
+        }),
+      filesize({
+        showBeforeSizes: 'build',
+        showBrotliSize: true,
+      }),
+      process.env.VISUALIZER === 'true' &&
+        visualizer({
+          filename: `./stats/${distName}.html`,
+          title: `Rollup Visualizer - ${distName}`,
+          sourcemap: true,
+          open: true,
+          gzipSize: true,
+          brotliSize: true,
+        })
+    ],
+  };
+}
+
+const outputFiles = [
+  {
+    file: getOutputFilePath(outDirCDN, distName),
+    format: 'iife',
+    name: modName,
+    sourcemap: sourceMapType,
+    generatedCode: {
+      preset: isLegacyBuild ? 'es5' : 'es2015',
+    },
+  },
+];
+
+const buildConfig = {
+  ...getDefaultConfig(distName),
+};
+
+export default [
+  {
+    ...buildConfig,
+    input: `src/integrations/${process.env.INTG_NAME}/index.js`,
+    output: outputFiles,
+  },
+];

package/packages/analytics-js-integrations/scripts/integrationBuildScript.js

@@ -0,0 +1,79 @@
+/* eslint-disable no-console */
+/* eslint-disable import/no-relative-packages */
+import { exec } from 'child_process';
+import { cpus } from 'os';
+import { configToIntNames } from '../../analytics-js-common/src/v1.1/utils/config_to_integration_names';
+
+const intgNamesArr = Object.values(configToIntNames);
+const totalIntgCount = intgNamesArr.length;
+let passCount = 0;
+let curInt = 0;
+const numCPUs = cpus().length;
+
+let numRunning = 0;
+let index = 0;
+
+// At any given time, create only processes for
+// max CPUs available
+// Intentionally using 1 less CPU and all cpus in github runner
+let maxAtOnce = numCPUs > 1 ? numCPUs - 1 : 1;
+
+console.log(`Environment is CI: ${process.env.CI || false}`);
+if (process.env.CI) {
+  maxAtOnce = numCPUs;
+}
+
+console.log(`Total CPUs to use: ${maxAtOnce}`);
+console.log(`Total integrations to build: ${totalIntgCount}`);
+console.log(`Maximum number of concurrent processes: ${maxAtOnce}`);
+
+function buildIntegrations() {
+  // if there are more waiting, run them
+  while (numRunning < maxAtOnce && index < totalIntgCount) {
+    numRunning += 1;
+    const intgName = intgNamesArr[index];
+    index += 1;
+
+    let cmd = `npm run build:integration:cli --intg=${intgName}`;
+
+    if (process.env.VISUALIZER === 'true') {
+      cmd = `npm run build:integration:bundle-size:cli --intg=${intgName}`;
+    }
+
+    // eslint-disable-next-line no-loop-func
+    exec(cmd, (error, stdout, stderr) => {
+      curInt += 1;
+      console.log(
+        `\nCompleted building integration: ${intgName} (${curInt} out of ${totalIntgCount})`,
+      );
+      console.log(stdout);
+      console.log(stderr);
+      if (error) {
+        console.log(`${intgName} build failed!!!`);
+        console.log('ERROR: ', error);
+      } else {
+        passCount += 1;
+      }
+      numRunning -= 1;
+
+      // Trigger more builds
+      buildIntegrations();
+    });
+  }
+
+  if (numRunning === 0) {
+    // All the integrations are built
+    console.log(`Final Status: ${passCount !== totalIntgCount ? 'FAILURE' : 'SUCCESS'}`);
+    console.log(
+      `Summary: ${passCount} out of ${totalIntgCount} integration builds were successful`,
+    );
+
+    if (passCount !== totalIntgCount) {
+      // Force exit to indicate failure
+      process.exit(1);
+    }
+  }
+}
+
+// Kickoff the builds
+buildIntegrations();

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

@@ -0,0 +1,53 @@
+/* eslint-disable class-methods-use-this */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/ActiveCampaign/constants';
+import get from 'get-value';
+import Logger from '../../utils/logger';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class ActiveCampaign {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.actId = config.actid;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    if (!this.actId) {
+      logger.error('actId is required');
+      return;
+    }
+    loadNativeSdk(this.actId);
+  }
+
+  isLoaded() {
+    return !!window.vgo;
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  page(rudderElement) {
+    const { message } = rudderElement;
+    const email = get(message, 'context.traits.email') || get(message, 'traits.email');
+
+    if (email) {
+      window.vgo('setEmail', email);
+    }
+    window.vgo('process');
+  }
+}
+
+export default ActiveCampaign;

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

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

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

@@ -0,0 +1,24 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadNativeSdk(actId) {
+  (function (e, t, o, n, p, r, i) {
+    e.visitorGlobalObjectAlias = n;
+    e[e.visitorGlobalObjectAlias] =
+      e[e.visitorGlobalObjectAlias] ||
+      function () {
+        (e[e.visitorGlobalObjectAlias].q = e[e.visitorGlobalObjectAlias].q || []).push(arguments);
+      };
+    e[e.visitorGlobalObjectAlias].l = new Date().getTime();
+    r = t.createElement('script');
+    r.src = o;
+    r.async = true;
+    r.setAttribute('data-loader', LOAD_ORIGIN);
+    i = t.getElementsByTagName('script')[0];
+    i.parentNode.insertBefore(r, i);
+  })(window, document, 'https://diffuser-cdn.app-us1.com/diffuser/diffuser.js', 'vgo');
+  window.vgo('setAccount', actId);
+  window.vgo('setTrackByDefault', true);
+  window.vgo('process');
+}
+
+export { loadNativeSdk };

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

@@ -0,0 +1,279 @@
+/* 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/AdobeAnalytics/constants';
+import Logger from '../../utils/logger';
+import * as utils from './util';
+import * as ecommUtils from './eCommHandle';
+import * as heartbeatUtils from './heartbeatHandle';
+import { getHashFromArray } from '../../utils/commonUtils';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class AdobeAnalytics {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.trackingServerUrl = config.trackingServerUrl || '';
+    this.reportSuiteIds = config.reportSuiteIds;
+    this.heartbeatTrackingServerUrl = config.heartbeatTrackingServerUrl || '';
+    this.eventsToTypes = config.eventsToTypes || [];
+    this.marketingCloudOrgId = config.marketingCloudOrgId || '';
+    this.dropVisitorId = config.dropVisitorId;
+    this.trackingServerSecureUrl = config.trackingServerSecureUrl || '';
+    this.timestampOption = config.timestampOption;
+    this.preferVisitorId = config.preferVisitorId;
+    this.rudderEventsToAdobeEvents = config.rudderEventsToAdobeEvents || [];
+    this.proxyNormalUrl = config.proxyNormalUrl;
+    this.proxyHeartbeatUrl = config.proxyHeartbeatUrl;
+    this.pageName = '';
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+    utils.setConfig(config);
+  }
+
+  init() {
+    // check if was already initialised. If yes then use already existing.
+    window.s_account = window.s_account || this.reportSuiteIds;
+    // update playhead value of a session
+    window.rudderHBPlayheads = {};
+    // load separately as heartbeat sdk is large and need not be required if this is off.
+    const heartbeatUrl =
+      this.proxyHeartbeatUrl ||
+      'https://cdn.rudderlabs.com/adobe-analytics-js/adobe-analytics-js-heartbeat.js';
+    const normalUrl =
+      this.proxyNormalUrl || 'https://cdn.rudderlabs.com/adobe-analytics-js/adobe-analytics-js.js';
+    if (this.heartbeatTrackingServerUrl) {
+      ScriptLoader('adobe-analytics-heartbeat', heartbeatUrl);
+      this.setIntervalHandler = setInterval(this.initAdobeAnalyticsClient.bind(this), 1000);
+    } else {
+      ScriptLoader('adobe-analytics-heartbeat', normalUrl);
+      this.setIntervalHandler = setInterval(this.initAdobeAnalyticsClient.bind(this), 1000);
+    }
+  }
+
+  initAdobeAnalyticsClient() {
+    const { s, Visitor } = window;
+    s.trackingServer = s.trackingServer || this.trackingServerUrl;
+    s.trackingServerSecure = s.trackingServerSecure || this.trackingServerSecureUrl;
+    if (this.marketingCloudOrgId && Visitor && typeof Visitor.getInstance === 'function') {
+      s.visitor = Visitor.getInstance(this.marketingCloudOrgId, {
+        trackingServer: s.trackingServer || this.trackingServerUrl,
+        trackingServerSecure: s.trackingServerSecure || this.trackingServerSecureUrl,
+      });
+    }
+  }
+
+  isLoaded() {
+    return !!(window.s_gi && window.s_gi !== Array.prototype.push);
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  page(rudderElement) {
+    // delete existing keys from widnow.s
+    utils.clearWindowSKeys(utils.getDynamicKeys());
+    // The pageName variable typically stores the name of a given page
+    let name;
+    if (rudderElement.message.name) {
+      name = rudderElement.message.name;
+    } else if (rudderElement.message.properties) {
+      name = rudderElement.message.properties.name;
+    }
+
+    this.pageName = name ? `Viewed Page ${name}` : 'Viewed Page';
+
+    window.s.pageName = this.pageName;
+
+    // The referrer variable overrides the automatically collected referrer in reports.
+    let referrer;
+    let url;
+    if (rudderElement.message.context && rudderElement.message.context.page) {
+      referrer = rudderElement.message.context.page.referrer;
+      url = rudderElement.message.context.page.url;
+    } else if (rudderElement.message.properties) {
+      referrer = rudderElement.message.properties.referrer;
+      url = rudderElement.message.properties.url;
+    }
+
+    window.s.referrer = referrer;
+
+    // if dropVisitorId is true visitorID will not be set
+    /** Cross-device visitor identification uses the visitorID variable to associate a user across devices.
+     *  The visitorID variable takes the highest priority when identifying unique visitors.
+     * Visitor deduplication is not retroactive: */
+    if (!this.dropVisitorId) {
+      const { userId } = rudderElement.message;
+      if (userId) {
+        if (this.timestampOption === 'disabled') {
+          window.s.visitorID = userId;
+        }
+        // If timestamp hybrid option and visitor id preferred is on visitorID is set
+        if (this.timestampOption === 'hybrid' && this.preferVisitorId) {
+          window.s.visitorID = userId;
+        }
+      }
+    }
+    // update values in window.s
+    utils.updateWindowSKeys(this.pageName, 'events');
+    utils.updateWindowSKeys(url, 'pageURL');
+    utils.updateCommonWindowSKeys(rudderElement, this.pageName);
+
+    utils.calculateTimestamp(rudderElement);
+
+    utils.handleContextData(rudderElement);
+    utils.handleEVars(rudderElement);
+    utils.handleHier(rudderElement);
+    utils.handleLists(rudderElement);
+    utils.handleCustomProps(rudderElement);
+    /** The t() method is an important core component to Adobe Analytics. It takes all Analytics variables defined on the page,
+     *  compiles them into an image request, and sends that data to Adobe data collection servers.
+     * */
+
+    window.s.t();
+  }
+
+  track(rudderElement) {
+    utils.clearWindowSKeys(utils.getDynamicKeys());
+    const { event } = rudderElement.message;
+    if (this.heartbeatTrackingServerUrl) {
+      const eventsToTypesHashmap = getHashFromArray(this.eventsToTypes);
+      const heartBeatFunction = eventsToTypesHashmap[event.toLowerCase()];
+      // process mapped video events
+
+      this.processHeartbeatMappedEvents(heartBeatFunction, rudderElement);
+    }
+    // process unmapped ecomm events
+    const isProcessed = this.checkIfRudderEcommEvent(rudderElement);
+    // process mapped events
+    if (!isProcessed) {
+      const rudderEventsToAdobeEventsHashmap = getHashFromArray(this.rudderEventsToAdobeEvents);
+      if (rudderEventsToAdobeEventsHashmap[event.toLowerCase()]) {
+        utils.processEvent(
+          rudderElement,
+          rudderEventsToAdobeEventsHashmap[event.toLowerCase()].trim(),
+          this.pageName,
+        );
+      }
+    }
+  }
+
+  /**
+   * @param  {} rudderElement
+   * @description Checks if the incoming rudder event is an Ecomm Event. Return true or false accordingly.
+   * DOC: https://docs.rudderstack.com/rudderstack-api-spec/rudderstack-ecommerce-events-specification
+   * @returns ret
+   */
+
+  checkIfRudderEcommEvent(rudderElement) {
+    const { event } = rudderElement.message;
+    let ret = true;
+    switch (event.toLowerCase()) {
+      case 'product viewed':
+      case 'product list viewed':
+        ecommUtils.productViewHandle(rudderElement, this.pageName);
+        break;
+      case 'product added':
+        ecommUtils.productAddedHandle(rudderElement, this.pageName);
+        break;
+      case 'product removed':
+        ecommUtils.productRemovedHandle(rudderElement, this.pageName);
+        break;
+      case 'order completed':
+        ecommUtils.orderCompletedHandle(rudderElement, this.pageName);
+        break;
+      case 'cart viewed':
+        ecommUtils.cartViewedHandle(rudderElement, this.pageName);
+        break;
+      case 'checkout started':
+        ecommUtils.checkoutStartedHandle(rudderElement, this.pageName);
+        break;
+      case 'cart opened':
+      case 'opened cart':
+        ecommUtils.cartOpenedHandle(rudderElement, this.pageName);
+        break;
+      default:
+        ret = false;
+    }
+    return ret;
+  }
+
+  /**
+   * @param  {} heartBeatFunction
+   * @param  {} rudderElement
+   *
+   * @description Function to process mapped video events in webapp with adobe video events.
+   */
+
+  processHeartbeatMappedEvents(heartBeatFunction, rudderElement) {
+    if (heartBeatFunction) {
+      switch (heartBeatFunction) {
+        case 'initHeartbeat':
+          heartbeatUtils.initHeartbeat(rudderElement);
+          break;
+        case 'heartbeatPlaybackStarted':
+        case 'heartbeatPlaybackResumed':
+        case 'heartbeatContentStarted':
+        case 'heartbeatVideoStart':
+          heartbeatUtils.heartbeatVideoStart(rudderElement);
+          break;
+        case 'heartbeatPlaybackPaused':
+        case 'heartbeatPlaybackInterrupted':
+        case 'heartbeatVideoPaused':
+          heartbeatUtils.heartbeatVideoPaused(rudderElement);
+          break;
+        case 'heartbeatContentComplete':
+        case 'heartbeatVideoComplete':
+          heartbeatUtils.heartbeatVideoComplete(rudderElement);
+          break;
+        case 'heartbeatSessionEnd':
+        case 'heartbeatPlaybackCompleted':
+          heartbeatUtils.heartbeatSessionEnd(rudderElement);
+          break;
+        case 'heartbeatAdStarted':
+        case 'heartbeatAdBreakStarted':
+          heartbeatUtils.heartbeatAdStarted(rudderElement);
+          break;
+        case 'heartbeatAdCompleted':
+        case 'heartbeatAdBreakCompleted':
+          heartbeatUtils.heartbeatAdCompleted(rudderElement);
+          break;
+        case 'heartbeatAdSkipped':
+          heartbeatUtils.heartbeatAdSkipped(rudderElement);
+          break;
+        case 'heartbeatSeekStarted':
+          heartbeatUtils.heartbeatSeekStarted(rudderElement);
+          break;
+        case 'heartbeatSeekCompleted':
+          heartbeatUtils.heartbeatSeekCompleted(rudderElement);
+          break;
+        case 'heartbeatBufferStarted':
+          heartbeatUtils.heartbeatBufferStarted(rudderElement);
+          break;
+        case 'heartbeatBufferCompleted':
+          heartbeatUtils.heartbeatBufferCompleted(rudderElement);
+          break;
+        case 'heartbeatQualityUpdated':
+          heartbeatUtils.heartbeatQualityUpdated(rudderElement);
+          break;
+        case 'heartbeatUpdatePlayhead':
+          heartbeatUtils.heartbeatUpdatePlayhead(rudderElement);
+          break;
+        default:
+          logger.error('No heartbeat function for this event');
+      }
+    }
+  }
+}
+
+export default AdobeAnalytics;

package/packages/analytics-js-integrations/src/integrations/AdobeAnalytics/eCommHandle.js

@@ -0,0 +1,56 @@
+import * as utils from './util';
+
+const productViewHandle = (rudderElement, pageName) => {
+  utils.clearWindowSKeys(utils.getDynamicKeys());
+  utils.processEvent(rudderElement, 'prodView', pageName);
+};
+
+const productAddedHandle = (rudderElement, pageName) => {
+  utils.clearWindowSKeys(utils.getDynamicKeys());
+  utils.processEvent(rudderElement, 'scAdd', pageName);
+};
+
+const productRemovedHandle = (rudderElement, pageName) => {
+  utils.clearWindowSKeys(utils.getDynamicKeys());
+  utils.processEvent(rudderElement, 'scRemove', pageName);
+};
+
+const orderCompletedHandle = (rudderElement, pageName) => {
+  utils.clearWindowSKeys(utils.getDynamicKeys());
+  const { properties } = rudderElement.message;
+  const { purchaseId, transactionId, order_id: orderId } = properties;
+  utils.updateWindowSKeys(purchaseId || orderId, 'purchaseID');
+  utils.updateWindowSKeys(transactionId || orderId, 'transactionID');
+
+  utils.processEvent(rudderElement, 'purchase', pageName);
+};
+
+const checkoutStartedHandle = (rudderElement, pageName) => {
+  utils.clearWindowSKeys(utils.getDynamicKeys());
+  const { properties } = rudderElement.message;
+  const { purchaseId, transactionId, order_id: orderId } = properties;
+  utils.updateWindowSKeys(purchaseId || orderId, 'purchaseID');
+  utils.updateWindowSKeys(transactionId || orderId, 'transactionID');
+
+  utils.processEvent(rudderElement, 'scCheckout', pageName);
+};
+
+const cartViewedHandle = (rudderElement, pageName) => {
+  utils.clearWindowSKeys(utils.getDynamicKeys());
+  utils.processEvent(rudderElement, 'scView', pageName);
+};
+
+const cartOpenedHandle = (rudderElement, pageName) => {
+  utils.clearWindowSKeys(utils.getDynamicKeys());
+  utils.processEvent(rudderElement, 'scOpen', pageName);
+};
+
+export {
+  productViewHandle,
+  productAddedHandle,
+  productRemovedHandle,
+  orderCompletedHandle,
+  checkoutStartedHandle,
+  cartViewedHandle,
+  cartOpenedHandle,
+};