From 7823369cae4bc2146b796df1d97c840c6df0316c Mon Sep 17 00:00:00 2001
From: Jen Huang <its.jenetic@gmail.com>
Date: Tue, 21 Aug 2018 22:31:26 -0700
Subject: [PATCH 1/7] Add `default` and `baseInterval` configuration ability to
 date histogram EditorConfig

---
 packages/kbn-datemath/src/index.js            |  18 ++-
 .../agg_types/buckets/date_histogram.js       |   5 +
 .../agg_types/controls/time_interval.html     |   3 +-
 .../public/utils/__tests__/parse_interval.js  | 141 +++++++++++-------
 src/ui/public/utils/parse_interval.js         |  29 ++++
 src/ui/public/validate_date_interval.js       |  20 ++-
 .../__tests__/lib/least_common_interval.ts    |  96 ++++++++++++
 .../editors/config/editor_config_providers.ts |  43 +++++-
 src/ui/public/vis/editors/config/types.ts     |  11 +-
 .../public/vis/editors/default/agg_params.js  |  19 ++-
 .../public/vis/lib/least_common_interval.ts   |  78 ++++++++++
 11 files changed, 399 insertions(+), 64 deletions(-)
 create mode 100644 src/ui/public/vis/__tests__/lib/least_common_interval.ts
 create mode 100644 src/ui/public/vis/lib/least_common_interval.ts

diff --git a/packages/kbn-datemath/src/index.js b/packages/kbn-datemath/src/index.js
index 17d91a530fdb38..f82a4324662700 100644
--- a/packages/kbn-datemath/src/index.js
+++ b/packages/kbn-datemath/src/index.js
@@ -19,9 +19,20 @@
 
 import moment from 'moment';
 
-const units = ['y', 'M', 'w', 'd', 'h', 'm', 's', 'ms'];
-const unitsDesc = units;
-const unitsAsc = [...unitsDesc].reverse();
+const unitsMap = {
+  ms: { weight: 1, type: 'fixed', base: 1 },
+  s: { weight: 2, type: 'fixed', base: 1000 },
+  m: { weight: 3, type: 'mixed', base: 1000 * 60 },
+  h: { weight: 4, type: 'mixed', base: 1000 * 60 * 60 },
+  d: { weight: 5, type: 'mixed', base: 1000 * 60 * 60 * 24 },
+  w: { weight: 6, type: 'calendar' },
+  M: { weight: 7, type: 'calendar' },
+  q: { weight: 8, type: 'calendar' },
+  y: { weight: 9, type: 'calendar' },
+};
+const units = Object.keys(unitsMap);
+const unitsDesc = [...units].reverse();
+const unitsAsc = [...units];
 
 const isDate = d => Object.prototype.toString.call(d) === '[object Date]';
 
@@ -142,6 +153,7 @@ function parseDateMath(mathString, time, roundUp) {
 
 export default {
   parse: parse,
+  unitsMap: Object.freeze(unitsMap),
   units: Object.freeze(units),
   unitsAsc: Object.freeze(unitsAsc),
   unitsDesc: Object.freeze(unitsDesc),
diff --git a/src/ui/public/agg_types/buckets/date_histogram.js b/src/ui/public/agg_types/buckets/date_histogram.js
index c9c26689f3d539..c80afd6d38851c 100644
--- a/src/ui/public/agg_types/buckets/date_histogram.js
+++ b/src/ui/public/agg_types/buckets/date_histogram.js
@@ -147,6 +147,11 @@ export const dateHistogramBucketAgg = new BucketAggType({
         return isDefaultTimezone ? detectedTimezone || tzOffset : config.get('dateFormat:tz');
       },
     },
+    {
+      name: 'intervalBase',
+      default: undefined,
+      write: _.noop
+    },
     {
       name: 'customInterval',
       default: '2h',
diff --git a/src/ui/public/agg_types/controls/time_interval.html b/src/ui/public/agg_types/controls/time_interval.html
index 1da3e3ddcd39be..4c5ae05dafa914 100644
--- a/src/ui/public/agg_types/controls/time_interval.html
+++ b/src/ui/public/agg_types/controls/time_interval.html
@@ -9,6 +9,7 @@
     ></icon-tip>
   </label>
   <select
+    ng-if="!agg.params.intervalBase"
     id="visEditorInterval{{agg.id}}"
     ng-model="agg.params.interval"
     ng-change="agg.write()"
@@ -23,7 +24,7 @@
     type="text"
     name="customInterval"
     ng-model="agg.params.customInterval"
-    validate-date-interval
+    validate-date-interval="{{agg.params.intervalBase}}"
     ng-change="aggForm.customInterval.$valid && agg.write()"
     ng-if="agg.params.interval.val == 'custom'"
     class="form-control"
diff --git a/src/ui/public/utils/__tests__/parse_interval.js b/src/ui/public/utils/__tests__/parse_interval.js
index b068ce170e1284..23a05c272a2b4f 100644
--- a/src/ui/public/utils/__tests__/parse_interval.js
+++ b/src/ui/public/utils/__tests__/parse_interval.js
@@ -17,77 +17,118 @@
  * under the License.
  */
 
-import { parseInterval } from '../parse_interval';
+import { parseInterval, parseEsInterval } from '../parse_interval';
 import expect from 'expect.js';
 
 describe('parseInterval', function () {
-  it('should correctly parse an interval containing unit and value', function () {
-    let duration = parseInterval('1d');
-    expect(duration.as('d')).to.be(1);
 
-    duration = parseInterval('2y');
-    expect(duration.as('y')).to.be(2);
+  describe('parseInterval()', function () {
+    it('should correctly parse an interval containing unit and value', function () {
+      let duration = parseInterval('1d');
+      expect(duration.as('d')).to.be(1);
 
-    duration = parseInterval('5M');
-    expect(duration.as('M')).to.be(5);
+      duration = parseInterval('2y');
+      expect(duration.as('y')).to.be(2);
 
-    duration = parseInterval('5m');
-    expect(duration.as('m')).to.be(5);
+      duration = parseInterval('5M');
+      expect(duration.as('M')).to.be(5);
 
-    duration = parseInterval('250ms');
-    expect(duration.as('ms')).to.be(250);
+      duration = parseInterval('5m');
+      expect(duration.as('m')).to.be(5);
 
-    duration = parseInterval('100s');
-    expect(duration.as('s')).to.be(100);
+      duration = parseInterval('250ms');
+      expect(duration.as('ms')).to.be(250);
 
-    duration = parseInterval('23d');
-    expect(duration.as('d')).to.be(23);
+      duration = parseInterval('100s');
+      expect(duration.as('s')).to.be(100);
 
-    duration = parseInterval('52w');
-    expect(duration.as('w')).to.be(52);
-  });
+      duration = parseInterval('23d');
+      expect(duration.as('d')).to.be(23);
 
-  it('should correctly parse fractional intervals containing unit and value', function () {
-    let duration = parseInterval('1.5w');
-    expect(duration.as('w')).to.be(1.5);
+      duration = parseInterval('52w');
+      expect(duration.as('w')).to.be(52);
+    });
 
-    duration = parseInterval('2.35y');
-    expect(duration.as('y')).to.be(2.35);
-  });
+    it('should correctly parse fractional intervals containing unit and value', function () {
+      let duration = parseInterval('1.5w');
+      expect(duration.as('w')).to.be(1.5);
 
-  it('should correctly bubble up intervals which are less than 1', function () {
-    let duration = parseInterval('0.5y');
-    expect(duration.as('d')).to.be(183);
+      duration = parseInterval('2.35y');
+      expect(duration.as('y')).to.be(2.35);
+    });
 
-    duration = parseInterval('0.5d');
-    expect(duration.as('h')).to.be(12);
-  });
+    it('should correctly bubble up intervals which are less than 1', function () {
+      let duration = parseInterval('0.5y');
+      expect(duration.as('d')).to.be(183);
 
-  it('should correctly parse a unit in an interval only', function () {
-    let duration = parseInterval('ms');
-    expect(duration.as('ms')).to.be(1);
+      duration = parseInterval('0.5d');
+      expect(duration.as('h')).to.be(12);
+    });
 
-    duration = parseInterval('d');
-    expect(duration.as('d')).to.be(1);
+    it('should correctly parse a unit in an interval only', function () {
+      let duration = parseInterval('ms');
+      expect(duration.as('ms')).to.be(1);
 
-    duration = parseInterval('m');
-    expect(duration.as('m')).to.be(1);
+      duration = parseInterval('d');
+      expect(duration.as('d')).to.be(1);
 
-    duration = parseInterval('y');
-    expect(duration.as('y')).to.be(1);
+      duration = parseInterval('m');
+      expect(duration.as('m')).to.be(1);
 
-    duration = parseInterval('M');
-    expect(duration.as('M')).to.be(1);
-  });
+      duration = parseInterval('y');
+      expect(duration.as('y')).to.be(1);
 
-  it('should return null for an invalid interval', function () {
-    let duration = parseInterval('');
-    expect(duration).to.not.be.ok();
+      duration = parseInterval('M');
+      expect(duration.as('M')).to.be(1);
+    });
 
-    duration = parseInterval(null);
-    expect(duration).to.not.be.ok();
+    it('should return null for an invalid interval', function () {
+      let duration = parseInterval('');
+      expect(duration).to.not.be.ok();
+
+      duration = parseInterval(null);
+      expect(duration).to.not.be.ok();
+
+      duration = parseInterval('234asdf');
+      expect(duration).to.not.be.ok();
+    });
+  });
 
-    duration = parseInterval('234asdf');
-    expect(duration).to.not.be.ok();
+  describe('parseEsInterval()', function () {
+    it('should correctly parse an interval containing unit and single value', function () {
+      expect(parseEsInterval('1ms')).to.eql({ value: 1, unit: 'ms', type: 'fixed' });
+      expect(parseEsInterval('1s')).to.eql({ value: 1, unit: 's', type: 'fixed' });
+      expect(parseEsInterval('1m')).to.eql({ value: 1, unit: 'm', type: 'calendar' });
+      expect(parseEsInterval('1h')).to.eql({ value: 1, unit: 'h', type: 'calendar' });
+      expect(parseEsInterval('1d')).to.eql({ value: 1, unit: 'd', type: 'calendar' });
+      expect(parseEsInterval('1w')).to.eql({ value: 1, unit: 'w', type: 'calendar' });
+      expect(parseEsInterval('1M')).to.eql({ value: 1, unit: 'M', type: 'calendar' });
+      expect(parseEsInterval('1q')).to.eql({ value: 1, unit: 'q', type: 'calendar' });
+      expect(parseEsInterval('1y')).to.eql({ value: 1, unit: 'y', type: 'calendar' });
+    });
+
+    it('should correctly parse an interval containing unit and multiple value', function () {
+      expect(parseEsInterval('250ms')).to.eql({ value: 250, unit: 'ms', type: 'fixed' });
+      expect(parseEsInterval('90s')).to.eql({ value: 90, unit: 's', type: 'fixed' });
+      expect(parseEsInterval('60m')).to.eql({ value: 60, unit: 'm', type: 'fixed' });
+      expect(parseEsInterval('12h')).to.eql({ value: 12, unit: 'h', type: 'fixed' });
+      expect(parseEsInterval('7d')).to.eql({ value: 7, unit: 'd', type: 'fixed' });
+    });
+
+    it('should throw an error for intervals containing calendar unit and multiple value', function () {
+      expect(parseEsInterval).withArgs('4w').to.throwError();
+      expect(parseEsInterval).withArgs('12M').to.throwError();
+      expect(parseEsInterval).withArgs('2q').to.throwError();
+      expect(parseEsInterval).withArgs('10y').to.throwError();
+    });
+
+    it('should throw an error for invalid interval formats', function () {
+      expect(parseEsInterval).withArgs('1').to.throwError();
+      expect(parseEsInterval).withArgs('h').to.throwError();
+      expect(parseEsInterval).withArgs('0m').to.throwError();
+      expect(parseEsInterval).withArgs('0.5h').to.throwError();
+      expect(parseEsInterval).withArgs().to.throwError();
+      expect(parseEsInterval).withArgs({}).to.throwError();
+    });
   });
 });
diff --git a/src/ui/public/utils/parse_interval.js b/src/ui/public/utils/parse_interval.js
index 979c6c4b4396c1..471e135b4b4a01 100644
--- a/src/ui/public/utils/parse_interval.js
+++ b/src/ui/public/utils/parse_interval.js
@@ -23,6 +23,7 @@ import dateMath from '@kbn/datemath';
 
 // Assume interval is in the form (value)(unit), such as "1h"
 const INTERVAL_STRING_RE = new RegExp('^([0-9\\.]*)\\s*(' + dateMath.units.join('|') + ')$');
+const ES_INTERVAL_STRING_RE = new RegExp('^([1-9][0-9]*)\\s*(' + dateMath.units.join('|') + ')$');
 
 export function parseInterval(interval) {
   const matches = String(interval).trim().match(INTERVAL_STRING_RE);
@@ -51,3 +52,31 @@ export function parseInterval(interval) {
     return null;
   }
 }
+
+/**
+ * Strict version of parseInterval(), enforces ES interval format, and disallows fractional values
+ *
+ * @param interval
+ * @returns {{amount: (RegExpMatchArray | null) | number, unit: (RegExpMatchArray | null) | string, type: string}}
+ */
+export function parseEsInterval(interval = '') {
+  const matches = String(interval).trim().match(ES_INTERVAL_STRING_RE);
+
+  if (!matches) {
+    throw Error(`Invalid interval format: ${interval}`);
+  }
+
+  const value = matches && parseFloat(matches[1]);
+  const unit = matches && matches[2];
+  const type = unit && dateMath.unitsMap[unit].type;
+
+  if (type === 'calendar' && value !== 1) {
+    throw Error(`Invalid calendar interval: ${interval}, value must be 1`);
+  }
+
+  return {
+    value,
+    unit,
+    type: (type === 'mixed' && value === 1) || type === 'calendar' ? 'calendar' : 'fixed',
+  };
+}
diff --git a/src/ui/public/validate_date_interval.js b/src/ui/public/validate_date_interval.js
index ab6906c678f0e5..4be14542eb33e2 100644
--- a/src/ui/public/validate_date_interval.js
+++ b/src/ui/public/validate_date_interval.js
@@ -19,6 +19,7 @@
 
 import { parseInterval } from './utils/parse_interval';
 import { uiModules } from './modules';
+import { leastCommonInterval } from './vis/lib/least_common_interval';
 
 uiModules
   .get('kibana')
@@ -27,14 +28,31 @@ uiModules
       restrict: 'A',
       require: 'ngModel',
       link: function ($scope, $el, attrs, ngModelCntrl) {
+        const baseInterval = attrs.validateDateInterval || null;
 
         ngModelCntrl.$parsers.push(check);
         ngModelCntrl.$formatters.push(check);
 
         function check(value) {
-          ngModelCntrl.$setValidity('dateInterval', parseInterval(value) != null);
+          if(baseInterval) {
+            ngModelCntrl.$setValidity('dateInterval', parseWithBase(value) === true);
+          } else {
+            ngModelCntrl.$setValidity('dateInterval', parseInterval(value) != null);
+          }
           return value;
         }
+
+        // When base interval is set, check for least common interval and allow
+        // input the value is the same. This means that the input interval is a
+        // multiple of the base interval.
+        function parseWithBase(value) {
+          try {
+            const lci = leastCommonInterval(baseInterval, value);
+            return lci === value.replace(/\s/g, '');
+          } catch(e) {
+            return false;
+          }
+        }
       }
     };
   });
diff --git a/src/ui/public/vis/__tests__/lib/least_common_interval.ts b/src/ui/public/vis/__tests__/lib/least_common_interval.ts
new file mode 100644
index 00000000000000..38df2ab0f738cd
--- /dev/null
+++ b/src/ui/public/vis/__tests__/lib/least_common_interval.ts
@@ -0,0 +1,96 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import expect from 'expect.js';
+import { leastCommonInterval } from '../../lib/least_common_interval';
+
+describe('leastCommonInterval', () => {
+  it('should correctly return lowest common interval for fixed units', () => {
+    expect(leastCommonInterval('1ms', '1s')).to.be('1s');
+    expect(leastCommonInterval('500ms', '1s')).to.be('1s');
+    expect(leastCommonInterval('1000ms', '1s')).to.be('1s');
+    expect(leastCommonInterval('1500ms', '1s')).to.be('3s');
+    expect(leastCommonInterval('1234ms', '1s')).to.be('617s');
+    expect(leastCommonInterval('1s', '2m')).to.be('2m');
+    expect(leastCommonInterval('300s', '2m')).to.be('10m');
+    expect(leastCommonInterval('1234ms', '7m')).to.be('4319m');
+    expect(leastCommonInterval('45m', '2h')).to.be('6h');
+    expect(leastCommonInterval('12h', '4d')).to.be('4d');
+    expect(leastCommonInterval('  20 h', '7d')).to.be('35d');
+  });
+
+  it('should correctly return lowest common interval for calendar units', () => {
+    expect(leastCommonInterval('1m', '1h')).to.be('1h');
+    expect(leastCommonInterval('1h', '1d')).to.be('1d');
+    expect(leastCommonInterval('1d', '1w')).to.be('1w');
+    expect(leastCommonInterval('1w', '1M')).to.be('1M');
+    expect(leastCommonInterval('1M', '1q')).to.be('1q');
+    expect(leastCommonInterval('1q', '1y')).to.be('1y');
+    expect(leastCommonInterval('1M', '1m')).to.be('1M');
+    expect(leastCommonInterval('1y', '1w')).to.be('1y');
+  });
+
+  it('should throw an error for intervals of different types', () => {
+    expect(leastCommonInterval)
+      .withArgs('60 s', '1m')
+      .to.throwError();
+    expect(leastCommonInterval)
+      .withArgs('1d', '7d')
+      .to.throwError();
+    expect(leastCommonInterval)
+      .withArgs('1h', '3d')
+      .to.throwError();
+    expect(leastCommonInterval)
+      .withArgs('7d', '1w')
+      .to.throwError();
+    expect(leastCommonInterval)
+      .withArgs('1M', '1000ms')
+      .to.throwError();
+  });
+
+  it('should throw an error for invalid intervals', () => {
+    expect(leastCommonInterval)
+      .withArgs()
+      .to.throwError();
+    expect(leastCommonInterval)
+      .withArgs({})
+      .to.throwError();
+    expect(leastCommonInterval)
+      .withArgs({}, {})
+      .to.throwError();
+    expect(leastCommonInterval)
+      .withArgs(123, '456')
+      .to.throwError();
+    expect(leastCommonInterval)
+      .withArgs('foo', 'bar')
+      .to.throwError();
+    expect(leastCommonInterval)
+      .withArgs('0h', '1h')
+      .to.throwError();
+    expect(leastCommonInterval)
+      .withArgs('0.5h', '1h')
+      .to.throwError();
+    expect(leastCommonInterval)
+      .withArgs('5w', '1h')
+      .to.throwError();
+    expect(leastCommonInterval)
+      .withArgs('2M', '4w')
+      .to.throwError();
+  });
+});
diff --git a/src/ui/public/vis/editors/config/editor_config_providers.ts b/src/ui/public/vis/editors/config/editor_config_providers.ts
index d11144ab0ae613..ae2adf6d0607e4 100644
--- a/src/ui/public/vis/editors/config/editor_config_providers.ts
+++ b/src/ui/public/vis/editors/config/editor_config_providers.ts
@@ -17,10 +17,12 @@
  * under the License.
  */
 
+import { TimeIntervalParam } from 'ui/vis/editors/config/types';
 import { AggConfig } from '../..';
 import { AggType } from '../../../agg_types';
 import { IndexPattern } from '../../../index_patterns';
-import { leastCommonMultiple } from '../../../utils/math';
+import { parseEsInterval } from '../../../utils/parse_interval';
+import { leastCommonInterval } from '../../lib/least_common_interval';
 import { EditorConfig, EditorParamConfig, FixedParam, NumericIntervalParam } from './types';
 
 type EditorConfigProvider = (
@@ -47,6 +49,10 @@ class EditorConfigProviderRegistry {
     return this.mergeConfigs(configs);
   }
 
+  private isTimeBaseParam(config: EditorParamConfig): config is TimeIntervalParam {
+    return config.hasOwnProperty('default') && config.hasOwnProperty('timeBase');
+  }
+
   private isBaseParam(config: EditorParamConfig): config is NumericIntervalParam {
     return config.hasOwnProperty('base');
   }
@@ -108,7 +114,6 @@ class EditorConfigProviderRegistry {
         fixedValue: current.fixedValue,
       };
     }
-
     if (this.isBaseParam(current)) {
       return {
         base: current.base,
@@ -118,6 +123,39 @@ class EditorConfigProviderRegistry {
     return {};
   }
 
+  private mergeTimeBase(
+    current: EditorParamConfig,
+    merged: EditorParamConfig,
+    paramName: string
+  ): { timeBase?: string; default?: string } {
+    if (this.isTimeBaseParam(current) && this.isTimeBaseParam(merged)) {
+      // In case both had where interval values, just use the least common multiple between both interval
+      try {
+        const timeBase = leastCommonInterval(current.timeBase, merged.timeBase);
+        return {
+          default: timeBase,
+          timeBase,
+        };
+      } catch (e) {
+        throw e;
+      }
+    }
+
+    if (this.isTimeBaseParam(current)) {
+      try {
+        parseEsInterval(current.timeBase);
+        return {
+          default: current.timeBase,
+          timeBase: current.timeBase,
+        };
+      } catch (e) {
+        throw e;
+      }
+    }
+
+    return {};
+  }
+
   private mergeConfigs(configs: EditorConfig[]): EditorConfig {
     return configs.reduce((output, conf) => {
       Object.entries(conf).forEach(([paramName, paramConfig]) => {
@@ -128,6 +166,7 @@ class EditorConfigProviderRegistry {
             hidden: this.mergeHidden(paramConfig, output[paramName]),
             warning: this.mergeWarning(paramConfig, output[paramName]),
             ...this.mergeFixedAndBase(paramConfig, output[paramName], paramName),
+            ...this.mergeTimeBase(paramConfig, output[paramName], paramName),
           };
         }
       });
diff --git a/src/ui/public/vis/editors/config/types.ts b/src/ui/public/vis/editors/config/types.ts
index e8c49232c878f8..34d54c81f660e7 100644
--- a/src/ui/public/vis/editors/config/types.ts
+++ b/src/ui/public/vis/editors/config/types.ts
@@ -41,7 +41,16 @@ export type NumericIntervalParam = Partial<Param> & {
   base: number;
 };
 
-export type EditorParamConfig = NumericIntervalParam | FixedParam | Param;
+/**
+ * Time interval parameters must always be set in the editor to a multiple of
+ * the specified base. It can optionally also be hidden.
+ */
+export type TimeIntervalParam = Partial<Param> & {
+  default: string;
+  timeBase: string;
+};
+
+export type EditorParamConfig = NumericIntervalParam | TimeIntervalParam | FixedParam | Param;
 
 export interface EditorConfig {
   [paramName: string]: EditorParamConfig;
diff --git a/src/ui/public/vis/editors/default/agg_params.js b/src/ui/public/vis/editors/default/agg_params.js
index d89e7e3944818d..da9a4b074eeeff 100644
--- a/src/ui/public/vis/editors/default/agg_params.js
+++ b/src/ui/public/vis/editors/default/agg_params.js
@@ -50,9 +50,12 @@ uiModules
 
         // We set up this watch prior to adding the controls below, because when the controls are added,
         // there is a possibility that the agg type can be automatically selected (if there is only one)
-        $scope.$watch('agg.type', updateAggParamEditor);
+        $scope.$watch('agg.type', () => {
+          updateAggParamEditor();
+          updateEditorConfig('default');
+        });
 
-        function updateEditorConfig() {
+        function updateEditorConfig(property = 'fixedValue') {
           $scope.editorConfig = editorConfigProviders.getConfigForAgg(
             aggTypes.byType[$scope.groupName],
             $scope.indexPattern,
@@ -61,17 +64,21 @@ uiModules
 
           Object.keys($scope.editorConfig).forEach(param => {
             const config = $scope.editorConfig[param];
+            const paramOptions = $scope.agg.type.params.find((paramOption) => paramOption.name === param);
             // If the parameter has a fixed value in the config, set this value.
             // Also for all supported configs we should freeze the editor for this param.
-            if (config.hasOwnProperty('fixedValue')) {
-              $scope.agg.params[param] = config.fixedValue;
+            if (config.hasOwnProperty(property)) {
+              if(paramOptions && paramOptions.deserialize) {
+                $scope.agg.params[param] = paramOptions.deserialize(config[property]);
+              } else {
+                $scope.agg.params[param] = config[property];
+              }
             }
           });
         }
 
-        $scope.$watchCollection('agg.params', updateEditorConfig);
-
         updateEditorConfig();
+        $scope.$watchCollection('agg.params', updateEditorConfig);
 
         // this will contain the controls for the schema (rows or columns?), which are unrelated to
         // controls for the agg, which is why they are first
diff --git a/src/ui/public/vis/lib/least_common_interval.ts b/src/ui/public/vis/lib/least_common_interval.ts
new file mode 100644
index 00000000000000..1b78ba0f653619
--- /dev/null
+++ b/src/ui/public/vis/lib/least_common_interval.ts
@@ -0,0 +1,78 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import dateMath from '@kbn/datemath';
+import { leastCommonMultiple } from '../../utils/math';
+import { parseEsInterval } from '../../utils/parse_interval';
+
+/**
+ * Finds the lowest common interval between two given ES date histogram intervals
+ * in the format of (value)(unit)
+ *
+ *  - `ms, s` units are fixed-length intervals
+ *  - `m, h, d` units are fixed-length intervals when value > 1 (i.e. 2m, 24h, 7d),
+ *    but calendar interval when value === 1
+ *  - `w, M, q, y` units are calendar intervals and do not support multiple, aka
+ *    value must === 1
+ *
+ * @param {string} a
+ * @param {string} b
+ * @returns {string}
+ */
+export function leastCommonInterval(a = '', b = '') {
+  const { unitsMap, unitsDesc } = dateMath;
+  const aInt = parseEsInterval(a);
+  const bInt = parseEsInterval(b);
+
+  if (a === b) {
+    return a;
+  }
+
+  const aUnit = unitsMap[aInt.unit];
+  const bUnit = unitsMap[bInt.unit];
+
+  // If intervals aren't the same type, throw error
+  if (aInt.type !== bInt.type) {
+    throw Error(`Incompatible intervals: ${a} (${aInt.type}), ${b} (${bInt.type})`);
+  }
+
+  // If intervals are calendar units, pick the larger one (calendar value is always 1)
+  if (aInt.type === 'calendar') {
+    return aUnit.weight > bUnit.weight ? `${aInt.value}${aInt.unit}` : `${bInt.value}${bInt.unit}`;
+  }
+
+  // Otherwise if intervals are fixed units, find least common multiple in milliseconds
+  const aMs = aInt.value * aUnit.base;
+  const bMs = bInt.value * bUnit.base;
+  const lcmMs = leastCommonMultiple(aMs, bMs);
+
+  // Return original interval string if it matches one of the original milliseconds
+  if (lcmMs === bMs) {
+    return b.replace(/\s/g, '');
+  }
+  if (lcmMs === aMs) {
+    return a.replace(/\s/g, '');
+  }
+
+  // Otherwise find the biggest unit that divides evenly
+  const lcmUnit = unitsDesc.find(unit => unitsMap[unit].base && lcmMs % unitsMap[unit].base === 0);
+
+  // Return the interval string
+  return `${lcmMs / unitsMap[lcmUnit].base}${lcmUnit}`;
+}

From 585622d863a2fdef75446c934b7cbc2bee606029 Mon Sep 17 00:00:00 2001
From: Jen Huang <its.jenetic@gmail.com>
Date: Wed, 22 Aug 2018 00:05:56 -0700
Subject: [PATCH 2/7] Remove quarter interval unit, change EditorConfig
 `warning` to `help`, show `help` below date histogram and histogram interval
 inputs

---
 packages/kbn-datemath/src/index.js               |  4 ++--
 .../public/agg_types/buckets/date_histogram.js   |  5 -----
 .../agg_types/controls/number_interval.html      | 16 +++++++---------
 .../public/agg_types/controls/time_interval.html | 11 +++++++++--
 src/ui/public/utils/__tests__/parse_interval.js  |  2 --
 .../editors/config/editor_config_providers.ts    | 10 +++++-----
 src/ui/public/vis/editors/config/types.ts        |  2 +-
 7 files changed, 24 insertions(+), 26 deletions(-)

diff --git a/packages/kbn-datemath/src/index.js b/packages/kbn-datemath/src/index.js
index f82a4324662700..e64cb6327b9fd3 100644
--- a/packages/kbn-datemath/src/index.js
+++ b/packages/kbn-datemath/src/index.js
@@ -27,10 +27,10 @@ const unitsMap = {
   d: { weight: 5, type: 'mixed', base: 1000 * 60 * 60 * 24 },
   w: { weight: 6, type: 'calendar' },
   M: { weight: 7, type: 'calendar' },
-  q: { weight: 8, type: 'calendar' },
+  // q: { weight: 8, type: 'calendar' }, // TODO: moment duration does not support quarter
   y: { weight: 9, type: 'calendar' },
 };
-const units = Object.keys(unitsMap);
+const units = Object.keys(unitsMap).sort((a, b) => unitsMap[a].weight - unitsMap[b].weight);
 const unitsDesc = [...units].reverse();
 const unitsAsc = [...units];
 
diff --git a/src/ui/public/agg_types/buckets/date_histogram.js b/src/ui/public/agg_types/buckets/date_histogram.js
index c80afd6d38851c..c9c26689f3d539 100644
--- a/src/ui/public/agg_types/buckets/date_histogram.js
+++ b/src/ui/public/agg_types/buckets/date_histogram.js
@@ -147,11 +147,6 @@ export const dateHistogramBucketAgg = new BucketAggType({
         return isDefaultTimezone ? detectedTimezone || tzOffset : config.get('dateFormat:tz');
       },
     },
-    {
-      name: 'intervalBase',
-      default: undefined,
-      write: _.noop
-    },
     {
       name: 'customInterval',
       default: '2h',
diff --git a/src/ui/public/agg_types/controls/number_interval.html b/src/ui/public/agg_types/controls/number_interval.html
index f0283d614cf163..a281875531d114 100644
--- a/src/ui/public/agg_types/controls/number_interval.html
+++ b/src/ui/public/agg_types/controls/number_interval.html
@@ -6,15 +6,6 @@
       position="'right'"
       content="'Interval will be automatically scaled in the event that the provided value creates more buckets than specified by Advanced Setting\'s histogram:maxBars'"
     ></icon-tip>
-
-    <icon-tip
-      ng-if="editorConfig.interval.warning"
-      position="'right'"
-      content="editorConfig.interval.warning"
-      type="'alert'"
-      color="'warning'"
-      style="float: right"
-    ></icon-tip>
   </label>
   <input
     id="visEditorInterval{{agg.id}}"
@@ -27,4 +18,11 @@
     step="{{editorConfig.interval.base}}"
     input-number
     >
+  <div
+    ng-if="editorConfig.interval.help"
+    class="kuiSubText kuiSubduedText kuiVerticalRhythmSmall"
+    style="margin-top: 5px"
+  >
+    <span>{{editorConfig.interval.help}}</span>
+  </div>
 </div>
diff --git a/src/ui/public/agg_types/controls/time_interval.html b/src/ui/public/agg_types/controls/time_interval.html
index 4c5ae05dafa914..4a980f39c727c5 100644
--- a/src/ui/public/agg_types/controls/time_interval.html
+++ b/src/ui/public/agg_types/controls/time_interval.html
@@ -9,7 +9,7 @@
     ></icon-tip>
   </label>
   <select
-    ng-if="!agg.params.intervalBase"
+    ng-if="!editorConfig.customInterval.timeBase"
     id="visEditorInterval{{agg.id}}"
     ng-model="agg.params.interval"
     ng-change="agg.write()"
@@ -24,9 +24,16 @@
     type="text"
     name="customInterval"
     ng-model="agg.params.customInterval"
-    validate-date-interval="{{agg.params.intervalBase}}"
+    validate-date-interval="{{editorConfig.customInterval.timeBase}}"
     ng-change="aggForm.customInterval.$valid && agg.write()"
     ng-if="agg.params.interval.val == 'custom'"
     class="form-control"
     required />
+  <div
+    ng-if="editorConfig.customInterval.help"
+    class="kuiSubText kuiSubduedText kuiVerticalRhythmSmall"
+    style="margin-top: 5px"
+  >
+    <span>{{editorConfig.customInterval.help}}</span>
+  </div>
 </div>
diff --git a/src/ui/public/utils/__tests__/parse_interval.js b/src/ui/public/utils/__tests__/parse_interval.js
index 23a05c272a2b4f..784774239e2c7c 100644
--- a/src/ui/public/utils/__tests__/parse_interval.js
+++ b/src/ui/public/utils/__tests__/parse_interval.js
@@ -103,7 +103,6 @@ describe('parseInterval', function () {
       expect(parseEsInterval('1d')).to.eql({ value: 1, unit: 'd', type: 'calendar' });
       expect(parseEsInterval('1w')).to.eql({ value: 1, unit: 'w', type: 'calendar' });
       expect(parseEsInterval('1M')).to.eql({ value: 1, unit: 'M', type: 'calendar' });
-      expect(parseEsInterval('1q')).to.eql({ value: 1, unit: 'q', type: 'calendar' });
       expect(parseEsInterval('1y')).to.eql({ value: 1, unit: 'y', type: 'calendar' });
     });
 
@@ -118,7 +117,6 @@ describe('parseInterval', function () {
     it('should throw an error for intervals containing calendar unit and multiple value', function () {
       expect(parseEsInterval).withArgs('4w').to.throwError();
       expect(parseEsInterval).withArgs('12M').to.throwError();
-      expect(parseEsInterval).withArgs('2q').to.throwError();
       expect(parseEsInterval).withArgs('10y').to.throwError();
     });
 
diff --git a/src/ui/public/vis/editors/config/editor_config_providers.ts b/src/ui/public/vis/editors/config/editor_config_providers.ts
index ae2adf6d0607e4..14fdf2976b5bb3 100644
--- a/src/ui/public/vis/editors/config/editor_config_providers.ts
+++ b/src/ui/public/vis/editors/config/editor_config_providers.ts
@@ -65,12 +65,12 @@ class EditorConfigProviderRegistry {
     return Boolean(current.hidden || merged.hidden);
   }
 
-  private mergeWarning(current: EditorParamConfig, merged: EditorParamConfig): string | undefined {
-    if (!current.warning) {
-      return merged.warning;
+  private mergeHelp(current: EditorParamConfig, merged: EditorParamConfig): string | undefined {
+    if (!current.help) {
+      return merged.help;
     }
 
-    return merged.warning ? `${merged.warning}\n\n${current.warning}` : current.warning;
+    return merged.help ? `${merged.help}\n\n${current.help}` : current.help;
   }
 
   private mergeFixedAndBase(
@@ -164,7 +164,7 @@ class EditorConfigProviderRegistry {
         } else {
           output[paramName] = {
             hidden: this.mergeHidden(paramConfig, output[paramName]),
-            warning: this.mergeWarning(paramConfig, output[paramName]),
+            help: this.mergeHelp(paramConfig, output[paramName]),
             ...this.mergeFixedAndBase(paramConfig, output[paramName], paramName),
             ...this.mergeTimeBase(paramConfig, output[paramName], paramName),
           };
diff --git a/src/ui/public/vis/editors/config/types.ts b/src/ui/public/vis/editors/config/types.ts
index 34d54c81f660e7..61c0ced3cd5198 100644
--- a/src/ui/public/vis/editors/config/types.ts
+++ b/src/ui/public/vis/editors/config/types.ts
@@ -22,7 +22,7 @@
  */
 interface Param {
   hidden?: boolean;
-  warning?: string;
+  help?: string;
 }
 
 /**

From 1da037b370f55942e6de4b3e080ca197c76bea10 Mon Sep 17 00:00:00 2001
From: Jen Huang <its.jenetic@gmail.com>
Date: Thu, 23 Aug 2018 22:36:35 -0700
Subject: [PATCH 3/7] Add editor config provider tests

---
 .../config/editor_config_providers.test.ts    | 67 +++++++++++++++++--
 .../editors/config/editor_config_providers.ts | 22 +++---
 2 files changed, 75 insertions(+), 14 deletions(-)

diff --git a/src/ui/public/vis/editors/config/editor_config_providers.test.ts b/src/ui/public/vis/editors/config/editor_config_providers.test.ts
index ab0b8b10718b14..3ba4c78b0abb5c 100644
--- a/src/ui/public/vis/editors/config/editor_config_providers.test.ts
+++ b/src/ui/public/vis/editors/config/editor_config_providers.test.ts
@@ -18,7 +18,7 @@
  */
 
 import { EditorConfigProviderRegistry } from './editor_config_providers';
-import { EditorParamConfig, FixedParam, NumericIntervalParam } from './types';
+import { EditorParamConfig, FixedParam, NumericIntervalParam, TimeIntervalParam } from './types';
 
 describe('EditorConfigProvider', () => {
   let registry: EditorConfigProviderRegistry;
@@ -111,6 +111,49 @@ describe('EditorConfigProvider', () => {
       }).toThrowError();
     });
 
+    it('should allow same timeBase values', () => {
+      registry.register(singleConfig({ timeBase: '2h', default: '2h' }));
+      registry.register(singleConfig({ timeBase: '2h', default: '2h' }));
+      const config = getOutputConfig(registry) as TimeIntervalParam;
+      expect(config).toHaveProperty('timeBase');
+      expect(config).toHaveProperty('default');
+      expect(config.timeBase).toBe('2h');
+      expect(config.default).toBe('2h');
+    });
+
+    it('should merge multiple compatible timeBase values, using least common interval', () => {
+      registry.register(singleConfig({ timeBase: '2h', default: '2h' }));
+      registry.register(singleConfig({ timeBase: '3h', default: '3h' }));
+      registry.register(singleConfig({ timeBase: '4h', default: '4h' }));
+      const config = getOutputConfig(registry) as TimeIntervalParam;
+      expect(config).toHaveProperty('timeBase');
+      expect(config).toHaveProperty('default');
+      expect(config.timeBase).toBe('12h');
+      expect(config.default).toBe('12h');
+    });
+
+    it('should throw on combining incompatible timeBase values', () => {
+      registry.register(singleConfig({ timeBase: '2h', default: '2h' }));
+      registry.register(singleConfig({ timeBase: '1d', default: '1d' }));
+      expect(() => {
+        getOutputConfig(registry);
+      }).toThrowError();
+    });
+
+    it('should throw on invalid timeBase values', () => {
+      registry.register(singleConfig({ timeBase: '2w', default: '2w' }));
+      expect(() => {
+        getOutputConfig(registry);
+      }).toThrowError();
+    });
+
+    it('should throw if timeBase and default are different', () => {
+      registry.register(singleConfig({ timeBase: '1h', default: '2h' }));
+      expect(() => {
+        getOutputConfig(registry);
+      }).toThrowError();
+    });
+
     it('should merge hidden together with fixedValue', () => {
       registry.register(singleConfig({ fixedValue: 'foo', hidden: true }));
       registry.register(singleConfig({ fixedValue: 'foo', hidden: false }));
@@ -131,12 +174,24 @@ describe('EditorConfigProvider', () => {
       expect(config.hidden).toBe(false);
     });
 
-    it('should merge warnings together into one string', () => {
-      registry.register(singleConfig({ warning: 'Warning' }));
-      registry.register(singleConfig({ warning: 'Another warning' }));
+    it('should merge hidden together with timeBase', () => {
+      registry.register(singleConfig({ timeBase: '2h', default: '2h', hidden: false }));
+      registry.register(singleConfig({ timeBase: '4h', default: '4h', hidden: false }));
+      const config = getOutputConfig(registry) as TimeIntervalParam;
+      expect(config).toHaveProperty('timeBase');
+      expect(config).toHaveProperty('default');
+      expect(config).toHaveProperty('hidden');
+      expect(config.timeBase).toBe('4h');
+      expect(config.default).toBe('4h');
+      expect(config.hidden).toBe(false);
+    });
+
+    it('should merge helps together into one string', () => {
+      registry.register(singleConfig({ help: 'Warning' }));
+      registry.register(singleConfig({ help: 'Another help' }));
       const config = getOutputConfig(registry);
-      expect(config).toHaveProperty('warning');
-      expect(config.warning).toBe('Warning\n\nAnother warning');
+      expect(config).toHaveProperty('help');
+      expect(config.help).toBe('Warning\n\nAnother help');
     });
   });
 });
diff --git a/src/ui/public/vis/editors/config/editor_config_providers.ts b/src/ui/public/vis/editors/config/editor_config_providers.ts
index 14fdf2976b5bb3..0479de59b64590 100644
--- a/src/ui/public/vis/editors/config/editor_config_providers.ts
+++ b/src/ui/public/vis/editors/config/editor_config_providers.ts
@@ -21,6 +21,7 @@ import { TimeIntervalParam } from 'ui/vis/editors/config/types';
 import { AggConfig } from '../..';
 import { AggType } from '../../../agg_types';
 import { IndexPattern } from '../../../index_patterns';
+import { leastCommonMultiple } from '../../../utils/math';
 import { parseEsInterval } from '../../../utils/parse_interval';
 import { leastCommonInterval } from '../../lib/least_common_interval';
 import { EditorConfig, EditorParamConfig, FixedParam, NumericIntervalParam } from './types';
@@ -128,6 +129,10 @@ class EditorConfigProviderRegistry {
     merged: EditorParamConfig,
     paramName: string
   ): { timeBase?: string; default?: string } {
+    if (current.default !== current.timeBase) {
+      throw new Error(`Tried to provide differing default and timeBase values for ${paramName}.`);
+    }
+
     if (this.isTimeBaseParam(current) && this.isTimeBaseParam(merged)) {
       // In case both had where interval values, just use the least common multiple between both interval
       try {
@@ -160,15 +165,16 @@ class EditorConfigProviderRegistry {
     return configs.reduce((output, conf) => {
       Object.entries(conf).forEach(([paramName, paramConfig]) => {
         if (!output[paramName]) {
-          output[paramName] = { ...paramConfig };
-        } else {
-          output[paramName] = {
-            hidden: this.mergeHidden(paramConfig, output[paramName]),
-            help: this.mergeHelp(paramConfig, output[paramName]),
-            ...this.mergeFixedAndBase(paramConfig, output[paramName], paramName),
-            ...this.mergeTimeBase(paramConfig, output[paramName], paramName),
-          };
+          output[paramName] = {};
         }
+
+        output[paramName] = {
+          hidden: this.mergeHidden(paramConfig, output[paramName]),
+          help: this.mergeHelp(paramConfig, output[paramName]),
+          ...(this.isTimeBaseParam(paramConfig)
+            ? this.mergeTimeBase(paramConfig, output[paramName], paramName)
+            : this.mergeFixedAndBase(paramConfig, output[paramName], paramName)),
+        };
       });
       return output;
     }, {});

From 7464096212aa7b57409856a76d4ae8f4be9d4988 Mon Sep 17 00:00:00 2001
From: Jen Huang <its.jenetic@gmail.com>
Date: Thu, 23 Aug 2018 23:31:54 -0700
Subject: [PATCH 4/7] Fix ts definitions

---
 .../utils/__tests__/parse_es_interval.js      |  57 +++++++
 .../public/utils/__tests__/parse_interval.js  | 139 +++++++-----------
 src/ui/public/utils/parse_es_interval.ts      |  51 +++++++
 src/ui/public/utils/parse_interval.js         |  29 ----
 .../editors/config/editor_config_providers.ts |   4 +-
 ...n_interval.ts => least_common_interval.js} |   2 +-
 6 files changed, 161 insertions(+), 121 deletions(-)
 create mode 100644 src/ui/public/utils/__tests__/parse_es_interval.js
 create mode 100644 src/ui/public/utils/parse_es_interval.ts
 rename src/ui/public/vis/lib/{least_common_interval.ts => least_common_interval.js} (97%)

diff --git a/src/ui/public/utils/__tests__/parse_es_interval.js b/src/ui/public/utils/__tests__/parse_es_interval.js
new file mode 100644
index 00000000000000..5ee9113b31dcef
--- /dev/null
+++ b/src/ui/public/utils/__tests__/parse_es_interval.js
@@ -0,0 +1,57 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { parseEsInterval } from '../parse_es_interval';
+import expect from 'expect.js';
+
+describe('parseEsInterval', function () {
+  it('should correctly parse an interval containing unit and single value', function () {
+    expect(parseEsInterval('1ms')).to.eql({ value: 1, unit: 'ms', type: 'fixed' });
+    expect(parseEsInterval('1s')).to.eql({ value: 1, unit: 's', type: 'fixed' });
+    expect(parseEsInterval('1m')).to.eql({ value: 1, unit: 'm', type: 'calendar' });
+    expect(parseEsInterval('1h')).to.eql({ value: 1, unit: 'h', type: 'calendar' });
+    expect(parseEsInterval('1d')).to.eql({ value: 1, unit: 'd', type: 'calendar' });
+    expect(parseEsInterval('1w')).to.eql({ value: 1, unit: 'w', type: 'calendar' });
+    expect(parseEsInterval('1M')).to.eql({ value: 1, unit: 'M', type: 'calendar' });
+    expect(parseEsInterval('1y')).to.eql({ value: 1, unit: 'y', type: 'calendar' });
+  });
+
+  it('should correctly parse an interval containing unit and multiple value', function () {
+    expect(parseEsInterval('250ms')).to.eql({ value: 250, unit: 'ms', type: 'fixed' });
+    expect(parseEsInterval('90s')).to.eql({ value: 90, unit: 's', type: 'fixed' });
+    expect(parseEsInterval('60m')).to.eql({ value: 60, unit: 'm', type: 'fixed' });
+    expect(parseEsInterval('12h')).to.eql({ value: 12, unit: 'h', type: 'fixed' });
+    expect(parseEsInterval('7d')).to.eql({ value: 7, unit: 'd', type: 'fixed' });
+  });
+
+  it('should throw an error for intervals containing calendar unit and multiple value', function () {
+    expect(parseEsInterval).withArgs('4w').to.throwError();
+    expect(parseEsInterval).withArgs('12M').to.throwError();
+    expect(parseEsInterval).withArgs('10y').to.throwError();
+  });
+
+  it('should throw an error for invalid interval formats', function () {
+    expect(parseEsInterval).withArgs('1').to.throwError();
+    expect(parseEsInterval).withArgs('h').to.throwError();
+    expect(parseEsInterval).withArgs('0m').to.throwError();
+    expect(parseEsInterval).withArgs('0.5h').to.throwError();
+    expect(parseEsInterval).withArgs().to.throwError();
+    expect(parseEsInterval).withArgs({}).to.throwError();
+  });
+});
diff --git a/src/ui/public/utils/__tests__/parse_interval.js b/src/ui/public/utils/__tests__/parse_interval.js
index 784774239e2c7c..b068ce170e1284 100644
--- a/src/ui/public/utils/__tests__/parse_interval.js
+++ b/src/ui/public/utils/__tests__/parse_interval.js
@@ -17,116 +17,77 @@
  * under the License.
  */
 
-import { parseInterval, parseEsInterval } from '../parse_interval';
+import { parseInterval } from '../parse_interval';
 import expect from 'expect.js';
 
 describe('parseInterval', function () {
+  it('should correctly parse an interval containing unit and value', function () {
+    let duration = parseInterval('1d');
+    expect(duration.as('d')).to.be(1);
 
-  describe('parseInterval()', function () {
-    it('should correctly parse an interval containing unit and value', function () {
-      let duration = parseInterval('1d');
-      expect(duration.as('d')).to.be(1);
+    duration = parseInterval('2y');
+    expect(duration.as('y')).to.be(2);
 
-      duration = parseInterval('2y');
-      expect(duration.as('y')).to.be(2);
+    duration = parseInterval('5M');
+    expect(duration.as('M')).to.be(5);
 
-      duration = parseInterval('5M');
-      expect(duration.as('M')).to.be(5);
+    duration = parseInterval('5m');
+    expect(duration.as('m')).to.be(5);
 
-      duration = parseInterval('5m');
-      expect(duration.as('m')).to.be(5);
+    duration = parseInterval('250ms');
+    expect(duration.as('ms')).to.be(250);
 
-      duration = parseInterval('250ms');
-      expect(duration.as('ms')).to.be(250);
+    duration = parseInterval('100s');
+    expect(duration.as('s')).to.be(100);
 
-      duration = parseInterval('100s');
-      expect(duration.as('s')).to.be(100);
+    duration = parseInterval('23d');
+    expect(duration.as('d')).to.be(23);
 
-      duration = parseInterval('23d');
-      expect(duration.as('d')).to.be(23);
-
-      duration = parseInterval('52w');
-      expect(duration.as('w')).to.be(52);
-    });
-
-    it('should correctly parse fractional intervals containing unit and value', function () {
-      let duration = parseInterval('1.5w');
-      expect(duration.as('w')).to.be(1.5);
+    duration = parseInterval('52w');
+    expect(duration.as('w')).to.be(52);
+  });
 
-      duration = parseInterval('2.35y');
-      expect(duration.as('y')).to.be(2.35);
-    });
+  it('should correctly parse fractional intervals containing unit and value', function () {
+    let duration = parseInterval('1.5w');
+    expect(duration.as('w')).to.be(1.5);
 
-    it('should correctly bubble up intervals which are less than 1', function () {
-      let duration = parseInterval('0.5y');
-      expect(duration.as('d')).to.be(183);
+    duration = parseInterval('2.35y');
+    expect(duration.as('y')).to.be(2.35);
+  });
 
-      duration = parseInterval('0.5d');
-      expect(duration.as('h')).to.be(12);
-    });
+  it('should correctly bubble up intervals which are less than 1', function () {
+    let duration = parseInterval('0.5y');
+    expect(duration.as('d')).to.be(183);
 
-    it('should correctly parse a unit in an interval only', function () {
-      let duration = parseInterval('ms');
-      expect(duration.as('ms')).to.be(1);
+    duration = parseInterval('0.5d');
+    expect(duration.as('h')).to.be(12);
+  });
 
-      duration = parseInterval('d');
-      expect(duration.as('d')).to.be(1);
+  it('should correctly parse a unit in an interval only', function () {
+    let duration = parseInterval('ms');
+    expect(duration.as('ms')).to.be(1);
 
-      duration = parseInterval('m');
-      expect(duration.as('m')).to.be(1);
+    duration = parseInterval('d');
+    expect(duration.as('d')).to.be(1);
 
-      duration = parseInterval('y');
-      expect(duration.as('y')).to.be(1);
+    duration = parseInterval('m');
+    expect(duration.as('m')).to.be(1);
 
-      duration = parseInterval('M');
-      expect(duration.as('M')).to.be(1);
-    });
+    duration = parseInterval('y');
+    expect(duration.as('y')).to.be(1);
 
-    it('should return null for an invalid interval', function () {
-      let duration = parseInterval('');
-      expect(duration).to.not.be.ok();
+    duration = parseInterval('M');
+    expect(duration.as('M')).to.be(1);
+  });
 
-      duration = parseInterval(null);
-      expect(duration).to.not.be.ok();
+  it('should return null for an invalid interval', function () {
+    let duration = parseInterval('');
+    expect(duration).to.not.be.ok();
 
-      duration = parseInterval('234asdf');
-      expect(duration).to.not.be.ok();
-    });
-  });
+    duration = parseInterval(null);
+    expect(duration).to.not.be.ok();
 
-  describe('parseEsInterval()', function () {
-    it('should correctly parse an interval containing unit and single value', function () {
-      expect(parseEsInterval('1ms')).to.eql({ value: 1, unit: 'ms', type: 'fixed' });
-      expect(parseEsInterval('1s')).to.eql({ value: 1, unit: 's', type: 'fixed' });
-      expect(parseEsInterval('1m')).to.eql({ value: 1, unit: 'm', type: 'calendar' });
-      expect(parseEsInterval('1h')).to.eql({ value: 1, unit: 'h', type: 'calendar' });
-      expect(parseEsInterval('1d')).to.eql({ value: 1, unit: 'd', type: 'calendar' });
-      expect(parseEsInterval('1w')).to.eql({ value: 1, unit: 'w', type: 'calendar' });
-      expect(parseEsInterval('1M')).to.eql({ value: 1, unit: 'M', type: 'calendar' });
-      expect(parseEsInterval('1y')).to.eql({ value: 1, unit: 'y', type: 'calendar' });
-    });
-
-    it('should correctly parse an interval containing unit and multiple value', function () {
-      expect(parseEsInterval('250ms')).to.eql({ value: 250, unit: 'ms', type: 'fixed' });
-      expect(parseEsInterval('90s')).to.eql({ value: 90, unit: 's', type: 'fixed' });
-      expect(parseEsInterval('60m')).to.eql({ value: 60, unit: 'm', type: 'fixed' });
-      expect(parseEsInterval('12h')).to.eql({ value: 12, unit: 'h', type: 'fixed' });
-      expect(parseEsInterval('7d')).to.eql({ value: 7, unit: 'd', type: 'fixed' });
-    });
-
-    it('should throw an error for intervals containing calendar unit and multiple value', function () {
-      expect(parseEsInterval).withArgs('4w').to.throwError();
-      expect(parseEsInterval).withArgs('12M').to.throwError();
-      expect(parseEsInterval).withArgs('10y').to.throwError();
-    });
-
-    it('should throw an error for invalid interval formats', function () {
-      expect(parseEsInterval).withArgs('1').to.throwError();
-      expect(parseEsInterval).withArgs('h').to.throwError();
-      expect(parseEsInterval).withArgs('0m').to.throwError();
-      expect(parseEsInterval).withArgs('0.5h').to.throwError();
-      expect(parseEsInterval).withArgs().to.throwError();
-      expect(parseEsInterval).withArgs({}).to.throwError();
-    });
+    duration = parseInterval('234asdf');
+    expect(duration).to.not.be.ok();
   });
 });
diff --git a/src/ui/public/utils/parse_es_interval.ts b/src/ui/public/utils/parse_es_interval.ts
new file mode 100644
index 00000000000000..4e047835a287c6
--- /dev/null
+++ b/src/ui/public/utils/parse_es_interval.ts
@@ -0,0 +1,51 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import dateMath from '@kbn/datemath';
+
+const ES_INTERVAL_STRING_RE = new RegExp('^([1-9][0-9]*)\\s*(' + dateMath.units.join('|') + ')$');
+
+/**
+ * Strict version of parseInterval(), enforces ES interval format, and disallows fractional values
+ *
+ * @param interval
+ * @returns {{amount: (RegExpMatchArray | null) | number, unit: (RegExpMatchArray | null) | string, type: string}}
+ */
+export function parseEsInterval(interval = '') {
+  const matches = String(interval)
+    .trim()
+    .match(ES_INTERVAL_STRING_RE);
+
+  if (!matches) {
+    throw Error(`Invalid interval format: ${interval}`);
+  }
+
+  const value = matches && parseFloat(matches[1]);
+  const unit = matches && matches[2];
+  const type = unit && dateMath.unitsMap[unit].type;
+
+  if (type === 'calendar' && value !== 1) {
+    throw Error(`Invalid calendar interval: ${interval}, value must be 1`);
+  }
+
+  return {
+    value,
+    unit,
+    type: (type === 'mixed' && value === 1) || type === 'calendar' ? 'calendar' : 'fixed',
+  };
+}
diff --git a/src/ui/public/utils/parse_interval.js b/src/ui/public/utils/parse_interval.js
index 471e135b4b4a01..979c6c4b4396c1 100644
--- a/src/ui/public/utils/parse_interval.js
+++ b/src/ui/public/utils/parse_interval.js
@@ -23,7 +23,6 @@ import dateMath from '@kbn/datemath';
 
 // Assume interval is in the form (value)(unit), such as "1h"
 const INTERVAL_STRING_RE = new RegExp('^([0-9\\.]*)\\s*(' + dateMath.units.join('|') + ')$');
-const ES_INTERVAL_STRING_RE = new RegExp('^([1-9][0-9]*)\\s*(' + dateMath.units.join('|') + ')$');
 
 export function parseInterval(interval) {
   const matches = String(interval).trim().match(INTERVAL_STRING_RE);
@@ -52,31 +51,3 @@ export function parseInterval(interval) {
     return null;
   }
 }
-
-/**
- * Strict version of parseInterval(), enforces ES interval format, and disallows fractional values
- *
- * @param interval
- * @returns {{amount: (RegExpMatchArray | null) | number, unit: (RegExpMatchArray | null) | string, type: string}}
- */
-export function parseEsInterval(interval = '') {
-  const matches = String(interval).trim().match(ES_INTERVAL_STRING_RE);
-
-  if (!matches) {
-    throw Error(`Invalid interval format: ${interval}`);
-  }
-
-  const value = matches && parseFloat(matches[1]);
-  const unit = matches && matches[2];
-  const type = unit && dateMath.unitsMap[unit].type;
-
-  if (type === 'calendar' && value !== 1) {
-    throw Error(`Invalid calendar interval: ${interval}, value must be 1`);
-  }
-
-  return {
-    value,
-    unit,
-    type: (type === 'mixed' && value === 1) || type === 'calendar' ? 'calendar' : 'fixed',
-  };
-}
diff --git a/src/ui/public/vis/editors/config/editor_config_providers.ts b/src/ui/public/vis/editors/config/editor_config_providers.ts
index 0479de59b64590..e0c7ddb6ac1f9c 100644
--- a/src/ui/public/vis/editors/config/editor_config_providers.ts
+++ b/src/ui/public/vis/editors/config/editor_config_providers.ts
@@ -22,7 +22,7 @@ import { AggConfig } from '../..';
 import { AggType } from '../../../agg_types';
 import { IndexPattern } from '../../../index_patterns';
 import { leastCommonMultiple } from '../../../utils/math';
-import { parseEsInterval } from '../../../utils/parse_interval';
+import { parseEsInterval } from '../../../utils/parse_es_interval';
 import { leastCommonInterval } from '../../lib/least_common_interval';
 import { EditorConfig, EditorParamConfig, FixedParam, NumericIntervalParam } from './types';
 
@@ -125,7 +125,7 @@ class EditorConfigProviderRegistry {
   }
 
   private mergeTimeBase(
-    current: EditorParamConfig,
+    current: TimeIntervalParam,
     merged: EditorParamConfig,
     paramName: string
   ): { timeBase?: string; default?: string } {
diff --git a/src/ui/public/vis/lib/least_common_interval.ts b/src/ui/public/vis/lib/least_common_interval.js
similarity index 97%
rename from src/ui/public/vis/lib/least_common_interval.ts
rename to src/ui/public/vis/lib/least_common_interval.js
index 1b78ba0f653619..a27f364708988c 100644
--- a/src/ui/public/vis/lib/least_common_interval.ts
+++ b/src/ui/public/vis/lib/least_common_interval.js
@@ -19,7 +19,7 @@
 
 import dateMath from '@kbn/datemath';
 import { leastCommonMultiple } from '../../utils/math';
-import { parseEsInterval } from '../../utils/parse_interval';
+import { parseEsInterval } from '../../utils/parse_es_interval';
 
 /**
  * Finds the lowest common interval between two given ES date histogram intervals

From 6a7058394ba1a55c1581c30d60bb3c3686737fc5 Mon Sep 17 00:00:00 2001
From: Jen Huang <its.jenetic@gmail.com>
Date: Fri, 24 Aug 2018 01:22:33 -0700
Subject: [PATCH 5/7] Fix additional typings

---
 .../__tests__/lib/least_common_interval.ts    | 96 -------------------
 .../vis/lib/least_common_interval.test.ts     | 85 ++++++++++++++++
 ...n_interval.js => least_common_interval.ts} |  0
 3 files changed, 85 insertions(+), 96 deletions(-)
 delete mode 100644 src/ui/public/vis/__tests__/lib/least_common_interval.ts
 create mode 100644 src/ui/public/vis/lib/least_common_interval.test.ts
 rename src/ui/public/vis/lib/{least_common_interval.js => least_common_interval.ts} (100%)

diff --git a/src/ui/public/vis/__tests__/lib/least_common_interval.ts b/src/ui/public/vis/__tests__/lib/least_common_interval.ts
deleted file mode 100644
index 38df2ab0f738cd..00000000000000
--- a/src/ui/public/vis/__tests__/lib/least_common_interval.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-import expect from 'expect.js';
-import { leastCommonInterval } from '../../lib/least_common_interval';
-
-describe('leastCommonInterval', () => {
-  it('should correctly return lowest common interval for fixed units', () => {
-    expect(leastCommonInterval('1ms', '1s')).to.be('1s');
-    expect(leastCommonInterval('500ms', '1s')).to.be('1s');
-    expect(leastCommonInterval('1000ms', '1s')).to.be('1s');
-    expect(leastCommonInterval('1500ms', '1s')).to.be('3s');
-    expect(leastCommonInterval('1234ms', '1s')).to.be('617s');
-    expect(leastCommonInterval('1s', '2m')).to.be('2m');
-    expect(leastCommonInterval('300s', '2m')).to.be('10m');
-    expect(leastCommonInterval('1234ms', '7m')).to.be('4319m');
-    expect(leastCommonInterval('45m', '2h')).to.be('6h');
-    expect(leastCommonInterval('12h', '4d')).to.be('4d');
-    expect(leastCommonInterval('  20 h', '7d')).to.be('35d');
-  });
-
-  it('should correctly return lowest common interval for calendar units', () => {
-    expect(leastCommonInterval('1m', '1h')).to.be('1h');
-    expect(leastCommonInterval('1h', '1d')).to.be('1d');
-    expect(leastCommonInterval('1d', '1w')).to.be('1w');
-    expect(leastCommonInterval('1w', '1M')).to.be('1M');
-    expect(leastCommonInterval('1M', '1q')).to.be('1q');
-    expect(leastCommonInterval('1q', '1y')).to.be('1y');
-    expect(leastCommonInterval('1M', '1m')).to.be('1M');
-    expect(leastCommonInterval('1y', '1w')).to.be('1y');
-  });
-
-  it('should throw an error for intervals of different types', () => {
-    expect(leastCommonInterval)
-      .withArgs('60 s', '1m')
-      .to.throwError();
-    expect(leastCommonInterval)
-      .withArgs('1d', '7d')
-      .to.throwError();
-    expect(leastCommonInterval)
-      .withArgs('1h', '3d')
-      .to.throwError();
-    expect(leastCommonInterval)
-      .withArgs('7d', '1w')
-      .to.throwError();
-    expect(leastCommonInterval)
-      .withArgs('1M', '1000ms')
-      .to.throwError();
-  });
-
-  it('should throw an error for invalid intervals', () => {
-    expect(leastCommonInterval)
-      .withArgs()
-      .to.throwError();
-    expect(leastCommonInterval)
-      .withArgs({})
-      .to.throwError();
-    expect(leastCommonInterval)
-      .withArgs({}, {})
-      .to.throwError();
-    expect(leastCommonInterval)
-      .withArgs(123, '456')
-      .to.throwError();
-    expect(leastCommonInterval)
-      .withArgs('foo', 'bar')
-      .to.throwError();
-    expect(leastCommonInterval)
-      .withArgs('0h', '1h')
-      .to.throwError();
-    expect(leastCommonInterval)
-      .withArgs('0.5h', '1h')
-      .to.throwError();
-    expect(leastCommonInterval)
-      .withArgs('5w', '1h')
-      .to.throwError();
-    expect(leastCommonInterval)
-      .withArgs('2M', '4w')
-      .to.throwError();
-  });
-});
diff --git a/src/ui/public/vis/lib/least_common_interval.test.ts b/src/ui/public/vis/lib/least_common_interval.test.ts
new file mode 100644
index 00000000000000..ad59b548472472
--- /dev/null
+++ b/src/ui/public/vis/lib/least_common_interval.test.ts
@@ -0,0 +1,85 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { leastCommonInterval } from './least_common_interval';
+
+describe('leastCommonInterval', () => {
+  it('should correctly return lowest common interval for fixed units', () => {
+    expect(leastCommonInterval('1ms', '1s')).toBe('1s');
+    expect(leastCommonInterval('500ms', '1s')).toBe('1s');
+    expect(leastCommonInterval('1000ms', '1s')).toBe('1s');
+    expect(leastCommonInterval('1500ms', '1s')).toBe('3s');
+    expect(leastCommonInterval('1234ms', '1s')).toBe('617s');
+    expect(leastCommonInterval('1s', '2m')).toBe('2m');
+    expect(leastCommonInterval('300s', '2m')).toBe('10m');
+    expect(leastCommonInterval('1234ms', '7m')).toBe('4319m');
+    expect(leastCommonInterval('45m', '2h')).toBe('6h');
+    expect(leastCommonInterval('12h', '4d')).toBe('4d');
+    expect(leastCommonInterval('  20 h', '7d')).toBe('35d');
+  });
+
+  it('should correctly return lowest common interval for calendar units', () => {
+    expect(leastCommonInterval('1m', '1h')).toBe('1h');
+    expect(leastCommonInterval('1h', '1d')).toBe('1d');
+    expect(leastCommonInterval('1d', '1w')).toBe('1w');
+    expect(leastCommonInterval('1w', '1M')).toBe('1M');
+    expect(leastCommonInterval('1M', '1y')).toBe('1y');
+    expect(leastCommonInterval('1M', '1m')).toBe('1M');
+    expect(leastCommonInterval('1y', '1w')).toBe('1y');
+  });
+
+  it('should throw an error for intervals of different types', () => {
+    expect(() => {
+      leastCommonInterval('60 s', '1m');
+    }).toThrowError();
+    expect(() => {
+      leastCommonInterval('1d', '7d');
+    }).toThrowError();
+    expect(() => {
+      leastCommonInterval('1h', '3d');
+    }).toThrowError();
+    expect(() => {
+      leastCommonInterval('7d', '1w');
+    }).toThrowError();
+    expect(() => {
+      leastCommonInterval('1M', '1000ms');
+    }).toThrowError();
+  });
+
+  it('should throw an error for invalid intervals', () => {
+    expect(() => {
+      leastCommonInterval();
+    }).toThrowError();
+    expect(() => {
+      leastCommonInterval('foo', 'bar');
+    }).toThrowError();
+    expect(() => {
+      leastCommonInterval('0h', '1h');
+    }).toThrowError();
+    expect(() => {
+      leastCommonInterval('0.5h', '1h');
+    }).toThrowError();
+    expect(() => {
+      leastCommonInterval('5w', '1h');
+    }).toThrowError();
+    expect(() => {
+      leastCommonInterval('2M', '4w');
+    }).toThrowError();
+  });
+});
diff --git a/src/ui/public/vis/lib/least_common_interval.js b/src/ui/public/vis/lib/least_common_interval.ts
similarity index 100%
rename from src/ui/public/vis/lib/least_common_interval.js
rename to src/ui/public/vis/lib/least_common_interval.ts

From 4346edb3e3c71b080b4c3fa472ce8d136a4e0cbe Mon Sep 17 00:00:00 2001
From: Jen Huang <its.jenetic@gmail.com>
Date: Tue, 4 Sep 2018 16:40:18 -0700
Subject: [PATCH 6/7] Fix typings, PR feedback

---
 packages/kbn-datemath/package.json            |  3 +-
 packages/kbn-datemath/src/index.d.ts          | 29 ++++++++++
 packages/kbn-datemath/tsconfig.json           | 10 ++++
 .../utils/__tests__/parse_es_interval.js      | 57 -------------------
 src/ui/public/utils/parse_es_interval.test.ts | 54 ++++++++++++++++++
 src/ui/public/utils/parse_es_interval.ts      | 27 +++++++--
 src/ui/public/validate_date_interval.js       |  4 +-
 .../editors/config/editor_config_providers.ts |  4 +-
 .../vis/lib/least_common_interval.test.ts     |  3 -
 .../public/vis/lib/least_common_interval.ts   | 10 +++-
 10 files changed, 127 insertions(+), 74 deletions(-)
 create mode 100644 packages/kbn-datemath/src/index.d.ts
 create mode 100644 packages/kbn-datemath/tsconfig.json
 delete mode 100644 src/ui/public/utils/__tests__/parse_es_interval.js
 create mode 100644 src/ui/public/utils/parse_es_interval.test.ts

diff --git a/packages/kbn-datemath/package.json b/packages/kbn-datemath/package.json
index 5338b65d83f2dc..c469661070816f 100644
--- a/packages/kbn-datemath/package.json
+++ b/packages/kbn-datemath/package.json
@@ -5,8 +5,9 @@
   "license": "Apache-2.0",
   "private": true,
   "main": "target/index.js",
+  "typings": "target/index.d.ts",
   "scripts": {
-    "build": "babel src --out-dir target",
+    "build": "babel src --out-dir target --copy-files",
     "kbn:bootstrap": "yarn build",
     "kbn:watch": "yarn build --watch"
   },
diff --git a/packages/kbn-datemath/src/index.d.ts b/packages/kbn-datemath/src/index.d.ts
new file mode 100644
index 00000000000000..e3389fb255700f
--- /dev/null
+++ b/packages/kbn-datemath/src/index.d.ts
@@ -0,0 +1,29 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+declare module '@kbn/datemath' {
+  const dateMath: {
+    parse: any;
+    unitsMap: any;
+    units: string[];
+    unitsAsc: string[];
+    unitsDesc: string[];
+  };
+  export default dateMath;
+}
diff --git a/packages/kbn-datemath/tsconfig.json b/packages/kbn-datemath/tsconfig.json
new file mode 100644
index 00000000000000..c23b6635a5c19e
--- /dev/null
+++ b/packages/kbn-datemath/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "./target"
+  },
+  "include": [
+    "./src/**/*.ts"
+  ]
+}
diff --git a/src/ui/public/utils/__tests__/parse_es_interval.js b/src/ui/public/utils/__tests__/parse_es_interval.js
deleted file mode 100644
index 5ee9113b31dcef..00000000000000
--- a/src/ui/public/utils/__tests__/parse_es_interval.js
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-import { parseEsInterval } from '../parse_es_interval';
-import expect from 'expect.js';
-
-describe('parseEsInterval', function () {
-  it('should correctly parse an interval containing unit and single value', function () {
-    expect(parseEsInterval('1ms')).to.eql({ value: 1, unit: 'ms', type: 'fixed' });
-    expect(parseEsInterval('1s')).to.eql({ value: 1, unit: 's', type: 'fixed' });
-    expect(parseEsInterval('1m')).to.eql({ value: 1, unit: 'm', type: 'calendar' });
-    expect(parseEsInterval('1h')).to.eql({ value: 1, unit: 'h', type: 'calendar' });
-    expect(parseEsInterval('1d')).to.eql({ value: 1, unit: 'd', type: 'calendar' });
-    expect(parseEsInterval('1w')).to.eql({ value: 1, unit: 'w', type: 'calendar' });
-    expect(parseEsInterval('1M')).to.eql({ value: 1, unit: 'M', type: 'calendar' });
-    expect(parseEsInterval('1y')).to.eql({ value: 1, unit: 'y', type: 'calendar' });
-  });
-
-  it('should correctly parse an interval containing unit and multiple value', function () {
-    expect(parseEsInterval('250ms')).to.eql({ value: 250, unit: 'ms', type: 'fixed' });
-    expect(parseEsInterval('90s')).to.eql({ value: 90, unit: 's', type: 'fixed' });
-    expect(parseEsInterval('60m')).to.eql({ value: 60, unit: 'm', type: 'fixed' });
-    expect(parseEsInterval('12h')).to.eql({ value: 12, unit: 'h', type: 'fixed' });
-    expect(parseEsInterval('7d')).to.eql({ value: 7, unit: 'd', type: 'fixed' });
-  });
-
-  it('should throw an error for intervals containing calendar unit and multiple value', function () {
-    expect(parseEsInterval).withArgs('4w').to.throwError();
-    expect(parseEsInterval).withArgs('12M').to.throwError();
-    expect(parseEsInterval).withArgs('10y').to.throwError();
-  });
-
-  it('should throw an error for invalid interval formats', function () {
-    expect(parseEsInterval).withArgs('1').to.throwError();
-    expect(parseEsInterval).withArgs('h').to.throwError();
-    expect(parseEsInterval).withArgs('0m').to.throwError();
-    expect(parseEsInterval).withArgs('0.5h').to.throwError();
-    expect(parseEsInterval).withArgs().to.throwError();
-    expect(parseEsInterval).withArgs({}).to.throwError();
-  });
-});
diff --git a/src/ui/public/utils/parse_es_interval.test.ts b/src/ui/public/utils/parse_es_interval.test.ts
new file mode 100644
index 00000000000000..05b29a5fb69e71
--- /dev/null
+++ b/src/ui/public/utils/parse_es_interval.test.ts
@@ -0,0 +1,54 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { parseEsInterval } from './parse_es_interval';
+
+describe('parseEsInterval', () => {
+  it('should correctly parse an interval containing unit and single value', () => {
+    expect(parseEsInterval('1ms')).toEqual({ value: 1, unit: 'ms', type: 'fixed' });
+    expect(parseEsInterval('1s')).toEqual({ value: 1, unit: 's', type: 'fixed' });
+    expect(parseEsInterval('1m')).toEqual({ value: 1, unit: 'm', type: 'calendar' });
+    expect(parseEsInterval('1h')).toEqual({ value: 1, unit: 'h', type: 'calendar' });
+    expect(parseEsInterval('1d')).toEqual({ value: 1, unit: 'd', type: 'calendar' });
+    expect(parseEsInterval('1w')).toEqual({ value: 1, unit: 'w', type: 'calendar' });
+    expect(parseEsInterval('1M')).toEqual({ value: 1, unit: 'M', type: 'calendar' });
+    expect(parseEsInterval('1y')).toEqual({ value: 1, unit: 'y', type: 'calendar' });
+  });
+
+  it('should correctly parse an interval containing unit and multiple value', () => {
+    expect(parseEsInterval('250ms')).toEqual({ value: 250, unit: 'ms', type: 'fixed' });
+    expect(parseEsInterval('90s')).toEqual({ value: 90, unit: 's', type: 'fixed' });
+    expect(parseEsInterval('60m')).toEqual({ value: 60, unit: 'm', type: 'fixed' });
+    expect(parseEsInterval('12h')).toEqual({ value: 12, unit: 'h', type: 'fixed' });
+    expect(parseEsInterval('7d')).toEqual({ value: 7, unit: 'd', type: 'fixed' });
+  });
+
+  it('should throw an error for intervals containing calendar unit and multiple value', () => {
+    expect(() => parseEsInterval('4w')).toThrowError();
+    expect(() => parseEsInterval('12M')).toThrowError();
+    expect(() => parseEsInterval('10y')).toThrowError();
+  });
+
+  it('should throw an error for invalid interval formats', () => {
+    expect(() => parseEsInterval('1')).toThrowError();
+    expect(() => parseEsInterval('h')).toThrowError();
+    expect(() => parseEsInterval('0m')).toThrowError();
+    expect(() => parseEsInterval('0.5h')).toThrowError();
+  });
+});
diff --git a/src/ui/public/utils/parse_es_interval.ts b/src/ui/public/utils/parse_es_interval.ts
index 4e047835a287c6..984f7e278d4fb1 100644
--- a/src/ui/public/utils/parse_es_interval.ts
+++ b/src/ui/public/utils/parse_es_interval.ts
@@ -18,18 +18,33 @@
  */
 import dateMath from '@kbn/datemath';
 
-const ES_INTERVAL_STRING_RE = new RegExp('^([1-9][0-9]*)\\s*(' + dateMath.units.join('|') + ')$');
+const ES_INTERVAL_STRING_REGEX = new RegExp(
+  '^([1-9][0-9]*)\\s*(' + dateMath.units.join('|') + ')$'
+);
 
 /**
- * Strict version of parseInterval(), enforces ES interval format, and disallows fractional values
+ * Extracts interval properties from an ES interval string. Disallows unrecognized interval formats
+ * and fractional values. Converts some intervals from "calendar" to "fixed" when the number of
+ * units is larger than 1, and throws an error for others.
+ *
+ * Conversion rules:
+ *
+ * | Interval | Single unit type | Multiple units type |
+ * | -------- | ---------------- | ------------------- |
+ * | ms       | fixed            | fixed               |
+ * | s        | fixed            | fixed               |
+ * | m        | fixed            | fixed               |
+ * | h        | calendar         | fixed               |
+ * | d        | calendar         | fixed               |
+ * | w        | calendar         | N/A - disallowed    |
+ * | M        | calendar         | N/A - disallowed    |
+ * | y        | calendar         | N/A - disallowed    |
  *
- * @param interval
- * @returns {{amount: (RegExpMatchArray | null) | number, unit: (RegExpMatchArray | null) | string, type: string}}
  */
-export function parseEsInterval(interval = '') {
+export function parseEsInterval(interval: string): { value: number; unit: string; type: string } {
   const matches = String(interval)
     .trim()
-    .match(ES_INTERVAL_STRING_RE);
+    .match(ES_INTERVAL_STRING_REGEX);
 
   if (!matches) {
     throw Error(`Invalid interval format: ${interval}`);
diff --git a/src/ui/public/validate_date_interval.js b/src/ui/public/validate_date_interval.js
index 4be14542eb33e2..a315d4eaaa0b70 100644
--- a/src/ui/public/validate_date_interval.js
+++ b/src/ui/public/validate_date_interval.js
@@ -47,8 +47,8 @@ uiModules
         // multiple of the base interval.
         function parseWithBase(value) {
           try {
-            const lci = leastCommonInterval(baseInterval, value);
-            return lci === value.replace(/\s/g, '');
+            const interval = leastCommonInterval(baseInterval, value);
+            return interval === value.replace(/\s/g, '');
           } catch(e) {
             return false;
           }
diff --git a/src/ui/public/vis/editors/config/editor_config_providers.ts b/src/ui/public/vis/editors/config/editor_config_providers.ts
index e0c7ddb6ac1f9c..6175b897f62fea 100644
--- a/src/ui/public/vis/editors/config/editor_config_providers.ts
+++ b/src/ui/public/vis/editors/config/editor_config_providers.ts
@@ -102,7 +102,7 @@ class EditorConfigProviderRegistry {
     }
 
     if (this.isBaseParam(current) && this.isBaseParam(merged)) {
-      // In case both had where interval values, just use the least common multiple between both interval
+      // In case where both had interval values, just use the least common multiple between both interval
       return {
         base: leastCommonMultiple(current.base, merged.base),
       };
@@ -134,7 +134,7 @@ class EditorConfigProviderRegistry {
     }
 
     if (this.isTimeBaseParam(current) && this.isTimeBaseParam(merged)) {
-      // In case both had where interval values, just use the least common multiple between both interval
+      // In case both had where interval values, just use the least common multiple between both intervals
       try {
         const timeBase = leastCommonInterval(current.timeBase, merged.timeBase);
         return {
diff --git a/src/ui/public/vis/lib/least_common_interval.test.ts b/src/ui/public/vis/lib/least_common_interval.test.ts
index ad59b548472472..f19b5c51f68b33 100644
--- a/src/ui/public/vis/lib/least_common_interval.test.ts
+++ b/src/ui/public/vis/lib/least_common_interval.test.ts
@@ -63,9 +63,6 @@ describe('leastCommonInterval', () => {
   });
 
   it('should throw an error for invalid intervals', () => {
-    expect(() => {
-      leastCommonInterval();
-    }).toThrowError();
     expect(() => {
       leastCommonInterval('foo', 'bar');
     }).toThrowError();
diff --git a/src/ui/public/vis/lib/least_common_interval.ts b/src/ui/public/vis/lib/least_common_interval.ts
index a27f364708988c..bbe3e6d4ee7c5a 100644
--- a/src/ui/public/vis/lib/least_common_interval.ts
+++ b/src/ui/public/vis/lib/least_common_interval.ts
@@ -31,11 +31,9 @@ import { parseEsInterval } from '../../utils/parse_es_interval';
  *  - `w, M, q, y` units are calendar intervals and do not support multiple, aka
  *    value must === 1
  *
- * @param {string} a
- * @param {string} b
  * @returns {string}
  */
-export function leastCommonInterval(a = '', b = '') {
+export function leastCommonInterval(a: string, b: string): string {
   const { unitsMap, unitsDesc } = dateMath;
   const aInt = parseEsInterval(a);
   const bInt = parseEsInterval(b);
@@ -73,6 +71,12 @@ export function leastCommonInterval(a = '', b = '') {
   // Otherwise find the biggest unit that divides evenly
   const lcmUnit = unitsDesc.find(unit => unitsMap[unit].base && lcmMs % unitsMap[unit].base === 0);
 
+  // Throw error in case we couldn't divide evenly, theoretically we never get here as everything is
+  // divisible by 1 millisecond
+  if (!lcmUnit) {
+    throw Error(`Unable to find common interval for: ${a}, ${b}`);
+  }
+
   // Return the interval string
   return `${lcmMs / unitsMap[lcmUnit].base}${lcmUnit}`;
 }

From 415c5733e17185e8df044c9f8a73cf6004d022a5 Mon Sep 17 00:00:00 2001
From: Jen Huang <its.jenetic@gmail.com>
Date: Wed, 5 Sep 2018 11:28:36 -0700
Subject: [PATCH 7/7] Fix ordering of units to maintain parity with original

---
 packages/kbn-datemath/src/index.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/kbn-datemath/src/index.js b/packages/kbn-datemath/src/index.js
index e64cb6327b9fd3..6576a458fe77b6 100644
--- a/packages/kbn-datemath/src/index.js
+++ b/packages/kbn-datemath/src/index.js
@@ -30,9 +30,9 @@ const unitsMap = {
   // q: { weight: 8, type: 'calendar' }, // TODO: moment duration does not support quarter
   y: { weight: 9, type: 'calendar' },
 };
-const units = Object.keys(unitsMap).sort((a, b) => unitsMap[a].weight - unitsMap[b].weight);
-const unitsDesc = [...units].reverse();
-const unitsAsc = [...units];
+const units = Object.keys(unitsMap).sort((a, b) => unitsMap[b].weight - unitsMap[a].weight);
+const unitsDesc = [...units];
+const unitsAsc = [...units].reverse();
 
 const isDate = d => Object.prototype.toString.call(d) === '[object Date]';