@perses-dev/plugin-system 0.54.0-beta.1 → 0.54.0-beta.10

package/dist/cjs/model/alerts-queries.js

@@ -0,0 +1,16 @@
+// Copyright 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
+});

package/dist/cjs/model/annotations.js

@@ -0,0 +1,16 @@
+// Copyright 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
+});

package/dist/cjs/model/index.js

@@ -14,6 +14,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+_export_star(require("./annotations"), exports);
 _export_star(require("./datasource"), exports);
 _export_star(require("./legend"), exports);
 _export_star(require("./log-queries"), exports);
@@ -27,6 +28,8 @@ _export_star(require("./trace-queries"), exports);
 _export_star(require("./profile-queries"), exports);
 _export_star(require("./variables"), exports);
 _export_star(require("./calculations"), exports);
+_export_star(require("./alerts-queries"), exports);
+_export_star(require("./silences-queries"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/dist/cjs/model/log-volume-utils.js

@@ -1,3 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "calculateVolumeInterval", {
+    enumerable: true,
+    get: function() {
+        return calculateVolumeInterval;
+    }
+});
 // Copyright 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.
@@ -11,16 +21,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 // Target number of bars for log volume histogram
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "calculateVolumeInterval", {
-    enumerable: true,
-    get: function() {
-        return calculateVolumeInterval;
-    }
-});
 const TARGET_HISTOGRAM_BARS = 40;
 // Standard intervals for histogram calculations (in milliseconds)
 const STANDARD_INTERVALS = [

package/dist/cjs/model/plugin-loading.js

@@ -20,21 +20,37 @@ Object.defineProperty(exports, "dynamicImportPluginLoader", {
         return dynamicImportPluginLoader;
     }
 });
+const _plugins = require("./plugins");
 function dynamicImportPluginLoader(plugins) {
-    const importMap = new Map(plugins.map((plugin)=>[
-            plugin.resource,
-            plugin.importPlugin
-        ]));
+    const importMap = new Map();
+    for (const p of plugins){
+        const { resource, resource: { kind, metadata: { name, registry, version } }, importPlugin } = p;
+        importMap.set((0, _plugins.getPluginModuleCompoundKey)({
+            kind,
+            name,
+            registry,
+            version
+        }), {
+            resource,
+            importPlugin
+        });
+    }
     return {
         async getInstalledPlugins () {
-            return Promise.resolve(Array.from(importMap.keys()));
+            return Promise.resolve(Array.from(importMap.values()).map((v)=>v.resource));
         },
         importPluginModule (resource) {
-            const importFn = importMap.get(resource);
-            if (importFn === undefined) {
+            const { kind, metadata: { name, version, registry } } = resource;
+            const { importPlugin } = importMap.get((0, _plugins.getPluginModuleCompoundKey)({
+                kind,
+                name,
+                registry,
+                version
+            })) || {};
+            if (importPlugin === undefined) {
                 throw new Error('Plugin not found');
             }
-            return importFn();
+            return importPlugin();
         }
     };
 }

package/dist/cjs/model/plugins.js

@@ -14,3 +14,13 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+Object.defineProperty(exports, "getPluginModuleCompoundKey", {
+    enumerable: true,
+    get: function() {
+        return getPluginModuleCompoundKey;
+    }
+});
+function getPluginModuleCompoundKey(compoundKey) {
+    const { kind, name, registry, version } = compoundKey;
+    return `${kind}:${name}:${registry ?? ''}:${version ?? ''}`;
+}

package/dist/cjs/model/silences-queries.js

@@ -0,0 +1,16 @@
+// Copyright 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
+});

package/dist/cjs/remote/PluginRuntime.js

@@ -147,7 +147,14 @@ const getPluginRuntime = ()=>{
                         requiredVersion: '^5.5.0'
                     }
                 },
-                // TODO should we add @perses-dev/spec here ?
+                '@perses-dev/spec': {
+                    version: '0.2.0-beta.2',
+                    lib: ()=>require('@perses-dev/spec'),
+                    shareConfig: {
+                        singleton: true,
+                        requiredVersion: '^0.2.0-beta.2'
+                    }
+                },
                 '@perses-dev/core': {
                     version: '0.53.1',
                     lib: ()=>require('@perses-dev/core'),
@@ -156,6 +163,14 @@ const getPluginRuntime = ()=>{
                         requiredVersion: '^0.53.1'
                     }
                 },
+                '@perses-dev/client': {
+                    version: '0.54.0-beta.1',
+                    lib: ()=>require('@perses-dev/client'),
+                    shareConfig: {
+                        singleton: true,
+                        requiredVersion: '^0.54.0-beta.1'
+                    }
+                },
                 '@perses-dev/components': {
                     version: '0.53.1',
                     lib: ()=>require('@perses-dev/components'),
@@ -268,28 +283,49 @@ const getPluginRuntime = ()=>{
     }
     return instance;
 };
-const registerRemote = (name, baseURL)=>{
+function getModuleFederationRemoteName(name, registry, version) {
+    return `${name}:${registry ?? ''}:${version ?? ''}`;
+}
+const registerRemote = (name, registry, version, baseURL)=>{
     const pluginRuntime = getPluginRuntime();
-    const existingRemote = pluginRuntime.options.remotes.find((remote)=>remote.name === name);
+    const registryName = getModuleFederationRemoteName(name, registry, version);
+    const existingRemote = pluginRuntime.options.remotes.find((remote)=>remote.name === registryName);
     if (!existingRemote) {
-        const remoteEntryURL = baseURL ? `${baseURL}/${name}/mf-manifest.json` : `/plugins/${name}/mf-manifest.json`;
+        const nameVersionRegistry = [
+            name,
+            version,
+            registry
+        ].filter(Boolean).join('~');
+        const prefix = baseURL || '/plugins';
+        const remoteEntryURL = `${prefix}/${nameVersionRegistry}/mf-manifest.json`;
         pluginRuntime.registerRemotes([
             {
-                name,
+                name: registryName,
                 entry: remoteEntryURL,
-                alias: name
+                alias: registryName
             }
         ]);
     }
 };
-const loadPlugin = async (moduleName, pluginName, baseURL)=>{
-    registerRemote(moduleName, baseURL);
+const loadPlugin = async (target)=>{
+    const { moduleName, pluginName, registry, version, baseURL } = target;
+    registerRemote(moduleName, registry, version, baseURL);
     const pluginRuntime = getPluginRuntime();
-    return pluginRuntime.loadRemote(`${moduleName}/${pluginName}`);
+    const registryName = getModuleFederationRemoteName(moduleName, registry, version);
+    return pluginRuntime.loadRemote(`${registryName}/${pluginName}`);
 };
 function usePluginRuntime({ plugin }) {
     return {
         pluginRuntime: getPluginRuntime(),
-        loadPlugin: ()=>loadPlugin(plugin.moduleName, plugin.name, plugin.baseURL)
+        loadPlugin: ()=>{
+            const { moduleName, name: pluginName, registry, version, baseURL } = plugin;
+            return loadPlugin({
+                moduleName,
+                pluginName,
+                registry,
+                version,
+                baseURL
+            });
+        }
     };
 }

package/dist/cjs/remote/remotePluginLoader.js

@@ -20,6 +20,7 @@ Object.defineProperty(exports, "remotePluginLoader", {
         return remotePluginLoader;
     }
 });
+const _pluginsystem = require("@perses-dev/plugin-system");
 const _PluginRuntime = require("./PluginRuntime");
 const isPluginMetadata = (plugin)=>{
     return typeof plugin === 'object' && plugin !== null && 'kind' in plugin && 'spec' in plugin && typeof plugin.spec === 'object' && plugin.spec !== null && 'name' in plugin.spec;
@@ -59,17 +60,39 @@ function remotePluginLoader(options) {
             return pluginModules;
         },
         importPluginModule: async (resource)=>{
-            const pluginModuleName = resource.metadata.name;
+            const { name: pluginModuleName, version, registry } = resource.metadata;
             const pluginModule = {};
-            for (const plugin of resource.spec.plugins){
-                const remotePluginModule = await (0, _PluginRuntime.loadPlugin)(pluginModuleName, plugin.spec.name, pluginsAssetsPath);
+            const loadPromises = resource.spec.plugins.map(async (plugin)=>{
+                const remotePluginModule = await (0, _PluginRuntime.loadPlugin)({
+                    moduleName: pluginModuleName,
+                    pluginName: plugin.spec.name,
+                    registry,
+                    version,
+                    baseURL: pluginsAssetsPath
+                });
                 const remotePlugin = remotePluginModule?.[plugin.spec.name];
                 if (remotePlugin) {
-                    pluginModule[plugin.spec.name] = remotePlugin;
+                    return {
+                        kind: plugin.kind,
+                        name: plugin.spec.name,
+                        remotePlugin
+                    };
                 } else {
                     console.error(`RemotePluginLoader: Error loading plugin ${plugin.spec.name}`);
+                    return null;
                 }
-            }
+            });
+            const loadedPlugins = await Promise.all(loadPromises);
+            loadedPlugins.forEach((item)=>{
+                if (item?.remotePlugin) {
+                    pluginModule[(0, _pluginsystem.getPluginModuleCompoundKey)({
+                        kind: item.kind,
+                        name: item.name,
+                        registry,
+                        version
+                    })] = item.remotePlugin;
+                }
+            });
             return pluginModule;
         }
     };

package/dist/cjs/runtime/DataQueriesProvider/DataQueriesProvider.js

@@ -39,6 +39,8 @@ const _react = require("react");
 const _timeseriesqueries = require("../time-series-queries");
 const _tracequeries = require("../trace-queries");
 const _profilequeries = require("../profile-queries");
+const _alertsqueries = require("../alerts-queries");
+const _silencesqueries = require("../silences-queries");
 const _UsageMetricsProvider = require("../UsageMetricsProvider");
 const _logqueries = require("../log-queries");
 const _model = require("./model");
@@ -52,60 +54,61 @@ function useDataQueriesContext() {
 }
 function useDataQueries(queryType) {
     const ctx = useDataQueriesContext();
+    // Filter query definitions based on the specified query type
+    const filteredQueryDefinitions = ctx.queryDefinitions.filter((definition)=>definition.kind === queryType);
     // Filter the query results based on the specified query type
     const filteredQueryResults = ctx.queryResults.filter((queryResult)=>queryResult?.definition?.kind === queryType);
     // Filter the errors based on the specified query type
     const filteredErrors = ctx.errors.filter((errors, index)=>ctx.queryResults[index]?.definition?.kind === queryType);
     // Create a new context object with the filtered results and errors
-    const filteredCtx = {
+    return {
+        queryDefinitions: filteredQueryDefinitions,
         queryResults: filteredQueryResults,
         isFetching: filteredQueryResults.some((result)=>result.isFetching),
         isLoading: filteredQueryResults.some((result)=>result.isLoading),
         refetchAll: ctx.refetchAll,
         errors: filteredErrors
     };
-    return filteredCtx;
 }
 function DataQueriesProvider(props) {
     const { definitions, options, children, queryOptions } = props;
-    // Returns a query kind, for example "TimeSeriesQuery" = getQueryType("PrometheusTimeSeriesQuery")
-    const getQueryType = (0, _model.useQueryType)();
-    const queryDefinitions = definitions.map((definition)=>{
-        const type = getQueryType(definition.kind);
-        return {
-            kind: type,
-            spec: {
-                plugin: definition
-            }
-        };
-    });
     const usageMetrics = (0, _UsageMetricsProvider.useUsageMetrics)();
     // Filter definitions for time series query and other future query plugins
-    const timeSeriesQueries = queryDefinitions.filter((definition)=>definition.kind === 'TimeSeriesQuery');
+    const timeSeriesQueries = definitions.filter((definition)=>definition.kind === 'TimeSeriesQuery');
     const timeSeriesResults = (0, _timeseriesqueries.useTimeSeriesQueries)(timeSeriesQueries, options, queryOptions);
-    const traceQueries = queryDefinitions.filter((definition)=>definition.kind === 'TraceQuery');
+    const traceQueries = definitions.filter((definition)=>definition.kind === 'TraceQuery');
     const traceResults = (0, _tracequeries.useTraceQueries)(traceQueries);
-    const profileQueries = queryDefinitions.filter((definition)=>definition.kind === 'ProfileQuery');
+    const profileQueries = definitions.filter((definition)=>definition.kind === 'ProfileQuery');
     const profileResults = (0, _profilequeries.useProfileQueries)(profileQueries);
-    const logQueries = queryDefinitions.filter((definition)=>definition.kind === 'LogQuery');
+    const logQueries = definitions.filter((definition)=>definition.kind === 'LogQuery');
     const logResults = (0, _logqueries.useLogQueries)(logQueries);
+    const alertsQueries = definitions.filter((definition)=>definition.kind === 'AlertsQuery');
+    const alertsResults = (0, _alertsqueries.useAlertsQueries)(alertsQueries);
+    const silencesQueries = definitions.filter((definition)=>definition.kind === 'SilencesQuery');
+    const silencesResults = (0, _silencesqueries.useSilencesQueries)(silencesQueries);
     const refetchAll = (0, _react.useCallback)(()=>{
         timeSeriesResults.forEach((result)=>result.refetch());
         traceResults.forEach((result)=>result.refetch());
         profileResults.forEach((result)=>result.refetch());
         logResults.forEach((result)=>result.refetch());
+        alertsResults.forEach((result)=>result.refetch());
+        silencesResults.forEach((result)=>result.refetch());
     }, [
         timeSeriesResults,
         traceResults,
         profileResults,
-        logResults
+        logResults,
+        alertsResults,
+        silencesResults
     ]);
     const ctx = (0, _react.useMemo)(()=>{
         const mergedQueryResults = [
             ...(0, _model.transformQueryResults)(timeSeriesResults, timeSeriesQueries),
             ...(0, _model.transformQueryResults)(traceResults, traceQueries),
             ...(0, _model.transformQueryResults)(profileResults, profileQueries),
-            ...(0, _model.transformQueryResults)(logResults, logQueries)
+            ...(0, _model.transformQueryResults)(logResults, logQueries),
+            ...(0, _model.transformQueryResults)(alertsResults, alertsQueries),
+            ...(0, _model.transformQueryResults)(silencesResults, silencesQueries)
         ];
         if (queryOptions?.enabled) {
             for (const result of mergedQueryResults){
@@ -119,6 +122,7 @@ function DataQueriesProvider(props) {
             }
         }
         return {
+            queryDefinitions: definitions,
             queryResults: mergedQueryResults,
             isFetching: mergedQueryResults.some((result)=>result.isFetching),
             isLoading: mergedQueryResults.some((result)=>result.isLoading),
@@ -126,16 +130,21 @@ function DataQueriesProvider(props) {
             errors: mergedQueryResults.map((result)=>result.error)
         };
     }, [
+        alertsQueries,
+        alertsResults,
+        logQueries,
+        logResults,
+        profileQueries,
+        profileResults,
+        silencesQueries,
+        silencesResults,
         timeSeriesQueries,
         timeSeriesResults,
         traceQueries,
         traceResults,
-        profileQueries,
-        profileResults,
-        logQueries,
-        logResults,
-        refetchAll,
+        definitions,
         queryOptions?.enabled,
+        refetchAll,
         usageMetrics
     ]);
     return /*#__PURE__*/ (0, _jsxruntime.jsx)(DataQueriesContext.Provider, {

package/dist/cjs/runtime/DataQueriesProvider/model.js

@@ -14,22 +14,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get transformQueryResults () {
+Object.defineProperty(exports, "transformQueryResults", {
+    enumerable: true,
+    get: function() {
         return transformQueryResults;
-    },
-    get useQueryType () {
-        return useQueryType;
     }
 });
-const _react = require("react");
-const _pluginregistry = require("../plugin-registry");
 function transformQueryResults(results, definitions) {
     return results.map(({ data, isFetching, isLoading, refetch, error }, i)=>{
         return {
@@ -42,83 +32,3 @@ function transformQueryResults(results, definitions) {
         };
     });
 }
-function useQueryType() {
-    const { data: timeSeriesQueryPlugins, isLoading: isTimeSeriesQueryLoading } = (0, _pluginregistry.useListPluginMetadata)([
-        'TimeSeriesQuery'
-    ]);
-    const { data: traceQueryPlugins, isLoading: isTraceQueryPluginLoading } = (0, _pluginregistry.useListPluginMetadata)([
-        'TraceQuery'
-    ]);
-    const { data: profileQueryPlugins, isLoading: isProfileQueryPluginLoading } = (0, _pluginregistry.useListPluginMetadata)([
-        'ProfileQuery'
-    ]);
-    const { data: logQueries, isLoading: isLogQueryPluginLoading } = (0, _pluginregistry.useListPluginMetadata)([
-        'LogQuery'
-    ]);
-    // For example, `map: {"TimeSeriesQuery":["PrometheusTimeSeriesQuery"],"TraceQuery":["TempoTraceQuery"]}`
-    const queryTypeMap = (0, _react.useMemo)(()=>{
-        const map = {
-            TimeSeriesQuery: [],
-            TraceQuery: [],
-            ProfileQuery: [],
-            LogQuery: []
-        };
-        if (timeSeriesQueryPlugins) {
-            timeSeriesQueryPlugins.forEach((plugin)=>{
-                map[plugin.kind]?.push(plugin.spec.name);
-            });
-        }
-        if (traceQueryPlugins) {
-            traceQueryPlugins.forEach((plugin)=>{
-                map[plugin.kind]?.push(plugin.spec.name);
-            });
-        }
-        if (profileQueryPlugins) {
-            profileQueryPlugins.forEach((plugin)=>{
-                map[plugin.kind]?.push(plugin.spec.name);
-            });
-        }
-        if (logQueries) {
-            logQueries.forEach((plugin)=>{
-                map[plugin.kind]?.push(plugin.spec.name);
-            });
-        }
-        return map;
-    }, [
-        timeSeriesQueryPlugins,
-        traceQueryPlugins,
-        profileQueryPlugins,
-        logQueries
-    ]);
-    const getQueryType = (0, _react.useCallback)((pluginKind)=>{
-        const isLoading = (pluginKind)=>{
-            switch(pluginKind){
-                case 'PrometheusTimeSeriesQuery':
-                    return isTimeSeriesQueryLoading;
-                case 'TempoTraceQuery':
-                    return isTraceQueryPluginLoading;
-                case 'PyroscopeProfileQuery':
-                    return isProfileQueryPluginLoading;
-                case 'LokiLogQuery':
-                    return isLogQueryPluginLoading;
-            }
-            return isTraceQueryPluginLoading || isTimeSeriesQueryLoading || isProfileQueryPluginLoading || isLogQueryPluginLoading;
-        };
-        if (isLoading(pluginKind)) {
-            return undefined;
-        }
-        for(const queryType in queryTypeMap){
-            if (queryTypeMap[queryType]?.includes(pluginKind)) {
-                return queryType;
-            }
-        }
-        throw new Error(`Unable to determine the query type: ${pluginKind}`);
-    }, [
-        queryTypeMap,
-        isTimeSeriesQueryLoading,
-        isTraceQueryPluginLoading,
-        isProfileQueryPluginLoading,
-        isLogQueryPluginLoading
-    ]);
-    return getQueryType;
-}

package/dist/cjs/runtime/UsageMetricsProvider.js

@@ -35,7 +35,7 @@ _export(exports, {
     }
 });
 const _jsxruntime = require("react/jsx-runtime");
-const _core = require("@perses-dev/core");
+const _client = require("@perses-dev/client");
 const _react = require("react");
 const UsageMetricsContext = /*#__PURE__*/ (0, _react.createContext)(undefined);
 const useUsageMetricsContext = ()=>{
@@ -70,7 +70,7 @@ const useUsageMetrics = ()=>{
     };
 };
 const submitMetrics = async (stats)=>{
-    await (0, _core.fetch)(`${stats.apiPrefix ?? ''}/api/v1/view`, {
+    await (0, _client.fetch)(`${stats.apiPrefix ?? ''}/api/v1/view`, {
         method: 'POST',
         headers: {
             'Content-Type': 'application/json'

package/dist/cjs/runtime/alerts-queries.js

@@ -0,0 +1,101 @@
+// Copyright 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: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get ALERTS_QUERY_KEY () {
+        return ALERTS_QUERY_KEY;
+    },
+    get useAlertsQueries () {
+        return useAlertsQueries;
+    }
+});
+const _reactquery = require("@tanstack/react-query");
+const _datasources = require("./datasources");
+const _pluginregistry = require("./plugin-registry");
+const _variables = require("./variables");
+const _utils = require("./utils");
+const ALERTS_QUERY_KEY = 'AlertsQuery';
+function useAlertsQueries(definitions) {
+    const { getPlugin } = (0, _pluginregistry.usePluginRegistry)();
+    const context = useAlertsQueryContext();
+    const pluginLoaderResponse = (0, _pluginregistry.usePlugins)('AlertsQuery', definitions.map((d)=>({
+            kind: d.spec.plugin.kind
+        })));
+    return (0, _reactquery.useQueries)({
+        queries: definitions.map((definition, idx)=>{
+            const plugin = pluginLoaderResponse[idx]?.data;
+            const { queryEnabled, queryKey } = getQueryOptions({
+                context,
+                definition,
+                plugin
+            });
+            const alertsQueryKind = definition?.spec?.plugin?.kind;
+            return {
+                enabled: queryEnabled,
+                queryKey: queryKey,
+                refetchOnMount: false,
+                refetchOnWindowFocus: false,
+                refetchOnReconnect: false,
+                staleTime: 60_000,
+                queryFn: async ({ signal })=>{
+                    const plugin = await getPlugin({
+                        kind: ALERTS_QUERY_KEY,
+                        name: alertsQueryKind
+                    });
+                    const data = await plugin.getAlertsData(definition.spec.plugin.spec, context, signal);
+                    return data;
+                }
+            };
+        })
+    });
+}
+function getQueryOptions({ plugin, definition, context }) {
+    const { variableState } = context;
+    const dependencies = plugin?.dependsOn ? plugin.dependsOn(definition.spec.plugin.spec, context) : {};
+    const variableDependencies = dependencies?.variables;
+    const filteredVariabledState = (0, _utils.filterVariableStateMap)(variableState, variableDependencies);
+    const variablesValueKey = (0, _utils.getVariableValuesKey)(filteredVariabledState);
+    // Note: no absoluteTimeRange in query key since alerts are current state
+    const queryKey = [
+        'query',
+        ALERTS_QUERY_KEY,
+        definition,
+        variablesValueKey
+    ];
+    let waitToLoad = false;
+    if (variableDependencies) {
+        waitToLoad = variableDependencies.some((v)=>variableState[v]?.loading);
+    }
+    const queryEnabled = plugin !== undefined && !waitToLoad;
+    return {
+        queryKey,
+        queryEnabled
+    };
+}
+function useAlertsQueryContext() {
+    const variableState = (0, _variables.useAllVariableValues)();
+    const datasourceStore = (0, _datasources.useDatasourceStore)();
+    return {
+        variableState,
+        datasourceStore
+    };
+}