survey-analytics 2.2.2 → 2.2.3

package/fesm/shared2.mjs

@@ -1,5 +1,5 @@
 /*!
- * surveyjs - SurveyJS Dashboard library v2.2.2
+ * surveyjs - SurveyJS Dashboard library v2.2.3
  * Copyright (c) 2015-2025 Devsoft Baltic OÜ  - http://surveyjs.io/
  * License: MIT (http://www.opensource.org/licenses/mit-license.php)
  */
@@ -240,8 +240,15 @@ class VisualizationManager {
     static registerAltVisualizerSelector(constructor) {
         VisualizationManager.alternativesVisualizer = constructor;
     }
+    static getPivotVisualizerConstructor() {
+        return VisualizationManager.pivotVisualizer || VisualizerBase;
+    }
+    static registerPivotVisualizer(constructor) {
+        VisualizationManager.pivotVisualizer = constructor;
+    }
 }
 VisualizationManager.alternativesVisualizer = undefined;
+VisualizationManager.pivotVisualizer = undefined;
 VisualizationManager.vizualizers = {};
 
 /**
@@ -447,12 +454,12 @@ class VisualizerBase {
     get hasFooter() {
         return (!!this.question && (this.question.hasComment || this.question.hasOther));
     }
-    createVisualizer(question, options) {
+    createVisualizer(question, options, data) {
         let visualizerOptions = Object.assign({}, options || this.options);
         if (visualizerOptions.dataProvider === undefined) {
             visualizerOptions.dataProvider = this.dataProvider;
         }
-        return VisualizerFactory.createVisualizer(question, this.data, visualizerOptions);
+        return VisualizerFactory.createVisualizer(question, data || this.data, visualizerOptions);
     }
     /**
      * Allows you to access the footer visualizer. Returns `undefined` if the footer is absent.
@@ -764,6 +771,14 @@ class VisualizerBase {
         targetElement.appendChild(this.footerContainer);
         this.renderFooter(this.footerContainer);
     }
+    updateToolbar() {
+        if (!!this.toolbarContainer) {
+            PostponeHelper.postpone(() => {
+                this.destroyToolbar(this.toolbarContainer);
+                this.renderToolbar(this.toolbarContainer);
+            });
+        }
+    }
     updateContent() {
         this.destroyContent(this.contentContainer);
         this.renderContent(this.contentContainer);
@@ -1056,9 +1071,9 @@ function hideEmptyAnswersInData(answersData) {
     seriesDataExistence.length = answersData.seriesLabels.length;
     const valuesDataExistence = [];
     valuesDataExistence.length = answersData.labels.length;
-    for (var valueIndex = 0; valueIndex < answersData.labels.length; valueIndex++) {
-        for (var seriesIndex = 0; seriesIndex < answersData.seriesLabels.length; seriesIndex++) {
-            if (answersData.datasets[valueIndex][seriesIndex] != 0) {
+    for (var seriesIndex = 0; seriesIndex < answersData.seriesLabels.length; seriesIndex++) {
+        for (var valueIndex = 0; valueIndex < answersData.labels.length; valueIndex++) {
+            if (answersData.datasets[seriesIndex][valueIndex] != 0) {
                 seriesDataExistence[seriesIndex] = true;
                 valuesDataExistence[valueIndex] = true;
             }
@@ -1075,14 +1090,14 @@ function hideEmptyAnswersInData(answersData) {
             result.seriesLabels.push(answersData.seriesLabels[seriesIndex]);
         }
     }
-    for (var valueIndex = 0; valueIndex < answersData.labels.length; valueIndex++) {
-        if (valuesDataExistence[valueIndex]) {
+    for (var seriesIndex = 0; seriesIndex < answersData.datasets.length; seriesIndex++) {
+        if (seriesDataExistence[seriesIndex]) {
             const dataset = [];
             const texts = [];
-            for (var seriesIndex = 0; seriesIndex < answersData.datasets.length; seriesIndex++) {
-                if (seriesDataExistence[seriesIndex]) {
-                    dataset.push(answersData.datasets[valueIndex][seriesIndex]);
-                    texts.push(answersData.texts[valueIndex][seriesIndex]);
+            for (var valueIndex = 0; valueIndex < answersData.labels.length; valueIndex++) {
+                if (valuesDataExistence[valueIndex]) {
+                    dataset.push(answersData.datasets[seriesIndex][valueIndex]);
+                    texts.push(answersData.texts[seriesIndex][valueIndex]);
                 }
             }
             result.datasets.push(dataset);
@@ -1119,14 +1134,19 @@ class SelectBase extends VisualizerBase {
          * options fields can be modified
          */
         this.onAnswersDataReady = new Event();
-        question.visibleChoicesChangedCallback = () => {
-            this.dataProvider.raiseDataChanged();
-        };
+        if (!!question) { // TODO: move somewhere else
+            question.visibleChoicesChangedCallback = () => {
+                this.dataProvider.raiseDataChanged();
+            };
+        }
         this._showPercentages = this.options.showPercentages === true;
         this._showOnlyPercentages = this.options.showOnlyPercentages === true;
         if (this.options.percentagePrecision) {
             this._percentagePrecision = this.options.percentagePrecision;
         }
+        if (this.options.transposeData !== undefined) {
+            this._transposeData = this.options.transposeData;
+        }
         this._hideEmptyAnswers = this.options.hideEmptyAnswers === true;
         this._answersOrder = this.options.answersOrder || "default";
         this._showMissingAnswers = this.isSupportMissingAnswers() && this.options.showMissingAnswers === true;
@@ -1562,9 +1582,9 @@ class SelectBase extends VisualizerBase {
         const series = this.getSeriesValues();
         const innerCalculatedData = [];
         if (series.length > 0) {
-            for (let i = 0; i < values.length; i++) {
+            for (let j = 0; j < series.length; j++) {
                 const seriesData = [];
-                for (let j = 0; j < series.length; j++) {
+                for (let i = 0; i < values.length; i++) {
                     if (!!externalCalculatedData[series[j]]) {
                         seriesData.push(externalCalculatedData[series[j]][values[i]] || 0);
                     }
@@ -1621,6 +1641,7 @@ SelectBase._stateProperties = ["chartType", "answersOrder", "hideEmptyAnswers",
 class Matrix extends SelectBase {
     constructor(question, data, options, name) {
         super(question, data, options, name || "matrix");
+        this._transposeData = true;
         // this.getAnswersData();
     }
     get matrixQuestion() {
@@ -1696,17 +1717,6 @@ class Matrix extends SelectBase {
         }
         return result;
     }
-    getCalculatedValuesCore() {
-        const statistics = super.getCalculatedValuesCore();
-        const series = this.getSeriesValues();
-        const values = this.getValues();
-        const preparedData = [];
-        values.forEach((val, valueIndex) => {
-            const seriesData = series.map((seriesName, seriesIndex) => statistics[seriesIndex][valueIndex]);
-            preparedData.push(seriesData);
-        });
-        return preparedData;
-    }
 }
 
 class BooleanModel extends SelectBase {
@@ -1770,6 +1780,7 @@ class HistogramModel extends SelectBase {
         this._continiousData = undefined;
         this._cachedIntervals = undefined;
         this._intervalPrecision = 2;
+        this._transposeData = false;
         if (this.options.intervalPrecision !== undefined) {
             this._intervalPrecision = this.options.intervalPrecision;
         }
@@ -2054,6 +2065,359 @@ class NumberModel extends VisualizerBase {
 NumberModel.stepsCount = 5;
 NumberModel.showAsPercentage = false;
 
+class PivotModel extends SelectBase {
+    constructor(questions, data, options, name) {
+        super(null, data, options, name || "pivot");
+        this.questions = questions;
+        this.valueType = "enum";
+        this._cachedValues = undefined;
+        this._continiousData = undefined;
+        this._cachedIntervals = undefined;
+        this._intervalPrecision = 2;
+        this.axisYSelectors = [];
+        this.axisYQuestionNames = [];
+        this.questionsY = [];
+        this.questions = this.questions.filter((question) => ["matrixdropdown", "matrixdynamic", "matrix", "file", "signature", "multipletext", "comment", "html", "image"].indexOf(question.getType()) === -1);
+        if (this.options.intervalPrecision !== undefined) {
+            this._intervalPrecision = this.options.intervalPrecision;
+        }
+        this.axisXQuestionName = this.questions.length > 0 ? this.questions[0].name : undefined;
+        this.registerToolbarItem("axisXSelector", () => this.axisXSelector = DocumentHelper.createSelector(this.questions.map((question) => {
+            return {
+                value: question.name,
+                text: question.title || question.name,
+            };
+        }), (option) => this.axisXQuestionName === option.value, (e) => { this.axisXQuestionName = e.target.value; this.setupPivot(); }, localization.getString("axisXSelectorTitle")));
+        this.registerToolbarItem("axisYSelector0", this.createYSelecterGenerator());
+        this.setupPivot();
+    }
+    createYSelecterGenerator() {
+        const selectorIndex = this.axisYSelectors.length;
+        return () => {
+            let selector = this.axisYSelectors[selectorIndex];
+            if (!selector) {
+                selector = this.createAxisYSelector(selectorIndex);
+                this.axisYSelectors.push(selector);
+            }
+            return selector;
+        };
+    }
+    setAxisQuestions(...axisQuestionNames) {
+        if (axisQuestionNames.length < 1) {
+            return;
+        }
+        this.axisXQuestionName = axisQuestionNames[0];
+        this.axisYQuestionNames = axisQuestionNames.splice(1);
+        this.setupPivot();
+    }
+    onAxisYSelectorChanged(index, value) {
+        this.axisYQuestionNames[index] = value;
+        if (index < this.axisYSelectors.length - 1) {
+            if (!value) {
+                for (let i = index + 1; i < this.axisYSelectors.length; ++i) {
+                    this.unregisterToolbarItem("axisYSelector" + i);
+                }
+                this.axisYSelectors = this.axisYSelectors.slice(0, index + 1);
+                this.axisYQuestionNames = this.axisYQuestionNames.slice(0, index + 1);
+                this.updateToolbar();
+            }
+        }
+        else {
+            if (!!value) {
+                this.registerToolbarItem("axisYSelector" + this.axisYSelectors.length, this.createYSelecterGenerator());
+                this.updateToolbar();
+            }
+        }
+        this.setupPivot();
+    }
+    createAxisYSelector(selectorIndex) {
+        const selector = DocumentHelper.createSelector([{ value: "", text: "Not selected" }].concat(this.questions.map((question) => {
+            return {
+                value: question.name,
+                text: question.title || question.name,
+            };
+        })), (option) => this.axisYQuestionNames[selectorIndex] === option.value, (e) => { this.onAxisYSelectorChanged(selectorIndex, e.target.value); }, selectorIndex ? undefined : localization.getString("axisYSelectorTitle"));
+        return selector;
+    }
+    getQuestionValueType(question) {
+        const questionType = question.getType();
+        if (questionType === "text" && (question["inputType"] === "date" || question["inputType"] === "datetime")) {
+            return "date";
+        }
+        else if (questionType === "text" || questionType === "rating" || questionType === "expression" || questionType === "range") {
+            return "number";
+        }
+        return "enum";
+    }
+    setupPivot() {
+        const questionX = this.questions.filter((q) => q.name === this.axisXQuestionName)[0];
+        if (!questionX) {
+            return;
+        }
+        this.question = questionX;
+        this.valueType = this.getQuestionValueType(questionX);
+        this.questionsY = this.axisYQuestionNames.map((name) => {
+            const questionY = this.questions.filter((q) => q.name === name)[0];
+            if (!!questionY) {
+                return this.getQuestionValueType(questionY) === "enum" ? new SelectBase(questionY, []) : new VisualizerBase(questionY, []);
+            }
+        }).filter((q) => !!q);
+        this.onDataChanged();
+    }
+    reset() {
+        this._continiousData = undefined;
+        this._cachedValues = undefined;
+        this._cachedIntervals = undefined;
+    }
+    getContiniousValue(value) {
+        if (this.valueType === "date") {
+            return Date.parse(value);
+        }
+        return parseFloat(value);
+    }
+    getString(value) {
+        if (this.valueType === "date") {
+            return new Date(value).toLocaleDateString();
+        }
+        return "" + value;
+    }
+    toPrecision(value) {
+        const base = Math.pow(10, this._intervalPrecision);
+        return Math.round(base * value) / base;
+    }
+    getSelectedItemByText(itemText) {
+        if (this.hasCustomIntervals || this.getContiniousValues().length > PivotModel.UseIntervalsFrom) {
+            const interval = this.intervals.filter(interval => interval.label === itemText)[0];
+            return new ItemValue(interval, interval !== undefined ? interval.label : "");
+        }
+        const labels = this.getLabels();
+        const labelIndex = labels.indexOf(itemText);
+        return new ItemValue(this.getValues()[labelIndex], labels[labelIndex]);
+    }
+    /**
+     * Updates visualizer data.
+     */
+    updateData(data) {
+        this.reset();
+        super.updateData(data);
+    }
+    onDataChanged() {
+        this.reset();
+        super.onDataChanged();
+    }
+    getContiniousValues() {
+        if (this._cachedValues === undefined) {
+            this._continiousData = [];
+            if (this.valueType === "enum") {
+                this._cachedValues = [];
+                return this._cachedValues;
+            }
+            const hash = {};
+            this.data.forEach(dataItem => {
+                const answerData = dataItem[this.name];
+                if (answerData !== undefined) {
+                    // TODO: _continiousData should be sorted in order to speed-up statistics calculation in the getData function
+                    this._continiousData.push({ continious: this.getContiniousValue(answerData), row: dataItem });
+                    hash[answerData] = { value: answerData, row: dataItem };
+                }
+            });
+            this._cachedValues = Object.keys(hash).map(key => ({ original: hash[key].value, continious: this.getContiniousValue(key), row: hash[key].row }));
+            this._cachedValues.sort((a, b) => a.continious - b.continious);
+        }
+        return this._cachedValues;
+    }
+    isSupportAnswersOrder() {
+        return false;
+    }
+    isSupportMissingAnswers() {
+        return false;
+    }
+    get needUseRateValues() {
+        return this.question.getType() == "rating" && Array.isArray(this.question["rateValues"]) && this.question["rateValues"].length > 0;
+    }
+    getSeriesValues() {
+        if (this.questionsY.length === 0) {
+            return this.options.seriesValues || [];
+        }
+        const seriesValues = [];
+        this.questionsY.forEach(q => {
+            if (this.getQuestionValueType(q.question) === "enum") {
+                seriesValues.push.apply(seriesValues, q.getValues().reverse());
+            }
+            else {
+                seriesValues.push(q.question.name);
+            }
+        });
+        return seriesValues;
+    }
+    getSeriesLabels() {
+        if (this.questionsY.length === 0) {
+            return this.getSeriesValues();
+        }
+        const seriesLabels = [];
+        this.questionsY.forEach(q => {
+            if (this.getQuestionValueType(q.question) === "enum") {
+                seriesLabels.push.apply(seriesLabels, q.getLabels().reverse());
+            }
+            else {
+                seriesLabels.push(q.question.title || q.question.name);
+            }
+        });
+        return seriesLabels;
+    }
+    getValues() {
+        if (this.valueType === "enum") {
+            return super.getValues().reverse();
+        }
+        return this.intervals.map(interval => interval.start);
+    }
+    getLabels() {
+        if (this.valueType === "enum") {
+            return super.getLabels().reverse();
+        }
+        return this.intervals.map(interval => interval.label);
+    }
+    get hasCustomIntervals() {
+        return !!this.questionOptions && Array.isArray(this.questionOptions.intervals);
+    }
+    get intervals() {
+        if (this.hasCustomIntervals) {
+            return this.questionOptions.intervals;
+        }
+        if (this.question.getType() == "rating") {
+            if (this.needUseRateValues) {
+                const rateValues = this.question["rateValues"];
+                rateValues.sort((iv1, iv2) => iv1.value - iv2.value);
+                return rateValues.map((rateValue, i) => ({
+                    start: rateValue.value,
+                    end: i < rateValues.length - 1 ? rateValues[i + 1].value : rateValue.value + 1,
+                    label: rateValue.text
+                }));
+            }
+            else {
+                const rateIntervals = [];
+                for (let i = (this.question["rateMin"] || 0); i <= (this.question["rateMax"] || (PivotModel.IntervalsCount - 1)); i += (this.question["rateStep"] || 1)) {
+                    rateIntervals.push({
+                        start: i,
+                        end: i + 1,
+                        label: "" + (!!this.question["rateMin"] && !!this.question["rateMax"] ? i : (i + "-" + (i + 1)))
+                    });
+                }
+                return rateIntervals;
+            }
+        }
+        if (this._cachedIntervals === undefined) {
+            const continiousValues = this.getContiniousValues();
+            this._cachedIntervals = [];
+            if (continiousValues.length) {
+                let start = continiousValues[0].continious;
+                const end = continiousValues[continiousValues.length - 1].continious;
+                const intervalsCount = PivotModel.IntervalsCount;
+                const delta = (end - start) / intervalsCount;
+                for (let i = 0; i < intervalsCount; ++i) {
+                    const next = start + delta;
+                    const istart = this.toPrecision(start);
+                    const inext = this.toPrecision(next);
+                    this._cachedIntervals.push({
+                        start: istart,
+                        end: i < intervalsCount - 1 ? inext : inext + delta / 100,
+                        label: "" + this.getString(istart) + "-" + this.getString(inext)
+                    });
+                    start = next;
+                }
+            }
+        }
+        return this._cachedIntervals;
+    }
+    convertFromExternalData(externalCalculatedData) {
+        return [externalCalculatedData];
+    }
+    getSeriesValueIndexes() {
+        const seriesValueIndexes = {};
+        let valueIndex = 0;
+        for (var i = 0; i < this.questionsY.length; ++i) {
+            const questionValueType = this.getQuestionValueType(this.questionsY[i].question);
+            if (questionValueType === "enum") {
+                this.questionsY[i].getValues().reverse().forEach((value) => {
+                    seriesValueIndexes[this.questionsY[i].name + "_" + value] = valueIndex++;
+                });
+            }
+            else {
+                seriesValueIndexes[this.questionsY[i].name] = valueIndex++;
+            }
+        }
+        return seriesValueIndexes;
+    }
+    updateStatisticsSeriesValue(statistics, dataRow, valueIndex, seriesValueIndexes) {
+        for (let j = 0; j < this.questionsY.length; ++j) {
+            if (dataRow[this.questionsY[j].name] !== undefined) {
+                const questionValueType = this.getQuestionValueType(this.questionsY[j].question);
+                if (questionValueType === "enum" || questionValueType === "date") {
+                    const seriesValueIndex = seriesValueIndexes[this.questionsY[j].name + "_" + dataRow[this.questionsY[j].name]];
+                    statistics[seriesValueIndex][valueIndex]++;
+                }
+                else {
+                    const seriesValueIndex = seriesValueIndexes[this.questionsY[j].name];
+                    statistics[seriesValueIndex][valueIndex] += parseFloat(dataRow[this.questionsY[j].name]);
+                }
+            }
+        }
+    }
+    getCalculatedValuesCore() {
+        const statistics = [];
+        const series = this.getSeriesValues();
+        if (series.length === 0) {
+            series.push("");
+        }
+        const seriesValueIndexes = this.getSeriesValueIndexes();
+        if (this.valueType === "enum") {
+            const values = this.getValues();
+            const valueIndexes = {};
+            values.forEach((value, index) => {
+                valueIndexes[value] = index;
+            });
+            for (var i = 0; i < series.length; ++i) {
+                statistics.push(values.map(i => 0));
+            }
+            this.data.forEach(dataRow => {
+                const answerData = dataRow[this.name];
+                if (answerData !== undefined && valueIndexes[answerData] !== undefined) {
+                    const valueIndex = valueIndexes[answerData];
+                    if (this.questionsY.length === 0) {
+                        statistics[0][valueIndex]++;
+                    }
+                    else {
+                        this.updateStatisticsSeriesValue(statistics, dataRow, valueIndex, seriesValueIndexes);
+                    }
+                }
+            });
+        }
+        else {
+            this.getContiniousValues();
+            const intervals = this.intervals;
+            for (var i = 0; i < series.length; ++i) {
+                statistics.push(intervals.map(i => 0));
+            }
+            this._continiousData.forEach(dataValue => {
+                for (let valueIndex = 0; valueIndex < intervals.length; ++valueIndex) {
+                    if (intervals[valueIndex].start <= dataValue.continious && (dataValue.continious < intervals[valueIndex].end || valueIndex == intervals.length - 1)) {
+                        if (this.questionsY.length === 0) {
+                            statistics[0][valueIndex]++;
+                        }
+                        else {
+                            this.updateStatisticsSeriesValue(statistics, dataValue.row, valueIndex, seriesValueIndexes);
+                        }
+                        break;
+                    }
+                }
+            });
+        }
+        return statistics;
+    }
+}
+PivotModel.IntervalsCount = 10;
+PivotModel.UseIntervalsFrom = 10;
+
 class AlternativeVisualizersWrapper extends VisualizerBase {
     updateVisualizerSelector() {
         if (!!this.visualizerSelector) {
@@ -2188,6 +2552,12 @@ class AlternativeVisualizersWrapper extends VisualizerBase {
             this.visualizer.setState(state.state);
         }
     }
+    getValues() {
+        return this.visualizer.getValues();
+    }
+    getLabels() {
+        return this.visualizer.getLabels();
+    }
     getCalculatedValues() {
         return this.visualizer.getCalculatedValues();
     }
@@ -9443,7 +9813,15 @@ class VisualizationPanel extends VisualizerBase {
     }
     buildVisualizers(questions) {
         questions.forEach((question) => {
-            const visualizer = this.createVisualizer(question);
+            let visualizerOptions = Object.assign({}, this.options);
+            let visualizerData = this.surveyData;
+            let visualizer;
+            if (Array.isArray(question)) {
+                visualizer = new (VisualizationManager.getPivotVisualizerConstructor())(question, visualizerData, visualizerOptions);
+            }
+            else {
+                visualizer = this.createVisualizer(question, visualizerOptions, visualizerData);
+            }
             if (!visualizer) {
                 return;
             }
@@ -9510,6 +9888,7 @@ class VisualizationPanel extends VisualizerBase {
     setLocale(newLocale) {
         super.setLocale(newLocale);
         (this.questions || []).forEach((question) => {
+            question = Array.isArray(question) ? question[0] : question;
             const element = this.getElement(question.name);
             if (!!element) {
                 element.displayName = this.processText(question.title);
@@ -9556,6 +9935,7 @@ class VisualizationPanel extends VisualizerBase {
     }
     buildElements(questions) {
         return (questions || []).map((question) => {
+            question = Array.isArray(question) ? question[0] : question;
             return {
                 name: question.name,
                 displayName: this.processText(question.title),
@@ -9756,7 +10136,7 @@ class VisualizationPanel extends VisualizerBase {
         this._settingState = true;
         try {
             if (Array.isArray(newState.elements)) {
-                const questionNames = this.questions.map(q => q.name);
+                const questionNames = this.questions.map(q => Array.isArray(q) ? q[0].name : q.name);
                 this._elements = [].concat(newState.elements.filter(e => (questionNames.indexOf(e.name) !== -1)));
             }
             if (typeof newState.locale !== "undefined")
@@ -9890,6 +10270,7 @@ class VisualizationMatrixDropdown extends VisualizerBase {
         this._childOptions.disableLocaleSwitch = true;
         this._childOptions.dataProvider = undefined;
         this._childOptions.allowDynamicLayout = false;
+        this._childOptions.transposeData = true;
         this._childOptions.seriesValues = question.rows.map((row) => row.value);
         this._childOptions.seriesLabels = question.rows.map((row) => row.text);
         const innerQuestions = this.getQuestions();
@@ -11941,5 +12322,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, 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, 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 };
 //# sourceMappingURL=shared2.mjs.map