@malloydata/render 0.0.58 → 0.0.59-dev230718005248

package/dist/html/table.d.ts

@@ -1,13 +1,16 @@
-import { DataColumn, Field, Tags } from '@malloydata/malloy';
+import { DataColumn, Field } from '@malloydata/malloy';
 import { StyleDefaults } from '../data_styles';
 import { ContainerRenderer } from './container';
 import { Renderer } from '../renderer';
 export declare class HTMLTableRenderer extends ContainerRenderer {
     protected childrenStyleDefaults: StyleDefaults;
     render(table: DataColumn): Promise<HTMLElement>;
+    calculatePivotDimensions(table: DataColumn): {
+        dimensions: Field[];
+        nonDimensions: Field[];
+    };
     generatePivotedCells(table: DataColumn, shouldTranspose: boolean): Promise<Map<string, Map<string, HTMLTableCellElement>>>;
-    generateNoValueCell(table: DataColumn, field: Field, shouldTranspose: boolean): HTMLTableCellElement;
-    tagIsPresent(tags: Tags | undefined, tag: string): boolean;
+    generateNoValueCell(field: Field, shouldTranspose: boolean): HTMLTableCellElement;
     createCellAndRender(childRenderer: Renderer, value: DataColumn, shouldTranspose: boolean): Promise<HTMLTableCellElement>;
     createHeaderCell(field: Field, shouldTranspose: boolean): HTMLTableCellElement;
     createCell(childRenderer: Renderer, shouldTranspose: boolean): HTMLTableCellElement;

package/dist/html/table.js

@@ -59,7 +59,7 @@ class HTMLTableRenderer extends container_1.ContainerRenderer {
         if (!table.isArray() && !table.isRecord()) {
             throw new Error('Invalid type for Table Renderer');
         }
-        const shouldTranspose = this.tagIsPresent(this.tags, 'transpose');
+        const shouldTranspose = (0, utils_1.tagIsPresent)(this.tags, 'transpose');
         if (shouldTranspose && table.field.intrinsicFields.length > 20) {
             throw new Error('Transpose limit of 20 columns exceeded.');
         }
@@ -75,23 +75,23 @@ class HTMLTableRenderer extends container_1.ContainerRenderer {
             }
             const childRenderer = this.childRenderers[field.name];
             const shouldPivot = childRenderer instanceof HTMLTableRenderer &&
-                this.tagIsPresent(childRenderer.tags, 'pivot');
+                (0, utils_1.tagIsPresent)(childRenderer.tags, 'pivot');
             if (shouldPivot) {
                 const pivotedFields = new Map();
                 let dimensions = undefined;
                 let nonDimensions = [];
                 for (const row of table) {
                     const dc = row.cell(field);
+                    if (dc.isNull()) {
+                        continue;
+                    }
                     if (!dc.isArray() && !dc.isRecord()) {
-                        throw new Error(`Cannot pivot field ${field.name}.`);
+                        throw new Error(`Can not pivot field ${field.name}.`);
                     }
                     if (!dimensions) {
-                        const fieldi = dc.field;
-                        dimensions = fieldi.dimensions;
-                        nonDimensions = fieldi.allFields.filter(f => dimensions.indexOf(f) < 0);
-                        if (nonDimensions.length === 0) {
-                            throw new Error(`Can not pivot ${field.name} since all of its fields are dimensions.`);
-                        }
+                        const dimensionsResult = childRenderer.calculatePivotDimensions(dc);
+                        dimensions = dimensionsResult.dimensions;
+                        nonDimensions = dimensionsResult.nonDimensions;
                     }
                     for (const innerRow of dc) {
                         const pivotedField = new PivotedField(field, dimensions.map(d => innerRow.cell(d)));
@@ -101,6 +101,9 @@ class HTMLTableRenderer extends container_1.ContainerRenderer {
                         }
                     }
                 }
+                if (!dimensions) {
+                    throw new Error(`Could not pivot ${field.name}, no data found.`);
+                }
                 for (const pf of pivotedFields) {
                     for (const nonDimension of nonDimensions) {
                         columnFields.push(new PivotedColumnField(pf[1], nonDimension));
@@ -166,69 +169,64 @@ class HTMLTableRenderer extends container_1.ContainerRenderer {
             rowIndex++;
         }
         cells = [...pivotHeaderCells, ...cells];
-        try {
-            for (const row of table) {
-                cells[rowIndex] = [];
-                columnIndex = 0;
-                let currentPivotedFieldKey = '';
-                let pivotedCells = new Map();
-                for (const field of columnFields) {
-                    if (field instanceof PivotedColumnField) {
-                        const childRenderer = this.childRenderers[field.pivotedField.parentField.name];
-                        const childTableRecord = row.cell(field.pivotedField.parentField);
-                        await (0, utils_1.yieldTask)();
-                        if (field.pivotedField.key !== currentPivotedFieldKey) {
-                            pivotedCells = await childRenderer.generatePivotedCells(childTableRecord, shouldTranspose);
-                            currentPivotedFieldKey = field.pivotedField.key;
-                        }
-                        const pfKey = field.pivotedField.key;
-                        if (pivotedCells.has(pfKey) &&
-                            ((_a = pivotedCells.get(pfKey)) === null || _a === void 0 ? void 0 : _a.has(field.field.name))) {
-                            cells[rowIndex][columnIndex] = pivotedCells
-                                .get(pfKey)
-                                .get(field.field.name);
-                        }
-                        else {
-                            cells[rowIndex][columnIndex] = childRenderer.generateNoValueCell(childTableRecord, field.field, shouldTranspose);
-                        }
-                        columnIndex++;
-                        // back
+        for (const row of table) {
+            cells[rowIndex] = [];
+            columnIndex = 0;
+            let currentPivotedFieldKey = '';
+            let pivotedCells = new Map();
+            for (const field of columnFields) {
+                if (field instanceof PivotedColumnField) {
+                    const childRenderer = this.childRenderers[field.pivotedField.parentField.name];
+                    const childTableRecord = row.cell(field.pivotedField.parentField);
+                    await (0, utils_1.yieldTask)();
+                    if (field.pivotedField.key !== currentPivotedFieldKey) {
+                        pivotedCells = await childRenderer.generatePivotedCells(childTableRecord, shouldTranspose);
+                        currentPivotedFieldKey = field.pivotedField.key;
+                    }
+                    const pfKey = field.pivotedField.key;
+                    if (pivotedCells.has(pfKey) &&
+                        ((_a = pivotedCells.get(pfKey)) === null || _a === void 0 ? void 0 : _a.has(field.field.name))) {
+                        cells[rowIndex][columnIndex] = pivotedCells
+                            .get(pfKey)
+                            .get(field.field.name);
                     }
                     else {
-                        if ((0, tags_utils_1.isFieldHidden)(field)) {
-                            continue;
-                        }
-                        const childRenderer = this.childRenderers[field.name];
-                        cells[rowIndex][columnIndex] = await this.createCellAndRender(childRenderer, row.cell(field), shouldTranspose);
-                        columnIndex++;
+                        cells[rowIndex][columnIndex] = childRenderer.generateNoValueCell(field.field, shouldTranspose);
                     }
+                    columnIndex++;
+                    // back
                 }
-                // TODO(figutierrez): Deal with drill when transpose is on.
-                if (!shouldTranspose && this.options.isDrillingEnabled) {
-                    const drillCell = this.document.createElement('td');
-                    const drillIcon = (0, utils_1.createDrillIcon)(this.document);
-                    drillCell.appendChild(drillIcon);
-                    drillCell.style.cssText = `
+                else {
+                    if ((0, tags_utils_1.isFieldHidden)(field)) {
+                        continue;
+                    }
+                    const childRenderer = this.childRenderers[field.name];
+                    cells[rowIndex][columnIndex] = await this.createCellAndRender(childRenderer, row.cell(field), shouldTranspose);
+                    columnIndex++;
+                }
+            }
+            // TODO(figutierrez): Deal with drill when transpose is on.
+            if (!shouldTranspose && this.options.isDrillingEnabled) {
+                const drillCell = this.document.createElement('td');
+                const drillIcon = (0, utils_1.createDrillIcon)(this.document);
+                drillCell.appendChild(drillIcon);
+                drillCell.style.cssText = `
           padding: 8px;
           vertical-align: top;
           border-bottom: 1px solid var(--malloy-border-color, #eaeaea);
           width: 25px;
           cursor: pointer
         `;
-                    drillCell.onclick = () => {
-                        if (this.options.onDrill) {
-                            const { drillQuery, drillFilters } = (0, drill_1.getDrillQuery)(row);
-                            this.options.onDrill(drillQuery, drillIcon, drillFilters);
-                        }
-                    };
-                    cells[rowIndex][columnIndex] = drillCell;
-                    columnIndex++;
-                }
-                rowIndex++;
+                drillCell.onclick = () => {
+                    if (this.options.onDrill) {
+                        const { drillQuery, drillFilters } = (0, drill_1.getDrillQuery)(row);
+                        this.options.onDrill(drillQuery, drillIcon, drillFilters);
+                    }
+                };
+                cells[rowIndex][columnIndex] = drillCell;
+                columnIndex++;
             }
-        }
-        catch (e) {
-            throw new Error(`${e.toString()} ${e.stack}`);
+            rowIndex++;
         }
         const tableElement = this.document.createElement('table');
         let tableSection = this.document.createElement('thead');
@@ -253,12 +251,40 @@ class HTMLTableRenderer extends container_1.ContainerRenderer {
     `;
         return tableElement;
     }
+    calculatePivotDimensions(table) {
+        if (!table.isArray() && !table.isRecord()) {
+            throw new Error(`Could not pivot ${table.field.name}`);
+        }
+        let dimensions = undefined;
+        const userSpecifiedDimensions = (0, utils_1.parseCommaSeparatedParameterTagValue)(this.tags, 'pivotDimensions');
+        if (userSpecifiedDimensions) {
+            dimensions = table.field.allFields.filter(f => userSpecifiedDimensions.indexOf(f.name) >= 0);
+            if (dimensions.length !== userSpecifiedDimensions.length) {
+                for (const dim of userSpecifiedDimensions) {
+                    if (table.field.allFields.filter(f => f.name === dim).length === 0) {
+                        throw new Error(`Could not pivot ${table.field.name} since ${dim} is not a valid field.`);
+                    }
+                }
+            }
+        }
+        else {
+            dimensions = table.field.dimensions;
+        }
+        const nonDimensions = table.field.allFields.filter(f => dimensions.indexOf(f) < 0);
+        if (nonDimensions.length === 0) {
+            throw new Error(`Can not pivot ${table.field.name} since all of its fields are dimensions.`);
+        }
+        return { dimensions, nonDimensions };
+    }
     async generatePivotedCells(table, shouldTranspose) {
         const result = new Map();
+        if (table.isNull()) {
+            return result;
+        }
         if (!table.isArray() && !table.isRecord()) {
             throw new Error(`Could not pivot ${table.field.name}`);
         }
-        const dimensions = table.field.dimensions;
+        const { dimensions } = this.calculatePivotDimensions(table);
         for (const row of table) {
             const pf = new PivotedField(table.field, dimensions.map(f => row.cell(f.name)));
             const renderedCells = new Map();
@@ -266,21 +292,18 @@ class HTMLTableRenderer extends container_1.ContainerRenderer {
                 const childRenderer = this.childRenderers[nonDimension.name];
                 renderedCells.set(nonDimension.name, await this.createCellAndRender(childRenderer, row.cell(nonDimension.name), shouldTranspose));
             }
+            if (result.has(pf.key)) {
+                throw new Error(`Can not pivot ${table.field.name} dimensions lead to non unique pivots.`);
+            }
             result.set(pf.key, renderedCells);
         }
         return result;
     }
-    generateNoValueCell(table, field, shouldTranspose) {
-        if (!table.isArray() && !table.isRecord()) {
-            throw new Error(`Could not pivot ${table.field.name}`);
-        }
+    generateNoValueCell(field, shouldTranspose) {
         const cell = this.createCell(this.childRenderers[field.name], shouldTranspose);
         cell.innerHTML = '-';
         return cell;
     }
-    tagIsPresent(tags, tag) {
-        return tags ? tags.getMalloyTags().properties[tag] === true : false;
-    }
     async createCellAndRender(childRenderer, value, shouldTranspose) {
         const cell = this.createCell(childRenderer, shouldTranspose);
         cell.appendChild(await childRenderer.render(value));

package/dist/html/utils.d.ts

@@ -12,3 +12,5 @@ export declare function createNullElement(document: Document): HTMLElement;
 export declare function createDrillIcon(document: Document): HTMLElement;
 export declare function formatTitle(options: RendererOptions, field: Field, renderDef?: RenderDef | undefined, timezone?: string): string;
 export declare function tagIsPresent(tags: Tags | undefined, tagToCheck: string): boolean;
+export declare function parameterTagValue(tags: Tags | undefined, tagToGetValue: string): string | undefined;
+export declare function parseCommaSeparatedParameterTagValue(tags: Tags | undefined, tagToGetValue: string): string[] | undefined;

package/dist/html/utils.js

@@ -25,7 +25,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tagIsPresent = exports.formatTitle = exports.createDrillIcon = exports.createNullElement = exports.createErrorElement = exports.yieldTask = exports.normalizeToTimezone = exports.timeToString = exports.getColorScale = void 0;
+exports.parseCommaSeparatedParameterTagValue = exports.parameterTagValue = exports.tagIsPresent = exports.formatTitle = exports.createDrillIcon = exports.createNullElement = exports.createErrorElement = exports.yieldTask = exports.normalizeToTimezone = exports.timeToString = exports.getColorScale = void 0;
 const malloy_1 = require("@malloydata/malloy");
 const startCase_1 = __importDefault(require("lodash/startCase"));
 const luxon_1 = require("luxon");
@@ -232,4 +232,17 @@ function tagIsPresent(tags, tagToCheck) {
     return tagProperty !== undefined && tagProperty !== false;
 }
 exports.tagIsPresent = tagIsPresent;
+function parameterTagValue(tags, tagToGetValue) {
+    const tagProperty = tags === null || tags === void 0 ? void 0 : tags.getMalloyTags().properties[tagToGetValue];
+    if (typeof tagProperty === 'string') {
+        return tagProperty;
+    }
+    return undefined;
+}
+exports.parameterTagValue = parameterTagValue;
+function parseCommaSeparatedParameterTagValue(tags, tagToGetValue) {
+    var _a;
+    return (_a = parameterTagValue(tags, tagToGetValue)) === null || _a === void 0 ? void 0 : _a.split(',');
+}
+exports.parseCommaSeparatedParameterTagValue = parseCommaSeparatedParameterTagValue;
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/render",
-  "version": "0.0.58",
+  "version": "0.0.59-dev230718005248",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,7 +18,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@malloydata/malloy": "^0.0.58",
+    "@malloydata/malloy": "^0.0.59-dev230718005248",
     "@types/luxon": "^2.4.0",
     "lodash": "^4.17.20",
     "luxon": "^2.4.0",