@perses-dev/core 0.0.0-snapshot-panel-extra-content-2-2767e21 → 0.0.0-snapshot-scatter-chart-embed-8efdfab

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

@@ -0,0 +1,113 @@
+// 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, {
+    THROUGHPUT_GROUP_CONFIG: function() {
+        return THROUGHPUT_GROUP_CONFIG;
+    },
+    THROUGHPUT_UNIT_CONFIG: function() {
+        return THROUGHPUT_UNIT_CONFIG;
+    },
+    formatThroughput: function() {
+        return formatThroughput;
+    }
+});
+const _constants = require("./constants");
+const _utils = require("./utils");
+const throughputUnits = [
+    'counts/sec',
+    'events/sec',
+    'messages/sec',
+    'ops/sec',
+    'packets/sec',
+    'reads/sec',
+    'records/sec',
+    'requests/sec',
+    'rows/sec',
+    'writes/sec'
+];
+const THROUGHPUT_GROUP_CONFIG = {
+    label: 'Throughput',
+    decimalPlaces: true
+};
+const THROUGHPUT_GROUP = 'Throughput';
+const THROUGHPUT_UNIT_CONFIG = {
+    'counts/sec': {
+        group: THROUGHPUT_GROUP,
+        label: 'Counts/sec'
+    },
+    'events/sec': {
+        group: THROUGHPUT_GROUP,
+        label: 'Events/sec'
+    },
+    'messages/sec': {
+        group: THROUGHPUT_GROUP,
+        label: 'Messages/sec'
+    },
+    'ops/sec': {
+        group: THROUGHPUT_GROUP,
+        label: 'Ops/sec'
+    },
+    'packets/sec': {
+        group: THROUGHPUT_GROUP,
+        label: 'Packets/sec'
+    },
+    'reads/sec': {
+        group: THROUGHPUT_GROUP,
+        label: 'Reads/sec'
+    },
+    'requests/sec': {
+        group: THROUGHPUT_GROUP,
+        label: 'Requests/sec'
+    },
+    'records/sec': {
+        group: THROUGHPUT_GROUP,
+        label: 'Records/sec'
+    },
+    'rows/sec': {
+        group: THROUGHPUT_GROUP,
+        label: 'Rows/sec'
+    },
+    'writes/sec': {
+        group: THROUGHPUT_GROUP,
+        label: 'Writes/sec'
+    }
+};
+function formatThroughput(value, { unit , shortValues , decimalPlaces  }) {
+    const formatterOptions = {
+        style: 'decimal',
+        useGrouping: true
+    };
+    if ((0, _utils.shouldShortenValues)(shortValues)) {
+        formatterOptions.notation = 'compact';
+    }
+    if ((0, _utils.hasDecimalPlaces)(decimalPlaces)) {
+        formatterOptions.minimumFractionDigits = (0, _utils.limitDecimalPlaces)(decimalPlaces);
+        formatterOptions.maximumFractionDigits = (0, _utils.limitDecimalPlaces)(decimalPlaces);
+    } else {
+        if ((0, _utils.shouldShortenValues)(shortValues)) {
+            formatterOptions.maximumSignificantDigits = _constants.MAX_SIGNIFICANT_DIGITS;
+        }
+    }
+    const formatter = Intl.NumberFormat('en-US', formatterOptions);
+    return formatter.format(value) + ' ' + unit;
+}

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,11 +18,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "UNIT_GROUPS", {
     enumerable: true,
-    get: ()=>UNIT_GROUPS
+    get: function() {
+        return UNIT_GROUPS;
+    }
 });
 const UNIT_GROUPS = [
     'Time',
     'Percent',
     'Decimal',
-    'Bytes'
+    'Bytes',
+    'Throughput'
 ];

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

@@ -21,81 +21,117 @@ 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;
+    },
+    isThroughputUnit: function() {
+        return isThroughputUnit;
+    }
 });
 const _bytes = require("./bytes");
 const _decimal = require("./decimal");
 const _percent = require("./percent");
 const _time = require("./time");
+const _throughput = require("./throughput");
 const UNIT_GROUP_CONFIG = {
     Time: _time.TIME_GROUP_CONFIG,
     Percent: _percent.PERCENT_GROUP_CONFIG,
     Decimal: _decimal.DECIMAL_GROUP_CONFIG,
-    Bytes: _bytes.BYTES_GROUP_CONFIG
+    Bytes: _bytes.BYTES_GROUP_CONFIG,
+    Throughput: _throughput.THROUGHPUT_GROUP_CONFIG
 };
 const UNIT_CONFIG = {
     ..._time.TIME_UNIT_CONFIG,
     ..._percent.PERCENT_UNIT_CONFIG,
     ..._decimal.DECIMAL_UNIT_CONFIG,
-    ..._bytes.BYTES_UNIT_CONFIG
+    ..._bytes.BYTES_UNIT_CONFIG,
+    ..._throughput.THROUGHPUT_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 (isDecimalUnit(formatOptions)) {
+        return (0, _decimal.formatDecimal)(value, formatOptions);
     }
-    if (isTimeUnit(unitOptions)) {
-        return (0, _time.formatTime)(value, unitOptions);
+    if (isPercentUnit(formatOptions)) {
+        return (0, _percent.formatPercent)(value, formatOptions);
     }
-    if (isPercentUnit(unitOptions)) {
-        return (0, _percent.formatPercent)(value, unitOptions);
+    if (isTimeUnit(formatOptions)) {
+        return (0, _time.formatTime)(value, formatOptions);
     }
-    if (isBytesUnit(unitOptions)) {
-        return (0, _bytes.formatBytes)(value, unitOptions);
+    if (isThroughputUnit(formatOptions)) {
+        return (0, _throughput.formatThroughput)(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(formatOptions) {
+    return getUnitGroup(formatOptions) === 'Percent';
 }
-function isPercentUnit(unitOptions) {
-    return getUnitGroup(unitOptions) === 'Percent';
+function isDecimalUnit(formatOptions) {
+    return getUnitGroup(formatOptions) === 'Decimal';
 }
-function isDecimalUnit(unitOptions) {
-    return getUnitGroup(unitOptions) === 'Decimal';
+function isBytesUnit(formatOptions) {
+    return getUnitGroup(formatOptions) === 'Bytes';
 }
-function isBytesUnit(unitOptions) {
-    return getUnitGroup(unitOptions) === 'Bytes';
+function isUnitWithDecimalPlaces(formatOptions) {
+    const groupConfig = getUnitGroupConfig(formatOptions);
+    return !!groupConfig.decimalPlaces;
 }
-function isUnitWithDecimalPlaces(unitOptions) {
-    const groupConfig = getUnitGroupConfig(unitOptions);
-    return !!groupConfig.decimal_places;
+function isUnitWithShortValues(formatOptions) {
+    const groupConfig = getUnitGroupConfig(formatOptions);
+    return !!groupConfig.shortValues;
 }
-function isUnitWithAbbreviate(unitOptions) {
-    const groupConfig = getUnitGroupConfig(unitOptions);
-    return !!groupConfig.abbreviate;
+function isThroughputUnit(formatOptions) {
+    return getUnitGroup(formatOptions) == 'Throughput';
 }

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,20 +23,41 @@ 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;
+    }
 });
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 async function fetch(...args) {
     const response = await global.fetch(...args);
     if (response.ok === false) {
         const json = await response.json();
         if (json.error) {
-            throw new UserFriendlyError(json.error);
+            throw new UserFriendlyError(json.error, response.status);
         }
         if (json.message) {
-            throw new UserFriendlyError(json.message);
+            throw new UserFriendlyError(json.message, response.status);
         }
         throw new FetchError(response);
     }
@@ -50,12 +71,16 @@ async function fetchJson(...args) {
 class FetchError extends Error {
     constructor(response){
         super(`${response.status} ${response.statusText}`);
+        _define_property(this, "status", void 0);
+        this.status = response.status;
         Object.setPrototypeOf(this, FetchError.prototype);
     }
 }
 class UserFriendlyError extends Error {
-    constructor(message){
+    constructor(message, status){
         super(message);
+        _define_property(this, "status", void 0);
+        this.status = status;
         Object.setPrototypeOf(this, UserFriendlyError.prototype);
     }
 }

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)