@perses-dev/dashboards 0.0.0-snapshot-panel-extra-content-2-2767e21 → 0.0.0-snapshot-scatter-chart-embed-8efdfab

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

@@ -21,25 +21,46 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    useTemplateVariableValues: ()=>useTemplateVariableValues,
-    useTemplateVariable: ()=>useTemplateVariable,
-    useTemplateVariableActions: ()=>useTemplateVariableActions,
-    useTemplateVariableDefinitions: ()=>useTemplateVariableDefinitions,
-    useTemplateVariableStore: ()=>useTemplateVariableStore,
-    TemplateVariableProvider: ()=>TemplateVariableProvider
+    useTemplateVariableStoreCtx: function() {
+        return useTemplateVariableStoreCtx;
+    },
+    useTemplateVariableValues: function() {
+        return useTemplateVariableValues;
+    },
+    useTemplateVariable: function() {
+        return useTemplateVariable;
+    },
+    useTemplateVariableActions: function() {
+        return useTemplateVariableActions;
+    },
+    useTemplateVariableDefinitions: function() {
+        return useTemplateVariableDefinitions;
+    },
+    useTemplateExternalVariableDefinitions: function() {
+        return useTemplateExternalVariableDefinitions;
+    },
+    useTemplateVariableStore: function() {
+        return useTemplateVariableStore;
+    },
+    TemplateVariableProvider: function() {
+        return TemplateVariableProvider;
+    },
+    TemplateVariableProviderWithQueryParams: function() {
+        return TemplateVariableProviderWithQueryParams;
+    }
 });
-const _jsxRuntime = require("react/jsx-runtime");
+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 _immer1 = /*#__PURE__*/ _interopRequireDefault(require("immer"));
-const _pluginSystem = require("@perses-dev/plugin-system");
+const _immer1 = /*#__PURE__*/ _interop_require_default(require("immer"));
+const _pluginsystem = require("@perses-dev/plugin-system");
 const _core = require("@perses-dev/core");
 const _utils = require("./utils");
 const _hydrationUtils = require("./hydrationUtils");
-const _queryParams = require("./query-params");
-function _interopRequireDefault(obj) {
+const _queryparams = require("./query-params");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
@@ -54,29 +75,51 @@ function useTemplateVariableStoreCtx() {
 }
 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);
+    return (0, _zustand.useStore)(store, (s)=>{
         const vars = {};
+        // Collect values of local variables, from the variable state
+        const names = variableNames !== null && variableNames !== void 0 ? variableNames : s.variableDefinitions.map((value)=>value.spec.name);
         names.forEach((name)=>{
-            const varState = s.variableState[name];
-            if (!varState) {
+            const varState = s.variableState.get({
+                name
+            });
+            if (!varState || varState.overridden) {
                 return;
             }
             vars[name] = varState;
         });
+        // Collect values of external variables, from the variable state
+        s.externalVariableDefinitions.forEach((d)=>{
+            const source = d.source;
+            d.definitions.forEach((value)=>{
+                const name = value.spec.name;
+                const varState = s.variableState.get({
+                    name,
+                    source
+                });
+                if (!varState || varState.overridden) {
+                    return;
+                }
+                vars[name] = varState;
+            });
+        });
         return vars;
     }, (left, right)=>{
         return JSON.stringify(left) === JSON.stringify(right);
     });
-    return state;
 }
-function useTemplateVariable(name) {
+function useTemplateVariable(name, source) {
     const store = useTemplateVariableStoreCtx();
     return (0, _zustand.useStore)(store, (s)=>{
-        const variableState = s.variableState[name];
-        const definition = s.variableDefinitions.find((v)=>v.spec.name === name);
+        var _s_externalVariableDefinitions_find;
+        const state = s.variableState.get({
+            name,
+            source
+        });
+        const definitions = source ? (_s_externalVariableDefinitions_find = s.externalVariableDefinitions.find((v)=>v.source === source)) === null || _s_externalVariableDefinitions_find === void 0 ? void 0 : _s_externalVariableDefinitions_find.definitions : s.variableDefinitions;
+        const definition = (definitions || []).find((v)=>v.spec.name === name);
         return {
-            state: variableState,
+            state,
             definition
         };
     });
@@ -98,13 +141,19 @@ function useTemplateVariableDefinitions() {
     const store = useTemplateVariableStoreCtx();
     return (0, _zustand.useStore)(store, (s)=>s.variableDefinitions);
 }
+function useTemplateExternalVariableDefinitions() {
+    const store = useTemplateVariableStoreCtx();
+    return (0, _zustand.useStore)(store, (s)=>s.externalVariableDefinitions);
+}
 function useTemplateVariableStore() {
     const store = useTemplateVariableStoreCtx();
     return (0, _zustand.useStore)(store);
 }
-function PluginProvider({ children  }) {
+function PluginProvider({ children , builtinVariables  }) {
     const originalValues = useTemplateVariableValues();
     const definitions = useTemplateVariableDefinitions();
+    const externalDefinitions = useTemplateExternalVariableDefinitions();
+    const { absoluteTimeRange  } = (0, _pluginsystem.useTimeRange)();
     const values = (0, _react.useMemo)(()=>{
         const contextValues = {};
         // This will loop through all the current variables values
@@ -115,14 +164,14 @@ function PluginProvider({ children  }) {
                 ...originalValues[name]
             };
             if (v.value === _core.DEFAULT_ALL_VALUE) {
-                const definition = definitions.find((d)=>d.spec.name === name);
+                const definition = (0, _utils.findVariableDefinitionByName)(name, definitions, externalDefinitions);
                 // If the variable is a list variable and has a custom all value, then use that value instead
-                if ((definition === null || definition === void 0 ? void 0 : definition.kind) === 'ListVariable' && definition.spec.custom_all_value) {
-                    v.value = definition.spec.custom_all_value;
+                if ((definition === null || definition === void 0 ? void 0 : definition.kind) === 'ListVariable' && definition.spec.customAllValue) {
+                    v.value = definition.spec.customAllValue;
                 } else {
-                    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;
+                    var _v_options;
+                    var _v_options_map;
+                    v.value = (_v_options_map = (_v_options = v.options) === null || _v_options === void 0 ? void 0 : _v_options.map((o)=>o.value)) !== null && _v_options_map !== void 0 ? _v_options_map : null;
                 }
             }
             contextValues[name] = v;
@@ -130,49 +179,133 @@ function PluginProvider({ children  }) {
         return contextValues;
     }, [
         originalValues,
-        definitions
+        definitions,
+        externalDefinitions
     ]);
-    return /*#__PURE__*/ (0, _jsxRuntime.jsx)(_pluginSystem.TemplateVariableContext.Provider, {
+    const allBuiltinVariables = [
+        {
+            kind: 'BuiltinVariable',
+            spec: {
+                name: '__from',
+                value: ()=>absoluteTimeRange.start.valueOf().toString(),
+                source: 'Dashboard',
+                display: {
+                    name: '__from',
+                    description: 'Start time of the current time range in unix millisecond epoch',
+                    hidden: true
+                }
+            }
+        },
+        {
+            kind: 'BuiltinVariable',
+            spec: {
+                name: '__to',
+                value: ()=>absoluteTimeRange.end.valueOf().toString(),
+                source: 'Dashboard',
+                display: {
+                    name: '__to',
+                    description: 'End time of the current time range in unix millisecond epoch',
+                    hidden: true
+                }
+            }
+        },
+        {
+            kind: 'BuiltinVariable',
+            spec: {
+                name: '__range',
+                value: ()=>(0, _core.formatDuration)((0, _core.intervalToPrometheusDuration)(absoluteTimeRange)),
+                source: 'Dashboard',
+                display: {
+                    name: '__range',
+                    description: 'The range for the current dashboard in human readable format',
+                    hidden: true
+                }
+            }
+        },
+        {
+            kind: 'BuiltinVariable',
+            spec: {
+                name: '__range_s',
+                value: ()=>((absoluteTimeRange.end.valueOf() - absoluteTimeRange.start.valueOf()) / 1000).toString(),
+                source: 'Dashboard',
+                display: {
+                    name: '__range_s',
+                    description: 'The range for the current dashboard in second',
+                    hidden: true
+                }
+            }
+        },
+        {
+            kind: 'BuiltinVariable',
+            spec: {
+                name: '__range_ms',
+                value: ()=>(absoluteTimeRange.end.valueOf() - absoluteTimeRange.start.valueOf()).toString(),
+                source: 'Dashboard',
+                display: {
+                    name: '__range_ms',
+                    description: 'The range for the current dashboard in millisecond',
+                    hidden: true
+                }
+            }
+        }
+    ];
+    builtinVariables === null || builtinVariables === void 0 ? void 0 : builtinVariables.forEach((def)=>allBuiltinVariables.push(def));
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_pluginsystem.BuiltinVariableContext.Provider, {
         value: {
-            state: values
+            variables: allBuiltinVariables
         },
-        children: children
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_pluginsystem.TemplateVariableContext.Provider, {
+            value: {
+                state: values
+            },
+            children: children
+        })
     });
 }
-function createTemplateVariableSrvStore({ initialVariableDefinitions =[] , queryParams  }) {
-    const initialParams = (0, _queryParams.getInitalValuesFromQueryParameters)(queryParams ? queryParams[0] : {});
+function createTemplateVariableSrvStore({ initialVariableDefinitions =[] , externalVariableDefinitions =[] , queryParams  }) {
+    const initialParams = (0, _queryparams.getInitalValuesFromQueryParameters)(queryParams ? queryParams[0] : {});
     const store = (0, _zustand.createStore)()((0, _middleware.devtools)((0, _immer.immer)((set, get)=>{
         return {
-            variableState: (0, _hydrationUtils.hydrateTemplateVariableStates)(initialVariableDefinitions, initialParams),
+            variableState: (0, _hydrationUtils.hydrateTemplateVariableStates)(initialVariableDefinitions, initialParams, externalVariableDefinitions),
             variableDefinitions: initialVariableDefinitions,
+            externalVariableDefinitions: externalVariableDefinitions,
             setVariableDefinitions (definitions) {
                 set((state)=>{
                     state.variableDefinitions = definitions;
-                    state.variableState = (0, _hydrationUtils.hydrateTemplateVariableStates)(definitions, initialParams);
+                    state.variableState = (0, _hydrationUtils.hydrateTemplateVariableStates)(definitions, initialParams, externalVariableDefinitions);
                 }, false, '[Variables] setVariableDefinitions' // Used for action name in Redux devtools
                 );
             },
-            setVariableOptions (name, options) {
+            setVariableOptions (name, options, source) {
                 set((state)=>{
-                    const varState = state.variableState[name];
+                    const varState = state.variableState.get({
+                        name,
+                        source
+                    });
                     if (!varState) {
                         return;
                     }
                     varState.options = options;
                 }, false, '[Variables] setVariableOptions');
             },
-            setVariableLoading (name, loading) {
+            setVariableLoading (name, loading, source) {
                 set((state)=>{
-                    const varState = state.variableState[name];
+                    const varState = state.variableState.get({
+                        name,
+                        source
+                    });
                     if (!varState) {
                         return;
                     }
                     varState.loading = loading;
                 }, false, '[Variables] setVariableLoading');
             },
-            setVariableValue: (name, value)=>set((state)=>{
+            setVariableValue: (name, value, source)=>set((state)=>{
                     let val = value;
-                    const varState = state.variableState[name];
+                    const varState = state.variableState.get({
+                        name,
+                        source
+                    });
                     if (!varState) {
                         return;
                     }
@@ -187,7 +320,7 @@ function createTemplateVariableSrvStore({ initialVariableDefinitions =[] , query
                     if (queryParams) {
                         const setQueryParams = queryParams[1];
                         setQueryParams({
-                            [(0, _queryParams.getURLQueryParamName)(name)]: val
+                            [(0, _queryparams.getURLQueryParamName)(name)]: val
                         });
                     }
                     varState.value = val;
@@ -197,20 +330,25 @@ function createTemplateVariableSrvStore({ initialVariableDefinitions =[] , query
                 const variableState = get().variableState;
                 const updatedVariables = (0, _immer1.default)(variableDefinitions, (draft)=>{
                     draft.forEach((variable, index)=>{
+                        const name = variable.spec.name;
                         if (variable.kind === 'ListVariable') {
-                            const currentVariable = variableState[variable.spec.name];
+                            const currentVariable = variableState.get({
+                                name
+                            });
                             if ((currentVariable === null || currentVariable === void 0 ? void 0 : currentVariable.value) !== undefined) {
                                 draft[index] = {
                                     kind: 'ListVariable',
                                     spec: (0, _immer1.default)(variable.spec, (specDraft)=>{
-                                        specDraft.default_value = currentVariable.value;
+                                        specDraft.defaultValue = currentVariable.value;
                                     })
                                 };
                             }
                         } else if (variable.kind === 'TextVariable') {
-                            const currentVariable1 = variableState[variable.spec.name];
-                            const currentVariableValue = typeof (currentVariable1 === null || currentVariable1 === void 0 ? void 0 : currentVariable1.value) === 'string' ? currentVariable1.value : '';
-                            if ((currentVariable1 === null || currentVariable1 === void 0 ? void 0 : currentVariable1.value) !== undefined) {
+                            const currentVariable = variableState.get({
+                                name
+                            });
+                            const currentVariableValue = typeof (currentVariable === null || currentVariable === void 0 ? void 0 : currentVariable.value) === 'string' ? currentVariable.value : '';
+                            if ((currentVariable === null || currentVariable === void 0 ? void 0 : currentVariable.value) !== undefined) {
                                 draft[index] = {
                                     kind: 'TextVariable',
                                     spec: (0, _immer1.default)(variable.spec, (specDraft)=>{
@@ -233,15 +371,31 @@ function createTemplateVariableSrvStore({ initialVariableDefinitions =[] , query
     })));
     return store;
 }
-function TemplateVariableProvider({ children , initialVariableDefinitions =[]  }) {
-    const queryParams = (0, _queryParams.useVariableQueryParams)(initialVariableDefinitions);
+function TemplateVariableProvider({ children , initialVariableDefinitions =[] , externalVariableDefinitions =[] , builtinVariables =[]  }) {
+    const [store] = (0, _react.useState)(createTemplateVariableSrvStore({
+        initialVariableDefinitions,
+        externalVariableDefinitions
+    }));
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(TemplateVariableStoreContext.Provider, {
+        value: store,
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(PluginProvider, {
+            builtinVariables: builtinVariables,
+            children: children
+        })
+    });
+}
+function TemplateVariableProviderWithQueryParams({ children , initialVariableDefinitions =[] , externalVariableDefinitions =[] , builtinVariables =[]  }) {
+    const allVariableDefs = (0, _utils.mergeVariableDefinitions)(initialVariableDefinitions, externalVariableDefinitions);
+    const queryParams = (0, _queryparams.useVariableQueryParams)(allVariableDefs);
     const [store] = (0, _react.useState)(createTemplateVariableSrvStore({
         initialVariableDefinitions,
+        externalVariableDefinitions,
         queryParams
     }));
-    return /*#__PURE__*/ (0, _jsxRuntime.jsx)(TemplateVariableStoreContext.Provider, {
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(TemplateVariableStoreContext.Provider, {
         value: store,
-        children: /*#__PURE__*/ (0, _jsxRuntime.jsx)(PluginProvider, {
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(PluginProvider, {
+            builtinVariables: builtinVariables,
             children: children
         })
     });

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

@@ -16,14 +16,19 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "hydrateTemplateVariableStates", {
     enumerable: true,
-    get: ()=>hydrateTemplateVariableStates
+    get: function() {
+        return hydrateTemplateVariableStates;
+    }
 });
 const _core = require("@perses-dev/core");
+const _pluginsystem = require("@perses-dev/plugin-system");
 // TODO: move to TemplateVariableProvider/utils.ts
 function hydrateTemplateVariableState(variable, initialValue) {
     const varState = {
         value: null,
-        loading: false
+        loading: false,
+        overriding: false,
+        overridden: false
     };
     switch(variable.kind){
         case 'TextVariable':
@@ -31,15 +36,15 @@ function hydrateTemplateVariableState(variable, initialValue) {
             break;
         case 'ListVariable':
             varState.options = [];
-            var ref;
-            varState.value = (ref = initialValue !== null && initialValue !== void 0 ? initialValue : variable.spec.default_value) !== null && ref !== void 0 ? ref : null;
-            // TODO: smarter fallbacks for default_value when allow_all_value is true
+            var _ref;
+            varState.value = (_ref = initialValue !== null && initialValue !== void 0 ? initialValue : variable.spec.defaultValue) !== null && _ref !== void 0 ? _ref : null;
+            // TODO: smarter fallbacks for defaultValue when allowAllValue is true
             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;
+                var _varState_options_;
+                var _varState_options__value;
+                const firstOptionValue = (_varState_options__value = (_varState_options_ = varState.options[0]) === null || _varState_options_ === void 0 ? void 0 : _varState_options_.value) !== null && _varState_options__value !== void 0 ? _varState_options__value : null;
                 if (firstOptionValue !== null) {
-                    varState.value = variable.spec.allow_multiple ? [
+                    varState.value = variable.spec.allowMultiple ? [
                         firstOptionValue
                     ] : firstOptionValue;
                 }
@@ -58,13 +63,60 @@ function hydrateTemplateVariableState(variable, initialValue) {
     }
     return varState;
 }
-function hydrateTemplateVariableStates(definitions, initialValues) {
-    const state = {};
-    definitions.forEach((v)=>{
+function hydrateTemplateVariableStates(localDefinitions, initialValues, externalDefinitions = []) {
+    const state = new _pluginsystem.VariableStoreStateMap();
+    // Collect the names used by local definitions
+    let overridingNames = {};
+    localDefinitions.forEach((v)=>{
+        overridingNames[v.spec.name] = true;
+    }, {});
+    // Then populate the external variables state,
+    // taking care of well flagging each name as used, so the overridden state can be filled accordingly.
+    const overriddenNames = {};
+    externalDefinitions.forEach((externalDef)=>{
+        const source = externalDef.source;
+        externalDef.definitions.forEach((v)=>{
+            const name = v.spec.name;
+            const param = initialValues[name];
+            const initialValue = param ? param : null;
+            state.set({
+                source,
+                name
+            }, {
+                ...hydrateTemplateVariableState(v, initialValue),
+                overridden: !!overridingNames[name]
+            });
+            overridingNames[name] = true;
+            overriddenNames[v.spec.name] = true;
+        });
+    }, {});
+    // Then populate the local variables state,
+    // taking care the overriding state is filled according to the names used in external variables.
+    localDefinitions.forEach((v)=>{
         const name = v.spec.name;
         const param = initialValues[name];
         const initialValue = param ? param : null;
-        state[name] = hydrateTemplateVariableState(v, initialValue);
+        state.set({
+            name
+        }, {
+            ...hydrateTemplateVariableState(v, initialValue),
+            overriding: !!overriddenNames[name]
+        });
+    });
+    overridingNames = {};
+    externalDefinitions.slice().reverse().forEach((externalDef)=>{
+        const source = externalDef.source;
+        externalDef.definitions.forEach((v)=>{
+            const name = v.spec.name;
+            const value = state.get({
+                source,
+                name
+            });
+            if (value) {
+                value.overriding = !!overridingNames[name];
+            }
+            overridingNames[name] = true;
+        });
     });
     return state;
 }

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

@@ -14,15 +14,17 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-_exportStar(require("./TemplateVariableProvider"), exports);
-function _exportStar(from, to) {
+_export_star(require("./TemplateVariableProvider"), exports);
+function _export_star(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];
-            }
-        });
+        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

@@ -21,13 +21,23 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    getURLQueryParamName: ()=>getURLQueryParamName,
-    encodeVariableValue: ()=>encodeVariableValue,
-    decodeVariableValue: ()=>decodeVariableValue,
-    useVariableQueryParams: ()=>useVariableQueryParams,
-    getInitalValuesFromQueryParameters: ()=>getInitalValuesFromQueryParameters
+    getURLQueryParamName: function() {
+        return getURLQueryParamName;
+    },
+    encodeVariableValue: function() {
+        return encodeVariableValue;
+    },
+    decodeVariableValue: function() {
+        return decodeVariableValue;
+    },
+    useVariableQueryParams: function() {
+        return useVariableQueryParams;
+    },
+    getInitalValuesFromQueryParameters: function() {
+        return getInitalValuesFromQueryParameters;
+    }
 });
-const _useQueryParams = require("use-query-params");
+const _usequeryparams = require("use-query-params");
 const variableQueryParameterPrefix = 'var-';
 function getURLQueryParamName(name) {
     return `${variableQueryParameterPrefix}${name}`;
@@ -63,7 +73,7 @@ function useVariableQueryParams(defs) {
         const name = getURLQueryParamName(def.spec.name);
         config[name] = VariableValueParam;
     });
-    return (0, _useQueryParams.useQueryParams)(config, {
+    return (0, _usequeryparams.useQueryParams)(config, {
         updateType: 'replaceIn'
     });
 }

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

@@ -14,25 +14,46 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "checkSavedDefaultVariableStatus", {
-    enumerable: true,
-    get: ()=>checkSavedDefaultVariableStatus
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    checkSavedDefaultVariableStatus: function() {
+        return checkSavedDefaultVariableStatus;
+    },
+    mergeVariableDefinitions: function() {
+        return mergeVariableDefinitions;
+    },
+    findVariableDefinitionByName: function() {
+        return findVariableDefinitionByName;
+    },
+    forEachVariableDefinition: function() {
+        return forEachVariableDefinition;
+    }
 });
 function checkSavedDefaultVariableStatus(definitions, varState) {
     let isSavedVariableModified = false;
     const modifiedVariableNames = [];
     for (const savedVariable of definitions){
+        const name = savedVariable.spec.name;
         if (savedVariable.kind === 'ListVariable') {
-            const currentVariable = varState[savedVariable.spec.name];
-            if ((currentVariable === null || currentVariable === void 0 ? void 0 : currentVariable.value) !== null && (currentVariable === null || currentVariable === void 0 ? void 0 : currentVariable.value) !== savedVariable.spec.default_value) {
-                modifiedVariableNames.push(savedVariable.spec.name);
+            const currentVariable = varState.get({
+                name
+            });
+            if ((currentVariable === null || currentVariable === void 0 ? void 0 : currentVariable.value) !== null && (currentVariable === null || currentVariable === void 0 ? void 0 : currentVariable.value) !== savedVariable.spec.defaultValue) {
+                modifiedVariableNames.push(name);
                 isSavedVariableModified = true;
             }
         } else if (savedVariable.kind === 'TextVariable') {
-            const currentVariable1 = varState[savedVariable.spec.name];
-            const currentVariableValue = typeof (currentVariable1 === null || currentVariable1 === void 0 ? void 0 : currentVariable1.value) === 'string' ? currentVariable1.value : '';
+            const currentVariable = varState.get({
+                name
+            });
+            const currentVariableValue = typeof (currentVariable === null || currentVariable === void 0 ? void 0 : currentVariable.value) === 'string' ? currentVariable.value : '';
             if (savedVariable.spec.value !== currentVariableValue) {
-                modifiedVariableNames.push(savedVariable.spec.name);
+                modifiedVariableNames.push(name);
                 isSavedVariableModified = true;
             }
         }
@@ -42,3 +63,22 @@ function checkSavedDefaultVariableStatus(definitions, varState) {
         modifiedVariableNames
     };
 }
+function mergeVariableDefinitions(locals, externals) {
+    const pushed = {};
+    const result = [];
+    // Append the value only if it's not already appended
+    forEachVariableDefinition(locals, externals, (value, name)=>{
+        if (!pushed[name]) {
+            result.push(value);
+            pushed[name] = true;
+        }
+    });
+    return result;
+}
+function findVariableDefinitionByName(name, localDefinitions, externalDefinitions) {
+    return mergeVariableDefinitions(localDefinitions, externalDefinitions).find((d)=>d.spec.name === name);
+}
+function forEachVariableDefinition(locals, externals, callbackFn) {
+    locals.forEach((v)=>callbackFn(v, v.spec.name));
+    externals.forEach((ext)=>ext.definitions.forEach((v)=>callbackFn(v, v.spec.name, ext.source)));
+}