@nbc-design/icons 50.0.0-alpha.4

package/browser.js

@@ -0,0 +1,843 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var assignDefaults = _interopDefault(require('lodash.defaults'));
+var merge = _interopDefault(require('lodash.merge'));
+var createLogger = _interopDefault(require('@nbc-studio/debug'));
+var pick = _interopDefault(require('lodash.pick'));
+var React = require('react');
+var React__default = _interopDefault(React);
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function (obj) {
+      return typeof obj;
+    };
+  } else {
+    _typeof = function (obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+  }
+
+  return _typeof(obj);
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly) symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    });
+    keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function (key) {
+        _defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+
+  return target;
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+
+  var key, i;
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
+
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+}
+
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
+}
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+
+    return arr2;
+  }
+}
+
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+function _iterableToArray(iter) {
+  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+}
+
+function _iterableToArrayLimit(arr, i) {
+  if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
+    return;
+  }
+
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _e = undefined;
+
+  try {
+    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance");
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance");
+}
+
+var STATE_KEY = '@@maui-analytics';
+var defaultState = {
+  hooks: {}
+};
+var getGlobalState = function getGlobalState() {
+  var _global = window || self || global;
+
+  var state = _global[STATE_KEY];
+
+  if (!state) {
+    _global[STATE_KEY] = defaultState;
+    return defaultState;
+  }
+
+  return state;
+};
+
+function registerHook(name, hook) {
+  getGlobalState().hooks[name] = hook;
+}
+function getRegisteredHooks() {
+  return getGlobalState().hooks;
+}
+function removeHook(name) {
+  var _getGlobalState = getGlobalState(),
+      hooks = _getGlobalState.hooks;
+
+  delete hooks[name];
+}
+function clearHooks() {
+  getGlobalState().hooks = {};
+}
+function executeHooks(event) {
+  var hooks = Object.values(getGlobalState().hooks);
+  return hooks.reduce(function (result, hook) {
+    return hook(result);
+  }, event);
+}
+var extendContext = function extendContext(context) {
+  return function (event) {
+    return _objectSpread2(_objectSpread2({}, event), {}, {
+      context: merge({}, event.context, typeof context === 'function' ? context(event) : context)
+    });
+  };
+};
+
+var TaggingActions = {
+  pageReady: 'PR',
+  pageLoad: 'PL',
+  pageError: 'PE',
+  formLaunch: 'FL',
+  scroll: 'SC',
+  toolLaunch: 'TL',
+  faqLaunch: 'FAQL',
+  faqScroll: 'FAQS',
+  faqSearch: 'FAQSC',
+  faqClose: 'FAQC',
+  faqOpen: 'FAQO',
+  chatLaunch: 'CL',
+  searchLaunch: 'SCL',
+  formError: 'FE',
+  roadblock: 'RB',
+  fieldFilled: 'FF',
+  helpDisplayed: 'HD',
+  clickToCall: 'CC',
+  clickToEmail: 'CE',
+  clickToShowPhone: 'CTP',
+  clickToShowEmail: 'CTE',
+  videoLaunch: 'VL',
+  clickCTA: 'CCTA'
+};
+
+var concat = function concat(items, separator) {
+  return items.filter(function (x) {
+    return x;
+  }).join(separator) || undefined;
+};
+
+var trimObject = function trimObject(source) {
+  var obj = source;
+  Object.keys(source).forEach(function (key) {
+    return obj[key] === undefined && delete obj[key];
+  });
+  return obj;
+};
+
+function formatUCSId(event) {
+  var _event$context = event.context,
+      ucsId = _event$context.ucsId,
+      formId = _event$context.formId;
+
+  if (typeof ucsId === 'string') {
+    return ucsId;
+  }
+
+  if (typeof ucsId === 'number') {
+    return formId ? "UCS".concat(ucsId.toString().padStart(4, '0'), "-").concat(formId) : "UCS".concat(ucsId.toString().padStart(4, '0'));
+  }
+
+  return undefined;
+}
+
+function getEventName(event) {
+  if (event.context.technicalError) {
+    return 'pageError';
+  }
+
+  if (event.type === 'state') {
+    return 'pageLoad';
+  }
+
+  if (event.context.roadblock) {
+    return 'roadblock';
+  }
+
+  if (event.context.formError) {
+    return 'formError';
+  }
+
+  if (event.context.fieldFilled) {
+    return 'fieldFilled';
+  }
+
+  if (event.context.helpText) {
+    return 'helpDisplayed';
+  }
+
+  return event.name;
+}
+
+function getEventId(event) {
+  var _event$context2 = event.context,
+      stepType = _event$context2.stepType,
+      fieldFilled = _event$context2.fieldFilled,
+      helpText = _event$context2.helpText,
+      formError = _event$context2.formError,
+      roadblock = _event$context2.roadblock,
+      technicalError = _event$context2.technicalError,
+      formId = _event$context2.formId;
+
+  if (!formId) {
+    return undefined;
+  }
+
+  if (technicalError) {
+    return "".concat(TaggingActions.pageError, "-").concat(formId);
+  }
+
+  if (roadblock) {
+    return "".concat(TaggingActions.roadblock, "-").concat(formId);
+  }
+
+  if (formError) {
+    return "".concat(TaggingActions.formError, "-").concat(formId);
+  }
+
+  if (fieldFilled) {
+    return "".concat(TaggingActions.fieldFilled, "-").concat(formId);
+  }
+
+  if (helpText) {
+    return "".concat(TaggingActions.helpDisplayed, "-").concat(formId);
+  }
+
+  if (event.type === 'action') {
+    var prefix = TaggingActions[event.name];
+    return prefix && "".concat(prefix, "-").concat(formId);
+  }
+
+  if (stepType === 'first') {
+    return "FS-".concat(formId);
+  }
+
+  if (stepType === 'last') {
+    return "FC-".concat(formId);
+  }
+
+  return "ST-".concat(formId);
+}
+
+var formatSeconds = function formatSeconds(ms) {
+  return "".concat(Math.round(ms / 100) / 10, "s");
+};
+
+var withTaggingPlan = function withTaggingPlan(defaults) {
+  return function (event) {
+    var type = event.type;
+
+    var _assignDefaults = assignDefaults({}, event.context, defaults),
+        ucsId = _assignDefaults.ucsId,
+        formId = _assignDefaults.formId,
+        stepType = _assignDefaults.stepType,
+        stepId = _assignDefaults.stepId,
+        stepName = _assignDefaults.stepName,
+        eventSource = _assignDefaults.eventSource,
+        eventSourceDetail = _assignDefaults.eventSourceDetail,
+        flowId = _assignDefaults.flowId,
+        fieldFilled = _assignDefaults.fieldFilled,
+        formError = _assignDefaults.formError,
+        lob = _assignDefaults.lob,
+        phoneDisplayed = _assignDefaults.phoneDisplayed,
+        technicalError = _assignDefaults.technicalError,
+        productCategory = _assignDefaults.productCategory,
+        productName = _assignDefaults.productName,
+        productPricing = _assignDefaults.productPricing,
+        promoDetail = _assignDefaults.promoDetail,
+        interaction = _assignDefaults.interaction,
+        loadTime = _assignDefaults.loadTime,
+        loadTimeout = _assignDefaults.loadTimeout,
+        timeOnStep = _assignDefaults.timeOnStep,
+        timeToComplete = _assignDefaults.timeToComplete,
+        roadblock = _assignDefaults.roadblock,
+        referenceId = _assignDefaults.referenceId,
+        customProps = _objectWithoutProperties(_assignDefaults, ["ucsId", "formId", "stepType", "stepId", "stepName", "eventSource", "eventSourceDetail", "flowId", "fieldFilled", "formError", "lob", "phoneDisplayed", "technicalError", "productCategory", "productName", "productPricing", "promoDetail", "interaction", "loadTime", "loadTimeout", "timeOnStep", "timeToComplete", "roadblock", "referenceId"]);
+
+    var getPageName = function getPageName(step) {
+      return concat([eventSource, lob, formId || eventSourceDetail, step], ':');
+    };
+
+    var payload = _objectSpread2({
+      ucsId: formatUCSId(event),
+      ucsState: type === 'state' ? 'pv' : 'non-pv',
+      eventName: getEventName(event),
+      eventSource: eventSource,
+      eventSourceDetail: eventSourceDetail,
+      eventTime: new Date(),
+      eventId: getEventId(event),
+      interaction: interaction || (type === 'action' ? event.name : undefined),
+      fieldFilled: fieldFilled,
+      pageName: getPageName(stepName),
+      lob: lob,
+      phoneDisplayed: phoneDisplayed,
+      technicalError: technicalError,
+      stepId: stepId,
+      stepName: stepName,
+      formId: formId,
+      flowId: flowId,
+      productCategory: productCategory,
+      productName: productName,
+      productPricing: productPricing,
+      promoDetail: promoDetail,
+      loadTime: loadTime ? formatSeconds(loadTime) : undefined,
+      loadTimeout: loadTimeout,
+      timeOnStep: timeOnStep ? formatSeconds(timeOnStep) : undefined,
+      timeToComplete: timeToComplete ? formatSeconds(timeToComplete) : undefined,
+      formError: formError,
+      roadblock: roadblock,
+      referenceId: referenceId
+    }, customProps);
+
+    var name = type === 'state' ? payload.pageName || 'untitled state' : payload.eventName || 'untitled action';
+    return {
+      type: type,
+      name: name,
+      context: trimObject(payload)
+    };
+  };
+};
+var enableTagging = function enableTagging(defaults) {
+  registerHook('tagging', withTaggingPlan(defaults));
+};
+var disableTagging = function disableTagging() {
+  removeHook('tagging');
+};
+
+var logger = createLogger('maui-analytics');
+logger.color = 'magenta';
+var debug = createLogger('maui-analytics:debug');
+debug.color = 'red';
+
+var launchMappings = {
+  eventInfo: {
+    ucsId: null,
+    ucsState: null,
+    eventName: null,
+    eventSource: null,
+    eventSourceDetail: null,
+    eventTime: null,
+    eventId: null,
+    interaction: undefined,
+    technicalError: undefined,
+    formError: undefined,
+    roadblock: undefined,
+    fieldFilled: undefined,
+    fieldAnswer: undefined,
+    helpText: undefined
+  },
+  page: {
+    pageName: null,
+    language: null,
+    loadTime: null,
+    lob: null,
+    breakPoints: undefined,
+    scrollPortion: undefined,
+    category: undefined,
+    phoneDisplayed: undefined
+  },
+  product: {
+    productCategory: null,
+    productName: null,
+    productPricing: null,
+    promoDetail: null
+  },
+  search: {
+    searchTerms: null,
+    searchResults: null,
+    searchMethod: null
+  },
+  offer: {
+    name: null,
+    position: null,
+    step: null,
+    action: null
+  },
+  step: {
+    stepName: null,
+    stepId: null,
+    formStatus: null,
+    formId: null,
+    flowId: null,
+    flowDetails: null,
+    timeOnStep: undefined,
+    timeToComplete: undefined
+  },
+  user: {
+    mauiId: undefined,
+    age: undefined,
+    gender: undefined,
+    postalCode: undefined,
+    province: undefined,
+    referenceId: null,
+    residencyStatus: undefined,
+    jobStatus: undefined,
+    accountUsage: undefined,
+    fundSource: undefined,
+    SINinput: undefined,
+    taxes: undefined,
+    applicantNumber: undefined,
+    applicantId: undefined,
+    loginMethod: null
+  }
+};
+
+var isEmpty = function isEmpty(source) {
+  return !(source && Object.keys(source).length > 0);
+};
+
+var trimObject$1 = function trimObject(source) {
+  var obj = source;
+  Object.keys(source).forEach(function (key) {
+    if (obj[key] === undefined) {
+      delete obj[key];
+    } else if (obj[key] !== null && _typeof(obj[key]) === 'object') {
+      trimObject(obj[key]);
+    }
+  });
+  return obj;
+};
+
+var mapContext = function mapContext(context, mappings) {
+  return pick(context, Object.keys(mappings).filter(function (key) {
+    return key in mappings;
+  }));
+};
+
+var formatDataLayer = function formatDataLayer(event) {
+  var mappings = merge({}, launchMappings);
+  var dataObject = {
+    eventInfo: _objectSpread2({}, mapContext(event.context, mappings.eventInfo)),
+    page: _objectSpread2({}, mapContext(event.context, mappings.page)),
+    product: _objectSpread2({}, mapContext(event.context, mappings.product)),
+    search: _objectSpread2({}, mapContext(event.context, mappings.search)),
+    offer: _objectSpread2({}, mapContext(event.context, mappings.offer)),
+    step: _objectSpread2({}, mapContext(event.context, mappings.step)),
+    user: _objectSpread2(_objectSpread2({}, mapContext(event.context, mappings.user)), {}, {
+      loggedStatus: Boolean(event.context.mauiId)
+    }),
+    event: event.type === 'state' ? 'trackPageView' : 'trackEvent'
+  };
+  var filteredObject = Object.entries(dataObject).reduce(function (prev, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+        key = _ref2[0],
+        value = _ref2[1];
+
+    if (!isEmpty(value)) {
+      return _objectSpread2(_objectSpread2({}, prev), {}, _defineProperty({}, key, value));
+    }
+
+    return prev;
+  }, {});
+
+  if (event.type === 'state' && !event.context.technicalError) {
+    var template = trimObject$1(_objectSpread2({}, mappings));
+    return merge({}, template, filteredObject);
+  }
+
+  return filteredObject;
+};
+
+function track(event) {
+  var dataLayer = formatDataLayer(event);
+
+  if (process.env.NODE_ENV === 'production' || process.env.NODE_ENV === 'test') {
+    if (typeof window.dataLayer === 'undefined') {
+      window.dataLayer = [];
+    }
+
+    window.dataLayer.push(dataLayer);
+  } else {
+    if (!window.mockDataLayer) {
+      window.mockDataLayer = [];
+      window.mockDataLayer.computedState = {};
+    }
+
+    window.mockDataLayer.push(dataLayer);
+    merge(window.mockDataLayer.computedState, dataLayer);
+    logger('dataLayer', dataLayer);
+  }
+}
+
+function trackState(page, context) {
+  var event = {
+    type: 'state',
+    name: page,
+    context: context
+  };
+  logger("trackState:".concat(page), context);
+  track(executeHooks(event));
+}
+function trackAction(action, context) {
+  var event = {
+    type: 'action',
+    name: action,
+    context: context
+  };
+  logger("trackAction:".concat(action), context);
+  track(executeHooks(event));
+}
+
+var ReactTaggingContext = React.createContext({});
+ReactTaggingContext.displayName = 'TaggingContext';
+var Tagging = function Tagging(props) {
+  var parent = React.useContext(ReactTaggingContext);
+
+  var children = props.children,
+      overrides = _objectWithoutProperties(props, ["children"]);
+
+  return React__default.createElement(ReactTaggingContext.Provider, {
+    value: _objectSpread2(_objectSpread2({}, parent), overrides)
+  }, children);
+};
+
+var TaggingFormContext = React.createContext({
+  formTime: undefined,
+  stepTime: undefined,
+  pushStep: function pushStep() {
+    return 0;
+  }
+});
+TaggingFormContext.displayName = 'TaggingFormContext';
+var TaggingForm = function TaggingForm(props) {
+  var _useState = React.useState(Date.now()),
+      _useState2 = _slicedToArray(_useState, 1),
+      formTime = _useState2[0];
+
+  var _useState3 = React.useState(0),
+      _useState4 = _slicedToArray(_useState3, 2),
+      stepTime = _useState4[0],
+      setStepStartTime = _useState4[1];
+
+  var _useState5 = React.useState([]),
+      _useState6 = _slicedToArray(_useState5, 2),
+      steps = _useState6[0],
+      setSteps = _useState6[1];
+
+  var pushStep = function pushStep(step) {
+    var nextSteps = steps;
+    setStepStartTime(Date.now());
+
+    if (!steps.includes(step)) {
+      nextSteps = [].concat(_toConsumableArray(steps), [step]);
+      setSteps(nextSteps);
+    }
+
+    return nextSteps.indexOf(step);
+  };
+
+  var children = props.children,
+      context = _objectWithoutProperties(props, ["children"]);
+
+  return React__default.createElement(Tagging, Object.assign({}, context), React__default.createElement(TaggingFormContext.Provider, {
+    value: {
+      formTime: formTime,
+      stepTime: stepTime,
+      pushStep: pushStep
+    }
+  }, children));
+};
+
+var TaggingStep = function TaggingStep(_ref) {
+  var children = _ref.children,
+      props = _objectWithoutProperties(_ref, ["children"]);
+
+  var _useContext = React.useContext(TaggingFormContext),
+      pushStep = _useContext.pushStep;
+
+  var stepIndex = React.useMemo(function () {
+    return pushStep(props.stepName);
+  }, [props.stepName]);
+  return React__default.createElement(Tagging, Object.assign({}, props, {
+    stepId: props.stepId || stepIndex + 1,
+    stepType: props.stepType || (stepIndex === 0 ? 'first' : 'step')
+  }), children);
+};
+
+var useTagging = function useTagging() {
+  var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var parent = React.useContext(ReactTaggingContext);
+  var form = React.useContext(TaggingFormContext);
+
+  var merged = _objectSpread2(_objectSpread2({}, parent), context);
+
+  var tagging = _objectSpread2(_objectSpread2({}, merged), {}, {
+    timeOnStep: merged.timeOnStep || (form.stepTime ? Date.now() - form.stepTime : undefined),
+    timeToComplete: merged.timeToComplete || (form.formTime && merged.stepType === 'last' ? Date.now() - form.formTime : undefined)
+  });
+
+  return {
+    context: tagging,
+    trackState: function trackState$1(name, params) {
+      trackState(name, _objectSpread2(_objectSpread2({}, tagging), params));
+    },
+    trackAction: function trackAction$1(name, params) {
+      trackAction(name, _objectSpread2(_objectSpread2({}, tagging), params));
+    }
+  };
+};
+
+var TrackAction = function TrackAction(_ref) {
+  var children = _ref.children,
+      _ref$type = _ref.type,
+      type = _ref$type === void 0 ? 'clickCTA' : _ref$type,
+      _ref$dependencies = _ref.dependencies,
+      dependencies = _ref$dependencies === void 0 ? [] : _ref$dependencies,
+      props = _objectWithoutProperties(_ref, ["children", "type", "dependencies"]);
+
+  var _useTagging = useTagging(props),
+      context = _useTagging.context,
+      trackAction = _useTagging.trackAction;
+
+  var name = type;
+
+  if (context.technicalError) {
+    name = 'pageError';
+  } else if (context.roadblock) {
+    name = 'roadblock';
+  } else if (context.formError) {
+    name = 'formError';
+  } else if (context.fieldFilled) {
+    name = 'fieldFilled';
+  } else if (context.helpText) {
+    name = 'helpDisplayed';
+  }
+
+  React.useEffect(function () {
+    return trackAction(name);
+  }, dependencies);
+  return React__default.createElement(React__default.Fragment, null, children);
+};
+
+var TrackingTimer = function TrackingTimer(_ref) {
+  var finished = _ref.finished,
+      timeout = _ref.timeout,
+      children = _ref.children;
+  var startTime = React.useMemo(Date.now, []);
+
+  var _useState = React.useState(0),
+      _useState2 = _slicedToArray(_useState, 2),
+      stopTime = _useState2[0],
+      setStop = _useState2[1];
+
+  var _useState3 = React.useState(false),
+      _useState4 = _slicedToArray(_useState3, 2),
+      timedOut = _useState4[0],
+      setTimedOut = _useState4[1];
+
+  var stopTimer = function stopTimer() {
+    return setStop(Date.now());
+  };
+
+  React.useEffect(function () {
+    var timer;
+
+    if (!finished) {
+      timer = setTimeout(function () {
+        setTimedOut(true);
+        stopTimer();
+      }, timeout);
+    } else {
+      stopTimer();
+    }
+
+    return function () {
+      if (timer) {
+        clearTimeout(timer);
+        stopTimer();
+      }
+    };
+  }, [finished]);
+
+  if (!stopTime) {
+    return null;
+  }
+
+  return React__default.createElement(Tagging, {
+    loadTime: stopTime - startTime,
+    loadTimeout: timedOut ? true : undefined
+  }, children);
+};
+
+function getStateName(_ref) {
+  var formId = _ref.formId,
+      stepId = _ref.stepId,
+      stepName = _ref.stepName;
+
+  if (formId && stepName) {
+    return "".concat(formId, ".").concat(stepName);
+  }
+
+  return stepName || stepId ? "step".concat(stepId) : 'untitled state';
+}
+var TrackState = function TrackState(_ref2) {
+  var children = _ref2.children,
+      _ref2$dependencies = _ref2.dependencies,
+      dependencies = _ref2$dependencies === void 0 ? [] : _ref2$dependencies,
+      props = _objectWithoutProperties(_ref2, ["children", "dependencies"]);
+
+  var _useTagging = useTagging(props),
+      trackState = _useTagging.trackState,
+      context = _useTagging.context;
+
+  React.useEffect(function () {
+    return trackState(getStateName(context));
+  }, dependencies);
+  return React__default.createElement(React__default.Fragment, null, children);
+};
+
+enableTagging();
+
+exports.Tagging = Tagging;
+exports.TaggingActions = TaggingActions;
+exports.TaggingForm = TaggingForm;
+exports.TaggingStep = TaggingStep;
+exports.TrackAction = TrackAction;
+exports.TrackState = TrackState;
+exports.TrackingTimer = TrackingTimer;
+exports.clearHooks = clearHooks;
+exports.disableTagging = disableTagging;
+exports.enableTagging = enableTagging;
+exports.executeHooks = executeHooks;
+exports.extendContext = extendContext;
+exports.getRegisteredHooks = getRegisteredHooks;
+exports.registerHook = registerHook;
+exports.removeHook = removeHook;
+exports.trackAction = trackAction;
+exports.trackState = trackState;
+exports.useTagging = useTagging;