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

package/dist/cjs/components/PluginKindSelect.test.js

@@ -0,0 +1,86 @@
+// 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
+});
+const _jsxRuntime = require("react/jsx-runtime");
+const _userEvent = /*#__PURE__*/ _interopRequireDefault(require("@testing-library/user-event"));
+const _react = require("@testing-library/react");
+const _test = require("../test");
+const _pluginKindSelect = require("./PluginKindSelect");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+describe('PluginKindSelect', ()=>{
+    const renderComponent = (props)=>{
+        return (0, _test.renderWithContext)(/*#__PURE__*/ (0, _jsxRuntime.jsx)(_pluginKindSelect.PluginKindSelect, {
+            ...props
+        }));
+    };
+    // Opens the select and waits for loading to finish (i.e. options to appear)
+    const openSelect = async ()=>{
+        const select = _react.screen.getByRole('button');
+        _userEvent.default.click(select);
+        const options = await _react.screen.findAllByRole('option');
+        return options;
+    };
+    it('displays the list of plugins for a plugin type', async ()=>{
+        renderComponent({
+            pluginType: 'Panel',
+            value: ''
+        });
+        // Open the select and verify the list of options from the test plugin data
+        const options = await openSelect();
+        expect(options).toHaveLength(2);
+        let option = _react.screen.queryByRole('option', {
+            name: 'Bert Panel 1'
+        });
+        expect(option).toBeInTheDocument();
+        option = _react.screen.queryByRole('option', {
+            name: 'Bert Panel 2'
+        });
+        expect(option).toBeInTheDocument();
+    });
+    it('shows the correct selected value', async ()=>{
+        renderComponent({
+            pluginType: 'Variable',
+            value: 'ErnieVariable'
+        });
+        // Use findByRole to wait for loading to finish and selected value to appear
+        const select = await _react.screen.findByRole('button', {
+            name: 'Ernie Variable'
+        });
+        expect(select).toBeInTheDocument();
+    });
+    it('can select new value', async ()=>{
+        let onChangeValue = undefined;
+        const onChange = jest.fn((e)=>{
+            onChangeValue = e.target.value;
+        });
+        renderComponent({
+            pluginType: 'Variable',
+            value: 'ErnieVariable',
+            onChange
+        });
+        await openSelect();
+        const newOption = _react.screen.getByRole('option', {
+            name: 'Bert Variable'
+        });
+        _userEvent.default.click(newOption);
+        expect(onChange).toHaveBeenCalledTimes(1);
+        expect(onChangeValue).toBe('BertVariable');
+    });
+});

package/dist/cjs/components/PluginRegistry/PluginRegistry.js

@@ -0,0 +1,85 @@
+// 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, "PluginRegistry", {
+    enumerable: true,
+    get: ()=>PluginRegistry
+});
+const _jsxRuntime = require("react/jsx-runtime");
+const _core = require("@perses-dev/core");
+const _react = require("react");
+const _runtime = require("../../runtime");
+const _pluginIndexes = require("./plugin-indexes");
+function PluginRegistry(props) {
+    const { pluginLoader: { getInstalledPlugins , importPluginModule  } , children , defaultPluginKinds ,  } = props;
+    const getPluginIndexes = (0, _pluginIndexes.usePluginIndexes)(getInstalledPlugins);
+    // De-dupe calls to import plugin modules
+    const importCache = (0, _react.useRef)(new Map());
+    // Do useEvent here since this accesses the importPluginModule prop and we want a stable reference to it for the
+    // callback below
+    const loadPluginModule = (0, _core.useEvent)((resource)=>{
+        let request = importCache.current.get(resource);
+        if (request === undefined) {
+            request = importPluginModule(resource);
+            importCache.current.set(resource, request);
+            // Remove failed requests from the cache so they can potentially be retried
+            request.catch(()=>importCache.current.delete(resource));
+        }
+        return request;
+    });
+    const getPlugin = (0, _react.useCallback)(async (pluginType, kind)=>{
+        // Get the indexes of the installed plugins
+        const pluginIndexes = await getPluginIndexes();
+        // Figure out what module the plugin is in by looking in the index
+        const typeAndKindKey = (0, _pluginIndexes.getTypeAndKindKey)(pluginType, kind);
+        const resource = pluginIndexes.pluginResourcesByTypeAndKind.get(typeAndKindKey);
+        if (resource === undefined) {
+            throw new Error(`A ${pluginType} plugin for kind '${kind}' is not installed`);
+        }
+        // Treat the plugin module as a bunch of named exports that have plugins
+        const pluginModule = await loadPluginModule(resource);
+        // We currently assume that plugin modules will have named exports that match the kinds they handle
+        const plugin = pluginModule[kind];
+        if (plugin === undefined) {
+            throw new Error(`The ${pluginType} plugin for kind '${kind}' is missing from the ${resource.metadata.name} plugin module`);
+        }
+        return plugin;
+    }, [
+        getPluginIndexes,
+        loadPluginModule
+    ]);
+    const listPluginMetadata = (0, _react.useCallback)(async (pluginType)=>{
+        const pluginIndexes = await getPluginIndexes();
+        var ref;
+        return (ref = pluginIndexes.pluginMetadataByType.get(pluginType)) !== null && ref !== void 0 ? ref : [];
+    }, [
+        getPluginIndexes
+    ]);
+    // Create the registry's context value and render
+    const context = (0, _react.useMemo)(()=>({
+            getPlugin,
+            listPluginMetadata,
+            defaultPluginKinds
+        }), [
+        getPlugin,
+        listPluginMetadata,
+        defaultPluginKinds
+    ]);
+    return /*#__PURE__*/ (0, _jsxRuntime.jsx)(_runtime.PluginRegistryContext.Provider, {
+        value: context,
+        children: children
+    });
+}

package/dist/cjs/components/PluginRegistry/PluginRegistry.test.js

@@ -0,0 +1,144 @@
+// 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
+});
+const _jsxRuntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interopRequireDefault(require("react"));
+const _react1 = require("@testing-library/react");
+const _runtime = require("../../runtime");
+const _test = require("../../test");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+describe('PluginRegistry', ()=>{
+    const renderPluginRegistry = (children)=>{
+        (0, _test.renderWithContext)(children);
+    };
+    it('can load a plugin that exists', async ()=>{
+        renderPluginRegistry(/*#__PURE__*/ (0, _jsxRuntime.jsx)(PluginConsumer, {
+            pluginType: "Variable",
+            kind: "ErnieVariable"
+        }));
+        const hasPlugin = await _react1.screen.findByText('Has plugin: true', undefined, {
+            timeout: 3000
+        });
+        expect(hasPlugin).toBeInTheDocument();
+    });
+    it('errors when plugin is not installed', async ()=>{
+        // This plugin is not in the test metadata at all
+        renderPluginRegistry(/*#__PURE__*/ (0, _jsxRuntime.jsx)(PluginConsumer, {
+            pluginType: "TimeSeriesQuery",
+            kind: "NotInstalled"
+        }));
+        const error = await _react1.screen.findByText(/error:/i);
+        expect(error).toBeInTheDocument();
+        expect(error).toHaveTextContent(/not installed/i);
+    });
+    it('errors when plugin is missing from the module', async ()=>{
+        // This plugin is in the test metadata, but the code is missing from the module
+        renderPluginRegistry(/*#__PURE__*/ (0, _jsxRuntime.jsx)(PluginConsumer, {
+            pluginType: "Variable",
+            kind: "MissingErnieVariable"
+        }));
+        const error = await _react1.screen.findByText(/error:/i);
+        expect(error).toBeInTheDocument();
+        expect(error).toHaveTextContent(/missing/i);
+    });
+    it('lists metadata for plugin metadata that exists', async ()=>{
+        // There should be 3 variable plugins across both test modules
+        renderPluginRegistry(/*#__PURE__*/ (0, _jsxRuntime.jsx)(MetadataConsumer, {
+            pluginType: "Variable"
+        }));
+        const table = await _react1.screen.findByRole('table');
+        expect(table).toBeInTheDocument();
+        const rows = _react1.screen.getAllByRole('row');
+        expect(rows).toHaveLength(3);
+    });
+    it('lists metadata for plugin types with no plugins available', async ()=>{
+        // There are no TimeSeriesQuery plugins in any of the test modules
+        renderPluginRegistry(/*#__PURE__*/ (0, _jsxRuntime.jsx)(MetadataConsumer, {
+            pluginType: "TimeSeriesQuery"
+        }));
+        const table = await _react1.screen.findByRole('table');
+        expect(table).toBeInTheDocument();
+        const rows = _react1.screen.queryAllByRole('row');
+        expect(rows).toHaveLength(0);
+    });
+});
+// A helper component for testing the PluginRegistry by calling usePlugin to load a plugin
+const PluginConsumer = (props)=>{
+    const { data: plugin , isLoading , error  } = (0, _runtime.usePlugin)(props.pluginType, props.kind);
+    if (error) {
+        return /*#__PURE__*/ (0, _jsxRuntime.jsxs)("div", {
+            children: [
+                "Error: ",
+                error.message
+            ]
+        });
+    }
+    if (isLoading) {
+        return /*#__PURE__*/ (0, _jsxRuntime.jsx)("div", {
+            children: "Loading"
+        });
+    }
+    return /*#__PURE__*/ (0, _jsxRuntime.jsxs)("div", {
+        children: [
+            "Has plugin: ",
+            (plugin !== undefined).toString()
+        ]
+    });
+};
+// A helper component for testing the PluginRegistry metadata APIs by calling useListPluginMetadata
+const MetadataConsumer = (props)=>{
+    const { data: pluginMetadata , isLoading , error  } = (0, _runtime.useListPluginMetadata)(props.pluginType);
+    if (error) {
+        return /*#__PURE__*/ (0, _jsxRuntime.jsxs)("div", {
+            children: [
+                "Error: ",
+                error.message
+            ]
+        });
+    }
+    if (isLoading) {
+        return /*#__PURE__*/ (0, _jsxRuntime.jsx)("div", {
+            children: "Loading"
+        });
+    }
+    if (pluginMetadata === undefined) {
+        return null;
+    }
+    return /*#__PURE__*/ (0, _jsxRuntime.jsx)("table", {
+        children: /*#__PURE__*/ (0, _jsxRuntime.jsx)("tbody", {
+            children: pluginMetadata.map((item)=>/*#__PURE__*/ (0, _jsxRuntime.jsxs)("tr", {
+                    children: [
+                        /*#__PURE__*/ (0, _jsxRuntime.jsx)("td", {
+                            children: item.pluginType
+                        }),
+                        /*#__PURE__*/ (0, _jsxRuntime.jsx)("td", {
+                            children: item.kind
+                        }),
+                        /*#__PURE__*/ (0, _jsxRuntime.jsx)("td", {
+                            children: item.display.name
+                        }),
+                        /*#__PURE__*/ (0, _jsxRuntime.jsx)("td", {
+                            children: item.display.description
+                        })
+                    ]
+                }, item.kind))
+        })
+    });
+};

package/dist/cjs/components/PluginRegistry/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("./PluginRegistry"), 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/components/PluginRegistry/plugin-indexes.js

@@ -0,0 +1,78 @@
+// 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, {
+    usePluginIndexes: ()=>usePluginIndexes,
+    getTypeAndKindKey: ()=>getTypeAndKindKey
+});
+const _core = require("@perses-dev/core");
+const _react = require("react");
+function usePluginIndexes(getInstalledPlugins) {
+    // Creates indexes from the installed plugins data (does useEvent because this accesses the getInstalledPlugins prop
+    // and we want a stable reference for the callback below)
+    const createPluginIndexes = (0, _core.useEvent)(async ()=>{
+        const installedPlugins = await getInstalledPlugins();
+        // Create the two indexes from the installed plugins
+        const pluginResourcesByTypeAndKind = new Map();
+        const pluginMetadataByType = new Map();
+        for (const resource of installedPlugins){
+            for (const pluginMetadata of resource.spec.plugins){
+                const { pluginType , kind  } = pluginMetadata;
+                // Index the plugin by type and kind to point at the module that contains it
+                const key = getTypeAndKindKey(pluginType, kind);
+                if (pluginResourcesByTypeAndKind.has(key)) {
+                    console.warn(`Got more than one ${pluginType} plugin for kind ${kind}`);
+                }
+                pluginResourcesByTypeAndKind.set(key, resource);
+                // Index the metadata by plugin type
+                let list = pluginMetadataByType.get(pluginType);
+                if (list === undefined) {
+                    list = [];
+                    pluginMetadataByType.set(pluginType, list);
+                }
+                list.push(pluginMetadata);
+            }
+        }
+        return {
+            pluginResourcesByTypeAndKind,
+            pluginMetadataByType
+        };
+    });
+    // De-dupe creating plugin indexes (i.e. requests to get installed plugins)
+    const pluginIndexesCache = (0, _react.useRef)(undefined);
+    const getPluginIndexes = (0, _react.useCallback)(()=>{
+        let request = pluginIndexesCache.current;
+        if (request === undefined) {
+            request = createPluginIndexes();
+            pluginIndexesCache.current = request;
+            // Remove failed requests from the cache so they can potentially be retried
+            request.catch(()=>pluginIndexesCache.current === undefined);
+        }
+        return request;
+    }, [
+        createPluginIndexes
+    ]);
+    return getPluginIndexes;
+}
+function getTypeAndKindKey(pluginType, kind) {
+    return `${pluginType}:${kind}`;
+}

package/dist/cjs/components/PluginSpecEditor.js

@@ -0,0 +1,43 @@
+// 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, "PluginSpecEditor", {
+    enumerable: true,
+    get: ()=>PluginSpecEditor
+});
+const _jsxRuntime = require("react/jsx-runtime");
+const _components = require("@perses-dev/components");
+const _runtime = require("../runtime");
+function PluginSpecEditor(props) {
+    const { pluginType , pluginKind , ...others } = props;
+    const { data: plugin , isLoading , error  } = (0, _runtime.usePlugin)(pluginType, pluginKind);
+    if (error) {
+        return /*#__PURE__*/ (0, _jsxRuntime.jsx)(_components.ErrorAlert, {
+            error: error
+        });
+    }
+    // TODO: Proper loading indicator
+    if (isLoading) {
+        return null;
+    }
+    if (plugin === undefined) {
+        throw new Error(`Missing OptionsEditorComponent for ${pluginType} plugin with kind '${pluginKind}'`);
+    }
+    const { OptionsEditorComponent  } = plugin;
+    return /*#__PURE__*/ (0, _jsxRuntime.jsx)(OptionsEditorComponent, {
+        ...others
+    });
+}

package/dist/cjs/components/PluginSpecEditor.test.js

@@ -0,0 +1,70 @@
+// 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
+});
+const _jsxRuntime = require("react/jsx-runtime");
+const _userEvent = /*#__PURE__*/ _interopRequireDefault(require("@testing-library/user-event"));
+const _react = require("@testing-library/react");
+const _test = require("../test");
+const _pluginSpecEditor = require("./PluginSpecEditor");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+describe('PluginSpecEditor', ()=>{
+    const renderComponent = (props)=>{
+        (0, _test.renderWithContext)(/*#__PURE__*/ (0, _jsxRuntime.jsx)(_pluginSpecEditor.PluginSpecEditor, {
+            ...props
+        }));
+    };
+    it('shows the options editor component for a plugin', async ()=>{
+        renderComponent({
+            pluginType: 'Panel',
+            pluginKind: 'BertPanel1',
+            value: {},
+            onChange: jest.fn()
+        });
+        const editor = await _react.screen.findByLabelText('BertPanel1 editor');
+        expect(editor).toBeInTheDocument();
+    });
+    it('propagates value changes', async ()=>{
+        const onChange = jest.fn();
+        renderComponent({
+            pluginType: 'Panel',
+            pluginKind: 'BertPanel1',
+            value: {
+                option1: 'Option1Value'
+            },
+            onChange
+        });
+        const editor = await _react.screen.findByLabelText('BertPanel1 editor');
+        expect(editor).toHaveValue('Option1Value');
+        _userEvent.default.clear(editor);
+        expect(onChange).toHaveBeenCalledWith({
+            option1: ''
+        });
+    });
+    it('shows an error if plugin fails to load', async ()=>{
+        renderComponent({
+            pluginType: 'Variable',
+            pluginKind: 'DoesNotExist',
+            value: {},
+            onChange: jest.fn()
+        });
+        const errorAlert = await _react.screen.findByRole('alert');
+        expect(errorAlert).toHaveTextContent(/doesnotexist/i);
+    });
+});

package/dist/cjs/components/TimeSeriesQueryEditor.js

@@ -0,0 +1,42 @@
+// 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, "TimeSeriesQueryEditor", {
+    enumerable: true,
+    get: ()=>TimeSeriesQueryEditor
+});
+const _jsxRuntime = require("react/jsx-runtime");
+const _material = require("@mui/material");
+const _immer = require("immer");
+const _pluginEditor = require("./PluginEditor");
+function TimeSeriesQueryEditor(props) {
+    const { value , onChange , ...others } = props;
+    const { spec: { plugin  } ,  } = value;
+    const handlePluginChange = (next)=>{
+        onChange((0, _immer.produce)(value, (draft)=>{
+            draft.spec.plugin = next;
+        }));
+    };
+    return /*#__PURE__*/ (0, _jsxRuntime.jsx)(_material.Box, {
+        ...others,
+        children: /*#__PURE__*/ (0, _jsxRuntime.jsx)(_pluginEditor.PluginEditor, {
+            pluginType: "TimeSeriesQuery",
+            pluginKindLabel: "Query Type",
+            value: plugin,
+            onChange: handlePluginChange
+        })
+    });
+}

package/dist/cjs/components/index.js

@@ -0,0 +1,35 @@
+// 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("./CalculationSelector"), exports);
+_exportStar(require("./DatasourceSelect"), exports);
+_exportStar(require("./OptionsEditorTabs"), exports);
+_exportStar(require("./PluginEditor"), exports);
+_exportStar(require("./PluginKindSelect"), exports);
+_exportStar(require("./PluginRegistry"), exports);
+_exportStar(require("./PluginSpecEditor"), exports);
+_exportStar(require("./TimeSeriesQueryEditor"), 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/index.js

@@ -0,0 +1,31 @@
+// 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("./components"), exports);
+_exportStar(require("./model"), exports);
+_exportStar(require("./runtime"), exports);
+_exportStar(require("./test-utils"), 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;
+}