@cubejs-client/core 0.30.29 → 0.30.64

package/dist/cubejs-client-core.esm.js

@@ -1,76 +1,13 @@
-import 'core-js/modules/es.object.keys.js';
-import 'core-js/modules/es.symbol.js';
-import 'core-js/modules/es.array.filter.js';
-import 'core-js/modules/es.object.get-own-property-descriptor.js';
-import 'core-js/modules/es.object.get-own-property-descriptors.js';
-import 'core-js/modules/es.object.define-properties.js';
-import 'core-js/modules/es.object.define-property.js';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import _typeof from '@babel/runtime/helpers/typeof';
-import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
-import _createClass from '@babel/runtime/helpers/createClass';
-import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
-import _regeneratorRuntime from '@babel/runtime/regenerator';
-import 'core-js/modules/es.object.to-string.js';
-import 'core-js/modules/es.promise.js';
-import 'core-js/modules/es.array.is-array.js';
-import 'core-js/modules/web.timers.js';
-import 'core-js/modules/es.array.for-each.js';
-import 'core-js/modules/web.dom-collections.for-each.js';
-import 'core-js/modules/es.array.map.js';
-import 'core-js/modules/es.function.bind.js';
 import { v4 } from 'uuid';
-import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import 'core-js/modules/es.array.iterator.js';
-import 'core-js/modules/es.map.js';
-import 'core-js/modules/es.string.iterator.js';
-import 'core-js/modules/web.dom-collections.iterator.js';
-import 'core-js/modules/es.array.from.js';
-import 'core-js/modules/es.array.includes.js';
-import 'core-js/modules/es.string.includes.js';
-import 'core-js/modules/es.object.values.js';
-import 'core-js/modules/es.array.find.js';
-import 'core-js/modules/es.array.concat.js';
-import 'core-js/modules/es.regexp.exec.js';
-import 'core-js/modules/es.string.split.js';
-import 'core-js/modules/es.array.join.js';
-import 'core-js/modules/es.date.to-string.js';
-import 'core-js/modules/es.regexp.to-string.js';
-import 'core-js/modules/es.string.match.js';
-import 'core-js/modules/es.array.reduce.js';
-import 'core-js/modules/es.number.is-nan.js';
-import 'core-js/modules/es.number.constructor.js';
-import 'core-js/modules/es.number.parse-float.js';
-import 'core-js/modules/es.set.js';
-import 'core-js/modules/es.array.index-of.js';
-import 'core-js/modules/es.string.trim.js';
 import dayjs from 'dayjs';
 import quarterOfYear from 'dayjs/plugin/quarterOfYear';
 import en from 'dayjs/locale/en';
-import { fromPairs, toPairs, equals, clone, indexBy, prop, pipe, map, filter, reduce, minBy, maxBy, flatten, pluck, mergeDeepLeft, mergeAll, uniq, dropLast, groupBy, unnest as unnest$1 } from 'ramda';
-import 'core-js/modules/es.object.entries.js';
-import 'core-js/modules/es.array.every.js';
-import 'core-js/modules/es.array.splice.js';
-import 'core-js/modules/es.function.name.js';
-import 'core-js/modules/es.array.sort.js';
-import 'core-js/modules/web.url-search-params.js';
+import { fromPairs, toPairs, equals, clone, indexBy, prop, mergeDeepLeft, pipe, map, filter, reduce, minBy, maxBy, flatten, pluck, mergeAll, uniq, dropLast, groupBy, unnest as unnest$1 } from 'ramda';
 import fetch from 'cross-fetch';
 import 'url-search-params-polyfill';
-import 'core-js/modules/es.reflect.construct.js';
-import _inherits from '@babel/runtime/helpers/inherits';
-import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
-import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
-import _wrapNativeSuper from '@babel/runtime/helpers/wrapNativeSuper';
 
-var _excluded$2 = ["query"];
-
-function ownKeys$3(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread$3(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$3(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$3(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var DEFAULT_GRANULARITY = 'day';
-var GRANULARITIES = [{
+const DEFAULT_GRANULARITY = 'day';
+const GRANULARITIES = [{
   name: undefined,
   title: 'w/o grouping'
 }, {
@@ -99,12 +36,8 @@ var GRANULARITIES = [{
   title: 'Year'
 }];
 function removeEmptyQueryFields(_query) {
-  var query = _query || {};
-  return fromPairs(toPairs(query).map(function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 2),
-        key = _ref2[0],
-        value = _ref2[1];
-
+  const query = _query || {};
+  return fromPairs(toPairs(query).map(([key, value]) => {
     if (['measures', 'dimensions', 'segments', 'timeDimensions', 'filters'].includes(key)) {
       if (Array.isArray(value) && value.length === 0) {
         return null;
@@ -123,53 +56,49 @@ function removeEmptyQueryFields(_query) {
   }).filter(Boolean));
 }
 function validateQuery(_query) {
-  var query = _query || {};
-  return removeEmptyQueryFields(_objectSpread$3(_objectSpread$3({}, query), {}, {
-    filters: (query.filters || []).filter(function (f) {
-      return f.operator;
-    }),
-    timeDimensions: (query.timeDimensions || []).filter(function (td) {
-      return !(!td.dateRange && !td.granularity);
-    })
-  }));
+  const query = _query || {};
+  return removeEmptyQueryFields({ ...query,
+    filters: (query.filters || []).filter(f => f.operator),
+    timeDimensions: (query.timeDimensions || []).filter(td => !(!td.dateRange && !td.granularity))
+  });
 }
-function areQueriesEqual() {
-  var query1 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var query2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+function areQueriesEqual(query1 = {}, query2 = {}) {
   return equals(Object.entries(query1 && query1.order || {}), Object.entries(query2 && query2.order || {})) && equals(query1, query2);
 }
 function defaultOrder(query) {
-  var granularity = (query.timeDimensions || []).find(function (d) {
-    return d.granularity;
-  });
+  const granularity = (query.timeDimensions || []).find(d => d.granularity);
 
   if (granularity) {
-    return _defineProperty({}, granularity.dimension, 'asc');
+    return {
+      [granularity.dimension]: 'asc'
+    };
   } else if ((query.measures || []).length > 0 && (query.dimensions || []).length > 0) {
-    return _defineProperty({}, query.measures[0], 'desc');
+    return {
+      [query.measures[0]]: 'desc'
+    };
   } else if ((query.dimensions || []).length > 0) {
-    return _defineProperty({}, query.dimensions[0], 'asc');
+    return {
+      [query.dimensions[0]]: 'asc'
+    };
   }
 
   return {};
 }
-function defaultHeuristics(newState) {
-  var oldQuery = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var options = arguments.length > 2 ? arguments[2] : undefined;
-
-  var _clone = clone(newState),
-      query = _clone.query,
-      props = _objectWithoutProperties(_clone, _excluded$2);
-
-  var meta = options.meta,
-      sessionGranularity = options.sessionGranularity;
-  var granularity = sessionGranularity || DEFAULT_GRANULARITY;
-
-  var state = _objectSpread$3({
-    query: query
-  }, props);
-
-  var newQuery = null;
+function defaultHeuristics(newState, oldQuery = {}, options) {
+  const {
+    query,
+    ...props
+  } = clone(newState);
+  const {
+    meta,
+    sessionGranularity
+  } = options;
+  const granularity = sessionGranularity || DEFAULT_GRANULARITY;
+  let state = {
+    query,
+    ...props
+  };
+  let newQuery = null;
 
   if (!areQueriesEqual(query, oldQuery)) {
     newQuery = query;
@@ -181,110 +110,99 @@ function defaultHeuristics(newState) {
 
   if (newQuery) {
     if ((oldQuery.timeDimensions || []).length === 1 && (newQuery.timeDimensions || []).length === 1 && newQuery.timeDimensions[0].granularity && oldQuery.timeDimensions[0].granularity !== newQuery.timeDimensions[0].granularity) {
-      state = _objectSpread$3(_objectSpread$3({}, state), {}, {
+      state = { ...state,
         sessionGranularity: newQuery.timeDimensions[0].granularity
-      });
+      };
     }
 
     if ((oldQuery.measures || []).length === 0 && (newQuery.measures || []).length > 0 || (oldQuery.measures || []).length === 1 && (newQuery.measures || []).length === 1 && oldQuery.measures[0] !== newQuery.measures[0]) {
-      var _ref6 = newQuery.timeDimensions || [],
-          _ref7 = _slicedToArray(_ref6, 1),
-          td = _ref7[0];
-
-      var defaultTimeDimension = meta.defaultTimeDimensionNameFor(newQuery.measures[0]);
-      newQuery = _objectSpread$3(_objectSpread$3({}, newQuery), {}, {
+      const [td] = newQuery.timeDimensions || [];
+      const defaultTimeDimension = meta.defaultTimeDimensionNameFor(newQuery.measures[0]);
+      newQuery = { ...newQuery,
         timeDimensions: defaultTimeDimension ? [{
           dimension: defaultTimeDimension,
           granularity: td && td.granularity || granularity,
           dateRange: td && td.dateRange
         }] : []
-      });
-      return _objectSpread$3(_objectSpread$3({}, state), {}, {
+      };
+      return { ...state,
         pivotConfig: null,
         shouldApplyHeuristicOrder: true,
         query: newQuery,
         chartType: defaultTimeDimension ? 'line' : 'number'
-      });
+      };
     }
 
     if ((oldQuery.dimensions || []).length === 0 && (newQuery.dimensions || []).length > 0) {
-      newQuery = _objectSpread$3(_objectSpread$3({}, newQuery), {}, {
-        timeDimensions: (newQuery.timeDimensions || []).map(function (td) {
-          return _objectSpread$3(_objectSpread$3({}, td), {}, {
-            granularity: undefined
-          });
-        })
-      });
-      return _objectSpread$3(_objectSpread$3({}, state), {}, {
+      newQuery = { ...newQuery,
+        timeDimensions: (newQuery.timeDimensions || []).map(td => ({ ...td,
+          granularity: undefined
+        }))
+      };
+      return { ...state,
         pivotConfig: null,
         shouldApplyHeuristicOrder: true,
         query: newQuery,
         chartType: 'table'
-      });
+      };
     }
 
     if ((oldQuery.dimensions || []).length > 0 && (newQuery.dimensions || []).length === 0) {
-      newQuery = _objectSpread$3(_objectSpread$3({}, newQuery), {}, {
-        timeDimensions: (newQuery.timeDimensions || []).map(function (td) {
-          return _objectSpread$3(_objectSpread$3({}, td), {}, {
-            granularity: td.granularity || granularity
-          });
-        })
-      });
-      return _objectSpread$3(_objectSpread$3({}, state), {}, {
+      newQuery = { ...newQuery,
+        timeDimensions: (newQuery.timeDimensions || []).map(td => ({ ...td,
+          granularity: td.granularity || granularity
+        }))
+      };
+      return { ...state,
         pivotConfig: null,
         shouldApplyHeuristicOrder: true,
         query: newQuery,
         chartType: (newQuery.timeDimensions || []).length ? 'line' : 'number'
-      });
+      };
     }
 
     if (((oldQuery.dimensions || []).length > 0 || (oldQuery.measures || []).length > 0) && (newQuery.dimensions || []).length === 0 && (newQuery.measures || []).length === 0) {
-      newQuery = _objectSpread$3(_objectSpread$3({}, newQuery), {}, {
+      newQuery = { ...newQuery,
         timeDimensions: [],
         filters: []
-      });
-      return _objectSpread$3(_objectSpread$3({}, state), {}, {
+      };
+      return { ...state,
         pivotConfig: null,
         shouldApplyHeuristicOrder: true,
         query: newQuery,
         sessionGranularity: null
-      });
+      };
     }
 
     return state;
   }
 
   if (state.chartType) {
-    var newChartType = state.chartType;
+    const newChartType = state.chartType;
 
     if ((newChartType === 'line' || newChartType === 'area') && (oldQuery.timeDimensions || []).length === 1 && !oldQuery.timeDimensions[0].granularity) {
-      var _oldQuery$timeDimensi = _slicedToArray(oldQuery.timeDimensions, 1),
-          _td = _oldQuery$timeDimensi[0];
-
-      return _objectSpread$3(_objectSpread$3({}, state), {}, {
+      const [td] = oldQuery.timeDimensions;
+      return { ...state,
         pivotConfig: null,
-        query: _objectSpread$3(_objectSpread$3({}, oldQuery), {}, {
-          timeDimensions: [_objectSpread$3(_objectSpread$3({}, _td), {}, {
-            granularity: granularity
-          })]
-        })
-      });
+        query: { ...oldQuery,
+          timeDimensions: [{ ...td,
+            granularity
+          }]
+        }
+      };
     }
 
     if ((newChartType === 'pie' || newChartType === 'table' || newChartType === 'number') && (oldQuery.timeDimensions || []).length === 1 && oldQuery.timeDimensions[0].granularity) {
-      var _oldQuery$timeDimensi2 = _slicedToArray(oldQuery.timeDimensions, 1),
-          _td2 = _oldQuery$timeDimensi2[0];
-
-      return _objectSpread$3(_objectSpread$3({}, state), {}, {
+      const [td] = oldQuery.timeDimensions;
+      return { ...state,
         pivotConfig: null,
         shouldApplyHeuristicOrder: true,
-        query: _objectSpread$3(_objectSpread$3({}, oldQuery), {}, {
-          timeDimensions: [_objectSpread$3(_objectSpread$3({}, _td2), {}, {
+        query: { ...oldQuery,
+          timeDimensions: [{ ...td,
             granularity: undefined
-          })]
-        })
-      });
+          }]
+        }
+      };
     }
   }
 
@@ -295,18 +213,15 @@ function isQueryPresent(query) {
     return false;
   }
 
-  return (Array.isArray(query) ? query : [query]).every(function (q) {
-    return q.measures && q.measures.length || q.dimensions && q.dimensions.length || q.timeDimensions && q.timeDimensions.length;
-  });
+  return (Array.isArray(query) ? query : [query]).every(q => q.measures && q.measures.length || q.dimensions && q.dimensions.length || q.timeDimensions && q.timeDimensions.length);
 }
 function movePivotItem(pivotConfig, sourceIndex, destinationIndex, sourceAxis, destinationAxis) {
-  var nextPivotConfig = _objectSpread$3(_objectSpread$3({}, pivotConfig), {}, {
-    x: _toConsumableArray(pivotConfig.x),
-    y: _toConsumableArray(pivotConfig.y)
-  });
-
-  var id = pivotConfig[sourceAxis][sourceIndex];
-  var lastIndex = nextPivotConfig[destinationAxis].length - 1;
+  const nextPivotConfig = { ...pivotConfig,
+    x: [...pivotConfig.x],
+    y: [...pivotConfig.y]
+  };
+  const id = pivotConfig[sourceAxis][sourceIndex];
+  const lastIndex = nextPivotConfig[destinationAxis].length - 1;
 
   if (id === 'measures') {
     destinationIndex = lastIndex + 1;
@@ -319,148 +234,87 @@ function movePivotItem(pivotConfig, sourceIndex, destinationIndex, sourceAxis, d
   return nextPivotConfig;
 }
 function moveItemInArray(list, sourceIndex, destinationIndex) {
-  var result = _toConsumableArray(list);
-
-  var _result$splice = result.splice(sourceIndex, 1),
-      _result$splice2 = _slicedToArray(_result$splice, 1),
-      removed = _result$splice2[0];
-
+  const result = [...list];
+  const [removed] = result.splice(sourceIndex, 1);
   result.splice(destinationIndex, 0, removed);
   return result;
 }
-function flattenFilters() {
-  var filters = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-  return filters.reduce(function (memo, filter) {
+function flattenFilters(filters = []) {
+  return filters.reduce((memo, filter) => {
     if (filter.or || filter.and) {
-      return [].concat(_toConsumableArray(memo), _toConsumableArray(flattenFilters(filter.or || filter.and)));
+      return [...memo, ...flattenFilters(filter.or || filter.and)];
     }
 
-    return [].concat(_toConsumableArray(memo), [filter]);
+    return [...memo, filter];
   }, []);
 }
-function getQueryMembers() {
-  var query = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var keys = ['measures', 'dimensions', 'segments'];
-  var members = new Set();
-  keys.forEach(function (key) {
-    return (query[key] || []).forEach(function (member) {
-      return members.add(member);
-    });
-  });
-  (query.timeDimensions || []).forEach(function (td) {
-    return members.add(td.dimension);
-  });
-  flattenFilters(query.filters).forEach(function (filter) {
-    return members.add(filter.dimension || filter.member);
-  });
-  return _toConsumableArray(members);
+function getQueryMembers(query = {}) {
+  const keys = ['measures', 'dimensions', 'segments'];
+  const members = new Set();
+  keys.forEach(key => (query[key] || []).forEach(member => members.add(member)));
+  (query.timeDimensions || []).forEach(td => members.add(td.dimension));
+  flattenFilters(query.filters).forEach(filter => members.add(filter.dimension || filter.member));
+  return [...members];
 }
 function getOrderMembersFromOrder(orderMembers, order) {
-  var ids = new Set();
-  var indexedOrderMembers = indexBy(prop('id'), orderMembers);
-  var entries = Array.isArray(order) ? order : Object.entries(order || {});
-  var nextOrderMembers = [];
-  entries.forEach(function (_ref8) {
-    var _ref9 = _slicedToArray(_ref8, 2),
-        memberId = _ref9[0],
-        currentOrder = _ref9[1];
-
+  const ids = new Set();
+  const indexedOrderMembers = indexBy(prop('id'), orderMembers);
+  const entries = Array.isArray(order) ? order : Object.entries(order || {});
+  const nextOrderMembers = [];
+  entries.forEach(([memberId, currentOrder]) => {
     if (currentOrder !== 'none' && indexedOrderMembers[memberId]) {
       ids.add(memberId);
-      nextOrderMembers.push(_objectSpread$3(_objectSpread$3({}, indexedOrderMembers[memberId]), {}, {
+      nextOrderMembers.push({ ...indexedOrderMembers[memberId],
         order: currentOrder
-      }));
+      });
     }
   });
-  orderMembers.forEach(function (member) {
+  orderMembers.forEach(member => {
     if (!ids.has(member.id)) {
-      nextOrderMembers.push(_objectSpread$3(_objectSpread$3({}, member), {}, {
+      nextOrderMembers.push({ ...member,
         order: member.order || 'none'
-      }));
+      });
     }
   });
   return nextOrderMembers;
 }
 function aliasSeries(values, index, pivotConfig, duplicateMeasures) {
-  var nonNullValues = values.filter(function (value) {
-    return value != null;
-  });
+  const nonNullValues = values.filter(value => value != null);
 
   if (pivotConfig && pivotConfig.aliasSeries && pivotConfig.aliasSeries[index]) {
-    return [pivotConfig.aliasSeries[index]].concat(_toConsumableArray(nonNullValues));
+    return [pivotConfig.aliasSeries[index], ...nonNullValues];
   } else if (duplicateMeasures.has(nonNullValues[0])) {
-    return [index].concat(_toConsumableArray(nonNullValues));
+    return [index, ...nonNullValues];
   }
 
   return nonNullValues;
 }
 
-var _excluded$1 = ["x"],
-    _excluded2 = ["key"],
-    _excluded3 = ["title", "shortTitle"];
-
-function ownKeys$2(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$2(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$2(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 dayjs.extend(quarterOfYear); // When granularity is week, weekStart Value must be 1. However, since the client can change it globally (https://day.js.org/docs/en/i18n/changing-locale)
 // So the function below has been added.
 
-var internalDayjs = function internalDayjs() {
-  return dayjs.apply(void 0, arguments).locale(_objectSpread$2(_objectSpread$2({}, en), {}, {
-    weekStart: 1
-  }));
-};
+const internalDayjs = (...args) => dayjs(...args).locale({ ...en,
+  weekStart: 1
+});
 
-var TIME_SERIES = {
-  day: function day(range) {
-    return range.by('d').map(function (d) {
-      return d.format('YYYY-MM-DDT00:00:00.000');
-    });
-  },
-  month: function month(range) {
-    return range.snapTo('month').by('M').map(function (d) {
-      return d.format('YYYY-MM-01T00:00:00.000');
-    });
-  },
-  year: function year(range) {
-    return range.snapTo('year').by('y').map(function (d) {
-      return d.format('YYYY-01-01T00:00:00.000');
-    });
-  },
-  hour: function hour(range) {
-    return range.by('h').map(function (d) {
-      return d.format('YYYY-MM-DDTHH:00:00.000');
-    });
-  },
-  minute: function minute(range) {
-    return range.by('m').map(function (d) {
-      return d.format('YYYY-MM-DDTHH:mm:00.000');
-    });
-  },
-  second: function second(range) {
-    return range.by('s').map(function (d) {
-      return d.format('YYYY-MM-DDTHH:mm:ss.000');
-    });
-  },
-  week: function week(range) {
-    return range.snapTo('week').by('w').map(function (d) {
-      return d.startOf('week').format('YYYY-MM-DDT00:00:00.000');
-    });
-  },
-  quarter: function quarter(range) {
-    return range.snapTo('quarter').by('quarter').map(function (d) {
-      return d.startOf('quarter').format('YYYY-MM-DDT00:00:00.000');
-    });
-  }
+const TIME_SERIES = {
+  day: range => range.by('d').map(d => d.format('YYYY-MM-DDT00:00:00.000')),
+  month: range => range.snapTo('month').by('M').map(d => d.format('YYYY-MM-01T00:00:00.000')),
+  year: range => range.snapTo('year').by('y').map(d => d.format('YYYY-01-01T00:00:00.000')),
+  hour: range => range.by('h').map(d => d.format('YYYY-MM-DDTHH:00:00.000')),
+  minute: range => range.by('m').map(d => d.format('YYYY-MM-DDTHH:mm:00.000')),
+  second: range => range.by('s').map(d => d.format('YYYY-MM-DDTHH:mm:ss.000')),
+  week: range => range.snapTo('week').by('w').map(d => d.startOf('week').format('YYYY-MM-DDT00:00:00.000')),
+  quarter: range => range.snapTo('quarter').by('quarter').map(d => d.startOf('quarter').format('YYYY-MM-DDT00:00:00.000'))
 };
-var DateRegex = /^\d\d\d\d-\d\d-\d\d$/;
-var LocalDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z?$/;
+const DateRegex = /^\d\d\d\d-\d\d-\d\d$/;
+const LocalDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z?$/;
 
-var groupByToPairs = function groupByToPairs(keyFn) {
-  var acc = new Map();
-  return function (data) {
-    data.forEach(function (row) {
-      var key = keyFn(row);
+const groupByToPairs = keyFn => {
+  const acc = new Map();
+  return data => {
+    data.forEach(row => {
+      const key = keyFn(row);
 
       if (!acc.has(key)) {
         acc.set(key, []);
@@ -472,49 +326,51 @@ var groupByToPairs = function groupByToPairs(keyFn) {
   };
 };
 
-var unnest = function unnest(arr) {
-  var res = [];
-  arr.forEach(function (subArr) {
-    subArr.forEach(function (element) {
-      return res.push(element);
-    });
+const unnest = arr => {
+  const res = [];
+  arr.forEach(subArr => {
+    subArr.forEach(element => res.push(element));
   });
   return res;
 };
 
-var dayRange = function dayRange(from, to) {
-  return {
-    by: function by(value) {
-      var results = [];
-      var start = internalDayjs(from);
-      var end = internalDayjs(to);
+const dayRange = (from, to) => ({
+  by: value => {
+    const results = [];
+    let start = internalDayjs(from);
+    const end = internalDayjs(to);
 
-      while (start.isBefore(end) || start.isSame(end)) {
-        results.push(start);
-        start = start.add(1, value);
-      }
+    while (start.isBefore(end) || start.isSame(end)) {
+      results.push(start);
+      start = start.add(1, value);
+    }
 
-      return results;
-    },
-    snapTo: function snapTo(value) {
-      return dayRange(internalDayjs(from).startOf(value), internalDayjs(to).endOf(value));
-    },
-    start: internalDayjs(from),
-    end: internalDayjs(to)
-  };
-};
-var QUERY_TYPE = {
+    return results;
+  },
+  snapTo: value => dayRange(internalDayjs(from).startOf(value), internalDayjs(to).endOf(value)),
+  start: internalDayjs(from),
+  end: internalDayjs(to)
+});
+const QUERY_TYPE = {
   REGULAR_QUERY: 'regularQuery',
   COMPARE_DATE_RANGE_QUERY: 'compareDateRangeQuery',
   BLENDING_QUERY: 'blendingQuery'
 };
 
-var ResultSet = /*#__PURE__*/function () {
-  function ResultSet(loadResponse) {
-    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+class ResultSet {
+  static measureFromAxis(axisValues) {
+    return axisValues[axisValues.length - 1];
+  }
+
+  static timeDimensionMember(td) {
+    return `${td.dimension}.${td.granularity}`;
+  }
 
-    _classCallCheck(this, ResultSet);
+  static deserialize(data, options = {}) {
+    return new ResultSet(data.loadResponse, options);
+  }
 
+  constructor(loadResponse, options = {}) {
     this.loadResponse = loadResponse;
 
     if (this.loadResponse.queryType != null) {
@@ -522,9 +378,9 @@ var ResultSet = /*#__PURE__*/function () {
       this.loadResponses = loadResponse.results;
     } else {
       this.queryType = QUERY_TYPE.REGULAR_QUERY;
-      this.loadResponse.pivotQuery = _objectSpread$2(_objectSpread$2({}, loadResponse.query), {}, {
+      this.loadResponse.pivotQuery = { ...loadResponse.query,
         queryType: this.queryType
-      });
+      };
       this.loadResponses = [loadResponse];
     }
 
@@ -537,803 +393,586 @@ var ResultSet = /*#__PURE__*/function () {
     this.backwardCompatibleData = [];
   }
 
-  _createClass(ResultSet, [{
-    key: "drillDown",
-    value: function drillDown(drillDownLocator, pivotConfig) {
-      if (this.queryType === QUERY_TYPE.COMPARE_DATE_RANGE_QUERY) {
-        throw new Error('compareDateRange drillDown query is not currently supported');
-      }
+  drillDown(drillDownLocator, pivotConfig) {
+    if (this.queryType === QUERY_TYPE.COMPARE_DATE_RANGE_QUERY) {
+      throw new Error('compareDateRange drillDown query is not currently supported');
+    }
 
-      if (this.queryType === QUERY_TYPE.BLENDING_QUERY) {
-        throw new Error('Data blending drillDown query is not currently supported');
-      }
+    if (this.queryType === QUERY_TYPE.BLENDING_QUERY) {
+      throw new Error('Data blending drillDown query is not currently supported');
+    }
 
-      var _drillDownLocator$xVa = drillDownLocator.xValues,
-          xValues = _drillDownLocator$xVa === void 0 ? [] : _drillDownLocator$xVa,
-          _drillDownLocator$yVa = drillDownLocator.yValues,
-          yValues = _drillDownLocator$yVa === void 0 ? [] : _drillDownLocator$yVa;
-      var normalizedPivotConfig = this.normalizePivotConfig(pivotConfig);
-      var values = [];
-      normalizedPivotConfig.x.forEach(function (member, currentIndex) {
-        return values.push([member, xValues[currentIndex]]);
-      });
-      normalizedPivotConfig.y.forEach(function (member, currentIndex) {
-        return values.push([member, yValues[currentIndex]]);
-      });
+    const {
+      xValues = [],
+      yValues = []
+    } = drillDownLocator;
+    const normalizedPivotConfig = this.normalizePivotConfig(pivotConfig);
+    const values = [];
+    normalizedPivotConfig.x.forEach((member, currentIndex) => values.push([member, xValues[currentIndex]]));
+    normalizedPivotConfig.y.forEach((member, currentIndex) => values.push([member, yValues[currentIndex]]));
+    const {
+      filters: parentFilters = [],
+      segments = []
+    } = this.query();
+    const {
+      measures
+    } = this.loadResponses[0].annotation;
+    let [, measureName] = values.find(([member]) => member === 'measures') || [];
+
+    if (measureName === undefined) {
+      [measureName] = Object.keys(measures);
+    }
 
-      var _this$query = this.query(),
-          _this$query$filters = _this$query.filters,
-          parentFilters = _this$query$filters === void 0 ? [] : _this$query$filters,
-          _this$query$segments = _this$query.segments,
-          segments = _this$query$segments === void 0 ? [] : _this$query$segments;
+    if (!(measures[measureName] && measures[measureName].drillMembers || []).length) {
+      return null;
+    }
 
-      var measures = this.loadResponses[0].annotation.measures;
+    const filters = [{
+      member: measureName,
+      operator: 'measureFilter'
+    }, ...parentFilters];
+    const timeDimensions = [];
+    values.filter(([member]) => member !== 'measures').forEach(([member, value]) => {
+      const [cubeName, dimension, granularity] = member.split('.');
+
+      if (granularity !== undefined) {
+        const range = dayRange(value, value).snapTo(granularity);
+        timeDimensions.push({
+          dimension: [cubeName, dimension].join('.'),
+          dateRange: [range.start, range.end].map(dt => dt.format('YYYY-MM-DDTHH:mm:ss.SSS'))
+        });
+      } else if (value == null) {
+        filters.push({
+          member,
+          operator: 'notSet'
+        });
+      } else {
+        filters.push({
+          member,
+          operator: 'equals',
+          values: [value.toString()]
+        });
+      }
+    });
+    const {
+      query
+    } = this.loadResponses[0];
 
-      var _ref = values.find(function (_ref3) {
-        var _ref4 = _slicedToArray(_ref3, 1),
-            member = _ref4[0];
+    if (timeDimensions.length === 0 && query.timeDimensions.length > 0 && query.timeDimensions[0].granularity == null) {
+      timeDimensions.push(query.timeDimensions[0]);
+    }
 
-        return member === 'measures';
-      }) || [],
-          _ref2 = _slicedToArray(_ref, 2),
-          measureName = _ref2[1];
+    return { ...measures[measureName].drillMembersGrouped,
+      filters,
+      ...(segments.length > 0 ? {
+        segments
+      } : {}),
+      timeDimensions,
+      segments,
+      timezone: query.timezone
+    };
+  }
 
-      if (measureName === undefined) {
-        var _Object$keys = Object.keys(measures);
+  series(pivotConfig) {
+    return this.seriesNames(pivotConfig).map(({
+      title,
+      key
+    }) => ({
+      title,
+      key,
+      series: this.chartPivot(pivotConfig).map(({
+        x,
+        ...obj
+      }) => ({
+        value: obj[key],
+        x
+      }))
+    }));
+  }
 
-        var _Object$keys2 = _slicedToArray(_Object$keys, 1);
+  axisValues(axis, resultIndex = 0) {
+    const {
+      query
+    } = this.loadResponses[resultIndex];
+    return row => {
+      const value = measure => axis.filter(d => d !== 'measures').map(d => row[d] != null ? row[d] : null).concat(measure ? [measure] : []);
 
-        measureName = _Object$keys2[0];
+      if (axis.find(d => d === 'measures') && (query.measures || []).length) {
+        return query.measures.map(value);
       }
 
-      if (!(measures[measureName] && measures[measureName].drillMembers || []).length) {
-        return null;
+      return [value()];
+    };
+  }
+
+  axisValuesString(axisValues, delimiter) {
+    const formatValue = v => {
+      if (v == null) {
+        return '∅';
+      } else if (v === '') {
+        return '[Empty string]';
+      } else {
+        return v;
       }
+    };
 
-      var filters = [{
-        member: measureName,
-        operator: 'measureFilter'
-      }].concat(_toConsumableArray(parentFilters));
-      var timeDimensions = [];
-      values.filter(function (_ref5) {
-        var _ref6 = _slicedToArray(_ref5, 1),
-            member = _ref6[0];
-
-        return member !== 'measures';
-      }).forEach(function (_ref7) {
-        var _ref8 = _slicedToArray(_ref7, 2),
-            member = _ref8[0],
-            value = _ref8[1];
-
-        var _member$split = member.split('.'),
-            _member$split2 = _slicedToArray(_member$split, 3),
-            cubeName = _member$split2[0],
-            dimension = _member$split2[1],
-            granularity = _member$split2[2];
-
-        if (granularity !== undefined) {
-          var range = dayRange(value, value).snapTo(granularity);
-          timeDimensions.push({
-            dimension: [cubeName, dimension].join('.'),
-            dateRange: [range.start, range.end].map(function (dt) {
-              return dt.format('YYYY-MM-DDTHH:mm:ss.SSS');
-            })
-          });
-        } else if (value == null) {
-          filters.push({
-            member: member,
-            operator: 'notSet'
-          });
-        } else {
-          filters.push({
-            member: member,
-            operator: 'equals',
-            values: [value.toString()]
-          });
-        }
-      });
-      var query = this.loadResponses[0].query;
+    return axisValues.map(formatValue).join(delimiter || ', ');
+  }
 
-      if (timeDimensions.length === 0 && query.timeDimensions.length > 0 && query.timeDimensions[0].granularity == null) {
-        timeDimensions.push(query.timeDimensions[0]);
-      }
+  static getNormalizedPivotConfig(query = {}, pivotConfig = null) {
+    const defaultPivotConfig = {
+      x: [],
+      y: [],
+      fillMissingDates: true,
+      joinDateRange: false
+    };
+    const {
+      measures = [],
+      dimensions = []
+    } = query;
+    const timeDimensions = (query.timeDimensions || []).filter(td => !!td.granularity);
+    pivotConfig = pivotConfig || (timeDimensions.length ? {
+      x: timeDimensions.map(td => ResultSet.timeDimensionMember(td)),
+      y: dimensions
+    } : {
+      x: dimensions,
+      y: []
+    });
+    pivotConfig = mergeDeepLeft(pivotConfig, defaultPivotConfig);
 
-      return _objectSpread$2(_objectSpread$2(_objectSpread$2({}, measures[measureName].drillMembersGrouped), {}, {
-        filters: filters
-      }, segments.length > 0 ? {
-        segments: segments
-      } : {}), {}, {
-        timeDimensions: timeDimensions,
-        segments: segments,
-        timezone: query.timezone
-      });
-    }
-  }, {
-    key: "series",
-    value: function series(pivotConfig) {
-      var _this = this;
+    const substituteTimeDimensionMembers = axis => axis.map(subDim => timeDimensions.find(td => td.dimension === subDim) && !dimensions.find(d => d === subDim) ? ResultSet.timeDimensionMember(query.timeDimensions.find(td => td.dimension === subDim)) : subDim);
 
-      return this.seriesNames(pivotConfig).map(function (_ref9) {
-        var title = _ref9.title,
-            key = _ref9.key;
-        return {
-          title: title,
-          key: key,
-          series: _this.chartPivot(pivotConfig).map(function (_ref10) {
-            var x = _ref10.x,
-                obj = _objectWithoutProperties(_ref10, _excluded$1);
-
-            return {
-              value: obj[key],
-              x: x
-            };
-          })
-        };
-      });
-    }
-  }, {
-    key: "axisValues",
-    value: function axisValues(axis) {
-      var resultIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-      var query = this.loadResponses[resultIndex].query;
-      return function (row) {
-        var value = function value(measure) {
-          return axis.filter(function (d) {
-            return d !== 'measures';
-          }).map(function (d) {
-            return row[d] != null ? row[d] : null;
-          }).concat(measure ? [measure] : []);
-        };
+    pivotConfig.x = substituteTimeDimensionMembers(pivotConfig.x);
+    pivotConfig.y = substituteTimeDimensionMembers(pivotConfig.y);
+    const allIncludedDimensions = pivotConfig.x.concat(pivotConfig.y);
+    const allDimensions = timeDimensions.map(td => ResultSet.timeDimensionMember(td)).concat(dimensions);
 
-        if (axis.find(function (d) {
-          return d === 'measures';
-        }) && (query.measures || []).length) {
-          return query.measures.map(value);
-        }
+    const dimensionFilter = key => allDimensions.includes(key) || key === 'measures';
 
-        return [value()];
-      };
-    }
-  }, {
-    key: "axisValuesString",
-    value: function axisValuesString(axisValues, delimiter) {
-      var formatValue = function formatValue(v) {
-        if (v == null) {
-          return '∅';
-        } else if (v === '') {
-          return '[Empty string]';
-        } else {
-          return v;
-        }
-      };
+    pivotConfig.x = pivotConfig.x.concat(allDimensions.filter(d => !allIncludedDimensions.includes(d) && d !== 'compareDateRange')).filter(dimensionFilter);
+    pivotConfig.y = pivotConfig.y.filter(dimensionFilter);
 
-      return axisValues.map(formatValue).join(delimiter || ', ');
+    if (!pivotConfig.x.concat(pivotConfig.y).find(d => d === 'measures')) {
+      pivotConfig.y.push('measures');
     }
-  }, {
-    key: "normalizePivotConfig",
-    value: function normalizePivotConfig(pivotConfig) {
-      return ResultSet.getNormalizedPivotConfig(this.loadResponse.pivotQuery, pivotConfig);
+
+    if (dimensions.includes('compareDateRange') && !pivotConfig.y.concat(pivotConfig.x).includes('compareDateRange')) {
+      pivotConfig.y.unshift('compareDateRange');
     }
-  }, {
-    key: "timeSeries",
-    value: function timeSeries(timeDimension, resultIndex) {
-      if (!timeDimension.granularity) {
-        return null;
-      }
 
-      var dateRange = timeDimension.dateRange;
-
-      if (!dateRange) {
-        var member = ResultSet.timeDimensionMember(timeDimension);
-        var dates = pipe(map(function (row) {
-          return row[member] && internalDayjs(row[member]);
-        }), filter(Boolean))(this.timeDimensionBackwardCompatibleData(resultIndex));
-        dateRange = dates.length && [reduce(minBy(function (d) {
-          return d.toDate();
-        }), dates[0], dates), reduce(maxBy(function (d) {
-          return d.toDate();
-        }), dates[0], dates)] || null;
-      }
+    if (!measures.length) {
+      pivotConfig.x = pivotConfig.x.filter(d => d !== 'measures');
+      pivotConfig.y = pivotConfig.y.filter(d => d !== 'measures');
+    }
 
-      if (!dateRange) {
-        return null;
-      }
+    return pivotConfig;
+  }
 
-      var padToDay = timeDimension.dateRange ? timeDimension.dateRange.find(function (d) {
-        return d.match(DateRegex);
-      }) : !['hour', 'minute', 'second'].includes(timeDimension.granularity);
+  normalizePivotConfig(pivotConfig) {
+    return ResultSet.getNormalizedPivotConfig(this.loadResponse.pivotQuery, pivotConfig);
+  }
 
-      var _dateRange = dateRange,
-          _dateRange2 = _slicedToArray(_dateRange, 2),
-          start = _dateRange2[0],
-          end = _dateRange2[1];
+  timeSeries(timeDimension, resultIndex) {
+    if (!timeDimension.granularity) {
+      return null;
+    }
 
-      var range = dayRange(start, end);
+    let {
+      dateRange
+    } = timeDimension;
 
-      if (!TIME_SERIES[timeDimension.granularity]) {
-        throw new Error("Unsupported time granularity: ".concat(timeDimension.granularity));
-      }
+    if (!dateRange) {
+      const member = ResultSet.timeDimensionMember(timeDimension);
+      const dates = pipe(map(row => row[member] && internalDayjs(row[member])), filter(Boolean))(this.timeDimensionBackwardCompatibleData(resultIndex));
+      dateRange = dates.length && [reduce(minBy(d => d.toDate()), dates[0], dates), reduce(maxBy(d => d.toDate()), dates[0], dates)] || null;
+    }
 
-      return TIME_SERIES[timeDimension.granularity](padToDay ? range.snapTo('d') : range);
+    if (!dateRange) {
+      return null;
     }
-  }, {
-    key: "pivot",
-    value: function pivot(pivotConfig) {
-      var _this2 = this;
-
-      pivotConfig = this.normalizePivotConfig(pivotConfig);
-      var query = this.loadResponse.pivotQuery;
-
-      var pivotImpl = function pivotImpl() {
-        var resultIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-        var groupByXAxis = groupByToPairs(function (_ref11) {
-          var xValues = _ref11.xValues;
-          return _this2.axisValuesString(xValues);
-        });
 
-        var measureValue = function measureValue(row, measure) {
-          return row[measure] || 0;
-        };
+    const padToDay = timeDimension.dateRange ? timeDimension.dateRange.find(d => d.match(DateRegex)) : !['hour', 'minute', 'second'].includes(timeDimension.granularity);
+    const [start, end] = dateRange;
+    const range = dayRange(start, end);
 
-        if (pivotConfig.fillMissingDates && pivotConfig.x.length === 1 && equals(pivotConfig.x, (query.timeDimensions || []).filter(function (td) {
-          return Boolean(td.granularity);
-        }).map(function (td) {
-          return ResultSet.timeDimensionMember(td);
-        }))) {
-          var series = _this2.loadResponses.map(function (loadResponse) {
-            return _this2.timeSeries(loadResponse.query.timeDimensions[0], resultIndex);
-          });
+    if (!TIME_SERIES[timeDimension.granularity]) {
+      throw new Error(`Unsupported time granularity: ${timeDimension.granularity}`);
+    }
 
-          if (series[0]) {
-            groupByXAxis = function groupByXAxis(rows) {
-              var byXValues = groupBy(function (_ref12) {
-                var xValues = _ref12.xValues;
-                return xValues[0];
-              }, rows);
-              return series[resultIndex].map(function (d) {
-                return [d, byXValues[d] || [{
-                  xValues: [d],
-                  row: {}
-                }]];
-              });
-            };
-          }
+    return TIME_SERIES[timeDimension.granularity](padToDay ? range.snapTo('d') : range);
+  }
+
+  pivot(pivotConfig) {
+    pivotConfig = this.normalizePivotConfig(pivotConfig);
+    const {
+      pivotQuery: query
+    } = this.loadResponse;
+
+    const pivotImpl = (resultIndex = 0) => {
+      let groupByXAxis = groupByToPairs(({
+        xValues
+      }) => this.axisValuesString(xValues));
+
+      const measureValue = (row, measure) => row[measure] || 0;
+
+      if (pivotConfig.fillMissingDates && pivotConfig.x.length === 1 && equals(pivotConfig.x, (query.timeDimensions || []).filter(td => Boolean(td.granularity)).map(td => ResultSet.timeDimensionMember(td)))) {
+        const series = this.loadResponses.map(loadResponse => this.timeSeries(loadResponse.query.timeDimensions[0], resultIndex));
+
+        if (series[0]) {
+          groupByXAxis = rows => {
+            const byXValues = groupBy(({
+              xValues
+            }) => xValues[0], rows);
+            return series[resultIndex].map(d => [d, byXValues[d] || [{
+              xValues: [d],
+              row: {}
+            }]]);
+          };
         }
+      }
 
-        var xGrouped = pipe(map(function (row) {
-          return _this2.axisValues(pivotConfig.x, resultIndex)(row).map(function (xValues) {
-            return {
-              xValues: xValues,
-              row: row
-            };
-          });
-        }), unnest, groupByXAxis)(_this2.timeDimensionBackwardCompatibleData(resultIndex));
-        var yValuesMap = {};
-        xGrouped.forEach(function (_ref13) {
-          var _ref14 = _slicedToArray(_ref13, 2),
-              rows = _ref14[1];
-
-          rows.forEach(function (_ref15) {
-            var row = _ref15.row;
-
-            _this2.axisValues(pivotConfig.y, resultIndex)(row).forEach(function (values) {
-              if (Object.keys(row).length > 0) {
-                yValuesMap[values.join()] = values;
-              }
-            });
+      const xGrouped = pipe(map(row => this.axisValues(pivotConfig.x, resultIndex)(row).map(xValues => ({
+        xValues,
+        row
+      }))), unnest, groupByXAxis)(this.timeDimensionBackwardCompatibleData(resultIndex));
+      const yValuesMap = {};
+      xGrouped.forEach(([, rows]) => {
+        rows.forEach(({
+          row
+        }) => {
+          this.axisValues(pivotConfig.y, resultIndex)(row).forEach(values => {
+            if (Object.keys(row).length > 0) {
+              yValuesMap[values.join()] = values;
+            }
           });
         });
-        var allYValues = Object.values(yValuesMap);
-        var measureOnX = Boolean(pivotConfig.x.find(function (d) {
-          return d === 'measures';
-        }));
-        return xGrouped.map(function (_ref16) {
-          var _ref17 = _slicedToArray(_ref16, 2),
-              rows = _ref17[1];
-
-          var xValues = rows[0].xValues;
-          var yGrouped = {};
-          rows.forEach(function (_ref18) {
-            var row = _ref18.row;
-
-            var arr = _this2.axisValues(pivotConfig.y, resultIndex)(row).map(function (yValues) {
-              return {
-                yValues: yValues,
-                row: row
-              };
-            });
-
-            arr.forEach(function (res) {
-              yGrouped[_this2.axisValuesString(res.yValues)] = res;
-            });
+      });
+      const allYValues = Object.values(yValuesMap);
+      const measureOnX = Boolean(pivotConfig.x.find(d => d === 'measures'));
+      return xGrouped.map(([, rows]) => {
+        const {
+          xValues
+        } = rows[0];
+        const yGrouped = {};
+        rows.forEach(({
+          row
+        }) => {
+          const arr = this.axisValues(pivotConfig.y, resultIndex)(row).map(yValues => ({
+            yValues,
+            row
+          }));
+          arr.forEach(res => {
+            yGrouped[this.axisValuesString(res.yValues)] = res;
           });
-          return {
-            xValues: xValues,
-            yValuesArray: unnest(allYValues.map(function (yValues) {
-              var measure = measureOnX ? ResultSet.measureFromAxis(xValues) : ResultSet.measureFromAxis(yValues);
-              return [[yValues, measureValue((yGrouped[_this2.axisValuesString(yValues)] || {
-                row: {}
-              }).row, measure)]];
-            }))
-          };
         });
-      };
-
-      var pivots = this.loadResponses.length > 1 ? this.loadResponses.map(function (_, index) {
-        return pivotImpl(index);
-      }) : [];
-      return pivots.length ? this.mergePivots(pivots, pivotConfig.joinDateRange) : pivotImpl();
-    }
-  }, {
-    key: "mergePivots",
-    value: function mergePivots(pivots, joinDateRange) {
-      var minLengthPivot = pivots.reduce(function (memo, current) {
-        return memo != null && current.length >= memo.length ? memo : current;
-      }, null);
-      return minLengthPivot.map(function (_, index) {
-        var xValues = joinDateRange ? [pivots.map(function (pivot) {
-          return pivot[index] && pivot[index].xValues || [];
-        }).join(', ')] : minLengthPivot[index].xValues;
         return {
-          xValues: xValues,
-          yValuesArray: unnest(pivots.map(function (pivot) {
-            return pivot[index].yValuesArray;
+          xValues,
+          yValuesArray: unnest(allYValues.map(yValues => {
+            const measure = measureOnX ? ResultSet.measureFromAxis(xValues) : ResultSet.measureFromAxis(yValues);
+            return [[yValues, measureValue((yGrouped[this.axisValuesString(yValues)] || {
+              row: {}
+            }).row, measure)]];
           }))
         };
       });
-    }
-  }, {
-    key: "pivotedRows",
-    value: function pivotedRows(pivotConfig) {
-      // TODO
-      return this.chartPivot(pivotConfig);
-    }
-  }, {
-    key: "chartPivot",
-    value: function chartPivot(pivotConfig) {
-      var _this3 = this;
-
-      var validate = function validate(value) {
-        if (_this3.parseDateMeasures && LocalDateRegex.test(value)) {
-          return new Date(value);
-        } else if (!Number.isNaN(Number.parseFloat(value))) {
-          return Number.parseFloat(value);
-        }
-
-        return value;
-      };
-
-      var duplicateMeasures = new Set();
-
-      if (this.queryType === QUERY_TYPE.BLENDING_QUERY) {
-        var allMeasures = flatten(this.loadResponses.map(function (_ref19) {
-          var query = _ref19.query;
-          return query.measures;
-        }));
-        allMeasures.filter(function (e, i, a) {
-          return a.indexOf(e) !== i;
-        }).forEach(function (m) {
-          return duplicateMeasures.add(m);
-        });
-      }
-
-      return this.pivot(pivotConfig).map(function (_ref20) {
-        var xValues = _ref20.xValues,
-            yValuesArray = _ref20.yValuesArray;
-        var yValuesMap = {};
-        yValuesArray.forEach(function (_ref21, i) {
-          var _ref22 = _slicedToArray(_ref21, 2),
-              yValues = _ref22[0],
-              m = _ref22[1];
+    };
 
-          yValuesMap[_this3.axisValuesString(aliasSeries(yValues, i, pivotConfig, duplicateMeasures), ',')] = m && validate(m);
-        });
-        return _objectSpread$2({
-          x: _this3.axisValuesString(xValues, ','),
-          xValues: xValues
-        }, yValuesMap);
-      });
-    }
-  }, {
-    key: "tablePivot",
-    value: function tablePivot(pivotConfig) {
-      var normalizedPivotConfig = this.normalizePivotConfig(pivotConfig || {});
-      var isMeasuresPresent = normalizedPivotConfig.x.concat(normalizedPivotConfig.y).includes('measures');
-      return this.pivot(normalizedPivotConfig).map(function (_ref23) {
-        var xValues = _ref23.xValues,
-            yValuesArray = _ref23.yValuesArray;
-        return fromPairs(normalizedPivotConfig.x.map(function (key, index) {
-          return [key, xValues[index]];
-        }).concat(isMeasuresPresent ? yValuesArray.map(function (_ref24) {
-          var _ref25 = _slicedToArray(_ref24, 2),
-              yValues = _ref25[0],
-              measure = _ref25[1];
-
-          return [yValues.length ? yValues.join() : 'value', measure];
-        }) : []));
-      });
-    }
-  }, {
-    key: "tableColumns",
-    value: function tableColumns(pivotConfig) {
-      var normalizedPivotConfig = this.normalizePivotConfig(pivotConfig || {});
-      var annotations = pipe(pluck('annotation'), reduce(mergeDeepLeft(), {}))(this.loadResponses);
-      var flatMeta = Object.values(annotations).reduce(function (a, b) {
-        return _objectSpread$2(_objectSpread$2({}, a), b);
-      }, {});
-      var schema = {};
-
-      var extractFields = function extractFields(key) {
-        var _ref26 = flatMeta[key] || {},
-            title = _ref26.title,
-            shortTitle = _ref26.shortTitle,
-            type = _ref26.type,
-            format = _ref26.format,
-            meta = _ref26.meta;
+    const pivots = this.loadResponses.length > 1 ? this.loadResponses.map((_, index) => pivotImpl(index)) : [];
+    return pivots.length ? this.mergePivots(pivots, pivotConfig.joinDateRange) : pivotImpl();
+  }
 
-        return {
-          key: key,
-          title: title,
-          shortTitle: shortTitle,
-          type: type,
-          format: format,
-          meta: meta
-        };
+  mergePivots(pivots, joinDateRange) {
+    const minLengthPivot = pivots.reduce((memo, current) => memo != null && current.length >= memo.length ? memo : current, null);
+    return minLengthPivot.map((_, index) => {
+      const xValues = joinDateRange ? [pivots.map(pivot => pivot[index] && pivot[index].xValues || []).join(', ')] : minLengthPivot[index].xValues;
+      return {
+        xValues,
+        yValuesArray: unnest(pivots.map(pivot => pivot[index].yValuesArray))
       };
+    });
+  }
 
-      var pivot = this.pivot(normalizedPivotConfig);
-      (pivot[0] && pivot[0].yValuesArray || []).forEach(function (_ref27) {
-        var _ref28 = _slicedToArray(_ref27, 1),
-            yValues = _ref28[0];
-
-        if (yValues.length > 0) {
-          var currentItem = schema;
-          yValues.forEach(function (value, index) {
-            currentItem["_".concat(value)] = {
-              key: value,
-              memberId: normalizedPivotConfig.y[index] === 'measures' ? value : normalizedPivotConfig.y[index],
-              children: currentItem["_".concat(value)] && currentItem["_".concat(value)].children || {}
-            };
-            currentItem = currentItem["_".concat(value)].children;
-          });
-        }
-      });
-
-      var toColumns = function toColumns() {
-        var item = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-        var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  pivotedRows(pivotConfig) {
+    // TODO
+    return this.chartPivot(pivotConfig);
+  }
 
-        if (Object.keys(item).length === 0) {
-          return [];
-        }
+  chartPivot(pivotConfig) {
+    const validate = value => {
+      if (this.parseDateMeasures && LocalDateRegex.test(value)) {
+        return new Date(value);
+      } else if (!Number.isNaN(Number.parseFloat(value))) {
+        return Number.parseFloat(value);
+      }
 
-        return Object.values(item).map(function (_ref29) {
-          var key = _ref29.key,
-              currentItem = _objectWithoutProperties(_ref29, _excluded2);
+      return value;
+    };
 
-          var children = toColumns(currentItem.children, [].concat(_toConsumableArray(path), [key]));
+    const duplicateMeasures = new Set();
 
-          var _extractFields = extractFields(currentItem.memberId),
-              title = _extractFields.title,
-              shortTitle = _extractFields.shortTitle,
-              fields = _objectWithoutProperties(_extractFields, _excluded3);
+    if (this.queryType === QUERY_TYPE.BLENDING_QUERY) {
+      const allMeasures = flatten(this.loadResponses.map(({
+        query
+      }) => query.measures));
+      allMeasures.filter((e, i, a) => a.indexOf(e) !== i).forEach(m => duplicateMeasures.add(m));
+    }
 
-          var dimensionValue = key !== currentItem.memberId || title == null ? key : '';
+    return this.pivot(pivotConfig).map(({
+      xValues,
+      yValuesArray
+    }) => {
+      const yValuesMap = {};
+      yValuesArray.forEach(([yValues, m], i) => {
+        yValuesMap[this.axisValuesString(aliasSeries(yValues, i, pivotConfig, duplicateMeasures), ',')] = m && validate(m);
+      });
+      return {
+        x: this.axisValuesString(xValues, ','),
+        xValues,
+        ...yValuesMap
+      };
+    });
+  }
 
-          if (!children.length) {
-            return _objectSpread$2(_objectSpread$2({}, fields), {}, {
-              key: key,
-              dataIndex: [].concat(_toConsumableArray(path), [key]).join(),
-              title: [title, dimensionValue].join(' ').trim(),
-              shortTitle: dimensionValue || shortTitle
-            });
-          }
+  tablePivot(pivotConfig) {
+    const normalizedPivotConfig = this.normalizePivotConfig(pivotConfig || {});
+    const isMeasuresPresent = normalizedPivotConfig.x.concat(normalizedPivotConfig.y).includes('measures');
+    return this.pivot(normalizedPivotConfig).map(({
+      xValues,
+      yValuesArray
+    }) => fromPairs(normalizedPivotConfig.x.map((key, index) => [key, xValues[index]]).concat(isMeasuresPresent ? yValuesArray.map(([yValues, measure]) => [yValues.length ? yValues.join() : 'value', measure]) : [])));
+  }
 
-          return _objectSpread$2(_objectSpread$2({}, fields), {}, {
-            key: key,
-            title: [title, dimensionValue].join(' ').trim(),
-            shortTitle: dimensionValue || shortTitle,
-            children: children
-          });
-        });
+  tableColumns(pivotConfig) {
+    const normalizedPivotConfig = this.normalizePivotConfig(pivotConfig || {});
+    const annotations = pipe(pluck('annotation'), reduce(mergeDeepLeft(), {}))(this.loadResponses);
+    const flatMeta = Object.values(annotations).reduce((a, b) => ({ ...a,
+      ...b
+    }), {});
+    const schema = {};
+
+    const extractFields = key => {
+      const {
+        title,
+        shortTitle,
+        type,
+        format,
+        meta
+      } = flatMeta[key] || {};
+      return {
+        key,
+        title,
+        shortTitle,
+        type,
+        format,
+        meta
       };
+    };
 
-      var otherColumns = [];
-
-      if (!pivot.length && normalizedPivotConfig.y.includes('measures')) {
-        otherColumns = (this.loadResponses[0].query.measures || []).map(function (key) {
-          return _objectSpread$2(_objectSpread$2({}, extractFields(key)), {}, {
-            dataIndex: key
-          });
+    const pivot = this.pivot(normalizedPivotConfig);
+    (pivot[0] && pivot[0].yValuesArray || []).forEach(([yValues]) => {
+      if (yValues.length > 0) {
+        let currentItem = schema;
+        yValues.forEach((value, index) => {
+          currentItem[`_${value}`] = {
+            key: value,
+            memberId: normalizedPivotConfig.y[index] === 'measures' ? value : normalizedPivotConfig.y[index],
+            children: currentItem[`_${value}`] && currentItem[`_${value}`].children || {}
+          };
+          currentItem = currentItem[`_${value}`].children;
         });
-      } // Syntatic column to display the measure value
-
+      }
+    });
 
-      if (!normalizedPivotConfig.y.length && normalizedPivotConfig.x.includes('measures')) {
-        otherColumns.push({
-          key: 'value',
-          dataIndex: 'value',
-          title: 'Value',
-          shortTitle: 'Value',
-          type: 'string'
-        });
+    const toColumns = (item = {}, path = []) => {
+      if (Object.keys(item).length === 0) {
+        return [];
       }
 
-      return normalizedPivotConfig.x.map(function (key) {
-        if (key === 'measures') {
-          return {
-            key: 'measures',
-            dataIndex: 'measures',
-            title: 'Measures',
-            shortTitle: 'Measures',
-            type: 'string'
+      return Object.values(item).map(({
+        key,
+        ...currentItem
+      }) => {
+        const children = toColumns(currentItem.children, [...path, key]);
+        const {
+          title,
+          shortTitle,
+          ...fields
+        } = extractFields(currentItem.memberId);
+        const dimensionValue = key !== currentItem.memberId || title == null ? key : '';
+
+        if (!children.length) {
+          return { ...fields,
+            key,
+            dataIndex: [...path, key].join(),
+            title: [title, dimensionValue].join(' ').trim(),
+            shortTitle: dimensionValue || shortTitle
           };
         }
 
-        return _objectSpread$2(_objectSpread$2({}, extractFields(key)), {}, {
-          dataIndex: key
-        });
-      }).concat(toColumns(schema)).concat(otherColumns);
-    }
-  }, {
-    key: "totalRow",
-    value: function totalRow(pivotConfig) {
-      return this.chartPivot(pivotConfig)[0];
-    }
-  }, {
-    key: "categories",
-    value: function categories(pivotConfig) {
-      // TODO
-      return this.chartPivot(pivotConfig);
-    }
-  }, {
-    key: "seriesNames",
-    value: function seriesNames(pivotConfig) {
-      var _this4 = this;
-
-      pivotConfig = this.normalizePivotConfig(pivotConfig);
-      var measures = pipe(pluck('annotation'), pluck('measures'), mergeAll)(this.loadResponses);
-      var seriesNames = unnest(this.loadResponses.map(function (_, index) {
-        return pipe(map(_this4.axisValues(pivotConfig.y, index)), unnest, uniq)(_this4.timeDimensionBackwardCompatibleData(index));
+        return { ...fields,
+          key,
+          title: [title, dimensionValue].join(' ').trim(),
+          shortTitle: dimensionValue || shortTitle,
+          children
+        };
+      });
+    };
+
+    let otherColumns = [];
+
+    if (!pivot.length && normalizedPivotConfig.y.includes('measures')) {
+      otherColumns = (this.loadResponses[0].query.measures || []).map(key => ({ ...extractFields(key),
+        dataIndex: key
       }));
-      var duplicateMeasures = new Set();
-
-      if (this.queryType === QUERY_TYPE.BLENDING_QUERY) {
-        var allMeasures = flatten(this.loadResponses.map(function (_ref30) {
-          var query = _ref30.query;
-          return query.measures;
-        }));
-        allMeasures.filter(function (e, i, a) {
-          return a.indexOf(e) !== i;
-        }).forEach(function (m) {
-          return duplicateMeasures.add(m);
-        });
-      }
+    } // Syntatic column to display the measure value
 
-      return seriesNames.map(function (axisValues, i) {
-        var aliasedAxis = aliasSeries(axisValues, i, pivotConfig, duplicateMeasures);
-        return {
-          title: _this4.axisValuesString(pivotConfig.y.find(function (d) {
-            return d === 'measures';
-          }) ? dropLast(1, aliasedAxis).concat(measures[ResultSet.measureFromAxis(axisValues)].title) : aliasedAxis, ', '),
-          key: _this4.axisValuesString(aliasedAxis, ','),
-          yValues: axisValues
-        };
+
+    if (!normalizedPivotConfig.y.length && normalizedPivotConfig.x.includes('measures')) {
+      otherColumns.push({
+        key: 'value',
+        dataIndex: 'value',
+        title: 'Value',
+        shortTitle: 'Value',
+        type: 'string'
       });
     }
-  }, {
-    key: "query",
-    value: function query() {
-      if (this.queryType !== QUERY_TYPE.REGULAR_QUERY) {
-        throw new Error("Method is not supported for a '".concat(this.queryType, "' query type. Please use decompose"));
-      }
 
-      return this.loadResponses[0].query;
-    }
-  }, {
-    key: "pivotQuery",
-    value: function pivotQuery() {
-      return this.loadResponse.pivotQuery || null;
-    }
-  }, {
-    key: "rawData",
-    value: function rawData() {
-      if (this.queryType !== QUERY_TYPE.REGULAR_QUERY) {
-        throw new Error("Method is not supported for a '".concat(this.queryType, "' query type. Please use decompose"));
+    return normalizedPivotConfig.x.map(key => {
+      if (key === 'measures') {
+        return {
+          key: 'measures',
+          dataIndex: 'measures',
+          title: 'Measures',
+          shortTitle: 'Measures',
+          type: 'string'
+        };
       }
 
-      return this.loadResponses[0].data;
-    }
-  }, {
-    key: "annotation",
-    value: function annotation() {
-      if (this.queryType !== QUERY_TYPE.REGULAR_QUERY) {
-        throw new Error("Method is not supported for a '".concat(this.queryType, "' query type. Please use decompose"));
-      }
+      return { ...extractFields(key),
+        dataIndex: key
+      };
+    }).concat(toColumns(schema)).concat(otherColumns);
+  }
 
-      return this.loadResponses[0].annotation;
-    }
-  }, {
-    key: "timeDimensionBackwardCompatibleData",
-    value: function timeDimensionBackwardCompatibleData(resultIndex) {
-      if (resultIndex === undefined) {
-        throw new Error('resultIndex is required');
-      }
+  totalRow(pivotConfig) {
+    return this.chartPivot(pivotConfig)[0];
+  }
 
-      if (!this.backwardCompatibleData[resultIndex]) {
-        var _this$loadResponses$r = this.loadResponses[resultIndex],
-            data = _this$loadResponses$r.data,
-            query = _this$loadResponses$r.query;
-        var timeDimensions = (query.timeDimensions || []).filter(function (td) {
-          return Boolean(td.granularity);
-        });
-        this.backwardCompatibleData[resultIndex] = data.map(function (row) {
-          return _objectSpread$2(_objectSpread$2({}, row), fromPairs(Object.keys(row).filter(function (field) {
-            return timeDimensions.find(function (d) {
-              return d.dimension === field;
-            }) && !row[ResultSet.timeDimensionMember(timeDimensions.find(function (d) {
-              return d.dimension === field;
-            }))];
-          }).map(function (field) {
-            return [ResultSet.timeDimensionMember(timeDimensions.find(function (d) {
-              return d.dimension === field;
-            })), row[field]];
-          })));
-        });
-      }
+  categories(pivotConfig) {
+    // TODO
+    return this.chartPivot(pivotConfig);
+  }
 
-      return this.backwardCompatibleData[resultIndex];
-    }
-  }, {
-    key: "decompose",
-    value: function decompose() {
-      var _this5 = this;
-
-      return this.loadResponses.map(function (result) {
-        return new ResultSet({
-          queryType: QUERY_TYPE.REGULAR_QUERY,
-          pivotQuery: _objectSpread$2(_objectSpread$2({}, result.query), {}, {
-            queryType: QUERY_TYPE.REGULAR_QUERY
-          }),
-          results: [result]
-        }, _this5.options);
-      });
+  seriesNames(pivotConfig) {
+    pivotConfig = this.normalizePivotConfig(pivotConfig);
+    const measures = pipe(pluck('annotation'), pluck('measures'), mergeAll)(this.loadResponses);
+    const seriesNames = unnest(this.loadResponses.map((_, index) => pipe(map(this.axisValues(pivotConfig.y, index)), unnest, uniq)(this.timeDimensionBackwardCompatibleData(index))));
+    const duplicateMeasures = new Set();
+
+    if (this.queryType === QUERY_TYPE.BLENDING_QUERY) {
+      const allMeasures = flatten(this.loadResponses.map(({
+        query
+      }) => query.measures));
+      allMeasures.filter((e, i, a) => a.indexOf(e) !== i).forEach(m => duplicateMeasures.add(m));
     }
-  }, {
-    key: "serialize",
-    value: function serialize() {
+
+    return seriesNames.map((axisValues, i) => {
+      const aliasedAxis = aliasSeries(axisValues, i, pivotConfig, duplicateMeasures);
       return {
-        loadResponse: clone(this.loadResponse)
+        title: this.axisValuesString(pivotConfig.y.find(d => d === 'measures') ? dropLast(1, aliasedAxis).concat(measures[ResultSet.measureFromAxis(axisValues)].title) : aliasedAxis, ', '),
+        key: this.axisValuesString(aliasedAxis, ','),
+        yValues: axisValues
       };
+    });
+  }
+
+  query() {
+    if (this.queryType !== QUERY_TYPE.REGULAR_QUERY) {
+      throw new Error(`Method is not supported for a '${this.queryType}' query type. Please use decompose`);
     }
-  }], [{
-    key: "measureFromAxis",
-    value: function measureFromAxis(axisValues) {
-      return axisValues[axisValues.length - 1];
-    }
-  }, {
-    key: "timeDimensionMember",
-    value: function timeDimensionMember(td) {
-      return "".concat(td.dimension, ".").concat(td.granularity);
-    }
-  }, {
-    key: "deserialize",
-    value: function deserialize(data) {
-      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      return new ResultSet(data.loadResponse, options);
-    }
-  }, {
-    key: "getNormalizedPivotConfig",
-    value: function getNormalizedPivotConfig() {
-      var query = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      var pivotConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-      var defaultPivotConfig = {
-        x: [],
-        y: [],
-        fillMissingDates: true,
-        joinDateRange: false
-      };
-      var _query$measures = query.measures,
-          measures = _query$measures === void 0 ? [] : _query$measures,
-          _query$dimensions = query.dimensions,
-          dimensions = _query$dimensions === void 0 ? [] : _query$dimensions;
-      var timeDimensions = (query.timeDimensions || []).filter(function (td) {
-        return !!td.granularity;
-      });
-      pivotConfig = pivotConfig || (timeDimensions.length ? {
-        x: timeDimensions.map(function (td) {
-          return ResultSet.timeDimensionMember(td);
-        }),
-        y: dimensions
-      } : {
-        x: dimensions,
-        y: []
-      });
-      pivotConfig = mergeDeepLeft(pivotConfig, defaultPivotConfig);
-
-      var substituteTimeDimensionMembers = function substituteTimeDimensionMembers(axis) {
-        return axis.map(function (subDim) {
-          return timeDimensions.find(function (td) {
-            return td.dimension === subDim;
-          }) && !dimensions.find(function (d) {
-            return d === subDim;
-          }) ? ResultSet.timeDimensionMember(query.timeDimensions.find(function (td) {
-            return td.dimension === subDim;
-          })) : subDim;
-        });
-      };
 
-      pivotConfig.x = substituteTimeDimensionMembers(pivotConfig.x);
-      pivotConfig.y = substituteTimeDimensionMembers(pivotConfig.y);
-      var allIncludedDimensions = pivotConfig.x.concat(pivotConfig.y);
-      var allDimensions = timeDimensions.map(function (td) {
-        return ResultSet.timeDimensionMember(td);
-      }).concat(dimensions);
+    return this.loadResponses[0].query;
+  }
 
-      var dimensionFilter = function dimensionFilter(key) {
-        return allDimensions.includes(key) || key === 'measures';
-      };
+  pivotQuery() {
+    return this.loadResponse.pivotQuery || null;
+  }
 
-      pivotConfig.x = pivotConfig.x.concat(allDimensions.filter(function (d) {
-        return !allIncludedDimensions.includes(d) && d !== 'compareDateRange';
-      })).filter(dimensionFilter);
-      pivotConfig.y = pivotConfig.y.filter(dimensionFilter);
+  rawData() {
+    if (this.queryType !== QUERY_TYPE.REGULAR_QUERY) {
+      throw new Error(`Method is not supported for a '${this.queryType}' query type. Please use decompose`);
+    }
 
-      if (!pivotConfig.x.concat(pivotConfig.y).find(function (d) {
-        return d === 'measures';
-      })) {
-        pivotConfig.y.push('measures');
-      }
+    return this.loadResponses[0].data;
+  }
 
-      if (dimensions.includes('compareDateRange') && !pivotConfig.y.concat(pivotConfig.x).includes('compareDateRange')) {
-        pivotConfig.y.unshift('compareDateRange');
-      }
+  annotation() {
+    if (this.queryType !== QUERY_TYPE.REGULAR_QUERY) {
+      throw new Error(`Method is not supported for a '${this.queryType}' query type. Please use decompose`);
+    }
 
-      if (!measures.length) {
-        pivotConfig.x = pivotConfig.x.filter(function (d) {
-          return d !== 'measures';
-        });
-        pivotConfig.y = pivotConfig.y.filter(function (d) {
-          return d !== 'measures';
-        });
-      }
+    return this.loadResponses[0].annotation;
+  }
+
+  timeDimensionBackwardCompatibleData(resultIndex) {
+    if (resultIndex === undefined) {
+      throw new Error('resultIndex is required');
+    }
 
-      return pivotConfig;
+    if (!this.backwardCompatibleData[resultIndex]) {
+      const {
+        data,
+        query
+      } = this.loadResponses[resultIndex];
+      const timeDimensions = (query.timeDimensions || []).filter(td => Boolean(td.granularity));
+      this.backwardCompatibleData[resultIndex] = data.map(row => ({ ...row,
+        ...fromPairs(Object.keys(row).filter(field => timeDimensions.find(d => d.dimension === field) && !row[ResultSet.timeDimensionMember(timeDimensions.find(d => d.dimension === field))]).map(field => [ResultSet.timeDimensionMember(timeDimensions.find(d => d.dimension === field)), row[field]]))
+      }));
     }
-  }]);
 
-  return ResultSet;
-}();
+    return this.backwardCompatibleData[resultIndex];
+  }
+
+  decompose() {
+    return this.loadResponses.map(result => new ResultSet({
+      queryType: QUERY_TYPE.REGULAR_QUERY,
+      pivotQuery: { ...result.query,
+        queryType: QUERY_TYPE.REGULAR_QUERY
+      },
+      results: [result]
+    }, this.options));
+  }
+
+  serialize() {
+    return {
+      loadResponse: clone(this.loadResponse)
+    };
+  }
 
-var SqlQuery = /*#__PURE__*/function () {
-  function SqlQuery(sqlQuery) {
-    _classCallCheck(this, SqlQuery);
+}
 
+class SqlQuery {
+  constructor(sqlQuery) {
     this.sqlQuery = sqlQuery;
   }
 
-  _createClass(SqlQuery, [{
-    key: "rawQuery",
-    value: function rawQuery() {
-      return this.sqlQuery.sql;
-    }
-  }, {
-    key: "sql",
-    value: function sql() {
-      return this.rawQuery().sql[0];
-    }
-  }]);
+  rawQuery() {
+    return this.sqlQuery.sql;
+  }
 
-  return SqlQuery;
-}();
+  sql() {
+    return this.rawQuery().sql[0];
+  }
 
-var memberMap = function memberMap(memberArray) {
-  return fromPairs(memberArray.map(function (m) {
-    return [m.name, m];
-  }));
-};
+}
 
-var operators = {
+/**
+ * @module @cubejs-client/core
+ */
+
+const memberMap = memberArray => fromPairs(memberArray.map(m => [m.name, m]));
+
+const operators = {
   string: [{
     name: 'contains',
     title: 'contains'
@@ -1402,158 +1041,112 @@ var operators = {
  * Contains information about available cubes and it's members.
  */
 
-var Meta = /*#__PURE__*/function () {
-  function Meta(metaResponse) {
-    _classCallCheck(this, Meta);
-
+class Meta {
+  constructor(metaResponse) {
     this.meta = metaResponse;
-    var cubes = this.meta.cubes;
+    const {
+      cubes
+    } = this.meta;
     this.cubes = cubes;
-    this.cubesMap = fromPairs(cubes.map(function (c) {
-      return [c.name, {
-        measures: memberMap(c.measures),
-        dimensions: memberMap(c.dimensions),
-        segments: memberMap(c.segments)
-      }];
-    }));
+    this.cubesMap = fromPairs(cubes.map(c => [c.name, {
+      measures: memberMap(c.measures),
+      dimensions: memberMap(c.dimensions),
+      segments: memberMap(c.segments)
+    }]));
   }
 
-  _createClass(Meta, [{
-    key: "membersForQuery",
-    value: function membersForQuery(query, memberType) {
-      return unnest$1(this.cubes.map(function (c) {
-        return c[memberType];
-      })).sort(function (a, b) {
-        return a.title > b.title ? 1 : -1;
-      });
-    }
-  }, {
-    key: "membersGroupedByCube",
-    value: function membersGroupedByCube() {
-      var memberKeys = ['measures', 'dimensions', 'segments', 'timeDimensions'];
-      return this.cubes.reduce(function (memo, cube) {
-        memberKeys.forEach(function (key) {
-          var members = cube[key];
-
-          if (key === 'timeDimensions') {
-            members = cube.dimensions.filter(function (m) {
-              return m.type === 'time';
-            });
-          }
-
-          memo[key] = [].concat(_toConsumableArray(memo[key]), [{
-            cubeName: cube.name,
-            cubeTitle: cube.title,
-            members: members
-          }]);
-        });
-        return memo;
-      }, {
-        measures: [],
-        dimensions: [],
-        segments: [],
-        timeDimensions: []
-      });
-    }
-  }, {
-    key: "resolveMember",
-    value: function resolveMember(memberName, memberType) {
-      var _this = this;
+  membersForQuery(query, memberType) {
+    return unnest$1(this.cubes.map(c => c[memberType])).sort((a, b) => a.title > b.title ? 1 : -1);
+  }
 
-      var _memberName$split = memberName.split('.'),
-          _memberName$split2 = _slicedToArray(_memberName$split, 1),
-          cube = _memberName$split2[0];
+  membersGroupedByCube() {
+    const memberKeys = ['measures', 'dimensions', 'segments', 'timeDimensions'];
+    return this.cubes.reduce((memo, cube) => {
+      memberKeys.forEach(key => {
+        let members = cube[key];
 
-      if (!this.cubesMap[cube]) {
-        return {
-          title: memberName,
-          error: "Cube not found ".concat(cube, " for path '").concat(memberName, "'")
-        };
-      }
+        if (key === 'timeDimensions') {
+          members = cube.dimensions.filter(m => m.type === 'time');
+        }
 
-      var memberTypes = Array.isArray(memberType) ? memberType : [memberType];
-      var member = memberTypes.map(function (type) {
-        return _this.cubesMap[cube][type] && _this.cubesMap[cube][type][memberName];
-      }).find(function (m) {
-        return m;
+        memo[key] = [...memo[key], {
+          cubeName: cube.name,
+          cubeTitle: cube.title,
+          members
+        }];
       });
+      return memo;
+    }, {
+      measures: [],
+      dimensions: [],
+      segments: [],
+      timeDimensions: []
+    });
+  }
 
-      if (!member) {
-        return {
-          title: memberName,
-          error: "Path not found '".concat(memberName, "'")
-        };
-      }
+  resolveMember(memberName, memberType) {
+    const [cube] = memberName.split('.');
 
-      return member;
+    if (!this.cubesMap[cube]) {
+      return {
+        title: memberName,
+        error: `Cube not found ${cube} for path '${memberName}'`
+      };
     }
-  }, {
-    key: "defaultTimeDimensionNameFor",
-    value: function defaultTimeDimensionNameFor(memberName) {
-      var _this2 = this;
 
-      var _memberName$split3 = memberName.split('.'),
-          _memberName$split4 = _slicedToArray(_memberName$split3, 1),
-          cube = _memberName$split4[0];
-
-      if (!this.cubesMap[cube]) {
-        return null;
-      }
+    const memberTypes = Array.isArray(memberType) ? memberType : [memberType];
+    const member = memberTypes.map(type => this.cubesMap[cube][type] && this.cubesMap[cube][type][memberName]).find(m => m);
 
-      return Object.keys(this.cubesMap[cube].dimensions || {}).find(function (d) {
-        return _this2.cubesMap[cube].dimensions[d].type === 'time';
-      });
-    }
-  }, {
-    key: "filterOperatorsForMember",
-    value: function filterOperatorsForMember(memberName, memberType) {
-      var member = this.resolveMember(memberName, memberType);
-      return operators[member.type] || operators.string;
+    if (!member) {
+      return {
+        title: memberName,
+        error: `Path not found '${memberName}'`
+      };
     }
-  }]);
-
-  return Meta;
-}();
-
-var ProgressResult = /*#__PURE__*/function () {
-  function ProgressResult(progressResponse) {
-    _classCallCheck(this, ProgressResult);
 
-    this.progressResponse = progressResponse;
+    return member;
   }
 
-  _createClass(ProgressResult, [{
-    key: "stage",
-    value: function stage() {
-      return this.progressResponse.stage;
-    }
-  }, {
-    key: "timeElapsed",
-    value: function timeElapsed() {
-      return this.progressResponse.timeElapsed;
+  defaultTimeDimensionNameFor(memberName) {
+    const [cube] = memberName.split('.');
+
+    if (!this.cubesMap[cube]) {
+      return null;
     }
-  }]);
 
-  return ProgressResult;
-}();
+    return Object.keys(this.cubesMap[cube].dimensions || {}).find(d => this.cubesMap[cube].dimensions[d].type === 'time');
+  }
 
-var _excluded = ["baseRequestId"];
+  filterOperatorsForMember(memberName, memberType) {
+    const member = this.resolveMember(memberName, memberType);
+    return operators[member.type] || operators.string;
+  }
 
-function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+}
 
-function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+class ProgressResult {
+  constructor(progressResponse) {
+    this.progressResponse = progressResponse;
+  }
 
-var HttpTransport = /*#__PURE__*/function () {
-  function HttpTransport(_ref) {
-    var authorization = _ref.authorization,
-        apiUrl = _ref.apiUrl,
-        method = _ref.method,
-        _ref$headers = _ref.headers,
-        headers = _ref$headers === void 0 ? {} : _ref$headers,
-        credentials = _ref.credentials;
+  stage() {
+    return this.progressResponse.stage;
+  }
 
-    _classCallCheck(this, HttpTransport);
+  timeElapsed() {
+    return this.progressResponse.timeElapsed;
+  }
 
+}
+
+class HttpTransport {
+  constructor({
+    authorization,
+    apiUrl,
+    method,
+    headers = {},
+    credentials
+  }) {
     this.authorization = authorization;
     this.apiUrl = apiUrl;
     this.method = method;
@@ -1561,167 +1154,92 @@ var HttpTransport = /*#__PURE__*/function () {
     this.credentials = credentials;
   }
 
-  _createClass(HttpTransport, [{
-    key: "request",
-    value: function request(method, _ref2) {
-      var _this = this;
-
-      var baseRequestId = _ref2.baseRequestId,
-          params = _objectWithoutProperties(_ref2, _excluded);
-
-      var spanCounter = 1;
-      var searchParams = new URLSearchParams(params && Object.keys(params).map(function (k) {
-        return _defineProperty({}, k, _typeof(params[k]) === 'object' ? JSON.stringify(params[k]) : params[k]);
-      }).reduce(function (a, b) {
-        return _objectSpread$1(_objectSpread$1({}, a), b);
-      }, {}));
-      var url = "".concat(this.apiUrl, "/").concat(method).concat(searchParams.toString().length ? "?".concat(searchParams) : '');
-      var requestMethod = this.method || (url.length < 2000 ? 'GET' : 'POST');
-
-      if (requestMethod === 'POST') {
-        url = "".concat(this.apiUrl, "/").concat(method);
-        this.headers['Content-Type'] = 'application/json';
-      } // Currently, all methods make GET requests. If a method makes a request with a body payload,
-      // remember to add {'Content-Type': 'application/json'} to the header.
-
-
-      var runRequest = function runRequest() {
-        return fetch(url, {
-          method: requestMethod,
-          headers: _objectSpread$1({
-            Authorization: _this.authorization,
-            'x-request-id': baseRequestId && "".concat(baseRequestId, "-span-").concat(spanCounter++)
-          }, _this.headers),
-          credentials: _this.credentials,
-          body: requestMethod === 'POST' ? JSON.stringify(params) : null
-        });
-      };
-
-      return {
-        /* eslint no-unsafe-finally: off */
-        subscribe: function subscribe(callback) {
-          var _this2 = this;
-
-          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-            var result;
-            return _regeneratorRuntime.wrap(function _callee$(_context) {
-              while (1) {
-                switch (_context.prev = _context.next) {
-                  case 0:
-                    result = {
-                      error: 'network Error' // add default error message
-
-                    };
-                    _context.prev = 1;
-                    _context.next = 4;
-                    return runRequest();
-
-                  case 4:
-                    result = _context.sent;
-
-                  case 5:
-                    _context.prev = 5;
-                    return _context.abrupt("return", callback(result, function () {
-                      return _this2.subscribe(callback);
-                    }));
-
-                  case 8:
-                  case "end":
-                    return _context.stop();
-                }
-              }
-            }, _callee, null, [[1,, 5, 8]]);
-          }))();
-        }
-      };
-    }
-  }]);
-
-  return HttpTransport;
-}();
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+  request(method, {
+    baseRequestId,
+    ...params
+  }) {
+    let spanCounter = 1;
+    const searchParams = new URLSearchParams(params && Object.keys(params).map(k => ({
+      [k]: typeof params[k] === 'object' ? JSON.stringify(params[k]) : params[k]
+    })).reduce((a, b) => ({ ...a,
+      ...b
+    }), {}));
+    let url = `${this.apiUrl}/${method}${searchParams.toString().length ? `?${searchParams}` : ''}`;
+    const requestMethod = this.method || (url.length < 2000 ? 'GET' : 'POST');
+
+    if (requestMethod === 'POST') {
+      url = `${this.apiUrl}/${method}`;
+      this.headers['Content-Type'] = 'application/json';
+    } // Currently, all methods make GET requests. If a method makes a request with a body payload,
+    // remember to add {'Content-Type': 'application/json'} to the header.
+
+
+    const runRequest = () => fetch(url, {
+      method: requestMethod,
+      headers: {
+        Authorization: this.authorization,
+        'x-request-id': baseRequestId && `${baseRequestId}-span-${spanCounter++}`,
+        ...this.headers
+      },
+      credentials: this.credentials,
+      body: requestMethod === 'POST' ? JSON.stringify(params) : null
+    });
 
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+    return {
+      /* eslint no-unsafe-finally: off */
+      async subscribe(callback) {
+        let result = {
+          error: 'network Error' // add default error message
 
-var RequestError = /*#__PURE__*/function (_Error) {
-  _inherits(RequestError, _Error);
+        };
 
-  var _super = _createSuper(RequestError);
+        try {
+          result = await runRequest();
+        } finally {
+          return callback(result, () => this.subscribe(callback));
+        }
+      }
 
-  function RequestError(message, response, status) {
-    var _this;
+    };
+  }
 
-    _classCallCheck(this, RequestError);
+}
 
-    _this = _super.call(this, message);
-    _this.response = response;
-    _this.status = status;
-    return _this;
+class RequestError extends Error {
+  constructor(message, response, status) {
+    super(message);
+    this.response = response;
+    this.status = status;
   }
 
-  return _createClass(RequestError);
-}( /*#__PURE__*/_wrapNativeSuper(Error));
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+}
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var mutexCounter = 0;
-var MUTEX_ERROR = 'Mutex has been changed';
+let mutexCounter = 0;
+const MUTEX_ERROR = 'Mutex has been changed';
 /**
  * Query result dataset formats enum.
  */
 
-var ResultType = {
+const ResultType = {
   DEFAULT: 'default',
   COMPACT: 'compact'
 };
 
 function mutexPromise(promise) {
-  return new Promise( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(resolve, reject) {
-      return _regeneratorRuntime.wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              _context.prev = 0;
-              _context.t0 = resolve;
-              _context.next = 4;
-              return promise;
-
-            case 4:
-              _context.t1 = _context.sent;
-              (0, _context.t0)(_context.t1);
-              _context.next = 11;
-              break;
-
-            case 8:
-              _context.prev = 8;
-              _context.t2 = _context["catch"](0);
-
-              if (_context.t2 !== MUTEX_ERROR) {
-                reject(_context.t2);
-              }
-
-            case 11:
-            case "end":
-              return _context.stop();
-          }
-        }
-      }, _callee, null, [[0, 8]]);
-    }));
-
-    return function (_x, _x2) {
-      return _ref.apply(this, arguments);
-    };
-  }());
+  return new Promise(async (resolve, reject) => {
+    try {
+      resolve(await promise);
+    } catch (error) {
+      if (error !== MUTEX_ERROR) {
+        reject(error);
+      }
+    }
+  });
 }
 
-var CubejsApi = /*#__PURE__*/function () {
-  function CubejsApi(apiToken, options) {
-    _classCallCheck(this, CubejsApi);
-
-    if (apiToken !== null && !Array.isArray(apiToken) && _typeof(apiToken) === 'object') {
+class CubejsApi {
+  constructor(apiToken, options) {
+    if (apiToken !== null && !Array.isArray(apiToken) && typeof apiToken === 'object') {
       options = apiToken;
       apiToken = undefined;
     }
@@ -1749,621 +1267,283 @@ var CubejsApi = /*#__PURE__*/function () {
     this.updateAuthorizationPromise = null;
   }
 
-  _createClass(CubejsApi, [{
-    key: "request",
-    value: function request(method, params) {
-      return this.transport.request(method, _objectSpread({
-        baseRequestId: v4()
-      }, params));
+  request(method, params) {
+    return this.transport.request(method, {
+      baseRequestId: v4(),
+      ...params
+    });
+  }
+
+  loadMethod(request, toResult, options, callback) {
+    const mutexValue = ++mutexCounter;
+
+    if (typeof options === 'function' && !callback) {
+      callback = options;
+      options = undefined;
     }
-  }, {
-    key: "loadMethod",
-    value: function loadMethod(request, toResult, options, callback) {
-      var _this = this;
 
-      var mutexValue = ++mutexCounter;
+    options = options || {};
+    const mutexKey = options.mutexKey || 'default';
 
-      if (typeof options === 'function' && !callback) {
-        callback = options;
-        options = undefined;
-      }
+    if (options.mutexObj) {
+      options.mutexObj[mutexKey] = mutexValue;
+    }
+
+    const requestPromise = this.updateTransportAuthorization().then(() => request());
+    let skipAuthorizationUpdate = true;
+    let unsubscribed = false;
+
+    const checkMutex = async () => {
+      const requestInstance = await requestPromise;
+
+      if (options.mutexObj && options.mutexObj[mutexKey] !== mutexValue) {
+        unsubscribed = true;
 
-      options = options || {};
-      var mutexKey = options.mutexKey || 'default';
+        if (requestInstance.unsubscribe) {
+          await requestInstance.unsubscribe();
+        }
 
-      if (options.mutexObj) {
-        options.mutexObj[mutexKey] = mutexValue;
+        throw MUTEX_ERROR;
       }
+    };
 
-      var requestPromise = this.updateTransportAuthorization().then(function () {
-        return request();
-      });
-      var skipAuthorizationUpdate = true;
-      var unsubscribed = false;
-
-      var checkMutex = /*#__PURE__*/function () {
-        var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
-          var requestInstance;
-          return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-            while (1) {
-              switch (_context2.prev = _context2.next) {
-                case 0:
-                  _context2.next = 2;
-                  return requestPromise;
-
-                case 2:
-                  requestInstance = _context2.sent;
-
-                  if (!(options.mutexObj && options.mutexObj[mutexKey] !== mutexValue)) {
-                    _context2.next = 9;
-                    break;
-                  }
-
-                  unsubscribed = true;
-
-                  if (!requestInstance.unsubscribe) {
-                    _context2.next = 8;
-                    break;
-                  }
-
-                  _context2.next = 8;
-                  return requestInstance.unsubscribe();
-
-                case 8:
-                  throw MUTEX_ERROR;
-
-                case 9:
-                case "end":
-                  return _context2.stop();
-              }
-            }
-          }, _callee2);
-        }));
+    const loadImpl = async (response, next) => {
+      const requestInstance = await requestPromise;
 
-        return function checkMutex() {
-          return _ref2.apply(this, arguments);
-        };
-      }();
-
-      var loadImpl = /*#__PURE__*/function () {
-        var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(response, next) {
-          var requestInstance, subscribeNext, continueWait, body, text, error, result;
-          return _regeneratorRuntime.wrap(function _callee5$(_context5) {
-            while (1) {
-              switch (_context5.prev = _context5.next) {
-                case 0:
-                  _context5.next = 2;
-                  return requestPromise;
-
-                case 2:
-                  requestInstance = _context5.sent;
-
-                  subscribeNext = /*#__PURE__*/function () {
-                    var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
-                      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
-                        while (1) {
-                          switch (_context3.prev = _context3.next) {
-                            case 0:
-                              if (!(options.subscribe && !unsubscribed)) {
-                                _context3.next = 8;
-                                break;
-                              }
-
-                              if (!requestInstance.unsubscribe) {
-                                _context3.next = 5;
-                                break;
-                              }
-
-                              return _context3.abrupt("return", next());
-
-                            case 5:
-                              _context3.next = 7;
-                              return new Promise(function (resolve) {
-                                return setTimeout(function () {
-                                  return resolve();
-                                }, _this.pollInterval * 1000);
-                              });
-
-                            case 7:
-                              return _context3.abrupt("return", next());
-
-                            case 8:
-                              return _context3.abrupt("return", null);
-
-                            case 9:
-                            case "end":
-                              return _context3.stop();
-                          }
-                        }
-                      }, _callee3);
-                    }));
-
-                    return function subscribeNext() {
-                      return _ref4.apply(this, arguments);
-                    };
-                  }();
-
-                  continueWait = /*#__PURE__*/function () {
-                    var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(wait) {
-                      return _regeneratorRuntime.wrap(function _callee4$(_context4) {
-                        while (1) {
-                          switch (_context4.prev = _context4.next) {
-                            case 0:
-                              if (unsubscribed) {
-                                _context4.next = 5;
-                                break;
-                              }
-
-                              if (!wait) {
-                                _context4.next = 4;
-                                break;
-                              }
-
-                              _context4.next = 4;
-                              return new Promise(function (resolve) {
-                                return setTimeout(function () {
-                                  return resolve();
-                                }, _this.pollInterval * 1000);
-                              });
-
-                            case 4:
-                              return _context4.abrupt("return", next());
-
-                            case 5:
-                              return _context4.abrupt("return", null);
-
-                            case 6:
-                            case "end":
-                              return _context4.stop();
-                          }
-                        }
-                      }, _callee4);
-                    }));
-
-                    return function continueWait(_x5) {
-                      return _ref5.apply(this, arguments);
-                    };
-                  }();
-
-                  if (!(options.subscribe && !skipAuthorizationUpdate)) {
-                    _context5.next = 8;
-                    break;
-                  }
-
-                  _context5.next = 8;
-                  return _this.updateTransportAuthorization();
-
-                case 8:
-                  skipAuthorizationUpdate = false;
-
-                  if (!(response.status === 502)) {
-                    _context5.next = 13;
-                    break;
-                  }
-
-                  _context5.next = 12;
-                  return checkMutex();
-
-                case 12:
-                  return _context5.abrupt("return", continueWait(true));
-
-                case 13:
-                  body = {};
-                  text = '';
-                  _context5.prev = 15;
-                  _context5.next = 18;
-                  return response.text();
-
-                case 18:
-                  text = _context5.sent;
-                  body = JSON.parse(text);
-                  _context5.next = 25;
-                  break;
-
-                case 22:
-                  _context5.prev = 22;
-                  _context5.t0 = _context5["catch"](15);
-                  body.error = text;
-
-                case 25:
-                  if (!(body.error === 'Continue wait')) {
-                    _context5.next = 30;
-                    break;
-                  }
-
-                  _context5.next = 28;
-                  return checkMutex();
-
-                case 28:
-                  if (options.progressCallback) {
-                    options.progressCallback(new ProgressResult(body));
-                  }
-
-                  return _context5.abrupt("return", continueWait());
-
-                case 30:
-                  if (!(response.status !== 200)) {
-                    _context5.next = 43;
-                    break;
-                  }
-
-                  _context5.next = 33;
-                  return checkMutex();
-
-                case 33:
-                  if (!(!options.subscribe && requestInstance.unsubscribe)) {
-                    _context5.next = 36;
-                    break;
-                  }
-
-                  _context5.next = 36;
-                  return requestInstance.unsubscribe();
-
-                case 36:
-                  error = new RequestError(body.error, body, response.status); // TODO error class
-
-                  if (!callback) {
-                    _context5.next = 41;
-                    break;
-                  }
-
-                  callback(error);
-                  _context5.next = 42;
-                  break;
-
-                case 41:
-                  throw error;
-
-                case 42:
-                  return _context5.abrupt("return", subscribeNext());
-
-                case 43:
-                  _context5.next = 45;
-                  return checkMutex();
-
-                case 45:
-                  if (!(!options.subscribe && requestInstance.unsubscribe)) {
-                    _context5.next = 48;
-                    break;
-                  }
-
-                  _context5.next = 48;
-                  return requestInstance.unsubscribe();
+      const subscribeNext = async () => {
+        if (options.subscribe && !unsubscribed) {
+          if (requestInstance.unsubscribe) {
+            return next();
+          } else {
+            await new Promise(resolve => setTimeout(() => resolve(), this.pollInterval * 1000));
+            return next();
+          }
+        }
 
-                case 48:
-                  result = toResult(body);
-
-                  if (!callback) {
-                    _context5.next = 53;
-                    break;
-                  }
-
-                  callback(null, result);
-                  _context5.next = 54;
-                  break;
-
-                case 53:
-                  return _context5.abrupt("return", result);
-
-                case 54:
-                  return _context5.abrupt("return", subscribeNext());
-
-                case 55:
-                case "end":
-                  return _context5.stop();
-              }
-            }
-          }, _callee5, null, [[15, 22]]);
-        }));
+        return null;
+      };
 
-        return function loadImpl(_x3, _x4) {
-          return _ref3.apply(this, arguments);
-        };
-      }();
+      const continueWait = async wait => {
+        if (!unsubscribed) {
+          if (wait) {
+            await new Promise(resolve => setTimeout(() => resolve(), this.pollInterval * 1000));
+          }
 
-      var promise = requestPromise.then(function (requestInstance) {
-        return mutexPromise(requestInstance.subscribe(loadImpl));
-      });
+          return next();
+        }
 
-      if (callback) {
-        return {
-          unsubscribe: function () {
-            var _unsubscribe = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
-              var requestInstance;
-              return _regeneratorRuntime.wrap(function _callee6$(_context6) {
-                while (1) {
-                  switch (_context6.prev = _context6.next) {
-                    case 0:
-                      _context6.next = 2;
-                      return requestPromise;
-
-                    case 2:
-                      requestInstance = _context6.sent;
-                      unsubscribed = true;
-
-                      if (!requestInstance.unsubscribe) {
-                        _context6.next = 6;
-                        break;
-                      }
-
-                      return _context6.abrupt("return", requestInstance.unsubscribe());
-
-                    case 6:
-                      return _context6.abrupt("return", null);
-
-                    case 7:
-                    case "end":
-                      return _context6.stop();
-                  }
-                }
-              }, _callee6);
-            }));
-
-            function unsubscribe() {
-              return _unsubscribe.apply(this, arguments);
-            }
+        return null;
+      };
 
-            return unsubscribe;
-          }()
-        };
-      } else {
-        return promise;
+      if (options.subscribe && !skipAuthorizationUpdate) {
+        await this.updateTransportAuthorization();
       }
-    }
-  }, {
-    key: "updateTransportAuthorization",
-    value: function () {
-      var _updateTransportAuthorization = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
-        var _this2 = this;
-
-        return _regeneratorRuntime.wrap(function _callee8$(_context8) {
-          while (1) {
-            switch (_context8.prev = _context8.next) {
-              case 0:
-                if (!this.updateAuthorizationPromise) {
-                  _context8.next = 4;
-                  break;
-                }
-
-                _context8.next = 3;
-                return this.updateAuthorizationPromise;
-
-              case 3:
-                return _context8.abrupt("return");
-
-              case 4:
-                if (!(typeof this.apiToken === 'function')) {
-                  _context8.next = 8;
-                  break;
-                }
-
-                this.updateAuthorizationPromise = new Promise( /*#__PURE__*/function () {
-                  var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(resolve, reject) {
-                    var token;
-                    return _regeneratorRuntime.wrap(function _callee7$(_context7) {
-                      while (1) {
-                        switch (_context7.prev = _context7.next) {
-                          case 0:
-                            _context7.prev = 0;
-                            _context7.next = 3;
-                            return _this2.apiToken();
-
-                          case 3:
-                            token = _context7.sent;
-
-                            if (_this2.transport.authorization !== token) {
-                              _this2.transport.authorization = token;
-                            }
-
-                            resolve();
-                            _context7.next = 11;
-                            break;
-
-                          case 8:
-                            _context7.prev = 8;
-                            _context7.t0 = _context7["catch"](0);
-                            reject(_context7.t0);
-
-                          case 11:
-                            _context7.prev = 11;
-                            _this2.updateAuthorizationPromise = null;
-                            return _context7.finish(11);
-
-                          case 14:
-                          case "end":
-                            return _context7.stop();
-                        }
-                      }
-                    }, _callee7, null, [[0, 8, 11, 14]]);
-                  }));
-
-                  return function (_x6, _x7) {
-                    return _ref6.apply(this, arguments);
-                  };
-                }());
-                _context8.next = 8;
-                return this.updateAuthorizationPromise;
-
-              case 8:
-              case "end":
-                return _context8.stop();
-            }
-          }
-        }, _callee8, this);
-      }));
 
-      function updateTransportAuthorization() {
-        return _updateTransportAuthorization.apply(this, arguments);
+      skipAuthorizationUpdate = false;
+
+      if (response.status === 502) {
+        await checkMutex();
+        return continueWait(true);
       }
 
-      return updateTransportAuthorization;
-    }()
-    /**
-     * Add system properties to a query object.
-     * @param {Query} query
-     * @param {string} responseFormat
-     * @returns {void}
-     * @private
-     */
+      let body = {};
+      let text = '';
 
-  }, {
-    key: "patchQueryInternal",
-    value: function patchQueryInternal(query, responseFormat) {
-      if (responseFormat === ResultType.COMPACT && query.responseFormat !== ResultType.COMPACT) {
-        return _objectSpread(_objectSpread({}, query), {}, {
-          responseFormat: ResultType.COMPACT
-        });
-      } else {
-        return query;
+      try {
+        text = await response.text();
+        body = JSON.parse(text);
+      } catch (_) {
+        body.error = text;
       }
-    }
-    /**
-     * Process result fetched from the gateway#load method according
-     * to the network protocol.
-     * @param {*} response
-     * @returns ResultSet
-     * @private
-     */
 
-  }, {
-    key: "loadResponseInternal",
-    value: function loadResponseInternal(response) {
-      if (response.results.length && response.results[0].query.responseFormat && response.results[0].query.responseFormat === ResultType.COMPACT) {
-        response.results.forEach(function (result, j) {
-          var data = [];
-          result.data.dataset.forEach(function (r) {
-            var row = {};
-            result.data.members.forEach(function (m, i) {
-              row[m] = r[i];
-            });
-            data.push(row);
-          });
-          response.results[j].data = data;
-        });
+      if (body.error === 'Continue wait') {
+        await checkMutex();
+
+        if (options.progressCallback) {
+          options.progressCallback(new ProgressResult(body));
+        }
+
+        return continueWait();
       }
 
-      return new ResultSet(response, {
-        parseDateMeasures: this.parseDateMeasures
-      });
-    }
-    /**
-     * Fetch data for the passed `query`. Operates with the
-     * `ApiGateway#load` method to fetch the data.
-     * @param {Query | Query[]} query
-     * @param {LoadMethodOptions | undefined} options
-     * @param {LoadMethodCallback<ResultSet> | undefined} callback
-     * @param {string} responseFormat
-     * @returns {undefined | Promise<ResultSet>}
-     */
+      if (response.status !== 200) {
+        await checkMutex();
 
-  }, {
-    key: "load",
-    value: function load(query, options, callback) {
-      var _this3 = this;
+        if (!options.subscribe && requestInstance.unsubscribe) {
+          await requestInstance.unsubscribe();
+        }
 
-      var responseFormat = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ResultType.DEFAULT;
+        const error = new RequestError(body.error, body, response.status); // TODO error class
 
-      if (responseFormat === ResultType.COMPACT) {
-        if (Array.isArray(query)) {
-          query = query.map(function (q) {
-            return _this3.patchQueryInternal(q, ResultType.COMPACT);
-          });
+        if (callback) {
+          callback(error);
         } else {
-          query = this.patchQueryInternal(query, ResultType.COMPACT);
+          throw error;
         }
+
+        return subscribeNext();
       }
 
-      return this.loadMethod(function () {
-        return _this3.request('load', {
-          query: query,
-          queryType: 'multi'
-        });
-      }, this.loadResponseInternal.bind(this), options, callback);
-    }
-    /**
-     * Allows you to fetch data and receive updates over time. Operates
-     * with the `ApiGateway#load` method to fetch the data.
-     * @link real-time-data-fetch
-     * @param {Query | Query[]} query
-     * @param {LoadMethodOptions | null} options
-     * @param {LoadMethodCallback<ResultSet> | undefined} callback
-     * @param {string} responseFormat
-     * @returns {void}
-     */
+      await checkMutex();
 
-  }, {
-    key: "subscribe",
-    value: function subscribe(query, options, callback) {
-      var _this4 = this;
+      if (!options.subscribe && requestInstance.unsubscribe) {
+        await requestInstance.unsubscribe();
+      }
 
-      var responseFormat = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ResultType.DEFAULT;
+      const result = toResult(body);
 
-      if (responseFormat === ResultType.COMPACT) {
-        if (Array.isArray(query)) {
-          query = query.map(function (q) {
-            return _this4.patchQueryInternal(q, ResultType.COMPACT);
-          });
-        } else {
-          query = this.patchQueryInternal(query, ResultType.COMPACT);
-        }
+      if (callback) {
+        callback(null, result);
+      } else {
+        return result;
       }
 
-      return this.loadMethod(function () {
-        return _this4.request('subscribe', {
-          query: query,
-          queryType: 'multi'
-        });
-      }, this.loadResponseInternal.bind(this), _objectSpread(_objectSpread({}, options), {}, {
-        subscribe: true
-      }), callback);
+      return subscribeNext();
+    };
+
+    const promise = requestPromise.then(requestInstance => mutexPromise(requestInstance.subscribe(loadImpl)));
+
+    if (callback) {
+      return {
+        unsubscribe: async () => {
+          const requestInstance = await requestPromise;
+          unsubscribed = true;
+
+          if (requestInstance.unsubscribe) {
+            return requestInstance.unsubscribe();
+          }
+
+          return null;
+        }
+      };
+    } else {
+      return promise;
     }
-  }, {
-    key: "sql",
-    value: function sql(query, options, callback) {
-      var _this5 = this;
+  }
+
+  async updateTransportAuthorization() {
+    if (this.updateAuthorizationPromise) {
+      await this.updateAuthorizationPromise;
+      return;
+    }
+
+    if (typeof this.apiToken === 'function') {
+      this.updateAuthorizationPromise = new Promise(async (resolve, reject) => {
+        try {
+          const token = await this.apiToken();
 
-      return this.loadMethod(function () {
-        return _this5.request('sql', {
-          query: query
+          if (this.transport.authorization !== token) {
+            this.transport.authorization = token;
+          }
+
+          resolve();
+        } catch (error) {
+          reject(error);
+        } finally {
+          this.updateAuthorizationPromise = null;
+        }
+      });
+      await this.updateAuthorizationPromise;
+    }
+  }
+  /**
+   * Add system properties to a query object.
+   * @param {Query} query
+   * @param {string} responseFormat
+   * @returns {void}
+   * @private
+   */
+
+
+  patchQueryInternal(query, responseFormat) {
+    if (responseFormat === ResultType.COMPACT && query.responseFormat !== ResultType.COMPACT) {
+      return { ...query,
+        responseFormat: ResultType.COMPACT
+      };
+    } else {
+      return query;
+    }
+  }
+  /**
+   * Process result fetched from the gateway#load method according
+   * to the network protocol.
+   * @param {*} response
+   * @returns ResultSet
+   * @private
+   */
+
+
+  loadResponseInternal(response) {
+    if (response.results.length && response.results[0].query.responseFormat && response.results[0].query.responseFormat === ResultType.COMPACT) {
+      response.results.forEach((result, j) => {
+        const data = [];
+        result.data.dataset.forEach(r => {
+          const row = {};
+          result.data.members.forEach((m, i) => {
+            row[m] = r[i];
+          });
+          data.push(row);
         });
-      }, function (response) {
-        return Array.isArray(response) ? response.map(function (body) {
-          return new SqlQuery(body);
-        }) : new SqlQuery(response);
-      }, options, callback);
+        response.results[j].data = data;
+      });
     }
-  }, {
-    key: "meta",
-    value: function meta(options, callback) {
-      var _this6 = this;
-
-      return this.loadMethod(function () {
-        return _this6.request('meta');
-      }, function (body) {
-        return new Meta(body);
-      }, options, callback);
+
+    return new ResultSet(response, {
+      parseDateMeasures: this.parseDateMeasures
+    });
+  }
+
+  load(query, options, callback, responseFormat = ResultType.DEFAULT) {
+    if (responseFormat === ResultType.COMPACT) {
+      if (Array.isArray(query)) {
+        query = query.map(q => this.patchQueryInternal(q, ResultType.COMPACT));
+      } else {
+        query = this.patchQueryInternal(query, ResultType.COMPACT);
+      }
     }
-  }, {
-    key: "dryRun",
-    value: function dryRun(query, options, callback) {
-      var _this7 = this;
 
-      return this.loadMethod(function () {
-        return _this7.request('dry-run', {
-          query: query
-        });
-      }, function (response) {
-        return response;
-      }, options, callback);
+    return this.loadMethod(() => this.request('load', {
+      query,
+      queryType: 'multi'
+    }), this.loadResponseInternal.bind(this), options, callback);
+  }
+
+  subscribe(query, options, callback, responseFormat = ResultType.DEFAULT) {
+    if (responseFormat === ResultType.COMPACT) {
+      if (Array.isArray(query)) {
+        query = query.map(q => this.patchQueryInternal(q, ResultType.COMPACT));
+      } else {
+        query = this.patchQueryInternal(query, ResultType.COMPACT);
+      }
     }
-  }]);
 
-  return CubejsApi;
-}();
+    return this.loadMethod(() => this.request('subscribe', {
+      query,
+      queryType: 'multi'
+    }), this.loadResponseInternal.bind(this), { ...options,
+      subscribe: true
+    }, callback);
+  }
 
-var index = (function (apiToken, options) {
-  return new CubejsApi(apiToken, options);
-});
+  sql(query, options, callback) {
+    return this.loadMethod(() => this.request('sql', {
+      query
+    }), response => Array.isArray(response) ? response.map(body => new SqlQuery(body)) : new SqlQuery(response), options, callback);
+  }
+
+  meta(options, callback) {
+    return this.loadMethod(() => this.request('meta'), body => new Meta(body), options, callback);
+  }
+
+  dryRun(query, options, callback) {
+    return this.loadMethod(() => this.request('dry-run', {
+      query
+    }), response => response, options, callback);
+  }
+
+}
+
+var index = ((apiToken, options) => new CubejsApi(apiToken, options));
 
 export default index;
 export { CubejsApi, DEFAULT_GRANULARITY, GRANULARITIES, HttpTransport, RequestError, ResultSet, aliasSeries, areQueriesEqual, defaultHeuristics, defaultOrder, flattenFilters, getOrderMembersFromOrder, getQueryMembers, isQueryPresent, moveItemInArray, movePivotItem, removeEmptyQueryFields, validateQuery };