@perses-dev/tracing-gantt-chart-plugin 0.6.0

package/lib/cjs/TracingGanttChart/Ticks.js

@@ -0,0 +1,106 @@
+// Copyright 2024 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, {
+    Ticks: function() {
+        return Ticks;
+    },
+    TicksHeader: function() {
+        return TicksHeader;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _material = require("@mui/material");
+const _utils = require("./utils");
+function TicksHeader(props) {
+    const { trace, viewport } = props;
+    const duration = viewport.endTimeUnixMs - viewport.startTimeUnixMs;
+    const startAt = viewport.startTimeUnixMs - trace.startTimeUnixMs;
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+        children: [
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(TickBox, {
+                style: {
+                    left: '0%',
+                    borderWidth: 0
+                },
+                children: (0, _utils.formatDuration)(startAt + duration * 0)
+            }),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(TickBox, {
+                style: {
+                    left: '25%'
+                },
+                children: (0, _utils.formatDuration)(startAt + duration * 0.25)
+            }),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(TickBox, {
+                style: {
+                    left: '50%'
+                },
+                children: (0, _utils.formatDuration)(startAt + duration * 0.5)
+            }),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(TickBox, {
+                style: {
+                    left: '75%'
+                },
+                children: (0, _utils.formatDuration)(startAt + duration * 0.75)
+            }),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(TickBox, {
+                style: {
+                    left: '100%'
+                },
+                children: /*#__PURE__*/ (0, _jsxruntime.jsx)("span", {
+                    style: {
+                        position: 'absolute',
+                        right: '.75rem'
+                    },
+                    children: (0, _utils.formatDuration)(startAt + duration * 1)
+                })
+            })
+        ]
+    });
+}
+function Ticks() {
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+        children: [
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(TickBox, {
+                style: {
+                    left: '25%'
+                }
+            }),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(TickBox, {
+                style: {
+                    left: '50%'
+                }
+            }),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(TickBox, {
+                style: {
+                    left: '75%'
+                }
+            })
+        ]
+    });
+}
+const TickBox = (0, _material.styled)(_material.Box)(({ theme })=>({
+        position: 'absolute',
+        height: '100%',
+        borderLeft: `1px solid ${theme.palette.divider}`,
+        padding: '.25rem'
+    }));

package/lib/cjs/TracingGanttChart/TracingGanttChart.js

@@ -0,0 +1,109 @@
+// Copyright 2024 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, "TracingGanttChart", {
+    enumerable: true,
+    get: function() {
+        return TracingGanttChart;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = require("react");
+const _material = require("@mui/material");
+const _MiniGanttChart = require("./MiniGanttChart/MiniGanttChart");
+const _DetailPane = require("./DetailPane/DetailPane");
+const _GanttTable = require("./GanttTable/GanttTable");
+const _GanttTableProvider = require("./GanttTable/GanttTableProvider");
+const _ResizableDivider = require("./GanttTable/ResizableDivider");
+const _trace = require("./trace");
+function TracingGanttChart(props) {
+    const { options, attributeLinks, trace: otlpTrace } = props;
+    const theme = (0, _material.useTheme)();
+    const trace = (0, _react.useMemo)(()=>{
+        try {
+            return (0, _trace.getTraceModel)(otlpTrace);
+        } catch (e) {
+            throw new Error(`Error: unable to parse trace: ${e}`);
+        }
+    }, [
+        otlpTrace
+    ]);
+    const [viewport, setViewport] = (0, _react.useState)({
+        startTimeUnixMs: trace.startTimeUnixMs,
+        endTimeUnixMs: trace.endTimeUnixMs
+    });
+    const [selectedSpan, setSelectedSpan] = (0, _react.useState)(undefined);
+    const ganttChart = (0, _react.useRef)(null);
+    // tableWidth only comes to effect if the detail pane is visible.
+    // setTableWidth() is only called by <ResizableDivider />
+    const [tableWidth, setTableWidth] = (0, _react.useState)(0.82);
+    const gap = 2;
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_material.Stack, {
+        ref: ganttChart,
+        direction: "row",
+        sx: {
+            height: '100%',
+            minHeight: '240px',
+            gap
+        },
+        children: [
+            /*#__PURE__*/ (0, _jsxruntime.jsxs)(_material.Stack, {
+                sx: {
+                    flexGrow: 1,
+                    gap
+                },
+                children: [
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(_MiniGanttChart.MiniGanttChart, {
+                        options: options,
+                        trace: trace,
+                        viewport: viewport,
+                        setViewport: setViewport
+                    }),
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(_GanttTableProvider.GanttTableProvider, {
+                        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_GanttTable.GanttTable, {
+                            options: options,
+                            trace: trace,
+                            viewport: viewport,
+                            selectedSpan: selectedSpan,
+                            onSpanClick: setSelectedSpan
+                        })
+                    })
+                ]
+            }),
+            selectedSpan && /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+                children: [
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(_ResizableDivider.ResizableDivider, {
+                        parentRef: ganttChart,
+                        spacing: parseInt(theme.spacing(gap)),
+                        onMove: setTableWidth
+                    }),
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(_material.Box, {
+                        sx: {
+                            width: `${(1 - tableWidth) * 100}%`,
+                            overflow: 'auto'
+                        },
+                        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_DetailPane.DetailPane, {
+                            attributeLinks: attributeLinks,
+                            trace: trace,
+                            span: selectedSpan,
+                            onCloseBtnClick: ()=>setSelectedSpan(undefined)
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}

package/lib/cjs/TracingGanttChart/palette.js

@@ -0,0 +1,83 @@
+// Copyright 2024 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, {
+    getConsistentCategoricalColor: function() {
+        return getConsistentCategoricalColor;
+    },
+    getConsistentColor: function() {
+        return getConsistentColor;
+    }
+});
+const _colorhash = /*#__PURE__*/ _interop_require_default(require("color-hash"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+// Valid hue values are 0 to 360 and can be adjusted to control the generated colors.
+// More info: https://github.com/zenozeng/color-hash#custom-hue
+// Picked min of 20 and max of 360 to exclude common threshold colors (red).
+// Items with "error" in them will always be generated as red.
+const ERROR_HUE_CUTOFF = 20;
+const colorGenerator = new _colorhash.default({
+    hue: {
+        min: ERROR_HUE_CUTOFF,
+        max: 360
+    }
+});
+const redColorGenerator = new _colorhash.default({
+    hue: {
+        min: 0,
+        max: ERROR_HUE_CUTOFF
+    }
+});
+function computeConsistentColor(name, error) {
+    const [hue, saturation, lightness] = error ? redColorGenerator.hsl(name) : colorGenerator.hsl(name);
+    const saturationPercent = `${(saturation * 100).toFixed(0)}%`;
+    const lightnessPercent = `${(lightness * 100).toFixed(0)}%`;
+    return `hsla(${hue.toFixed(2)},${saturationPercent},${lightnessPercent},0.9)`;
+}
+// To check whether a color has already been generated for a given string.
+// TODO: Predefined color aliases will be defined here
+const colorLookup = {};
+function getConsistentColor(name, error) {
+    const key = `${name}_____${error}`;
+    let value = colorLookup[key];
+    if (!value) {
+        value = computeConsistentColor(name, error);
+        colorLookup[key] = value;
+    }
+    return value;
+}
+function getConsistentCategoricalColor(name, error, categoricalPalette, errorPalette) {
+    const palette = error ? errorPalette : categoricalPalette;
+    if (palette.length === 0) {
+        console.warn('getConsistentCategoricalColor() called with empty color palette, fallback to #000');
+        return '#000';
+    }
+    let hash = 0;
+    for(let i = 0; i < name.length; i++){
+        hash = name.charCodeAt(i) + ((hash << 5) - hash);
+    }
+    return palette[Math.abs(hash) % palette.length] ?? '#000';
+}

package/lib/cjs/TracingGanttChart/trace.js

@@ -0,0 +1,113 @@
+// Copyright 2024 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, "getTraceModel", {
+    enumerable: true,
+    get: function() {
+        return getTraceModel;
+    }
+});
+const _lodash = require("lodash");
+function getTraceModel(trace) {
+    // first pass: build lookup table <spanId, Span> and compute min/max
+    const lookup = new Map();
+    const rootSpans = [];
+    let startTimeUnixMs = 0;
+    let endTimeUnixMs = 0;
+    for (const resourceSpan of trace.resourceSpans){
+        const resource = parseResource(resourceSpan.resource);
+        for (const scopeSpan of resourceSpan.scopeSpans){
+            const scope = parseScope(scopeSpan.scope);
+            for (const otelSpan of scopeSpan.spans){
+                const span = {
+                    resource,
+                    scope,
+                    childSpans: [],
+                    ...parseSpan(otelSpan)
+                };
+                lookup.set(otelSpan.spanId, span);
+                if (startTimeUnixMs === 0 || span.startTimeUnixMs < startTimeUnixMs) {
+                    startTimeUnixMs = span.startTimeUnixMs;
+                }
+                if (endTimeUnixMs === 0 || span.endTimeUnixMs > endTimeUnixMs) {
+                    endTimeUnixMs = span.endTimeUnixMs;
+                }
+            }
+        }
+    }
+    // second pass: build tree based on parentSpanId property
+    for (const [, span] of lookup){
+        if (!span.parentSpanId) {
+            rootSpans.push(span);
+            continue;
+        }
+        const parent = lookup.get(span.parentSpanId);
+        if (!parent) {
+            console.trace(`span ${span.spanId} has parent ${span.parentSpanId} which has not been received yet`);
+            rootSpans.push(span);
+            continue;
+        }
+        span.parentSpan = parent;
+        const insertChildSpanAt = (0, _lodash.sortedIndexBy)(parent.childSpans, span, (s)=>s.startTimeUnixMs);
+        parent.childSpans.splice(insertChildSpanAt, 0, span);
+    }
+    return {
+        trace,
+        rootSpans,
+        startTimeUnixMs,
+        endTimeUnixMs
+    };
+}
+function parseResource(resource) {
+    let serviceName = 'unknown';
+    for (const attr of resource?.attributes ?? []){
+        if (attr.key === 'service.name' && 'stringValue' in attr.value) {
+            serviceName = attr.value.stringValue;
+            break;
+        }
+    }
+    return {
+        serviceName,
+        attributes: resource?.attributes ?? []
+    };
+}
+function parseScope(scope) {
+    return scope ?? {};
+}
+/**
+ * parseSpan parses the Span API type to the internal representation
+ * i.e. convert strings to numbers etc.
+ */ function parseSpan(span) {
+    return {
+        traceId: span.traceId,
+        spanId: span.spanId,
+        parentSpanId: span.parentSpanId,
+        name: span.name,
+        kind: span.kind,
+        startTimeUnixMs: parseInt(span.startTimeUnixNano) * 1e-6,
+        endTimeUnixMs: parseInt(span.endTimeUnixNano) * 1e-6,
+        attributes: span.attributes ?? [],
+        events: (span.events ?? []).map(parseEvent),
+        status: span.status ?? {}
+    };
+}
+function parseEvent(event) {
+    return {
+        timeUnixMs: parseInt(event.timeUnixNano) * 1e-6,
+        name: event.name,
+        attributes: event.attributes ?? []
+    };
+}

package/lib/cjs/TracingGanttChart/utils.js

@@ -0,0 +1,76 @@
+// Copyright 2024 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, {
+    formatDuration: function() {
+        return formatDuration;
+    },
+    getServiceColor: function() {
+        return getServiceColor;
+    },
+    getSpanColor: function() {
+        return getSpanColor;
+    },
+    minSpanWidthPx: function() {
+        return minSpanWidthPx;
+    },
+    rowHeight: function() {
+        return rowHeight;
+    },
+    spanHasError: function() {
+        return spanHasError;
+    }
+});
+const _core = require("@perses-dev/core");
+const _palette = require("./palette");
+const minSpanWidthPx = 2;
+const rowHeight = '2rem';
+const spanHasError = (span)=>span.status?.code === _core.otlptracev1.StatusCodeError;
+function getServiceColor(muiTheme, chartsTheme, paletteMode, serviceName, error = false) {
+    switch(paletteMode){
+        case 'categorical':
+            {
+                // ECharts type for color is not always an array but it is always an array in ChartsProvider
+                const categoricalPalette = chartsTheme.echartsTheme.color;
+                const errorPalette = [
+                    muiTheme.palette.error.light,
+                    muiTheme.palette.error.main,
+                    muiTheme.palette.error.dark
+                ];
+                return (0, _palette.getConsistentCategoricalColor)(serviceName, error, categoricalPalette, errorPalette);
+            }
+        default:
+            return (0, _palette.getConsistentColor)(serviceName, error);
+    }
+}
+function getSpanColor(muiTheme, chartsTheme, paletteMode, span) {
+    return getServiceColor(muiTheme, chartsTheme, paletteMode, span.resource.serviceName ?? '', spanHasError(span));
+}
+function formatDuration(timeMs) {
+    if (timeMs < 1) {
+        return `${Math.round(timeMs * 1000)}μs`;
+    }
+    if (timeMs < 1000) {
+        return `${+timeMs.toFixed(2)}ms`;
+    }
+    return `${+(timeMs / 1000).toFixed(2)}s`;
+}

package/lib/cjs/TracingGanttChart.js

@@ -0,0 +1,31 @@
+// Copyright 2024 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, "TracingGanttChart", {
+    enumerable: true,
+    get: function() {
+        return TracingGanttChart;
+    }
+});
+const _ganttchartmodel = require("./gantt-chart-model");
+const _TracingGanttChartPanel = require("./TracingGanttChartPanel");
+const TracingGanttChart = {
+    PanelComponent: _TracingGanttChartPanel.TracingGanttChartPanel,
+    supportedQueryTypes: [
+        'TraceQuery'
+    ],
+    createInitialOptions: _ganttchartmodel.createInitialTracingGanttChartOptions
+};

package/lib/cjs/TracingGanttChartPanel.js

@@ -0,0 +1,53 @@
+// Copyright 2024 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, "TracingGanttChartPanel", {
+    enumerable: true,
+    get: function() {
+        return TracingGanttChartPanel;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _components = require("@perses-dev/components");
+const _material = require("@mui/material");
+const _TracingGanttChart = require("./TracingGanttChart/TracingGanttChart");
+function TracingGanttChartPanel(props) {
+    const { spec, queryResults, attributeLinks } = props;
+    const chartsTheme = (0, _components.useChartsTheme)();
+    const contentPadding = chartsTheme.container.padding.default;
+    if (queryResults.length > 1) {
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)(_components.TextOverlay, {
+            message: "This panel does not support more than one query."
+        });
+    }
+    const trace = queryResults[0]?.data.trace;
+    if (!trace) {
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)(_components.NoDataOverlay, {
+            resource: "trace"
+        });
+    }
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_material.Box, {
+        sx: {
+            height: '100%',
+            padding: `${contentPadding}px`
+        },
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_TracingGanttChart.TracingGanttChart, {
+            options: spec,
+            attributeLinks: attributeLinks,
+            trace: trace
+        })
+    });
+}

package/lib/cjs/bootstrap.js

@@ -0,0 +1,26 @@
+// Copyright 2024 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__*/ _interop_require_default(require("react"));
+const _client = /*#__PURE__*/ _interop_require_default(require("react-dom/client"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const root = _client.default.createRoot(document.getElementById('root'));
+root.render(/*#__PURE__*/ (0, _jsxruntime.jsx)(_react.default.StrictMode, {}));

package/lib/cjs/env.d.js

@@ -0,0 +1,14 @@
+// Copyright 2024 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.
+/// <reference types="@rsbuild/core/types" />
+"use strict";

package/lib/cjs/gantt-chart-model.js

@@ -0,0 +1,28 @@
+// Copyright 2024 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.
+/**
+ * The Options object type supported by the TracingGanttChart panel plugin.
+ */ // Note: The interface attributes must match cue/schemas/panels/tracing-gantt-chart/tracing-gantt-chart.cue
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createInitialTracingGanttChartOptions", {
+    enumerable: true,
+    get: function() {
+        return createInitialTracingGanttChartOptions;
+    }
+});
+function createInitialTracingGanttChartOptions() {
+    return {};
+}

package/lib/cjs/getPluginModule.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getPluginModule", {
+    enumerable: true,
+    get: function() {
+        return getPluginModule;
+    }
+});
+const _packagejson = /*#__PURE__*/ _interop_require_default(require("../package.json"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getPluginModule() {
+    const { name, version, perses } = _packagejson.default;
+    return {
+        kind: 'PluginModule',
+        metadata: {
+            name,
+            version
+        },
+        spec: perses
+    };
+}