survey-analytics 2.2.3 → 2.2.5

package/fesm/shared2.mjs

@@ -1,11 +1,11 @@
 /*!
- * surveyjs - SurveyJS Dashboard library v2.2.3
+ * surveyjs - SurveyJS Dashboard library v2.2.5
  * Copyright (c) 2015-2025 Devsoft Baltic OÜ  - http://surveyjs.io/
  * License: MIT (http://www.opensource.org/licenses/mit-license.php)
  */
 
-import { Event, QuestionCommentModel, settings, ItemValue, hasLicense, surveyLocalization, IsTouch, Helpers } from 'survey-core';
 import { D as DocumentHelper, l as localization, f as createLoadingIndicator, a as DataHelper, e as svgTemplate, d as createCommercialLicenseLink, t as toPrecision } from './shared.mjs';
+import { Event, QuestionCommentModel, settings, ItemValue, hasLicense, surveyLocalization, IsTouch, Helpers } from 'survey-core';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -217,10 +217,10 @@ class VisualizationManager {
     static getVisualizersByType(questionType) {
         let vDescrs = VisualizationManager.vizualizers[questionType];
         if (!vDescrs) {
-            if (VisualizerBase.suppressVisualizerStubRendering) {
+            if (VisualizationManager.defaultVisualizer.suppressVisualizerStubRendering) {
                 return [];
             }
-            return [VisualizerBase];
+            return [VisualizationManager.defaultVisualizer];
         }
         vDescrs = [].concat(vDescrs);
         vDescrs.sort((v1, v2) => v1.index - v2.index);
@@ -231,7 +231,7 @@ class VisualizationManager {
      * @see registerAltVisualizerSelector
      */
     static getAltVisualizerSelector() {
-        return VisualizationManager.alternativesVisualizer || VisualizerBase;
+        return VisualizationManager.alternativesVisualizer || VisualizationManager.defaultVisualizer;
     }
     /**
      * Registers an alternative visualizer selector.
@@ -241,12 +241,13 @@ class VisualizationManager {
         VisualizationManager.alternativesVisualizer = constructor;
     }
     static getPivotVisualizerConstructor() {
-        return VisualizationManager.pivotVisualizer || VisualizerBase;
+        return VisualizationManager.pivotVisualizer || VisualizationManager.defaultVisualizer;
     }
     static registerPivotVisualizer(constructor) {
         VisualizationManager.pivotVisualizer = constructor;
     }
 }
+VisualizationManager.defaultVisualizer = undefined;
 VisualizationManager.alternativesVisualizer = undefined;
 VisualizationManager.pivotVisualizer = undefined;
 VisualizationManager.vizualizers = {};
@@ -294,6 +295,104 @@ class VisualizerFactory {
     }
 }
 
+function defaultStatisticsCalculator(data, dataInfo) {
+    const dataNames = dataInfo.dataNames;
+    const statistics = [];
+    const values = dataInfo.getValues();
+    const valuesIndex = {};
+    values.forEach((val, index) => {
+        valuesIndex[val] = index;
+    });
+    const processMissingAnswers = values.indexOf(undefined) !== -1;
+    const series = dataInfo.getSeriesValues();
+    const seriesIndex = {};
+    series.forEach((val, index) => {
+        seriesIndex[val] = index;
+    });
+    const seriesLength = series.length || 1;
+    for (var i = 0; i < dataNames.length; ++i) {
+        const dataNameStatistics = new Array();
+        for (var j = 0; j < seriesLength; ++j) {
+            dataNameStatistics.push(new Array(values.length).fill(0));
+        }
+        statistics.push(dataNameStatistics);
+    }
+    data.forEach((row) => {
+        dataNames.forEach((dataName, index) => {
+            const rowValue = row[dataName];
+            if (rowValue !== undefined || processMissingAnswers) {
+                const rowValues = Array.isArray(rowValue) ? rowValue : [rowValue];
+                if (series.length > 0) {
+                    if (row[DataProvider.seriesMarkerKey] !== undefined) {
+                        // Series are labelled by seriesMarkerKey in row data
+                        const seriesNo = seriesIndex[row[DataProvider.seriesMarkerKey]] || 0;
+                        rowValues.forEach((val) => {
+                            statistics[index][seriesNo][valuesIndex[val]]++;
+                        });
+                    }
+                    else {
+                        // Series are the keys in question value (matrix question)
+                        // TODO: think about the de-normalization and combine with the previous case
+                        rowValues.forEach((val) => {
+                            series.forEach((seriesName) => {
+                                if (val[seriesName] !== undefined) {
+                                    const seriesNo = seriesIndex[seriesName] || 0;
+                                    statistics[index][seriesNo][valuesIndex[val[seriesName]]]++;
+                                }
+                            });
+                        });
+                    }
+                }
+                else {
+                    // No series
+                    rowValues.forEach((val) => statistics[0][0][valuesIndex[val]]++);
+                }
+            }
+        });
+    });
+    return dataInfo.dataNames.length > 1 ? statistics : statistics[0];
+}
+function histogramStatisticsCalculator(data, intervals, seriesValues) {
+    const statistics = [];
+    if (seriesValues.length === 0) {
+        seriesValues.push("");
+    }
+    for (var i = 0; i < seriesValues.length; ++i) {
+        statistics.push(intervals.map(i => 0));
+        data[seriesValues[i]].forEach(dataValue => {
+            for (let j = 0; j < intervals.length; ++j) {
+                if (intervals[j].start <= dataValue && (dataValue < intervals[j].end || j == intervals.length - 1)) {
+                    statistics[i][j]++;
+                    break;
+                }
+            }
+        });
+    }
+    return statistics;
+}
+function mathStatisticsCalculator(data, dataName) {
+    let resultMin = Number.MAX_VALUE, resultMax = -Number.MAX_VALUE, resultAverage = 0;
+    let actualAnswerCount = 0;
+    data.forEach((rowData) => {
+        if (rowData[dataName] !== undefined) {
+            const questionValue = +rowData[dataName];
+            actualAnswerCount++;
+            resultAverage += questionValue;
+            if (resultMin > questionValue) {
+                resultMin = questionValue;
+            }
+            if (resultMax < questionValue) {
+                resultMax = questionValue;
+            }
+        }
+    });
+    if (actualAnswerCount > 0) {
+        resultAverage = resultAverage / actualAnswerCount;
+    }
+    resultAverage = Math.ceil(resultAverage * 100) / 100;
+    return [resultAverage, resultMin, resultMax];
+}
+
 class PostponeHelper {
     static postpone(fn, timeout) {
         if (PostponeHelper.postponeFunction) {
@@ -356,6 +455,7 @@ class VisualizerBase {
         this.contentContainer = undefined;
         this.footerContainer = undefined;
         this._supportSelection = false;
+        this._chartAdapter = undefined;
         /**
          * An event that is raised after the visualizer's content is rendered.
          *
@@ -673,9 +773,10 @@ class VisualizerBase {
         if (!!this.options && typeof this.options.destroyContent === "function") {
             this.options.destroyContent(container, this);
         }
-        else {
-            container.innerHTML = "";
+        else if (this._chartAdapter) {
+            this._chartAdapter.destroy(container.children[0]);
         }
+        container.innerHTML = "";
     }
     renderHeader(container) {
         if (!!this.options && typeof this.options.renderHeader === "function") {
@@ -689,10 +790,16 @@ class VisualizerBase {
     }
     renderContentAsync(container) {
         return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
+            if (this._chartAdapter) {
+                const chartNode = DocumentHelper.createElement("div");
+                container.innerHTML = "";
+                container.appendChild(chartNode);
+                yield this._chartAdapter.create(chartNode);
+            }
+            else {
                 container.innerText = localization.getString("noVisualizerForQuestion");
-                resolve(container);
-            });
+            }
+            return container;
         });
     }
     ensureQuestionIsReady() {
@@ -779,10 +886,23 @@ class VisualizerBase {
             });
         }
     }
-    updateContent() {
+    isSupportSoftUpdateContent() {
+        return false;
+    }
+    softUpdateContent() {
+    }
+    hardUpdateContent() {
         this.destroyContent(this.contentContainer);
         this.renderContent(this.contentContainer);
     }
+    updateContent() {
+        if (!this.isSupportSoftUpdateContent()) {
+            this.hardUpdateContent();
+        }
+        else {
+            this.softUpdateContent();
+        }
+    }
     /**
      * Re-renders the visualizer and its content.
      */
@@ -973,6 +1093,7 @@ class VisualizerBase {
     }
 }
 VisualizerBase.suppressVisualizerStubRendering = false;
+VisualizerBase.chartAdapterType = undefined;
 // public static otherCommentQuestionType = "comment"; // TODO: make it configureable - allow choose what kind of question/visualizer will be used for comments/others
 VisualizerBase.otherCommentCollapsed = true;
 VisualizerBase.customColors = [];
@@ -988,63 +1109,112 @@ VisualizerBase.colors = [
     "#cf37a6",
     "#4e6198",
 ];
-function defaultStatisticsCalculator(data, dataInfo) {
-    const dataNames = dataInfo.dataNames;
-    const statistics = [];
-    const values = dataInfo.getValues();
-    const valuesIndex = {};
-    values.forEach((val, index) => {
-        valuesIndex[val] = index;
-    });
-    const processMissingAnswers = values.indexOf(undefined) !== -1;
-    const series = dataInfo.getSeriesValues();
-    const seriesIndex = {};
-    series.forEach((val, index) => {
-        seriesIndex[val] = index;
-    });
-    const seriesLength = series.length || 1;
-    for (var i = 0; i < dataNames.length; ++i) {
-        const dataNameStatistics = new Array();
-        for (var j = 0; j < seriesLength; ++j) {
-            dataNameStatistics.push(new Array(values.length).fill(0));
+VisualizationManager.defaultVisualizer = VisualizerBase;
+
+class NumberModel extends VisualizerBase {
+    constructor(question, data, options = {}, name) {
+        super(question, data, options, name || "number");
+        if (VisualizerBase.chartAdapterType) {
+            this._chartAdapter = new VisualizerBase.chartAdapterType(this);
+            this.chartTypes = this._chartAdapter.getChartTypes();
+            this.chartType = this.chartTypes[0];
         }
-        statistics.push(dataNameStatistics);
-    }
-    data.forEach((row) => {
-        dataNames.forEach((dataName, index) => {
-            const rowValue = row[dataName];
-            if (rowValue !== undefined || processMissingAnswers) {
-                const rowValues = Array.isArray(rowValue) ? rowValue : [rowValue];
-                if (series.length > 0) {
-                    if (row[DataProvider.seriesMarkerKey] !== undefined) {
-                        // Series are labelled by seriesMarkerKey in row data
-                        const seriesNo = seriesIndex[row[DataProvider.seriesMarkerKey]] || 0;
-                        rowValues.forEach((val) => {
-                            statistics[index][seriesNo][valuesIndex[val]]++;
-                        });
-                    }
-                    else {
-                        // Series are the keys in question value (matrix question)
-                        // TODO: think about the de-normalization and combine with the previous case
-                        rowValues.forEach((val) => {
-                            series.forEach((seriesName) => {
-                                if (val[seriesName] !== undefined) {
-                                    const seriesNo = seriesIndex[seriesName] || 0;
-                                    statistics[index][seriesNo][valuesIndex[val[seriesName]]]++;
-                                }
-                            });
-                        });
-                    }
-                }
-                else {
-                    // No series
-                    rowValues.forEach((val) => statistics[0][0][valuesIndex[val]]++);
-                }
+        this.registerToolbarItem("changeChartType", () => {
+            if (this.chartTypes.length > 1) {
+                return DocumentHelper.createSelector(this.chartTypes.map((chartType) => {
+                    return {
+                        value: chartType,
+                        text: localization.getString("chartType_" + chartType),
+                    };
+                }), (option) => this.chartType === option.value, (e) => {
+                    this.setChartType(e.target.value);
+                });
             }
+            return null;
         });
-    });
-    return dataInfo.dataNames.length > 1 ? statistics : statistics[0];
+    }
+    onDataChanged() {
+        this._resultAverage = undefined;
+        this._resultMin = undefined;
+        this._resultMax = undefined;
+        super.onDataChanged();
+    }
+    onChartTypeChanged() { }
+    setChartType(chartType) {
+        if (this.chartTypes.indexOf(chartType) !== -1 &&
+            this.chartType !== chartType) {
+            this.chartType = chartType;
+            this.onChartTypeChanged();
+            if (!!this.contentContainer) {
+                this.destroyContent(this.contentContainer);
+                this.renderContent(this.contentContainer);
+            }
+            this.invokeOnUpdate();
+        }
+    }
+    destroy() {
+        this._resultAverage = undefined;
+        this._resultMin = undefined;
+        this._resultMax = undefined;
+        super.destroy();
+    }
+    generateText(maxValue, minValue, stepsCount) {
+        let texts = [];
+        if (stepsCount === 5) {
+            texts = [
+                "very high (" + maxValue + ")",
+                "high",
+                "medium",
+                "low",
+                "very low (" + minValue + ")",
+            ];
+        }
+        else {
+            texts.push(maxValue);
+            for (let i = 0; i < stepsCount - 2; i++) {
+                texts.push("");
+            }
+            texts.push(minValue);
+        }
+        if (!!NumberModel.generateTextsCallback) {
+            return NumberModel.generateTextsCallback(this.question, maxValue, minValue, stepsCount, texts);
+        }
+        return texts;
+    }
+    generateValues(maxValue, stepsCount) {
+        const values = [];
+        for (let i = 0; i < stepsCount; i++) {
+            values.push(maxValue / stepsCount);
+        }
+        values.push(maxValue);
+        return values;
+    }
+    generateColors(maxValue, minValue, stepsCount) {
+        const palette = this.getColors();
+        const colors = [];
+        for (let i = 0; i < stepsCount; i++) {
+            colors.push(palette[i]);
+        }
+        colors.push("rgba(255, 255, 255, 0)");
+        return colors;
+    }
+    convertFromExternalData(externalCalculatedData) {
+        return [externalCalculatedData.value || 0, externalCalculatedData.minValue || 0, externalCalculatedData.maxValue || 0];
+    }
+    getCalculatedValuesCore() {
+        if (this._resultAverage === undefined ||
+            this._resultMin === undefined ||
+            this._resultMax === undefined) {
+            [this._resultAverage, this._resultMin, this._resultMax] = mathStatisticsCalculator(this.surveyData, this.dataNames[0]);
+        }
+        return [this._resultAverage, this._resultMin, this._resultMax];
+    }
 }
+NumberModel.stepsCount = 5;
+NumberModel.showAsPercentage = false;
+VisualizationManager.registerVisualizer("number", NumberModel, 200);
+VisualizationManager.registerVisualizer("rating", NumberModel, 200);
+VisualizationManager.registerVisualizer("expression", NumberModel);
 
 function hideEmptyAnswersInData(answersData) {
     const result = {
@@ -1150,6 +1320,18 @@ class SelectBase extends VisualizerBase {
         this._hideEmptyAnswers = this.options.hideEmptyAnswers === true;
         this._answersOrder = this.options.answersOrder || "default";
         this._showMissingAnswers = this.isSupportMissingAnswers() && this.options.showMissingAnswers === true;
+        if (this.options.allowExperimentalFeatures) ;
+        if (VisualizerBase.chartAdapterType) {
+            this._chartAdapter = new VisualizerBase.chartAdapterType(this);
+            this.chartTypes = this._chartAdapter.getChartTypes();
+            if (this.getSeriesValues().length > 0 && this.chartTypes.indexOf("stackedbar") === -1) {
+                this.chartTypes.push("stackedbar");
+            }
+            this._chartType = this.chartTypes[0];
+            if (this.chartTypes.indexOf(this.options.defaultChartType) !== -1) {
+                this._chartType = this.options.defaultChartType;
+            }
+        }
         this.registerToolbarItem("changeChartType", () => {
             if (this.chartTypes.length > 1) {
                 return DocumentHelper.createSelector(this.chartTypes.map((chartType) => {
@@ -1327,6 +1509,16 @@ class SelectBase extends VisualizerBase {
         const selectBaseQuestion = this.question;
         return resultValues.map((value) => ItemValue.getTextOrHtmlByValue(selectBaseQuestion.choices, value)).join(", ");
     }
+    isSupportSoftUpdateContent() {
+        return true;
+    }
+    softUpdateContent() {
+        var _a;
+        const chartNode = (_a = this.contentContainer) === null || _a === void 0 ? void 0 : _a.children[0];
+        if (chartNode) {
+            this._chartAdapter.update(chartNode);
+        }
+    }
     getSelectedItemByText(itemText) {
         const selBase = this.question;
         if (this.question.hasOther && itemText == selBase.otherText) {
@@ -1637,87 +1829,11 @@ class SelectBase extends VisualizerBase {
 }
 SelectBase.topNValuesDefaults = [-1, 5, 10, 20];
 SelectBase._stateProperties = ["chartType", "answersOrder", "hideEmptyAnswers", "topN"];
-
-class Matrix extends SelectBase {
-    constructor(question, data, options, name) {
-        super(question, data, options, name || "matrix");
-        this._transposeData = true;
-        // this.getAnswersData();
-    }
-    get matrixQuestion() {
-        return this.question;
-    }
-    isSupportMissingAnswers() {
-        return false;
-    }
-    getSeriesValues() {
-        return this.matrixQuestion.rows.map((row) => "" + row.value);
-    }
-    getSeriesLabels() {
-        return this.matrixQuestion.rows.map((row) => ItemValue.getTextOrHtmlByValue(this.matrixQuestion.rows, row.value));
-    }
-    getSelectedItemByText(itemText) {
-        return this.matrixQuestion.columns.filter((column) => column.text === itemText)[0];
-    }
-    valuesSource() {
-        return this.matrixQuestion.columns;
-    }
-    getHasAnswersInAllSeriesArray(datasets) {
-        let result = Array();
-        for (let i = 0; i < datasets[0].length; i++) {
-            for (let j = 0; j < datasets.length; j++) {
-                if (datasets[j][i] != 0) {
-                    result[i] = true;
-                }
-            }
-        }
-        return result;
-    }
-    getHasAnswersInSeries(dataset) {
-        for (let i = 0; i < dataset.length; i++) {
-            if (dataset[i] != 0) {
-                return true;
-            }
-        }
-        return false;
-    }
-    hideEmptyAnswersInData(answersData) {
-        const result = {
-            datasets: [],
-            labels: [],
-            colors: [],
-            texts: [],
-            seriesLabels: [],
-        };
-        const hasAnswersInAllSeriesArr = this.getHasAnswersInAllSeriesArray(answersData.datasets);
-        for (let i = 0; i < answersData.datasets.length; i++) {
-            const hasAnswersInSeries = this.getHasAnswersInSeries(answersData.datasets[i]);
-            if (hasAnswersInSeries) {
-                result.labels.push(answersData.labels[i]);
-                result.colors.push(answersData.colors[i]);
-            }
-            else {
-                continue;
-            }
-            const datasets = [];
-            const texts = [];
-            for (let j = 0; j < answersData.datasets[0].length; j++) {
-                if (hasAnswersInAllSeriesArr[j]) {
-                    datasets.push(answersData.datasets[i][j]);
-                    texts.push(answersData.texts[i][j]);
-                }
-            }
-            result.datasets.push(datasets);
-            result.texts.push(texts);
-        }
-        for (let i = 0; i < answersData.datasets[0].length; i++) {
-            if (hasAnswersInAllSeriesArr[i]) {
-                result.seriesLabels.push(answersData.seriesLabels[i]);
-            }
-        }
-        return result;
-    }
-}
+VisualizationManager.registerVisualizer("checkbox", SelectBase);
+VisualizationManager.registerVisualizer("radiogroup", SelectBase);
+VisualizationManager.registerVisualizer("dropdown", SelectBase);
+VisualizationManager.registerVisualizer("imagepicker", SelectBase);
+VisualizationManager.registerVisualizer("tagbox", SelectBase);
 
 class BooleanModel extends SelectBase {
     constructor(question, data, options, name) {
@@ -1771,6 +1887,7 @@ class BooleanModel extends SelectBase {
 }
 BooleanModel.trueColor = "";
 BooleanModel.falseColor = "";
+VisualizationManager.registerVisualizer("boolean", BooleanModel);
 
 class HistogramModel extends SelectBase {
     constructor(question, data, options, name) {
@@ -1925,145 +2042,99 @@ class HistogramModel extends SelectBase {
     }
     getCalculatedValuesCore() {
         this.getContiniousValues();
-        const intervals = this.intervals;
-        const statistics = [];
-        const series = this.getSeriesValues();
-        if (series.length === 0) {
-            series.push("");
-        }
-        for (var i = 0; i < series.length; ++i) {
-            statistics.push(intervals.map(i => 0));
-            this._continiousData[series[i]].forEach(dataValue => {
-                for (let j = 0; j < intervals.length; ++j) {
-                    if (intervals[j].start <= dataValue && (dataValue < intervals[j].end || j == intervals.length - 1)) {
-                        statistics[i][j]++;
-                        break;
-                    }
-                }
-            });
-        }
-        return statistics;
+        return histogramStatisticsCalculator(this._continiousData, this.intervals, this.getSeriesValues());
+    }
+    getValueType() {
+        return this.valueType;
     }
 }
 HistogramModel.IntervalsCount = 10;
 HistogramModel.UseIntervalsFrom = 10;
+VisualizationManager.registerVisualizer("date", HistogramModel);
+VisualizationManager.registerVisualizer("number", HistogramModel, 100);
+VisualizationManager.registerVisualizer("rating", HistogramModel, 100);
 
-class NumberModel extends VisualizerBase {
-    constructor(question, data, options = {}, name) {
-        super(question, data, options, name || "number");
-        this.registerToolbarItem("changeChartType", () => {
-            if (this.chartTypes.length > 1) {
-                return DocumentHelper.createSelector(this.chartTypes.map((chartType) => {
-                    return {
-                        value: chartType,
-                        text: localization.getString("chartType_" + chartType),
-                    };
-                }), (option) => this.chartType === option.value, (e) => {
-                    this.setChartType(e.target.value);
-                });
-            }
-            return null;
-        });
+class Matrix extends SelectBase {
+    constructor(question, data, options, name) {
+        super(question, data, options, name || "matrix");
+        this._transposeData = true;
+        // this.getAnswersData();
     }
-    onDataChanged() {
-        this._resultAverage = undefined;
-        this._resultMin = undefined;
-        this._resultMax = undefined;
-        super.onDataChanged();
+    get matrixQuestion() {
+        return this.question;
     }
-    onChartTypeChanged() { }
-    setChartType(chartType) {
-        if (this.chartTypes.indexOf(chartType) !== -1 &&
-            this.chartType !== chartType) {
-            this.chartType = chartType;
-            this.onChartTypeChanged();
-            if (!!this.contentContainer) {
-                this.destroyContent(this.contentContainer);
-                this.renderContent(this.contentContainer);
-            }
-            this.invokeOnUpdate();
-        }
+    isSupportMissingAnswers() {
+        return false;
     }
-    destroy() {
-        this._resultAverage = undefined;
-        this._resultMin = undefined;
-        this._resultMax = undefined;
-        super.destroy();
+    getSeriesValues() {
+        return this.matrixQuestion.rows.map((row) => "" + row.value);
     }
-    generateText(maxValue, minValue, stepsCount) {
-        let texts = [];
-        if (stepsCount === 5) {
-            texts = [
-                "very high (" + maxValue + ")",
-                "high",
-                "medium",
-                "low",
-                "very low (" + minValue + ")",
-            ];
-        }
-        else {
-            texts.push(maxValue);
-            for (let i = 0; i < stepsCount - 2; i++) {
-                texts.push("");
-            }
-            texts.push(minValue);
-        }
-        if (!!NumberModel.generateTextsCallback) {
-            return NumberModel.generateTextsCallback(this.question, maxValue, minValue, stepsCount, texts);
-        }
-        return texts;
+    getSeriesLabels() {
+        return this.matrixQuestion.rows.map((row) => ItemValue.getTextOrHtmlByValue(this.matrixQuestion.rows, row.value));
     }
-    generateValues(maxValue, stepsCount) {
-        const values = [];
-        for (let i = 0; i < stepsCount; i++) {
-            values.push(maxValue / stepsCount);
-        }
-        values.push(maxValue);
-        return values;
+    getSelectedItemByText(itemText) {
+        return this.matrixQuestion.columns.filter((column) => column.text === itemText)[0];
     }
-    generateColors(maxValue, minValue, stepsCount) {
-        const palette = this.getColors();
-        const colors = [];
-        for (let i = 0; i < stepsCount; i++) {
-            colors.push(palette[i]);
+    valuesSource() {
+        return this.matrixQuestion.columns;
+    }
+    getHasAnswersInAllSeriesArray(datasets) {
+        let result = Array();
+        for (let i = 0; i < datasets[0].length; i++) {
+            for (let j = 0; j < datasets.length; j++) {
+                if (datasets[j][i] != 0) {
+                    result[i] = true;
+                }
+            }
         }
-        colors.push("rgba(255, 255, 255, 0)");
-        return colors;
+        return result;
     }
-    convertFromExternalData(externalCalculatedData) {
-        return [externalCalculatedData.value || 0, externalCalculatedData.minValue || 0, externalCalculatedData.maxValue || 0];
+    getHasAnswersInSeries(dataset) {
+        for (let i = 0; i < dataset.length; i++) {
+            if (dataset[i] != 0) {
+                return true;
+            }
+        }
+        return false;
     }
-    getCalculatedValuesCore() {
-        if (this._resultAverage === undefined ||
-            this._resultMin === undefined ||
-            this._resultMax === undefined) {
-            this._resultMin = Number.MAX_VALUE;
-            this._resultMax = -Number.MAX_VALUE;
-            this._resultAverage = 0;
-            let actualAnswerCount = 0;
-            this.data.forEach((rowData) => {
-                if (rowData[this.question.name] !== undefined) {
-                    const questionValue = +rowData[this.question.name];
-                    actualAnswerCount++;
-                    this._resultAverage += questionValue;
-                    if (this._resultMin > questionValue) {
-                        this._resultMin = questionValue;
-                    }
-                    if (this._resultMax < questionValue) {
-                        this._resultMax = questionValue;
-                    }
+    hideEmptyAnswersInData(answersData) {
+        const result = {
+            datasets: [],
+            labels: [],
+            colors: [],
+            texts: [],
+            seriesLabels: [],
+        };
+        const hasAnswersInAllSeriesArr = this.getHasAnswersInAllSeriesArray(answersData.datasets);
+        for (let i = 0; i < answersData.datasets.length; i++) {
+            const hasAnswersInSeries = this.getHasAnswersInSeries(answersData.datasets[i]);
+            if (hasAnswersInSeries) {
+                result.labels.push(answersData.labels[i]);
+                result.colors.push(answersData.colors[i]);
+            }
+            else {
+                continue;
+            }
+            const datasets = [];
+            const texts = [];
+            for (let j = 0; j < answersData.datasets[0].length; j++) {
+                if (hasAnswersInAllSeriesArr[j]) {
+                    datasets.push(answersData.datasets[i][j]);
+                    texts.push(answersData.texts[i][j]);
                 }
-            });
-            if (actualAnswerCount > 0) {
-                this._resultAverage = this._resultAverage / actualAnswerCount;
             }
-            this._resultAverage = Math.ceil(this._resultAverage * 100) / 100;
+            result.datasets.push(datasets);
+            result.texts.push(texts);
+        }
+        for (let i = 0; i < answersData.datasets[0].length; i++) {
+            if (hasAnswersInAllSeriesArr[i]) {
+                result.seriesLabels.push(answersData.seriesLabels[i]);
+            }
         }
-        return [this._resultAverage, this._resultMin, this._resultMax];
+        return result;
     }
 }
-NumberModel.stepsCount = 5;
-NumberModel.showAsPercentage = false;
+VisualizationManager.registerVisualizer("matrix", Matrix);
 
 class PivotModel extends SelectBase {
     constructor(questions, data, options, name) {
@@ -2236,7 +2307,7 @@ class PivotModel extends SelectBase {
         return this.question.getType() == "rating" && Array.isArray(this.question["rateValues"]) && this.question["rateValues"].length > 0;
     }
     getSeriesValues() {
-        if (this.questionsY.length === 0) {
+        if (!this.questionsY || this.questionsY.length === 0) {
             return this.options.seriesValues || [];
         }
         const seriesValues = [];
@@ -2414,9 +2485,49 @@ class PivotModel extends SelectBase {
         }
         return statistics;
     }
+    getValueType() {
+        return this.valueType;
+    }
+    isSupportSoftUpdateContent() {
+        return false;
+    }
 }
 PivotModel.IntervalsCount = 10;
 PivotModel.UseIntervalsFrom = 10;
+VisualizationManager.registerPivotVisualizer(PivotModel);
+
+class RankingModel extends SelectBase {
+    getQuestionResults() {
+        const name = this.question.name;
+        return this.data.map((dataItem) => dataItem[name]);
+    }
+    getEmptyData() {
+        const choices = this.getValues();
+        let data = [];
+        data.length = choices.length;
+        data.fill(0);
+        return data;
+    }
+    getCalculatedValuesCore() {
+        const results = this.getQuestionResults();
+        const choices = this.getValues();
+        let plotlyData = this.getEmptyData();
+        results.forEach((result) => {
+            this.applyResultToPlotlyData(result, plotlyData, choices);
+        });
+        return [plotlyData];
+    }
+    applyResultToPlotlyData(result, plotlyData, choices) {
+        if (!result || !plotlyData || !choices)
+            return;
+        result.forEach((resultValue, resultValueIndex, result) => {
+            let index = choices.indexOf(resultValue);
+            plotlyData[index] =
+                +plotlyData[index] + (result.length - resultValueIndex);
+        });
+    }
+}
+VisualizationManager.registerVisualizer("ranking", RankingModel);
 
 class AlternativeVisualizersWrapper extends VisualizerBase {
     updateVisualizerSelector() {
@@ -12322,5 +12433,5 @@ NpsVisualizer.DetractorScore = 6;
 NpsVisualizer.PromoterScore = 9;
 // VisualizationManager.registerVisualizer("rating", NpsVisualizer);
 
-export { AlternativeVisualizersWrapper as A, BooleanModel as B, DataProvider as D, HistogramModel as H, Matrix as M, NumberModel as N, PostponeHelper as P, SelectBase as S, TextTableAdapter as T, VisualizerFactory as V, WordCloudAdapter as W, __awaiter as _, VisualizerBase as a, VisualizationManager as b, VisualizationPanel as c, defaultStatisticsCalculator as d, VisualizationPanelDynamic as e, VisualizationMatrixDynamic as f, VisualizationMatrixDropdown as g, hideEmptyAnswersInData as h, WordCloud as i, Text as j, StatisticsTableAdapter as k, StatisticsTable as l, NpsVisualizerWidget as m, NpsAdapter as n, NpsVisualizer as o, PivotModel as p, textHelper as t };
+export { AlternativeVisualizersWrapper as A, BooleanModel as B, DataProvider as D, HistogramModel as H, Matrix as M, NumberModel as N, PostponeHelper as P, RankingModel as R, SelectBase as S, TextTableAdapter as T, VisualizerFactory as V, WordCloudAdapter as W, __awaiter as _, VisualizerBase as a, VisualizationManager as b, VisualizationPanel as c, VisualizationPanelDynamic as d, VisualizationMatrixDynamic as e, VisualizationMatrixDropdown as f, WordCloud as g, hideEmptyAnswersInData as h, Text as i, StatisticsTableAdapter as j, StatisticsTable as k, NpsVisualizerWidget as l, NpsAdapter as m, NpsVisualizer as n, PivotModel as o, defaultStatisticsCalculator as p, textHelper as t };
 //# sourceMappingURL=shared2.mjs.map