@malloydata/render 0.0.99-dev231102173733 → 0.0.99-dev231102201226

package/dist/html/table.d.ts

@@ -1,19 +1,35 @@
-import { DataColumn, Field, SortableField } from '@malloydata/malloy';
+import { DataColumn, DataRecord, Field, SortableField } from '@malloydata/malloy';
 import { StyleDefaults } from '../data_styles';
 import { ContainerRenderer } from './container';
-import { Renderer } from '../renderer';
+import { ChildRenderers, Renderer } from '../renderer';
+declare class FlattenedColumnField {
+    readonly flattenedField: Field;
+    readonly field: Field;
+    readonly name: string;
+    constructor(flattenedField: Field, field: Field, name: string);
+    isFlattenedColumnField(): this is FlattenedColumnField;
+    getChildRenderer(childRenderers: ChildRenderers): Renderer;
+    getValue(row: DataRecord): DataColumn;
+}
+type NonDimension = SortableField & {
+    flattenedField?: FlattenedColumnField;
+};
 export declare class HTMLTableRenderer extends ContainerRenderer {
     protected childrenStyleDefaults: StyleDefaults;
     render(table: DataColumn): Promise<HTMLElement>;
     calculatePivotDimensions(table: DataColumn, userSpecifiedDimensions?: Array<string>): {
         dimensions: SortableField[];
-        nonDimensions: SortableField[];
+        nonDimensions: NonDimension[];
     };
     generatePivotedCells(table: DataColumn, shouldTranspose: boolean, userSpecifiedDimensions?: Array<string>): Promise<Map<string, Map<string, HTMLTableCellElement>>>;
     generateNoValueCell(field: Field, shouldTranspose: boolean): HTMLTableCellElement;
     createCellAndRender(childRenderer: Renderer, value: DataColumn, shouldTranspose: boolean): Promise<HTMLTableCellElement>;
     createEmptyHeaderCell(): HTMLTableCellElement;
-    createHeaderCell(field: Field, shouldTranspose: boolean): HTMLTableCellElement;
+    createHeaderCell(field: Field, shouldTranspose: boolean, override?: {
+        name?: string;
+        childRenderer?: Renderer;
+    }): HTMLTableCellElement;
     createCell(childRenderer: Renderer, shouldTranspose: boolean): HTMLTableCellElement;
     renderChild(value: DataColumn): Promise<HTMLElement>;
 }
+export {};

package/dist/html/table.js

@@ -53,6 +53,38 @@ class PivotedColumnField {
         return this instanceof PivotedColumnField;
     }
 }
+class FlattenedColumnField {
+    constructor(flattenedField, field, name) {
+        this.flattenedField = flattenedField;
+        this.field = field;
+        this.name = name;
+    }
+    isFlattenedColumnField() {
+        return this instanceof FlattenedColumnField;
+    }
+    getChildRenderer(childRenderers) {
+        const baseRenderer = childRenderers[this.flattenedField.name];
+        if (baseRenderer instanceof HTMLTableRenderer) {
+            return baseRenderer.childRenderers[this.field.name];
+        }
+        else {
+            throw Error('Could not render flattened table. `# flatten` only supports nests.');
+        }
+    }
+    getValue(row) {
+        const parentRecord = row.cell(this.flattenedField);
+        if (parentRecord.isRecord())
+            return parentRecord.cell(this.field);
+        else
+            throw Error('Cannot find nested record within flattened field. `# flatten` only supports nests with no group_bys.');
+    }
+}
+function shouldFlattenField(field) {
+    const { tag } = field.tagParse();
+    return (field.isExploreField() &&
+        tag.has('flatten') &&
+        field.structDef.structSource.type === 'inline');
+}
 class HTMLTableRenderer extends container_1.ContainerRenderer {
     constructor() {
         super(...arguments);
@@ -61,7 +93,7 @@ class HTMLTableRenderer extends container_1.ContainerRenderer {
         };
     }
     async render(table) {
-        var _a;
+        var _a, _b, _c;
         if (table.isNull()) {
             return this.document.createElement('span');
         }
@@ -144,12 +176,27 @@ class HTMLTableRenderer extends container_1.ContainerRenderer {
                 for (const pf of sortedPivotedFields) {
                     for (const nonDimension of nonDimensions) {
                         columnFields.push(new PivotedColumnField(pf, nonDimension.field, userDefinedDimensions));
-                        cells[rowIndex][columnIndex] = childRenderer.createHeaderCell(nonDimension.field, shouldTranspose);
+                        cells[rowIndex][columnIndex] = childRenderer.createHeaderCell(nonDimension.field, shouldTranspose, {
+                            name: (_a = nonDimension.flattenedField) === null || _a === void 0 ? void 0 : _a.name,
+                            childRenderer: (_b = nonDimension.flattenedField) === null || _b === void 0 ? void 0 : _b.getChildRenderer(childRenderer.childRenderers),
+                        });
                         columnIndex++;
                     }
                 }
                 pivotDepth = Math.max(pivotDepth, dimensions.length);
             }
+            else if (shouldFlattenField(field)) {
+                const parentField = field;
+                const flattenedFields = parentField.allFields.map(f => new FlattenedColumnField(parentField, f, `${parentField.name} ${f.name}`));
+                for (const flatField of flattenedFields) {
+                    cells[rowIndex][columnIndex] = this.createHeaderCell(flatField.field, shouldTranspose, {
+                        name: flatField.name,
+                        childRenderer: flatField.getChildRenderer(this.childRenderers),
+                    });
+                    columnFields.push(flatField);
+                    columnIndex++;
+                }
+            }
             else {
                 cells[rowIndex][columnIndex] = this.createHeaderCell(field, shouldTranspose);
                 columnFields.push(field);
@@ -230,7 +277,7 @@ class HTMLTableRenderer extends container_1.ContainerRenderer {
                     }
                     const pfKey = field.pivotedField.key;
                     if (pivotedCells.has(pfKey) &&
-                        ((_a = pivotedCells.get(pfKey)) === null || _a === void 0 ? void 0 : _a.has(field.field.name))) {
+                        ((_c = pivotedCells.get(pfKey)) === null || _c === void 0 ? void 0 : _c.has(field.field.name))) {
                         cells[rowIndex][columnIndex] = pivotedCells
                             .get(pfKey)
                             .get(field.field.name);
@@ -241,6 +288,10 @@ class HTMLTableRenderer extends container_1.ContainerRenderer {
                     columnIndex++;
                     // back
                 }
+                else if (field instanceof FlattenedColumnField) {
+                    cells[rowIndex][columnIndex] = await this.createCellAndRender(field.getChildRenderer(this.childRenderers), field.getValue(row), shouldTranspose);
+                    columnIndex++;
+                }
                 else {
                     if ((0, tags_utils_1.isFieldHidden)(field)) {
                         continue;
@@ -318,7 +369,22 @@ class HTMLTableRenderer extends container_1.ContainerRenderer {
         else {
             dimensions = table.field.dimensions;
         }
-        const nonDimensions = table.field.allFieldsWithOrder.filter(f => dimensions.indexOf(f) < 0);
+        const nonDimensions = [];
+        for (const f of table.field.allFieldsWithOrder) {
+            if (dimensions.indexOf(f) >= 0)
+                continue;
+            if (shouldFlattenField(f.field)) {
+                const nestedFields = f.field.allFieldsWithOrder.map(nf => ({
+                    dir: nf.dir,
+                    field: nf.field,
+                    flattenedField: new FlattenedColumnField(f.field, nf.field, `${f.field.name} ${nf.field.name}`),
+                }));
+                nonDimensions.push(...nestedFields);
+            }
+            else {
+                nonDimensions.push(f);
+            }
+        }
         if (nonDimensions.length === 0) {
             throw new Error(`Can not pivot ${table.field.name} since all of its fields are dimensions.`);
         }
@@ -336,9 +402,18 @@ class HTMLTableRenderer extends container_1.ContainerRenderer {
         for (const row of table) {
             const pf = new PivotedField(table.field, dimensions.map(f => row.cell(f.field.name)), nonDimensions.length);
             const renderedCells = new Map();
-            for (const nonDimension of table.field.allFieldsWithOrder.filter(f => dimensions.indexOf(f) < 0)) {
-                const childRenderer = this.childRenderers[nonDimension.field.name];
-                renderedCells.set(nonDimension.field.name, await this.createCellAndRender(childRenderer, row.cell(nonDimension.field.name), shouldTranspose));
+            for (const nonDimension of nonDimensions) {
+                let childRenderer;
+                let value;
+                if (nonDimension.flattenedField) {
+                    childRenderer = nonDimension.flattenedField.getChildRenderer(this.childRenderers);
+                    value = nonDimension.flattenedField.getValue(row);
+                }
+                else {
+                    childRenderer = this.childRenderers[nonDimension.field.name];
+                    value = row.cell(nonDimension.field.name);
+                }
+                renderedCells.set(nonDimension.field.name, await this.createCellAndRender(childRenderer, value, shouldTranspose));
             }
             if (result.has(pf.key)) {
                 throw new Error(`Can not pivot ${table.field.name} dimensions lead to non unique pivots.`);
@@ -366,9 +441,11 @@ class HTMLTableRenderer extends container_1.ContainerRenderer {
     `;
         return headerCell;
     }
-    createHeaderCell(field, shouldTranspose) {
-        let name = (0, utils_1.formatTitle)(this.options, field, this.options.dataStyles[field.name], field.parentExplore.queryTimezone);
-        const isNumeric = this.childRenderers[field.name] instanceof number_1.HTMLNumberRenderer;
+    createHeaderCell(field, shouldTranspose, override = {}) {
+        var _a, _b;
+        let name = (_a = override.name) !== null && _a !== void 0 ? _a : (0, utils_1.formatTitle)(this.options, field, this.options.dataStyles[field.name], field.parentExplore.queryTimezone);
+        const childRenderer = (_b = override.childRenderer) !== null && _b !== void 0 ? _b : this.childRenderers[field.name];
+        const isNumeric = childRenderer instanceof number_1.HTMLNumberRenderer;
         const headerCell = this.document.createElement('th');
         headerCell.style.cssText = `
       padding: 8px;

package/dist/stories/basic.stories.d.ts

@@ -23,3 +23,9 @@ export declare const ProductsBar: {
         view: string;
     };
 };
+export declare const FlattenNestedMeasures: {
+    args: {
+        source: string;
+        view: string;
+    };
+};

package/dist/stories/basic.stories.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProductsBar = exports.ProductsTable = void 0;
+exports.FlattenNestedMeasures = exports.ProductsBar = exports.ProductsTable = void 0;
 const basic_malloy_raw_1 = __importDefault(require("./static/basic.malloy?raw"));
 const render_malloy_1 = require("./render-malloy");
 exports.default = {
@@ -25,4 +25,10 @@ exports.ProductsBar = {
         view: 'category_bar',
     },
 };
+exports.FlattenNestedMeasures = {
+    args: {
+        source: 'products',
+        view: 'flatten',
+    },
+};
 //# sourceMappingURL=basic.stories.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/render",
-  "version": "0.0.99-dev231102173733",
+  "version": "0.0.99-dev231102201226",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,7 +23,7 @@
     "build-storybook": "storybook build"
   },
   "dependencies": {
-    "@malloydata/malloy": "^0.0.99-dev231102173733",
+    "@malloydata/malloy": "^0.0.99-dev231102201226",
     "@types/luxon": "^2.4.0",
     "lodash": "^4.17.20",
     "luxon": "^2.4.0",