angular-intercom.js

/**
 * @license angular-intercom
 * (c) 2014-2015 PatrickJS gdi2290.com
 * License: MIT
 */
(function (root, factory) {
  // AMD
  if (typeof define === 'function' && define.amd) {
    define(['angular'], function (angular) {
      return factory(root, angular, root.Intercom);
    });
  }
  // Node.js
  else if (typeof exports === 'object') {
    // Optional require in the intercom
    var intercom = null;
    try {
      intercom = require('intercom')
    } catch (error) {

    }
    module.exports = factory({}, require('angular'), intercom);
  }
  // Angular
  else if (angular) {
    factory(root, root.angular, root.Intercom);
  }
}(this, function (global, angular, Intercom) {
  'use strict';
  if (Intercom && global && !global.Intercom) { global.Intercom = Intercom; }

  function _capitalize_(string) {
    return (!string) ? '' : string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();
  }
  var intercomSettings = global.IntercomSettings || global.intercomSettings;

  var intercom_exist = false;
  // if intercom exist then reattach
  if (angular.isFunction(Intercom)) {
    global.Intercom('reattach_activator');
    if (intercomSettings) {
      global.Intercom('update', intercomSettings);
    }
    intercom_exist = true;
  } else {
    // build Intercom for async loading
    // see commented out code at the bottom for more details
    var build_intercom = function() {
      build_intercom.c(arguments);
    };
    build_intercom.q = [];
    build_intercom.c = function(args) {
      build_intercom.q.push(args);
    };
    global.Intercom = build_intercom;
  }
  var instance = false;

  // Create a script tag with moment as the source
  // and call our onScriptLoad callback when it
  // has been loaded
  function createScript(url, appID) {
    if (!document) { return; }
    var script = document.createElement('script');
    script.type = 'text/javascript';
    script.async = true;
    script.src = url+appID;
    // Attach the script tag to the document head
    var s = document.getElementsByTagName('head')[0];
    s.appendChild(script);
  }

  var config = {
    'asyncLoading': false,
    'scriptUrl': 'https://widget.intercom.io/widget/',// <INSERT APP_ID HERE>
    'appID': '',
    'development': false
  };

  // Allow constructor to be used for both $intercom and Intercom services
  function $IntercomProvider() {

    var provider = this;

    angular.forEach(config, function(val, key) {
      provider[key] = function(newValue) {
        config[key] = newValue || val;
        return provider;
      };
    });

    provider.$get = ['$rootScope', '$log', 'IntercomSettings', function($rootScope, $log, IntercomSettings) {
      // warn the user if they inject both $intercom and Intercom
      if (instance) {
        $log.warn('Please use consider using either $intercom or Intercom not both');
      }
      instance = true;

      var _options;
      var initializeOptions = function() {
        _options = {};
        // ensure appID is added to _options
        if (config.appID) {
          _options.app_id = _options.app_id || config.appID;
        }
        angular.extend(_options, IntercomSettings);
      };

      initializeOptions();

      if (intercom_exist) {
        global.Intercom('reattach_activator');
        global.Intercom('update', _options );
      }

      if (config.asyncLoading) {
        createScript(config.scriptUrl, config.appID);
      }


      function $intercom() {
        global.Intercom.apply(global.Intercom, arguments);
        return $intercom;
      }

      var methods = {
        boot: function(options) {
          angular.extend(_options, options || {});
          if (!_options.app_id && config.appID) {
            _options.app_id = config.appID;
          }
          if (options.app_id && options.app_id !== _options.app_id) {
            _options.app_id = options.app_id;
          }
          global.Intercom('boot', _options);
          return $intercom;
        },
        update: function(data) {
          if (data) {
            if (!data.app_id && config.appID) {
              data.app_id = config.appID;
            }
            if (data.app_id && data.app_id !== config.app_id) {
              config.app_id = data.app_id;
            }
            global.Intercom('update', data);
          } else {
            global.Intercom('update');
          }
          return $intercom;
        },
        trackEvent: function(eventName, data) {
          global.Intercom('trackEvent', eventName, data);
          return $intercom;
        },
        showMessages: function() {
          global.Intercom('showMessages');
          return $intercom;
        },
        showNewMessage: function(data) {
          if (data) {
            global.Intercom('showNewMessage', data);
          } else {
            global.Intercom('showNewMessage');
          }
          return $intercom;
        },
        hideMessages: function() {
          // Not sure this is even a real intercom api
          global.Intercom('hideMessages');
          return $intercom;
        },
        shutdown: function() {
          global.Intercom('shutdown');
          initializeOptions();
          return $intercom;
        },
        hide: function() {
          global.Intercom('hide');
          return $intercom;
        },
        show: function() {
          global.Intercom('show');
          return $intercom;
        },
        getVisitorId: function() {
          return global.Intercom('getVisitorId');
        },
        reattachActivator: function() {
          global.Intercom('reattach_activator');
          return $intercom;
        }
      };

      // this allows you to use methods prefixed with '$' to safe $apply on $rootScope
      /*
        $intercom.trackEvent( 'event', {data: 'data'});
        $intercom.$trackEvent('event', {data: 'data'}); // digest loop has been triggered
      */
      function buildMethod(func, method) {
        $intercom[method] = func;
        $intercom['$'+method] = function() {
          func.apply(Intercom, arguments);
          if (!$rootScope.$$phase) { $rootScope.$apply(); }
          return $intercom;
        };
      }

      angular.forEach(methods, buildMethod);

      // 3 events exposed by intercom allowing you to hook in callbacks
      var isEvent = {
        'show': true,
        'hide': true,
        'activatorClick': true
      };

      $intercom.$on = function(event, callback) {
        if (!isEvent[event]) { return; }
        global.Intercom('on'+_capitalize_(event), function() {
          if ($rootScope.$$phase) {
            callback();
          } else {
            $rootScope.$apply(callback);
          }
        });
        return $intercom;
      };

      $intercom.on = function(event, callback) {
        if (!isEvent[event]) { return; }
        global.Intercom('on'+_capitalize_(event), callback);
        return $intercom;
      };

      // experimental '$$defineMethod' method to extend $intercom
      $intercom.$$defineMethod = function(method) {
        if (!method) { return; }
        buildMethod(method, function() {
          var args = Array.prototype.slice.call(arguments);
          global.Intercom.apply(global.Intercom, args.unshift(method));
          return $intercom;
        });
      };

      return $intercom;
    }]; // end $get
  }

  angular.module('ngIntercom', [])
  // some people use .value  pattern to config their services
  .value('IntercomSettings', {})
  .provider('$intercom', $IntercomProvider)
  .provider('Intercom',  $IntercomProvider);

  // allow you to use either module
  angular.module('angular-intercom', ['ngIntercom']);

  return angular.module('ngIntercom');

  // Intercom's script break down
  /*
  (function(){
    // if intercom exist then reattach
    var _intercom = window.Intercom;
    if (typeof _intercom === "function" ) {
      _global.intercom('reattach_activator');
      _global.intercom('update', window.intercomSettings );
    } else {

      // build Intercom for async loading
      var intercom = function() {
        intercom.c(arguments);
      };
      intercom.q = [];
      intercom.c = function(args) {
        intercom.q.push(args);
      };
      window.Intercom = intercom;

      function listener() {
        var script = document.createElement('script');
        script.type = 'text/javascript';
        script.async = true;
        script.src='https://widget.intercom.io/widget/<INSERT APP_ID HERE>';
        var $script = document.getElementsByTagName('script')[0];
        $script.parentNode.insertBefore(script, $script);
      }

      if (window.attachEvent) {
        window.attachEvent('onload',listener);
      } else {
        window.addEventListener('load',listener,false);
      }
    }
  })();
  */
}));