@malloydata/render 0.0.135-dev240325191847 → 0.0.135-dev240326154530

package/dist/html/table.js

@@ -1,475 +0,0 @@
-"use strict";
-/*
- * Copyright 2023 Google LLC
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files
- * (the "Software"), to deal in the Software without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HTMLTableRenderer = void 0;
-const drill_1 = require("../drill");
-const container_1 = require("./container");
-const number_1 = require("./number");
-const utils_1 = require("./utils");
-const tags_utils_1 = require("../tags_utils");
-class PivotedField {
-    constructor(parentField, values, span) {
-        this.parentField = parentField;
-        this.values = values;
-        this.span = span;
-        this.key = JSON.stringify({
-            parentField: this.parentField.name,
-            values: this.values.map(v => (v.isScalar() ? v.key : '')),
-        });
-        this.fieldValueMap = new Map();
-        for (const value of this.values) {
-            this.fieldValueMap.set(value.field.name, value);
-        }
-    }
-}
-class PivotedColumnField {
-    constructor(pivotedField, field, userDefinedPivotDimensions) {
-        this.pivotedField = pivotedField;
-        this.field = field;
-        this.userDefinedPivotDimensions = userDefinedPivotDimensions;
-    }
-    isPivotedColumnField() {
-        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.isRecord;
-}
-class HTMLTableRenderer extends container_1.ContainerRenderer {
-    constructor() {
-        super(...arguments);
-        this.childrenStyleDefaults = {
-            size: 'medium',
-        };
-    }
-    async render(table) {
-        var _a, _b, _c;
-        if (table.isNull()) {
-            return this.document.createElement('span');
-        }
-        if (!table.isArray() && !table.isRecord()) {
-            throw new Error('Invalid type for Table Renderer');
-        }
-        const shouldTranspose = this.tagged.has('transpose');
-        if (shouldTranspose && table.field.intrinsicFields.length > 20) {
-            throw new Error('Transpose limit of 20 columns exceeded.');
-        }
-        let rowIndex = 0;
-        let columnIndex = 0;
-        let cells = [];
-        cells[rowIndex] = [];
-        const columnFields = [];
-        let pivotDepth = 0;
-        for (const field of table.field.intrinsicFields) {
-            if ((0, tags_utils_1.isFieldHidden)(field)) {
-                continue;
-            }
-            const childRenderer = this.childRenderers[field.name];
-            const shouldPivot = childRenderer instanceof HTMLTableRenderer &&
-                childRenderer.tagged.has('pivot');
-            if (shouldPivot) {
-                const userDefinedDimensions = childRenderer.tagged.textArray('pivot', 'dimensions');
-                let dimensions = undefined;
-                let nonDimensions = [];
-                const pivotedFields = new Map();
-                for (const row of table) {
-                    const dc = row.cell(field);
-                    if (dc.isNull()) {
-                        continue;
-                    }
-                    if (!dc.isArray() && !dc.isRecord()) {
-                        throw new Error(`Can not pivot field ${field.name}.`);
-                    }
-                    if (!dimensions) {
-                        const dimensionsResult = childRenderer.calculatePivotDimensions(dc, userDefinedDimensions);
-                        dimensions = dimensionsResult.dimensions;
-                        nonDimensions = dimensionsResult.nonDimensions;
-                    }
-                    for (const innerRow of dc) {
-                        const pivotedField = new PivotedField(field, dimensions.map(d => innerRow.cell(d.field)), nonDimensions.length);
-                        const pfKey = pivotedField.key;
-                        if (!pivotedFields.get(pfKey)) {
-                            pivotedFields.set(pfKey, pivotedField);
-                        }
-                    }
-                }
-                if (!dimensions) {
-                    throw new Error(`Could not pivot ${field.name}, no data found.`);
-                }
-                const sortedPivotedFields = Array.from(pivotedFields.values()).sort((a, b) => {
-                    for (const d of dimensions) {
-                        const aValue = a.fieldValueMap.get(d.field.name);
-                        const bValue = b.fieldValueMap.get(d.field.name);
-                        if ((aValue === null || aValue === void 0 ? void 0 : aValue.isScalar()) &&
-                            (bValue === null || bValue === void 0 ? void 0 : bValue.isScalar()) &&
-                            typeof aValue === typeof bValue) {
-                            if (aValue.isNull()) {
-                                if (bValue.isNull()) {
-                                    return 0;
-                                }
-                                else {
-                                    return 1;
-                                }
-                            }
-                            else if (bValue.isNull()) {
-                                return -1;
-                            }
-                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            const compValue = aValue.compareTo(bValue);
-                            if (compValue !== 0) {
-                                return d.dir !== 'desc' ? compValue : -compValue;
-                            }
-                        }
-                    }
-                    return 0;
-                });
-                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, {
-                            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);
-                columnIndex++;
-            }
-        }
-        if (pivotDepth > 0 && columnFields.length > 30) {
-            throw new Error('Pivot limit of 30 columns exceeded.');
-        }
-        if (!shouldTranspose && this.options.isDrillingEnabled) {
-            const drillHeader = this.document.createElement('th');
-            drillHeader.style.cssText = `
-        padding: 8px;
-        color: var(--malloy-title-color, #505050);
-        border-bottom: 1px solid var(--malloy-border-color, #eaeaea);
-        width: 25px;
-      `;
-            cells[rowIndex][columnIndex] = drillHeader;
-            columnIndex++;
-        }
-        rowIndex++;
-        const pivotHeaderCells = [];
-        for (let r = 0; r < pivotDepth; r++) {
-            const row = [];
-            let lastPivotedColumnHash = null;
-            for (const field of columnFields) {
-                if (field instanceof PivotedColumnField) {
-                    const pfKey = field.pivotedField.key;
-                    const valueIndex = field.pivotedField.values.length - pivotDepth + r;
-                    if (valueIndex < 0) {
-                        row.push(this.createEmptyHeaderCell());
-                    }
-                    else if (lastPivotedColumnHash !== pfKey) {
-                        const headerCell = this.document.createElement('th');
-                        if (!shouldTranspose) {
-                            headerCell.colSpan = field.pivotedField.span;
-                        }
-                        else {
-                            headerCell.rowSpan = field.pivotedField.span;
-                        }
-                        headerCell.style.cssText = `
-                padding: 8px;
-                color: var(--malloy-title-color, #505050);
-                border-bottom: 1px solid var(--malloy-border-color, #eaeaeb);
-                text-align: left;
-              `;
-                        const value = field.pivotedField.values[valueIndex];
-                        headerCell.appendChild(this.document.createTextNode(`${value.field.name}: `));
-                        headerCell.appendChild(await this.childRenderers[field.pivotedField.parentField.name].renderChild(value));
-                        lastPivotedColumnHash = pfKey;
-                        row.push(headerCell);
-                    }
-                    else {
-                        row.push(undefined);
-                    }
-                }
-                else {
-                    row.push(this.createEmptyHeaderCell());
-                }
-            }
-            pivotHeaderCells.push(row);
-            rowIndex++;
-        }
-        cells = [...pivotHeaderCells, ...cells];
-        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, field.userDefinedPivotDimensions);
-                        currentPivotedFieldKey = field.pivotedField.key;
-                    }
-                    const pfKey = field.pivotedField.key;
-                    if (pivotedCells.has(pfKey) &&
-                        ((_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);
-                    }
-                    else {
-                        cells[rowIndex][columnIndex] = childRenderer.generateNoValueCell(field.field, shouldTranspose);
-                    }
-                    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;
-                    }
-                    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: 2px;
-          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++;
-        }
-        const tableElement = this.document.createElement('table');
-        let tableSection = this.document.createElement('thead');
-        for (let row = 0; row < (shouldTranspose ? columnIndex : rowIndex); row++) {
-            if (row === 1 + pivotDepth) {
-                tableElement.appendChild(tableSection);
-                tableSection = this.document.createElement('tbody');
-            }
-            const currentRow = this.document.createElement('tr');
-            for (let column = 0; column < (shouldTranspose ? rowIndex : columnIndex); column++) {
-                const cell = shouldTranspose ? cells[column][row] : cells[row][column];
-                if (cell) {
-                    currentRow.appendChild(cell);
-                }
-            }
-            tableSection.appendChild(currentRow);
-        }
-        tableElement.appendChild(tableSection);
-        tableElement.style.cssText = `
-      border: 1px solid var(--malloy-border-color, #eaeaea);
-      vertical-align: top;
-      border-bottom: 1px solid var(--malloy-border-color, #eaeaea);
-      border-collapse: collapse;
-      width: 100%;
-    `;
-        return tableElement;
-    }
-    calculatePivotDimensions(table, userSpecifiedDimensions) {
-        if (!table.isArray() && !table.isRecord()) {
-            throw new Error(`Could not pivot ${table.field.name}`);
-        }
-        let dimensions = undefined;
-        if (userSpecifiedDimensions) {
-            dimensions = table.field.allFieldsWithOrder.filter(f => userSpecifiedDimensions.indexOf(f.field.name) >= 0);
-            if (dimensions.length !== userSpecifiedDimensions.length) {
-                for (const dim of userSpecifiedDimensions) {
-                    if (table.field.allFieldsWithOrder.filter(f => f.field.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 = [];
-        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.`);
-        }
-        return { dimensions, nonDimensions };
-    }
-    async generatePivotedCells(table, shouldTranspose, userSpecifiedDimensions) {
-        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, nonDimensions } = this.calculatePivotDimensions(table, userSpecifiedDimensions);
-        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 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.`);
-            }
-            result.set(pf.key, renderedCells);
-        }
-        return result;
-    }
-    generateNoValueCell(field, shouldTranspose) {
-        const cell = this.createCell(this.childRenderers[field.name], shouldTranspose);
-        cell.textContent = '-';
-        return cell;
-    }
-    async createCellAndRender(childRenderer, value, shouldTranspose) {
-        const cell = this.createCell(childRenderer, shouldTranspose);
-        cell.appendChild(await childRenderer.render(value));
-        return cell;
-    }
-    createEmptyHeaderCell() {
-        const headerCell = this.document.createElement('th');
-        headerCell.style.cssText = `
-      padding: 8px;
-      color: var(--malloy-title-color, #505050);
-      border-bottom: 1px solid var(--malloy-border-color, #eaeaea);
-    `;
-        return headerCell;
-    }
-    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;
-      color: var(--malloy-title-color, #505050);
-      border-bottom: 1px solid var(--malloy-border-color, #eaeaea);
-      text-align: ${isNumeric || shouldTranspose ? 'right' : 'left'};
-    `;
-        name = name.replace(/_/g, '_&#8203;');
-        headerCell.innerHTML = name;
-        return headerCell;
-    }
-    createCell(childRenderer, shouldTranspose) {
-        const isNumeric = childRenderer instanceof number_1.HTMLNumberRenderer;
-        (0, utils_1.yieldTask)();
-        const cellElement = this.document.createElement('td');
-        cellElement.style.cssText = `
-      padding: ${childRenderer instanceof HTMLTableRenderer ? '0' : '8px'};
-      vertical-align: top;
-      border-bottom: 1px solid var(--malloy-border-color, #eaeaea);
-      ${isNumeric || shouldTranspose ? 'text-align: right;' : ''}
-    `;
-        return cellElement;
-    }
-    async renderChild(value) {
-        return this.childRenderers[value.field.name].render(value);
-    }
-}
-exports.HTMLTableRenderer = HTMLTableRenderer;
-//# sourceMappingURL=table.js.map

package/dist/html/text.js

@@ -1,65 +0,0 @@
-"use strict";
-/*
- * Copyright 2023 Google LLC
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files
- * (the "Software"), to deal in the Software without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TextRendererFactory = exports.HTMLTextRenderer = void 0;
-const utils_1 = require("./utils");
-const renderer_factory_1 = require("../renderer_factory");
-class HTMLTextRenderer {
-    constructor(document) {
-        this.document = document;
-    }
-    getText(data) {
-        return data.value === null ? null : `${data.value}`;
-    }
-    async render(data) {
-        let text = null;
-        try {
-            text = this.getText(data);
-        }
-        catch (e) {
-            return (0, utils_1.createErrorElement)(this.document, e);
-        }
-        if (text === null) {
-            return (0, utils_1.createNullElement)(this.document);
-        }
-        const element = this.document.createElement('span');
-        element.appendChild(this.document.createTextNode(text));
-        return element;
-    }
-}
-exports.HTMLTextRenderer = HTMLTextRenderer;
-class TextRendererFactory extends renderer_factory_1.RendererFactory {
-    activates(field) {
-        return field.hasParentExplore() && !field.isExploreField();
-    }
-    create(document, _styleDefaults, _rendererOptions, _field, _options) {
-        return new HTMLTextRenderer(document);
-    }
-    get rendererName() {
-        return undefined;
-    }
-}
-exports.TextRendererFactory = TextRendererFactory;
-TextRendererFactory.instance = new TextRendererFactory();
-//# sourceMappingURL=text.js.map

package/dist/html/unsupported.js

@@ -1,72 +0,0 @@
-"use strict";
-/*
- * Copyright 2023 Google LLC
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files
- * (the "Software"), to deal in the Software without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnsupportedRendererFactory = exports.HTMLUnsupportedRenderer = void 0;
-const utils_1 = require("./utils");
-const renderer_factory_1 = require("../renderer_factory");
-class HTMLUnsupportedRenderer {
-    constructor(document) {
-        this.document = document;
-    }
-    getText(data) {
-        const value = data.value;
-        if (typeof value === 'string') {
-            return value;
-        }
-        else if (value === null) {
-            return null;
-        }
-        else if (typeof data.value === 'object') {
-            const record = data.value;
-            if ('value' in record && typeof record['value'] === 'string') {
-                return record['value'];
-            }
-        }
-        return JSON.stringify(data.value);
-    }
-    async render(data) {
-        const text = this.getText(data);
-        if (text === null) {
-            return (0, utils_1.createNullElement)(this.document);
-        }
-        const element = this.document.createElement('span');
-        element.appendChild(this.document.createTextNode(text));
-        return element;
-    }
-}
-exports.HTMLUnsupportedRenderer = HTMLUnsupportedRenderer;
-class UnsupportedRendererFactory extends renderer_factory_1.RendererFactory {
-    activates(field) {
-        return (field.hasParentExplore() && field.isAtomicField() && field.isUnsupported());
-    }
-    create(document, _styleDefaults, _rendererOptions, _field, _options) {
-        return new HTMLUnsupportedRenderer(document);
-    }
-    get rendererName() {
-        return undefined;
-    }
-}
-exports.UnsupportedRendererFactory = UnsupportedRendererFactory;
-UnsupportedRendererFactory.instance = new UnsupportedRendererFactory();
-//# sourceMappingURL=unsupported.js.map