@esri/solution-simple-types 4.1.2 → 5.0.1

package/dist/esm/dashboard.js

@@ -1,340 +1,340 @@
-/** @license
- * Copyright 2018 Esri
- *
- * 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.
- */
-import * as common from "@esri/solution-common";
-/**
- * Converts a dashboard item to a template.
- *
- * @param itemTemplate Template for the dashboard item
- * @param templateDictionary Hash of key details used for variable replacement
- * @returns templatized itemTemplate
- */
-export function convertItemToTemplate(itemTemplate, templateDictionary) {
-    return _extractDependencies(itemTemplate, templateDictionary);
-}
-/**
- * Templatizes all itemIds and updates the dependency array
- *
- * @param itemTemplate Template for the dashboard item
- * @param templateDictionary Hash of key details used for variable replacement
- * @returns The updated itemTemplate
- * @private
- */
-export function _extractDependencies(itemTemplate, templateDictionary) {
-    // get dependencies from any
-    const updatePaths = [
-        "data.desktopView.header",
-        "data.desktopView.headerPanel.selectors",
-        "data.desktopView.leftPanel.selectors",
-        "data.desktopView.sidebar",
-        "data.desktopView.urlParameters",
-        "data.desktopView.widgets",
-        "data.header",
-        "data.headerPanel.selectors",
-        "data.leftPanel.selectors",
-        "data.mobileView.header",
-        "data.mobileView.headerPanel.selectors",
-        "data.mobileView.leftPanel.selectors",
-        "data.mobileView.sidebar",
-        "data.mobileView.urlParameters",
-        "data.mobileView.widgets",
-        "data.sidebar",
-        "data.urlParameters",
-        "data.widgets"
-    ];
-    updatePaths.forEach(path => {
-        const objs = common.getProp(itemTemplate, path);
-        if (Array.isArray(objs)) {
-            objs.forEach(obj => {
-                /* istanbul ignore else */
-                if (obj.type === "mapWidget") {
-                    /* istanbul ignore else */
-                    if (itemTemplate.dependencies.indexOf(obj.itemId) < 0) {
-                        itemTemplate.dependencies.push(obj.itemId);
-                    }
-                    obj.itemId = common.templatizeTerm(obj.itemId, obj.itemId, ".itemId");
-                }
-                /* istanbul ignore else */
-                if (Array.isArray(obj.datasets)) {
-                    _getDatasourceDependencies(obj, itemTemplate, templateDictionary);
-                }
-            });
-        }
-    });
-    return itemTemplate;
-}
-/**
- * Templatize datasource itemIds and update the dependency array
- *
- * @param obj A widget, selector, or urlParameter that contains a datasets collection
- * @param itemTemplate Template for the dashboard item
- * @param templateDictionary Hash of key details used for variable replacement
- * @private
- */
-export function _getDatasourceDependencies(obj, itemTemplate, templateDictionary) {
-    obj.datasets.forEach((dataset) => {
-        // when the datasource has an itemId it's an external datasource except if the datasource type is "arcadeDataSource"
-        const dataSourceType = common.getProp(dataset, "dataSource.type");
-        if (dataSourceType !== "arcadeDataSource") {
-            const itemId = common.getProp(dataset, "dataSource.itemId");
-            if (itemId) {
-                if (itemTemplate.dependencies.indexOf(itemId) < 0) {
-                    itemTemplate.dependencies.push(itemId);
-                }
-                const layerId = common.getProp(dataset, "dataSource.layerId");
-                common.cacheLayerInfo(layerId?.toString(), itemId, "", templateDictionary);
-                dataset.dataSource.itemId = common.templatizeTerm(itemId, itemId, ".itemId");
-            }
-        }
-    });
-}
-/**
- * Templatize field references for datasources and widgets.
- *
- * @param solutionTemplate The solution item template
- * @param datasourceInfos A list of datasource info objects that contain key values to templatize field references
- * @returns The solutionTemplate with templatized field references
- */
-export function postProcessFieldReferences(solutionTemplate, datasourceInfos) {
-    const updatePaths = [
-        "data.desktopView.header",
-        "data.desktopView.headerPanel.selectors",
-        "data.desktopView.leftPanel.selectors",
-        "data.desktopView.sidebar",
-        "data.desktopView.urlParameters",
-        "data.desktopView.widgets",
-        "data.header",
-        "data.headerPanel.selectors",
-        "data.leftPanel.selectors",
-        "data.mobileView.header",
-        "data.mobileView.headerPanel.selectors",
-        "data.mobileView.leftPanel.selectors",
-        "data.mobileView.sidebar",
-        "data.mobileView.urlParameters",
-        "data.mobileView.widgets",
-        "data.sidebar",
-        "data.urlParameters",
-        "data.widgets"
-    ];
-    // dashboards reference datasets from other widgets
-    // add reference IDs to the appropriate datasourceInfos
-    updatePaths.forEach(path => {
-        const objs = common.getProp(solutionTemplate, path);
-        _updateDatasourceReferences(objs, datasourceInfos);
-    });
-    // after we know the potential references go ahead and templatize
-    updatePaths.forEach(path => {
-        _templatize(solutionTemplate, path, datasourceInfos);
-    });
-    return solutionTemplate;
-}
-/**
- * Add all dataset ids to the appropriate datasource info object so we can navigate any relative references
- *
- * @param objs Thes can be widgets, selectors, or urlParameters
- * @param datasourceInfos A list of objects that contain key details about the datasources from the application
- * @private
- */
-export function _updateDatasourceReferences(objs, datasourceInfos) {
-    // objects can be events or widgets
-    /* istanbul ignore else */
-    if (objs && Array.isArray(objs)) {
-        objs.forEach(obj => {
-            if (Array.isArray(obj.datasets)) {
-                obj.datasets.forEach((dataset) => {
-                    // when the datasource has an itemId it's an external datasource
-                    const itemId = common.cleanItemId(common.getProp(dataset, "dataSource.itemId"));
-                    if (itemId) {
-                        const layerId = common.cleanLayerId(common.getProp(dataset, "dataSource.layerId"));
-                        datasourceInfos.some(ds => {
-                            if (ds.itemId === itemId && ds.layerId === layerId) {
-                                _updateReferences(ds, obj.id);
-                                return true;
-                            }
-                            else {
-                                return false;
-                            }
-                        });
-                    }
-                    else {
-                        // add placeholder for map layer datasource info so we can know the items that reference them
-                        // needed when item field reference are derived from another widgets datasource eg. <dashboardWidgetId>#datasetname
-                        const id = common.getProp(dataset, "dataSource.id");
-                        if (id) {
-                            const dashboardLayerId = id.split("#")[1];
-                            datasourceInfos.some(ds => {
-                                if (ds.ids.indexOf(dashboardLayerId) > -1) {
-                                    _updateReferences(ds, obj.id);
-                                    return true;
-                                }
-                                else {
-                                    return false;
-                                }
-                            });
-                        }
-                    }
-                });
-            }
-        });
-    }
-}
-/**
- * Templatize all datasets and/or events for the objects at the given path
- *
- * @param itemTemplate Template for the dashboard item
- * @param path A property path to an array of objects that could contain datasets or events
- * @param datasourceInfos A list of objects that contain key details about the datasources from the application
- * @private
- */
-export function _templatize(itemTemplate, path, datasourceInfos) {
-    const obj = common.getProp(itemTemplate, path);
-    /* istanbul ignore else */
-    if (obj) {
-        common.setProp(itemTemplate, path, _templatizeByDatasource(obj, datasourceInfos));
-    }
-}
-/**
- * For any service dataset datasource templatize all field references
- *
- * @param objs A list of objects that can contain field references
- * @param datasourceInfos A list of objects that contain key details about the datasources from the application
- * @returns An updated list of objects with templatized field references
- * @private
- */
-export function _templatizeByDatasource(objs, datasourceInfos) {
-    if (Array.isArray(objs)) {
-        return objs.map(obj => {
-            let _obj = obj;
-            if (Array.isArray(_obj.events)) {
-                // Events can be associated with datasets but they can also be associated with a target
-                // In some cases an event will have a source and a target.
-                // Handle these specifically first to ensure that it has the correct layer reference
-                _obj.events = _obj.events.map((event) => {
-                    const _event = event;
-                    /* istanbul ignore else */
-                    if (Array.isArray(_event.actions)) {
-                        _event.actions = _event.actions.map((action) => {
-                            const _action = action;
-                            if (_action.fieldMap &&
-                                _action.targetId &&
-                                _action.targetId.indexOf("#") > -1) {
-                                const datasourceInfo = _getDatasourceInfo(_action, datasourceInfos);
-                                /* istanbul ignore else */
-                                if (datasourceInfo) {
-                                    const fields = common.getProp(datasourceInfo, "fields");
-                                    const basePath = common.getProp(datasourceInfo, "basePath");
-                                    /* istanbul ignore else */
-                                    if (Array.isArray(fields) && basePath) {
-                                        _action.fieldMap = _action.fieldMap.map((m) => {
-                                            const _m = m;
-                                            _m.targetName = common.templatizeFieldReferences(_m.targetName, fields, basePath);
-                                            return _m;
-                                        });
-                                    }
-                                }
-                            }
-                            return _action;
-                        });
-                    }
-                    return _event;
-                });
-            }
-            if (Array.isArray(_obj.datasets)) {
-                _obj.datasets = _obj.datasets.map((dataset) => {
-                    let _dataset = dataset;
-                    if (_dataset.type === "serviceDataset") {
-                        const datasourceInfo = _getDatasourceInfo(dataset, datasourceInfos);
-                        /* istanbul ignore else */
-                        if (datasourceInfo) {
-                            const fields = common.getProp(datasourceInfo, "fields");
-                            const basePath = common.getProp(datasourceInfo, "basePath");
-                            /* istanbul ignore else */
-                            if (Array.isArray(fields) && basePath) {
-                                _obj = common.templatizeFieldReferences(_obj, fields, basePath);
-                                _dataset = common.templatizeFieldReferences(_dataset, fields, basePath);
-                            }
-                        }
-                    }
-                    return _dataset;
-                });
-                return _obj;
-            }
-            else
-                return _obj;
-        });
-    }
-    else {
-        return objs;
-    }
-}
-/**
- * Find the appropriate datasource info object from the datasourceInfo collection
- *
- * @param obj Can be a Dataset or an event
- * @param datasourceInfos A list of objects that contain key details about the datasources from the application
- * @returns The supporting datasource info for the given object
- * @private
- */
-export function _getDatasourceInfo(obj, datasourceInfos) {
-    let info;
-    // the datasource will have an id property when it's referencing a map layer
-    // the fields collection will already be defined
-    const id = common.getProp(obj, "dataSource.id") || common.getProp(obj, "targetId");
-    if (id) {
-        const dashboardLayerId = id.split("#")[1];
-        if (!datasourceInfos.some(di => {
-            info = di.ids.indexOf(dashboardLayerId) > -1 ? di : info;
-            return di.ids.indexOf(dashboardLayerId) > -1;
-        })) {
-            // in some cases the id will not contain a layer name...it will have the dashboard id for another widget
-            // in that case lookup the datasource from referenced widget
-            const dashboardWidgetId = id.split("#")[0];
-            datasourceInfos.some(di => {
-                const references = di.references || [];
-                const hasRef = references.indexOf(dashboardWidgetId) > -1;
-                info = hasRef ? di : info;
-                return hasRef;
-            });
-        }
-    }
-    else {
-        // otherwise match the itemId and the layerId to get the correct fields and path
-        const itemId = common.cleanItemId(common.getProp(obj, "dataSource.itemId"));
-        const layerId = common.cleanLayerId(common.getProp(obj, "dataSource.layerId"));
-        /* istanbul ignore else */
-        if (itemId) {
-            datasourceInfos.some(di => {
-                const matches = itemId === di.itemId && layerId === di.layerId;
-                info = matches ? di : info;
-                return matches;
-            });
-        }
-    }
-    return info;
-}
-/**
- * Verifies if the datasource info contains the given id and adds it if not
- *
- * @param ds The datasource info to add the reference to
- * @param id The id from dashboard object, commonly another widget
- * @private
- */
-export function _updateReferences(ds, id) {
-    ds.references = Array.isArray(ds.references) ? ds.references : [];
-    if (ds.references.indexOf(id) < 0) {
-        ds.references.push(id);
-    }
-}
+/** @license
+ * Copyright 2018 Esri
+ *
+ * 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.
+ */
+import * as common from "@esri/solution-common";
+/**
+ * Converts a dashboard item to a template.
+ *
+ * @param itemTemplate Template for the dashboard item
+ * @param templateDictionary Hash of key details used for variable replacement
+ * @returns templatized itemTemplate
+ */
+export function convertItemToTemplate(itemTemplate, templateDictionary) {
+    return _extractDependencies(itemTemplate, templateDictionary);
+}
+/**
+ * Templatizes all itemIds and updates the dependency array
+ *
+ * @param itemTemplate Template for the dashboard item
+ * @param templateDictionary Hash of key details used for variable replacement
+ * @returns The updated itemTemplate
+ * @private
+ */
+export function _extractDependencies(itemTemplate, templateDictionary) {
+    // get dependencies from any
+    const updatePaths = [
+        "data.desktopView.header",
+        "data.desktopView.headerPanel.selectors",
+        "data.desktopView.leftPanel.selectors",
+        "data.desktopView.sidebar",
+        "data.desktopView.urlParameters",
+        "data.desktopView.widgets",
+        "data.header",
+        "data.headerPanel.selectors",
+        "data.leftPanel.selectors",
+        "data.mobileView.header",
+        "data.mobileView.headerPanel.selectors",
+        "data.mobileView.leftPanel.selectors",
+        "data.mobileView.sidebar",
+        "data.mobileView.urlParameters",
+        "data.mobileView.widgets",
+        "data.sidebar",
+        "data.urlParameters",
+        "data.widgets"
+    ];
+    updatePaths.forEach(path => {
+        const objs = common.getProp(itemTemplate, path);
+        if (Array.isArray(objs)) {
+            objs.forEach(obj => {
+                /* istanbul ignore else */
+                if (obj.type === "mapWidget") {
+                    /* istanbul ignore else */
+                    if (itemTemplate.dependencies.indexOf(obj.itemId) < 0) {
+                        itemTemplate.dependencies.push(obj.itemId);
+                    }
+                    obj.itemId = common.templatizeTerm(obj.itemId, obj.itemId, ".itemId");
+                }
+                /* istanbul ignore else */
+                if (Array.isArray(obj.datasets)) {
+                    _getDatasourceDependencies(obj, itemTemplate, templateDictionary);
+                }
+            });
+        }
+    });
+    return itemTemplate;
+}
+/**
+ * Templatize datasource itemIds and update the dependency array
+ *
+ * @param obj A widget, selector, or urlParameter that contains a datasets collection
+ * @param itemTemplate Template for the dashboard item
+ * @param templateDictionary Hash of key details used for variable replacement
+ * @private
+ */
+export function _getDatasourceDependencies(obj, itemTemplate, templateDictionary) {
+    obj.datasets.forEach((dataset) => {
+        // when the datasource has an itemId it's an external datasource except if the datasource type is "arcadeDataSource"
+        const dataSourceType = common.getProp(dataset, "dataSource.type");
+        if (dataSourceType !== "arcadeDataSource") {
+            const itemId = common.getProp(dataset, "dataSource.itemId");
+            if (itemId) {
+                if (itemTemplate.dependencies.indexOf(itemId) < 0) {
+                    itemTemplate.dependencies.push(itemId);
+                }
+                const layerId = common.getProp(dataset, "dataSource.layerId");
+                common.cacheLayerInfo(layerId?.toString(), itemId, "", templateDictionary);
+                dataset.dataSource.itemId = common.templatizeTerm(itemId, itemId, ".itemId");
+            }
+        }
+    });
+}
+/**
+ * Templatize field references for datasources and widgets.
+ *
+ * @param solutionTemplate The solution item template
+ * @param datasourceInfos A list of datasource info objects that contain key values to templatize field references
+ * @returns The solutionTemplate with templatized field references
+ */
+export function postProcessFieldReferences(solutionTemplate, datasourceInfos) {
+    const updatePaths = [
+        "data.desktopView.header",
+        "data.desktopView.headerPanel.selectors",
+        "data.desktopView.leftPanel.selectors",
+        "data.desktopView.sidebar",
+        "data.desktopView.urlParameters",
+        "data.desktopView.widgets",
+        "data.header",
+        "data.headerPanel.selectors",
+        "data.leftPanel.selectors",
+        "data.mobileView.header",
+        "data.mobileView.headerPanel.selectors",
+        "data.mobileView.leftPanel.selectors",
+        "data.mobileView.sidebar",
+        "data.mobileView.urlParameters",
+        "data.mobileView.widgets",
+        "data.sidebar",
+        "data.urlParameters",
+        "data.widgets"
+    ];
+    // dashboards reference datasets from other widgets
+    // add reference IDs to the appropriate datasourceInfos
+    updatePaths.forEach(path => {
+        const objs = common.getProp(solutionTemplate, path);
+        _updateDatasourceReferences(objs, datasourceInfos);
+    });
+    // after we know the potential references go ahead and templatize
+    updatePaths.forEach(path => {
+        _templatize(solutionTemplate, path, datasourceInfos);
+    });
+    return solutionTemplate;
+}
+/**
+ * Add all dataset ids to the appropriate datasource info object so we can navigate any relative references
+ *
+ * @param objs Thes can be widgets, selectors, or urlParameters
+ * @param datasourceInfos A list of objects that contain key details about the datasources from the application
+ * @private
+ */
+export function _updateDatasourceReferences(objs, datasourceInfos) {
+    // objects can be events or widgets
+    /* istanbul ignore else */
+    if (objs && Array.isArray(objs)) {
+        objs.forEach(obj => {
+            if (Array.isArray(obj.datasets)) {
+                obj.datasets.forEach((dataset) => {
+                    // when the datasource has an itemId it's an external datasource
+                    const itemId = common.cleanItemId(common.getProp(dataset, "dataSource.itemId"));
+                    if (itemId) {
+                        const layerId = common.cleanLayerId(common.getProp(dataset, "dataSource.layerId"));
+                        datasourceInfos.some(ds => {
+                            if (ds.itemId === itemId && ds.layerId === layerId) {
+                                _updateReferences(ds, obj.id);
+                                return true;
+                            }
+                            else {
+                                return false;
+                            }
+                        });
+                    }
+                    else {
+                        // add placeholder for map layer datasource info so we can know the items that reference them
+                        // needed when item field reference are derived from another widgets datasource eg. <dashboardWidgetId>#datasetname
+                        const id = common.getProp(dataset, "dataSource.id");
+                        if (id) {
+                            const dashboardLayerId = id.split("#")[1];
+                            datasourceInfos.some(ds => {
+                                if (ds.ids.indexOf(dashboardLayerId) > -1) {
+                                    _updateReferences(ds, obj.id);
+                                    return true;
+                                }
+                                else {
+                                    return false;
+                                }
+                            });
+                        }
+                    }
+                });
+            }
+        });
+    }
+}
+/**
+ * Templatize all datasets and/or events for the objects at the given path
+ *
+ * @param itemTemplate Template for the dashboard item
+ * @param path A property path to an array of objects that could contain datasets or events
+ * @param datasourceInfos A list of objects that contain key details about the datasources from the application
+ * @private
+ */
+export function _templatize(itemTemplate, path, datasourceInfos) {
+    const obj = common.getProp(itemTemplate, path);
+    /* istanbul ignore else */
+    if (obj) {
+        common.setProp(itemTemplate, path, _templatizeByDatasource(obj, datasourceInfos));
+    }
+}
+/**
+ * For any service dataset datasource templatize all field references
+ *
+ * @param objs A list of objects that can contain field references
+ * @param datasourceInfos A list of objects that contain key details about the datasources from the application
+ * @returns An updated list of objects with templatized field references
+ * @private
+ */
+export function _templatizeByDatasource(objs, datasourceInfos) {
+    if (Array.isArray(objs)) {
+        return objs.map(obj => {
+            let _obj = obj;
+            if (Array.isArray(_obj.events)) {
+                // Events can be associated with datasets but they can also be associated with a target
+                // In some cases an event will have a source and a target.
+                // Handle these specifically first to ensure that it has the correct layer reference
+                _obj.events = _obj.events.map((event) => {
+                    const _event = event;
+                    /* istanbul ignore else */
+                    if (Array.isArray(_event.actions)) {
+                        _event.actions = _event.actions.map((action) => {
+                            const _action = action;
+                            if (_action.fieldMap &&
+                                _action.targetId &&
+                                _action.targetId.indexOf("#") > -1) {
+                                const datasourceInfo = _getDatasourceInfo(_action, datasourceInfos);
+                                /* istanbul ignore else */
+                                if (datasourceInfo) {
+                                    const fields = common.getProp(datasourceInfo, "fields");
+                                    const basePath = common.getProp(datasourceInfo, "basePath");
+                                    /* istanbul ignore else */
+                                    if (Array.isArray(fields) && basePath) {
+                                        _action.fieldMap = _action.fieldMap.map((m) => {
+                                            const _m = m;
+                                            _m.targetName = common.templatizeFieldReferences(_m.targetName, fields, basePath);
+                                            return _m;
+                                        });
+                                    }
+                                }
+                            }
+                            return _action;
+                        });
+                    }
+                    return _event;
+                });
+            }
+            if (Array.isArray(_obj.datasets)) {
+                _obj.datasets = _obj.datasets.map((dataset) => {
+                    let _dataset = dataset;
+                    if (_dataset.type === "serviceDataset") {
+                        const datasourceInfo = _getDatasourceInfo(dataset, datasourceInfos);
+                        /* istanbul ignore else */
+                        if (datasourceInfo) {
+                            const fields = common.getProp(datasourceInfo, "fields");
+                            const basePath = common.getProp(datasourceInfo, "basePath");
+                            /* istanbul ignore else */
+                            if (Array.isArray(fields) && basePath) {
+                                _obj = common.templatizeFieldReferences(_obj, fields, basePath);
+                                _dataset = common.templatizeFieldReferences(_dataset, fields, basePath);
+                            }
+                        }
+                    }
+                    return _dataset;
+                });
+                return _obj;
+            }
+            else
+                return _obj;
+        });
+    }
+    else {
+        return objs;
+    }
+}
+/**
+ * Find the appropriate datasource info object from the datasourceInfo collection
+ *
+ * @param obj Can be a Dataset or an event
+ * @param datasourceInfos A list of objects that contain key details about the datasources from the application
+ * @returns The supporting datasource info for the given object
+ * @private
+ */
+export function _getDatasourceInfo(obj, datasourceInfos) {
+    let info;
+    // the datasource will have an id property when it's referencing a map layer
+    // the fields collection will already be defined
+    const id = common.getProp(obj, "dataSource.id") || common.getProp(obj, "targetId");
+    if (id) {
+        const dashboardLayerId = id.split("#")[1];
+        if (!datasourceInfos.some(di => {
+            info = di.ids.indexOf(dashboardLayerId) > -1 ? di : info;
+            return di.ids.indexOf(dashboardLayerId) > -1;
+        })) {
+            // in some cases the id will not contain a layer name...it will have the dashboard id for another widget
+            // in that case lookup the datasource from referenced widget
+            const dashboardWidgetId = id.split("#")[0];
+            datasourceInfos.some(di => {
+                const references = di.references || [];
+                const hasRef = references.indexOf(dashboardWidgetId) > -1;
+                info = hasRef ? di : info;
+                return hasRef;
+            });
+        }
+    }
+    else {
+        // otherwise match the itemId and the layerId to get the correct fields and path
+        const itemId = common.cleanItemId(common.getProp(obj, "dataSource.itemId"));
+        const layerId = common.cleanLayerId(common.getProp(obj, "dataSource.layerId"));
+        /* istanbul ignore else */
+        if (itemId) {
+            datasourceInfos.some(di => {
+                const matches = itemId === di.itemId && layerId === di.layerId;
+                info = matches ? di : info;
+                return matches;
+            });
+        }
+    }
+    return info;
+}
+/**
+ * Verifies if the datasource info contains the given id and adds it if not
+ *
+ * @param ds The datasource info to add the reference to
+ * @param id The id from dashboard object, commonly another widget
+ * @private
+ */
+export function _updateReferences(ds, id) {
+    ds.references = Array.isArray(ds.references) ? ds.references : [];
+    if (ds.references.indexOf(id) < 0) {
+        ds.references.push(id);
+    }
+}
 //# sourceMappingURL=dashboard.js.map