@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207180844

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

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GranularLiteral = void 0;
+/*
+ * 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.
+ */
+const luxon_1 = require("luxon");
+const malloy_types_1 = require("../../../model/malloy_types");
+const range_1 = require("./range");
+const expr_time_1 = require("./expr-time");
+const time_utils_1 = require("../time-utils");
+const expression_def_1 = require("../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.
+ */
+class GranularLiteral extends expression_def_1.ExpressionDef {
+    constructor(moment, until, units) {
+        super();
+        this.moment = moment;
+        this.until = until;
+        this.units = units;
+        this.elementType = "timeLiteral";
+    }
+    granular() {
+        return true;
+    }
+    static parse(possibleLiteral) {
+        const s = possibleLiteral.slice(1);
+        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";
+            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";
+            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");
+            if (qplus > 0) {
+                qstart = qstart.plus({ quarters: qplus });
+            }
+            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 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 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");
+        }
+        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 });
+                }
+                const next = sunday.plus({ days: 7 });
+                return new GranularLiteral(`${sunday.toFormat(fDay)}`, `${next.toFormat(fDay)}`, "week");
+            }
+        }
+        return undefined;
+    }
+    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";
+            }
+            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 value = {
+            dataType,
+            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
+        // there should be a better way to make this happen, but the point
+        // 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)) {
+            value.alsoTimestamp = true;
+        }
+        if (this.units != "second") {
+            return {
+                ...value,
+                timeframe: this.units,
+            };
+        }
+        return value;
+    }
+}
+exports.GranularLiteral = GranularLiteral;
+//# sourceMappingURL=granular-literal.js.map

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

@@ -0,0 +1,14 @@
+import { Comparison } from "../types/comparison";
+import { ExprValue } from "../types/expr-value";
+import { FieldSpace } from "../types/field-space";
+import { ExpressionDef } from "../types/expression-def";
+export declare class PartialCompare extends ExpressionDef {
+    readonly op: Comparison;
+    readonly right: ExpressionDef;
+    elementType: string;
+    constructor(op: Comparison, right: ExpressionDef);
+    granular(): boolean;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(_fs: FieldSpace): ExprValue | undefined;
+    getExpression(_fs: FieldSpace): ExprValue;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartialCompare = void 0;
+/*
+ * 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.
+ */
+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 });
+        this.op = op;
+        this.right = right;
+        this.elementType = "<=> a";
+    }
+    granular() {
+        return this.right.granular();
+    }
+    apply(fs, op, expr) {
+        return this.right.apply(fs, this.op, expr);
+    }
+    requestExpression(_fs) {
+        return undefined;
+    }
+    getExpression(_fs) {
+        this.log(`Partial comparison does not have a value`);
+        return (0, ast_utils_1.errorFor)("no value for partial compare");
+    }
+}
+exports.PartialCompare = PartialCompare;
+//# sourceMappingURL=partial-compare.js.map

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

@@ -0,0 +1,19 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldSpace } from "../types/field-space";
+import { MalloyElement } from "../types/malloy-element";
+import { ExpressionDef } from "../types/expression-def";
+export declare class Pick extends ExpressionDef {
+    readonly choices: PickWhen[];
+    readonly elsePick?: ExpressionDef | undefined;
+    elementType: string;
+    constructor(choices: PickWhen[], elsePick?: ExpressionDef | undefined);
+    requestExpression(fs: FieldSpace): ExprValue | undefined;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
+}
+export declare class PickWhen extends MalloyElement {
+    readonly pick: ExpressionDef | undefined;
+    readonly when: ExpressionDef;
+    elementType: string;
+    constructor(pick: ExpressionDef | undefined, when: ExpressionDef);
+}

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

@@ -0,0 +1,156 @@
+"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.PickWhen = exports.Pick = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const ast_utils_1 = require("../ast-utils");
+const fragtype_utils_1 = require("../fragtype-utils");
+const malloy_element_1 = require("../types/malloy-element");
+const expression_def_1 = require("../types/expression-def");
+const utils_1 = require("./utils");
+class Pick extends expression_def_1.ExpressionDef {
+    constructor(choices, elsePick) {
+        super({ choices });
+        this.choices = choices;
+        this.elsePick = elsePick;
+        this.elementType = "pick";
+        this.has({ elsePick });
+    }
+    requestExpression(fs) {
+        // pick statements are sometimes partials which must be applied
+        // and sometimes have a value.
+        if (this.elsePick === undefined) {
+            return undefined;
+        }
+        for (const c of this.choices) {
+            if (c.pick == undefined) {
+                return undefined;
+            }
+            const whenResp = c.when.requestExpression(fs);
+            if (whenResp == undefined || whenResp.dataType != "boolean") {
+                // If when is not a boolean, we'll treat it like a partial compare
+                return undefined;
+            }
+        }
+        return this.getExpression(fs);
+    }
+    apply(fs, op, expr) {
+        const caseValue = ["CASE"];
+        let returnType;
+        let anyExpressionType = "scalar";
+        for (const choice of this.choices) {
+            const whenExpr = choice.when.apply(fs, "=", expr);
+            const thenExpr = choice.pick
+                ? choice.pick.getExpression(fs)
+                : expr.getExpression(fs);
+            anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, (0, malloy_types_1.maxExpressionType)(whenExpr.expressionType, thenExpr.expressionType));
+            if (returnType) {
+                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");
+                }
+            }
+            else {
+                returnType = thenExpr;
+            }
+            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";
+            this.log(`${errSrc} type '${fragtype_utils_1.FT.inspect(elseVal)}', expected '${returnType.dataType}'`);
+            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"]),
+        };
+    }
+    getExpression(fs) {
+        if (this.elsePick === undefined) {
+            this.log("pick incomplete, missing 'else'");
+            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");
+            }
+            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");
+            }
+            choiceValues.push({
+                pick: c.pick.getExpression(fs),
+                when: c.when.getExpression(fs),
+            });
+        }
+        const returnType = choiceValues[0].pick;
+        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");
+            }
+            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");
+            }
+            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);
+        }
+        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");
+        }
+        caseValue.push(" ELSE ", ...defVal.value, " END");
+        return {
+            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 });
+        this.pick = pick;
+        this.when = when;
+        this.elementType = "pickWhen";
+        this.has({ pick });
+    }
+}
+exports.PickWhen = PickWhen;
+//# sourceMappingURL=pick-when.js.map

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

@@ -0,0 +1,12 @@
+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;
+    elementType: string;
+    constructor(first: ExpressionDef, last: ExpressionDef);
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(_fs: FieldSpace): ExprValue | undefined;
+    getExpression(_fs: FieldSpace): ExprValue;
+}

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

@@ -0,0 +1,80 @@
+"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.Range = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const ast_utils_1 = require("../ast-utils");
+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, last });
+        this.first = first;
+        this.last = last;
+        this.elementType = "range";
+    }
+    apply(fs, op, expr) {
+        switch (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),
+                };
+            }
+            /**
+             * This is a little surprising, but is actually how you comapre a
+             * value to a range ...
+             *
+             * val > begin to end     val >= end
+             * val >= begin to end    val >= begin
+             * 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);
+        }
+        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");
+    }
+}
+exports.Range = Range;
+//# sourceMappingURL=range.js.map

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

@@ -0,0 +1,7 @@
+import { TimestampUnit } from "../../../model/malloy_types";
+import { MalloyElement } from "../types/malloy-element";
+export declare class Timeframe extends MalloyElement {
+    elementType: string;
+    readonly text: TimestampUnit;
+    constructor(timeframeName: string);
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timeframe = void 0;
+/*
+ * 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.
+ */
+const malloy_types_1 = require("../../../model/malloy_types");
+const malloy_element_1 = require("../types/malloy-element");
+class Timeframe extends malloy_element_1.MalloyElement {
+    constructor(timeframeName) {
+        super();
+        this.elementType = "timeframe";
+        let tf = timeframeName.toLowerCase();
+        if (tf.endsWith("s")) {
+            tf = tf.slice(0, -1);
+        }
+        this.text = (0, malloy_types_1.isTimestampUnit)(tf) ? tf : "second";
+    }
+}
+exports.Timeframe = Timeframe;
+//# sourceMappingURL=time-frame.js.map

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

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

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopBy = void 0;
+/*
+ * 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.
+ */
+const malloy_types_1 = require("../../../model/malloy_types");
+const malloy_element_1 = require("../types/malloy-element");
+const expression_def_1 = require("../types/expression-def");
+const utils_1 = require("./utils");
+class TopBy extends malloy_element_1.MalloyElement {
+    constructor(by) {
+        super();
+        this.by = by;
+        this.elementType = "topBy";
+        if (by instanceof expression_def_1.ExpressionDef) {
+            this.has({ 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");
+            }
+            return { by: "expression", e: (0, utils_1.compressExpr)(byExpr.value) };
+        }
+        return { by: "name", name: this.by };
+    }
+}
+exports.TopBy = TopBy;
+//# sourceMappingURL=top-by.js.map

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,34 @@
+"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.Unary = void 0;
+const expression_def_1 = require("../types/expression-def");
+class Unary extends expression_def_1.ExpressionDef {
+    constructor(expr) {
+        super({ expr });
+        this.expr = expr;
+    }
+}
+exports.Unary = Unary;
+//# sourceMappingURL=unary.js.map

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

@@ -0,0 +1,12 @@
+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
+ * @param op
+ * @param right
+ * @returns Fragment list of the composed expression
+ */
+export declare function compose(left: Fragment[], op: string, right: Fragment[]): Fragment[];
+export declare function compressExpr(expr: Expr): Expr;
+export declare function nullsafeNot(expr: Expr, op?: Equality): Expr;