https://app.nichebrains.ai/_content/ChartJs.Blazor.Fork/ChartJsBlazorInterop.js

1"use strict";
2class ChartJsInterop {
3    constructor() {
4        this.BlazorCharts = new Map();
5    }
6    setupChart(config) {
7        if (!this.BlazorCharts.has(config.canvasId)) {
8            this.wireUpCallbacks(config);
9            let chart = new Chart(config.canvasId, config);
10            this.BlazorCharts.set(config.canvasId, chart);
11            return true;
12        }
13        else {
14            return this.updateChart(config);
15        }
16    }
17    updateChart(config) {
18        if (!this.BlazorCharts.has(config.canvasId))
19            throw `Could not find a chart with the given id. ${config.canvasId}`;
20        let myChart = this.BlazorCharts.get(config.canvasId);
21        this.mergeDatasets(myChart.config.data.datasets, config.data.datasets);
22        this.mergeLabels(myChart.config.data, config.data);
23        this.wireUpCallbacks(config);
24        Chart.helpers.extend(myChart.config.options, config.options);
25        myChart.update();
26        return true;
27    }
28    mergeDatasets(oldDatasets, newDatasets) {
29        for (let i = oldDatasets.length - 1; i >= 0; i--) {
30            let sameDatasetInNewConfig = newDatasets.find(newD => newD.id === oldDatasets[i].id);
31            if (sameDatasetInNewConfig === undefined) {
32                oldDatasets.splice(i, 1);
33            }
34            else {
35                Chart.helpers.extend(oldDatasets[i], sameDatasetInNewConfig);
36            }
37        }
38        let currentIds = oldDatasets.map(dataset => dataset.id);
39        newDatasets.filter(newDataset => !currentIds.includes(newDataset.id))
40            .forEach(newDataset => oldDatasets.push(newDataset));
41    }
42    mergeLabels(oldChartData, newChartData) {
43        const innerFunc = (oldLabels, newLabels) => {
44            if (newLabels == null || newLabels.length === 0) {
45                if (oldLabels) {
46                    oldLabels.length = 0;
47                }
48                return oldLabels;
49            }
50            if (oldLabels == null) {
51                return newLabels;
52            }
53            oldLabels.length = 0;
54            for (var i = 0; i < newLabels.length; i++) {
55                oldLabels.push(newLabels[i]);
56            }
57            return oldLabels;
58        };
59        oldChartData.labels = innerFunc(oldChartData.labels, newChartData.labels);
60        oldChartData.xLabels = innerFunc(oldChartData.xLabels, newChartData.xLabels);
61        oldChartData.yLabels = innerFunc(oldChartData.yLabels, newChartData.yLabels);
62    }
63    wireUpCallbacks(config) {
64        this.wireUpOptionsOnClick(config);
65        this.wireUpOptionsOnHover(config);
66        this.wireUpLegendOnClick(config);
67        this.wireUpLegendOnHover(config);
68        this.wireUpLegendItemFilter(config);
69        this.wireUpGenerateLabels(config);
70        this.wireUpTickCallback(config);
71    }
72    wireUpOptionsOnClick(config) {
73        let getDefaultFunc = type => {
74            let defaults = Chart.defaults[type] || Chart.defaults.global;
75            return (defaults === null || defaults === void 0 ? void 0 : defaults.onClick) || Chart.defaults.global.onClick;
76        };
77        if (!config.options)
78            return;
79        config.options.onClick = this.getMethodHandler(config.options.onClick, getDefaultFunc(config.type));
80    }
81    wireUpOptionsOnHover(config) {
82        let getDefaultFunc = type => {
83            let defaults = Chart.defaults[type] || Chart.defaults.global;
84            return (defaults === null || defaults === void 0 ? void 0 : defaults.onHover) || Chart.defaults.global.onHover;
85        };
86        if (!config.options)
87            return;
88        config.options.onHover = this.getMethodHandler(config.options.onHover, getDefaultFunc(config.type));
89    }
90    wireUpLegendOnClick(config) {
91        var _a;
92        let getDefaultHandler = type => {
93            var _a;
94            let chartDefaults = Chart.defaults[type] || Chart.defaults.global;
95            return ((_a = chartDefaults === null || chartDefaults === void 0 ? void 0 : chartDefaults.legend) === null || _a === void 0 ? void 0 : _a.onClick) || Chart.defaults.global.legend.onClick;
96        };
97        if (!((_a = config.options) === null || _a === void 0 ? void 0 : _a.legend))
98            return;
99        config.options.legend.onClick = this.getMethodHandler(config.options.legend.onClick, getDefaultHandler(config.type));
100    }
101    wireUpLegendOnHover(config) {
102        var _a;
103        let getDefaultFunc = type => {
104            var _a;
105            let chartDefaults = Chart.defaults[type] || Chart.defaults.global;
106            return ((_a = chartDefaults === null || chartDefaults === void 0 ? void 0 : chartDefaults.legend) === null || _a === void 0 ? void 0 : _a.onHover) || Chart.defaults.global.legend.onHover;
107        };
108        if (!((_a = config.options) === null || _a === void 0 ? void 0 : _a.legend))
109            return;
110        config.options.legend.onHover = this.getMethodHandler(config.options.legend.onHover, getDefaultFunc(config.type));
111    }
112    wireUpLegendItemFilter(config) {
113        var _a, _b;
114        let getDefaultFunc = type => {
115            var _a, _b;
116            let chartDefaults = Chart.defaults[type] || Chart.defaults.global;
117            return ((_b = (_a = chartDefaults === null || chartDefaults === void 0 ? void 0 : chartDefaults.legend) === null || _a === void 0 ? void 0 : _a.labels) === null || _b === void 0 ? void 0 : _b.filter) || Chart.defaults.global.legend.labels.filter;
118        };
119        if (!((_b = (_a = config.options) === null || _a === void 0 ? void 0 : _a.legend) === null || _b === void 0 ? void 0 : _b.labels))
120            return;
121        config.options.legend.labels.filter = this.getMethodHandler(config.options.legend.labels.filter, getDefaultFunc(config.type));
122    }
123    wireUpGenerateLabels(config) {
124        var _a, _b;
125        let getDefaultFunc = type => {
126            var _a, _b;
127            let chartDefaults = Chart.defaults[type] || Chart.defaults.global;
128            return ((_b = (_a = chartDefaults === null || chartDefaults === void 0 ? void 0 : chartDefaults.legend) === null || _a === void 0 ? void 0 : _a.labels) === null || _b === void 0 ? void 0 : _b.generateLabels) || Chart.defaults.global.legend.labels.generateLabels;

129        };
130        if (!((_b = (_a = config.options) === null || _a === void 0 ? void 0 : _a.legend) === null || _b === void 0 ? void 0 : _b.labels))
131            return;
132        config.options.legend.labels.generateLabels = this.getMethodHandler(config.options.legend.labels.generateLabels, getDefaultFunc(config.type));
133    }
134    wireUpTickCallback(config) {
135        var _a, _b, _c;
136        const assignCallbacks = axes => {
137            if (axes) {
138                for (var i = 0; i < axes.length; i++) {
139                    if (!axes[i].ticks)
140                        continue;
141                    axes[i].ticks.callback = this.getMethodHandler(axes[i].ticks.callback, undefined);
142                    if (!axes[i].ticks.callback) {
143                        delete axes[i].ticks.callback;
144                    }
145                }
146            }
147        };
148        if ((_a = config.options) === null || _a === void 0 ? void 0 : _a.scales) {
149            assignCallbacks(config.options.scales.xAxes);
150            assignCallbacks(config.options.scales.yAxes);
151        }
152        if ((_c = (_b = config.options) === null || _b === void 0 ? void 0 : _b.scale) === null || _c === void 0 ? void 0 : _c.ticks) {
153            config.options.scale.ticks.callback = this.getMethodHandler(config.options.scale.ticks.callback, undefined);
154            if (!config.options.scale.ticks.callback) {
155                delete config.options.scale.ticks.callback;
156            }
157        }
158    }
159    getMethodHandler(handler, defaultFunc) {
160        if (handler == null) {
161            return defaultFunc;
162        }
163        if (this.isDelegateHandler(handler)) {
164            const stringifyArgs = (args) => {
165                for (var i = 0; i < args.length; i++) {
166                    if (handler.ignoredIndices.includes(i)) {
167                        args[i] = '';
168                    }
169                    else {
170                        args[i] = this.stringifyObjectIgnoreCircular(args[i]);
171                    }
172                }
173                return args;
174            };
175            if (!handler.returnsValue) {
176                return (...args) => handler.handlerReference.invokeMethodAsync(handler.methodName, stringifyArgs(args));
177            }
178            else {
179                if (window.hasOwnProperty('MONO')) {
180                    return (...args) => handler.handlerReference.invokeMethod(handler.methodName, stringifyArgs(args));
181                }
182                else {
183                    console.warn('Using C# delegates that return values in chart.js callbacks is not supported on ' +
184                        "server side blazor because the server side dispatcher doesn't support synchronous interop calls. Falling back to default value.");
185                    return defaultFunc;
186                }
187            }
188        }
189        else {
190            if (handler.methodName == null) {
191                return defaultFunc;
192            }
193            const namespaceAndFunc = handler.methodName.split('.');
194            if (namespaceAndFunc.length !== 2) {
195                return defaultFunc;
196            }
197            const namespace = window[namespaceAndFunc[0]];
198            if (namespace == null) {
199                return defaultFunc;
200            }
201            const func = namespace[namespaceAndFunc[1]];
202            if (typeof func === 'function') {
203                return func;
204            }
205            else {
206                return defaultFunc;
207            }
208        }
209    }
210    isDelegateHandler(handler) {
211        return 'handlerReference' in handler;
212    }
213    stringifyObjectIgnoreCircular(object) {
214        const seen = new WeakSet();
215        const replacer = (_name, value) => {
216            if (typeof value === 'object' &&
217                value !== null &&
218                !(value instanceof Boolean) &&
219                !(value instanceof Date) &&
220                !(value instanceof Number) &&
221                !(value instanceof RegExp) &&
222                !(value instanceof String)) {
223                if (seen.has(value))
224                    return undefined;
225                seen.add(value);
226            }
227            return value;
228        };
229        return JSON.stringify(object, replacer);
230    }
231}
232window[ChartJsInterop.name] = new ChartJsInterop();