@sisense/sdk-pivot-query-client 2.17.0

package/dist/cjs/data-handling/utils/jaqlProcessor.js

@@ -0,0 +1,661 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markSortedNode = exports.getResizeWidthFromJaql = exports.setResizeWidthToJaql = exports.updatePanelsSortingMetadata = exports.updateLastAppliedSortingFlag = exports.normalizeSingleBranchTreeSortDetails = exports.getMetadataTree = exports.getMetadataPanelByIndex = exports.getMetadataPanels = exports.isMeasurePathEqual = exports.getDataTypes = void 0;
+const isEqual_js_1 = __importDefault(require("lodash-es/isEqual.js"));
+const index_js_1 = require("../../tree-structure/utils/index.js");
+const constants_js_1 = require("../constants.js");
+const createPivotTreeNode_js_1 = __importDefault(require("./createPivotTreeNode.js"));
+const jaqlProcessor = __importStar(require("./jaqlProcessor.js"));
+function getDataTypes(panels = []) {
+    const dataTypes = {};
+    panels.forEach((panel) => {
+        const { index = Infinity } = panel.field || {};
+        const indexStr = `${index}`;
+        dataTypes[indexStr] = panel.jaql.datatype || constants_js_1.JaqlDataType.TEXT;
+    });
+    return dataTypes;
+}
+exports.getDataTypes = getDataTypes;
+function defaultFormatter(value, dataType) {
+    if (value && dataType === constants_js_1.JaqlDataType.DATETIME) {
+        try {
+            return new Date(value).toISOString();
+        }
+        catch (e) {
+            return value;
+        }
+    }
+    return value;
+}
+function normalizeMeasurePath(path) {
+    if (path === null) {
+        return undefined;
+    }
+    if ((0, isEqual_js_1.default)(path, {})) {
+        return undefined;
+    }
+    return path;
+}
+// eslint-disable-next-line sonarjs/cognitive-complexity
+function isMeasurePathEqual(_measurePathA, _measurePathB, dataTypes = {}) {
+    const measurePathA = normalizeMeasurePath(_measurePathA);
+    const measurePathB = normalizeMeasurePath(_measurePathB);
+    let result = false;
+    if (typeof measurePathA === 'object' &&
+        measurePathA !== null &&
+        typeof measurePathB === 'object' &&
+        measurePathB !== null) {
+        result = true;
+        const measurePathAKeys = Object.keys(measurePathA);
+        const measurePathBKeys = Object.keys(measurePathB);
+        if (measurePathAKeys.length !== measurePathBKeys.length) {
+            result = false;
+        }
+        else {
+            measurePathAKeys.forEach((key) => {
+                const dataType = dataTypes[key] || '';
+                let valueA = (measurePathA || {})[key];
+                let valueB = (measurePathB || {})[key];
+                if (typeof valueA === 'undefined' || typeof valueB === 'undefined') {
+                    result = false;
+                    return;
+                }
+                if (dataType === constants_js_1.JaqlDataType.DATETIME) {
+                    valueA = defaultFormatter(valueA, dataType);
+                    valueB = defaultFormatter(valueB, dataType);
+                }
+                if (valueA !== valueB) {
+                    result = false;
+                }
+            });
+        }
+    }
+    else {
+        result = measurePathA === measurePathB;
+    }
+    return result;
+}
+exports.isMeasurePathEqual = isMeasurePathEqual;
+function getCompatibleMeasurePath(measurePath, dataTypes, formatter = defaultFormatter) {
+    if (!measurePath || typeof measurePath !== 'object') {
+        return measurePath;
+    }
+    const result = {};
+    Object.keys(measurePath).forEach((key) => {
+        const dataType = dataTypes[key];
+        const value = (measurePath || {})[key];
+        const formattedValue = formatter(value, dataType);
+        result[key] = formattedValue;
+    });
+    return result;
+}
+/**
+ * Get appropriate metadata panels (rows/columns/measures) from JAQL request object
+ *
+ * @param {JaqlRequest} jaql - jaql with metadata
+ * @param {string} type - panels type to receive
+ * @returns {Array<JaqlPanel>} - list of panels
+ */
+const getMetadataPanels = (jaql, type) => {
+    let panels = (jaql && jaql.metadata) || [];
+    if (type) {
+        panels = panels.filter((item) => item.panel === type);
+    }
+    panels.sort((prev, next) => {
+        const defaultField = { index: Infinity };
+        const prevField = prev.field || defaultField;
+        const nextField = next.field || defaultField;
+        return prevField.index - nextField.index;
+    });
+    return panels;
+};
+exports.getMetadataPanels = getMetadataPanels;
+/**
+ * Get appropriate metadata panel (rows/columns/measures) from JAQL request object by panel index
+ *
+ * @param {JaqlRequest} jaql - jaql with metadata
+ * @param {number} index - panel index
+ * @param {string} [type] - panels type to receive
+ * @returns {JaqlPanel} - jaql panels
+ */
+const getMetadataPanelByIndex = (jaql, index, type) => {
+    if (typeof index === 'undefined') {
+        return undefined;
+    }
+    const panels = (0, exports.getMetadataPanels)(jaql, type);
+    const filteredPanels = panels.filter((panel) => {
+        const panelField = panel.field || { index: Infinity };
+        return panelField.index === index;
+    });
+    return filteredPanels[0];
+};
+exports.getMetadataPanelByIndex = getMetadataPanelByIndex;
+/**
+ * sortingLastDimension jaql's sorting param processing method
+ *
+ * @param {JaqlPanel} processedPanel - panel to be identified
+ * @param {?JaqlRequest} jaql - jaql to be processed
+ * @returns {boolean} - sortingLastDimension initialization
+ */
+const isPanelsLastDimension = (processedPanel, jaql) => {
+    const processedPanelField = processedPanel.field || { index: Infinity };
+    if (processedPanel.panel === constants_js_1.PanelType.MEASURES) {
+        return true;
+    }
+    if (processedPanel.panel === constants_js_1.PanelType.ROWS) {
+        const panels = (0, exports.getMetadataPanels)(jaql, constants_js_1.PanelType.ROWS);
+        const lastPanel = panels[panels.length - 1] || {};
+        const lastPanelField = lastPanel.field || { index: Infinity };
+        if (panels.length && lastPanelField.index === processedPanelField.index) {
+            return true;
+        }
+        if (!panels.length) {
+            // eslint-disable-next-line no-console
+            console.error('Missing rows panel in jaql!');
+        }
+    }
+    return false;
+};
+function checkRowSortedBySubtotal(sortDetails, jaqlIndex) {
+    if (!sortDetails) {
+        return false;
+    }
+    if (typeof sortDetails.field !== 'number') {
+        return false;
+    }
+    return sortDetails.field !== jaqlIndex;
+}
+/**
+ * Get appropriate metadata panels (rows/columns/measures) in TreeNode structure from
+ * JAQL request object
+ *
+ * @param {JaqlRequest} jaql - jaql with metadata
+ * @param {string} [type=PanelType.ROWS] - panels type to receive
+ * @returns {PivotTreeNode} - metadata panels tree
+ */
+const getMetadataTree = (jaql, type = constants_js_1.PanelType.ROWS) => {
+    const panels = (0, exports.getMetadataPanels)(jaql, type);
+    const nodes = panels.map((item, index) => {
+        const node = index_js_1.treeNode.create(item.jaql.title, undefined, undefined, index);
+        const pivotNode = (0, createPivotTreeNode_js_1.default)(node, type);
+        pivotNode.jaqlIndex = item.field ? item.field.index : undefined;
+        switch (type) {
+            case constants_js_1.PanelType.ROWS: {
+                pivotNode.measurePath = undefined;
+                const isSortedBySubtotal = checkRowSortedBySubtotal(item.jaql.sortDetails, pivotNode.jaqlIndex);
+                if (item.jaql.sort && !isSortedBySubtotal) {
+                    pivotNode.dir = item.jaql.sort;
+                }
+                else {
+                    pivotNode.dir = null;
+                }
+                break;
+            }
+            case constants_js_1.PanelType.MEASURES:
+                pivotNode.databars = item.format ? item.format.databars : false;
+                pivotNode.measureJaqlIndex = pivotNode.jaqlIndex;
+                if (!(0, exports.getMetadataPanels)(jaql, constants_js_1.PanelType.COLUMNS).length) {
+                    pivotNode.measurePath = undefined;
+                    if (item.jaql.sortDetails && item.jaql.sortDetails.measurePath === null) {
+                        pivotNode.dir = item.jaql.sortDetails.dir;
+                    }
+                    else {
+                        pivotNode.dir = null;
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+        return pivotNode;
+    });
+    return index_js_1.treeNode.wrapInRootNode(nodes);
+};
+exports.getMetadataTree = getMetadataTree;
+/**
+ * method to clear sorting information in panels with
+ * sortingLastDimension === false
+ *
+ * @param {?JaqlRequest} jaql - jaql to clear
+ * @returns {void}
+ */
+const clearLastDimesionSortDetails = (jaql) => {
+    const metadata = jaql && jaql.metadata ? jaql.metadata : [];
+    metadata.forEach((panel) => {
+        if (panel &&
+            panel.jaql &&
+            panel.jaql.sort &&
+            panel.jaql.sortDetails &&
+            panel.jaql.sortDetails.sortingLastDimension) {
+            panel.jaql.sort = null;
+            delete panel.jaql.sortDetails;
+        }
+    });
+};
+/**
+ * Clears panel sort details
+ *
+ * @param {JaqlPanel} panel - jaql panel
+ * @returns {void}
+ */
+const clearPanelSortDetails = (panel) => {
+    if (panel && panel.jaql) {
+        panel.jaql.sort = null;
+        delete panel.jaql.sortDetails;
+    }
+};
+/**
+ * method to clear sorting all information in panels
+ *
+ * @param {?JaqlRequest} jaql - jaql to clear
+ * @returns {void}
+ */
+const clearAllSortDetails = (jaql) => {
+    const metadata = jaql && jaql.metadata ? jaql.metadata : [];
+    metadata.forEach((panel) => clearPanelSortDetails(panel));
+};
+/**
+ * Getter for last sorted panel
+ *
+ * @param {JaqlRequest} jaql - jaql request
+ * @returns {JaqlPanel|undefined} - panel item
+ */
+const getLastSortedPanel = (jaql) => (jaql.metadata || []).reverse().find((item) => !!item.jaql.sortDetails);
+/**
+ * Getter for panel item on which sorting was last applied
+ *
+ * @param {JaqlRequest} jaql - jaql request
+ * @returns {JaqlPanel|undefined} - panel item
+ */
+const getLastAppliedSortedPanel = (jaql) => (jaql.metadata || []).find((item) => !!(item.jaql.sortDetails && item.jaql.sortDetails.isLastApplied));
+/**
+ * Removes redundant sort details for single branch tree
+ * (As such pivot can be sorted only by one panel)
+ *
+ * @param {JaqlRequest} jaql - jaql request
+ * @returns {void}
+ */
+const normalizeSingleBranchTreeSortDetails = (jaql) => {
+    const sortedPanel = getLastAppliedSortedPanel(jaql) || getLastSortedPanel(jaql);
+    if (!sortedPanel) {
+        return;
+    }
+    const sortedIndex = sortedPanel.field && sortedPanel.field.index;
+    (jaql.metadata || []).forEach((panel) => {
+        const currentIndex = panel.field && panel.field.index;
+        if (currentIndex !== sortedIndex) {
+            clearPanelSortDetails(panel);
+        }
+    });
+};
+exports.normalizeSingleBranchTreeSortDetails = normalizeSingleBranchTreeSortDetails;
+/**
+ * Updates last applied flag on metadata item sort details
+ * (Required for proper apply single branch tree sorting)
+ *
+ * @param {JaqlRequest} jaql - jaql request
+ * @param {SortDetails} sortDetails - last updated sort details
+ * @returns {void}
+ */
+const updateLastAppliedSortingFlag = (jaql, sortDetails) => {
+    jaql.metadata.forEach((item) => {
+        const currentIndex = item.field && item.field.index;
+        if (sortDetails.field === currentIndex) {
+            item.jaql.sortDetails = item.jaql.sortDetails || sortDetails;
+            item.jaql.sortDetails.isLastApplied = true;
+            return;
+        }
+        if (item.jaql.sortDetails && item.jaql.sortDetails) {
+            delete item.jaql.sortDetails.isLastApplied;
+        }
+    });
+};
+exports.updateLastAppliedSortingFlag = updateLastAppliedSortingFlag;
+/**
+ * method to handle new sorting metadata
+ *
+ * @param {SortDetails} sortDetails - node with sorting metadata
+ * @param {?JaqlRequest} jaql - jaql to process
+ * @param {object} [options] - additional options
+ * @param {Function} [options.formatter] - fields formatter for measurePath
+ * @param {boolean} [options.isSingleRowTree] - defines data structure
+ * @returns {JaqlRequest} - reload pivot after jaql formatting
+ */
+const updatePanelsSortingMetadata = (sortDetails, jaql, options) => {
+    const { isSingleRowTree = false, formatter } = options || {};
+    if (!jaql) {
+        // eslint-disable-next-line no-console
+        console.warn('jaql is undefined or null!');
+        return;
+    }
+    const panelToSortBy = (0, exports.getMetadataPanelByIndex)(jaql, sortDetails.field);
+    if (panelToSortBy && panelToSortBy.panel === constants_js_1.PanelType.COLUMNS) {
+        // eslint-disable-next-line no-console
+        console.warn('Should not be sorted by "COLUMN" type panels!');
+        return;
+    }
+    if (!panelToSortBy) {
+        return;
+    }
+    const sortingLastDimension = isPanelsLastDimension(panelToSortBy, jaql);
+    if (isSingleRowTree) {
+        clearAllSortDetails(jaql);
+    }
+    else if (sortingLastDimension) {
+        clearLastDimesionSortDetails(jaql);
+    }
+    switch (sortDetails.dir) {
+        case constants_js_1.SortingDirection.DESC:
+        case null:
+            panelToSortBy.jaql.sort = constants_js_1.SortingDirection.ASC;
+            break;
+        case constants_js_1.SortingDirection.ASC:
+            panelToSortBy.jaql.sort = constants_js_1.SortingDirection.DESC;
+            break;
+        default:
+            panelToSortBy.jaql.sort = undefined;
+    }
+    const panelToSortByField = panelToSortBy.field || { index: Infinity };
+    if (panelToSortBy.jaql.sort) {
+        let { measurePath } = sortDetails;
+        if (measurePath) {
+            const panels = (0, exports.getMetadataPanels)(jaql);
+            const dataTypes = getDataTypes(panels);
+            measurePath = getCompatibleMeasurePath(measurePath, dataTypes, formatter);
+        }
+        panelToSortBy.jaql.sortDetails = {
+            field: panelToSortByField.index,
+            dir: panelToSortBy.jaql.sort,
+            sortingLastDimension,
+            measurePath,
+            initialized: true,
+        };
+    }
+    else {
+        panelToSortBy.jaql.sortDetails = undefined;
+    }
+    if (jaql && jaql.metadata && panelToSortByField.index !== undefined) {
+        jaql.metadata[panelToSortByField.index] = panelToSortBy;
+    }
+    (0, exports.updateLastAppliedSortingFlag)(jaql, sortDetails);
+};
+exports.updatePanelsSortingMetadata = updatePanelsSortingMetadata;
+/**
+ * Set width for jaql panel item
+ *
+ * @param {JaqlRequest} jaql - jaql request object
+ * @param {number} jaqlIndex - jaql panel item index
+ * @param {number} width - jaql panel item width
+ * @returns {void}
+ */
+const setResizeWidthToJaql = (jaql, jaqlIndex, width) => {
+    if (!jaql) {
+        return;
+    }
+    const jaqlPanel = (0, exports.getMetadataPanelByIndex)(jaql, jaqlIndex);
+    if (!jaqlPanel) {
+        return;
+    }
+    jaqlPanel.format = jaqlPanel.format || {};
+    jaqlPanel.format.width = width;
+};
+exports.setResizeWidthToJaql = setResizeWidthToJaql;
+/**
+ * Get pairs 'jaqlIndex: value'  for jaql panel items
+ *
+ * @param {JaqlRequest} jaql - jaql request object
+ * @returns {object} - object, keys - jaqlIndex, value - width
+ * appropriate width
+ */
+const getResizeWidthFromJaql = (jaql) => {
+    const result = {};
+    if (!jaql) {
+        return result;
+    }
+    const panels = (0, exports.getMetadataPanels)(jaql);
+    panels.forEach((panel) => {
+        const panelField = panel.field || { index: Infinity };
+        if (panel.format &&
+            typeof panel.format.width !== 'undefined' &&
+            typeof panelField.index !== 'undefined') {
+            result[panelField.index] = panel.format.width;
+        }
+    });
+    return result;
+};
+exports.getResizeWidthFromJaql = getResizeWidthFromJaql;
+const markSortedNode = (jaql, item) => {
+    if (typeof item.measureJaqlIndex !== 'undefined') {
+        const panels = (0, exports.getMetadataPanels)(jaql);
+        const dataTypes = getDataTypes(panels);
+        const rowWhereSortPropIs = panels
+            .filter((p) => p.panel === constants_js_1.PanelType.ROWS)
+            .find((rp) => {
+            const rowSortDetails = rp.jaql.sortDetails;
+            if (!rowSortDetails) {
+                return false;
+            }
+            const isIndexSame = rowSortDetails.field === item.measureJaqlIndex;
+            if (!isIndexSame) {
+                return false;
+            }
+            return Boolean(isMeasurePathEqual(item.measurePath, rowSortDetails.measurePath, dataTypes));
+        });
+        if (rowWhereSortPropIs) {
+            item.dir = rowWhereSortPropIs.jaql.sort ? rowWhereSortPropIs.jaql.sort : null;
+            return;
+        }
+        const panel = (0, exports.getMetadataPanelByIndex)(jaql, item.measureJaqlIndex);
+        if (panel && panel.jaql.sortDetails) {
+            const panelMeasurePath = panel.jaql.sortDetails.measurePath;
+            const itemMeasurePath = item.measurePath;
+            if (isMeasurePathEqual(panelMeasurePath, itemMeasurePath, dataTypes)) {
+                item.dir = panel.jaql.sort || null;
+                return;
+            }
+        }
+    }
+    item.dir = null;
+};
+exports.markSortedNode = markSortedNode;
+function handleComplexSortingSettingsUpdate(jaql, desiredSortingSettings, possibleSortDetailsOfCurrentMeasure, options) {
+    const { isSingleRowTree, formatter } = options;
+    if (isSingleRowTree) {
+        clearAllSortDetails(jaql);
+    }
+    jaql.metadata.forEach((item) => {
+        if (item.jaql.sortDetails) {
+            delete item.jaql.sortDetails.isLastApplied;
+        }
+    });
+    desiredSortingSettings.forEach((dss, index) => {
+        let indexOfPanelToSortBy;
+        if (index === desiredSortingSettings.length - 1) {
+            if (dss.selected) {
+                clearLastDimesionSortDetails(jaql);
+            }
+            indexOfPanelToSortBy = possibleSortDetailsOfCurrentMeasure.field;
+        }
+        else {
+            indexOfPanelToSortBy = dss.indexInJaql;
+        }
+        const panelToSortBy = (0, exports.getMetadataPanelByIndex)(jaql, indexOfPanelToSortBy);
+        if (!panelToSortBy) {
+            // eslint-disable-next-line no-console
+            console.warn(new Error('Panel not found'));
+            return;
+        }
+        if (dss.selected && !dss.direction) {
+            // eslint-disable-next-line no-console
+            console.warn(new Error("Direction should be defined and equal to 'asc' or 'desc'"));
+        }
+        const panels = (0, exports.getMetadataPanels)(jaql);
+        const dataTypes = getDataTypes(panels);
+        if (!dss.direction || !dss.selected) {
+            const { sortDetails } = panelToSortBy.jaql;
+            const shouldDeleteSorting = Boolean(sortDetails &&
+                possibleSortDetailsOfCurrentMeasure.field === sortDetails.field &&
+                isMeasurePathEqual(possibleSortDetailsOfCurrentMeasure.measurePath, sortDetails.measurePath, dataTypes));
+            if (shouldDeleteSorting) {
+                delete panelToSortBy.jaql.sort;
+                delete panelToSortBy.jaql.sortDetails;
+            }
+        }
+        if (dss.selected && dss.direction) {
+            panelToSortBy.jaql.sort = dss.direction;
+            let { measurePath } = possibleSortDetailsOfCurrentMeasure;
+            if (measurePath) {
+                measurePath = getCompatibleMeasurePath(measurePath, dataTypes, formatter);
+            }
+            if (possibleSortDetailsOfCurrentMeasure.measurePath === undefined &&
+                panelToSortBy.field && // for type checker
+                panelToSortBy.panel === 'rows' &&
+                possibleSortDetailsOfCurrentMeasure.field !== panelToSortBy.field.index) {
+                measurePath = {};
+            }
+            panelToSortBy.jaql.sortDetails = {
+                field: possibleSortDetailsOfCurrentMeasure.field,
+                dir: dss.direction,
+                sortingLastDimension: false,
+                measurePath,
+                isLastApplied: true,
+                initialized: true,
+            };
+        }
+    });
+}
+function checkLastRowSortedByMeasure(lastRow, // TODO: fix
+possibleSortDetailsOfCurrentMeasure, currentSortDetailsOfCurrentMeasure, dataTypesOfPanels) {
+    if (lastRow.jaql.sortDetails) {
+        // case 1: last row sorted
+        //   then `.dir` and `.sortDetails` will be on row `.jaql`
+        //   `direction` should be `undefined`
+        //   `selected` should be `false`
+        return false;
+    }
+    if (currentSortDetailsOfCurrentMeasure) {
+        // case 2: measure sorted
+        //   then `.dir` and `.sortDetails` will be on measure `.jaql`
+        //   `direction` should be `currentSortDetailsOfCurrentMeasure.dir`
+        //   `selected` should be `true`
+        return jaqlProcessor.isMeasurePathEqual(possibleSortDetailsOfCurrentMeasure.measurePath, currentSortDetailsOfCurrentMeasure.measurePath, dataTypesOfPanels);
+    }
+    // case 3: nothing sorted
+    return false;
+}
+function pickDirectionProperty(sd) {
+    const dir = sd && sd.dir;
+    switch (dir) {
+        case 'asc':
+        case 'desc':
+            return dir;
+        default:
+            return null;
+    }
+}
+function mapWidgetJaqlToComplexSortingSettings(jaql, possibleSortDetailsOfCurrentMeasure) {
+    var _a, _b;
+    const listOfRows = jaql.metadata.filter((meta) => meta.panel === 'rows'); // TODO: fix `any`
+    const metadataPanelOfCurrentMeasure = jaqlProcessor.getMetadataPanelByIndex(jaql, possibleSortDetailsOfCurrentMeasure.field); // TODO: fix `as`
+    // TODO: fix `as` type assertion
+    const datatype = metadataPanelOfCurrentMeasure.jaql.datatype;
+    // currentSortDetailsOfCurrentMeasure is not possibleSortDetailsOfCurrentMeasure
+    //   (measurePath can be different)
+    const currentSortDetailsOfCurrentMeasure = metadataPanelOfCurrentMeasure.jaql // TODO: name it better
+        .sortDetails; // TODO: fix `SortDetails`
+    const dataTypesOfPanels = jaqlProcessor.getDataTypes(jaqlProcessor.getMetadataPanels(jaql));
+    const listOfSettingsEntries = [];
+    for (let index = 0; index < listOfRows.length - 1; index += 1) {
+        const row = listOfRows[index];
+        const isRowSortedBySubtotals = Boolean(row.jaql.sortDetails &&
+            row.jaql.sortDetails.field === possibleSortDetailsOfCurrentMeasure.field &&
+            jaqlProcessor.isMeasurePathEqual(possibleSortDetailsOfCurrentMeasure.measurePath, row.jaql.sortDetails.measurePath, dataTypesOfPanels));
+        const direction = pickDirectionProperty(row.jaql.sortDetails);
+        listOfSettingsEntries.push({
+            title: row.jaql.title,
+            // `datatype` should correspond to datatype of value column on which
+            //   sorting settings was called
+            datatype,
+            selected: isRowSortedBySubtotals,
+            direction,
+            indexInJaql: (_a = row.field) === null || _a === void 0 ? void 0 : _a.index,
+        });
+    }
+    const lastRow = listOfRows[listOfRows.length - 1];
+    const isLastRowSortedByMeasure = checkLastRowSortedByMeasure(lastRow, possibleSortDetailsOfCurrentMeasure, currentSortDetailsOfCurrentMeasure, dataTypesOfPanels);
+    const direction = pickDirectionProperty(currentSortDetailsOfCurrentMeasure);
+    const lastEntry = {
+        title: lastRow.jaql.title,
+        // `datatype` should correspond to datatype of value column on which
+        //   sorting settings was called
+        datatype,
+        selected: isLastRowSortedByMeasure,
+        direction,
+        indexInJaql: (_b = metadataPanelOfCurrentMeasure.field) === null || _b === void 0 ? void 0 : _b.index,
+    };
+    listOfSettingsEntries.push(lastEntry);
+    return listOfSettingsEntries;
+}
+function mapWidgetJaqlToSimpleSortingSettings(metadataPanels, possibleSortDetailsOfCurrentMeasure, dataTypes) {
+    const result = metadataPanels
+        .filter((meta) => {
+        // eslint-disable-line arrow-body-style
+        return meta.field && possibleSortDetailsOfCurrentMeasure.field === meta.field.index;
+    })
+        .map((metadataPanel) => {
+        const { sortDetails } = metadataPanel.jaql;
+        const selected = Boolean(sortDetails &&
+            jaqlProcessor.isMeasurePathEqual(possibleSortDetailsOfCurrentMeasure.measurePath, sortDetails.measurePath, dataTypes));
+        const direction = selected ? pickDirectionProperty(sortDetails) : null;
+        return {
+            title: metadataPanel.jaql.title,
+            // TODO: remove `as` type assertion
+            datatype: metadataPanel.jaql.datatype,
+            selected,
+            direction,
+        };
+    });
+    return result[0];
+}
+exports.default = {
+    isMeasurePathEqual,
+    getDataTypes,
+    updatePanelsSortingMetadata: exports.updatePanelsSortingMetadata,
+    getMetadataTree: exports.getMetadataTree,
+    getMetadataPanels: exports.getMetadataPanels,
+    getMetadataPanelByIndex: exports.getMetadataPanelByIndex,
+    setResizeWidthToJaql: exports.setResizeWidthToJaql,
+    getResizeWidthFromJaql: exports.getResizeWidthFromJaql,
+    markSortedNode: exports.markSortedNode,
+    normalizeSingleBranchTreeSortDetails: exports.normalizeSingleBranchTreeSortDetails,
+    updateLastAppliedSortingFlag: exports.updateLastAppliedSortingFlag,
+    handleComplexSortingSettingsUpdate,
+    mapWidgetJaqlToSimpleSortingSettings,
+    mapWidgetJaqlToComplexSortingSettings,
+};