@perses-dev/core 0.34.0 → 0.36.0

package/dist/cjs/model/calculations.js

@@ -23,67 +23,146 @@ function _export(target, all) {
 _export(exports, {
     CalculationsMap: ()=>CalculationsMap,
     CALCULATIONS_CONFIG: ()=>CALCULATIONS_CONFIG,
-    DEFAULT_CALCULATION: ()=>DEFAULT_CALCULATION
+    DEFAULT_CALCULATION: ()=>DEFAULT_CALCULATION,
+    getCalculations: ()=>getCalculations,
+    getCalculation: ()=>getCalculation
 });
-const _findLast = /*#__PURE__*/ _interopRequireDefault(require("lodash/findLast"));
-const _meanBy = /*#__PURE__*/ _interopRequireDefault(require("lodash/meanBy"));
-const _sumBy = /*#__PURE__*/ _interopRequireDefault(require("lodash/sumBy"));
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
 const CalculationsMap = {
     First: first,
     Last: last,
+    FirstNumber: firstNumber,
     LastNumber: lastNumber,
     Mean: mean,
-    Sum: sum
+    Sum: sum,
+    Min: min,
+    Max: max
 };
 const CALCULATIONS_CONFIG = {
     First: {
-        label: 'First'
+        label: 'First',
+        description: 'First value'
     },
     Last: {
-        label: 'Last'
+        label: 'Last',
+        description: 'Last value'
+    },
+    FirstNumber: {
+        label: 'First *',
+        description: 'First numeric value'
     },
     LastNumber: {
-        label: 'Last number'
+        label: 'Last *',
+        description: 'Last numeric value'
     },
     Mean: {
-        label: 'Mean'
+        label: 'Avg',
+        description: 'Average value excluding nulls'
     },
     Sum: {
-        label: 'Sum'
+        label: 'Sum',
+        description: 'The sum of all values'
+    },
+    Min: {
+        label: 'Min',
+        description: 'Minimum value'
+    },
+    Max: {
+        label: 'Max',
+        description: 'Maximum value'
     }
 };
 const DEFAULT_CALCULATION = 'Sum';
+function getCalculations(values, includeCalculations) {
+    const calculations = includeCalculations.reduce((initResult, calculation)=>{
+        initResult[calculation] = undefined;
+        return initResult;
+    }, {});
+    // We save these values as separate values instead of directly setting them
+    // in the calculations because they are needed by multiple calculations.
+    let nonNullCount = 0;
+    let sum = 0;
+    // We use this large function capable of performing one or more calculations
+    // in a single iteration of the data to minimize the performance impact of
+    // generating multiple calculations for large timeseries values. This is
+    // less optimized for certain single calculations when done in isolation (e.g.
+    // `Last`), but will be more performant in the more expensive cases where
+    // multiple values are being used (e.g. table legend).
+    values.forEach((tuple, i)=>{
+        const value = tuple[1];
+        if (i === 0 && 'First' in calculations) {
+            calculations.First = value;
+        }
+        if (i === values.length - 1 && 'Last' in calculations) {
+            calculations.Last = value;
+        }
+        // Handling specific to non-null values.
+        if (typeof value === 'number') {
+            nonNullCount += 1;
+            sum += value;
+            if ('FirstNumber' in calculations && calculations.FirstNumber === undefined) {
+                // Save the first number we see.
+                calculations.FirstNumber = value;
+            }
+            if ('LastNumber' in calculations) {
+                // Keep setting the numbers we see, which will eventually be set to the
+                // last number when finished iterating.
+                calculations.LastNumber = value;
+            }
+            if ('Min' in calculations) {
+                if (typeof calculations.Min !== 'number') {
+                    // Init the first time we see a number
+                    calculations.Min = value;
+                } else {
+                    // Use lowest value once initialized
+                    calculations.Min = Math.min(calculations.Min, value);
+                }
+            }
+            if ('Max' in calculations) {
+                if (typeof calculations.Max !== 'number') {
+                    // Init the first time we see a number
+                    calculations.Max = value;
+                } else {
+                    // Use highest value once initialized
+                    calculations.Max = Math.max(calculations.Max, value);
+                }
+            }
+        }
+    });
+    // Set calculations that require iterating over all values.
+    if (nonNullCount > 0 && 'Sum' in calculations) {
+        calculations.Sum = sum;
+    }
+    if (nonNullCount > 0 && 'Mean' in calculations) {
+        calculations.Mean = sum / nonNullCount;
+    }
+    return calculations;
+}
+function getCalculation(values, calculation) {
+    return getCalculations(values, [
+        calculation
+    ])[calculation];
+}
 function first(values) {
-    const tuple = values[0];
-    return tuple === undefined ? undefined : getValue(tuple);
+    return getCalculation(values, 'First');
 }
 function last(values) {
-    if (values.length <= 0) return undefined;
-    const tuple = values[values.length - 1];
-    return tuple === undefined ? undefined : getValue(tuple);
+    return getCalculation(values, 'Last');
+}
+function firstNumber(values) {
+    return getCalculation(values, 'FirstNumber');
 }
 function lastNumber(values) {
-    const tuple = (0, _findLast.default)(values, (tuple)=>isNaN(getValue(tuple)) === false);
-    return tuple === undefined ? undefined : getValue(tuple);
+    return getCalculation(values, 'LastNumber');
 }
 function mean(values) {
-    if (values.length <= 0) return undefined;
-    return (0, _meanBy.default)(values, getValue);
+    return getCalculation(values, 'Mean');
 }
 function sum(values) {
-    if (values.length <= 0) return undefined;
-    return (0, _sumBy.default)(values, getValue);
+    return getCalculation(values, 'Sum');
 }
-function getValue(valueTuple) {
-    const value = valueTuple[1];
-    if (value !== null) {
-        return value;
-    }
-    // TODO: refactor utils so null can be returned and LastNotNull supported
-    return NaN;
+function min(values) {
+    return getCalculation(values, 'Min');
+}
+function max(values) {
+    return getCalculation(values, 'Max');
 }

package/dist/cjs/model/index.js

@@ -30,6 +30,7 @@ _exportStar(require("./thresholds"), exports);
 _exportStar(require("./time"), exports);
 _exportStar(require("./time-series-data"), exports);
 _exportStar(require("./time-series-queries"), exports);
+_exportStar(require("./units"), exports);
 _exportStar(require("./variables"), exports);
 function _exportStar(from, to) {
     Object.keys(from).forEach(function(k) {

package/dist/cjs/model/legend.js

@@ -27,11 +27,14 @@ function _export(target, all) {
 _export(exports, {
     legendPositions: ()=>legendPositions,
     legendModes: ()=>legendModes,
+    legendSizes: ()=>legendSizes,
     isValidLegendPosition: ()=>isValidLegendPosition,
     isValidLegendMode: ()=>isValidLegendMode,
+    isValidLegendSize: ()=>isValidLegendSize,
     DEFAULT_LEGEND: ()=>DEFAULT_LEGEND,
     getLegendPosition: ()=>getLegendPosition,
-    getLegendMode: ()=>getLegendMode
+    getLegendMode: ()=>getLegendMode,
+    getLegendSize: ()=>getLegendSize
 });
 const legendPositions = [
     'Bottom',
@@ -41,15 +44,23 @@ const legendModes = [
     'List',
     'Table'
 ];
+const legendSizes = [
+    'Small',
+    'Medium'
+];
 function isValidLegendPosition(position) {
     return legendPositions.includes(position);
 }
 function isValidLegendMode(mode) {
     return legendModes.includes(mode);
 }
+function isValidLegendSize(size) {
+    return legendSizes.includes(size);
+}
 const DEFAULT_LEGEND = {
     position: 'Bottom',
-    mode: 'List'
+    mode: 'List',
+    size: 'Medium'
 };
 function getLegendPosition(position) {
     if (position === undefined) {
@@ -66,3 +77,9 @@ function getLegendMode(mode) {
     }
     return mode;
 }
+function getLegendSize(size) {
+    if (!size || !isValidLegendSize(size)) {
+        return DEFAULT_LEGEND.size;
+    }
+    return size;
+}

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

@@ -0,0 +1,84 @@
+// Copyright 2023 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    BYTES_GROUP_CONFIG: ()=>BYTES_GROUP_CONFIG,
+    BYTES_UNIT_CONFIG: ()=>BYTES_UNIT_CONFIG,
+    formatBytes: ()=>formatBytes
+});
+const _numbro = /*#__PURE__*/ _interopRequireDefault(require("numbro"));
+const _constants = require("./constants");
+const _utils = require("./utils");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const DEFAULT_NUMBRO_MANTISSA = 2;
+const bytesUnitKinds = [
+    'Bytes'
+];
+const BYTES_GROUP_CONFIG = {
+    label: 'Bytes',
+    decimal_places: true,
+    abbreviate: true
+};
+const BYTES_UNIT_CONFIG = {
+    // These units are powers of 1000.
+    // In other words, 1 KB = 1000 bytes.
+    Bytes: {
+        group: 'Bytes',
+        label: 'Bytes'
+    }
+};
+function formatBytes(bytes, options) {
+    const { abbreviate , decimal_places  } = options;
+    if (!(0, _utils.shouldAbbreviate)(abbreviate) || Math.abs(bytes) < 1000) {
+        const formatterOptions = {
+            style: 'unit',
+            unit: 'byte',
+            unitDisplay: 'long',
+            useGrouping: true
+        };
+        if ((0, _utils.hasDecimalPlaces)(decimal_places)) {
+            formatterOptions.minimumFractionDigits = (0, _utils.limitDecimalPlaces)(decimal_places);
+            formatterOptions.maximumFractionDigits = (0, _utils.limitDecimalPlaces)(decimal_places);
+        } else {
+            // This can happen if bytes is between -1000 and 1000
+            if ((0, _utils.shouldAbbreviate)(abbreviate)) {
+                formatterOptions.maximumSignificantDigits = _constants.MAX_SIGNIFICANT_DIGITS;
+            }
+        }
+        return Intl.NumberFormat('en-US', formatterOptions).format(bytes);
+    }
+    // numbro is able to add units like KB, MB, GB, etc. correctly
+    return (0, _numbro.default)(bytes).format({
+        output: 'byte',
+        base: 'decimal',
+        spaceSeparated: true,
+        mantissa: (0, _utils.hasDecimalPlaces)(decimal_places) ? decimal_places : DEFAULT_NUMBRO_MANTISSA,
+        // trimMantissa trims trailing 0s
+        trimMantissa: !(0, _utils.hasDecimalPlaces)(decimal_places),
+        // optionalMantissa excludes all the decimal places if they're all zeros
+        optionalMantissa: !(0, _utils.hasDecimalPlaces)(decimal_places)
+    });
+}

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

@@ -0,0 +1,23 @@
+// Copyright 2023 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// Common constants needed across individual unit groups and the overall
+// combined units.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MAX_SIGNIFICANT_DIGITS", {
+    enumerable: true,
+    get: ()=>MAX_SIGNIFICANT_DIGITS
+});
+const MAX_SIGNIFICANT_DIGITS = 3;

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

@@ -0,0 +1,62 @@
+// Copyright 2023 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DECIMAL_GROUP_CONFIG: ()=>DECIMAL_GROUP_CONFIG,
+    DECIMAL_UNIT_CONFIG: ()=>DECIMAL_UNIT_CONFIG,
+    formatDecimal: ()=>formatDecimal
+});
+const _constants = require("./constants");
+const _utils = require("./utils");
+const decimalUnitKinds = [
+    'Decimal'
+];
+const DECIMAL_GROUP_CONFIG = {
+    label: 'Decimal',
+    decimal_places: true,
+    abbreviate: true
+};
+const DECIMAL_UNIT_CONFIG = {
+    Decimal: {
+        group: 'Decimal',
+        label: 'Decimal'
+    }
+};
+function formatDecimal(value, options) {
+    const { abbreviate , decimal_places  } = options;
+    const formatterOptions = {
+        style: 'decimal',
+        useGrouping: true
+    };
+    if ((0, _utils.shouldAbbreviate)(abbreviate)) {
+        formatterOptions.notation = 'compact';
+    }
+    if ((0, _utils.hasDecimalPlaces)(decimal_places)) {
+        formatterOptions.minimumFractionDigits = (0, _utils.limitDecimalPlaces)(decimal_places);
+        formatterOptions.maximumFractionDigits = (0, _utils.limitDecimalPlaces)(decimal_places);
+    } else {
+        if ((0, _utils.shouldAbbreviate)(abbreviate)) {
+            formatterOptions.maximumSignificantDigits = _constants.MAX_SIGNIFICANT_DIGITS;
+        }
+    }
+    return Intl.NumberFormat('en-US', formatterOptions).format(value);
+}

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

@@ -0,0 +1,31 @@
+// Copyright 2023 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_exportStar(require("./utils"), exports);
+_exportStar(require("./units"), exports);
+_exportStar(require("./constants"), exports);
+_exportStar(require("./types"), exports);
+function _exportStar(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];
+            }
+        });
+    });
+    return from;
+}

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

@@ -0,0 +1,73 @@
+// Copyright 2023 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    PERCENT_GROUP_CONFIG: ()=>PERCENT_GROUP_CONFIG,
+    PERCENT_UNIT_CONFIG: ()=>PERCENT_UNIT_CONFIG,
+    formatPercent: ()=>formatPercent
+});
+const _constants = require("./constants");
+const _utils = require("./utils");
+const percentUnitKinds = [
+    'Percent',
+    'PercentDecimal',
+    '%'
+];
+const PERCENT_GROUP_CONFIG = {
+    label: 'Percent',
+    decimal_places: true
+};
+const PERCENT_GROUP = 'Percent';
+const PERCENT_UNIT_CONFIG = {
+    Percent: {
+        group: PERCENT_GROUP,
+        label: 'Percent (0-100)'
+    },
+    PercentDecimal: {
+        group: PERCENT_GROUP,
+        label: 'Percent (0.0-1.0)'
+    },
+    '%': {
+        // This option is not shown in the selector because it is a shorthand
+        // duplicate of `Percent`.
+        disableSelectorOption: true,
+        group: PERCENT_GROUP,
+        label: '%'
+    }
+};
+function formatPercent(value, { kind , decimal_places  }) {
+    // Intl.NumberFormat translates 0 -> 0%, 0.5 -> 50%, 1 -> 100%
+    if (kind === 'Percent') {
+        value = value / 100;
+    }
+    const formatterOptions = {
+        style: 'percent',
+        useGrouping: true
+    };
+    if ((0, _utils.hasDecimalPlaces)(decimal_places)) {
+        formatterOptions.minimumFractionDigits = (0, _utils.limitDecimalPlaces)(decimal_places);
+        formatterOptions.maximumFractionDigits = (0, _utils.limitDecimalPlaces)(decimal_places);
+    } else {
+        formatterOptions.maximumSignificantDigits = _constants.MAX_SIGNIFICANT_DIGITS;
+    }
+    return Intl.NumberFormat('en-US', formatterOptions).format(value);
+}

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

@@ -0,0 +1,105 @@
+// Copyright 2023 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    PersesTimeToIntlTime: ()=>PersesTimeToIntlTime,
+    TIME_GROUP_CONFIG: ()=>TIME_GROUP_CONFIG,
+    TIME_UNIT_CONFIG: ()=>TIME_UNIT_CONFIG,
+    formatTime: ()=>formatTime
+});
+const _constants = require("./constants");
+const _utils = require("./utils");
+const timeUnitKinds = [
+    'Milliseconds',
+    'Seconds',
+    'Minutes',
+    'Hours',
+    'Days',
+    'Weeks',
+    'Months',
+    'Years'
+];
+const TIME_GROUP = 'Time';
+const TIME_GROUP_CONFIG = {
+    label: 'Time',
+    decimal_places: true
+};
+const TIME_UNIT_CONFIG = {
+    Milliseconds: {
+        group: TIME_GROUP,
+        label: 'Milliseconds'
+    },
+    Seconds: {
+        group: TIME_GROUP,
+        label: 'Seconds'
+    },
+    Minutes: {
+        group: TIME_GROUP,
+        label: 'Minutes'
+    },
+    Hours: {
+        group: TIME_GROUP,
+        label: 'Hours'
+    },
+    Days: {
+        group: TIME_GROUP,
+        label: 'Days'
+    },
+    Weeks: {
+        group: TIME_GROUP,
+        label: 'Weeks'
+    },
+    Months: {
+        group: TIME_GROUP,
+        label: 'Months'
+    },
+    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 || (PersesTimeToIntlTime = {}));
+function formatTime(value, { kind , decimal_places  }) {
+    const isMonthOrYear = kind === 'Months' || kind === 'Years';
+    const formatterOptions = {
+        style: 'unit',
+        unit: PersesTimeToIntlTime[kind],
+        unitDisplay: isMonthOrYear ? 'long' : 'narrow'
+    };
+    if ((0, _utils.hasDecimalPlaces)(decimal_places)) {
+        formatterOptions.minimumFractionDigits = (0, _utils.limitDecimalPlaces)(decimal_places);
+        formatterOptions.maximumFractionDigits = (0, _utils.limitDecimalPlaces)(decimal_places);
+    } else {
+        formatterOptions.maximumSignificantDigits = _constants.MAX_SIGNIFICANT_DIGITS;
+    }
+    return Intl.NumberFormat('en-US', formatterOptions).format(value);
+}

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

@@ -0,0 +1,28 @@
+// Copyright 2023 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// Common types needed across individual unit groups and the overall combined
+// units.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "UNIT_GROUPS", {
+    enumerable: true,
+    get: ()=>UNIT_GROUPS
+});
+const UNIT_GROUPS = [
+    'Time',
+    'Percent',
+    'Decimal',
+    'Bytes'
+];