@malloydata/malloy 0.0.24-dev230224184907 → 0.0.24-dev230228224434

package/dist/lang/ast/expressions/granular-literal.js

@@ -39,70 +39,70 @@ class GranularLiteral extends expression_def_1.ExpressionDef {
         this.moment = moment;
         this.until = until;
         this.units = units;
-        this.elementType = "timeLiteral";
+        this.elementType = 'timeLiteral';
     }
     granular() {
         return true;
     }
     static parse(possibleLiteral) {
         const s = possibleLiteral.slice(1);
-        const fYear = "yyyy";
+        const fYear = 'yyyy';
         const fMonth = `${fYear}-LL`;
         const fDay = `${fMonth}-dd`;
         const fMinute = `${fDay} HH:mm`;
         const fSecond = `${fMinute}:ss`;
         const tss = luxon_1.DateTime.fromFormat(s, fSecond);
         if (tss.isValid) {
-            const nextSecond = tss.plus({ "second": 1 }).toFormat(fSecond);
-            const tsLit = new GranularLiteral(s, nextSecond, "second");
-            tsLit.timeType = "timestamp";
+            const nextSecond = tss.plus({ second: 1 }).toFormat(fSecond);
+            const tsLit = new GranularLiteral(s, nextSecond, 'second');
+            tsLit.timeType = 'timestamp';
             return tsLit;
         }
         const tsm = luxon_1.DateTime.fromFormat(s, fMinute);
         if (tsm.isValid) {
             // working around a weird bigquery bug ...
-            const thisMin = s + ":00";
-            const nextMinute = tsm.plus({ "minute": 1 }).toFormat(fMinute) + ":00";
-            const tsLit = new GranularLiteral(thisMin, nextMinute, "minute");
-            tsLit.timeType = "timestamp";
+            const thisMin = s + ':00';
+            const nextMinute = tsm.plus({ minute: 1 }).toFormat(fMinute) + ':00';
+            const tsLit = new GranularLiteral(thisMin, nextMinute, 'minute');
+            tsLit.timeType = 'timestamp';
             return tsLit;
         }
         const quarter = s.match(/(\d{4})-[qQ](\d)$/);
         if (quarter) {
             const qplus = Number.parseInt(quarter[2]) - 1;
-            let qstart = luxon_1.DateTime.fromFormat(quarter[1], "yyyy");
+            let qstart = luxon_1.DateTime.fromFormat(quarter[1], 'yyyy');
             if (qplus > 0) {
-                qstart = qstart.plus({ "quarters": qplus });
+                qstart = qstart.plus({ quarters: qplus });
             }
-            const qend = qstart.plus({ "quarter": 1 });
-            return new GranularLiteral(`${qstart.toFormat(fDay)}`, `${qend.toFormat(fDay)}`, "quarter");
+            const qend = qstart.plus({ quarter: 1 });
+            return new GranularLiteral(`${qstart.toFormat(fDay)}`, `${qend.toFormat(fDay)}`, 'quarter');
         }
         const yyyymmdd = luxon_1.DateTime.fromFormat(s, fDay);
         if (yyyymmdd.isValid) {
-            const next = yyyymmdd.plus({ "days": 1 });
-            return new GranularLiteral(`${yyyymmdd.toFormat(fDay)}`, `${next.toFormat(fDay)}`, "day");
+            const next = yyyymmdd.plus({ days: 1 });
+            return new GranularLiteral(`${yyyymmdd.toFormat(fDay)}`, `${next.toFormat(fDay)}`, 'day');
         }
         const yyyymm = luxon_1.DateTime.fromFormat(s, fMonth);
         if (yyyymm.isValid) {
-            const next = yyyymm.plus({ "months": 1 });
-            return new GranularLiteral(`${yyyymm.toFormat(fDay)}`, `${next.toFormat(fDay)}`, "month");
+            const next = yyyymm.plus({ months: 1 });
+            return new GranularLiteral(`${yyyymm.toFormat(fDay)}`, `${next.toFormat(fDay)}`, 'month');
         }
         const yyyy = luxon_1.DateTime.fromFormat(s, fYear);
         if (yyyy.isValid) {
-            const year = yyyy.toFormat(`yyyy-01-01`);
-            const nextYear = yyyy.plus({ "year": 1 }).toFormat(`yyyy-01-01`);
-            return new GranularLiteral(year, nextYear, "year");
+            const year = yyyy.toFormat('yyyy-01-01');
+            const nextYear = yyyy.plus({ year: 1 }).toFormat('yyyy-01-01');
+            return new GranularLiteral(year, nextYear, 'year');
         }
-        if (s.startsWith("WK")) {
+        if (s.startsWith('WK')) {
             const yyyymmdd = luxon_1.DateTime.fromFormat(s.slice(2), fDay);
             if (yyyymmdd.isValid) {
                 // wonky because luxon uses monday weeks and bigquery uses sunday weeks
                 let sunday = yyyymmdd;
                 if (yyyymmdd.weekday !== 7) {
-                    sunday = yyyymmdd.startOf("week").minus({ "day": 1 });
+                    sunday = yyyymmdd.startOf('week').minus({ day: 1 });
                 }
-                const next = sunday.plus({ "days": 7 });
-                return new GranularLiteral(`${sunday.toFormat(fDay)}`, `${next.toFormat(fDay)}`, "week");
+                const next = sunday.plus({ days: 7 });
+                return new GranularLiteral(`${sunday.toFormat(fDay)}`, `${next.toFormat(fDay)}`, 'week');
             }
         }
         return undefined;
@@ -110,21 +110,21 @@ class GranularLiteral extends expression_def_1.ExpressionDef {
     apply(fs, op, left) {
         const lhs = left.getExpression(fs);
         if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType)) {
-            let rangeType = "timestamp";
-            if (lhs.dataType === "date" && !this.timeType) {
-                rangeType = "date";
+            let rangeType = 'timestamp';
+            if (lhs.dataType === 'date' && !this.timeType) {
+                rangeType = 'date';
             }
-            const range = new range_1.Range(new expr_time_1.ExprTime(rangeType, (0, time_utils_1.timeLiteral)(this.moment, rangeType, "UTC")), new expr_time_1.ExprTime(rangeType, (0, time_utils_1.timeLiteral)(this.until, rangeType, "UTC")));
+            const range = new range_1.Range(new expr_time_1.ExprTime(rangeType, (0, time_utils_1.timeLiteral)(this.moment, rangeType, 'UTC')), new expr_time_1.ExprTime(rangeType, (0, time_utils_1.timeLiteral)(this.until, rangeType, 'UTC')));
             return range.apply(fs, op, left);
         }
         return super.apply(fs, op, left);
     }
     getExpression(_fs) {
-        const dataType = this.timeType || "date";
+        const dataType = this.timeType || 'date';
         const value = {
             dataType,
-            "expressionType": "scalar",
-            "value": (0, time_utils_1.timeLiteral)(this.moment, dataType, "UTC")
+            expressionType: 'scalar',
+            value: (0, time_utils_1.timeLiteral)(this.moment, dataType, 'UTC'),
         };
         // Literals with date resolution can be used as timestamps or dates,
         // this is the third attempt to make that work. It still feels like
@@ -132,13 +132,13 @@ class GranularLiteral extends expression_def_1.ExpressionDef {
         // at which the data is needed, the handle is gone to the ExpressionDef
         // which would allow a method call into this class. I think the second
         // if clause is redundant (see "parse" above, but I'm paranoid)
-        if (dataType == "date" && (0, malloy_types_1.isDateUnit)(this.units)) {
+        if (dataType === 'date' && (0, malloy_types_1.isDateUnit)(this.units)) {
             value.alsoTimestamp = true;
         }
-        if (this.units != "second") {
+        if (this.units !== 'second') {
             return {
                 ...value,
-                "timeframe": this.units
+                timeframe: this.units,
             };
         }
         return value;

package/dist/lang/ast/expressions/partial-compare.d.ts

@@ -1,7 +1,7 @@
-import { Comparison } from "../types/comparison";
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
-import { FieldSpace } from "../types/field-space";
+import { Comparison } from '../types/comparison';
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
 export declare class PartialCompare extends ExpressionDef {
     readonly op: Comparison;
     readonly right: ExpressionDef;

package/dist/lang/ast/expressions/partial-compare.js

@@ -27,10 +27,10 @@ const ast_utils_1 = require("../ast-utils");
 const expression_def_1 = require("../types/expression-def");
 class PartialCompare extends expression_def_1.ExpressionDef {
     constructor(op, right) {
-        super({ "right": right });
+        super({ right: right });
         this.op = op;
         this.right = right;
-        this.elementType = "<=> a";
+        this.elementType = '<=> a';
     }
     granular() {
         return this.right.granular();
@@ -42,8 +42,8 @@ class PartialCompare extends expression_def_1.ExpressionDef {
         return undefined;
     }
     getExpression(_fs) {
-        this.log(`Partial comparison does not have a value`);
-        return (0, ast_utils_1.errorFor)("no value for partial compare");
+        this.log('Partial comparison does not have a value');
+        return (0, ast_utils_1.errorFor)('no value for partial compare');
     }
 }
 exports.PartialCompare = PartialCompare;

package/dist/lang/ast/expressions/pick-when.d.ts

@@ -1,7 +1,7 @@
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
-import { FieldSpace } from "../types/field-space";
-import { MalloyElement } from "../types/malloy-element";
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
+import { MalloyElement } from '../types/malloy-element';
 export declare class Pick extends ExpressionDef {
     readonly choices: PickWhen[];
     readonly elsePick?: ExpressionDef | undefined;

package/dist/lang/ast/expressions/pick-when.js

@@ -34,7 +34,7 @@ class Pick extends expression_def_1.ExpressionDef {
         super({ choices });
         this.choices = choices;
         this.elsePick = elsePick;
-        this.elementType = "pick";
+        this.elementType = 'pick';
         this.has({ elsePick });
     }
     requestExpression(fs) {
@@ -44,11 +44,11 @@ class Pick extends expression_def_1.ExpressionDef {
             return undefined;
         }
         for (const c of this.choices) {
-            if (c.pick == undefined) {
+            if (c.pick === undefined) {
                 return undefined;
             }
             const whenResp = c.when.requestExpression(fs);
-            if (whenResp == undefined || whenResp.dataType != "boolean") {
+            if (whenResp === undefined || whenResp.dataType !== 'boolean') {
                 // If when is not a boolean, we'll treat it like a partial compare
                 return undefined;
             }
@@ -56,11 +56,11 @@ class Pick extends expression_def_1.ExpressionDef {
         return this.getExpression(fs);
     }
     apply(fs, op, expr) {
-        const caseValue = ["CASE"];
+        const caseValue = ['CASE'];
         let returnType;
-        let anyExpressionType = "scalar";
+        let anyExpressionType = 'scalar';
         for (const choice of this.choices) {
-            const whenExpr = choice.when.apply(fs, "=", expr);
+            const whenExpr = choice.when.apply(fs, '=', expr);
             const thenExpr = choice.pick
                 ? choice.pick.getExpression(fs)
                 : expr.getExpression(fs);
@@ -69,87 +69,87 @@ class Pick extends expression_def_1.ExpressionDef {
                 if (!fragtype_utils_1.FT.typeEq(returnType, thenExpr, true)) {
                     const whenType = fragtype_utils_1.FT.inspect(thenExpr);
                     this.log(`pick type '${whenType}', expected '${returnType.dataType}'`);
-                    return (0, ast_utils_1.errorFor)("pick when type");
+                    return (0, ast_utils_1.errorFor)('pick when type');
                 }
             }
             else {
                 returnType = thenExpr;
             }
-            caseValue.push(" WHEN ", ...whenExpr.value, " THEN ", ...thenExpr.value);
+            caseValue.push(' WHEN ', ...whenExpr.value, ' THEN ', ...thenExpr.value);
         }
         const elsePart = this.elsePick || expr;
         const elseVal = elsePart.getExpression(fs);
         returnType || (returnType = elseVal);
         if (!fragtype_utils_1.FT.typeEq(returnType, elseVal, true)) {
-            const errSrc = this.elsePick ? "else" : "pick default";
+            const errSrc = this.elsePick ? 'else' : 'pick default';
             this.log(`${errSrc} type '${fragtype_utils_1.FT.inspect(elseVal)}', expected '${returnType.dataType}'`);
-            return (0, ast_utils_1.errorFor)("pick else type");
+            return (0, ast_utils_1.errorFor)('pick else type');
         }
         return {
-            "dataType": returnType.dataType,
-            "expressionType": (0, malloy_types_1.maxExpressionType)(anyExpressionType, elseVal.expressionType),
-            "value": (0, utils_1.compressExpr)([...caseValue, " ELSE ", ...elseVal.value, " END"])
+            dataType: returnType.dataType,
+            expressionType: (0, malloy_types_1.maxExpressionType)(anyExpressionType, elseVal.expressionType),
+            value: (0, utils_1.compressExpr)([...caseValue, ' ELSE ', ...elseVal.value, ' END']),
         };
     }
     getExpression(fs) {
         if (this.elsePick === undefined) {
             this.log("pick incomplete, missing 'else'");
-            return (0, ast_utils_1.errorFor)("no value for partial pick");
+            return (0, ast_utils_1.errorFor)('no value for partial pick');
         }
         const choiceValues = [];
         for (const c of this.choices) {
             if (c.pick === undefined) {
-                this.log("pick with no value can only be used with apply");
-                return (0, ast_utils_1.errorFor)("no value for partial pick");
+                this.log('pick with no value can only be used with apply');
+                return (0, ast_utils_1.errorFor)('no value for partial pick');
             }
             const pickWhen = c.when.requestExpression(fs);
             if (pickWhen === undefined) {
-                this.log("pick with partial when can only be used with apply");
-                return (0, ast_utils_1.errorFor)("partial when");
+                this.log('pick with partial when can only be used with apply');
+                return (0, ast_utils_1.errorFor)('partial when');
             }
             choiceValues.push({
-                "pick": c.pick.getExpression(fs),
-                "when": c.when.getExpression(fs)
+                pick: c.pick.getExpression(fs),
+                when: c.when.getExpression(fs),
             });
         }
         const returnType = choiceValues[0].pick;
-        const caseValue = ["CASE"];
+        const caseValue = ['CASE'];
         let anyExpressionType = returnType.expressionType;
         for (const aChoice of choiceValues) {
             if (!fragtype_utils_1.FT.typeEq(aChoice.when, fragtype_utils_1.FT.boolT)) {
                 this.log(`when expression must be boolean, not '${fragtype_utils_1.FT.inspect(aChoice.when)}`);
-                return (0, ast_utils_1.errorFor)("pick when type");
+                return (0, ast_utils_1.errorFor)('pick when type');
             }
             if (!fragtype_utils_1.FT.typeEq(returnType, aChoice.pick, true)) {
                 const whenType = fragtype_utils_1.FT.inspect(aChoice.pick);
                 this.log(`pick type '${whenType}', expected '${returnType.dataType}'`);
-                return (0, ast_utils_1.errorFor)("pick value type");
+                return (0, ast_utils_1.errorFor)('pick value type');
             }
             anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, (0, malloy_types_1.maxExpressionType)(aChoice.pick.expressionType, aChoice.when.expressionType));
-            caseValue.push(" WHEN ", ...aChoice.when.value, " THEN ", ...aChoice.pick.value);
+            caseValue.push(' WHEN ', ...aChoice.when.value, ' THEN ', ...aChoice.pick.value);
         }
         const defVal = this.elsePick.getExpression(fs);
         anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, defVal.expressionType);
         if (!fragtype_utils_1.FT.typeEq(returnType, defVal, true)) {
             this.elsePick.log(`else type '${fragtype_utils_1.FT.inspect(defVal)}', expected '${returnType.dataType}'`);
-            return (0, ast_utils_1.errorFor)("pick value type mismatch");
+            return (0, ast_utils_1.errorFor)('pick value type mismatch');
         }
-        caseValue.push(" ELSE ", ...defVal.value, " END");
+        caseValue.push(' ELSE ', ...defVal.value, ' END');
         return {
-            "dataType": returnType.dataType,
-            "expressionType": anyExpressionType,
-            "value": (0, utils_1.compressExpr)(caseValue)
+            dataType: returnType.dataType,
+            expressionType: anyExpressionType,
+            value: (0, utils_1.compressExpr)(caseValue),
         };
     }
 }
 exports.Pick = Pick;
 class PickWhen extends malloy_element_1.MalloyElement {
     constructor(pick, when) {
-        super({ "when": when });
+        super({ when: when });
         this.pick = pick;
         this.when = when;
-        this.elementType = "pickWhen";
-        this.has({ "pick": pick });
+        this.elementType = 'pickWhen';
+        this.has({ pick: pick });
     }
 }
 exports.PickWhen = PickWhen;

package/dist/lang/ast/expressions/range.d.ts

@@ -1,6 +1,6 @@
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
-import { FieldSpace } from "../types/field-space";
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
 export declare class Range extends ExpressionDef {
     readonly first: ExpressionDef;
     readonly last: ExpressionDef;

package/dist/lang/ast/expressions/range.js

@@ -29,24 +29,24 @@ const expression_def_1 = require("../types/expression-def");
 const utils_1 = require("./utils");
 class Range extends expression_def_1.ExpressionDef {
     constructor(first, last) {
-        super({ "first": first, "last": last });
+        super({ first: first, last: last });
         this.first = first;
         this.last = last;
-        this.elementType = "range";
+        this.elementType = 'range';
     }
     apply(fs, op, expr) {
         switch (op) {
-            case "=":
-            case "!=": {
-                const op1 = op === "=" ? ">=" : "<";
-                const op2 = op === "=" ? "and" : "or";
-                const op3 = op === "=" ? "<" : ">=";
+            case '=':
+            case '!=': {
+                const op1 = op === '=' ? '>=' : '<';
+                const op2 = op === '=' ? 'and' : 'or';
+                const op3 = op === '=' ? '<' : '>=';
                 const fromValue = this.first.apply(fs, op1, expr);
                 const toValue = this.last.apply(fs, op3, expr);
                 return {
-                    "dataType": "boolean",
-                    "expressionType": (0, malloy_types_1.maxExpressionType)(fromValue.expressionType, toValue.expressionType),
-                    "value": (0, utils_1.compose)(fromValue.value, op2, toValue.value)
+                    dataType: 'boolean',
+                    expressionType: (0, malloy_types_1.maxExpressionType)(fromValue.expressionType, toValue.expressionType),
+                    value: (0, utils_1.compose)(fromValue.value, op2, toValue.value),
                 };
             }
             /**
@@ -58,22 +58,22 @@ class Range extends expression_def_1.ExpressionDef {
              * val < begin to end     val < begin
              * val <= begin to end    val < end
              */
-            case ">":
-                return this.last.apply(fs, ">=", expr);
-            case ">=":
-                return this.first.apply(fs, ">=", expr);
-            case "<":
-                return this.first.apply(fs, "<", expr);
-            case "<=":
-                return this.last.apply(fs, "<", expr);
+            case '>':
+                return this.last.apply(fs, '>=', expr);
+            case '>=':
+                return this.first.apply(fs, '>=', expr);
+            case '<':
+                return this.first.apply(fs, '<', expr);
+            case '<=':
+                return this.last.apply(fs, '<', expr);
         }
-        throw new Error("mysterious error in range computation");
+        throw new Error('mysterious error in range computation');
     }
     requestExpression(_fs) {
         return undefined;
     }
     getExpression(_fs) {
-        return (0, ast_utils_1.errorFor)("a range is not a value");
+        return (0, ast_utils_1.errorFor)('a range is not a value');
     }
 }
 exports.Range = Range;

package/dist/lang/ast/expressions/time-frame.d.ts

@@ -1,5 +1,5 @@
-import { TimestampUnit } from "../../../model/malloy_types";
-import { MalloyElement } from "../types/malloy-element";
+import { TimestampUnit } from '../../../model/malloy_types';
+import { MalloyElement } from '../types/malloy-element';
 export declare class Timeframe extends MalloyElement {
     elementType: string;
     readonly text: TimestampUnit;

package/dist/lang/ast/expressions/time-frame.js

@@ -28,12 +28,12 @@ const malloy_element_1 = require("../types/malloy-element");
 class Timeframe extends malloy_element_1.MalloyElement {
     constructor(timeframeName) {
         super();
-        this.elementType = "timeframe";
+        this.elementType = 'timeframe';
         let tf = timeframeName.toLowerCase();
-        if (tf.endsWith("s")) {
+        if (tf.endsWith('s')) {
             tf = tf.slice(0, -1);
         }
-        this.text = (0, malloy_types_1.isTimestampUnit)(tf) ? tf : "second";
+        this.text = (0, malloy_types_1.isTimestampUnit)(tf) ? tf : 'second';
     }
 }
 exports.Timeframe = Timeframe;

package/dist/lang/ast/expressions/top-by.d.ts

@@ -1,7 +1,7 @@
-import { By } from "../../../model/malloy_types";
-import { ExpressionDef } from "../types/expression-def";
-import { FieldSpace } from "../types/field-space";
-import { MalloyElement } from "../types/malloy-element";
+import { By } from '../../../model/malloy_types';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
+import { MalloyElement } from '../types/malloy-element';
 export declare class TopBy extends MalloyElement {
     readonly by: string | ExpressionDef;
     elementType: string;

package/dist/lang/ast/expressions/top-by.js

@@ -31,20 +31,20 @@ class TopBy extends malloy_element_1.MalloyElement {
     constructor(by) {
         super();
         this.by = by;
-        this.elementType = "topBy";
+        this.elementType = 'topBy';
         if (by instanceof expression_def_1.ExpressionDef) {
-            this.has({ "by": by });
+            this.has({ by: by });
         }
     }
     getBy(fs) {
         if (this.by instanceof expression_def_1.ExpressionDef) {
             const byExpr = this.by.getExpression(fs);
             if (!(0, malloy_types_1.expressionIsAggregate)(byExpr.expressionType)) {
-                this.log("top by expression must be an aggregate");
+                this.log('top by expression must be an aggregate');
             }
-            return { "by": "expression", "e": (0, utils_1.compressExpr)(byExpr.value) };
+            return { by: 'expression', e: (0, utils_1.compressExpr)(byExpr.value) };
         }
-        return { "by": "name", "name": this.by };
+        return { by: 'name', name: this.by };
     }
 }
 exports.TopBy = TopBy;

package/dist/lang/ast/expressions/unary.d.ts

@@ -1,4 +1,4 @@
-import { ExpressionDef } from "../types/expression-def";
+import { ExpressionDef } from '../types/expression-def';
 export declare abstract class Unary extends ExpressionDef {
     readonly expr: ExpressionDef;
     constructor(expr: ExpressionDef);

package/dist/lang/ast/expressions/unary.js

@@ -26,7 +26,7 @@ exports.Unary = void 0;
 const expression_def_1 = require("../types/expression-def");
 class Unary extends expression_def_1.ExpressionDef {
     constructor(expr) {
-        super({ "expr": expr });
+        super({ expr: expr });
         this.expr = expr;
     }
 }

package/dist/lang/ast/expressions/utils.d.ts

@@ -1,5 +1,5 @@
-import { Expr, Fragment } from "../../../model/malloy_types";
-import { Equality } from "../types/equality";
+import { Expr, Fragment } from '../../../model/malloy_types';
+import { Equality } from '../types/equality';
 /**
  * Compose a binary expression. Tries to write them safely and concisely
  * @param left

package/dist/lang/ast/expressions/utils.js

@@ -30,13 +30,13 @@ const malloy_types_1 = require("../../../model/malloy_types");
  */
 function term(f) {
     if (f.length > 1) {
-        return ["(", ...f, ")"];
+        return ['(', ...f, ')'];
     }
     if (f.length === 0) {
         // Trying to compose a binary expresion with an entity that has no value
         // this should at least cause the generated SQL to error, but likely
         // there has already been a semantic error reported.
-        return ["__MISSING_VALUE__"];
+        return ['__MISSING_VALUE__'];
     }
     return f;
 }
@@ -49,8 +49,8 @@ function term(f) {
  */
 function compose(left, op, right) {
     const opAlpha = op.match(/^[A-Za-z]/);
-    const leftSpace = left.length === 1 && opAlpha ? " " : "";
-    const rightSpace = right.length === 1 && opAlpha ? " " : "";
+    const leftSpace = left.length === 1 && opAlpha ? ' ' : '';
+    const rightSpace = right.length === 1 && opAlpha ? ' ' : '';
     const newOp = leftSpace + op + rightSpace;
     return [...term(left), newOp, ...term(right)];
 }
@@ -60,7 +60,7 @@ function compressExpr(expr) {
     const compressValue = [];
     let buildString;
     for (const fragment of expr.flat()) {
-        if (typeof fragment === "string") {
+        if (typeof fragment === 'string') {
             buildString = buildString ? buildString + fragment : fragment;
         }
         else {
@@ -78,7 +78,7 @@ function compressExpr(expr) {
 }
 exports.compressExpr = compressExpr;
 function nullsafeNot(expr, op) {
-    if (op === undefined || op === "!=" || op === "!~") {
+    if (op === undefined || op === '!=' || op === '!~') {
         return (0, malloy_types_1.mkExpr) `COALESCE(NOT(${expr}),FALSE)`;
     }
     return expr;

package/dist/lang/ast/field-space/column-space-field.d.ts

@@ -1,6 +1,6 @@
-import { FieldDef, FieldTypeDef } from "../../../model/malloy_types";
-import { SpaceField } from "../types/space-field";
-import { TypeDesc } from "../types/type-desc";
+import { FieldDef, FieldTypeDef } from '../../../model/malloy_types';
+import { SpaceField } from '../types/space-field';
+import { TypeDesc } from '../types/type-desc';
 export declare class ColumnSpaceField extends SpaceField {
     protected def: FieldTypeDef;
     constructor(def: FieldTypeDef);

package/dist/lang/ast/field-space/dynamic-space.d.ts

@@ -1,10 +1,10 @@
-import * as model from "../../../model/malloy_types";
-import { SpaceEntry } from "../types/space-entry";
-import { FieldSpace } from "../types/field-space";
-import { HasParameter } from "../parameters/has-parameter";
-import { MalloyElement } from "../types/malloy-element";
-import { SourceSpec, SpaceSeed } from "../space-seed";
-import { StaticSpace } from "./static-space";
+import * as model from '../../../model/malloy_types';
+import { SpaceEntry } from '../types/space-entry';
+import { FieldSpace } from '../types/field-space';
+import { HasParameter } from '../parameters/has-parameter';
+import { MalloyElement } from '../types/malloy-element';
+import { SourceSpec, SpaceSeed } from '../space-seed';
+import { StaticSpace } from './static-space';
 export declare abstract class DynamicSpace extends StaticSpace {
     protected final: model.StructDef | undefined;
     protected source: SpaceSeed;

package/dist/lang/ast/field-space/dynamic-space.js

@@ -62,7 +62,7 @@ class DynamicSpace extends static_space_1.StaticSpace {
     }
     setEntry(name, value) {
         if (this.final) {
-            throw new Error("Space already final");
+            throw new Error('Space already final');
         }
         super.setEntry(name, value);
     }
@@ -87,7 +87,7 @@ class DynamicSpace extends static_space_1.StaticSpace {
         if (this.final === undefined) {
             this.final = {
                 ...this.fromStruct,
-                "fields": []
+                fields: [],
             };
             // Need to process the entities in specific order
             const fields = [];

package/dist/lang/ast/field-space/field-definition-value.d.ts

@@ -1,8 +1,8 @@
-import * as model from "../../../model/malloy_types";
-import { FieldDeclaration } from "../query-items/field-declaration";
-import { FieldSpace } from "../types/field-space";
-import { SpaceField } from "../types/space-field";
-import { TypeDesc } from "../types/type-desc";
+import * as model from '../../../model/malloy_types';
+import { FieldDeclaration } from '../query-items/field-declaration';
+import { FieldSpace } from '../types/field-space';
+import { SpaceField } from '../types/space-field';
+import { TypeDesc } from '../types/type-desc';
 export declare class FieldDefinitionValue extends SpaceField {
     readonly space: FieldSpace;
     readonly exprDef: FieldDeclaration;