@malloydata/malloy 0.0.24-dev230224184907 → 0.0.24-dev230228224434

package/dist/lang/ast/expressions/expr-null.d.ts

@@ -1,5 +1,5 @@
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
 export declare class ExprNULL extends ExpressionDef {
     elementType: string;
     getExpression(): ExprValue;

package/dist/lang/ast/expressions/expr-null.js

@@ -27,13 +27,13 @@ const expression_def_1 = require("../types/expression-def");
 class ExprNULL extends expression_def_1.ExpressionDef {
     constructor() {
         super(...arguments);
-        this.elementType = "NULL";
+        this.elementType = 'NULL';
     }
     getExpression() {
         return {
-            "dataType": "null",
-            "value": ["NULL"],
-            "expressionType": "scalar"
+            dataType: 'null',
+            value: ['NULL'],
+            expressionType: 'scalar',
         };
     }
 }

package/dist/lang/ast/expressions/expr-number.d.ts

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

package/dist/lang/ast/expressions/expr-number.js

@@ -29,13 +29,13 @@ class ExprNumber extends expression_def_1.ExpressionDef {
     constructor(n) {
         super();
         this.n = n;
-        this.elementType = "numeric literal";
+        this.elementType = 'numeric literal';
     }
     getExpression(_fs) {
         return this.constantExpression();
     }
     constantExpression() {
-        return { ...fragtype_utils_1.FT.numberT, "value": [this.n] };
+        return { ...fragtype_utils_1.FT.numberT, value: [this.n] };
     }
 }
 exports.ExprNumber = ExprNumber;

package/dist/lang/ast/expressions/expr-parens.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 ExprParens extends ExpressionDef {
     readonly expr: ExpressionDef;
     elementType: string;

package/dist/lang/ast/expressions/expr-parens.js

@@ -26,16 +26,16 @@ exports.ExprParens = void 0;
 const expression_def_1 = require("../types/expression-def");
 class ExprParens extends expression_def_1.ExpressionDef {
     constructor(expr) {
-        super({ "expr": expr });
+        super({ expr: expr });
         this.expr = expr;
-        this.elementType = "(expression)";
+        this.elementType = '(expression)';
     }
     requestExpression(fs) {
         return this.expr.requestExpression(fs);
     }
     getExpression(fs) {
         const subExpr = this.expr.getExpression(fs);
-        return { ...subExpr, "value": ["(", ...subExpr.value, ")"] };
+        return { ...subExpr, value: ['(', ...subExpr.value, ')'] };
     }
 }
 exports.ExprParens = ExprParens;

package/dist/lang/ast/expressions/expr-regex.d.ts

@@ -1,5 +1,5 @@
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
 export declare class ExprRegEx extends ExpressionDef {
     readonly regex: string;
     elementType: string;

package/dist/lang/ast/expressions/expr-regex.js

@@ -28,13 +28,13 @@ class ExprRegEx extends expression_def_1.ExpressionDef {
     constructor(regex) {
         super();
         this.regex = regex;
-        this.elementType = "regular expression literal";
+        this.elementType = 'regular expression literal';
     }
     getExpression() {
         return {
-            "dataType": "regular expression",
-            "expressionType": "scalar",
-            "value": [`r'${this.regex}'`]
+            dataType: 'regular expression',
+            expressionType: 'scalar',
+            value: [`r'${this.regex}'`],
         };
     }
 }

package/dist/lang/ast/expressions/expr-string.d.ts

@@ -1,6 +1,6 @@
-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';
+import { ExprValue } from '../types/expr-value';
 export declare class ExprString extends ExpressionDef {
     elementType: string;
     value: string;

package/dist/lang/ast/expressions/expr-string.js

@@ -28,21 +28,21 @@ const fragtype_utils_1 = require("../fragtype-utils");
 class ExprString extends expression_def_1.ExpressionDef {
     constructor(src) {
         super();
-        this.elementType = "string literal";
+        this.elementType = 'string literal';
         const bareStr = src.slice(1, -1);
-        const val = bareStr.replace(/\\(.)/g, "$1");
+        const val = bareStr.replace(/\\(.)/g, '$1');
         this.value = val;
     }
     getExpression(_fs) {
         return {
             ...fragtype_utils_1.FT.stringT,
-            "value": [
+            value: [
                 {
-                    "type": "dialect",
-                    "function": "stringLiteral",
-                    "literal": this.value
-                }
-            ]
+                    type: 'dialect',
+                    function: 'stringLiteral',
+                    literal: this.value,
+                },
+            ],
         };
     }
 }

package/dist/lang/ast/expressions/expr-sum.d.ts

@@ -1,6 +1,6 @@
-import { FieldReference } from "../query-items/field-references";
-import { ExpressionDef } from "../types/expression-def";
-import { ExprAsymmetric } from "./expr-asymmetric";
+import { FieldReference } from '../query-items/field-references';
+import { ExpressionDef } from '../types/expression-def';
+import { ExprAsymmetric } from './expr-asymmetric';
 export declare class ExprSum extends ExprAsymmetric {
     constructor(expr: ExpressionDef | undefined, source?: FieldReference);
 }

package/dist/lang/ast/expressions/expr-sum.js

@@ -26,8 +26,8 @@ exports.ExprSum = void 0;
 const expr_asymmetric_1 = require("./expr-asymmetric");
 class ExprSum extends expr_asymmetric_1.ExprAsymmetric {
     constructor(expr, source) {
-        super("sum", expr, source);
-        this.has({ "source": source });
+        super('sum', expr, source);
+        this.has({ source: source });
     }
 }
 exports.ExprSum = ExprSum;

package/dist/lang/ast/expressions/expr-time-extract.d.ts

@@ -1,7 +1,7 @@
-import { ExtractUnit } from "../../../model/malloy_types";
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
-import { FieldSpace } from "../types/field-space";
+import { ExtractUnit } from '../../../model/malloy_types';
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
 export declare class ExprTimeExtract extends ExpressionDef {
     readonly extractText: string;
     readonly args: ExpressionDef[];

package/dist/lang/ast/expressions/expr-time-extract.js

@@ -29,10 +29,10 @@ const expression_def_1 = require("../types/expression-def");
 const range_1 = require("./range");
 class ExprTimeExtract extends expression_def_1.ExpressionDef {
     constructor(extractText, args) {
-        super({ "args": args });
+        super({ args: args });
         this.extractText = extractText;
         this.args = args;
-        this.elementType = "timeExtract";
+        this.elementType = 'timeExtract';
     }
     static extractor(funcName) {
         const mappedName = ExprTimeExtract.pluralMap[funcName];
@@ -48,7 +48,7 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
         if (extractTo) {
             if (this.args.length !== 1) {
                 this.log(`Extraction function ${extractTo} requires one argument`);
-                return (0, ast_utils_1.errorFor)(`{this.name} arg count`);
+                return (0, ast_utils_1.errorFor)('{this.name} arg count');
             }
             const from = this.args[0];
             if (from instanceof range_1.Range) {
@@ -67,33 +67,33 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                     return (0, ast_utils_1.errorFor)(`${extractTo} bad extraction`);
                 }
                 return {
-                    "dataType": "number",
-                    "expressionType": (0, malloy_types_1.maxExpressionType)(first.expressionType, last.expressionType),
-                    "value": [
+                    dataType: 'number',
+                    expressionType: (0, malloy_types_1.maxExpressionType)(first.expressionType, last.expressionType),
+                    value: [
                         {
-                            "type": "dialect",
-                            "function": "timeDiff",
-                            "units": extractTo,
-                            "left": { "valueType": first.dataType, "value": first.value },
-                            "right": { "valueType": last.dataType, "value": last.value }
-                        }
-                    ]
+                            type: 'dialect',
+                            function: 'timeDiff',
+                            units: extractTo,
+                            left: { valueType: first.dataType, value: first.value },
+                            right: { valueType: last.dataType, value: last.value },
+                        },
+                    ],
                 };
             }
             else {
                 const argV = from.getExpression(fs);
                 if ((0, malloy_types_1.isTimeFieldType)(argV.dataType)) {
                     return {
-                        "dataType": "number",
-                        "expressionType": argV.expressionType,
-                        "value": [
+                        dataType: 'number',
+                        expressionType: argV.expressionType,
+                        value: [
                             {
-                                "type": "dialect",
-                                "function": "extract",
-                                "expr": { "value": argV.value, "valueType": argV.dataType },
-                                "units": extractTo
-                            }
-                        ]
+                                type: 'dialect',
+                                function: 'extract',
+                                expr: { value: argV.value, valueType: argV.dataType },
+                                units: extractTo,
+                            },
+                        ],
                     };
                 }
                 this.log(`${this.extractText}() requires time type, not '${argV.dataType}'`);
@@ -105,13 +105,13 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
 }
 exports.ExprTimeExtract = ExprTimeExtract;
 ExprTimeExtract.pluralMap = {
-    "years": "year",
-    "quarters": "quarter",
-    "months": "month",
-    "weeks": "week",
-    "days": "day",
-    "hours": "hour",
-    "minutes": "minute",
-    "seconds": "second"
+    years: 'year',
+    quarters: 'quarter',
+    months: 'month',
+    weeks: 'week',
+    days: 'day',
+    hours: 'hour',
+    minutes: 'minute',
+    seconds: 'second',
 };
 //# sourceMappingURL=expr-time-extract.js.map

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

@@ -1,7 +1,7 @@
-import { ExpressionType, Fragment, TimeFieldType } from "../../../model/malloy_types";
-import { FieldSpace } from "../types/field-space";
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
+import { ExpressionType, Fragment, TimeFieldType } from '../../../model/malloy_types';
+import { FieldSpace } from '../types/field-space';
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
 export declare class ExprTime extends ExpressionDef {
     elementType: string;
     readonly translationValue: ExprValue;

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

@@ -27,14 +27,14 @@ const malloy_types_1 = require("../../../model/malloy_types");
 const utils_1 = require("./utils");
 const expression_def_1 = require("../types/expression-def");
 class ExprTime extends expression_def_1.ExpressionDef {
-    constructor(timeType, value, expressionType = "scalar") {
+    constructor(timeType, value, expressionType = 'scalar') {
         super();
-        this.elementType = "timestampOrDate";
+        this.elementType = 'timestampOrDate';
         this.elementType = timeType;
         this.translationValue = {
-            "dataType": timeType,
+            dataType: timeType,
             expressionType,
-            "value": typeof value === "string" ? [value] : value
+            value: typeof value === 'string' ? [value] : value,
         };
     }
     getExpression(_fs) {
@@ -42,13 +42,13 @@ class ExprTime extends expression_def_1.ExpressionDef {
     }
     static fromValue(timeType, expr) {
         let value = expr.value;
-        if (timeType != expr.dataType) {
+        if (timeType !== expr.dataType) {
             const toTs = {
-                "type": "dialect",
-                "function": "cast",
-                "safe": false,
-                "dstType": timeType,
-                "expr": expr.value
+                type: 'dialect',
+                function: 'cast',
+                safe: false,
+                dstType: timeType,
+                expr: expr.value,
             };
             if ((0, malloy_types_1.isTimeFieldType)(expr.dataType)) {
                 toTs.srcType = expr.dataType;

package/dist/lang/ast/expressions/expr-ungroup.d.ts

@@ -1,14 +1,14 @@
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
-import { FieldName, FieldSpace } from "../types/field-space";
-import { FieldValueType } from "../types/type-desc";
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldName, FieldSpace } from '../types/field-space';
+import { FieldValueType } from '../types/type-desc';
 export declare class ExprUngroup extends ExpressionDef {
-    readonly control: "all" | "exclude";
+    readonly control: 'all' | 'exclude';
     readonly expr: ExpressionDef;
     readonly fields: FieldName[];
     legalChildTypes: import("../types/type-desc").TypeDesc[];
     elementType: string;
-    constructor(control: "all" | "exclude", expr: ExpressionDef, fields: FieldName[]);
+    constructor(control: 'all' | 'exclude', expr: ExpressionDef, fields: FieldName[]);
     returns(_forExpression: ExprValue): FieldValueType;
     getExpression(fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/expr-ungroup.js

@@ -31,27 +31,27 @@ const field_declaration_1 = require("../query-items/field-declaration");
 const expression_def_1 = require("../types/expression-def");
 class ExprUngroup extends expression_def_1.ExpressionDef {
     constructor(control, expr, fields) {
-        super({ "expr": expr, "fields": fields });
+        super({ expr: expr, fields: fields });
         this.control = control;
         this.expr = expr;
         this.fields = fields;
         this.legalChildTypes = fragtype_utils_1.FT.anyAtomicT;
-        this.elementType = "ungroup";
+        this.elementType = 'ungroup';
     }
     returns(_forExpression) {
-        return "number";
+        return 'number';
     }
     getExpression(fs) {
         const exprVal = this.expr.getExpression(fs);
         if (!(0, malloy_types_1.expressionIsAggregate)(exprVal.expressionType)) {
             this.expr.log(`${this.control}() expression must be an aggregate`);
-            return (0, ast_utils_1.errorFor)("ungrouped scalar");
+            return (0, ast_utils_1.errorFor)('ungrouped scalar');
         }
         const ungroup = {
-            "type": this.control,
-            "e": exprVal.value
+            type: this.control,
+            e: exprVal.value,
         };
-        if (this.typeCheck(this.expr, { ...exprVal, "expressionType": "scalar" })) {
+        if (this.typeCheck(this.expr, { ...exprVal, expressionType: 'scalar' })) {
             if (this.fields.length > 0) {
                 let qs = fs;
                 if (fs instanceof field_declaration_1.DefSpace) {
@@ -59,11 +59,11 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
                 }
                 if (!(qs instanceof query_spaces_1.QueryInputSpace)) {
                     this.log(`${this.control}() must be in a query -- weird internal error`);
-                    return (0, ast_utils_1.errorFor)("ungroup query check");
+                    return (0, ast_utils_1.errorFor)('ungroup query check');
                 }
                 const output = qs.result;
                 const dstFields = [];
-                const isExclude = this.control == "exclude";
+                const isExclude = this.control === 'exclude';
                 for (const mustBeInOutput of this.fields) {
                     output.whenComplete(() => {
                         output.checkUngroup(mustBeInOutput, isExclude);
@@ -73,13 +73,13 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
                 ungroup.fields = dstFields;
             }
             return {
-                "dataType": this.returns(exprVal),
-                "expressionType": "analytic",
-                "value": [ungroup]
+                dataType: this.returns(exprVal),
+                expressionType: 'analytic',
+                value: [ungroup],
             };
         }
         this.log(`${this.control}() incompatible type`);
-        return (0, ast_utils_1.errorFor)("ungrouped type check");
+        return (0, ast_utils_1.errorFor)('ungrouped type check');
     }
 }
 exports.ExprUngroup = ExprUngroup;

package/dist/lang/ast/expressions/for-range.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 { Timeframe } from "./time-frame";
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
+import { Timeframe } from './time-frame';
 /**
  * TODO: This is sort of a hand clone of the "Range" class, they should
  * be siblings of a common abstract classs.

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

@@ -36,23 +36,23 @@ const range_1 = require("./range");
  */
 class ForRange extends expression_def_1.ExpressionDef {
     constructor(from, duration, timeframe) {
-        super({ "from": from, "duration": duration, "timeframe": timeframe });
+        super({ from: from, duration: duration, timeframe: timeframe });
         this.from = from;
         this.duration = duration;
         this.timeframe = timeframe;
-        this.elementType = "forRange";
+        this.elementType = 'forRange';
         this.legalChildTypes = [fragtype_utils_1.FT.timestampT, fragtype_utils_1.FT.dateT];
     }
     apply(fs, op, expr) {
         const startV = this.from.getExpression(fs);
         const checkV = expr.getExpression(fs);
         if (!this.typeCheck(expr, checkV)) {
-            return (0, ast_utils_1.errorFor)("no time for range");
+            return (0, ast_utils_1.errorFor)('no time for range');
         }
         const nV = this.duration.getExpression(fs);
-        if (nV.dataType !== "number") {
+        if (nV.dataType !== 'number') {
             this.log(`FOR duration count must be a number, not '${nV.dataType}'`);
-            return (0, ast_utils_1.errorFor)("FOR not number");
+            return (0, ast_utils_1.errorFor)('FOR not number');
         }
         const units = this.timeframe.text;
         // If the duration resolution is smaller than date, we have
@@ -61,40 +61,40 @@ class ForRange extends expression_def_1.ExpressionDef {
         let rangeType = durationRes;
         // Next, if the beginning of the range is a timestamp, then we
         // also have to do the computation as a timestamp
-        if (startV.dataType === "timestamp") {
-            rangeType = "timestamp";
+        if (startV.dataType === 'timestamp') {
+            rangeType = 'timestamp';
         }
         // everything is dates, do date math
-        if (checkV.dataType === "date" && rangeType === "date") {
+        if (checkV.dataType === 'date' && rangeType === 'date') {
             const rangeStart = this.from;
-            const rangeEndV = (0, time_utils_1.timeOffset)("date", startV.value, "+", nV.value, units);
-            const rangeEnd = new expr_time_1.ExprTime("date", rangeEndV);
+            const rangeEndV = (0, time_utils_1.timeOffset)('date', startV.value, '+', nV.value, units);
+            const rangeEnd = new expr_time_1.ExprTime('date', rangeEndV);
             return new range_1.Range(rangeStart, rangeEnd).apply(fs, op, expr);
         }
         // Now it doesn't matter if the range is a date or a timestamp,
         // the comparison will be in timestamp space,
-        const applyTo = expr_time_1.ExprTime.fromValue("timestamp", checkV);
+        const applyTo = expr_time_1.ExprTime.fromValue('timestamp', checkV);
         let rangeStart = this.from;
         let from = startV.value;
-        if (startV.dataType === "date") {
+        if (startV.dataType === 'date') {
             // Time literals with timestamp units can also be used as timestamps;
             const alreadyTs = (0, granular_result_1.isGranularResult)(startV) && startV.alsoTimestamp;
             if (!alreadyTs) {
                 // ... not a literal, need a cast
                 from = (0, time_utils_1.castDateToTimestamp)(from);
             }
-            rangeStart = new expr_time_1.ExprTime("timestamp", from, startV.expressionType);
+            rangeStart = new expr_time_1.ExprTime('timestamp', from, startV.expressionType);
         }
-        const to = (0, time_utils_1.timeOffset)("timestamp", from, "+", nV.value, units);
-        const rangeEnd = new expr_time_1.ExprTime("timestamp", to, startV.expressionType);
+        const to = (0, time_utils_1.timeOffset)('timestamp', from, '+', nV.value, units);
+        const rangeEnd = new expr_time_1.ExprTime('timestamp', to, startV.expressionType);
         return new range_1.Range(rangeStart, rangeEnd).apply(fs, op, applyTo);
     }
     requestExpression(_fs) {
         return undefined;
     }
     getExpression(_fs) {
-        this.log("A Range is not a value");
-        return (0, ast_utils_1.errorFor)("range has no value");
+        this.log('A Range is not a value');
+        return (0, ast_utils_1.errorFor)('range has no value');
     }
 }
 exports.ForRange = ForRange;

package/dist/lang/ast/expressions/granular-literal.d.ts

@@ -1,7 +1,7 @@
-import { TimeFieldType, TimestampUnit } from "../../../model/malloy_types";
-import { ExprValue } from "../types/expr-value";
-import { FieldSpace } from "../types/field-space";
-import { ExpressionDef } from "../types/expression-def";
+import { TimeFieldType, TimestampUnit } from '../../../model/malloy_types';
+import { ExprValue } from '../types/expr-value';
+import { FieldSpace } from '../types/field-space';
+import { ExpressionDef } from '../types/expression-def';
 /**
  * GranularTime made from a literal. Funky because it doesn't know if it
  * is a date or a timestamp in many cases until it is applied.