quakemap.bundle.js

var quakemap = (function (angular,rx) {
'use strict';

angular = 'default' in angular ? angular['default'] : angular;

var radioFilterSubject = new rx.BehaviorSubject();

/**
* @ngdoc directive
* @name dashboard.directive:map
* @description
* Description of the map directive.
*/

MapController.$inject = ['leaflet', 'quakesService'];
function MapController(L, quakesService) {
  var quakesStream = void 0;

  this.$onInit = function () {
    var map = L.map('map');
    var markers = {};
    var circles = {};

    var drawQuake = function drawQuake(quake) {
      var popupData = '' + '<h3>' + quake.place + '</h3>' + '<ul>' + '<li><strong>Time:</strong> ' + new Date(quake.time).toUTCString() + '</li>' + '<li><strong>Magnitude:</strong> ' + quake.mag + '</li>' + '</ul>';

      circles[quake.code] = L.circle([quake.lat, quake.lng], quake.mag * 1000).addTo(map);

      markers[quake.code] = L.marker([quake.lat, quake.lng]).addTo(map).bindPopup(popupData);
    };

    L.tileLayer('//{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
      attribution: '\n        &copy; <a href="http://osm.org/copyright">OpenStreetMap</a>\n        contributors\n      '
    }).addTo(map);

    map.setView([0, 0], 7);

    quakesStream = quakesService.getQuakesStream().subscribe(drawQuake);

    radioFilterSubject.subscribe(function (quake) {
      if (quake) {
        map.setView([quake.lat, quake.lng], 7);
      }
    });
  };

  this.$onDestroy = function () {
    quakesStream.dispose();
  };
}

var mapComponent = {
  template: '<div id="map">map</div>',
  controller: MapController,
  controllerAs: 'map',
  bindings: {}
};

var strongestSoFar = function strongestSoFar() {
  var acc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { mag: 0 };
  var val = arguments[1];

  return val.mag > acc.mag ? val : acc;
};

var latestSoFar = function latestSoFar() {
  var acc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
  var val = arguments[1];

  return val.time > acc.time ? val : acc;
};

/**
* @ngdoc directive
* @name dashboard.directive:viewSelector
* @description
* Description of the viewSelector directive.
*/
ViewSelectorController.$inject = ['quakesService', 'jquery'];
function ViewSelectorController(quakesService, $) {

  this.$onInit = function () {
    var quakesStream = quakesService.getQuakesStream();

    var $radios = $('[name="show-filter"]');
    var radioChanges = Rx.Observable.fromEvent($radios, 'change');

    var byValue = function byValue(event) {
      /* eslint no-invalid-this:0 */
      return this === event.target.value;
    };

    radioChanges.filter(byValue, 'mag').merge(quakesStream).scan(strongestSoFar).sample(250).subscribe(radioFilterSubject);

    radioChanges.filter(byValue, 'time').merge(quakesStream).scan(latestSoFar).sample(250)
    // skips the first value to let the mag observer value only to go through
    .skip(1).subscribe(radioFilterSubject);
  };

  this.$onDestroy = function () {};
}

var viewSelector = {
  template: '\n    <div class="show-filter">\n      <form>\n        <span class="filter-title"><strong>Show</strong></span>\n        <label class="radio-inline">\n          <input checked="true"\n            type="radio"\n            name="show-filter"\n            value="mag"> Strongest\n        </label>\n        <label class="radio-inline">\n          <input type="radio" name="show-filter" value="time"> Latest\n        </label>\n      </form>\n    </div>\n  ',
  controller: ViewSelectorController,
  controllerAs: 'viewSelector',
  bindings: {}
};

/**
* @ngdoc directive
* @name dashboard.directive:datatable
* @description
* Description of the datatable directive.
*/
datatable.$inject = ['$timeout', '$filter', 'quakesService'];
function datatable($timeout, $filter, quakesService) {

  var scope = {};

  function link($scope, $element) {
    var $table = $element.find('table');
    $scope.quakes = [];

    var quakesStream = quakesService.getQuakesStream();

    var dateFilter = $filter('date');
    var formatDate = function formatDate(quake) {
      return Object.assign({}, quake, {
        time: dateFilter(quake.time, 'MMM dd, yyyy - HH:mm UTCZ', String(quake.tz))
      });
    };

    quakesStream.bufferWithTime(500).filter(function (value) {
      return value.length;
    }).subscribe(function (quakes) {
      // Subsequent data stream will bring in only the new quakes we don't yet
      // have, therefore we concat the new data to the existing ones.
      $scope.quakes = $scope.quakes.concat(quakes.map(formatDate));
      $scope.$apply();

      /* eslint new-cap:0 */
      // Sorts the table by the magnitude column
      $table.DataTable().column('2:visible').order('desc').draw();
    });

    $scope.$on('$destroy', function () {
      quakesStream.dispose();
    });
  }

  return {
    restrict: 'E',
    template: '\n      <div>\n        <table datatable="ng" class="table table-striped table-hover">\n          <thead>\n            <tr>\n              <th>Location</th>\n              <th>Time</th>\n              <th>Magnitude</th>\n              <th></th>\n            </tr>\n          </thead>\n          <tbody>\n            <tr ng-repeat="quake in quakes">\n              <td>{{quake.place}}</td>\n              <td>{{quake.time}}</td>\n              <td>{{quake.mag}}</td>\n              <td><a href="{{quake.url}}" target="_blank">More details</a></td>\n            </tr>\n          </tbody>\n        </table>\n      </div>\n    ',
    scope: scope,
    link: link
  };
}

var FETCH_INTERVAL = 5000; //1800e+3; // every half hour

var QUAKE_URL =
//'//earthquake.usgs.gov/earthquakes/feed/v1.0/summary/all_day.geojson'
'all_day.geojsonp';

/**
* @ngdoc directive
* @name dashboard.directive:metadataInfo
* @description
* Description of the metadataInfo directive.
*/
MetadataInfoController.$inject = ['$timeout', '$interval', '$filter', 'quakesService'];
function MetadataInfoController($timeout, $interval, $filter, quakesService) {
  var _this = this;

  var onMetadataUpdate = void 0;

  this.$onInit = function () {
    var quakeStream = quakesService.getStreamMetadata();
    var dateFilter = $filter('date');
    var countdownPromise = void 0;

    onMetadataUpdate = quakeStream.subscribe(function (metadata) {
      // We must use a $timeout here to hook into the Angular digest cycle
      $timeout(function () {
        _this.lastUpdateTime = dateFilter(metadata.generated, 'MMM dd, yyyy - HH:mm UTCZ');
      });

      if (countdownPromise) {
        _this.updateCountdown = '00:00:00';
        $interval.cancel(countdownPromise);
      }

      countdownPromise = $interval(function (tickValue) {
        //this.updateCountdown = (FETCH_INTERVAL / 1000) - tickValue;
        _this.updateCountdown = dateFilter(FETCH_INTERVAL - tickValue * 1000, 'HH:mm:ss', '+000');
      }, 1000);
    });
  };

  this.$onDestroy = function () {
    onMetadataUpdate.dispose();
  };
}

var metadataInfo = {
  template: '\n    <span ng-show="metadataInfo.lastUpdateTime">\n      <strong>Last update: </strong>{{metadataInfo.lastUpdateTime}}\n       - <strong>Next update</strong>: {{metadataInfo.updateCountdown}}\n    </span>\n  ',
  controller: MetadataInfoController,
  controllerAs: 'metadataInfo',
  bindings: {}
};

quakesService.$inject = ['Rx'];
function quakesService(Rx) {

  var jsonStream = function jsonStream() {
    return Rx.DOM.jsonpRequest({
      url: QUAKE_URL,
      jsonpCallback: 'eqfeed_callback'
    });
  };

  var quakeStream = Rx.Observable.interval(FETCH_INTERVAL).startWith(1).flatMap(function () {
    return jsonStream();
  });

  function getStreamMetadata() {
    return quakeStream.flatMap(function (result) {
      return Rx.Observable.return(result.response.metadata);
      //return Rx.Observable.return({ generated: Date.now() });
    });
  }

  function getQuakesStream() {
    return quakeStream.flatMap(function (result) {
      return Rx.Observable.from(result.response.features);
    }).distinct(function (feature) {
      return feature.properties.code;
    }).map(function (feature) {
      return {
        lat: feature.geometry.coordinates[1],
        lng: feature.geometry.coordinates[0],
        mag: feature.properties.mag,
        code: feature.properties.code,
        place: feature.properties.place,
        url: feature.properties.url,
        time: feature.properties.time,
        tz: feature.properties.tz
      };
    }).filter(function (quake) {
      return quake.mag >= 1;
    });
  }

  return {
    getQuakesStream: getQuakesStream,
    getStreamMetadata: getStreamMetadata
  };
}

var dashboard = angular.module('dashboard', ['datatables']).factory('quakesService', quakesService).component('map', mapComponent).component('viewSelector', viewSelector).component('metadataInfo', metadataInfo).directive('datatable', datatable).name;

/**
* @ngdoc overview
* @name shims
* @description
* Description of the shims module.
*/
var shims = angular.module('shims', []).value('leaflet', window.L).value('Rx', window.Rx).value('jquery', window.jQuery).name;

var utils = angular.module('utils', []).name;

var quakemap = angular.module('quakemap', [shims, utils, dashboard]).name;

angular.bootstrap(document, [quakemap]);

return quakemap;

}(angular,Rx));

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":null,"sources":["app/dashboard/radioFilterSubject.js","app/dashboard/map.component.js","app/utils/quakesDataUtils.js","app/dashboard/view-selector.component.js","app/dashboard/datatable.component.js","app/settings.js","app/dashboard/metadata-info.component.js","app/dashboard/quakes.service.js","app/dashboard/dashboard.js","app/shims/shims.js","app/utils/utils.js","app/quakemap.js"],"sourcesContent":["import { BehaviorSubject } from 'rx';\n\nexport default new BehaviorSubject();\n","import radioFilterSubject from './radioFilterSubject';\n\n/**\n* @ngdoc directive\n* @name dashboard.directive:map\n* @description\n* Description of the map directive.\n*/\n\nMapController.$inject = ['leaflet', 'quakesService'];\nfunction MapController(L, quakesService){\n  let quakesStream;\n\n  this.$onInit = () => {\n    let map = L.map('map');\n    let markers = {};\n    let circles = {};\n\n    const drawQuake = (quake) => {\n      const popupData = '' +\n        '<h3>' + quake.place + '</h3>' +\n        '<ul>' +\n          '<li><strong>Time:</strong> ' +\n            new Date(quake.time).toUTCString() +\n          '</li>' +\n          '<li><strong>Magnitude:</strong> ' + quake.mag + '</li>' +\n        '</ul>';\n\n      circles[quake.code] = L.circle(\n        [quake.lat, quake.lng],\n        quake.mag * 1000\n      ).addTo(map);\n\n      markers[quake.code] = L.marker([quake.lat, quake.lng])\n        .addTo(map)\n        .bindPopup(popupData);\n    };\n\n\n    L.tileLayer('//{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {\n      attribution: `\n        &copy; <a href=\"http://osm.org/copyright\">OpenStreetMap</a>\n        contributors\n      `\n    }).addTo(map);\n\n    map.setView([0, 0], 7);\n\n    quakesStream = quakesService\n      .getQuakesStream()\n      .subscribe(drawQuake);\n\n    radioFilterSubject.subscribe((quake) => {\n      if (quake){\n        map.setView([quake.lat, quake.lng], 7);\n      }\n    });\n  };\n\n  this.$onDestroy = () => {\n    quakesStream.dispose();\n  };\n}\n\nconst mapComponent = {\n  template: '<div id=\"map\">map</div>',\n  controller: MapController,\n  controllerAs: 'map',\n  bindings: {}\n};\n\nexport default mapComponent;\n\n\n","export const strongestSoFar = (acc = { mag: 0 }, val) => {\n  return val.mag > acc.mag ? val : acc;\n};\n\nexport const latestSoFar = (acc = 0, val) => {\n  return val.time > acc.time ? val : acc;\n};\n","import { strongestSoFar, latestSoFar } from '../utils/quakesDataUtils';\nimport radioFilterSubject from './radioFilterSubject';\n\n/**\n* @ngdoc directive\n* @name dashboard.directive:viewSelector\n* @description\n* Description of the viewSelector directive.\n*/\nViewSelectorController.$inject = [\n  'quakesService',\n  'jquery'\n];\nfunction ViewSelectorController(quakesService, $){\n\n  this.$onInit = () => {\n    const quakesStream = quakesService.getQuakesStream();\n\n    const $radios = $('[name=\"show-filter\"]');\n    const radioChanges = Rx.Observable.fromEvent($radios, 'change');\n\n    const byValue = function(event){\n      /* eslint no-invalid-this:0 */\n      return this === event.target.value;\n    };\n\n    radioChanges\n      .filter(byValue, 'mag')\n      .merge(quakesStream)\n      .scan(strongestSoFar)\n      .sample(250)\n      .subscribe(radioFilterSubject);\n\n    radioChanges\n      .filter(byValue, 'time')\n      .merge(quakesStream)\n      .scan(latestSoFar)\n      .sample(250)\n      // skips the first value to let the mag observer value only to go through\n      .skip(1)\n      .subscribe(radioFilterSubject);\n  };\n\n  this.$onDestroy = () => {};\n}\n\nconst viewSelector = {\n  template: `\n    <div class=\"show-filter\">\n      <form>\n        <span class=\"filter-title\"><strong>Show</strong></span>\n        <label class=\"radio-inline\">\n          <input checked=\"true\"\n            type=\"radio\"\n            name=\"show-filter\"\n            value=\"mag\"> Strongest\n        </label>\n        <label class=\"radio-inline\">\n          <input type=\"radio\" name=\"show-filter\" value=\"time\"> Latest\n        </label>\n      </form>\n    </div>\n  `,\n  controller: ViewSelectorController,\n  controllerAs: 'viewSelector',\n  bindings: {}\n};\n\nexport default viewSelector;\n","/**\n* @ngdoc directive\n* @name dashboard.directive:datatable\n* @description\n* Description of the datatable directive.\n*/\ndatatable.$inject = ['$timeout', '$filter', 'quakesService'];\nfunction datatable($timeout, $filter, quakesService){\n\n  const scope = {};\n\n  function link($scope, $element){\n    const $table = $element.find('table');\n    $scope.quakes = [];\n\n    const quakesStream = quakesService.getQuakesStream();\n\n    const dateFilter = $filter('date');\n    const formatDate = (quake) => {\n      return Object.assign({}, quake, {\n        time: dateFilter(\n          quake.time,\n          'MMM dd, yyyy - HH:mm UTCZ',\n          String(quake.tz)\n        )\n      });\n    };\n\n    quakesStream\n      .bufferWithTime(500)\n      .filter((value) => value.length)\n      .subscribe((quakes) => {\n        // Subsequent data stream will bring in only the new quakes we don't yet\n        // have, therefore we concat the new data to the existing ones.\n        $scope.quakes = $scope.quakes.concat(quakes.map(formatDate));\n        $scope.$apply();\n\n        /* eslint new-cap:0 */\n        // Sorts the table by the magnitude column\n        $table.DataTable()\n          .column('2:visible')\n          .order('desc')\n          .draw();\n      });\n\n    $scope.$on('$destroy', () => {\n      quakesStream.dispose();\n    });\n  }\n\n  return {\n    restrict: 'E',\n    template: `\n      <div>\n        <table datatable=\"ng\" class=\"table table-striped table-hover\">\n          <thead>\n            <tr>\n              <th>Location</th>\n              <th>Time</th>\n              <th>Magnitude</th>\n              <th></th>\n            </tr>\n          </thead>\n          <tbody>\n            <tr ng-repeat=\"quake in quakes\">\n              <td>{{quake.place}}</td>\n              <td>{{quake.time}}</td>\n              <td>{{quake.mag}}</td>\n              <td><a href=\"{{quake.url}}\" target=\"_blank\">More details</a></td>\n            </tr>\n          </tbody>\n        </table>\n      </div>\n    `,\n    scope: scope,\n    link: link\n  };\n}\n\nexport default datatable;\n","export const FETCH_INTERVAL = 5000; //1800e+3; // every half hour\n\nexport const QUAKE_URL = (\n  //'//earthquake.usgs.gov/earthquakes/feed/v1.0/summary/all_day.geojson'\n  'all_day.geojsonp'\n);\n","import { FETCH_INTERVAL } from '../settings';\n\n/**\n* @ngdoc directive\n* @name dashboard.directive:metadataInfo\n* @description\n* Description of the metadataInfo directive.\n*/\nMetadataInfoController.$inject = [\n  '$timeout',\n  '$interval',\n  '$filter',\n  'quakesService'\n];\nfunction MetadataInfoController($timeout, $interval, $filter, quakesService){\n  let onMetadataUpdate;\n\n  this.$onInit = () => {\n    const quakeStream = quakesService.getStreamMetadata();\n    const dateFilter = $filter('date');\n    let countdownPromise;\n\n    onMetadataUpdate = quakeStream.subscribe((metadata) => {\n      // We must use a $timeout here to hook into the Angular digest cycle\n      $timeout(() => {\n        this.lastUpdateTime = dateFilter(\n          metadata.generated,\n          'MMM dd, yyyy - HH:mm UTCZ'\n        );\n      });\n\n      if (countdownPromise){\n        this.updateCountdown = '00:00:00';\n        $interval.cancel(countdownPromise);\n      }\n\n      countdownPromise = $interval((tickValue) => {\n        //this.updateCountdown = (FETCH_INTERVAL / 1000) - tickValue;\n        this.updateCountdown = dateFilter(\n          FETCH_INTERVAL - tickValue * 1000,\n          'HH:mm:ss',\n          '+000'\n        );\n      }, 1000);\n\n    });\n  };\n\n  this.$onDestroy = () => {\n    onMetadataUpdate.dispose();\n  };\n}\n\nconst metadataInfo = {\n  template: `\n    <span ng-show=\"metadataInfo.lastUpdateTime\">\n      <strong>Last update: </strong>{{metadataInfo.lastUpdateTime}}\n       - <strong>Next update</strong>: {{metadataInfo.updateCountdown}}\n    </span>\n  `,\n  controller: MetadataInfoController,\n  controllerAs: 'metadataInfo',\n  bindings: {}\n};\n\nexport default metadataInfo;\n","import { FETCH_INTERVAL, QUAKE_URL } from '../settings';\n\nquakesService.$inject = ['Rx'];\nfunction quakesService(Rx){\n\n  const jsonStream = () => {\n    return Rx.DOM.jsonpRequest({\n      url: QUAKE_URL,\n      jsonpCallback: 'eqfeed_callback'\n    });\n  };\n\n  const quakeStream = Rx.Observable\n      .interval(FETCH_INTERVAL)\n      .startWith(1)\n      .flatMap(() => jsonStream());\n\n  function getStreamMetadata(){\n    return quakeStream\n      .flatMap((result) => {\n        return Rx.Observable.return(result.response.metadata);\n        //return Rx.Observable.return({ generated: Date.now() });\n      });\n  }\n\n  function getQuakesStream(){\n    return quakeStream\n      .flatMap((result) => {\n        return Rx.Observable.from(result.response.features);\n      })\n      .distinct((feature) => {\n        return feature.properties.code;\n      })\n      .map((feature) => {\n        return {\n          lat: feature.geometry.coordinates[1],\n          lng: feature.geometry.coordinates[0],\n          mag: feature.properties.mag,\n          code: feature.properties.code,\n          place: feature.properties.place,\n          url: feature.properties.url,\n          time: feature.properties.time,\n          tz: feature.properties.tz\n        };\n      })\n      .filter((quake) => {\n        return quake.mag >= 1;\n      });\n  };\n\n  return {\n    getQuakesStream,\n    getStreamMetadata\n  };\n}\n\nexport default quakesService;\n","import angular from 'angular';\n\nimport mapComponent from './map.component';\nimport viewSelector from './view-selector.component';\nimport datatable from './datatable.component';\nimport metadataInfo from './metadata-info.component';\nimport quakesService from './quakes.service';\n\nconst dashboard = angular.module('dashboard', ['datatables'])\n  .factory('quakesService', quakesService)\n  .component('map', mapComponent)\n  .component('viewSelector', viewSelector)\n  .component('metadataInfo', metadataInfo)\n  .directive('datatable', datatable)\n  .name;\n\nexport default dashboard;\n","import angular from 'angular';\n\n/**\n* @ngdoc overview\n* @name shims\n* @description\n* Description of the shims module.\n*/\nconst shims = angular.module('shims', [])\n  .value('leaflet', window.L)\n  .value('Rx', window.Rx)\n  .value('jquery', window.jQuery)\n  .name;\n\nexport default shims;\n","import angular from 'angular';\n\nconst utils = angular.module('utils', [])\n  .name;\n\nexport default utils;\n","import angular from 'angular';\n\nimport dashboard from './dashboard/dashboard';\nimport shims from './shims/shims';\nimport utils from './utils/utils';\n\nconst quakemap = angular.module('quakemap', [\n    shims,\n    utils,\n    dashboard\n  ])\n  .name;\n\nangular.bootstrap(document, [quakemap]);\n\nexport default quakemap;\n"],"names":["BehaviorSubject","MapController","$inject","L","quakesService","quakesStream","$onInit","map","markers","circles","drawQuake","quake","popupData","place","Date","time","toUTCString","mag","code","circle","lat","lng","addTo","marker","bindPopup","tileLayer","setView","getQuakesStream","subscribe","$onDestroy","dispose","mapComponent","strongestSoFar","acc","val","latestSoFar","ViewSelectorController","$","$radios","radioChanges","Rx","Observable","fromEvent","byValue","event","target","value","filter","merge","scan","sample","radioFilterSubject","skip","viewSelector","datatable","$timeout","$filter","scope","link","$scope","$element","$table","find","quakes","dateFilter","formatDate","Object","assign","String","tz","bufferWithTime","length","concat","$apply","DataTable","column","order","draw","$on","FETCH_INTERVAL","QUAKE_URL","MetadataInfoController","$interval","onMetadataUpdate","quakeStream","getStreamMetadata","countdownPromise","metadata","lastUpdateTime","generated","updateCountdown","cancel","tickValue","metadataInfo","jsonStream","DOM","jsonpRequest","interval","startWith","flatMap","result","return","response","from","features","distinct","feature","properties","geometry","coordinates","url","dashboard","angular","module","factory","component","directive","name","shims","window","jQuery","utils","quakemap","bootstrap","document"],"mappings":"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"}