@perses-dev/core 0.38.0 → 0.40.0

package/dist/cjs/model/units/time.js

@@ -21,85 +21,146 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    PersesTimeToIntlTime: ()=>PersesTimeToIntlTime,
-    TIME_GROUP_CONFIG: ()=>TIME_GROUP_CONFIG,
-    TIME_UNIT_CONFIG: ()=>TIME_UNIT_CONFIG,
-    formatTime: ()=>formatTime
+    PersesTimeToIntlTime: function() {
+        return PersesTimeToIntlTime;
+    },
+    TIME_GROUP_CONFIG: function() {
+        return TIME_GROUP_CONFIG;
+    },
+    TIME_UNIT_CONFIG: function() {
+        return TIME_UNIT_CONFIG;
+    },
+    formatTime: function() {
+        return formatTime;
+    }
 });
 const _constants = require("./constants");
 const _utils = require("./utils");
-const timeUnitKinds = [
-    'Milliseconds',
-    'Seconds',
-    'Minutes',
-    'Hours',
-    'Days',
-    'Weeks',
-    'Months',
-    'Years'
+const timeUnits = [
+    'milliseconds',
+    'seconds',
+    'minutes',
+    'hours',
+    'days',
+    'weeks',
+    'months',
+    'years'
 ];
 const TIME_GROUP = 'Time';
 const TIME_GROUP_CONFIG = {
     label: 'Time',
-    decimal_places: true
+    decimalPlaces: true
 };
 const TIME_UNIT_CONFIG = {
-    Milliseconds: {
+    milliseconds: {
         group: TIME_GROUP,
         label: 'Milliseconds'
     },
-    Seconds: {
+    seconds: {
         group: TIME_GROUP,
         label: 'Seconds'
     },
-    Minutes: {
+    minutes: {
         group: TIME_GROUP,
         label: 'Minutes'
     },
-    Hours: {
+    hours: {
         group: TIME_GROUP,
         label: 'Hours'
     },
-    Days: {
+    days: {
         group: TIME_GROUP,
         label: 'Days'
     },
-    Weeks: {
+    weeks: {
         group: TIME_GROUP,
         label: 'Weeks'
     },
-    Months: {
+    months: {
         group: TIME_GROUP,
         label: 'Months'
     },
-    Years: {
+    years: {
         group: TIME_GROUP,
         label: 'Years'
     }
 };
 var PersesTimeToIntlTime;
 (function(PersesTimeToIntlTime) {
-    PersesTimeToIntlTime["Milliseconds"] = 'millisecond';
-    PersesTimeToIntlTime["Seconds"] = 'second';
-    PersesTimeToIntlTime["Minutes"] = 'minute';
-    PersesTimeToIntlTime["Hours"] = 'hour';
-    PersesTimeToIntlTime["Days"] = 'day';
-    PersesTimeToIntlTime["Weeks"] = 'week';
-    PersesTimeToIntlTime["Months"] = 'month';
-    PersesTimeToIntlTime["Years"] = 'year';
+    PersesTimeToIntlTime["milliseconds"] = 'millisecond';
+    PersesTimeToIntlTime["seconds"] = 'second';
+    PersesTimeToIntlTime["minutes"] = 'minute';
+    PersesTimeToIntlTime["hours"] = 'hour';
+    PersesTimeToIntlTime["days"] = 'day';
+    PersesTimeToIntlTime["weeks"] = 'week';
+    PersesTimeToIntlTime["months"] = 'month';
+    PersesTimeToIntlTime["years"] = 'year';
 })(PersesTimeToIntlTime || (PersesTimeToIntlTime = {}));
-function formatTime(value, { kind , decimal_places  }) {
-    const isMonthOrYear = kind === 'Months' || kind === 'Years';
+/**
+ * Note: This conversion will not be exactly accurate for months and years,
+ * due variations in the lengths of months (i.e. 28 - 31 days) and years (i.e. leap years).
+ * For precision with months and years, we would need more complex algorithms and/or external libraries.
+ * However, we expect that measurements in months and years will be rare.
+ */ const TIME_UNITS_IN_SECONDS = {
+    years: 31536000,
+    months: 2592000,
+    weeks: 604800,
+    days: 86400,
+    hours: 3600,
+    minutes: 60,
+    seconds: 1,
+    milliseconds: 0.001
+};
+const LARGEST_TO_SMALLEST_TIME_UNITS = [
+    'years',
+    'months',
+    'weeks',
+    'days',
+    'hours',
+    'minutes',
+    'seconds',
+    'milliseconds'
+];
+/**
+ * Choose the first time unit that produces a number greater than 1, starting from the biggest time unit.
+ */ function getValueAndKindForNaturalNumbers(value, unit) {
+    const valueInSeconds = value * TIME_UNITS_IN_SECONDS[unit];
+    // Initialize for TS
+    const largestTimeUnit = LARGEST_TO_SMALLEST_TIME_UNITS[0] || 'years';
+    let timeUnit = largestTimeUnit;
+    let valueInTimeUnit = valueInSeconds / TIME_UNITS_IN_SECONDS[largestTimeUnit];
+    for (timeUnit of LARGEST_TO_SMALLEST_TIME_UNITS){
+        valueInTimeUnit = valueInSeconds / TIME_UNITS_IN_SECONDS[timeUnit];
+        if (valueInTimeUnit >= 1) {
+            return {
+                value: valueInTimeUnit,
+                unit: timeUnit
+            };
+        }
+    }
+    // If we didn't find a time unit, we have to settle for the smallest time unit (which is the last time unit).
+    return {
+        value: valueInTimeUnit,
+        unit: timeUnit
+    };
+}
+function isMonthOrYear(unit) {
+    return unit === 'months' || unit === 'years';
+}
+function formatTime(value, { unit , decimalPlaces  }) {
+    if (value === 0) return '0s';
+    const results = getValueAndKindForNaturalNumbers(value, unit);
     const formatterOptions = {
         style: 'unit',
-        unit: PersesTimeToIntlTime[kind],
-        unitDisplay: isMonthOrYear ? 'long' : 'narrow'
+        unit: PersesTimeToIntlTime[results.unit],
+        unitDisplay: isMonthOrYear(results.unit) ? 'long' : 'narrow'
     };
-    if ((0, _utils.hasDecimalPlaces)(decimal_places)) {
-        formatterOptions.minimumFractionDigits = (0, _utils.limitDecimalPlaces)(decimal_places);
-        formatterOptions.maximumFractionDigits = (0, _utils.limitDecimalPlaces)(decimal_places);
+    if ((0, _utils.hasDecimalPlaces)(decimalPlaces)) {
+        formatterOptions.minimumFractionDigits = (0, _utils.limitDecimalPlaces)(decimalPlaces);
+        formatterOptions.maximumFractionDigits = (0, _utils.limitDecimalPlaces)(decimalPlaces);
     } else {
         formatterOptions.maximumSignificantDigits = _constants.MAX_SIGNIFICANT_DIGITS;
     }
-    return Intl.NumberFormat('en-US', formatterOptions).format(value);
+    const formatter = Intl.NumberFormat('en-US', formatterOptions);
+    return formatter.format(results.value);
 }

package/dist/cjs/model/units/types.js

@@ -18,7 +18,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "UNIT_GROUPS", {
     enumerable: true,
-    get: ()=>UNIT_GROUPS
+    get: function() {
+        return UNIT_GROUPS;
+    }
 });
 const UNIT_GROUPS = [
     'Time',

package/dist/cjs/model/units/units.js

@@ -21,18 +21,42 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    UNIT_GROUP_CONFIG: ()=>UNIT_GROUP_CONFIG,
-    UNIT_CONFIG: ()=>UNIT_CONFIG,
-    formatValue: ()=>formatValue,
-    getUnitKindConfig: ()=>getUnitKindConfig,
-    getUnitGroup: ()=>getUnitGroup,
-    getUnitGroupConfig: ()=>getUnitGroupConfig,
-    isTimeUnit: ()=>isTimeUnit,
-    isPercentUnit: ()=>isPercentUnit,
-    isDecimalUnit: ()=>isDecimalUnit,
-    isBytesUnit: ()=>isBytesUnit,
-    isUnitWithDecimalPlaces: ()=>isUnitWithDecimalPlaces,
-    isUnitWithAbbreviate: ()=>isUnitWithAbbreviate
+    UNIT_GROUP_CONFIG: function() {
+        return UNIT_GROUP_CONFIG;
+    },
+    UNIT_CONFIG: function() {
+        return UNIT_CONFIG;
+    },
+    formatValue: function() {
+        return formatValue;
+    },
+    getUnitConfig: function() {
+        return getUnitConfig;
+    },
+    getUnitGroup: function() {
+        return getUnitGroup;
+    },
+    getUnitGroupConfig: function() {
+        return getUnitGroupConfig;
+    },
+    isTimeUnit: function() {
+        return isTimeUnit;
+    },
+    isPercentUnit: function() {
+        return isPercentUnit;
+    },
+    isDecimalUnit: function() {
+        return isDecimalUnit;
+    },
+    isBytesUnit: function() {
+        return isBytesUnit;
+    },
+    isUnitWithDecimalPlaces: function() {
+        return isUnitWithDecimalPlaces;
+    },
+    isUnitWithShortValues: function() {
+        return isUnitWithShortValues;
+    }
 });
 const _bytes = require("./bytes");
 const _decimal = require("./decimal");
@@ -50,52 +74,52 @@ const UNIT_CONFIG = {
     ..._decimal.DECIMAL_UNIT_CONFIG,
     ..._bytes.BYTES_UNIT_CONFIG
 };
-function formatValue(value, unitOptions) {
-    if (unitOptions === undefined) {
+function formatValue(value, formatOptions) {
+    if (formatOptions === undefined) {
         return value.toString();
     }
-    if (isDecimalUnit(unitOptions)) {
-        return (0, _decimal.formatDecimal)(value, unitOptions);
+    if (isBytesUnit(formatOptions)) {
+        return (0, _bytes.formatBytes)(value, formatOptions);
     }
-    if (isTimeUnit(unitOptions)) {
-        return (0, _time.formatTime)(value, unitOptions);
+    if (isDecimalUnit(formatOptions)) {
+        return (0, _decimal.formatDecimal)(value, formatOptions);
     }
-    if (isPercentUnit(unitOptions)) {
-        return (0, _percent.formatPercent)(value, unitOptions);
+    if (isPercentUnit(formatOptions)) {
+        return (0, _percent.formatPercent)(value, formatOptions);
     }
-    if (isBytesUnit(unitOptions)) {
-        return (0, _bytes.formatBytes)(value, unitOptions);
+    if (isTimeUnit(formatOptions)) {
+        return (0, _time.formatTime)(value, formatOptions);
     }
-    const exhaustive = unitOptions;
+    const exhaustive = formatOptions;
     throw new Error(`Unknown unit options ${exhaustive}`);
 }
-function getUnitKindConfig(unitOptions) {
-    return UNIT_CONFIG[unitOptions.kind];
+function getUnitConfig(formatOptions) {
+    return UNIT_CONFIG[formatOptions.unit];
 }
-function getUnitGroup(unitOptions) {
-    return getUnitKindConfig(unitOptions).group;
+function getUnitGroup(formatOptions) {
+    return getUnitConfig(formatOptions).group;
 }
-function getUnitGroupConfig(unitOptions) {
-    const unitConfig = getUnitKindConfig(unitOptions);
+function getUnitGroupConfig(formatOptions) {
+    const unitConfig = getUnitConfig(formatOptions);
     return UNIT_GROUP_CONFIG[unitConfig.group];
 }
-function isTimeUnit(unitOptions) {
-    return getUnitGroup(unitOptions) === 'Time';
+function isTimeUnit(formatOptions) {
+    return getUnitGroup(formatOptions) === 'Time';
 }
-function isPercentUnit(unitOptions) {
-    return getUnitGroup(unitOptions) === 'Percent';
+function isPercentUnit(formatOptions) {
+    return getUnitGroup(formatOptions) === 'Percent';
 }
-function isDecimalUnit(unitOptions) {
-    return getUnitGroup(unitOptions) === 'Decimal';
+function isDecimalUnit(formatOptions) {
+    return getUnitGroup(formatOptions) === 'Decimal';
 }
-function isBytesUnit(unitOptions) {
-    return getUnitGroup(unitOptions) === 'Bytes';
+function isBytesUnit(formatOptions) {
+    return getUnitGroup(formatOptions) === 'Bytes';
 }
-function isUnitWithDecimalPlaces(unitOptions) {
-    const groupConfig = getUnitGroupConfig(unitOptions);
-    return !!groupConfig.decimal_places;
+function isUnitWithDecimalPlaces(formatOptions) {
+    const groupConfig = getUnitGroupConfig(formatOptions);
+    return !!groupConfig.decimalPlaces;
 }
-function isUnitWithAbbreviate(unitOptions) {
-    const groupConfig = getUnitGroupConfig(unitOptions);
-    return !!groupConfig.abbreviate;
+function isUnitWithShortValues(formatOptions) {
+    const groupConfig = getUnitGroupConfig(formatOptions);
+    return !!groupConfig.shortValues;
 }

package/dist/cjs/model/units/utils.js

@@ -21,15 +21,21 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    shouldAbbreviate: ()=>shouldAbbreviate,
-    hasDecimalPlaces: ()=>hasDecimalPlaces,
-    limitDecimalPlaces: ()=>limitDecimalPlaces
+    shouldShortenValues: function() {
+        return shouldShortenValues;
+    },
+    hasDecimalPlaces: function() {
+        return hasDecimalPlaces;
+    },
+    limitDecimalPlaces: function() {
+        return limitDecimalPlaces;
+    }
 });
-function shouldAbbreviate(abbreviate) {
-    return abbreviate !== false;
+function shouldShortenValues(shortValues) {
+    return shortValues !== false;
 }
-function hasDecimalPlaces(decimal_places) {
-    return typeof decimal_places === 'number';
+function hasDecimalPlaces(decimalPlaces) {
+    return typeof decimalPlaces === 'number';
 }
 function limitDecimalPlaces(num) {
     if (!num) return num;

package/dist/cjs/model/variables.js

@@ -14,8 +14,21 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "DEFAULT_ALL_VALUE", {
-    enumerable: true,
-    get: ()=>DEFAULT_ALL_VALUE
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getVariableProject: function() {
+        return getVariableProject;
+    },
+    DEFAULT_ALL_VALUE: function() {
+        return DEFAULT_ALL_VALUE;
+    }
 });
+function getVariableProject(variable) {
+    return 'project' in variable.metadata ? variable.metadata.project : undefined;
+}
 const DEFAULT_ALL_VALUE = '$__all';

package/dist/cjs/utils/event.js

@@ -16,7 +16,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "useEvent", {
     enumerable: true,
-    get: ()=>useEvent
+    get: function() {
+        return useEvent;
+    }
 });
 const _react = require("react");
 function useEvent(handler) {

package/dist/cjs/utils/fetch.js

@@ -23,10 +23,18 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    fetch: ()=>fetch,
-    fetchJson: ()=>fetchJson,
-    FetchError: ()=>FetchError,
-    UserFriendlyError: ()=>UserFriendlyError
+    fetch: function() {
+        return fetch;
+    },
+    fetchJson: function() {
+        return fetchJson;
+    },
+    FetchError: function() {
+        return FetchError;
+    },
+    UserFriendlyError: function() {
+        return UserFriendlyError;
+    }
 });
 async function fetch(...args) {
     const response = await global.fetch(...args);

package/dist/cjs/utils/index.js

@@ -14,21 +14,24 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-_exportStar(require("./event"), exports);
-_exportStar(require("./fetch"), exports);
-_exportStar(require("./is-empty-object"), exports);
-_exportStar(require("./memo"), exports);
-_exportStar(require("./panel-refs"), exports);
-_exportStar(require("./time-series-data"), exports);
-_exportStar(require("./text"), exports);
-function _exportStar(from, to) {
+_export_star(require("./event"), exports);
+_export_star(require("./fetch"), exports);
+_export_star(require("./is-empty-object"), exports);
+_export_star(require("./memo"), exports);
+_export_star(require("./panel-refs"), exports);
+_export_star(require("./text"), exports);
+_export_star(require("./time-series-data"), exports);
+_export_star(require("./types"), exports);
+function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) Object.defineProperty(to, k, {
-            enumerable: true,
-            get: function() {
-                return from[k];
-            }
-        });
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
     });
     return from;
 }

package/dist/cjs/utils/is-empty-object.js

@@ -18,7 +18,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "isEmptyObject", {
     enumerable: true,
-    get: ()=>isEmptyObject
+    get: function() {
+        return isEmptyObject;
+    }
 });
 function isEmptyObject(obj) {
     return Object.getOwnPropertyNames(obj).length === 0;

package/dist/cjs/utils/mathjs.js

@@ -16,7 +16,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "gcd", {
     enumerable: true,
-    get: ()=>gcd
+    get: function() {
+        return gcd;
+    }
 });
 const _mathjs = require("mathjs");
 // This ensures we get a minimal mathjs bundle for just what we need (see https://mathjs.org/docs/custom_bundling.html)

package/dist/cjs/utils/memo.js

@@ -21,12 +21,16 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    useMemoized: ()=>useMemoized,
-    useDeepMemo: ()=>useDeepMemo
+    useMemoized: function() {
+        return useMemoized;
+    },
+    useDeepMemo: function() {
+        return useDeepMemo;
+    }
 });
 const _react = require("react");
-const _isEqual = /*#__PURE__*/ _interopRequireDefault(require("lodash/isEqual"));
-function _interopRequireDefault(obj) {
+const _isEqual = /*#__PURE__*/ _interop_require_default(require("lodash/isEqual"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
@@ -35,8 +39,8 @@ function useMemoized(factory, deps) {
     const ref = (0, _react.useRef)();
     let areEqual = true;
     for(let i = 0; i < deps.length; i++){
-        var ref1;
-        if (((ref1 = ref.current) === null || ref1 === void 0 ? void 0 : ref1.deps[i]) !== deps[i]) {
+        var _ref_current;
+        if (((_ref_current = ref.current) === null || _ref_current === void 0 ? void 0 : _ref_current.deps[i]) !== deps[i]) {
             areEqual = false;
             break;
         }

package/dist/cjs/utils/panel-refs.js

@@ -21,9 +21,15 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    resolvePanelRef: ()=>resolvePanelRef,
-    getPanelKeyFromRef: ()=>getPanelKeyFromRef,
-    createPanelRef: ()=>createPanelRef
+    resolvePanelRef: function() {
+        return resolvePanelRef;
+    },
+    getPanelKeyFromRef: function() {
+        return getPanelKeyFromRef;
+    },
+    createPanelRef: function() {
+        return createPanelRef;
+    }
 });
 function resolvePanelRef(spec, panelRef) {
     const panelsKey = getPanelKeyFromRef(panelRef);

package/dist/cjs/utils/text.js

@@ -21,32 +21,57 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    getDashboardDisplayName: ()=>getDashboardDisplayName,
-    getVariableDisplayName: ()=>getVariableDisplayName,
-    getDashboardExtendedDisplayName: ()=>getDashboardExtendedDisplayName,
-    getVariableExtendedDisplayName: ()=>getVariableExtendedDisplayName
+    getDashboardDisplayName: function() {
+        return getDashboardDisplayName;
+    },
+    getVariableDisplayName: function() {
+        return getVariableDisplayName;
+    },
+    getDatasourceDisplayName: function() {
+        return getDatasourceDisplayName;
+    },
+    getDashboardExtendedDisplayName: function() {
+        return getDashboardExtendedDisplayName;
+    },
+    getVariableExtendedDisplayName: function() {
+        return getVariableExtendedDisplayName;
+    },
+    getDatasourceExtendedDisplayName: function() {
+        return getDatasourceExtendedDisplayName;
+    }
 });
 function getDashboardDisplayName(dashboard) {
-    var ref;
-    var ref1;
-    return (ref1 = (ref = dashboard.spec.display) === null || ref === void 0 ? void 0 : ref.name) !== null && ref1 !== void 0 ? ref1 : dashboard.metadata.name;
+    var _dashboard_spec_display;
+    var _dashboard_spec_display_name;
+    return (_dashboard_spec_display_name = (_dashboard_spec_display = dashboard.spec.display) === null || _dashboard_spec_display === void 0 ? void 0 : _dashboard_spec_display.name) !== null && _dashboard_spec_display_name !== void 0 ? _dashboard_spec_display_name : dashboard.metadata.name;
 }
 function getVariableDisplayName(variable) {
-    var ref;
-    var ref1;
-    return (ref1 = (ref = variable.spec.spec.display) === null || ref === void 0 ? void 0 : ref.name) !== null && ref1 !== void 0 ? ref1 : variable.metadata.name;
+    var _variable_spec_spec_display;
+    var _variable_spec_spec_display_name;
+    return (_variable_spec_spec_display_name = (_variable_spec_spec_display = variable.spec.spec.display) === null || _variable_spec_spec_display === void 0 ? void 0 : _variable_spec_spec_display.name) !== null && _variable_spec_spec_display_name !== void 0 ? _variable_spec_spec_display_name : variable.metadata.name;
+}
+function getDatasourceDisplayName(datasource) {
+    var _datasource_spec_display;
+    return ((_datasource_spec_display = datasource.spec.display) === null || _datasource_spec_display === void 0 ? void 0 : _datasource_spec_display.name) || datasource.metadata.name;
 }
 function getDashboardExtendedDisplayName(dashboard) {
-    var ref;
-    if ((ref = dashboard.spec.display) === null || ref === void 0 ? void 0 : ref.name) {
+    var _dashboard_spec_display;
+    if ((_dashboard_spec_display = dashboard.spec.display) === null || _dashboard_spec_display === void 0 ? void 0 : _dashboard_spec_display.name) {
         return `${dashboard.spec.display.name} (Name: ${dashboard.metadata.name})`;
     }
     return dashboard.metadata.name;
 }
 function getVariableExtendedDisplayName(variable) {
-    var ref;
-    if ((ref = variable.spec.spec.display) === null || ref === void 0 ? void 0 : ref.name) {
+    var _variable_spec_spec_display;
+    if ((_variable_spec_spec_display = variable.spec.spec.display) === null || _variable_spec_spec_display === void 0 ? void 0 : _variable_spec_spec_display.name) {
         return `${variable.spec.spec.display.name} (Name: ${variable.metadata.name})`;
     }
     return variable.metadata.name;
 }
+function getDatasourceExtendedDisplayName(datasource) {
+    var _datasource_spec_display;
+    if ((_datasource_spec_display = datasource.spec.display) === null || _datasource_spec_display === void 0 ? void 0 : _datasource_spec_display.name) {
+        return `${datasource.spec.display.name} (Name: ${datasource.metadata.name})`;
+    }
+    return datasource.metadata.name;
+}

package/dist/cjs/utils/time-series-data.js

@@ -21,11 +21,21 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    MIN_STEP_INTERVAL_MS: ()=>MIN_STEP_INTERVAL_MS,
-    getXValues: ()=>getXValues,
-    getTimeSeriesValues: ()=>getTimeSeriesValues,
-    getYValues: ()=>getYValues,
-    getCommonTimeScale: ()=>getCommonTimeScale
+    MIN_STEP_INTERVAL_MS: function() {
+        return MIN_STEP_INTERVAL_MS;
+    },
+    getXValues: function() {
+        return getXValues;
+    },
+    getTimeSeriesValues: function() {
+        return getTimeSeriesValues;
+    },
+    getYValues: function() {
+        return getYValues;
+    },
+    getCommonTimeScale: function() {
+        return getCommonTimeScale;
+    }
 });
 const _mathjs = require("./mathjs");
 const MIN_STEP_INTERVAL_MS = 10;
@@ -154,13 +164,13 @@ function getCommonTimeScale(seriesData) {
         const calculatedStepMs = (0, _mathjs.gcd)(...steps);
         stepMs = calculatedStepMs < MIN_STEP_INTERVAL_MS ? MIN_STEP_INTERVAL_MS : calculatedStepMs;
     }
-    const startMs1 = timeRange.start.valueOf();
-    const endMs1 = timeRange.end.valueOf();
-    const rangeMs1 = endMs1 - startMs1;
+    const startMs = timeRange.start.valueOf();
+    const endMs = timeRange.end.valueOf();
+    const rangeMs = endMs - startMs;
     return {
-        startMs: startMs1,
-        endMs: endMs1,
+        startMs,
+        endMs,
         stepMs,
-        rangeMs: rangeMs1
+        rangeMs
     };
 }