@splunk/visualizations 28.1.0 → 28.2.0

package/dist/types/common/gaugeUtils.d.ts

@@ -0,0 +1,387 @@
+export declare const GAUGE_THICKNESS = 50;
+export declare const FILL_THICKNESS = 38;
+/**
+ * get width for the whole gauge viz for horizontal or vertical view
+ * @method getGaugeWidth
+ * @param {Object} input
+ * @param {Number} containerWidth
+ * @param {String} orientation
+ * @return {Number} width
+ */
+export declare const getGaugeWidth: ({ containerWidth, orientation }: {
+    containerWidth: any;
+    orientation: any;
+}) => number;
+/**
+ * get height for the whole gauge viz for horizontal or vertical view
+ * @method getGaugeHeight
+ * @param {Object} input
+ * @param {Number} containerHeight
+ * @param {String} orientation
+ * @return {Number} height
+ */
+export declare const getGaugeHeight: ({ containerHeight, orientation }: {
+    containerHeight: any;
+    orientation: any;
+}) => number;
+/**
+ * get how long the gauge shoud be.
+ * In horizontal view, gauge length equals to gauge width. In vertical view, it equals to gauge height.
+ * @method getGaugeLength
+ * @param {Object} input
+ * @param {Number} input.containerWidth
+ * @param {Number} input.containerHeight
+ * @param {String} input.orientation
+ * @return {Number} gaugeLength
+ */
+export declare const getGaugeLength: ({ containerWidth, containerHeight, orientation }: {
+    containerWidth: any;
+    containerHeight: any;
+    orientation: any;
+}) => number;
+/**
+ * get start x and y for rendering gauge
+ * @method getGaugeStartPosition
+ * @param {Object} input
+ * @param {Number} containerWidth
+ * @param {Number} containerHeight
+ * @param {Number} gaugeLength
+ * @param {String} orientation
+ * @return {Object} position
+ * @return {Number} position.gaugeStartX
+ * @return {Number} position.gaugeStartY
+ */
+export declare const getGaugeStartPosition: ({ containerWidth, containerHeight, gaugeLength, orientation }: {
+    containerWidth: any;
+    containerHeight: any;
+    gaugeLength: any;
+    orientation: any;
+}) => {
+    gaugeStartX: number;
+    gaugeStartY: number;
+};
+/**
+ * get dimensions for the whole gauge viz,
+ * which can be useful to calculate background bar and major ticks positions.
+ * @method getGaugeDimensions
+ * @param {Object} input
+ * @param {Number} input.containerWidth
+ * @param {Number} input.containerHeight
+ * @param {String} input.orientation  'horizontal' or 'vertical'
+ * @return {Object} gaugeDimensions
+ * @return {Number} gaugeDimensions.gaugeLength  how long the gauge shoud be in horizontal or vertical orientation.
+ * @return {Number} gaugeDimensions.gaugeStartX  start x to render gauge
+ * @return {Number} gaugeDimensions.gaugeStartY  start y to render gauge
+ * @return {Number} gaugeDimensions.gaugeWidth   natural width of gauge
+ * @return {Number} gaugeDimensions.gaugeHeight  natural height of gauge
+ */
+export declare const getGaugeDimensions: ({ containerWidth, containerHeight, orientation }: {
+    containerWidth: any;
+    containerHeight: any;
+    orientation: any;
+}) => {
+    gaugeLength: number;
+    gaugeStartX: number;
+    gaugeStartY: number;
+    gaugeWidth: number;
+    gaugeHeight: number;
+};
+/**
+ * if gaugeColor is not specified, auto assign a gauge color to the fill bar
+ * based on how much percentage the value is taken between min and max
+ * @method assignGaugeColor
+ * @params
+ * */
+export declare const assignGaugeColor: ({ value, min, max }: {
+    value: any;
+    min: any;
+    max: any;
+}) => any;
+/**
+ * get inner bar length in gauge
+ * @method getGaugeBarLength
+ * @param {Object} input
+ * @param {Number} input.gaugeLength
+ * @param {Number} input.value
+ * @param {Number} input.min
+ * @param {Number} input.max
+ * @return {Number} gaugeBarLength
+ */
+export declare const getGaugeBarLength: ({ gaugeLength, value, min, max }: {
+    gaugeLength: any;
+    value: any;
+    min: any;
+    max: any;
+}) => any;
+/**
+ * get x and y position for rendering inner bar in gauge
+ * @method getGaugeBarStartPositions
+ * @param {Object} input
+ * @param {Number} input.gaugeStartX
+ * @param {Number} input.gaugeStartY
+ * @param {Number} input.gaugeWidth
+ * @param {Number} input.gaugeHeight
+ * @param {Number} input.gaugeBarLength
+ * @param {String} input.orientation
+ * @return {Object} position
+ * @return {Number} position.gaugeBarX
+ * @return {Number} position.gaugeBarY
+ */
+export declare const getGaugeBarStartPositions: ({ gaugeStartX, gaugeStartY, gaugeWidth, gaugeHeight, gaugeBarLength, orientation, }: {
+    gaugeStartX: any;
+    gaugeStartY: any;
+    gaugeWidth: any;
+    gaugeHeight: any;
+    gaugeBarLength: any;
+    orientation: any;
+}) => {
+    gaugeBarX: any;
+    gaugeBarY: any;
+};
+/**
+ * get width of inner bar in gauge
+ * @method getGaugeBarWidth
+ * @param {Object} input
+ * @param {Number} input.gaugeBarLength
+ * @param {String} orientation
+ * @return {Number} gaugeBarWidth
+ */
+export declare const getGaugeBarWidth: ({ gaugeBarLength, orientation }: {
+    gaugeBarLength: any;
+    orientation: any;
+}) => any;
+/**
+ * get height of inner bar in gauge
+ * @method getGaugeBarWidth
+ * @param {Object} input
+ * @param {Number} input.gaugeBarLength
+ * @param {String} orientation
+ * @return {Number} gaugeBarHeight
+ */
+export declare const getGaugeBarHeight: ({ gaugeBarLength, orientation }: {
+    gaugeBarLength: any;
+    orientation: any;
+}) => any;
+/**
+ * get dimensions for the fill bar in the gauge
+ * @method getFillBarDimensions
+ * @param {Object} input
+ * @param {Number} input.gaugeLength
+ * @param {Number} input.gaugeStartX
+ * @param {Number} input.gaugeStartY
+ * @param {Number} input.gaugeWidth,
+ * @param {Number} input.gaugeHeight,
+ * @param {Number} input.value,
+ * @param {Number} input.min,
+ * @param {Number} input.max,
+ * @param {String} input.orientation
+ * @return {Object} fillBarDimensions
+ * @return {Number} fillBarDimensions.fillBarLength
+ * @return {Number} fillBarDimensions.fillBarX
+ * @return {Number} fillBarDimensions.fillBarY
+ * @return {Number} fillBarDimensions.fillBarWidth
+ * @return {Number} fillBarDimensions.fillBarHeight
+ */
+export declare const getFillBarDimensions: ({ gaugeLength, gaugeStartX, gaugeStartY, gaugeWidth, gaugeHeight, value, min, max, orientation, }: {
+    gaugeLength: any;
+    gaugeStartX: any;
+    gaugeStartY: any;
+    gaugeWidth: any;
+    gaugeHeight: any;
+    value: any;
+    min: any;
+    max: any;
+    orientation: any;
+}) => {
+    fillBarLength: any;
+    fillBarX: any;
+    fillBarY: any;
+    fillBarWidth: any;
+    fillBarHeight: any;
+};
+/**
+ * get position x and y for value marker in filler gauge
+ * @method getFillerGaugeValueMarkerPositions
+ * @param {Object} input
+ * @param {Number} input.fillBarX
+ * @param {Number} input.fillBarY
+ * @param {Number} input.fillBarLength
+ * @param {String} input.orientation
+ * @return {Object} position
+ * @return {Number} position.valueMarkerX
+ * @return {Number} position.valueMarkerY
+ */
+export declare const getFillerGaugeValueMarkerPositions: ({ fillBarX, fillBarY, fillBarLength, orientation }: {
+    fillBarX: any;
+    fillBarY: any;
+    fillBarLength: any;
+    orientation: any;
+}) => {
+    valueMarkerX: any;
+    valueMarkerY: any;
+};
+/**
+ * get dimensions for the marker bar in the gauge
+ * @method getMarkerBarDimensions
+ * @param {Object} input
+ * @param {Number} input.gaugeLength
+ * @param {Number} input.gaugeStartX
+ * @param {Number} input.gaugeStartY
+ * @param {Number} input.gaugeWidth,
+ * @param {Number} input.gaugeHeight,
+ * @param {String} input.orientation
+ * @return {Object} markerBarDimensions
+ * @return {Number} markerBarDimensions.markerBarLength
+ * @return {Number} markerBarDimensions.markerBarX
+ * @return {Number} markerBarDimensions.markerBarY
+ * @return {Number} markerBarDimensions.markerBarWidth
+ * @return {Number} markerBarDimensions.markerBarHeight
+ */
+export declare const getMarkerBarDimensions: ({ gaugeLength, gaugeStartX, gaugeStartY, gaugeWidth, gaugeHeight, orientation, }: {
+    gaugeLength: any;
+    gaugeStartX: any;
+    gaugeStartY: any;
+    gaugeWidth: any;
+    gaugeHeight: any;
+    orientation: any;
+}) => {
+    markerBarLength: any;
+    markerBarX: any;
+    markerBarY: any;
+    markerBarWidth: any;
+    markerBarHeight: any;
+};
+/**
+ * get position x and y for value marker in marker gauge
+ * @method getMarkerGaugeValueMarkerPositions
+ * @param {Object} input
+ * @param {Number} input.markerBarX
+ * @param {Number} input.markerBarY
+ * @param {Number} input.markerBarHeight
+ * @param {Number} input.markerBarLength
+ * @param {Number} input.value
+ * @param {Number} input.min
+ * @param {Number} input.max
+ * @param {String} input.orientation
+ * @return {Object} position
+ * @return {Number} position.valueMarkerX
+ * @return {Number} position.valueMarkerY
+ */
+export declare const getMarkerGaugeValueMarkerPositions: ({ markerBarX, markerBarY, markerBarHeight, markerBarLength: gaugeLength, orientation, value, min, max, }: {
+    markerBarX: any;
+    markerBarY: any;
+    markerBarHeight: any;
+    markerBarLength: any;
+    orientation: any;
+    value: any;
+    min: any;
+    max: any;
+}) => {
+    valueMarkerX: any;
+    valueMarkerY: any;
+};
+/**
+ * sort the ranges in ascending order
+ * @method getSortedRanges
+ * @param {Array} ranges
+ * @return {Array} sortedRanges
+ */
+export declare const getSortedRanges: (ranges: any) => any;
+/**
+ * validate whether ranges prop is valid - continuous ranges, range.to < range.from, range.from != range.to
+ * @method validateRanges
+ * @param {Array} ranges
+ * @return {String} error
+ */
+export declare const validateRanges: (ranges: any) => any;
+/**
+ * calculate min and max value of gauge
+ * @method getGaugeRange
+ * @param {Array} ranges
+ * @return {Object} gaugeRange
+ * @return {Number} gaugeRange.min
+ * @return {Number} gaugeRange.max
+ */
+export declare const getGaugeRange: (ranges: any) => {
+    min: number;
+    max: number;
+};
+/**
+ * calculate stop offsets for linear gradient
+ * @method getGradientStopOffsets
+ * @param {Array} ranges
+ * @param {String} orientation
+ * @return {Array} cumulativeOffsets
+ */
+export declare const getGradientStopOffsets: ({ ranges, orientation }: {
+    ranges: any;
+    orientation: any;
+}) => any[];
+/**
+ * calculate stop colors for linear gradient
+ * @method getGradientStopColors
+ * @param {Array} ranges
+ * @param {String} orientation
+ * @return {Array} stopColors
+ */
+export declare const getGradientStopColors: ({ ranges, orientation }: {
+    ranges: any;
+    orientation: any;
+}) => any;
+/**
+ * calculate linear gradient stops from ranges
+ * @method getGradientStops
+ * @param {Object} input
+ * @param {Array} ranges
+ * @param {String} orientation
+ * @return {Array} stops
+ */
+export declare const getGradientStops: ({ ranges, orientation }: {
+    ranges: any;
+    orientation: any;
+}) => any[];
+/**
+ * calculate linear gradient dimensions
+ * @method getGradientDimensions
+ * @param {String} orientation
+ * @return {Object} dimensions
+ * @return {String} dimensions.x1
+ * @return {String} dimensions.y1
+ * @return {String} dimensions.x2
+ * @return {String} dimensions.y2
+ */
+export declare const getGradientDimensions: (orientation: any) => {
+    x1: string;
+    y1: string;
+    x2: string;
+    y2: string;
+};
+interface GaugeOptions {
+    [key: string]: any;
+}
+/**
+ * Helper method to update the option names which can be mapped to pure component options
+ * @method mapToOldKey
+ * @param {Object} options
+ * @returns {Object}
+ */
+export declare const mapToOldKey: (options: GaugeOptions) => GaugeOptions;
+type LabelOrValue = 'label' | 'value';
+/**
+ * Helper method to map labelDisplay and valueDisplay options to pure component option names
+ * @method mapToOldKey
+ * @param {string} labelOrValue
+ * @param {Object} options
+ * @returns {Object}
+ */
+export declare const mapValueLabelDisplay: (labelOrValue: LabelOrValue, options: GaugeOptions) => GaugeOptions;
+/**
+ * Chained helper for mapping the option properties (and values) we expose in config.ts into property values that pure component accepts
+ * This is for options that has new key name and can not directly be mapped with pure component props
+ * @method convertToGaugeProperties
+ * @param {Object} originalOptions
+ * @returns {Object}
+ */
+export declare const convertToGaugeProperties: (originalOptions: GaugeOptions) => GaugeOptions;
+export {};
+//# sourceMappingURL=gaugeUtils.d.ts.map

package/dist/types/common/gaugeUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaugeUtils.d.ts","sourceRoot":"","sources":["../../../src/common/gaugeUtils.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,cAAc,KAAK,CAAC;AAIjC;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,GAAI;;;CAA+B,WACU,CAAC;AAExE;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAAI;;;CAAgC,WACS,CAAC;AAEzE;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI;;;;CAAgD,WAGvB,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,GAAI;;;;;CAA6D;;;CAWlG,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB,GAAI;;;;CAAgD;;;;;;CAsBlF,CAAC;AAEF;;;;;KAKK;AACL,eAAO,MAAM,gBAAgB,GAAI;;;;CAAmB,QAWnD,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAAI;;;;;CAAgC,QAcjE,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,yBAAyB,GAAI;;;;;;;CAOzC;;;CAeA,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAAI;;;CAA+B,QACA,CAAC;AAEjE;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,GAAI;;;CAA+B,QACD,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB,GAAI;;;;;;;;;;CAUpC;;;;;;CAoBA,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kCAAkC,GAAI;;;;;CAAkD;;;CAepG,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,sBAAsB,GAAI;;;;;;;CAOtC;;;;;;CAoBA,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kCAAkC,GAAI;;;;;;;;;CASlD;;;CAeA,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAG,WAAM,QAA0C,CAAC;AAEhF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAG,WAAM,QAyBnC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,GAAG,WAAM;;;CAIlC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,GAAI;;;CAAuB,UAY7D,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAAI;;;CAAuB,QAI5D,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAAI;;;CAAuB,UAYvD,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GAAG,gBAAW;;;;;CAM/C,CAAC;AAEF,UAAU,YAAY;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACtB;AAQD;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,YAAY,KAAG,YAC2C,CAAC;AAEhG,KAAK,YAAY,GAAG,OAAO,GAAG,OAAO,CAAC;AAEtC;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAAI,cAAc,YAAY,EAAE,SAAS,YAAY,KAAG,YAmBxF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GAAI,iBAAiB,YAAY,KAAG,YAIzD,CAAC"}

package/dist/types/common/hocs/FixedSizeContainer.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+interface HeightAndWidthProps {
+    width?: string | number;
+    height?: string | number;
+    backgroundColor?: string;
+}
+declare const withFixedSizeContainer: <P extends HeightAndWidthProps>(Viz: React.ComponentType<P>) => React.ComponentType<P>;
+export default withFixedSizeContainer;
+//# sourceMappingURL=FixedSizeContainer.d.ts.map

package/dist/types/common/hocs/FixedSizeContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FixedSizeContainer.d.ts","sourceRoot":"","sources":["../../../../src/common/hocs/FixedSizeContainer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAkE/B,UAAU,mBAAmB;IACzB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,QAAA,MAAM,sBAAsB,GAAI,CAAC,SAAS,mBAAmB,EACzD,KAAK,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,KAC5B,KAAK,CAAC,aAAa,CAAC,CAAC,CAmCvB,CAAC;AAEF,eAAe,sBAAsB,CAAC"}