@perses-dev/plugin-system 0.55.0-beta.3 → 0.55.0-beta.6

package/dist/cjs/runtime/TimeRangeProvider/query-params.js

@@ -1,250 +0,0 @@
-// 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 TimeRangeParam () {
-        return TimeRangeParam;
-    },
-    get decodeTimeRangeValue () {
-        return decodeTimeRangeValue;
-    },
-    get encodeTimeRangeValue () {
-        return encodeTimeRangeValue;
-    },
-    get refreshIntervalQueryConfig () {
-        return refreshIntervalQueryConfig;
-    },
-    get timeRangeQueryConfig () {
-        return timeRangeQueryConfig;
-    },
-    get timeZoneQueryConfig () {
-        return timeZoneQueryConfig;
-    },
-    get useInitialRefreshInterval () {
-        return useInitialRefreshInterval;
-    },
-    get useInitialTimeRange () {
-        return useInitialTimeRange;
-    },
-    get useSetRefreshIntervalParams () {
-        return useSetRefreshIntervalParams;
-    },
-    get useTimeRangeParams () {
-        return useTimeRangeParams;
-    },
-    get useTimeZoneParams () {
-        return useTimeZoneParams;
-    }
-});
-const _spec = require("@perses-dev/spec");
-const _datefns = require("date-fns");
-const _react = require("react");
-const _usequeryparams = require("use-query-params");
-/* Interprets an encoded string and returns either the string or null/undefined if not available */ function getEncodedValue(input, allowEmptyString) {
-    // '' or []
-    if (!input || input.length === 0 && (!allowEmptyString || allowEmptyString && input !== '')) {
-        return null;
-    }
-    const str = input instanceof Array ? input[0] : input;
-    if (str === null || str === undefined) {
-        return str;
-    }
-    if (!allowEmptyString && str === '') {
-        return null;
-    }
-    return str;
-}
-function encodeTimeRangeValue(timeOptionValue) {
-    if (!timeOptionValue) {
-        return timeOptionValue;
-    }
-    if (typeof timeOptionValue === 'string') {
-        if ((0, _spec.isDurationString)(timeOptionValue)) {
-            return timeOptionValue;
-        }
-    }
-    return ((0, _datefns.getUnixTime)(timeOptionValue) * 1000).toString();
-}
-function decodeTimeRangeValue(input) {
-    const paramString = getEncodedValue(input);
-    if (!paramString) return null;
-    return (0, _spec.isDurationString)(paramString) ? paramString : new Date(Number(paramString));
-}
-const TimeRangeParam = {
-    encode: encodeTimeRangeValue,
-    decode: decodeTimeRangeValue,
-    equals: (valueA, valueB)=>{
-        if (valueA === valueB) return true;
-        if (!valueA || !valueB) return valueA === valueB;
-        return valueA.valueOf() === valueB.valueOf();
-    }
-};
-const timeRangeQueryConfig = {
-    start: TimeRangeParam,
-    end: TimeRangeParam
-};
-const refreshIntervalQueryConfig = {
-    refresh: TimeRangeParam
-};
-const timeZoneQueryConfig = {
-    tz: _usequeryparams.StringParam
-};
-function useInitialTimeRange(dashboardDuration) {
-    const [query] = (0, _usequeryparams.useQueryParams)(timeRangeQueryConfig, {
-        updateType: 'replaceIn'
-    });
-    const { start, end } = query;
-    return (0, _react.useMemo)(()=>{
-        let initialTimeRange = {
-            pastDuration: dashboardDuration
-        };
-        if (!start) {
-            return initialTimeRange;
-        }
-        const startStr = start.toString();
-        if ((0, _spec.isDurationString)(startStr)) {
-            initialTimeRange = {
-                pastDuration: startStr
-            };
-        } else if ((0, _datefns.isDate)(start) && (0, _datefns.isDate)(end)) {
-            initialTimeRange = {
-                start: start,
-                end: end
-            };
-        }
-        return initialTimeRange;
-    }, [
-        start,
-        end,
-        dashboardDuration
-    ]);
-}
-function useTimeRangeParams(initialTimeRange) {
-    const [query, setQuery] = (0, _usequeryparams.useQueryParams)(timeRangeQueryConfig, {
-        updateType: 'replaceIn'
-    });
-    // determine whether initial param had previously been populated to fix back btn
-    const [paramsLoaded, setParamsLoaded] = (0, _react.useState)(false);
-    const { start } = query;
-    (0, _react.useEffect)(()=>{
-        // when dashboard loaded with no params, default to dashboard duration
-        if (!paramsLoaded && !start) {
-            if ((0, _spec.isRelativeTimeRange)(initialTimeRange)) {
-                setQuery({
-                    start: initialTimeRange.pastDuration,
-                    end: undefined
-                });
-                setParamsLoaded(true);
-            }
-        }
-    }, [
-        initialTimeRange,
-        paramsLoaded,
-        start,
-        setQuery
-    ]);
-    const setTimeRange = (0, _react.useCallback)((value)=>{
-        if ((0, _spec.isRelativeTimeRange)(value)) {
-            setQuery({
-                start: value.pastDuration,
-                end: undefined
-            });
-        } else {
-            setQuery(value);
-        }
-    }, [
-        setQuery
-    ]);
-    return {
-        timeRange: initialTimeRange,
-        setTimeRange: setTimeRange
-    };
-}
-function useInitialRefreshInterval(dashboardDuration) {
-    const [query] = (0, _usequeryparams.useQueryParams)(refreshIntervalQueryConfig, {
-        updateType: 'replaceIn'
-    });
-    const { refresh } = query;
-    return (0, _react.useMemo)(()=>{
-        let initialTimeRange = dashboardDuration;
-        if (!refresh) {
-            return initialTimeRange;
-        }
-        const startStr = refresh.toString();
-        if ((0, _spec.isDurationString)(startStr)) {
-            initialTimeRange = startStr;
-        }
-        return initialTimeRange;
-    }, [
-        dashboardDuration,
-        refresh
-    ]);
-}
-function useSetRefreshIntervalParams(initialRefreshInterval) {
-    const [query, setQuery] = (0, _usequeryparams.useQueryParams)(refreshIntervalQueryConfig, {
-        updateType: 'replaceIn'
-    });
-    // determine whether initial param had previously been populated to fix back btn
-    const [paramsLoaded, setParamsLoaded] = (0, _react.useState)(false);
-    const { refresh } = query;
-    (0, _react.useEffect)(()=>{
-        // when dashboard loaded with no params, default to dashboard refresh interval
-        if (!paramsLoaded && !refresh) {
-            setQuery({
-                refresh: initialRefreshInterval
-            });
-            setParamsLoaded(true);
-        }
-    }, [
-        initialRefreshInterval,
-        paramsLoaded,
-        refresh,
-        setQuery
-    ]);
-    const setRefreshInterval = (0, _react.useCallback)((refresh)=>setQuery({
-            refresh
-        }), [
-        setQuery
-    ]);
-    return {
-        refreshInterval: initialRefreshInterval,
-        setRefreshInterval: setRefreshInterval
-    };
-}
-function useTimeZoneParams(initialTimeZone) {
-    const [query, setQuery] = (0, _usequeryparams.useQueryParams)(timeZoneQueryConfig, {
-        updateType: 'replaceIn'
-    });
-    const { tz } = query;
-    const timeZone = tz ?? initialTimeZone ?? 'local';
-    const setTimeZone = (0, _react.useCallback)((newTz)=>{
-        setQuery({
-            tz: newTz
-        });
-    }, [
-        setQuery
-    ]);
-    return {
-        timeZone,
-        setTimeZone
-    };
-}

package/dist/cjs/runtime/TimeRangeProvider/refresh-interval.js

@@ -1,30 +0,0 @@
-// 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
-});
-Object.defineProperty(exports, "getRefreshIntervalInMs", {
-    enumerable: true,
-    get: function() {
-        return getRefreshIntervalInMs;
-    }
-});
-const _spec = require("@perses-dev/spec");
-const _datefns = require("date-fns");
-function getRefreshIntervalInMs(refreshInterval) {
-    if (refreshInterval !== undefined && refreshInterval !== null) {
-        return (0, _datefns.milliseconds)((0, _spec.parseDurationString)(refreshInterval));
-    }
-    return 0;
-}

package/dist/cjs/runtime/UsageMetricsProvider.js

@@ -1,102 +0,0 @@
-// 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 UsageMetricsContext () {
-        return UsageMetricsContext;
-    },
-    get UsageMetricsProvider () {
-        return UsageMetricsProvider;
-    },
-    get useUsageMetrics () {
-        return useUsageMetrics;
-    },
-    get useUsageMetricsContext () {
-        return useUsageMetricsContext;
-    }
-});
-const _jsxruntime = require("react/jsx-runtime");
-const _client = require("@perses-dev/client");
-const _react = require("react");
-const UsageMetricsContext = /*#__PURE__*/ (0, _react.createContext)(undefined);
-const useUsageMetricsContext = ()=>{
-    return (0, _react.useContext)(UsageMetricsContext);
-};
-const useUsageMetrics = ()=>{
-    const ctx = useUsageMetricsContext();
-    return {
-        markQuery: (definition, newState)=>{
-            if (ctx === undefined) {
-                return;
-            }
-            const definitionKey = JSON.stringify(definition);
-            if (ctx.pendingQueries.has(definitionKey) && newState === 'pending') {
-                // Never allow transitions back to pending, to avoid re-sending stats on a re-render.
-                return;
-            }
-            if (ctx.pendingQueries.get(definitionKey) !== newState) {
-                ctx.pendingQueries.set(definitionKey, newState);
-                if (newState === 'error') {
-                    ctx.renderErrorCount += 1;
-                }
-                const allDone = [
-                    ...ctx.pendingQueries.values()
-                ].every((p)=>p !== 'pending');
-                if (ctx.renderDurationMs === 0 && allDone) {
-                    ctx.renderDurationMs = Date.now() - ctx.startRenderTime;
-                    submitMetrics(ctx);
-                }
-            }
-        }
-    };
-};
-const submitMetrics = async (stats)=>{
-    await stats.fetchFn(`${stats.apiPrefix ?? ''}/api/v1/view`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json'
-        },
-        body: JSON.stringify({
-            project: stats.project,
-            dashboard: stats.dashboard,
-            render_time: stats.renderDurationMs / 1000,
-            render_errors: stats.renderErrorCount
-        })
-    });
-};
-const UsageMetricsProvider = ({ apiPrefix, project, dashboard, children })=>{
-    const { fetch } = (0, _client.useFetch)();
-    const ctx = {
-        project: project,
-        dashboard: dashboard,
-        renderErrorCount: 0,
-        startRenderTime: Date.now(),
-        renderDurationMs: 0,
-        pendingQueries: new Map(),
-        apiPrefix,
-        fetchFn: fetch
-    };
-    return /*#__PURE__*/ (0, _jsxruntime.jsx)(UsageMetricsContext.Provider, {
-        value: ctx,
-        children: children
-    });
-};

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

@@ -1,101 +0,0 @@
-// 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 _utils = require("./utils");
-const _variables = require("./variables");
-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
-    };
-}

package/dist/cjs/runtime/annotations.js

@@ -1,148 +0,0 @@
-// 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 ANNOTATION_KEY () {
-        return ANNOTATION_KEY;
-    },
-    get useAnnotationData () {
-        return useAnnotationData;
-    },
-    get useAnnotations () {
-        return useAnnotations;
-    }
-});
-const _reactquery = require("@tanstack/react-query");
-const _datasources = require("./datasources");
-const _pluginregistry = require("./plugin-registry");
-const _TimeRangeProvider = require("./TimeRangeProvider");
-const _utils = require("./utils");
-const _variables = require("./variables");
-const ANNOTATION_KEY = 'Annotation';
-function useAnnotationContext() {
-    const { absoluteTimeRange } = (0, _TimeRangeProvider.useTimeRange)();
-    const variableState = (0, _variables.useAllVariableValues)();
-    const datasourceStore = (0, _datasources.useDatasourceStore)();
-    return {
-        variableState,
-        datasourceStore,
-        absoluteTimeRange
-    };
-}
-function getQueryOptions({ plugin, definition, context }) {
-    const { variableState, absoluteTimeRange } = context;
-    const dependencies = plugin?.dependsOn ? plugin.dependsOn(definition.plugin.spec, context) : {};
-    const variableDependencies = dependencies?.variables;
-    const filteredVariableState = (0, _utils.filterVariableStateMap)(variableState, variableDependencies);
-    const variablesValueKey = (0, _utils.getVariableValuesKey)(filteredVariableState);
-    const queryKey = [
-        ANNOTATION_KEY,
-        definition,
-        absoluteTimeRange,
-        variablesValueKey
-    ];
-    let waitToLoad = false;
-    if (variableDependencies) {
-        waitToLoad = variableDependencies.some((v)=>variableState[v]?.loading);
-    }
-    const queryEnabled = plugin !== undefined && !waitToLoad;
-    return {
-        queryKey,
-        queryEnabled
-    };
-}
-function useAnnotations(definitions) {
-    const { getPlugin } = (0, _pluginregistry.usePluginRegistry)();
-    const context = useAnnotationContext();
-    const pluginLoaderResponse = (0, _pluginregistry.usePlugins)('Annotation', definitions.map((d)=>({
-            kind: d.plugin.kind
-        })));
-    // useQueries() handles data fetching from query plugins
-    return (0, _reactquery.useQueries)({
-        queries: definitions.map((definition, idx)=>{
-            const plugin = pluginLoaderResponse[idx]?.data;
-            const { queryEnabled, queryKey } = getQueryOptions({
-                context,
-                definition,
-                plugin
-            });
-            const annotationKind = definition?.plugin?.kind;
-            return {
-                enabled: queryEnabled,
-                queryKey: queryKey,
-                refetchOnMount: false,
-                refetchOnWindowFocus: false,
-                refetchOnReconnect: false,
-                staleTime: Infinity,
-                queryFn: async ({ signal })=>{
-                    const plugin = await getPlugin({
-                        kind: ANNOTATION_KEY,
-                        name: annotationKind
-                    });
-                    const data = await plugin.getAnnotationData(definition.plugin.spec, context, signal);
-                    return data;
-                }
-            };
-        })
-    });
-}
-function useAnnotationData(spec) {
-    const { data: annotationPlugin } = (0, _pluginregistry.usePlugin)('Annotation', spec.plugin.kind);
-    const datasourceStore = (0, _datasources.useDatasourceStore)();
-    const allVariables = (0, _variables.useAllVariableValues)();
-    const { absoluteTimeRange: timeRange } = (0, _TimeRangeProvider.useTimeRange)();
-    const variablePluginCtx = {
-        absoluteTimeRange: timeRange,
-        datasourceStore,
-        variableState: allVariables
-    };
-    let dependsOnVariables = Object.keys(allVariables); // Default to all variables
-    if (annotationPlugin?.dependsOn) {
-        const dependencies = annotationPlugin.dependsOn(spec.plugin.spec, variablePluginCtx);
-        dependsOnVariables = dependencies.variables ? dependencies.variables : dependsOnVariables;
-    }
-    const variables = (0, _variables.useAllVariableValues)(dependsOnVariables);
-    let waitToLoad = false;
-    if (dependsOnVariables) {
-        waitToLoad = dependsOnVariables.some((v)=>variables[v]?.loading);
-    }
-    const variablesValueKey = (0, _utils.getVariableValuesKey)(variables);
-    return (0, _reactquery.useQuery)({
-        queryKey: [
-            'annotation',
-            spec,
-            timeRange,
-            variablesValueKey
-        ],
-        queryFn: async ({ signal })=>{
-            const resp = await annotationPlugin?.getAnnotationData(spec.plugin.spec, {
-                ...variablePluginCtx,
-                variableState: variables
-            }, signal);
-            if (!resp?.length) {
-                return [];
-            }
-            return resp;
-        },
-        enabled: !!annotationPlugin || waitToLoad
-    });
-}