@perses-dev/dashboards 0.0.0-snapshot-time-range-height-80d08fc

package/dist/cjs/context/DashboardProvider/panel-group-slice.js

@@ -0,0 +1,113 @@
+// Copyright 2022 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: all[name]
+    });
+}
+_export(exports, {
+    createPanelGroupSlice: ()=>createPanelGroupSlice,
+    convertLayoutsToPanelGroups: ()=>convertLayoutsToPanelGroups,
+    createEmptyPanelGroup: ()=>createEmptyPanelGroup,
+    addPanelGroup: ()=>addPanelGroup
+});
+const _core = require("@perses-dev/core");
+const _common = require("./common");
+function createPanelGroupSlice(layouts) {
+    const { panelGroups , panelGroupOrder  } = convertLayoutsToPanelGroups(layouts);
+    // Return the state creator function for Zustand
+    return (set)=>({
+            panelGroups,
+            panelGroupOrder,
+            swapPanelGroups (x, y) {
+                set((state)=>{
+                    if (x < 0 || x >= state.panelGroupOrder.length || y < 0 || y >= state.panelGroupOrder.length) {
+                        throw new Error('index out of bound');
+                    }
+                    const xPanelGroup = state.panelGroupOrder[x];
+                    const yPanelGroup = state.panelGroupOrder[y];
+                    if (xPanelGroup === undefined || yPanelGroup === undefined) {
+                        throw new Error('panel group is undefined');
+                    }
+                    // assign yPanelGroup to layouts[x] and assign xGroup to layouts[y], swapping two panel groups
+                    [state.panelGroupOrder[x], state.panelGroupOrder[y]] = [
+                        yPanelGroup,
+                        xPanelGroup
+                    ];
+                });
+            },
+            updatePanelGroupLayouts (panelGroupId, itemLayouts) {
+                set((state)=>{
+                    const group = state.panelGroups[panelGroupId];
+                    if (group === undefined) {
+                        throw new Error(`Cannot find panel group ${panelGroupId}`);
+                    }
+                    group.itemLayouts = itemLayouts;
+                });
+            }
+        });
+}
+function convertLayoutsToPanelGroups(layouts) {
+    // Convert the initial layouts from the JSON
+    const panelGroups = {};
+    const panelGroupIdOrder = [];
+    for (const layout of layouts){
+        var ref, ref1, ref2;
+        const itemLayouts = [];
+        const itemPanelKeys = {};
+        // Split layout information from panel keys to make it easier to update just layouts on move/resize of panels
+        for (const item of layout.spec.items){
+            const panelGroupLayoutId = (0, _common.generateId)().toString();
+            itemLayouts.push({
+                i: panelGroupLayoutId,
+                w: item.width,
+                h: item.height,
+                x: item.x,
+                y: item.y
+            });
+            itemPanelKeys[panelGroupLayoutId] = (0, _core.getPanelKeyFromRef)(item.content);
+        }
+        // Create the panel group and keep track of the ID order
+        const panelGroupId = (0, _common.generateId)();
+        panelGroups[panelGroupId] = {
+            id: panelGroupId,
+            isCollapsed: ((ref = layout.spec.display) === null || ref === void 0 ? void 0 : (ref1 = ref.collapse) === null || ref1 === void 0 ? void 0 : ref1.open) === false,
+            title: (ref2 = layout.spec.display) === null || ref2 === void 0 ? void 0 : ref2.title,
+            itemLayouts,
+            itemPanelKeys
+        };
+        panelGroupIdOrder.push(panelGroupId);
+    }
+    return {
+        panelGroups,
+        panelGroupOrder: panelGroupIdOrder
+    };
+}
+function createEmptyPanelGroup() {
+    return {
+        id: (0, _common.generateId)(),
+        title: undefined,
+        isCollapsed: false,
+        itemLayouts: [],
+        itemPanelKeys: {}
+    };
+}
+function addPanelGroup(draft, newGroup) {
+    draft.panelGroups[newGroup.id] = newGroup;
+    draft.panelGroupOrder.unshift(newGroup.id);
+}

package/dist/cjs/context/DashboardProvider/panel-slice.js

@@ -0,0 +1,25 @@
+// Copyright 2022 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, "createPanelSlice", {
+    enumerable: true,
+    get: ()=>createPanelSlice
+});
+function createPanelSlice(panels) {
+    return ()=>({
+            panels
+        });
+}

package/dist/cjs/context/DatasourceStoreProvider.js

@@ -0,0 +1,170 @@
+// Copyright 2022 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, "DatasourceStoreProvider", {
+    enumerable: true,
+    get: ()=>DatasourceStoreProvider
+});
+const _jsxRuntime = require("react/jsx-runtime");
+const _react = require("react");
+const _core = require("@perses-dev/core");
+const _pluginSystem = require("@perses-dev/plugin-system");
+function DatasourceStoreProvider(props) {
+    const { dashboardResource , datasourceApi , children  } = props;
+    const { project  } = dashboardResource.metadata;
+    const { getPlugin , listPluginMetadata  } = (0, _pluginSystem.usePluginRegistry)();
+    const findDatasource = (0, _core.useEvent)(async (selector)=>{
+        // Try to find it in dashboard spec
+        const { datasources  } = dashboardResource.spec;
+        const dashboardDatasource = findDashboardDatasource(datasources, selector);
+        if (dashboardDatasource !== undefined) {
+            return {
+                spec: dashboardDatasource,
+                proxyUrl: undefined
+            };
+        }
+        // Try to find it at the project level as a Datasource resource
+        const datasource = await datasourceApi.getDatasource(project, selector);
+        if (datasource !== undefined) {
+            return {
+                spec: datasource.resource.spec,
+                proxyUrl: datasource.proxyUrl
+            };
+        }
+        // Try to find it at the global level as a GlobalDatasource resource
+        const globalDatasource = await datasourceApi.getGlobalDatasource(selector);
+        if (globalDatasource !== undefined) {
+            return {
+                spec: globalDatasource.resource.spec,
+                proxyUrl: globalDatasource.proxyUrl
+            };
+        }
+        throw new Error(`No datasource found for kind '${selector.kind}' and name '${selector.name}'`);
+    });
+    // Gets a datasource spec for a given selector
+    const getDatasource = (0, _react.useCallback)(async (selector)=>{
+        const { spec  } = await findDatasource(selector);
+        return spec;
+    }, [
+        findDatasource
+    ]);
+    // Given a Datasource selector, finds the spec for it and then uses its corresponding plugin the create a client
+    const getDatasourceClient = (0, _react.useCallback)(async function getClient(selector) {
+        const { kind  } = selector;
+        const [{ spec , proxyUrl  }, plugin] = await Promise.all([
+            findDatasource(selector),
+            getPlugin('Datasource', kind)
+        ]);
+        return plugin.createClient(spec.plugin.spec, {
+            proxyUrl
+        });
+    }, [
+        findDatasource,
+        getPlugin
+    ]);
+    const listDatasourceMetadata = (0, _core.useEvent)(async (datasourcePluginKind)=>{
+        const [pluginMetadata, datasources, globalDatasources] = await Promise.all([
+            listPluginMetadata('Datasource'),
+            datasourceApi.listDatasources(project, datasourcePluginKind),
+            datasourceApi.listGlobalDatasources(datasourcePluginKind)
+        ]);
+        // Find the metadata for the plugin type they asked for so we can use it for the name of the default datasource
+        const datasourcePluginMetadata = pluginMetadata.find((metadata)=>metadata.kind === datasourcePluginKind);
+        if (datasourcePluginMetadata === undefined) {
+            throw new Error(`Could not find a Datasource plugin with kind '${datasourcePluginKind}'`);
+        }
+        // Get helper for de-duping results properly
+        const { results , addResult  } = buildListDatasourceMetadataResults(datasourcePluginMetadata.display.name);
+        // Start with dashboard datasources that have highest precedence
+        if (dashboardResource.spec.datasources !== undefined) {
+            for(const selectorName in dashboardResource.spec.datasources){
+                const spec = dashboardResource.spec.datasources[selectorName];
+                if (spec === undefined || spec.plugin.kind !== datasourcePluginKind) continue;
+                addResult(spec, selectorName);
+            }
+        }
+        // Now look at project-level datasources
+        for (const datasource of datasources){
+            const selectorName1 = datasource.metadata.name;
+            addResult(datasource.spec, selectorName1);
+        }
+        // And finally global datasources
+        for (const globalDatasource of globalDatasources){
+            const selectorName2 = globalDatasource.metadata.name;
+            addResult(globalDatasource.spec, selectorName2);
+        }
+        return results;
+    });
+    const ctxValue = (0, _react.useMemo)(()=>({
+            getDatasource,
+            getDatasourceClient,
+            listDatasourceMetadata
+        }), [
+        getDatasource,
+        getDatasourceClient,
+        listDatasourceMetadata
+    ]);
+    return /*#__PURE__*/ (0, _jsxRuntime.jsx)(_pluginSystem.DatasourceStoreContext.Provider, {
+        value: ctxValue,
+        children: children
+    });
+}
+// Helper to find a datasource in the list embedded in a dashboard spec
+function findDashboardDatasource(dashboardDatasources, selector) {
+    if (dashboardDatasources === undefined) return undefined;
+    // If using a name in the selector...
+    if (selector.name !== undefined) {
+        const named = dashboardDatasources[selector.name];
+        if (named === undefined) return undefined;
+        return named.plugin.kind === selector.kind ? named : undefined;
+    }
+    // If only using a kind, try to find one with that kind that is the default
+    return Object.values(dashboardDatasources).find((ds)=>ds.plugin.kind === selector.kind && ds.default === true);
+}
+// Helper for building a list of DatasourceMetadata results that will take care of de-duping already used selectors
+function buildListDatasourceMetadataResults(pluginDisplayName) {
+    const results = [];
+    const usedNames = new Set();
+    let defaultAdded = false;
+    const addResult = (spec, selectorName)=>{
+        var ref;
+        // If we haven't added a default yet and this is a default, add default option to the beginning of the results
+        if (spec.default && defaultAdded === false) {
+            results.unshift({
+                name: `Default ${pluginDisplayName}`,
+                selector: {
+                    kind: spec.plugin.kind
+                }
+            });
+            defaultAdded = true;
+        }
+        // If we already have a datasource with this selector name, ignore it, otherwise add to end of list
+        if (usedNames.has(selectorName)) return;
+        var ref1;
+        results.push({
+            name: (ref1 = (ref = spec.display) === null || ref === void 0 ? void 0 : ref.name) !== null && ref1 !== void 0 ? ref1 : selectorName,
+            selector: {
+                kind: spec.plugin.kind,
+                name: selectorName
+            }
+        });
+        usedNames.add(selectorName);
+    };
+    return {
+        results,
+        addResult
+    };
+}

package/dist/cjs/context/TemplateVariableProvider/TemplateVariableProvider.js

@@ -0,0 +1,228 @@
+// Copyright 2022 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: all[name]
+    });
+}
+_export(exports, {
+    useTemplateVariableValues: ()=>useTemplateVariableValues,
+    useTemplateVariable: ()=>useTemplateVariable,
+    useTemplateVariableActions: ()=>useTemplateVariableActions,
+    useTemplateVariableDefinitions: ()=>useTemplateVariableDefinitions,
+    useTemplateVariableStore: ()=>useTemplateVariableStore,
+    TemplateVariableProvider: ()=>TemplateVariableProvider
+});
+const _jsxRuntime = require("react/jsx-runtime");
+const _react = require("react");
+const _zustand = require("zustand");
+const _immer = require("zustand/middleware/immer");
+const _middleware = require("zustand/middleware");
+const _pluginSystem = require("@perses-dev/plugin-system");
+const _queryParams = require("./query-params");
+const TemplateVariableStoreContext = /*#__PURE__*/ (0, _react.createContext)(undefined);
+function useTemplateVariableStoreCtx() {
+    const context = (0, _react.useContext)(TemplateVariableStoreContext);
+    if (!context) {
+        throw new Error('TemplateVariableStoreContext not initialized');
+    }
+    return context;
+}
+function useTemplateVariableValues(variableNames) {
+    const store = useTemplateVariableStoreCtx();
+    const state = (0, _zustand.useStore)(store, (s)=>{
+        const names = variableNames !== null && variableNames !== void 0 ? variableNames : Object.keys(s.variableState);
+        const vars = {};
+        names.forEach((name)=>{
+            const varState = s.variableState[name];
+            if (!varState) {
+                return;
+            }
+            vars[name] = varState;
+        });
+        return vars;
+    }, (left, right)=>{
+        return JSON.stringify(left) === JSON.stringify(right);
+    });
+    return state;
+}
+function useTemplateVariable(name) {
+    const store = useTemplateVariableStoreCtx();
+    return (0, _zustand.useStore)(store, (s)=>{
+        const variableState = s.variableState[name];
+        const definition = s.variableDefinitions.find((v)=>v.spec.name === name);
+        return {
+            state: variableState,
+            definition
+        };
+    });
+}
+function useTemplateVariableActions() {
+    const store = useTemplateVariableStoreCtx();
+    return (0, _zustand.useStore)(store, (s)=>{
+        return {
+            setVariableValue: s.setVariableValue,
+            setVariableLoading: s.setVariableLoading,
+            setVariableOptions: s.setVariableOptions,
+            setVariableDefinitions: s.setVariableDefinitions
+        };
+    });
+}
+function useTemplateVariableDefinitions() {
+    const store = useTemplateVariableStoreCtx();
+    return (0, _zustand.useStore)(store, (s)=>s.variableDefinitions);
+}
+function useTemplateVariableStore() {
+    const store = useTemplateVariableStoreCtx();
+    return (0, _zustand.useStore)(store);
+}
+function PluginProvider({ children  }) {
+    const originalValues = useTemplateVariableValues();
+    const values = (0, _react.useMemo)(()=>{
+        const contextValues = {};
+        // This will loop through all the current variables values
+        // and update any variables that have ALL_VALUE as their current value
+        // to include all options.
+        Object.keys(originalValues).forEach((name)=>{
+            const v = {
+                ...originalValues[name]
+            };
+            if (v.value === _pluginSystem.DEFAULT_ALL_VALUE) {
+                var ref;
+                var ref1;
+                v.value = (ref1 = (ref = v.options) === null || ref === void 0 ? void 0 : ref.map((o)=>o.value)) !== null && ref1 !== void 0 ? ref1 : null;
+            }
+            contextValues[name] = v;
+        });
+        return contextValues;
+    }, [
+        originalValues
+    ]);
+    return /*#__PURE__*/ (0, _jsxRuntime.jsx)(_pluginSystem.TemplateVariableContext.Provider, {
+        value: {
+            state: values
+        },
+        children: children
+    });
+}
+function createTemplateVariableSrvStore({ initialVariableDefinitions =[] , queryParams  }) {
+    const initialParams = (0, _queryParams.getInitalValuesFromQueryParameters)(queryParams ? queryParams[0] : {});
+    const store = (0, _zustand.createStore)()((0, _middleware.devtools)((0, _immer.immer)((set)=>({
+            variableState: hydrateTemplateVariableStates(initialVariableDefinitions, initialParams),
+            variableDefinitions: initialVariableDefinitions,
+            setVariableDefinitions (definitions) {
+                set((state)=>{
+                    state.variableDefinitions = definitions;
+                    state.variableState = hydrateTemplateVariableStates(definitions, initialParams);
+                });
+            },
+            setVariableOptions (name, options) {
+                set((state)=>{
+                    const varState = state.variableState[name];
+                    if (!varState) {
+                        return;
+                    }
+                    varState.options = options;
+                });
+            },
+            setVariableLoading (name, loading) {
+                set((state)=>{
+                    const varState = state.variableState[name];
+                    if (!varState) {
+                        return;
+                    }
+                    varState.loading = loading;
+                });
+            },
+            setVariableValue: (name, value)=>set((state)=>{
+                    let val = value;
+                    const varState = state.variableState[name];
+                    if (!varState) {
+                        return;
+                    }
+                    // Make sure there is only one all value
+                    if (Array.isArray(val) && val.includes(_pluginSystem.DEFAULT_ALL_VALUE)) {
+                        if (val.at(-1) === _pluginSystem.DEFAULT_ALL_VALUE) {
+                            val = _pluginSystem.DEFAULT_ALL_VALUE;
+                        } else {
+                            val = val.filter((v)=>v !== _pluginSystem.DEFAULT_ALL_VALUE);
+                        }
+                    }
+                    if (queryParams) {
+                        const setQueryParams = queryParams[1];
+                        setQueryParams({
+                            [(0, _queryParams.getURLQueryParamName)(name)]: val
+                        });
+                    }
+                    varState.value = val;
+                })
+        }))));
+    return store;
+}
+function TemplateVariableProvider({ children , initialVariableDefinitions =[]  }) {
+    const queryParams = (0, _queryParams.useVariableQueryParams)(initialVariableDefinitions);
+    const [store] = (0, _react.useState)(createTemplateVariableSrvStore({
+        initialVariableDefinitions,
+        queryParams
+    }));
+    return /*#__PURE__*/ (0, _jsxRuntime.jsx)(TemplateVariableStoreContext.Provider, {
+        value: store,
+        children: /*#__PURE__*/ (0, _jsxRuntime.jsx)(PluginProvider, {
+            children: children
+        })
+    });
+}
+/** Helpers */ function hydrateTemplateVariableState(definition, initialValue) {
+    const v = definition;
+    var ref;
+    const varState = {
+        value: (ref = initialValue !== null && initialValue !== void 0 ? initialValue : v.spec.default_value) !== null && ref !== void 0 ? ref : null,
+        loading: false
+    };
+    switch(v.kind){
+        case 'TextVariable':
+            varState.value = initialValue !== null && initialValue !== void 0 ? initialValue : v.spec.value;
+            break;
+        case 'ListVariable':
+            varState.options = [];
+            if (varState.options.length > 0 && !varState.value) {
+                var ref1;
+                var ref2;
+                const firstOptionValue = (ref2 = (ref1 = varState.options[0]) === null || ref1 === void 0 ? void 0 : ref1.value) !== null && ref2 !== void 0 ? ref2 : null;
+                if (firstOptionValue !== null) {
+                    varState.value = v.spec.allow_multiple ? [
+                        firstOptionValue
+                    ] : firstOptionValue;
+                }
+            }
+            break;
+        default:
+            break;
+    }
+    return varState;
+}
+function hydrateTemplateVariableStates(definitions, initialValues) {
+    const state = {};
+    definitions.forEach((v)=>{
+        const name = v.spec.name;
+        const param = initialValues[name];
+        const initialValue = param ? param : null;
+        state[name] = hydrateTemplateVariableState(v, initialValue);
+    });
+    return state;
+}

package/dist/cjs/context/TemplateVariableProvider/index.js

@@ -0,0 +1,28 @@
+// Copyright 2022 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
+});
+_exportStar(require("./TemplateVariableProvider"), exports);
+function _exportStar(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) Object.defineProperty(to, k, {
+            enumerable: true,
+            get: function() {
+                return from[k];
+            }
+        });
+    });
+    return from;
+}

package/dist/cjs/context/TemplateVariableProvider/query-params.js

@@ -0,0 +1,81 @@
+// Copyright 2022 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: all[name]
+    });
+}
+_export(exports, {
+    getURLQueryParamName: ()=>getURLQueryParamName,
+    encodeVariableValue: ()=>encodeVariableValue,
+    decodeVariableValue: ()=>decodeVariableValue,
+    useVariableQueryParams: ()=>useVariableQueryParams,
+    getInitalValuesFromQueryParameters: ()=>getInitalValuesFromQueryParameters
+});
+const _useQueryParams = require("use-query-params");
+const variableQueryParameterPrefix = 'var-';
+function getURLQueryParamName(name) {
+    return `${variableQueryParameterPrefix}${name}`;
+}
+function encodeVariableValue(value) {
+    if (Array.isArray(value)) {
+        return value.join(',');
+    }
+    return value;
+}
+function decodeVariableValue(value) {
+    if (!value) {
+        return null;
+    }
+    const values = value.split(',');
+    if (values.length === 1) {
+        return values[0];
+    }
+    return values;
+}
+const VariableValueParam = {
+    encode: encodeVariableValue,
+    decode: (v)=>{
+        if (typeof v === 'string') {
+            return decodeVariableValue(v);
+        }
+        return '';
+    }
+};
+function useVariableQueryParams(defs) {
+    const config = {};
+    defs.forEach((def)=>{
+        const name = getURLQueryParamName(def.spec.name);
+        config[name] = VariableValueParam;
+    });
+    return (0, _useQueryParams.useQueryParams)(config, {
+        updateType: 'replaceIn'
+    });
+}
+function getInitalValuesFromQueryParameters(queryParamValues) {
+    const values = {};
+    Object.keys(queryParamValues).forEach((key)=>{
+        const value = queryParamValues[key];
+        if (!value) {
+            return;
+        }
+        const name = key.replace(variableQueryParameterPrefix, '');
+        values[name] = value;
+    });
+    return values;
+}