@grafana/scenes 6.47.1--canary.1303.19437678211.0 → 6.47.1--canary.1303.19493819306.0

package/dist/index.d.ts

@@ -988,11 +988,90 @@ interface MacroVariableConstructor {
  */
 declare function registerVariableMacro(name: string, macro: MacroVariableConstructor, replace?: boolean): () => void;
 
-declare function renderPrometheusLabelFilters(filters: AdHocVariableFilter[]): string;
-declare function escapeLabelValueInExactSelector(labelValue: string): string;
-declare function escapeLabelValueInRegexSelector(labelValue: string): string;
-declare function escapeUrlPipeDelimiters(value: string | undefined): string;
-declare function escapeURLDelimiters(value: string | undefined): string;
+interface QueryRunnerState extends SceneObjectState {
+    data?: PanelData;
+    queries: SceneDataQuery[];
+    datasource?: DataSourceRef;
+    minInterval?: string;
+    maxDataPoints?: number;
+    liveStreaming?: boolean;
+    maxDataPointsFromWidth?: boolean;
+    cacheTimeout?: DataQueryRequest['cacheTimeout'];
+    queryCachingTTL?: DataQueryRequest['queryCachingTTL'];
+    /**
+     * When set to auto (the default) query runner will issue queries on activate (when variable dependencies are ready) or when time range change.
+     * Set to manual to have full manual control over when queries are issued. Try not to set this. This is mainly useful for unit tests, or special edge case workflows.
+     */
+    runQueriesMode?: 'auto' | 'manual';
+    dataLayerFilter?: DataLayerFilter;
+    _hasFetchedData?: boolean;
+}
+declare class SceneQueryRunner extends SceneObjectBase<QueryRunnerState> implements SceneDataProvider {
+    private _querySub?;
+    private _dataLayersSub?;
+    private _dataLayersMerger;
+    private _timeSub?;
+    private _timeSubRange?;
+    private _containerWidth?;
+    private _variableValueRecorder;
+    private _results;
+    private _scopedVars;
+    private _layerAnnotations?;
+    private _resultAnnotations?;
+    private _isInView;
+    private _bypassIsInView;
+    private _queryNotExecutedWhenOutOfView;
+    getResultsStream(): ReplaySubject<SceneDataProviderResult>;
+    protected _variableDependency: VariableDependencyConfig<QueryRunnerState>;
+    private _drilldownDependenciesManager;
+    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;
+    private subscribeToTimeRangeChanges;
+    runQueries(): void;
+    private getMaxDataPoints;
+    cancelQuery(): void;
+    private runWithTimeRange;
+    clone(withState?: Partial<QueryRunnerState>): this;
+    private prepareRequests;
+    private onDataReceived;
+    private _combineDataLayers;
+    private _setNoDataState;
+    /**
+     * Walk up the scene graph and find any ExtraQueryProviders.
+     *
+     * This will return an array of the closest provider of each type.
+     */
+    private getClosestExtraQueryProviders;
+    private isQueryModeAuto;
+    isInViewChanged(isInView: boolean): void;
+    bypassIsInViewChanged(bypassIsInView: boolean): void;
+}
 
 declare class AdHocFiltersVariableUrlSyncHandler implements SceneObjectUrlSyncHandler {
     private _variable;
@@ -1165,20 +1244,6 @@ declare class AdHocFiltersVariable extends SceneObjectBase<AdHocFiltersVariableS
 }
 declare function AdHocFiltersVariableRenderer({ model }: SceneComponentProps<AdHocFiltersVariable>): React__default.JSX.Element;
 
-interface ConstantVariableState extends SceneVariableState {
-    value: VariableValue;
-}
-declare class ConstantVariable extends SceneObjectBase<ConstantVariableState> implements SceneVariable<ConstantVariableState> {
-    protected _variableDependency: VariableDependencyConfig<ConstantVariableState>;
-    private _prevValue;
-    constructor(initialState: Partial<ConstantVariableState>);
-    /**
-     * This function is called on when SceneVariableSet is activated or when a dependency changes.
-     */
-    validateAndUpdate(): Observable<ValidateAndUpdateResult>;
-    getValue(): VariableValue;
-}
-
 interface MultiValueVariableState extends SceneVariableState {
     value: VariableValue;
     text: VariableValue;
@@ -1253,6 +1318,108 @@ declare abstract class MultiValueVariable<TState extends MultiValueVariableState
     onSearchChange?(searchFilter: string): void;
 }
 
+interface GroupByVariableState extends MultiValueVariableState {
+    /** Defaults to "Group" */
+    name: string;
+    /** The visible keys to group on */
+    defaultOptions?: MetricFindValue[];
+    /** Base filters to always apply when looking up keys */
+    baseFilters?: AdHocVariableFilter[];
+    /** Datasource to use for getTagKeys and also controls which scene queries the group by should apply to */
+    datasource: DataSourceRef | null;
+    /** Default value set for this groupBy. When this field is set, changing value will allow the user to restore back to this default value */
+    defaultValue?: {
+        text: VariableValue;
+        value: VariableValue;
+    };
+    /** Needed for url sync when passing flag to another dashboard */
+    restorable?: boolean;
+    /** Controls if the group by can be changed */
+    readOnly?: boolean;
+    /**
+     * @experimental
+     * Controls the layout and design of the label.
+     * Vertical layout does not yet support operator selector.
+     */
+    layout?: ControlsLayout;
+    /**
+     * Defaults to same-datasource which means group by will automatically be applied to all queries with the same data source as this GroupBySet.
+     * In manual mode no queries are re-run on changes, and you have to manually apply the filter to whatever queries you want.
+     */
+    applyMode?: 'auto' | 'manual';
+    /**
+     * Filter out the keys that do not match the regex.
+     */
+    tagKeyRegexFilter?: RegExp;
+    /**
+     * Extension hook for customizing the key lookup.
+     * Return replace: true if you want to override the default lookup
+     * Return replace: false if you want to combine the results with the default lookup
+     */
+    getTagKeysProvider?: getTagKeysProvider;
+    /**
+     * Holds the applicability for each of the selected keys
+     */
+    keysApplicability?: DrilldownsApplicability[];
+    /**
+     * state for checking whether drilldown applicability is enabled
+     */
+    applicabilityEnabled?: boolean;
+}
+type getTagKeysProvider = (set: GroupByVariable, currentKey: string | null) => Promise<{
+    replace?: boolean;
+    values: MetricFindValue[] | GetTagResponse;
+}>;
+declare class GroupByVariable extends MultiValueVariable<GroupByVariableState> {
+    static Component: typeof GroupByVariableRenderer;
+    isLazy: boolean;
+    protected _urlSync: SceneObjectUrlSyncHandler;
+    validateAndUpdate(): Observable<ValidateAndUpdateResult>;
+    private _updateValueGivenNewOptions;
+    getValueOptions(args: VariableGetOptionsArgs): Observable<VariableValueOption[]>;
+    constructor(initialState: Partial<GroupByVariableState>);
+    private _activationHandler;
+    getApplicableKeys(): VariableValue;
+    getGroupByApplicabilityForQueries(value: VariableValue, queries: SceneDataQuery[]): Promise<DrilldownsApplicability[] | undefined>;
+    _verifyApplicability(): Promise<void>;
+    checkIfRestorable(values: VariableValue): boolean;
+    restoreDefaultValues(): void;
+    /**
+     * Get possible keys given current filters. Do not call from plugins directly
+     */
+    _getKeys: (ds: DataSourceApi) => Promise<GetTagResponse | MetricFindValue[]>;
+    /**
+     * Allows clearing the value of the variable to an empty value. Overrides default behavior of a MultiValueVariable
+     */
+    getDefaultMultiState(options: VariableValueOption[]): {
+        value: VariableValueSingle[];
+        text: string[];
+    };
+}
+declare function GroupByVariableRenderer({ model }: SceneComponentProps<GroupByVariable>): React__default.JSX.Element;
+
+declare function renderPrometheusLabelFilters(filters: AdHocVariableFilter[]): string;
+declare function escapeLabelValueInExactSelector(labelValue: string): string;
+declare function escapeLabelValueInRegexSelector(labelValue: string): string;
+declare function escapeUrlPipeDelimiters(value: string | undefined): string;
+declare function escapeURLDelimiters(value: string | undefined): string;
+declare function verifyDrilldownApplicability(sourceObject: SceneObject, queriesDataSource: DataSourceRef | undefined, drilldownDatasource: DataSourceRef | null, isApplicabilityEnabled?: boolean): boolean;
+declare function getDrilldownApplicability(queryRunner: SceneQueryRunner, filtersVar?: AdHocFiltersVariable, groupByVar?: GroupByVariable): Promise<DrilldownsApplicability[] | undefined>;
+
+interface ConstantVariableState extends SceneVariableState {
+    value: VariableValue;
+}
+declare class ConstantVariable extends SceneObjectBase<ConstantVariableState> implements SceneVariable<ConstantVariableState> {
+    protected _variableDependency: VariableDependencyConfig<ConstantVariableState>;
+    private _prevValue;
+    constructor(initialState: Partial<ConstantVariableState>);
+    /**
+     * This function is called on when SceneVariableSet is activated or when a dependency changes.
+     */
+    validateAndUpdate(): Observable<ValidateAndUpdateResult>;
+    getValue(): VariableValue;
+}
+
 interface CustomVariableState extends MultiValueVariableState {
     query: string;
 }
@@ -1346,86 +1513,6 @@ declare class QueryVariable extends MultiValueVariable<QueryVariableState> {
     static Component: ({ model }: SceneComponentProps<MultiValueVariable>) => React__default.JSX.Element;
 }
 
-interface GroupByVariableState extends MultiValueVariableState {
-    /** Defaults to "Group" */
-    name: string;
-    /** The visible keys to group on */
-    defaultOptions?: MetricFindValue[];
-    /** Base filters to always apply when looking up keys */
-    baseFilters?: AdHocVariableFilter[];
-    /** Datasource to use for getTagKeys and also controls which scene queries the group by should apply to */
-    datasource: DataSourceRef | null;
-    /** Default value set for this groupBy. When this field is set, changing value will allow the user to restore back to this default value */
-    defaultValue?: {
-        text: VariableValue;
-        value: VariableValue;
-    };
-    /** Needed for url sync when passing flag to another dashboard */
-    restorable?: boolean;
-    /** Controls if the group by can be changed */
-    readOnly?: boolean;
-    /**
-     * @experimental
-     * Controls the layout and design of the label.
-     * Vertical layout does not yet support operator selector.
-     */
-    layout?: ControlsLayout;
-    /**
-     * Defaults to same-datasource which means group by will automatically be applied to all queries with the same data source as this GroupBySet.
-     * In manual mode no queries are re-run on changes, and you have to manually apply the filter to whatever queries you want.
-     */
-    applyMode?: 'auto' | 'manual';
-    /**
-     * Filter out the keys that do not match the regex.
-     */
-    tagKeyRegexFilter?: RegExp;
-    /**
-     * Extension hook for customizing the key lookup.
-     * Return replace: true if you want to override the default lookup
-     * Return replace: false if you want to combine the results with the default lookup
-     */
-    getTagKeysProvider?: getTagKeysProvider;
-    /**
-     * Holds the applicability for each of the selected keys
-     */
-    keysApplicability?: DrilldownsApplicability[];
-    /**
-     * state for checking whether drilldown applicability is enabled
-     */
-    applicabilityEnabled?: boolean;
-}
-type getTagKeysProvider = (set: GroupByVariable, currentKey: string | null) => Promise<{
-    replace?: boolean;
-    values: MetricFindValue[] | GetTagResponse;
-}>;
-declare class GroupByVariable extends MultiValueVariable<GroupByVariableState> {
-    static Component: typeof GroupByVariableRenderer;
-    isLazy: boolean;
-    protected _urlSync: SceneObjectUrlSyncHandler;
-    validateAndUpdate(): Observable<ValidateAndUpdateResult>;
-    private _updateValueGivenNewOptions;
-    getValueOptions(args: VariableGetOptionsArgs): Observable<VariableValueOption[]>;
-    constructor(initialState: Partial<GroupByVariableState>);
-    private _activationHandler;
-    getApplicableKeys(): VariableValue;
-    getGroupByApplicabilityForQueries(value: VariableValue, queries: SceneDataQuery[]): Promise<DrilldownsApplicability[] | undefined>;
-    _verifyApplicability(): Promise<void>;
-    checkIfRestorable(values: VariableValue): boolean;
-    restoreDefaultValues(): void;
-    /**
-     * Get possible keys given current filters. Do not call from plugins directly
-     */
-    _getKeys: (ds: DataSourceApi) => Promise<GetTagResponse | MetricFindValue[]>;
-    /**
-     * Allows clearing the value of the variable to an empty value. Overrides default behavior of a MultiValueVariable
-     */
-    getDefaultMultiState(options: VariableValueOption[]): {
-        value: VariableValueSingle[];
-        text: string[];
-    };
-}
-declare function GroupByVariableRenderer({ model }: SceneComponentProps<GroupByVariable>): React__default.JSX.Element;
-
 interface SwitchVariableState extends SceneVariableState {
     value: string;
     enabledValue: string;
@@ -2088,91 +2175,6 @@ declare class SceneTimeZoneOverride extends SceneTimeRangeTransformerBase<SceneT
     onTimeZoneChange(timeZone: string): void;
 }
 
-interface QueryRunnerState extends SceneObjectState {
-    data?: PanelData;
-    queries: SceneDataQuery[];
-    datasource?: DataSourceRef;
-    minInterval?: string;
-    maxDataPoints?: number;
-    liveStreaming?: boolean;
-    maxDataPointsFromWidth?: boolean;
-    cacheTimeout?: DataQueryRequest['cacheTimeout'];
-    queryCachingTTL?: DataQueryRequest['queryCachingTTL'];
-    /**
-     * When set to auto (the default) query runner will issue queries on activate (when variable dependencies are ready) or when time range change.
-     * Set to manual to have full manual control over when queries are issued. Try not to set this. This is mainly useful for unit tests, or special edge case workflows.
-     */
-    runQueriesMode?: 'auto' | 'manual';
-    dataLayerFilter?: DataLayerFilter;
-    _hasFetchedData?: boolean;
-}
-declare class SceneQueryRunner extends SceneObjectBase<QueryRunnerState> implements SceneDataProvider {
-    private _querySub?;
-    private _dataLayersSub?;
-    private _dataLayersMerger;
-    private _timeSub?;
-    private _timeSubRange?;
-    private _containerWidth?;
-    private _variableValueRecorder;
-    private _results;
-    private _scopedVars;
-    private _layerAnnotations?;
-    private _resultAnnotations?;
-    private _isInView;
-    private _bypassIsInView;
-    private _queryNotExecutedWhenOutOfView;
-    getResultsStream(): ReplaySubject<SceneDataProviderResult>;
-    protected _variableDependency: VariableDependencyConfig<QueryRunnerState>;
-    private _drilldownDependenciesManager;
-    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;
-    private subscribeToTimeRangeChanges;
-    runQueries(): void;
-    private getMaxDataPoints;
-    cancelQuery(): void;
-    private runWithTimeRange;
-    clone(withState?: Partial<QueryRunnerState>): this;
-    private prepareRequests;
-    private onDataReceived;
-    private _combineDataLayers;
-    private _setNoDataState;
-    /**
-     * Walk up the scene graph and find any ExtraQueryProviders.
-     *
-     * This will return an array of the closest provider of each type.
-     */
-    private getClosestExtraQueryProviders;
-    private isQueryModeAuto;
-    isInViewChanged(isInView: boolean): void;
-    bypassIsInViewChanged(bypassIsInView: boolean): void;
-}
-
 interface DataProviderSharerState extends SceneDataState {
     source: SceneObjectRef<SceneDataProvider>;
 }
@@ -3594,6 +3596,8 @@ declare const sceneUtils: {
     isSwitchVariable: typeof isSwitchVariable;
     isRepeatCloneOrChildOf: typeof isRepeatCloneOrChildOf;
     buildPathIdFor: typeof buildPathIdFor;
+    verifyDrilldownApplicability: typeof verifyDrilldownApplicability;
+    getDrilldownApplicability: typeof getDrilldownApplicability;
 };
 
 export { AdHocFiltersComboboxRenderer, AdHocFiltersVariable, AdHocFiltersVariableController, ConstantVariable, ControlsLabel, CustomVariable, DataProviderProxy, DataSourceVariable, EmbeddedScene, FieldConfigBuilder, FieldConfigBuilders, FieldConfigOverridesBuilder, GroupByVariable, IntervalVariable, LazyLoader, LocalValueVariable, MultiOrSingleValueSelect, MultiValueVariable, NestedScene, NewSceneObjectAddedEvent, PATH_ID_SEPARATOR, PanelBuilders, PanelOptionsBuilders, QueryVariable, RuntimeDataSource, SafeSerializableSceneObject, SceneApp, SceneAppPage, SceneByFrameRepeater, SceneByVariableRepeater, SceneCSSGridItem, SceneCSSGridLayout, SceneCanvasText, SceneControlsSpacer, SceneDataLayerBase, SceneDataLayerControls, SceneDataLayerSet, SceneDataLayerSetBase, SceneDataNode, SceneDataTransformer, SceneDebugger, SceneFlexItem, SceneFlexLayout, SceneGridItem, SceneGridLayout, SceneGridLayoutDragStartEvent, SceneGridRow, SceneObjectBase, SceneObjectRef, SceneObjectStateChangedEvent, SceneObjectUrlSyncConfig, SceneQueryRunner, SceneReactObject, SceneRefreshPicker, SceneTimePicker, SceneTimeRange, SceneTimeRangeCompare, SceneTimeRangeTransformerBase, SceneTimeZoneOverride, SceneToolbarButton, SceneToolbarInput, SceneVariableSet, SceneVariableValueChangedEvent, ScopesVariable, SplitLayout, SwitchVariable, TestVariable, TextBoxVariable, UrlSyncContextProvider, UrlSyncManager, UserActionEvent, VariableDependencyConfig, VariableValueControl, VariableValueSelectWrapper, VariableValueSelectors, VizConfigBuilder, VizConfigBuilders, VizPanel, VizPanelBuilder, VizPanelExploreButton, VizPanelMenu, index$2 as behaviors, index as dataLayers, escapeUrlPipeDelimiters, formatRegistry, getExploreURL, isCustomVariableValue, isDataLayer, isDataRequestEnricher, isFiltersRequestEnricher, isSceneObject, loadResources, index$1 as performanceUtils, registerQueryWithController, registerRuntimeDataSource, sceneGraph, sceneUtils, useSceneApp, useSceneObjectState, useUrlSync, writePerformanceLog };

package/dist/index.js

@@ -3615,6 +3615,8 @@ class GroupByVariable extends MultiValueVariable {
     if (!lodash.isEqual(response, this.state.keysApplicability)) {
       this.setState({ keysApplicability: response != null ? response : void 0, applicabilityEnabled: true });
       this.publishEvent(new SceneVariableValueChangedEvent(this), true);
+    } else {
+      this.setState({ applicabilityEnabled: true });
     }
   }
   // This method is related to the defaultValue property. We check if the current value
@@ -9069,6 +9071,50 @@ function getNonApplicablePillStyles(theme) {
     })
   };
 }
+function verifyDrilldownApplicability(sourceObject, queriesDataSource, drilldownDatasource, isApplicabilityEnabled) {
+  const datasourceUid = sceneGraph.interpolate(sourceObject, queriesDataSource == null ? void 0 : queriesDataSource.uid);
+  return Boolean(
+    isApplicabilityEnabled && datasourceUid === sceneGraph.interpolate(sourceObject, drilldownDatasource == null ? void 0 : drilldownDatasource.uid)
+  );
+}
+async function getDrilldownApplicability(queryRunner, filtersVar, groupByVar) {
+  var _a, _b, _c, _d, _e, _f;
+  if (!filtersVar && !groupByVar) {
+    return;
+  }
+  const datasource = queryRunner.state.datasource;
+  const queries = (_b = (_a = queryRunner.state.data) == null ? void 0 : _a.request) == null ? void 0 : _b.targets;
+  const ds = await getDataSource(datasource, {
+    __sceneObject: wrapInSafeSerializableSceneObject(queryRunner)
+  });
+  if (!ds.getDrilldownsApplicability) {
+    return;
+  }
+  const dsUid = sceneGraph.interpolate(queryRunner, datasource == null ? void 0 : datasource.uid);
+  const timeRange = sceneGraph.getTimeRange(queryRunner).state.value;
+  const groupByKeys = [];
+  const filters = [];
+  const hasGroupByApplicability = groupByVar && dsUid === sceneGraph.interpolate(groupByVar, (_c = groupByVar == null ? void 0 : groupByVar.state.datasource) == null ? void 0 : _c.uid);
+  const hasFiltersApplicability = filtersVar && dsUid === sceneGraph.interpolate(filtersVar, (_e = (_d = filtersVar.state) == null ? void 0 : _d.datasource) == null ? void 0 : _e.uid);
+  if (!hasGroupByApplicability && !hasFiltersApplicability) {
+    return;
+  }
+  if (hasGroupByApplicability) {
+    groupByKeys.push(
+      ...Array.isArray(groupByVar.state.value) ? groupByVar.state.value.map((v) => String(v)) : groupByVar.state.value ? [String(groupByVar.state.value)] : []
+    );
+  }
+  if (hasFiltersApplicability) {
+    filters.push(...filtersVar.state.filters, ...(_f = filtersVar.state.originFilters) != null ? _f : []);
+  }
+  return await ds.getDrilldownsApplicability({
+    groupByKeys,
+    filters,
+    queries,
+    timeRange,
+    scopes: sceneGraph.getScopes(queryRunner)
+  });
+}
 
 class ConstantVariable extends SceneObjectBase {
   constructor(initialState) {
@@ -16132,7 +16178,10 @@ const sceneUtils = {
   isGroupByVariable,
   isSwitchVariable,
   isRepeatCloneOrChildOf,
-  buildPathIdFor
+  buildPathIdFor,
+  //drilldowns
+  verifyDrilldownApplicability,
+  getDrilldownApplicability
 };
 
 exports.AdHocFiltersComboboxRenderer = AdHocFiltersComboboxRenderer;