@grafana/scenes 4.5.5 → 4.5.7--canary.685.8631031033.0

package/dist/index.d.ts

@@ -4,7 +4,7 @@ import React$1, { CSSProperties, ComponentType } from 'react';
 import * as rxjs from 'rxjs';
 import { Observable, Unsubscribable, MonoTypeOperatorFunction, Subscription, ReplaySubject } from 'rxjs';
 import * as _grafana_schema from '@grafana/schema';
-import { VariableType, VariableHide, TimeZone, DataTopic, DataSourceRef, VariableRefresh, DataQuery as DataQuery$1, LoadingState, DashboardCursorSync, MatcherConfig, TableFieldOptions } from '@grafana/schema';
+import { VariableType, VariableHide, TimeZone, DataTopic, DataSourceRef, DataQuery as DataQuery$1, VariableRefresh, LoadingState, DashboardCursorSync, MatcherConfig, TableFieldOptions } from '@grafana/schema';
 import { PanelContext, IconName } from '@grafana/ui';
 import ReactGridLayout from 'react-grid-layout';
 import { RouteComponentProps } from 'react-router-dom';
@@ -451,6 +451,139 @@ interface MacroVariableConstructor {
  */
 declare function registerVariableMacro(name: string, macro: MacroVariableConstructor): () => void;
 
+interface VariableDependencyConfigOptions<TState extends SceneObjectState> {
+    /**
+     * State paths to scan / extract variable dependencies from. Leave empty to scan all paths.
+     */
+    statePaths?: Array<keyof TState | '*'>;
+    /**
+     * Explicit list of variable names to depend on. Leave empty to scan state for dependencies.
+     */
+    variableNames?: string[];
+    /**
+     * Optional way to customize how to handle when a dependent variable changes
+     * If not specified the default behavior is to trigger a re-render
+     */
+    onReferencedVariableValueChanged?: (variable: SceneVariable) => void;
+    /**
+     * Two scenarios trigger this callback to be called.
+     * 1. When any direct dependency changed value
+     * 2. In case hasDependencyInLoadingState was called and returned true we really care about any variable update. So in this scenario this callback is called
+     *    after any variable update completes. This is to cover scenarios where an object is waiting for indirect dependencies to complete.
+     */
+    onVariableUpdateCompleted?: () => void;
+    /**
+     * Optional way to subscribe to all variable value changes, even to variables that are not dependencies.
+     */
+    onAnyVariableChanged?: (variable: SceneVariable) => void;
+}
+declare class VariableDependencyConfig<TState extends SceneObjectState> implements SceneVariableDependencyConfigLike {
+    private _sceneObject;
+    private _options;
+    private _state;
+    private _dependencies;
+    private _statePaths?;
+    private _isWaitingForVariables;
+    scanCount: number;
+    constructor(_sceneObject: SceneObject<TState>, _options: VariableDependencyConfigOptions<TState>);
+    /**
+     * Used to check for dependency on a specific variable
+     */
+    hasDependencyOn(name: string): boolean;
+    /**
+     * This is called whenever any set of variables have new values. It is up to this implementation to check if it's relevant given the current dependencies.
+     */
+    variableUpdateCompleted(variable: SceneVariable, hasChanged: boolean): void;
+    hasDependencyInLoadingState(): boolean;
+    getNames(): Set<string>;
+    /**
+     * Update variableNames
+     */
+    setVariableNames(varNames: string[]): void;
+    setPaths(paths: Array<keyof TState | '*'>): void;
+    private scanStateForDependencies;
+    private extractVariablesFrom;
+}
+
+interface QueryRunnerState extends SceneObjectState {
+    data?: PanelData;
+    queries: DataQueryExtended[];
+    datasource?: DataSourceRef;
+    minInterval?: string;
+    maxDataPoints?: number;
+    liveStreaming?: boolean;
+    maxDataPointsFromWidth?: boolean;
+    cacheTimeout?: DataQueryRequest['cacheTimeout'];
+    queryCachingTTL?: DataQueryRequest['queryCachingTTL'];
+    dataLayerFilter?: DataLayerFilter;
+    _hasFetchedData?: boolean;
+}
+interface DataQueryExtended extends DataQuery$1 {
+    [key: string]: any;
+    timeRangeCompare?: boolean;
+}
+declare class SceneQueryRunner extends SceneObjectBase<QueryRunnerState> implements SceneDataProvider {
+    private _querySub?;
+    private _dataLayersSub?;
+    private _containerWidth?;
+    private _variableValueRecorder;
+    private _results;
+    private _scopedVars;
+    private _layerAnnotations?;
+    private _resultAnnotations?;
+    private _adhocFiltersVar?;
+    private _groupByVar?;
+    getResultsStream(): ReplaySubject<SceneDataProviderResult>;
+    protected _variableDependency: VariableDependencyConfig<QueryRunnerState>;
+    constructor(initialState: QueryRunnerState);
+    private _onActivate;
+    private _handleDataLayers;
+    private _onLayersReceived;
+    /**
+     * This tries to start a new query whenever a variable completes or is changed.
+     *
+     * We care about variable update completions even when the variable has not changed and even when it is not a direct dependency.
+     * Example: Variables A and B (B depends on A). A update depends on time range. So when time change query runner will
+     * find that variable A is loading which is a dependency on of variable B so will set _isWaitingForVariables to true and
+     * not issue any query.
+     *
+     * When A completes it's loading (with no value change, so B never updates) it will cause a call of this function letting
+     * the query runner know that A has completed, and in case _isWaitingForVariables we try to run the query. The query will
+     * only run if all variables are in a non loading state so in other scenarios where a query depends on many variables this will
+     * be called many times until all dependencies are in a non loading state.   *
+     */
+    private onVariableUpdatesCompleted;
+    /**
+     * Check if value changed is a adhoc filter o group by variable that did not exist when we issued the last query
+     */
+    private onAnyVariableChanged;
+    private _isRelevantAutoVariable;
+    private shouldRunQueriesOnActivate;
+    private _isDataTimeRangeStale;
+    private _onDeactivate;
+    setContainerWidth(width: number): void;
+    isDataReadyToDisplay(): boolean;
+    runQueries(): void;
+    private getMaxDataPoints;
+    cancelQuery(): void;
+    private runWithTimeRange;
+    clone(withState?: Partial<QueryRunnerState>): this;
+    private prepareRequests;
+    private onDataReceived;
+    private _combineDataLayers;
+    private _setNoDataState;
+    /**
+     * Will walk up the scene graph and find the closest time range compare object
+     * It performs buttom-up search, including shallow search across object children for supporting controls/header actions
+     */
+    private getTimeCompare;
+    /**
+     * Walk up scene graph and find the closest filterset with matching data source
+     */
+    private findAndSubscribeToAdHocFilters;
+    private _updateExplicitVariableDependencies;
+}
+
 declare function renderPrometheusLabelFilters(filters: AdHocVariableFilter[]): string;
 
 declare class AdHocFiltersVariableUrlSyncHandler implements SceneObjectUrlSyncHandler {
@@ -548,10 +681,6 @@ declare class AdHocFiltersVariable extends SceneObjectBase<AdHocFiltersVariableS
     _getValuesFor(filter: AdHocVariableFilter): Promise<Array<SelectableValue<string>>>;
     _addWip(): void;
     _getOperators(): SelectableValue<string>[];
-    /**
-     * Get all queries in the scene that have the same datasource as this AdHocFilterSet
-     */
-    private _getSceneQueries;
 }
 declare function AdHocFiltersVariableRenderer({ model }: SceneComponentProps<AdHocFiltersVariable>): JSX.Element;
 
@@ -563,60 +692,6 @@ declare class ConstantVariable extends SceneObjectBase<ConstantVariableState> im
     getValue(): VariableValue;
 }
 
-interface VariableDependencyConfigOptions<TState extends SceneObjectState> {
-    /**
-     * State paths to scan / extract variable dependencies from. Leave empty to scan all paths.
-     */
-    statePaths?: Array<keyof TState | '*'>;
-    /**
-     * Explicit list of variable names to depend on. Leave empty to scan state for dependencies.
-     */
-    variableNames?: string[];
-    /**
-     * Optional way to customize how to handle when a dependent variable changes
-     * If not specified the default behavior is to trigger a re-render
-     */
-    onReferencedVariableValueChanged?: (variable: SceneVariable) => void;
-    /**
-     * Two scenarios trigger this callback to be called.
-     * 1. When any direct dependency changed value
-     * 2. In case hasDependencyInLoadingState was called and returned true we really care about any variable update. So in this scenario this callback is called
-     *    after any variable update completes. This is to cover scenarios where an object is waiting for indirect dependencies to complete.
-     */
-    onVariableUpdateCompleted?: () => void;
-    /**
-     * Optional way to subscribe to all variable value changes, even to variables that are not dependencies.
-     */
-    onAnyVariableChanged?: (variable: SceneVariable) => void;
-}
-declare class VariableDependencyConfig<TState extends SceneObjectState> implements SceneVariableDependencyConfigLike {
-    private _sceneObject;
-    private _options;
-    private _state;
-    private _dependencies;
-    private _statePaths?;
-    private _isWaitingForVariables;
-    scanCount: number;
-    constructor(_sceneObject: SceneObject<TState>, _options: VariableDependencyConfigOptions<TState>);
-    /**
-     * Used to check for dependency on a specific variable
-     */
-    hasDependencyOn(name: string): boolean;
-    /**
-     * This is called whenever any set of variables have new values. It is up to this implementation to check if it's relevant given the current dependencies.
-     */
-    variableUpdateCompleted(variable: SceneVariable, hasChanged: boolean): void;
-    hasDependencyInLoadingState(): boolean;
-    getNames(): Set<string>;
-    /**
-     * Update variableNames
-     */
-    setVariableNames(varNames: string[]): void;
-    setPaths(paths: Array<keyof TState | '*'>): void;
-    private scanStateForDependencies;
-    private extractVariablesFrom;
-}
-
 interface MultiValueVariableState extends SceneVariableState {
     value: VariableValue;
     text: VariableValue;
@@ -752,85 +827,6 @@ declare class TextBoxVariable extends SceneObjectBase<TextBoxVariableState> impl
     static Component: ({ model }: SceneComponentProps<TextBoxVariable>) => JSX.Element;
 }
 
-interface QueryRunnerState extends SceneObjectState {
-    data?: PanelData;
-    queries: DataQueryExtended[];
-    datasource?: DataSourceRef;
-    minInterval?: string;
-    maxDataPoints?: number;
-    liveStreaming?: boolean;
-    maxDataPointsFromWidth?: boolean;
-    cacheTimeout?: DataQueryRequest['cacheTimeout'];
-    queryCachingTTL?: DataQueryRequest['queryCachingTTL'];
-    dataLayerFilter?: DataLayerFilter;
-    _hasFetchedData?: boolean;
-}
-interface DataQueryExtended extends DataQuery$1 {
-    [key: string]: any;
-    timeRangeCompare?: boolean;
-}
-declare class SceneQueryRunner extends SceneObjectBase<QueryRunnerState> implements SceneDataProvider {
-    private _querySub?;
-    private _dataLayersSub?;
-    private _containerWidth?;
-    private _variableValueRecorder;
-    private _results;
-    private _scopedVars;
-    private _layerAnnotations?;
-    private _resultAnnotations?;
-    private _adhocFiltersVar?;
-    private _groupByVar?;
-    getResultsStream(): ReplaySubject<SceneDataProviderResult>;
-    protected _variableDependency: VariableDependencyConfig<QueryRunnerState>;
-    constructor(initialState: QueryRunnerState);
-    private _onActivate;
-    private _handleDataLayers;
-    private _onLayersReceived;
-    /**
-     * This tries to start a new query whenever a variable completes or is changed.
-     *
-     * We care about variable update completions even when the variable has not changed and even when it is not a direct dependency.
-     * Example: Variables A and B (B depends on A). A update depends on time range. So when time change query runner will
-     * find that variable A is loading which is a dependency on of variable B so will set _isWaitingForVariables to true and
-     * not issue any query.
-     *
-     * When A completes it's loading (with no value change, so B never updates) it will cause a call of this function letting
-     * the query runner know that A has completed, and in case _isWaitingForVariables we try to run the query. The query will
-     * only run if all variables are in a non loading state so in other scenarios where a query depends on many variables this will
-     * be called many times until all dependencies are in a non loading state.   *
-     */
-    private onVariableUpdatesCompleted;
-    /**
-     * Check if value changed is a adhoc filter o group by variable that did not exist when we issued the last query
-     */
-    private onAnyVariableChanged;
-    private _isRelevantAutoVariable;
-    private shouldRunQueriesOnActivate;
-    private _isDataTimeRangeStale;
-    private _onDeactivate;
-    setContainerWidth(width: number): void;
-    isDataReadyToDisplay(): boolean;
-    runQueries(): void;
-    private getMaxDataPoints;
-    cancelQuery(): void;
-    private runWithTimeRange;
-    clone(withState?: Partial<QueryRunnerState>): this;
-    private prepareRequests;
-    private onDataReceived;
-    private _combineDataLayers;
-    private _setNoDataState;
-    /**
-     * Will walk up the scene graph and find the closest time range compare object
-     * It performs buttom-up search, including shallow search across object children for supporting controls/header actions
-     */
-    private getTimeCompare;
-    /**
-     * Walk up scene graph and find the closest filterset with matching data source
-     */
-    private findAndSubscribeToAdHocFilters;
-    private _updateExplicitVariableDependencies;
-}
-
 interface QueryVariableState extends MultiValueVariableState {
     type: 'query';
     datasource: DataSourceRef | null;
@@ -905,10 +901,6 @@ declare class GroupByVariable extends MultiValueVariable<GroupByVariableState> {
         value: VariableValueSingle[];
         text: string[];
     };
-    /**
-     * Get all queries in the scene that have the same datasource as this AggregationsSet
-     */
-    private _getSceneQueries;
 }
 declare function GroupByVariableRenderer({ model }: SceneComponentProps<MultiValueVariable>): JSX.Element;
 
@@ -1560,6 +1552,10 @@ interface VizPanelState<TOptions = {}, TFieldConfig = {}> extends SceneObjectSta
      * Only shows header on hover, absolutly positioned above the panel.
      */
     hoverHeader?: boolean;
+    /**
+     * Offset hoverHeader position on the y axis
+     */
+    hoverHeaderOffset?: number;
     /**
      * Defines a menu in the top right of the panel. The menu object is only activated when the dropdown menu itself is shown.
      * So the best way to add dynamic menu actions and links is by adding them in a behavior attached to the menu.