@malloydata/malloy 0.0.205-dev241028163321 → 0.0.205-dev241028173215

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

@@ -21,10 +21,33 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprCoalesce = void 0;
 const model_1 = require("../../../model");
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 const expression_def_1 = require("../types/expression-def");
 class ExprCoalesce extends expression_def_1.ExpressionDef {
     constructor(expr, altExpr) {
@@ -32,12 +55,12 @@ class ExprCoalesce extends expression_def_1.ExpressionDef {
         this.expr = expr;
         this.altExpr = altExpr;
         this.elementType = 'coalesce expression';
-        this.legalChildTypes = fragtype_utils_1.FT.anyAtomicT;
+        this.legalChildTypes = TDU.anyAtomicT;
     }
     getExpression(fs) {
         const maybeNull = this.expr.getExpression(fs);
         const whenNull = this.altExpr.getExpression(fs);
-        if (maybeNull.dataType === 'null') {
+        if (maybeNull.type === 'null') {
             return whenNull;
         }
         /**
@@ -48,12 +71,12 @@ class ExprCoalesce extends expression_def_1.ExpressionDef {
          * SQL, but I decided that is will happen when the "expressions are true
          * trees" rewrite happens.
          */
-        if (!fragtype_utils_1.FT.typeEq(maybeNull, whenNull)) {
-            this.logError('mismatched-coalesce-types', `Mismatched types for coalesce (${maybeNull.dataType}, ${whenNull.dataType})`);
+        if (!TDU.typeEq(maybeNull, whenNull)) {
+            this.logError('mismatched-coalesce-types', `Mismatched types for coalesce (${maybeNull.type}, ${whenNull.type})`);
         }
+        const srcForType = maybeNull.type === 'error' ? whenNull : maybeNull;
         return {
-            ...whenNull,
-            dataType: maybeNull.dataType === 'error' ? whenNull.dataType : maybeNull.dataType,
+            ...srcForType,
             expressionType: (0, model_1.maxExpressionType)(maybeNull.expressionType, whenNull.expressionType),
             value: {
                 node: 'coalesce',

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

@@ -21,21 +21,44 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprLegacyIn = exports.ExprEquality = exports.ExprCompare = void 0;
 const model_1 = require("../../../model");
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 const expression_def_1 = require("../types/expression-def");
 const binary_boolean_1 = require("./binary-boolean");
 const compareTypes = {
-    '~': [fragtype_utils_1.FT.stringT],
-    '!~': [fragtype_utils_1.FT.stringT],
-    '<': [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
-    '<=': [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
-    '=': [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
-    '!=': [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
-    '>=': [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
-    '>': [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
+    '~': [TDU.stringT],
+    '!~': [TDU.stringT],
+    '<': [TDU.numberT, TDU.stringT, TDU.dateT, TDU.timestampT],
+    '<=': [TDU.numberT, TDU.stringT, TDU.dateT, TDU.timestampT],
+    '=': [TDU.numberT, TDU.stringT, TDU.dateT, TDU.timestampT],
+    '!=': [TDU.numberT, TDU.stringT, TDU.dateT, TDU.timestampT],
+    '>=': [TDU.numberT, TDU.stringT, TDU.dateT, TDU.timestampT],
+    '>': [TDU.numberT, TDU.stringT, TDU.dateT, TDU.timestampT],
 };
 class ExprCompare extends binary_boolean_1.BinaryBoolean {
     constructor(left, op, right) {
@@ -86,7 +109,7 @@ class ExprLegacyIn extends expression_def_1.ExpressionDef {
             return choice.value;
         });
         return {
-            dataType: 'boolean',
+            type: 'boolean',
             expressionType,
             evalSpace,
             value: {

package/dist/lang/ast/expressions/expr-count-distinct.d.ts

@@ -1,6 +1,8 @@
 import { ExprAggregateFunction } from './expr-aggregate-function';
 import { ExpressionDef } from '../types/expression-def';
+import { ExprValue } from '../types/expr-value';
 export declare class ExprCountDistinct extends ExprAggregateFunction {
     legalChildTypes: import("../../..").TypeDesc[];
     constructor(expr: ExpressionDef);
+    returns(ev: ExprValue): ExprValue;
 }

package/dist/lang/ast/expressions/expr-count-distinct.js

@@ -21,14 +21,46 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprCountDistinct = void 0;
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 const expr_aggregate_function_1 = require("./expr-aggregate-function");
 class ExprCountDistinct extends expr_aggregate_function_1.ExprAggregateFunction {
     constructor(expr) {
         super('distinct', expr);
-        this.legalChildTypes = [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT];
+        this.legalChildTypes = [TDU.numberT, TDU.stringT, TDU.dateT, TDU.timestampT];
+    }
+    returns(ev) {
+        return {
+            type: 'number',
+            numberType: 'integer',
+            evalSpace: ev.evalSpace,
+            expressionType: 'aggregate',
+            value: ev.value,
+        };
     }
 }
 exports.ExprCountDistinct = ExprCountDistinct;

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

@@ -7,5 +7,6 @@ export declare class ExprCount extends ExprAggregateFunction {
     elementType: string;
     constructor(source?: FieldReference | undefined);
     defaultFieldName(): string | undefined;
+    returns(ev: ExprValue): ExprValue;
     getExpression(_fs: FieldSpace): ExprValue;
 }

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

@@ -37,6 +37,15 @@ class ExprCount extends expr_aggregate_function_1.ExprAggregateFunction {
         }
         return undefined;
     }
+    returns(ev) {
+        return {
+            type: 'number',
+            numberType: 'integer',
+            evalSpace: ev.evalSpace,
+            expressionType: 'aggregate',
+            value: ev.value,
+        };
+    }
     getExpression(_fs) {
         const ret = {
             node: 'aggregate',
@@ -47,7 +56,8 @@ class ExprCount extends expr_aggregate_function_1.ExprAggregateFunction {
             ret.structPath = this.source.path;
         }
         return {
-            dataType: 'number',
+            type: 'number',
+            numberType: 'integer',
             expressionType: 'aggregate',
             value: ret,
             evalSpace: 'output',

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

@@ -1,4 +1,4 @@
-import { FieldValueType } from '../../../model/malloy_types';
+import { CastType } from '../../../model/malloy_types';
 import { FieldReference } from '../query-items/field-references';
 import { FunctionOrdering } from './function-ordering';
 import { Limit } from '../query-properties/limit';
@@ -10,10 +10,10 @@ export declare class ExprFunc extends ExpressionDef {
     readonly name: string;
     readonly args: ExpressionDef[];
     readonly isRaw: boolean;
-    readonly rawType: FieldValueType | undefined;
+    readonly rawType: CastType | undefined;
     readonly source?: FieldReference | undefined;
     elementType: string;
-    constructor(name: string, args: ExpressionDef[], isRaw: boolean, rawType: FieldValueType | undefined, source?: FieldReference | undefined);
+    constructor(name: string, args: ExpressionDef[], isRaw: boolean, rawType: CastType | undefined, source?: FieldReference | undefined);
     canSupportPartitionBy(): boolean;
     canSupportOrderBy(): boolean;
     canSupportLimit(): boolean;

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

@@ -21,6 +21,29 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprFunc = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
@@ -30,6 +53,7 @@ const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const field_space_1 = require("../types/field-space");
 const utils_1 = require("../../../model/utils");
+const TDU = __importStar(require("../typedesc-utils"));
 class ExprFunc extends expression_def_1.ExpressionDef {
     constructor(name, args, isRaw, rawType, source) {
         super({ args: args });
@@ -86,14 +110,16 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                     funcCall.push(',');
                 }
                 else {
-                    collectType = expr.dataType;
+                    if ((0, malloy_types_1.isCastType)(expr.type)) {
+                        collectType = expr.type;
+                    }
                 }
                 funcCall.push(expr.value);
             }
             funcCall.push(')');
             const dataType = (_b = (_a = this.rawType) !== null && _a !== void 0 ? _a : collectType) !== null && _b !== void 0 ? _b : 'number';
             return (0, expr_value_1.computedExprValue)({
-                dataType,
+                dataType: { type: dataType },
                 value: (0, utils_1.composeSQLExpr)(funcCall),
                 from: argExprsWithoutImplicit,
             });
@@ -112,9 +138,9 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             const sourceFoot = lookup.found;
             if (sourceFoot) {
                 const footType = sourceFoot.typeDesc();
-                if ((0, malloy_types_1.isAtomicFieldType)(footType.dataType)) {
+                if ((0, malloy_types_1.isAtomicFieldType)(footType.type)) {
                     implicitExpr = {
-                        dataType: footType.dataType,
+                        ...TDU.atomicDef(footType),
                         expressionType: footType.expressionType,
                         value: { node: 'field', path: this.source.path },
                         evalSpace: footType.evalSpace,
@@ -123,7 +149,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                 }
                 else {
                     if (!(sourceFoot instanceof struct_space_field_base_1.StructSpaceFieldBase)) {
-                        return this.loggedErrorExpr('invalid-aggregate-source', `Aggregate source cannot be a ${footType.dataType}`);
+                        return this.loggedErrorExpr('invalid-aggregate-source', `Aggregate source cannot be a ${footType.type}`);
                     }
                 }
             }
@@ -139,7 +165,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         const result = findOverload(func, argExprs);
         if (result === undefined) {
             return this.loggedErrorExpr('no-matching-function-overload', `No matching overload for function ${this.name}(${argExprs
-                .map(e => e.dataType)
+                .map(e => e.type)
                 .join(', ')})`);
         }
         const { overload, expressionTypeErrors, evalSpaceErrors, nullabilityErrors } = result;
@@ -177,7 +203,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         if (!(0, malloy_types_1.expressionIsAggregate)(overload.returnType.expressionType) &&
             this.source !== undefined) {
             return this.loggedErrorExpr('non-aggregate-function-with-source', `Cannot call function ${this.name}(${argExprs
-                .map(e => e.dataType)
+                .map(e => e.type)
                 .join(', ')}) with source`);
         }
         const frag = {
@@ -291,8 +317,8 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                 funcCall = (0, utils_1.composeSQLExpr)(expr);
             }
         }
-        if (type.dataType === 'any') {
-            return this.loggedErrorExpr('function-returns-any', `Invalid return type ${type.dataType} for function '${this.name}'`);
+        if (type.type === 'any') {
+            return this.loggedErrorExpr('function-returns-any', `Invalid return type ${type.type} for function '${this.name}'`);
         }
         const maxEvalSpace = (0, malloy_types_1.mergeEvalSpaces)(...argExprs.map(e => e.evalSpace));
         // If the merged eval space of all args is constant, the result is constant.
@@ -308,7 +334,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         // TODO consider if I can use `computedExprValue` here...
         // seems like the rules for the evalSpace is a bit different from normal though
         return {
-            dataType: type.dataType,
+            ...TDU.atomicDef(type),
             expressionType,
             value: funcCall,
             evalSpace,
@@ -334,13 +360,13 @@ function findOverload(func, args) {
             const argOk = param.allowedTypes.some(paramT => {
                 // Check whether types match (allowing for nullability errors, expression type errors,
                 // eval space errors, and unknown types due to prior errors in args)
-                const dataTypeMatch = paramT.dataType === arg.dataType ||
-                    paramT.dataType === 'any' ||
+                const dataTypeMatch = malloy_types_1.TD.eq(paramT, arg) ||
+                    paramT.type === 'any' ||
                     // TODO We should consider whether `nulls` should always be allowed. It probably
                     // does not make sense to limit function calls to not allow nulls, since have
                     // so little control over nullability.
-                    arg.dataType === 'null' ||
-                    arg.dataType === 'error';
+                    arg.type === 'null' ||
+                    arg.type === 'error';
                 // Check expression type errors
                 if (paramT.expressionType) {
                     const expressionTypeMatch = (0, malloy_types_1.isExpressionTypeLEQ)(arg.expressionType, paramT.expressionType);
@@ -374,7 +400,7 @@ function findOverload(func, args) {
                 // Check nullability errors. For now we only require that literal arguments must be
                 // non-null, but in the future we may allow parameters to say whether they can accept literal
                 // nulls.
-                if (paramT.evalSpace === 'literal' && arg.dataType === 'null') {
+                if (paramT.evalSpace === 'literal' && arg.type === 'null') {
                     nullabilityErrors.push({
                         argIndex,
                         param,

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

@@ -21,11 +21,34 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprGranularTime = 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 TDU = __importStar(require("../typedesc-utils"));
 const time_utils_1 = require("../time-utils");
 const expression_def_1 = require("../types/expression-def");
 const expr_time_1 = require("./expr-time");
@@ -44,7 +67,7 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
         this.units = units;
         this.truncate = truncate;
         this.elementType = 'granularTime';
-        this.legalChildTypes = [fragtype_utils_1.FT.timestampT, fragtype_utils_1.FT.dateT];
+        this.legalChildTypes = [TDU.timestampT, TDU.dateT];
     }
     granular() {
         return true;
@@ -52,32 +75,31 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
     getExpression(fs) {
         const timeframe = this.units;
         const exprVal = this.expr.getExpression(fs);
-        if ((0, malloy_types_1.isTemporalField)(exprVal.dataType)) {
+        if (malloy_types_1.TD.isTemporal(exprVal)) {
             const tsVal = {
                 ...exprVal,
-                dataType: exprVal.dataType,
                 timeframe: timeframe,
             };
             if (this.truncate) {
                 tsVal.value = {
                     node: 'trunc',
-                    e: (0, malloy_types_1.mkTemporal)(exprVal.value, exprVal.dataType),
+                    e: (0, malloy_types_1.mkTemporal)(exprVal.value, exprVal.type),
                     units: timeframe,
                 };
             }
             return tsVal;
         }
-        if (exprVal.dataType !== 'error') {
-            this.logError('unsupported-type-for-time-truncation', `Cannot do time truncation on type '${exprVal.dataType}'`);
+        if (exprVal.type !== 'error') {
+            this.logError('unsupported-type-for-time-truncation', `Cannot do time truncation on type '${exprVal.type}'`);
         }
-        const returnType = exprVal.dataType === 'error'
-            ? (0, malloy_types_1.isDateUnit)(timeframe)
+        const returnType = { ...exprVal };
+        if (exprVal.type === 'error') {
+            returnType.type = (0, malloy_types_1.isDateUnit)(timeframe)
                 ? 'date'
-                : 'timestamp'
-            : exprVal.dataType;
+                : 'timestamp';
+        }
         return {
-            ...exprVal,
-            dataType: returnType,
+            ...returnType,
             value: (0, ast_utils_1.errorFor)('granularity typecheck').value,
             evalSpace: 'constant',
         };
@@ -100,7 +122,7 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
     toRange(fs) {
         const begin = this.getExpression(fs);
         const one = { node: 'numberLiteral', literal: '1' };
-        if (begin.dataType === 'timestamp') {
+        if (begin.type === 'timestamp') {
             const beginTS = expr_time_1.ExprTime.fromValue('timestamp', begin);
             const endTS = new expr_time_1.ExprTime('timestamp', (0, time_utils_1.timeOffset)('timestamp', begin.value, '+', one, this.units), [begin]);
             return new range_1.Range(beginTS, endTS);

package/dist/lang/ast/expressions/expr-logical-op.js

@@ -21,15 +21,38 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprLogicalOp = void 0;
 const binary_boolean_1 = require("./binary-boolean");
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 class ExprLogicalOp extends binary_boolean_1.BinaryBoolean {
     constructor() {
         super(...arguments);
         this.elementType = 'logical operator';
-        this.legalChildTypes = [fragtype_utils_1.FT.boolT, fragtype_utils_1.FT.aggregateBoolT];
+        this.legalChildTypes = [TDU.boolT, TDU.aggregateBoolT];
     }
 }
 exports.ExprLogicalOp = ExprLogicalOp;

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

@@ -1,9 +1,8 @@
-import { ExprValue } from '../types/expr-value';
-import { FieldValueType } from '../../../model';
 import { ExprAggregateFunction } from './expr-aggregate-function';
 import { ExpressionDef } from '../types/expression-def';
+import { ExprValue } from '../types/expr-value';
 export declare class ExprMax extends ExprAggregateFunction {
-    legalChildTypes: import("../../../model").TypeDesc[];
+    legalChildTypes: import("../../..").TypeDesc[];
     constructor(expr: ExpressionDef);
-    returns(forExpression: ExprValue): FieldValueType;
+    returns(ev: ExprValue): ExprValue;
 }

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

@@ -21,17 +21,40 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprMax = void 0;
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 const expr_aggregate_function_1 = require("./expr-aggregate-function");
 class ExprMax extends expr_aggregate_function_1.ExprAggregateFunction {
     constructor(expr) {
         super('max', expr);
-        this.legalChildTypes = [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT];
+        this.legalChildTypes = [TDU.numberT, TDU.stringT, TDU.dateT, TDU.timestampT];
     }
-    returns(forExpression) {
-        return forExpression.dataType;
+    returns(ev) {
+        return ev;
     }
 }
 exports.ExprMax = ExprMax;

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

@@ -1,9 +1,8 @@
-import { ExprValue } from '../types/expr-value';
-import { FieldValueType } from '../../../model';
 import { ExprAggregateFunction } from './expr-aggregate-function';
 import { ExpressionDef } from '../types/expression-def';
+import { ExprValue } from '../types/expr-value';
 export declare class ExprMin extends ExprAggregateFunction {
-    legalChildTypes: import("../../../model").TypeDesc[];
+    legalChildTypes: import("../../..").TypeDesc[];
     constructor(expr: ExpressionDef);
-    returns(forExpression: ExprValue): FieldValueType;
+    returns(ev: ExprValue): ExprValue;
 }

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

@@ -21,17 +21,40 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprMin = void 0;
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 const expr_aggregate_function_1 = require("./expr-aggregate-function");
 class ExprMin extends expr_aggregate_function_1.ExprAggregateFunction {
     constructor(expr) {
         super('min', expr);
-        this.legalChildTypes = [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT];
+        this.legalChildTypes = [TDU.numberT, TDU.stringT, TDU.dateT, TDU.timestampT];
     }
-    returns(forExpression) {
-        return forExpression.dataType;
+    returns(ev) {
+        return ev;
     }
 }
 exports.ExprMin = ExprMin;