@malloydata/render 0.0.24-dev230224184907 → 0.0.24-dev230228224434

package/dist/data_styles.d.ts

@@ -1,58 +1,58 @@
-import * as lite from "vega-lite";
+import * as lite from 'vega-lite';
 export declare type DataStyles = {
     [fieldName: string]: RenderDef;
 };
-export declare type ChartSize = "small" | "medium" | "large";
+export declare type ChartSize = 'small' | 'medium' | 'large';
 export declare type RenderDef = ({
     renderer?: undefined;
 } & DataRenderOptions) | ({
-    renderer: "table";
+    renderer: 'table';
 } & TableRenderOptions) | ({
-    renderer: "dashboard";
+    renderer: 'dashboard';
 } & DashboardRenderOptions) | ({
-    renderer: "text";
+    renderer: 'text';
 } & TextRenderOptions) | ({
-    renderer: "currency";
+    renderer: 'currency';
 } & CurrencyRenderOptions) | ({
-    renderer: "image";
+    renderer: 'image';
 } & ImageRenderOptions) | ({
-    renderer: "time";
+    renderer: 'time';
 } & TimeRenderOptions) | ({
-    renderer: "json";
+    renderer: 'json';
 } & JSONRenderOptions) | ({
-    renderer: "single_value";
+    renderer: 'single_value';
 } & SingleValueRenderOptions) | ({
-    renderer: "list";
+    renderer: 'list';
 } & ListRenderOptions) | ({
-    renderer: "list_detail";
+    renderer: 'list_detail';
 } & ListDetailRenderOptions) | ({
-    renderer: "cartesian_chart";
+    renderer: 'cartesian_chart';
 } & CartesianChartRenderOptions) | ({
-    renderer: "bar_chart";
+    renderer: 'bar_chart';
 } & BarChartRenderOptions) | ({
-    renderer: "scatter_chart";
+    renderer: 'scatter_chart';
 } & ScatterChartRenderOptions) | ({
-    renderer: "line_chart";
+    renderer: 'line_chart';
 } & LineChartRenderOptions) | ({
-    renderer: "point_map";
+    renderer: 'point_map';
 } & PointMapRenderOptions) | ({
-    renderer: "segment_map";
+    renderer: 'segment_map';
 } & SegmentMapRenderOptions) | ({
-    renderer: "shape_map";
+    renderer: 'shape_map';
 } & ShapeMapRenderOptions) | ({
-    renderer: "number";
+    renderer: 'number';
 } & NumberRenderOptions) | ({
-    renderer: "percent";
+    renderer: 'percent';
 } & PercentRenderOptions) | ({
-    renderer: "boolean";
+    renderer: 'boolean';
 } & BooleanRenderOptions) | ({
-    renderer: "spark_line";
+    renderer: 'spark_line';
 } & SparkLineRenderOptions) | ({
-    renderer: "bytes";
+    renderer: 'bytes';
 } & BytesRenderOptions) | ({
-    renderer: "link";
+    renderer: 'link';
 } & LinkRenderOptions) | ({
-    renderer: "vega";
+    renderer: 'vega';
 } & VegaRenderOptions);
 export interface DataRenderOptions {
     data?: {
@@ -82,7 +82,7 @@ export interface BytesRenderOptions extends TextRenderOptions {
 }
 export interface CurrencyRenderOptions extends TextRenderOptions {
     currency?: {
-        unit?: "dollars" | "pounds";
+        unit?: 'dollars' | 'pounds';
     };
 }
 export interface TimeRenderOptions extends TextRenderOptions {

package/dist/drill.d.ts

@@ -1,4 +1,4 @@
-import { DataArrayOrRecord, Explore } from "@malloydata/malloy";
+import { DataArrayOrRecord, Explore } from '@malloydata/malloy';
 export declare function getDrillFilters(data: DataArrayOrRecord): {
     formattedFilters: string[];
     source: Explore | undefined;

package/dist/drill.js

@@ -32,34 +32,34 @@ function timestampToDateFilter(key, value, timeframe) {
     const adjustedTimeframe = timeframe === malloy_1.TimestampTimeframe.Minute
         ? malloy_1.TimestampTimeframe.Second
         : timeframe || malloy_1.TimestampTimeframe.Second;
-    const filterValue = "@" + (0, utils_1.timeToString)(value, adjustedTimeframe);
-    return { key, "value": filterValue };
+    const filterValue = '@' + (0, utils_1.timeToString)(value, adjustedTimeframe);
+    return { key, value: filterValue };
 }
 function getTableFilters(table) {
     const filters = [];
     for (const f of table.field.filters || []) {
-        if (f.expressionType === "scalar") {
-            filters.push({ "key": f.code, "value": undefined });
+        if (f.expressionType === 'scalar') {
+            filters.push({ key: f.code, value: undefined });
         }
     }
     return filters;
 }
 function getRowFilters(row) {
     const filters = [];
-    const dimensions = row.field.intrinsicFields.filter((field) => field.isAtomicField() && field.sourceWasDimension());
+    const dimensions = row.field.intrinsicFields.filter(field => field.isAtomicField() && field.sourceWasDimension());
     for (const dim of dimensions) {
         const cell = row.cell(dim);
         // if we have an expression, use it instead of the name of the field.
         const key = dim.isAtomicField() || dim.isQueryField() ? dim.expression : undefined;
         if (key && !cell.isArray()) {
             if (cell.isNull()) {
-                filters.push({ key, "value": "null" });
+                filters.push({ key, value: 'null' });
             }
             else if (cell.isString()) {
-                filters.push({ key, "value": filterQuote(cell.value) });
+                filters.push({ key, value: filterQuote(cell.value) });
             }
             else if (cell.isNumber() || cell.isBoolean()) {
-                filters.push({ key, "value": cell.value.toString() });
+                filters.push({ key, value: cell.value.toString() });
             }
             else if (cell.isTimestamp() || cell.isDate()) {
                 filters.push(timestampToDateFilter(key, cell.value, cell.field.timeframe));
@@ -97,17 +97,17 @@ function getDrillFilters(data) {
     // TODO HACK: some filters get duplicated by the language, and this
     //      is a workaround until that is fixed
     const dedupedFilters = formattedFilters.filter((filter, index) => formattedFilters.find((otherFilter, otherIndex) => otherFilter === filter && index < otherIndex) === undefined);
-    return { "formattedFilters": dedupedFilters, source };
+    return { formattedFilters: dedupedFilters, source };
 }
 exports.getDrillFilters = getDrillFilters;
 function getDrillQuery(data) {
     const { formattedFilters, source } = getDrillFilters(data);
     let ret = `query: ${(source === null || source === void 0 ? void 0 : source.name) || '"unable to compute source"'} `;
     if (formattedFilters.length) {
-        ret += `{ \n  where: \n    ${formattedFilters.join(",\n    ")}\n  \n}\n`;
+        ret += `{ \n  where: \n    ${formattedFilters.join(',\n    ')}\n  \n}\n`;
     }
-    const drillQuery = ret + "-> ";
-    return { drillQuery, "drillFilters": formattedFilters };
+    const drillQuery = ret + '-> ';
+    return { drillQuery, drillFilters: formattedFilters };
 }
 exports.getDrillQuery = getDrillQuery;
 //# sourceMappingURL=drill.js.map

package/dist/html/bar_chart.d.ts

@@ -1,7 +1,7 @@
-import { DataColumn, Field } from "@malloydata/malloy";
-import { HTMLCartesianChartRenderer } from "./cartesian_chart";
+import { DataColumn, Field } from '@malloydata/malloy';
+import { HTMLCartesianChartRenderer } from './cartesian_chart';
 export declare class HTMLBarChartRenderer extends HTMLCartesianChartRenderer {
-    getMark(): "bar";
-    getDataType(field: Field): "temporal" | "ordinal" | "quantitative" | "nominal";
+    getMark(): 'bar';
+    getDataType(field: Field): 'temporal' | 'ordinal' | 'quantitative' | 'nominal';
     getDataValue(data: DataColumn): Date | string | number | null;
 }

package/dist/html/bar_chart.js

@@ -26,18 +26,18 @@ exports.HTMLBarChartRenderer = void 0;
 const cartesian_chart_1 = require("./cartesian_chart");
 class HTMLBarChartRenderer extends cartesian_chart_1.HTMLCartesianChartRenderer {
     getMark() {
-        return "bar";
+        return 'bar';
     }
     getDataType(field) {
         if (field.isAtomicField()) {
             if (field.isDate() || field.isTimestamp() || field.isString()) {
-                return "nominal";
+                return 'nominal';
             }
             else if (field.isNumber()) {
-                return "quantitative";
+                return 'quantitative';
             }
         }
-        throw new Error("Invalid field type for bar chart.");
+        throw new Error('Invalid field type for bar chart.');
     }
     getDataValue(data) {
         if (data.isNull()) {
@@ -50,7 +50,7 @@ class HTMLBarChartRenderer extends cartesian_chart_1.HTMLCartesianChartRenderer
             return data.value;
         }
         else {
-            throw new Error("Invalid field type for bar chart.");
+            throw new Error('Invalid field type for bar chart.');
         }
     }
 }

package/dist/html/boolean.d.ts

@@ -1,5 +1,5 @@
-import { DataColumn } from "@malloydata/malloy";
-import { HTMLTextRenderer } from "./text";
+import { DataColumn } from '@malloydata/malloy';
+import { HTMLTextRenderer } from './text';
 export declare class HTMLBooleanRenderer extends HTMLTextRenderer {
     getText(data: DataColumn): string | null;
 }

package/dist/html/bytes.d.ts

@@ -1,5 +1,5 @@
-import { DataColumn } from "@malloydata/malloy";
-import { HTMLTextRenderer } from "./text";
+import { DataColumn } from '@malloydata/malloy';
+import { HTMLTextRenderer } from './text';
 export declare class HTMLBytesRenderer extends HTMLTextRenderer {
     getText(data: DataColumn): string | null;
 }

package/dist/html/bytes.js

@@ -29,7 +29,7 @@ class HTMLBytesRenderer extends text_1.HTMLTextRenderer {
         if (data.isNull()) {
             return null;
         }
-        return data.bytes.value.toString("base64");
+        return data.bytes.value.toString('base64');
     }
 }
 exports.HTMLBytesRenderer = HTMLBytesRenderer;

package/dist/html/cartesian_chart.d.ts

@@ -1,7 +1,7 @@
-import { DataArray } from "@malloydata/malloy";
-import * as lite from "vega-lite";
-import { HTMLChartRenderer } from "./chart";
+import { DataArray } from '@malloydata/malloy';
+import * as lite from 'vega-lite';
+import { HTMLChartRenderer } from './chart';
 export declare abstract class HTMLCartesianChartRenderer extends HTMLChartRenderer {
-    abstract getMark(): "bar" | "line" | "point";
+    abstract getMark(): 'bar' | 'line' | 'point';
     getVegaLiteSpec(data: DataArray): lite.TopLevelSpec;
 }

package/dist/html/cartesian_chart.js

@@ -42,55 +42,55 @@ class HTMLCartesianChartRenderer extends chart_1.HTMLChartRenderer {
         const mark = this.getMark();
         const colorDef = colorField !== undefined
             ? {
-                "field": colorField.name,
-                "type": colorType,
-                "axis": { "title": (0, utils_1.formatTitle)(this.options, colorField.name) },
-                "scale": (0, utils_1.getColorScale)(colorType, mark === "bar")
+                field: colorField.name,
+                type: colorType,
+                axis: { title: (0, utils_1.formatTitle)(this.options, colorField.name) },
+                scale: (0, utils_1.getColorScale)(colorType, mark === 'bar'),
             }
-            : { "value": "#4285F4" };
+            : { value: '#4285F4' };
         const sizeDef = sizeField
             ? {
-                "field": sizeField.name,
-                "type": sizeType,
-                "axis": { "title": (0, utils_1.formatTitle)(this.options, sizeField.name) }
+                field: sizeField.name,
+                type: sizeType,
+                axis: { title: (0, utils_1.formatTitle)(this.options, sizeField.name) },
             }
             : undefined;
         const shapeDef = shapeField
             ? {
-                "field": shapeField.name,
-                "type": shapeType,
-                "axis": { "title": (0, utils_1.formatTitle)(this.options, shapeField.name) }
+                field: shapeField.name,
+                type: shapeType,
+                axis: { title: (0, utils_1.formatTitle)(this.options, shapeField.name) },
             }
             : undefined;
-        const xSort = xType === "nominal" ? null : undefined;
-        const ySort = yType === "nominal" ? null : undefined;
+        const xSort = xType === 'nominal' ? null : undefined;
+        const ySort = yType === 'nominal' ? null : undefined;
         const xDef = {
-            "field": xField.name,
-            "type": xType,
-            "sort": xSort,
-            "axis": { "title": (0, utils_1.formatTitle)(this.options, xField.name) }
+            field: xField.name,
+            type: xType,
+            sort: xSort,
+            axis: { title: (0, utils_1.formatTitle)(this.options, xField.name) },
         };
         const yDef = {
-            "field": yField.name,
-            "type": yType,
-            "sort": ySort,
-            "axis": { "title": (0, utils_1.formatTitle)(this.options, yField.name) }
+            field: yField.name,
+            type: yType,
+            sort: ySort,
+            axis: { title: (0, utils_1.formatTitle)(this.options, yField.name) },
         };
         return {
             ...vega_spec_1.DEFAULT_SPEC,
             ...this.getSize(),
-            "data": {
-                "values": this.mapData(data)
+            data: {
+                values: this.mapData(data),
             },
             mark,
-            "encoding": {
-                "x": xDef,
-                "y": yDef,
-                "size": sizeDef,
-                "color": colorDef,
-                "shape": shapeDef
+            encoding: {
+                x: xDef,
+                y: yDef,
+                size: sizeDef,
+                color: colorDef,
+                shape: shapeDef,
             },
-            "background": "transparent"
+            background: 'transparent',
         };
     }
 }

package/dist/html/chart.d.ts

@@ -1,7 +1,7 @@
-import * as lite from "vega-lite";
-import { DataArray, DataColumn, Field } from "@malloydata/malloy";
-import { Renderer, RendererOptions } from "../renderer";
-import { ChartRenderOptions, StyleDefaults } from "../data_styles";
+import * as lite from 'vega-lite';
+import { DataArray, DataColumn, Field } from '@malloydata/malloy';
+import { Renderer, RendererOptions } from '../renderer';
+import { ChartRenderOptions, StyleDefaults } from '../data_styles';
 declare type MappedRow = {
     [p: string]: string | number | Date | undefined | null;
 };
@@ -10,7 +10,7 @@ export declare abstract class HTMLChartRenderer implements Renderer {
     protected styleDefaults: StyleDefaults;
     protected options: RendererOptions;
     size: string;
-    abstract getDataType(field: Field): "temporal" | "ordinal" | "quantitative" | "nominal";
+    abstract getDataType(field: Field): 'temporal' | 'ordinal' | 'quantitative' | 'nominal';
     abstract getDataValue(value: DataColumn): Date | string | number | null | undefined;
     mapData(data: DataArray): MappedRow[];
     getSize(): {

package/dist/html/chart.js

@@ -53,7 +53,7 @@ class HTMLChartRenderer {
         this.document = document;
         this.styleDefaults = styleDefaults;
         this.options = options;
-        this.size = chartOptions.size || this.styleDefaults.size || "medium";
+        this.size = chartOptions.size || this.styleDefaults.size || 'medium';
     }
     mapData(data) {
         const mappedRows = [];
@@ -67,20 +67,20 @@ class HTMLChartRenderer {
         return mappedRows;
     }
     getSize() {
-        if (this.size === "large") {
-            return { "height": 350, "width": 500 };
+        if (this.size === 'large') {
+            return { height: 350, width: 500 };
         }
         else {
-            return { "height": 175, "width": 250 };
+            return { height: 175, width: 250 };
         }
     }
     async render(table) {
         if (!table.isArray()) {
-            throw new Error("Invalid type for chart renderer");
+            throw new Error('Invalid type for chart renderer');
         }
         const spec = this.getVegaLiteSpec(table);
         const vegaspec = lite.compile(spec, {
-            "logger": {
+            logger: {
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-ignore
                 level(newLevel) {
@@ -100,14 +100,14 @@ class HTMLChartRenderer {
                 },
                 debug() {
                     return this;
-                }
-            }
+                },
+            },
         }).spec;
         const view = new vega.View(vega.parse(vegaspec), {
-            "renderer": "none"
+            renderer: 'none',
         });
         view.logger().level(-1);
-        const element = this.document.createElement("div");
+        const element = this.document.createElement('div');
         element.innerHTML = await view.toSVG();
         return element;
     }

package/dist/html/container.d.ts

@@ -1,6 +1,6 @@
-import { Explore } from "@malloydata/malloy";
-import { StyleDefaults } from "../data_styles";
-import { ChildRenderers, RendererOptions, RenderTree } from "../renderer";
+import { Explore } from '@malloydata/malloy';
+import { StyleDefaults } from '../data_styles';
+import { ChildRenderers, RendererOptions, RenderTree } from '../renderer';
 export declare abstract class ContainerRenderer extends RenderTree {
     childRenderers: ChildRenderers;
     protected abstract childrenStyleDefaults: StyleDefaults;

package/dist/html/currency.d.ts

@@ -1,5 +1,5 @@
-import { DataColumn } from "@malloydata/malloy";
-import { HTMLTextRenderer } from "./text";
+import { DataColumn } from '@malloydata/malloy';
+import { HTMLTextRenderer } from './text';
 export declare class HTMLCurrencyRenderer extends HTMLTextRenderer {
     getText(data: DataColumn): string | null;
 }

package/dist/html/currency.js

@@ -30,10 +30,10 @@ class HTMLCurrencyRenderer extends text_1.HTMLTextRenderer {
             return null;
         }
         // TODO get this from renderer options
-        const unitText = "$";
-        const numText = data.number.value.toLocaleString("en-US", {
-            "minimumFractionDigits": 2,
-            "maximumFractionDigits": 2
+        const unitText = '$';
+        const numText = data.number.value.toLocaleString('en-US', {
+            minimumFractionDigits: 2,
+            maximumFractionDigits: 2,
         });
         return `${unitText}${numText}`;
     }

package/dist/html/dashboard.d.ts

@@ -1,6 +1,6 @@
-import { DataArrayOrRecord } from "@malloydata/malloy";
-import { StyleDefaults } from "../data_styles";
-import { ContainerRenderer } from "./container";
+import { DataArrayOrRecord } from '@malloydata/malloy';
+import { StyleDefaults } from '../data_styles';
+import { ContainerRenderer } from './container';
 export declare class HTMLDashboardRenderer extends ContainerRenderer {
     protected childrenStyleDefaults: StyleDefaults;
     render(table: DataArrayOrRecord): Promise<HTMLElement>;

package/dist/html/dashboard.js

@@ -31,33 +31,33 @@ class HTMLDashboardRenderer extends container_1.ContainerRenderer {
     constructor() {
         super(...arguments);
         this.childrenStyleDefaults = {
-            "size": "medium"
+            size: 'medium',
         };
     }
     async render(table) {
         if (!table.isArrayOrRecord()) {
-            return (0, utils_1.createErrorElement)(this.document, "Invalid data for dashboard renderer.");
+            return (0, utils_1.createErrorElement)(this.document, 'Invalid data for dashboard renderer.');
         }
         const fields = table.field.intrinsicFields;
-        const dimensions = fields.filter((field) => field.isAtomicField() && field.sourceWasDimension());
-        const measures = fields.filter((field) => !field.isAtomicField() || field.sourceWasMeasureLike());
-        const body = this.document.createElement("div");
+        const dimensions = fields.filter(field => field.isAtomicField() && field.sourceWasDimension());
+        const measures = fields.filter(field => !field.isAtomicField() || field.sourceWasMeasureLike());
+        const body = this.document.createElement('div');
         for (const row of table) {
-            const dimensionsContainer = this.document.createElement("div");
-            dimensionsContainer.classList.add("dimensions");
-            dimensionsContainer.style.display = "flex";
-            dimensionsContainer.style.flexWrap = "wrap";
-            const rowElement = this.document.createElement("div");
-            rowElement.style.position = "relative";
+            const dimensionsContainer = this.document.createElement('div');
+            dimensionsContainer.classList.add('dimensions');
+            dimensionsContainer.style.display = 'flex';
+            dimensionsContainer.style.flexWrap = 'wrap';
+            const rowElement = this.document.createElement('div');
+            rowElement.style.position = 'relative';
             for (const field of dimensions) {
                 const renderer = this.childRenderers[field.name];
                 const rendered = await renderer.render(row.cell(field));
-                const renderedDimension = this.document.createElement("div");
+                const renderedDimension = this.document.createElement('div');
                 renderedDimension.style.cssText = DIMENSION_BOX;
-                const dimensionTitle = this.document.createElement("div");
+                const dimensionTitle = this.document.createElement('div');
                 dimensionTitle.style.cssText = DIMENSION_TITLE;
                 dimensionTitle.appendChild(this.document.createTextNode((0, utils_1.formatTitle)(this.options, field.name, this.options.dataStyles[field.name])));
-                const dimensionInner = this.document.createElement("div");
+                const dimensionInner = this.document.createElement('div');
                 dimensionInner.style.cssText = VERTICAL_CENTER;
                 dimensionInner.appendChild(rendered);
                 renderedDimension.appendChild(dimensionTitle);
@@ -65,15 +65,15 @@ class HTMLDashboardRenderer extends container_1.ContainerRenderer {
                 dimensionsContainer.appendChild(renderedDimension);
             }
             if (dimensions.length > 0) {
-                const rowSeparatorOuter = this.document.createElement("div");
-                rowSeparatorOuter.classList.add("row-separator-outer");
+                const rowSeparatorOuter = this.document.createElement('div');
+                rowSeparatorOuter.classList.add('row-separator-outer');
                 rowSeparatorOuter.style.cssText = ROW_SEPARATOR_OUTER;
-                const rowSeparator = this.document.createElement("div");
+                const rowSeparator = this.document.createElement('div');
                 rowSeparator.style.cssText = ROW_SEPARATOR;
                 rowSeparatorOuter.appendChild(rowSeparator);
                 dimensionsContainer.appendChild(rowSeparatorOuter);
             }
-            const measuresContainer = this.document.createElement("div");
+            const measuresContainer = this.document.createElement('div');
             measuresContainer.style.cssText = MEASURE_BOXES;
             for (const field of measures) {
                 const childRenderer = this.childRenderers[field.name];
@@ -83,14 +83,14 @@ class HTMLDashboardRenderer extends container_1.ContainerRenderer {
                     measuresContainer.appendChild(rendered);
                 }
                 else if (childRenderer instanceof text_1.HTMLTextRenderer) {
-                    const measureBox = this.document.createElement("div");
+                    const measureBox = this.document.createElement('div');
                     measureBox.style.cssText = MEASURE_BOX;
-                    const measureTitle = this.document.createElement("div");
+                    const measureTitle = this.document.createElement('div');
                     measureTitle.style.cssText = TITLE;
                     measureTitle.appendChild(this.document.createTextNode((0, utils_1.formatTitle)(this.options, field.name, this.options.dataStyles[field.name])));
-                    const measureInner = this.document.createElement("div");
+                    const measureInner = this.document.createElement('div');
                     measureInner.style.cssText = VERTICAL_CENTER;
-                    const innerInner = this.document.createElement("div");
+                    const innerInner = this.document.createElement('div');
                     innerInner.style.cssText = SINGLE_VALUE;
                     innerInner.appendChild(rendered);
                     measureInner.appendChild(innerInner);
@@ -99,14 +99,14 @@ class HTMLDashboardRenderer extends container_1.ContainerRenderer {
                     measuresContainer.appendChild(measureBox);
                 }
                 else {
-                    const measureBox = this.document.createElement("div");
+                    const measureBox = this.document.createElement('div');
                     measureBox.style.cssText = MEASURE_BOX;
-                    const measureTitle = this.document.createElement("div");
+                    const measureTitle = this.document.createElement('div');
                     measureTitle.style.cssText = TITLE;
                     measureTitle.appendChild(this.document.createTextNode((0, utils_1.formatTitle)(this.options, field.name, this.options.dataStyles[field.name])));
-                    const measureInner = this.document.createElement("div");
+                    const measureInner = this.document.createElement('div');
                     measureInner.style.cssText = VERTICAL_CENTER;
-                    const innerInner = this.document.createElement("div");
+                    const innerInner = this.document.createElement('div');
                     innerInner.style.cssText = HORIZONTAL_CENTER;
                     innerInner.appendChild(rendered);
                     measureInner.appendChild(innerInner);
@@ -117,10 +117,11 @@ class HTMLDashboardRenderer extends container_1.ContainerRenderer {
             }
             rowElement.appendChild(dimensionsContainer);
             if (dimensions.length > 0 && this.options.isDrillingEnabled) {
-                const drillElement = this.document.createElement("span");
+                const drillElement = this.document.createElement('span');
                 const drillIcon = (0, utils_1.createDrillIcon)(this.document);
                 drillElement.appendChild(drillIcon);
-                drillElement.style.cssText = `padding: 8px; vertical-align: top; width: 25px; cursor: pointer; position: absolute; top: 5px; right: 5px;`;
+                drillElement.style.cssText =
+                    'padding: 8px; vertical-align: top; width: 25px; cursor: pointer; position: absolute; top: 5px; right: 5px;';
                 drillElement.onclick = () => {
                     if (this.options.onDrill) {
                         const { drillQuery, drillFilters } = (0, drill_1.getDrillQuery)(row);
@@ -129,11 +130,11 @@ class HTMLDashboardRenderer extends container_1.ContainerRenderer {
                 };
                 rowElement.appendChild(drillElement);
             }
-            const dashboardOuter = this.document.createElement("div");
-            dashboardOuter.classList.add("dashboard-outer");
+            const dashboardOuter = this.document.createElement('div');
+            dashboardOuter.classList.add('dashboard-outer');
             dashboardOuter.style.cssText = DASHBOARD_OUTER;
             if (dimensions.length > 0) {
-                const nestIndicator = this.document.createElement("div");
+                const nestIndicator = this.document.createElement('div');
                 nestIndicator.style.cssText = NEST_INDICATOR;
                 dashboardOuter.appendChild(nestIndicator);
             }

package/dist/html/date.d.ts

@@ -1,5 +1,5 @@
-import { DataColumn } from "@malloydata/malloy";
-import { Renderer } from "../renderer";
+import { DataColumn } from '@malloydata/malloy';
+import { Renderer } from '../renderer';
 export declare class HTMLDateRenderer implements Renderer {
     private readonly document;
     constructor(document: Document);

package/dist/html/date.js

@@ -34,12 +34,12 @@ class HTMLDateRenderer {
             return (0, utils_1.createNullElement)(this.document);
         }
         if (!data.isDate() && !data.isTimestamp()) {
-            return (0, utils_1.createErrorElement)(this.document, "Invalid field for date renderer");
+            return (0, utils_1.createErrorElement)(this.document, 'Invalid field for date renderer');
         }
         const timeframe = data.field.timeframe ||
             (data.isTimestamp() ? malloy_1.TimestampTimeframe.Second : malloy_1.DateTimeframe.Day);
         const timestring = (0, utils_1.timeToString)(data.value, timeframe);
-        const element = this.document.createElement("span");
+        const element = this.document.createElement('span');
         element.appendChild(this.document.createTextNode(timestring));
         return element;
     }