@malloydata/malloy 0.0.204 → 0.0.205-dev241028173215

package/dist/model/malloy_types.d.ts

@@ -242,11 +242,11 @@ export interface Expression {
     code?: string;
 }
 type ConstantExpr = Expr;
-export interface Parameter {
-    value: ConstantExpr | null;
+interface ParameterInfo {
     name: string;
-    type: AtomicFieldType;
+    value: ConstantExpr | null;
 }
+export type Parameter = AtomicTypeDef & ParameterInfo;
 export type Argument = Parameter;
 export declare function paramHasValue(p: Parameter): boolean;
 export interface DocumentRange {
@@ -349,9 +349,6 @@ export declare function isCastType(s: string): s is CastType;
 export interface FieldBase extends NamedObject, Expression, ResultMetadata {
     annotation?: Annotation;
 }
-interface FieldAtomicBase extends FieldBase {
-    type: AtomicFieldType;
-}
 export declare function fieldIsIntrinsic(f: FieldDef): boolean;
 export interface StringTypeDef {
     type: 'string';
@@ -611,28 +608,28 @@ export type SourceDef = TableSourceDef | SQLSourceDef | QuerySourceDef | QueryRe
 export declare function isBaseTable(def: StructDef): def is SourceDef;
 export declare function isScalarArray(def: FieldDef | StructDef): boolean;
 export type StructDef = SourceDef | RecordFieldDef | ArrayDef;
-export type ExpressionValueType = AtomicFieldType | 'null' | 'duration' | 'any' | 'regular expression';
-export type FieldValueType = ExpressionValueType | 'turtle' | JoinFieldTypes;
-export interface ExpressionTypeDesc {
-    dataType: FieldValueType;
+export type NonAtomicType = Exclude<JoinElementType, 'array' | 'record'> | 'turtle' | 'null' | 'duration' | 'any' | 'regular expression';
+export interface NonAtomicTypeDef {
+    type: NonAtomicType;
+}
+export type ExpressionValueType = AtomicFieldType | NonAtomicType;
+export type ExpressionValueTypeDef = AtomicTypeDef | NonAtomicTypeDef;
+export type LeafExpressionType = Exclude<ExpressionValueType, JoinElementType | 'turtle'>;
+export type TypeInfo = {
     expressionType: ExpressionType;
-    rawType?: string;
     evalSpace: EvalSpace;
-}
-export interface FunctionParamTypeDesc {
-    dataType: FieldValueType;
+};
+export type TypeDesc = ExpressionValueTypeDef & TypeInfo;
+export type FunctionParamType = ExpressionValueTypeDef | {
+    type: 'any';
+};
+export type FunctionParamTypeDesc = FunctionParamType & {
     expressionType: ExpressionType | undefined;
     evalSpace: EvalSpace;
-}
+};
 export type EvalSpace = 'constant' | 'input' | 'output' | 'literal';
 export declare function isLiteral(evalSpace: EvalSpace): boolean;
 export declare function mergeEvalSpaces(...evalSpaces: EvalSpace[]): EvalSpace;
-export interface TypeDesc {
-    dataType: FieldValueType;
-    expressionType: ExpressionType;
-    rawType?: string;
-    evalSpace: EvalSpace;
-}
 export interface FunctionParameterDef {
     name: string;
     allowedTypes: FunctionParamTypeDesc[];
@@ -666,10 +663,11 @@ export interface ConnectionDef extends NamedObject {
 export type TemporalTypeDef = DateTypeDef | TimestampTypeDef;
 export type LeafAtomicTypeDef = StringTypeDef | TemporalTypeDef | NumberTypeDef | BooleanTypeDef | JSONTypeDef | NativeUnsupportedTypeDef | ErrorTypeDef;
 export type AtomicTypeDef = LeafAtomicTypeDef | ArrayTypeDef | RecordTypeDef;
-export type LeafAtomicDef = LeafAtomicTypeDef & FieldAtomicBase;
-export type AtomicFieldDef = AtomicTypeDef & FieldAtomicBase;
+export type LeafAtomicDef = LeafAtomicTypeDef & FieldBase;
+export type AtomicFieldDef = AtomicTypeDef & FieldBase;
 export declare function isLeafAtomic(fd: FieldDef | QueryFieldDef | AtomicTypeDef): fd is LeafAtomicDef;
 export type FieldDef = AtomicFieldDef | JoinFieldDef | TurtleDef;
+export type FieldDefType = AtomicFieldType | 'turtle' | JoinElementType;
 export interface RefToField {
     type: 'fieldref';
     path: string[];
@@ -789,10 +787,14 @@ export interface PrepareResultOptions {
     replaceMaterializedReferences?: boolean;
     materializedTablePrefix?: string;
 }
-type UTD = AtomicTypeDef | undefined;
+type UTD = AtomicTypeDef | FunctionParamTypeDesc | undefined;
+/**
+ * A set of utilities for asking questions TypeDef/TypeDesc
+ * (which is OK because TypeDesc is an extension of a TypeDef)
+ */
 export declare const TD: {
-    isA: (td: UTD, ...tList: string[]) => boolean | undefined;
-    notA: (td: UTD, ...tList: string[]) => boolean | undefined;
+    isAtomic(td: UTD): td is AtomicTypeDef;
+    isLeafAtomic(td: UTD): td is LeafAtomicTypeDef;
     isString: (td: UTD) => td is StringTypeDef;
     isNumber: (td: UTD) => td is NumberTypeDef;
     isBoolean: (td: UTD) => td is BooleanTypeDef;
@@ -800,12 +802,8 @@ export declare const TD: {
     isSQL: (td: UTD) => td is NativeUnsupportedTypeDef;
     isDate: (td: UTD) => td is DateTypeDef;
     isTimestamp: (td: UTD) => td is TimestampTypeDef;
+    isTemporal(td: UTD): td is TimestampTypeDef;
     isError: (td: UTD) => td is ErrorTypeDef;
-    eq: (x: UTD, y: UTD) => boolean;
-    timestamp: () => TimestampTypeDef;
-    date: () => DateTypeDef;
-    string: () => StringTypeDef;
-    number: () => NumberTypeDef;
-    error: () => ErrorTypeDef;
+    eq(x: UTD, y: UTD): boolean;
 };
 export {};

package/dist/model/malloy_types.js

@@ -399,18 +399,29 @@ function isValueDate(value, field) {
     return field.type === 'date';
 }
 exports.isValueDate = isValueDate;
+/**
+ * A set of utilities for asking questions TypeDef/TypeDesc
+ * (which is OK because TypeDesc is an extension of a TypeDef)
+ */
 exports.TD = {
-    isA: (td, ...tList) => td && tList.includes(td.type),
-    notA: (td, ...tList) => td && !tList.includes(td.type),
-    isString: (td) => td !== undefined && td.type === 'string',
-    isNumber: (td) => td !== undefined && td.type === 'number',
-    isBoolean: (td) => td !== undefined && td.type === 'boolean',
-    isJSON: (td) => td !== undefined && td.type === 'json',
-    isSQL: (td) => td !== undefined && td.type === 'sql native',
-    isDate: (td) => td !== undefined && td.type === 'date',
-    isTimestamp: (td) => td !== undefined && td.type === 'timestamp',
-    isError: (td) => td !== undefined && td.type === 'error',
-    eq: function (x, y) {
+    isAtomic(td) {
+        return td !== undefined && isAtomicFieldType(td.type);
+    },
+    isLeafAtomic(td) {
+        return td !== undefined && isLeafAtomic({ type: td.type });
+    },
+    isString: (td) => (td === null || td === void 0 ? void 0 : td.type) === 'string',
+    isNumber: (td) => (td === null || td === void 0 ? void 0 : td.type) === 'number',
+    isBoolean: (td) => (td === null || td === void 0 ? void 0 : td.type) === 'boolean',
+    isJSON: (td) => (td === null || td === void 0 ? void 0 : td.type) === 'json',
+    isSQL: (td) => (td === null || td === void 0 ? void 0 : td.type) === 'sql native',
+    isDate: (td) => (td === null || td === void 0 ? void 0 : td.type) === 'date',
+    isTimestamp: (td) => (td === null || td === void 0 ? void 0 : td.type) === 'timestamp',
+    isTemporal(td) {
+        return (td === null || td === void 0 ? void 0 : td.type) === 'timestamp' || (td === null || td === void 0 ? void 0 : td.type) === 'date';
+    },
+    isError: (td) => (td === null || td === void 0 ? void 0 : td.type) === 'error',
+    eq(x, y) {
         if (x === undefined || y === undefined) {
             return false;
         }
@@ -445,13 +456,11 @@ exports.TD = {
         else if (x.type === 'record' && y.type === 'record') {
             return checkFields(x, y);
         }
+        if (x.type === 'sql native' && y.type === 'sql native') {
+            return x.rawType !== undefined && x.rawType === y.rawType;
+        }
         return x.type === y.type;
     },
-    timestamp: () => ({ type: 'timestamp' }),
-    date: () => ({ type: 'date' }),
-    string: () => ({ type: 'string' }),
-    number: () => ({ type: 'number', numberType: 'float' }),
-    error: () => ({ type: 'error' }),
 };
 // clang-format on
 //# sourceMappingURL=malloy_types.js.map

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.204";
+export declare const MALLOY_VERSION = "0.0.205";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.204';
+exports.MALLOY_VERSION = '0.0.205';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.204",
+  "version": "0.0.205-dev241028173215",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",

package/dist/lang/ast/fragtype-utils.d.ts

@@ -1,46 +0,0 @@
-import { TypeDesc } from '../../model';
-/**
- * Collects functions which operate on fragtype compatible objects
- */
-export declare class FT {
-    /**
-     * Checks if a given type is in a list
-     * @param check The type to check (can be undefined)
-     * @param from List of types which are OK
-     */
-    static in(check: TypeDesc | undefined, from: TypeDesc[]): boolean;
-    /**
-     * Checks if a possibly undefined candidate matches a type
-     * @param good The real type
-     * @param checkThis The possibly undefined candidate
-     */
-    static eq(good: TypeDesc, checkThis: TypeDesc | undefined): boolean;
-    /**
-     * Checks if a given type is in a list, ignoring aggregate
-     * @param check The type to check (can be undefined)
-     * @param from List of types which are OK
-     */
-    static typeIn(check: TypeDesc | undefined, from: TypeDesc[]): boolean;
-    /**
-     * Checks if the base types, ignoring aggregate, are equal
-     * @param left Left type
-     * @param right Right type
-     * @param nullOk True if a NULL is an acceptable match
-     */
-    static typeEq(left: TypeDesc, right: TypeDesc, nullOk?: boolean, errorOk?: boolean): boolean;
-    /**
-     *
-     * For error messages, returns a comma seperated list of readable names
-     * for a list of types.
-     * @param types List of type or objects with types
-     */
-    static inspect(...types: (TypeDesc | undefined)[]): string;
-    static nullT: TypeDesc;
-    static numberT: TypeDesc;
-    static stringT: TypeDesc;
-    static dateT: TypeDesc;
-    static timestampT: TypeDesc;
-    static boolT: TypeDesc;
-    static anyAtomicT: TypeDesc[];
-    static aggregateBoolT: TypeDesc;
-}

package/dist/lang/ast/fragtype-utils.js

@@ -1,115 +0,0 @@
-"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.FT = void 0;
-const model_1 = require("../../model");
-function mkFragType(dataType, expressionType = 'scalar', evalSpace = 'constant') {
-    return { dataType, expressionType, evalSpace };
-}
-/**
- * Collects functions which operate on fragtype compatible objects
- */
-class FT {
-    /**
-     * Checks if a given type is in a list
-     * @param check The type to check (can be undefined)
-     * @param from List of types which are OK
-     */
-    static in(check, from) {
-        if (check) {
-            const found = from.find(okType => FT.eq(okType, check));
-            return found !== undefined;
-        }
-        return false;
-    }
-    /**
-     * Checks if a possibly undefined candidate matches a type
-     * @param good The real type
-     * @param checkThis The possibly undefined candidate
-     */
-    static eq(good, checkThis) {
-        return (checkThis !== undefined &&
-            good.dataType === checkThis.dataType &&
-            good.expressionType === checkThis.expressionType);
-    }
-    /**
-     * Checks if a given type is in a list, ignoring aggregate
-     * @param check The type to check (can be undefined)
-     * @param from List of types which are OK
-     */
-    static typeIn(check, from) {
-        if (check) {
-            const found = from.find(okType => FT.typeEq(okType, check));
-            return found !== undefined;
-        }
-        return false;
-    }
-    /**
-     * Checks if the base types, ignoring aggregate, are equal
-     * @param left Left type
-     * @param right Right type
-     * @param nullOk True if a NULL is an acceptable match
-     */
-    static typeEq(left, right, nullOk = false, errorOk = true) {
-        const maybeEq = left.dataType === right.dataType;
-        const nullEq = nullOk && (left.dataType === 'null' || right.dataType === 'null');
-        const errorEq = errorOk && (left.dataType === 'error' || right.dataType === 'error');
-        return maybeEq || nullEq || errorEq;
-    }
-    /**
-     *
-     * For error messages, returns a comma seperated list of readable names
-     * for a list of types.
-     * @param types List of type or objects with types
-     */
-    static inspect(...types) {
-        const strings = types.map(type => {
-            if (type) {
-                let inspected = type.dataType;
-                if (!(0, model_1.expressionIsScalar)(type.expressionType)) {
-                    inspected = `${type.expressionType} ${inspected}`;
-                }
-                return inspected;
-            }
-            return 'undefined';
-        });
-        return strings.join(',');
-    }
-}
-exports.FT = FT;
-FT.nullT = mkFragType('null');
-FT.numberT = mkFragType('number');
-FT.stringT = mkFragType('string');
-FT.dateT = mkFragType('date');
-FT.timestampT = mkFragType('timestamp');
-FT.boolT = mkFragType('boolean');
-FT.anyAtomicT = [
-    FT.numberT,
-    FT.stringT,
-    FT.dateT,
-    FT.timestampT,
-    FT.boolT,
-];
-FT.aggregateBoolT = mkFragType('boolean', 'aggregate');
-//# sourceMappingURL=fragtype-utils.js.map