@mwater/visualization 5.0.0

package/lib/widgets/charts/pivot/PivotChartLayoutBuilder.js

@@ -0,0 +1,676 @@
+"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 });
+const lodash_1 = __importDefault(require("lodash"));
+const expressions_1 = require("@mwater/expressions");
+const AxisBuilder_1 = __importDefault(require("../../../axes/AxisBuilder"));
+const color_1 = __importDefault(require("color"));
+const PivotChartUtils = __importStar(require("./PivotChartUtils"));
+const canonical_json_1 = __importDefault(require("canonical-json"));
+const maxRows = 500;
+const maxColumns = 50;
+// Builds pivot table layout from the design and data
+// See PivotChart Design.md for more detauls
+class PivotChartLayoutBuilder {
+    schema;
+    exprUtils;
+    axisBuilder;
+    // Pass in schema
+    constructor(options) {
+        this.schema = options.schema;
+        this.exprUtils = new expressions_1.ExprUtils(this.schema);
+        this.axisBuilder = new AxisBuilder_1.default({ schema: this.schema });
+    }
+    buildLayout(design, data, locale) {
+        // Create empty layout
+        let cell, cells, column, i, layoutRow, segment;
+        const layout = {
+            rows: [],
+            striping: design.striping
+        };
+        // Get all columns
+        let columns = [];
+        for (segment of design.columns) {
+            columns = columns.concat(this.getRowsOrColumns(false, segment, data, locale));
+        }
+        // Get all rows
+        let rows = [];
+        for (segment of design.rows) {
+            rows = rows.concat(this.getRowsOrColumns(true, segment, data, locale));
+        }
+        // Limit rows
+        if (rows.length > maxRows) {
+            rows = rows.slice(0, maxRows);
+            layout.tooManyRows = true;
+        }
+        // Limit columns
+        if (columns.length > maxColumns) {
+            columns = columns.slice(0, maxColumns);
+            layout.tooManyColumns = true;
+        }
+        // Determine depth of row headers and column headers (how deeply nested segments are)
+        const rowsDepth = lodash_1.default.max(lodash_1.default.map(rows, (row) => row.length));
+        const columnsDepth = lodash_1.default.max(lodash_1.default.map(columns, (column) => column.length));
+        // Create indexed data (index each intersection's array by canonical json of rX and cX)
+        const dataIndexed = lodash_1.default.mapValues(data, (list) => lodash_1.default.zipObject(lodash_1.default.map(list, (row) => [(0, canonical_json_1.default)(lodash_1.default.pick(row, (v, k) => k.match(/^[rc]\d$/))), row])));
+        // Emit column headers, leaving blank space at left for row headers
+        for (let depth = 0; depth < columnsDepth; depth++) {
+            // If any segment has label and axis, add a special row of just labels
+            const hasValueAxisLabel = columns.some(column => column[depth]?.segment.label && column[depth]?.segment.valueAxis);
+            if (hasValueAxisLabel) {
+                const cells = Array(rowsDepth).fill({ type: "blank", text: null });
+                for (const column of columns) {
+                    cells.push({
+                        type: "column",
+                        subtype: "valueLabel",
+                        segment: column[depth]?.segment,
+                        section: column[depth]?.segment.id,
+                        text: column[depth]?.segment.label,
+                        align: "center",
+                        // Unconfigured if segment has no label or value
+                        unconfigured: !column[depth]?.segment?.label && !column[depth]?.segment?.valueAxis,
+                        bold: column[depth]?.segment.bold || column[depth]?.segment.valueLabelBold,
+                        italic: column[depth]?.segment.italic
+                    });
+                }
+                layout.rows.push({ cells });
+            }
+            // Emit column labels
+            const cells = Array(rowsDepth).fill({ type: "blank", text: null });
+            for (const column of columns) {
+                cells.push({
+                    type: "column",
+                    subtype: column[depth]?.segment?.valueAxis ? "value" : "label",
+                    segment: column[depth]?.segment,
+                    section: column[depth]?.segment.id,
+                    text: column[depth]?.label,
+                    align: "center",
+                    // Unconfigured if segment has no label or value
+                    unconfigured: !column[depth]?.segment?.label && !column[depth]?.segment?.valueAxis,
+                    bold: column[depth]?.segment.bold,
+                    italic: column[depth]?.segment.italic
+                });
+            }
+            layout.rows.push({ cells });
+        }
+        // Emit main section
+        // Keep track of current row segment, so we can re-emit headers for row segments that have both axis and label
+        let rowSegments = [];
+        for (let row of rows) {
+            // Emit special row header for any segments that have changed and have both axis and label
+            const needsSpecialRowHeader = [];
+            for (let depth = 0; depth < rowsDepth; depth++) {
+                if (row[depth] &&
+                    rowSegments[depth] !== row[depth].segment &&
+                    row[depth].segment.label &&
+                    row[depth].segment.valueAxis) {
+                    needsSpecialRowHeader.push(true);
+                }
+                else {
+                    needsSpecialRowHeader.push(false);
+                }
+            }
+            if (lodash_1.default.any(needsSpecialRowHeader)) {
+                cells = [];
+                for (let depth = 0; depth < rowsDepth; depth++) {
+                    if (needsSpecialRowHeader[depth]) {
+                        cells.push({
+                            type: "row",
+                            subtype: "valueLabel",
+                            segment: row[depth]?.segment,
+                            section: row[depth]?.segment.id,
+                            text: row[depth].segment.label,
+                            bold: row[depth]?.segment.bold || row[depth]?.segment.valueLabelBold,
+                            italic: row[depth]?.segment.italic
+                        });
+                    }
+                    else {
+                        cells.push({
+                            type: "row",
+                            subtype: "label",
+                            segment: row[depth]?.segment,
+                            section: row[depth]?.segment.id,
+                            text: null,
+                            // Unconfigured if segment has no label or value
+                            unconfigured: row[depth]?.segment && row[depth]?.segment.label == null && !row[depth]?.segment.valueAxis,
+                            bold: row[depth]?.segment.bold,
+                            italic: row[depth]?.segment.italic
+                        });
+                    }
+                }
+                // Add intersection columns
+                for (column of columns) {
+                    // Get intersection id
+                    const intersectionId = PivotChartUtils.getIntersectionId(lodash_1.default.map(row, (r) => r.segment), lodash_1.default.map(column, (c) => c.segment));
+                    cells.push({
+                        type: "intersection",
+                        subtype: "filler",
+                        section: intersectionId,
+                        text: null,
+                        backgroundColor: lodash_1.default.reduce(row, (total, r) => total || r.segment?.fillerColor || null, null)
+                    });
+                }
+                layout.rows.push({ cells });
+            }
+            // Reset row segments
+            rowSegments = lodash_1.default.pluck(row, "segment");
+            // Emit normal row headers
+            cells = [];
+            for (let depth = 0; depth < rowsDepth; depth++) {
+                cells.push({
+                    type: "row",
+                    subtype: row[depth]?.segment?.valueAxis ? "value" : "label",
+                    segment: row[depth]?.segment,
+                    section: row[depth]?.segment.id,
+                    text: row[depth]?.label,
+                    // Unconfigured if segment has no label or value
+                    unconfigured: row[depth]?.segment && row[depth]?.segment.label == null && !row[depth]?.segment.valueAxis,
+                    bold: row[depth]?.segment.bold,
+                    italic: row[depth]?.segment.italic,
+                    // Indent if has value and label
+                    indent: row[depth]?.segment?.valueAxis && row[depth]?.segment?.label ? 1 : undefined
+                });
+            }
+            // Emit contents
+            for (column of columns) {
+                cells.push(this.buildIntersectionCell(design, dataIndexed, locale, row, column));
+            }
+            layout.rows.push({ cells });
+        }
+        // Set up section top/left/bottom/right info
+        for (let columnIndex = 0; columnIndex < layout.rows[0].cells.length; columnIndex++) {
+            for (let rowIndex = 0; rowIndex < layout.rows.length; rowIndex++) {
+                cell = layout.rows[rowIndex].cells[columnIndex];
+                cell.sectionTop =
+                    cell.section != null &&
+                        (rowIndex === 0 || layout.rows[rowIndex - 1].cells[columnIndex].section !== cell.section);
+                cell.sectionLeft =
+                    cell.section != null &&
+                        (columnIndex === 0 || layout.rows[rowIndex].cells[columnIndex - 1].section !== cell.section);
+                cell.sectionRight =
+                    cell.section != null &&
+                        (columnIndex >= layout.rows[0].cells.length - 1 ||
+                            layout.rows[rowIndex].cells[columnIndex + 1].section !== cell.section);
+                cell.sectionBottom =
+                    cell.section != null &&
+                        (rowIndex >= layout.rows.length - 1 || layout.rows[rowIndex + 1].cells[columnIndex].section !== cell.section);
+            }
+        }
+        this.setupSummarize(design, layout);
+        this.setupBorders(layout);
+        // Span column headers and column segments that have same segment and value (TODO: uses text right now)
+        for (layoutRow of layout.rows) {
+            let refCell = null;
+            for (i = 0; i < layoutRow.cells.length; i++) {
+                cell = layoutRow.cells[i];
+                if (i === 0) {
+                    refCell = cell;
+                    continue;
+                }
+                // If matches, span columns
+                if (cell.type === "column" &&
+                    cell.text === refCell.text &&
+                    cell.type === refCell.type &&
+                    cell.section === refCell.section) {
+                    cell.skip = true;
+                    refCell.columnSpan = (refCell.columnSpan || 1) + 1;
+                    refCell.sectionRight = true;
+                    refCell.borderRight = cell.borderRight;
+                }
+                else {
+                    refCell = cell;
+                }
+            }
+        }
+        // Span intersections that are fillers
+        for (layoutRow of layout.rows) {
+            let refCell = null;
+            for (i = 0; i < layoutRow.cells.length; i++) {
+                cell = layoutRow.cells[i];
+                if (i === 0) {
+                    refCell = cell;
+                    continue;
+                }
+                // If matches, span columns
+                if (cell.type === "intersection" &&
+                    cell.subtype === "filler" &&
+                    cell.type === refCell.type &&
+                    cell.subtype === refCell.subtype) {
+                    cell.skip = true;
+                    refCell.columnSpan = (refCell.columnSpan || 1) + 1;
+                    refCell.sectionRight = true;
+                    refCell.borderRight = cell.borderRight;
+                }
+                else {
+                    refCell = cell;
+                }
+            }
+        }
+        // Span row headers and row segments that have same segment and value (TODO: uses text right now)
+        for (let columnIndex = 0; columnIndex < layout.rows[0].cells.length; columnIndex++) {
+            let refCell = null;
+            for (let rowIndex = 0; rowIndex < layout.rows.length; rowIndex++) {
+                cell = layout.rows[rowIndex].cells[columnIndex];
+                if (rowIndex === 0) {
+                    refCell = cell;
+                    continue;
+                }
+                // If matches, span rows
+                if (cell.type === "row" &&
+                    cell.text === refCell.text &&
+                    cell.type === refCell.type &&
+                    cell.section === refCell.section) {
+                    cell.skip = true;
+                    refCell.rowSpan = (refCell.rowSpan || 1) + 1;
+                    refCell.sectionBottom = true;
+                    refCell.borderBottom = cell.borderBottom;
+                }
+                else {
+                    refCell = cell;
+                }
+            }
+        }
+        // Span column headers that have the same segment and value (TODO: uses text right now)
+        for (let columnIndex = 0; columnIndex < layout.rows[0].cells.length; columnIndex++) {
+            let refCell = null;
+            for (let rowIndex = 0; rowIndex < layout.rows.length; rowIndex++) {
+                cell = layout.rows[rowIndex].cells[columnIndex];
+                if (rowIndex === 0) {
+                    refCell = cell;
+                    continue;
+                }
+                // If matches, span rows
+                if (cell.type === "column" &&
+                    cell.text === refCell.text &&
+                    cell.type === refCell.type &&
+                    cell.section === refCell.section) {
+                    cell.skip = true;
+                    refCell.rowSpan = (refCell.rowSpan || 1) + 1;
+                    refCell.sectionBottom = true;
+                    refCell.borderBottom = cell.borderBottom;
+                }
+                else {
+                    refCell = cell;
+                }
+            }
+        }
+        return layout;
+    }
+    // Build a cell which is the intersection of a row and column, where row and column are nested arrays
+    // from getRowsOrColumns
+    // dataIndexed is created above. See there for format
+    buildIntersectionCell(design, dataIndexed, locale, row, column) {
+        // Get intersection id
+        let i, part, text;
+        const intersectionId = PivotChartUtils.getIntersectionId(lodash_1.default.map(row, (r) => r.segment), lodash_1.default.map(column, (c) => c.segment));
+        // Lookup intersection
+        const intersection = design.intersections[intersectionId];
+        if (!intersection) {
+            // Should not happen
+            return { type: "blank", text: null };
+        }
+        // Lookup data
+        const intersectionData = dataIndexed[intersectionId];
+        // Create key to lookup value
+        const key = {};
+        for (i = 0; i < row.length; i++) {
+            part = row[i];
+            key[`r${i}`] = part.value;
+        }
+        for (i = 0; i < column.length; i++) {
+            part = column[i];
+            key[`c${i}`] = part.value;
+        }
+        // Lookup value by finding an entry which matches all of the row and column values
+        const entry = intersectionData?.[(0, canonical_json_1.default)(key)];
+        const value = entry?.value;
+        // Format using axis builder if present. Blank otherwise
+        if (value != null) {
+            text = this.axisBuilder.formatValue(intersection.valueAxis, value, locale);
+        }
+        else {
+            text = intersection.valueAxis?.nullLabel || null;
+        }
+        const cell = {
+            type: "intersection",
+            subtype: "value",
+            section: intersectionId,
+            text,
+            align: "right",
+            bold: intersection.bold,
+            italic: intersection.italic
+        };
+        // Set background color
+        let backgroundColor = null;
+        const iterable = intersection.backgroundColorConditions || [];
+        for (i = 0; i < iterable.length; i++) {
+            const backgroundColorCondition = iterable[i];
+            if (entry?.[`bcc${i}`]) {
+                backgroundColor = backgroundColorCondition.color;
+            }
+        }
+        if (!backgroundColor && intersection.backgroundColorAxis && entry?.bc != null) {
+            backgroundColor = this.axisBuilder.getValueColor(intersection.backgroundColorAxis, entry?.bc);
+        }
+        if (!backgroundColor && intersection.backgroundColor && !intersection.backgroundColorAxis) {
+            ;
+            ({ backgroundColor } = intersection);
+        }
+        if (backgroundColor) {
+            backgroundColor = (0, color_1.default)(backgroundColor).alpha(intersection.backgroundColorOpacity || 1).string();
+            cell.backgroundColor = backgroundColor;
+        }
+        return cell;
+    }
+    // Determine summarize value for unconfigured cells
+    setupSummarize(design, layout) {
+        return __range__(0, layout.rows[0].cells.length, false).map((columnIndex) => (() => {
+            const result = [];
+            for (let rowIndex = 0, end = layout.rows.length, asc = 0 <= end; asc ? rowIndex < end : rowIndex > end; asc ? rowIndex++ : rowIndex--) {
+                const cell = layout.rows[rowIndex].cells[columnIndex];
+                if (cell.unconfigured && cell.type === "row") {
+                    cell.summarize = PivotChartUtils.canSummarizeSegment(design.rows, cell.section);
+                }
+                if (cell.unconfigured && cell.type === "column") {
+                    result.push((cell.summarize = PivotChartUtils.canSummarizeSegment(design.columns, cell.section)));
+                }
+                else {
+                    result.push(undefined);
+                }
+            }
+            return result;
+        })());
+    }
+    // Determine borders, mutating cells
+    setupBorders(layout) {
+        // Set up borders for row and column cells
+        let cell, columnIndex, rowIndex;
+        let asc, end;
+        let asc2, end2;
+        const borderTops = []; // Array of border top information for intersections. index is layout row number
+        const borderBottoms = []; // Array of border bottom information for intersections. index is layout row number
+        const borderLefts = []; // Array of border left information for intersections. index is layout column number
+        const borderRights = []; // Array of border right information for intersections. index is layout column number
+        for (columnIndex = 0, end = layout.rows[0].cells.length, asc = 0 <= end; asc ? columnIndex < end : columnIndex > end; asc ? columnIndex++ : columnIndex--) {
+            var asc1, end1;
+            for (rowIndex = 0, end1 = layout.rows.length, asc1 = 0 <= end1; asc1 ? rowIndex < end1 : rowIndex > end1; asc1 ? rowIndex++ : rowIndex--) {
+                cell = layout.rows[rowIndex].cells[columnIndex];
+                if (cell.type === "row") {
+                    // Rows have always left and right = 2
+                    cell.borderLeft = 2;
+                    cell.borderRight = 2;
+                    // Top is from segment (default 2) if section left, otherwise from segment (default 1).
+                    if (cell.sectionTop) {
+                        if (cell.segment?.borderBefore != null) {
+                            cell.borderTop = cell.segment?.borderBefore;
+                        }
+                        else {
+                            cell.borderTop = 2;
+                        }
+                        // Only border within if changed value (TODO: uses text right now)
+                    }
+                    else if (rowIndex > 0 && layout.rows[rowIndex - 1].cells[columnIndex].text !== cell.text) {
+                        if (cell.segment?.borderWithin != null) {
+                            cell.borderTop = cell.segment?.borderWithin;
+                        }
+                        else {
+                            cell.borderTop = 1;
+                        }
+                    }
+                    else {
+                        cell.borderTop = 0;
+                    }
+                    // Bottom is from segment (default 2) if section right, otherwise from segment (default 1)
+                    if (cell.sectionBottom) {
+                        if (cell.segment?.borderAfter != null) {
+                            cell.borderBottom = cell.segment?.borderAfter;
+                        }
+                        else {
+                            cell.borderBottom = 2;
+                        }
+                        // Only border within if changed value (TODO: uses text right now)
+                    }
+                    else if (rowIndex < layout.rows.length - 1 &&
+                        layout.rows[rowIndex + 1].cells[columnIndex].text !== cell.text) {
+                        if (cell.segment?.borderWithin != null) {
+                            cell.borderBottom = cell.segment?.borderWithin;
+                        }
+                        else {
+                            cell.borderBottom = 1;
+                        }
+                    }
+                    else {
+                        cell.borderBottom = 0;
+                    }
+                    // Save for intersections
+                    borderTops[rowIndex] = Math.max(borderTops[rowIndex] || 0, cell.borderTop);
+                    borderBottoms[rowIndex] = Math.max(borderBottoms[rowIndex] || 0, cell.borderBottom);
+                }
+                // Columns have always top and bottom = 2
+                if (cell.type === "column") {
+                    cell.borderTop = 2;
+                    cell.borderBottom = 2;
+                    // Left is from segment (default 2) if section left, otherwise from segment (default 1).
+                    // TODO for nested segments, within is zero if data did not change
+                    if (cell.sectionLeft) {
+                        if (cell.segment?.borderBefore != null) {
+                            cell.borderLeft = cell.segment?.borderBefore;
+                        }
+                        else {
+                            cell.borderLeft = 2;
+                        }
+                        // Only border within if changed value (TODO: uses text right now)
+                    }
+                    else if (columnIndex > 0 && layout.rows[rowIndex].cells[columnIndex - 1].text !== cell.text) {
+                        if (cell.segment?.borderWithin != null) {
+                            cell.borderLeft = cell.segment?.borderWithin;
+                        }
+                        else {
+                            cell.borderLeft = 1;
+                        }
+                    }
+                    else {
+                        cell.borderLeft = 0;
+                    }
+                    // Right is from segment (default 2) if section right, otherwise from segment (default 1)
+                    if (cell.sectionRight) {
+                        if (cell.segment?.borderAfter != null) {
+                            cell.borderRight = cell.segment?.borderAfter;
+                        }
+                        else {
+                            cell.borderRight = 2;
+                        }
+                        // Only border within if changed value (TODO: uses text right now)
+                    }
+                    else if (columnIndex < layout.rows[rowIndex].cells.length - 1 &&
+                        layout.rows[rowIndex].cells[columnIndex + 1].text !== cell.text) {
+                        if (cell.segment?.borderWithin != null) {
+                            cell.borderRight = cell.segment?.borderWithin;
+                        }
+                        else {
+                            cell.borderRight = 1;
+                        }
+                    }
+                    else {
+                        cell.borderRight = 0;
+                    }
+                    // Save for intersections, keeping heaviest
+                    borderLefts[columnIndex] = Math.max(borderLefts[columnIndex] || 0, cell.borderLeft);
+                    borderRights[columnIndex] = Math.max(borderRights[columnIndex] || 0, cell.borderRight);
+                }
+            }
+        }
+        // Propagate borders across row cells and down column cells so that heavier border win
+        for (columnIndex = 1, end2 = layout.rows[0].cells.length, asc2 = 1 <= end2; asc2 ? columnIndex < end2 : columnIndex > end2; asc2 ? columnIndex++ : columnIndex--) {
+            var asc3, end3;
+            for (rowIndex = 1, end3 = layout.rows.length, asc3 = 1 <= end3; asc3 ? rowIndex < end3 : rowIndex > end3; asc3 ? rowIndex++ : rowIndex--) {
+                cell = layout.rows[rowIndex].cells[columnIndex];
+                if (cell.type === "row") {
+                    cell.borderTop = Math.max(layout.rows[rowIndex].cells[columnIndex - 1].borderTop, cell.borderTop);
+                    cell.borderBottom = Math.max(layout.rows[rowIndex].cells[columnIndex - 1].borderBottom, cell.borderBottom);
+                }
+                if (cell.type === "column") {
+                    cell.borderLeft = Math.max(layout.rows[rowIndex - 1].cells[columnIndex].borderLeft, cell.borderLeft);
+                    cell.borderRight = Math.max(layout.rows[rowIndex - 1].cells[columnIndex].borderRight, cell.borderRight);
+                }
+            }
+        }
+        // Setup borders of intersections
+        return (() => {
+            let asc4, end4;
+            const result = [];
+            for (columnIndex = 0, end4 = layout.rows[0].cells.length, asc4 = 0 <= end4; asc4 ? columnIndex < end4 : columnIndex > end4; asc4 ? columnIndex++ : columnIndex--) {
+                result.push((() => {
+                    let asc5, end5;
+                    const result1 = [];
+                    for (rowIndex = 0, end5 = layout.rows.length, asc5 = 0 <= end5; asc5 ? rowIndex < end5 : rowIndex > end5; asc5 ? rowIndex++ : rowIndex--) {
+                        cell = layout.rows[rowIndex].cells[columnIndex];
+                        if (cell.type === "intersection") {
+                            cell.borderLeft = borderLefts[columnIndex];
+                            cell.borderRight = borderRights[columnIndex];
+                            cell.borderTop = borderTops[rowIndex];
+                            result1.push((cell.borderBottom = borderBottoms[rowIndex]));
+                        }
+                        else {
+                            result1.push(undefined);
+                        }
+                    }
+                    return result1;
+                })());
+            }
+            return result;
+        })();
+    }
+    // Get rows or columns in format of array of
+    // [{ segment:, label:, value:  }, ...]
+    // For segments with no children, there will be an array of single value array entries (array of array)
+    // data is lookup of query results by intersection id
+    // parentSegments are ancestry of current segment, starting with root
+    getRowsOrColumns(isRow, segment, data, locale, parentSegments = [], parentValues = []) {
+        // If no axis, categories are just null
+        let categories, value;
+        if (!segment.valueAxis) {
+            categories = [{ value: null, label: segment.label }];
+        }
+        else {
+            // Find all values (needed for category finding of axis)
+            let allValues = [];
+            // To find all values, first need all intersections that are relevant
+            for (let intersectionId in data) {
+                // Ignore non-intersection data (header + footer)
+                var segIds;
+                const intersectionData = data[intersectionId];
+                if (!intersectionId.match(":")) {
+                    continue;
+                }
+                // Get segment ids
+                if (isRow) {
+                    segIds = intersectionId.split(":")[0].split(",");
+                }
+                else {
+                    segIds = intersectionId.split(":")[1].split(",");
+                }
+                // Ensure that matches any parent segments passed in plus self
+                if (!lodash_1.default.isEqual(lodash_1.default.take(segIds, parentSegments.length + 1), lodash_1.default.pluck(parentSegments, "id").concat(segment.id))) {
+                    continue;
+                }
+                // Only take data that matches any parent values
+                const relevantData = lodash_1.default.filter(intersectionData, (dataRow) => {
+                    for (let i = 0; i < parentValues.length; i++) {
+                        const parentValue = parentValues[i];
+                        if (isRow) {
+                            if (dataRow[`r${i}`] !== parentValue) {
+                                return false;
+                            }
+                        }
+                        else {
+                            if (dataRow[`c${i}`] !== parentValue) {
+                                return false;
+                            }
+                        }
+                    }
+                    return true;
+                });
+                if (isRow) {
+                    allValues = allValues.concat(lodash_1.default.pluck(relevantData, `r${parentSegments.length}`));
+                }
+                else {
+                    allValues = allValues.concat(lodash_1.default.pluck(relevantData, `c${parentSegments.length}`));
+                }
+            }
+            // Get categories, mapping label
+            categories = lodash_1.default.map(this.axisBuilder.getCategories(segment.valueAxis, allValues, { locale, onlyValuesPresent: segment.valueAxisOnlyValuesPresent }), (category) => {
+                return { value: category.value, label: this.axisBuilder.formatCategory(segment.valueAxis, category) };
+            });
+            // Filter excluded values
+            categories = lodash_1.default.filter(categories, (category) => !(segment.valueAxis.excludedValues || []).includes(category.value));
+            // Always have placeholder category
+            if (categories.length === 0) {
+                categories = [{ value: null, label: null }];
+            }
+            // Sort categories if segment is sorted
+            if (segment.orderExpr) {
+                // Index the ordering by the JSON.stringify to make it O(n)
+                const orderIndex = {};
+                const iterable = lodash_1.default.pluck(data[segment.id], "value");
+                for (let index = 0; index < iterable.length; index++) {
+                    value = iterable[index];
+                    orderIndex[JSON.stringify(value)] = index;
+                }
+                // Sort the categories
+                categories = lodash_1.default.sortBy(categories, (category) => orderIndex[JSON.stringify(category.value)]);
+            }
+        }
+        // If no children segments, return
+        if (!segment.children || segment.children.length === 0) {
+            return lodash_1.default.map(categories, (category) => [{ segment, value: category.value, label: category.label }]);
+        }
+        // For each category, get children and combine into results
+        const results = [];
+        for (let category of categories) {
+            for (let childSegment of segment.children) {
+                // Get child results
+                const childResults = this.getRowsOrColumns(isRow, childSegment, data, locale, parentSegments.concat([segment]), parentValues.concat([category.value]));
+                for (let childResult of childResults) {
+                    results.push([{ segment, value: category.value, label: category.label }].concat(childResult));
+                }
+            }
+        }
+        return results;
+    }
+}
+exports.default = PivotChartLayoutBuilder;
+function __range__(left, right, inclusive) {
+    let range = [];
+    let ascending = left < right;
+    let end = !inclusive ? right : ascending ? right + 1 : right - 1;
+    for (let i = left; ascending ? i < end : i > end; ascending ? i++ : i--) {
+        range.push(i);
+    }
+    return range;
+}