@cloudcare/guance-front-tools 1.0.11 → 1.0.12

package/README.md

@@ -17,3 +17,11 @@ $ grafanaCovertToGuance
 # run task
 $ grafanaCovertToGuance -d examples/grafana.json -o examples/guance.json
 ```
+
+Module usage:
+
+```ts
+import { covert } from '@cloudcare/guance-front-tools'
+
+const guanceDashboard = covert(grafanaDashboard)
+```

package/lib/cjs/scripts/grafana-covert-to-guance-core.d.ts

@@ -0,0 +1,4 @@
+import type { DashboardData as GuanceDashboardType } from '../generated/dashboardCharts';
+import type { DashboardData as GrafanaDashboardType, VariableModel, Panel, RowPanel } from './grafana-dashbord';
+export declare function covert(grafanaData: GrafanaDashboardType): GuanceDashboardType;
+export type { GrafanaDashboardType, Panel as GrafanaPanel, RowPanel as GrafanaRowPanel, VariableModel as GrafanaVariableModel };

package/lib/cjs/scripts/grafana-covert-to-guance-core.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.covert = covert;
+var grafanaPanelTypeToGuanceChartMap = {
+    stat: 'singlestat',
+    singlestat: 'singlestat',
+    barchart: 'bar',
+    timeseries: 'sequence',
+    graph: 'sequence',
+    piechart: 'pie',
+    histogram: 'histogram',
+    bargauge: 'toplist',
+    gauge: 'gauge',
+    table: 'table',
+    text: 'text',
+    heatmap: 'heatmap',
+    treemap: 'treemap',
+};
+var GRAFANA_KEYWORKD = ['__interval'];
+var VARIABLE_MAP = {
+    query: 'PROMQL_QUERY',
+    custom: 'CUSTOM_LIST',
+};
+var VARIABLE_DATASOURCE_MAP = {
+    query: 'dataflux',
+    custom: 'custom',
+};
+function isSupportedVariableType(type) {
+    return Object.prototype.hasOwnProperty.call(VARIABLE_MAP, type);
+}
+function replaceVariableStr(grafanaExpr) {
+    return grafanaExpr.replace(/\$\{?([\d_\w]+)\}?/g, function (match, variable) {
+        if (GRAFANA_KEYWORKD.indexOf(variable) > -1)
+            return match;
+        return "#{".concat(variable, "}");
+    });
+}
+function sortPanelItemsByRowCol(panels) {
+    return panels.slice(0).sort(function (panelA, panelB) {
+        var posA = panelA.gridPos;
+        var posB = panelB.gridPos;
+        if (!posA || !posB)
+            return -1;
+        if (posA.y === posB.y && posA.x === posB.x && posA.w > posB.w) {
+            return -1;
+        }
+        if (posA.y === posB.y && posA.x === posB.x) {
+            return 0;
+        }
+        if (posA.y > posB.y || (posA.y === posB.y && posA.x > posB.x)) {
+            return 1;
+        }
+        return -1;
+    });
+}
+function tenToTweenty(source) {
+    if (source === void 0) { source = 1; }
+    var numArr = [];
+    source--;
+    do {
+        numArr.push(source % 26);
+        source = Math.floor(source / 26);
+    } while (source > 0);
+    return numArr
+        .reverse()
+        .map(function (item, index) {
+        return String.fromCharCode(item + 97 + (index === numArr.length - 1 ? 0 : -1));
+    })
+        .join('')
+        .toLowerCase();
+}
+function getGridH(h, rowHeight, margin) {
+    return Math.round(h * rowHeight + Math.max(0, 2 * (h - 1)) * margin);
+}
+function getGuanceHByGrafanaH(granfanH) {
+    return (getGridH(granfanH, 30, 4) + 10) / 20;
+}
+function covertPanelToGuanceChart(grafanaPanel, rowPanel) {
+    var gridPos = grafanaPanel.gridPos, title = grafanaPanel.title, type = grafanaPanel.type, targets = grafanaPanel.targets, options = grafanaPanel.options;
+    var chartType = grafanaPanelTypeToGuanceChartMap[type];
+    var pos = {
+        x: gridPos.x,
+        w: gridPos.w,
+        y: gridPos.y,
+        h: gridPos.h,
+    };
+    if (rowPanel) {
+        var rowGridPos = rowPanel.gridPos;
+        if (rowGridPos && gridPos && !rowPanel.collapsed) {
+            pos = {
+                x: gridPos.x,
+                w: gridPos.w,
+                y: gridPos.y - rowGridPos.y,
+                h: gridPos.h,
+            };
+        }
+    }
+    var queries = [];
+    if (targets && targets.length) {
+        var currentIndex_1 = 0;
+        targets.forEach(function (_target) {
+            var queryStr = _target.expr || _target.query || _target.queryText;
+            if (!queryStr)
+                return;
+            currentIndex_1++;
+            var queryItem = {
+                datasource: 'dataflux',
+                qtype: 'promql',
+                type: chartType,
+                query: {
+                    q: replaceVariableStr(queryStr),
+                    type: 'promql',
+                    code: tenToTweenty(currentIndex_1),
+                    promqlCode: currentIndex_1,
+                },
+            };
+            queries.push(queryItem);
+        });
+    }
+    var settings = {};
+    if (options) {
+        switch (chartType) {
+            case 'text':
+                queries.push({
+                    query: {
+                        content: options.content,
+                    },
+                });
+                break;
+            case 'toplist':
+                settings = {
+                    showTopSize: true,
+                    chartType: 'bar',
+                };
+                break;
+            default:
+                break;
+        }
+    }
+    return {
+        extend: {
+            settings: settings,
+        },
+        group: {
+            name: rowPanel ? rowPanel.title : null,
+        },
+        pos: {
+            x: pos.x,
+            y: getGuanceHByGrafanaH(pos.y),
+            h: getGuanceHByGrafanaH(pos.h),
+            w: pos.w,
+        },
+        name: replaceVariableStr(title || ''),
+        queries: queries,
+        type: chartType,
+    };
+}
+function covertPanelsToCharts(grafanaPanelData, rowPanel) {
+    var guanceCharts = [];
+    grafanaPanelData.forEach(function (grafanaPanel) {
+        if (!grafanaPanel.gridPos)
+            return;
+        guanceCharts.push(covertPanelToGuanceChart(grafanaPanel, rowPanel));
+    });
+    return guanceCharts;
+}
+function covert(grafanaData) {
+    var _a, _b, _c;
+    var covertGuanceResult = {};
+    covertGuanceResult.title = grafanaData.title;
+    var guanceVars = [];
+    (_b = (_a = grafanaData.templating) === null || _a === void 0 ? void 0 : _a.list) === null || _b === void 0 ? void 0 : _b.forEach(function (_variable, index) {
+        var current = _variable.current, type = _variable.type, allValue = _variable.allValue;
+        var variableType = String(type);
+        if (!isSupportedVariableType(variableType))
+            return;
+        var defaultVal = {
+            label: '',
+            value: '',
+        };
+        if (current) {
+            var labels = [];
+            var values = [];
+            if (Array.isArray(current.text)) {
+                labels = current.text;
+            }
+            else if (typeof current.text === 'string') {
+                labels = [current.text];
+            }
+            if (Array.isArray(current.value)) {
+                values = current.value;
+            }
+            else if (typeof current.value === 'string') {
+                values = [current.value];
+            }
+            labels = labels.map(function (label) {
+                if (label === 'All') {
+                    if (allValue === '.*') {
+                        return '*';
+                    }
+                    return 'all values';
+                }
+                return label;
+            });
+            values = values.map(function (value) {
+                if (value === '$__all') {
+                    if (allValue === '.*') {
+                        return '*';
+                    }
+                    return '__all__';
+                }
+                return value;
+            });
+            defaultVal = {
+                label: labels.join(','),
+                value: values.join(','),
+            };
+        }
+        var value = _variable.query;
+        if (value && typeof value === 'object' && value.query) {
+            value = replaceVariableStr(value.query);
+        }
+        else if (value && typeof value === 'string') {
+            value = replaceVariableStr(_variable.query);
+        }
+        else {
+            return;
+        }
+        var guanceVariableItem = {
+            type: VARIABLE_MAP[variableType],
+            datasource: VARIABLE_DATASOURCE_MAP[variableType],
+            name: _variable.label || _variable.name || '',
+            seq: index,
+            hide: _variable.hide ? 1 : 0,
+            multiple: _variable.multi !== undefined ? _variable.multi : true,
+            includeStar: _variable.includeAll !== undefined ? _variable.includeAll : true,
+            valueSort: 'desc',
+            code: _variable.name,
+            definition: {
+                value: value,
+                defaultVal: defaultVal,
+            },
+        };
+        guanceVars.push(guanceVariableItem);
+    });
+    var guanceGroups = [];
+    var guanceExpand = {};
+    var guanceCharts = [];
+    var lastRowPanel;
+    var lastPanels = [];
+    var grafanaCharts = ((_c = grafanaData.panels) === null || _c === void 0 ? void 0 : _c.filter(function (_panel) { return _panel.type === 'row' || grafanaPanelTypeToGuanceChartMap[_panel.type]; })) || [];
+    grafanaCharts = sortPanelItemsByRowCol(grafanaCharts);
+    grafanaCharts.forEach(function (_panel) {
+        var _a;
+        if (_panel.type === 'row') {
+            var _rowPanel = _panel;
+            if (_rowPanel.title) {
+                guanceGroups.push({
+                    name: _rowPanel.title,
+                });
+                guanceExpand[_rowPanel.title] = !_rowPanel.collapsed;
+            }
+            if (lastPanels.length) {
+                guanceCharts.push.apply(guanceCharts, covertPanelsToCharts(lastPanels, lastRowPanel));
+                lastPanels = [];
+                lastRowPanel = undefined;
+            }
+            if (_rowPanel.collapsed) {
+                var subPanels = ((_a = _rowPanel.panels) === null || _a === void 0 ? void 0 : _a.filter(function (_childPanel) {
+                    return _childPanel.type === 'row' || grafanaPanelTypeToGuanceChartMap[_childPanel.type];
+                })) || [];
+                guanceCharts.push.apply(guanceCharts, covertPanelsToCharts(subPanels, _rowPanel));
+            }
+            else {
+                lastRowPanel = _rowPanel;
+            }
+        }
+        else {
+            lastPanels.push(_panel);
+        }
+    });
+    if (lastPanels.length) {
+        guanceCharts.push.apply(guanceCharts, covertPanelsToCharts(lastPanels, lastRowPanel));
+    }
+    covertGuanceResult.dashboardExtend = {
+        groupUnfoldStatus: guanceExpand,
+    };
+    covertGuanceResult.main = {
+        vars: guanceVars,
+        charts: guanceCharts,
+        groups: guanceGroups,
+    };
+    return covertGuanceResult;
+}