@perses-dev/dashboards 0.8.1 → 0.10.0

package/dist/cjs/context/DashboardProvider/dashboard-provider-api.js

@@ -0,0 +1,71 @@
+// 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, {
+    useEditMode: ()=>useEditMode,
+    useLayouts: ()=>useLayouts,
+    usePanelGroupDialog: ()=>usePanelGroupDialog,
+    usePanels: ()=>usePanels,
+    useDefaultTimeRange: ()=>useDefaultTimeRange
+});
+const _dashboardProvider = require("./DashboardProvider");
+function useEditMode() {
+    return (0, _dashboardProvider.useDashboardStore)(({ isEditMode , setEditMode  })=>({
+            isEditMode,
+            setEditMode
+        }));
+}
+function useLayouts() {
+    return (0, _dashboardProvider.useDashboardStore)(({ layouts , addPanelToGroup , movePanelToGroup , updatePanelGroup , swapPanelGroups , deletePanelGroup  })=>({
+            layouts,
+            addPanelToGroup,
+            movePanelToGroup,
+            updatePanelGroup,
+            swapPanelGroups,
+            deletePanelGroup
+        }));
+}
+function usePanelGroupDialog() {
+    return (0, _dashboardProvider.useDashboardStore)(({ panelGroupDialog , openPanelGroupDialog , closePanelGroupDialog , deletePanelGroupDialog , openDeletePanelGroupDialog , closeDeletePanelGroupDialog ,  })=>({
+            panelGroupDialog,
+            openPanelGroupDialog,
+            closePanelGroupDialog,
+            deletePanelGroupDialog,
+            openDeletePanelGroupDialog,
+            closeDeletePanelGroupDialog
+        }));
+}
+function usePanels() {
+    return (0, _dashboardProvider.useDashboardStore)(({ panels , panelEditor , addPanel , editPanel , deletePanelDialog , deletePanels , openDeletePanelDialog , closeDeletePanelDialog ,  })=>({
+            panels,
+            panelEditor,
+            addPanel,
+            editPanel,
+            deletePanels,
+            deletePanelDialog,
+            openDeletePanelDialog,
+            closeDeletePanelDialog
+        }));
+}
+function useDefaultTimeRange() {
+    return (0, _dashboardProvider.useDashboardStore)((state)=>state.defaultTimeRange);
+}

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

@@ -0,0 +1,29 @@
+// 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("./dashboard-provider-api"), exports);
+_exportStar(require("./DashboardProvider"), 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/DashboardProvider/layout-slice.js

@@ -0,0 +1,200 @@
+// 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, "createLayoutSlice", {
+    enumerable: true,
+    get: ()=>createLayoutSlice
+});
+const _core = require("@perses-dev/core");
+function createLayoutSlice(layouts) {
+    // Return the state creator function for Zustand that uses the layouts provided as initial state
+    let id = -1;
+    function createPanelGroupId() {
+        id++;
+        return id;
+    }
+    var ref;
+    return (set, get)=>{
+        return {
+            layouts: layouts.map((layout)=>{
+                var ref1, ref2, ref3;
+                return {
+                    ...layout,
+                    id: createPanelGroupId(),
+                    title: (ref1 = layout.spec.display) === null || ref1 === void 0 ? void 0 : ref1.title,
+                    isCollapsed: (ref = !((ref2 = layout.spec.display) === null || ref2 === void 0 ? void 0 : (ref3 = ref2.collapse) === null || ref3 === void 0 ? void 0 : ref3.open)) !== null && ref !== void 0 ? ref : false,
+                    items: layout.spec.items
+                };
+            }),
+            getPanelKey ({ groupIndex , itemIndex  }) {
+                const { layouts  } = get();
+                const group = findGroup(layouts, groupIndex);
+                const item = findItem(group, itemIndex);
+                return (0, _core.getPanelKeyFromRef)(item.content);
+            },
+            addPanelToGroup (panelKey, groupIndex) {
+                const { layouts  } = get();
+                const group = findGroup(layouts, groupIndex);
+                const gridItem = {
+                    x: 0,
+                    y: getYForNewRow(group),
+                    width: 12,
+                    height: 6,
+                    content: (0, _core.createPanelRef)(panelKey)
+                };
+                set((state)=>{
+                    var ref;
+                    (ref = state.layouts[groupIndex]) === null || ref === void 0 ? void 0 : ref.items.push(gridItem);
+                });
+            },
+            movePanelToGroup ({ groupIndex , itemIndex  }, newGroupIndex) {
+                const { layouts  } = get();
+                // Find the existing item to make sure it exists
+                const group = findGroup(layouts, groupIndex);
+                const item = findItem(group, itemIndex);
+                // Find the new group and figure out where a new row should go
+                const newGroup = findGroup(layouts, newGroupIndex);
+                const newGroupY = getYForNewRow(newGroup);
+                set((state)=>{
+                    var // Remove the item from its current group
+                    ref, // Add a new item to the new group
+                    ref1;
+                    (ref = state.layouts[groupIndex]) === null || ref === void 0 ? void 0 : ref.items.splice(itemIndex, 1);
+                    (ref1 = state.layouts[newGroupIndex]) === null || ref1 === void 0 ? void 0 : ref1.items.push({
+                        x: 0,
+                        y: newGroupY,
+                        width: item.width,
+                        height: item.height,
+                        content: item.content
+                    });
+                });
+            },
+            // TODO: Maybe combine this into some kind of groupEditor state
+            updatePanelGroup (next, groupIndex) {
+                set((state)=>{
+                    if (groupIndex === undefined) {
+                        state.layouts.unshift({
+                            ...next,
+                            id: createPanelGroupId()
+                        });
+                    } else {
+                        const layout = state.layouts[groupIndex];
+                        if (layout === undefined) {
+                            throw new Error(`No layout at index ${groupIndex}`);
+                        }
+                        state.layouts[groupIndex] = {
+                            ...next,
+                            id: layout.id
+                        };
+                    }
+                });
+            },
+            swapPanelGroups (x, y) {
+                set((state)=>{
+                    if (x < 0 || x >= state.layouts.length || y < 0 || y >= state.layouts.length) {
+                        throw new Error('index out of bound');
+                    }
+                    const xPanelGroup = state.layouts[x];
+                    const yPanelGroup = state.layouts[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.layouts[x], state.layouts[y]] = [
+                        yPanelGroup,
+                        xPanelGroup
+                    ];
+                });
+            },
+            deletePanelInPanelGroup ({ groupIndex , itemIndex  }) {
+                set((state)=>{
+                    const group = state.layouts[groupIndex];
+                    if (group === undefined) {
+                        throw new Error(`No panel group found: ${groupIndex}`);
+                    }
+                    // remove panel from panel group
+                    group.items.splice(itemIndex, 1);
+                });
+            },
+            deletePanelGroup (groupIndex) {
+                const { layouts , deletePanels  } = get();
+                const group = layouts[groupIndex];
+                if (group === undefined) {
+                    throw new Error(`No panel group found: ${groupIndex}`);
+                }
+                // remove panels from group first
+                const panelsToBeDeleted = [];
+                for(let i = 0; i < group.items.length; i++){
+                    panelsToBeDeleted.push({
+                        groupIndex,
+                        itemIndex: i
+                    });
+                }
+                deletePanels(panelsToBeDeleted);
+                // remove group from state.layouts
+                set((state)=>{
+                    state.layouts.splice(groupIndex, 1);
+                });
+            },
+            // Return an object that maps each panel to the groups it belongs
+            mapPanelToPanelGroups () {
+                const map = {}; // { panel key: [group ids] }
+                get().layouts.forEach((group)=>{
+                    // for each panel in a group, add the group id to map[panelKey]
+                    group.items.forEach((panel)=>{
+                        const panelKey = (0, _core.getPanelKeyFromRef)(panel.content);
+                        if (map[panelKey]) {
+                            var ref;
+                            (ref = map[panelKey]) === null || ref === void 0 ? void 0 : ref.push(group.id);
+                        } else {
+                            map[panelKey] = [
+                                group.id
+                            ];
+                        }
+                    });
+                });
+                return map;
+            }
+        };
+    };
+}
+// Helper to find a group and throw if not found
+function findGroup(layouts, groupIndex) {
+    const group = layouts[groupIndex];
+    if (group === undefined) {
+        throw new Error(`No layout at index ${groupIndex}`);
+    }
+    return group;
+}
+// Helper to get an item in a group and throw if not found
+function findItem(group, itemIndex) {
+    const item = group.items[itemIndex];
+    if (item === undefined) {
+        throw new Error(`No grid item found at position ${itemIndex}`);
+    }
+    return item;
+}
+// Given a Grid, will find the Y coordinate for adding a new row to the grid, taking into account the items present
+function getYForNewRow(group) {
+    let newRowY = 0;
+    for (const item of group.items){
+        const itemMaxY = item.y + item.height;
+        if (itemMaxY > newRowY) {
+            newRowY = itemMaxY;
+        }
+    }
+    return newRowY;
+}

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

@@ -0,0 +1,156 @@
+// 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, "createPanelEditorSlice", {
+    enumerable: true,
+    get: ()=>createPanelEditorSlice
+});
+const _functions = require("../../utils/functions");
+function createPanelEditorSlice(panels) {
+    // Return the state creator function for Zustand that uses the panels provided as intitial state
+    return (set, get)=>{
+        return {
+            panels,
+            panelEditor: undefined,
+            editPanel (item) {
+                const { panels , getPanelKey  } = get();
+                // Ask the layout store for the panel key at that location
+                const panelKey = getPanelKey(item);
+                // Find the panel to edit
+                const panelToEdit = panels[panelKey];
+                if (panelToEdit === undefined) {
+                    throw new Error(`Cannot find Panel with key '${panelKey}'`);
+                }
+                var _description;
+                const editorState = {
+                    mode: 'Edit',
+                    initialValues: {
+                        name: panelToEdit.spec.display.name,
+                        description: (_description = panelToEdit.spec.display.description) !== null && _description !== void 0 ? _description : '',
+                        groupIndex: item.groupIndex,
+                        kind: panelToEdit.spec.plugin.kind,
+                        spec: panelToEdit.spec.plugin.spec
+                    },
+                    applyChanges: (next)=>{
+                        const panelDefinititon = createPanelDefinitionFromEditorValues(next);
+                        set((state)=>{
+                            state.panels[panelKey] = panelDefinititon;
+                        });
+                        // Move the panel to another group if it changed
+                        if (next.groupIndex !== item.groupIndex) {
+                            get().movePanelToGroup(item, next.groupIndex);
+                        }
+                    },
+                    close: ()=>{
+                        set((state)=>{
+                            state.panelEditor = undefined;
+                        });
+                    }
+                };
+                // Open the editor with the new state
+                set((state)=>{
+                    state.panelEditor = editorState;
+                });
+            },
+            addPanel (initialGroup) {
+                const editorState = {
+                    mode: 'Add',
+                    initialValues: {
+                        name: '',
+                        description: '',
+                        groupIndex: initialGroup,
+                        // TODO: If we knew what plugins were available (and how to create the initial spec), we might be able to
+                        // set a smarter default here?
+                        kind: '',
+                        spec: {}
+                    },
+                    applyChanges: (next)=>{
+                        const panelDef = createPanelDefinitionFromEditorValues(next);
+                        const panelKey = (0, _functions.removeWhiteSpacesAndSpecialCharacters)(next.name);
+                        set((state)=>{
+                            state.panels[panelKey] = panelDef;
+                        });
+                        get().addPanelToGroup(panelKey, next.groupIndex);
+                    },
+                    close: ()=>{
+                        set((state)=>{
+                            state.panelEditor = undefined;
+                        });
+                    }
+                };
+                // Open the editor with the new state
+                set((state)=>{
+                    state.panelEditor = editorState;
+                });
+            },
+            deletePanels (items) {
+                const { mapPanelToPanelGroups , deletePanelInPanelGroup , getPanelKey  } = get();
+                const map = mapPanelToPanelGroups();
+                // get panel key first before deleting panel from panel group since getPanelKey relies on index
+                const panels = items.map((panel)=>{
+                    return {
+                        ...panel,
+                        panelKey: getPanelKey(panel)
+                    };
+                });
+                panels.forEach(({ panelKey , ...panel })=>{
+                    var ref;
+                    deletePanelInPanelGroup(panel);
+                    // make sure panel is only referenced in one panel group before deleting it from state.panels
+                    if (map[panelKey] && ((ref = map[panelKey]) === null || ref === void 0 ? void 0 : ref.length) === 1) {
+                        set((state)=>{
+                            delete state.panels[panelKey];
+                        });
+                    }
+                });
+            },
+            openDeletePanelDialog (item) {
+                set((state)=>{
+                    var ref;
+                    const { panels , getPanelKey  } = get();
+                    const panelKey = getPanelKey(item);
+                    var _name;
+                    state.deletePanelDialog = {
+                        panelKey,
+                        panelName: (_name = (ref = panels[panelKey]) === null || ref === void 0 ? void 0 : ref.spec.display.name) !== null && _name !== void 0 ? _name : '',
+                        layoutItem: item
+                    };
+                });
+            },
+            closeDeletePanelDialog () {
+                set((state)=>{
+                    state.deletePanelDialog = undefined;
+                });
+            }
+        };
+    };
+}
+// Helper to create PanelDefinitions when saving
+function createPanelDefinitionFromEditorValues(editorValues) {
+    return {
+        kind: 'Panel',
+        spec: {
+            display: {
+                name: editorValues.name,
+                description: editorValues.description !== '' ? editorValues.description : undefined
+            },
+            plugin: {
+                kind: editorValues.kind,
+                spec: editorValues.spec
+            }
+        }
+    };
+}

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

@@ -0,0 +1,38 @@
+// 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, "createPanelGroupSlice", {
+    enumerable: true,
+    get: ()=>createPanelGroupSlice
+});
+const createPanelGroupSlice = (set)=>({
+        openPanelGroupDialog: (groupIndex)=>set((state)=>{
+                state.panelGroupDialog = {
+                    groupIndex
+                };
+            }),
+        closePanelGroupDialog: ()=>set((state)=>{
+                state.panelGroupDialog = undefined;
+            }),
+        openDeletePanelGroupDialog: (groupIndex)=>set((state)=>{
+                state.deletePanelGroupDialog = {
+                    groupIndex
+                };
+            }),
+        closeDeletePanelGroupDialog: ()=>set((state)=>{
+                state.deletePanelGroupDialog = undefined;
+            })
+    });

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
+    };
+}