@malloydata/malloy 0.0.22-dev230126015148 → 0.0.22-dev230202171033

package/dist/lang/test/test-translator.d.ts

@@ -1,5 +1,7 @@
 import { StructDef, NamedModelObject, ModelDef, Query, FieldDef, PipeSegment, TurtleDef, DocumentLocation } from "../../model/malloy_types";
-import { MalloyElement, ModelEntry, NameSpace } from "../ast";
+import { MalloyElement } from "../ast";
+import { NameSpace } from "../ast/types/name-space";
+import { ModelEntry } from "../ast/types/model-entry";
 import { MalloyTranslator, TranslateResponse } from "../parse-malloy";
 export declare function pretty(thing: any): string;
 export declare const aTableDef: StructDef;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.22-dev230126015148",
+  "version": "0.0.22-dev230202171033",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/lang/ast/apply-expr.d.ts

@@ -1,3 +0,0 @@
-import { Expr } from "../../model/malloy_types";
-import { Equality } from "./ast-types";
-export declare function nullsafeNot(expr: Expr, op?: Equality): Expr;

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

@@ -1,206 +0,0 @@
-import { By, ExpressionType } from "../../model/malloy_types";
-import { BinaryBoolean, ExpressionDef, ExprCompare, FieldName, FieldReference, FieldSpace, Filter, MalloyElement } from "./ast-main";
-import { ExprValue, FieldValueType, FragType } from "./ast-types";
-export declare class ExprString extends ExpressionDef {
-    elementType: string;
-    value: string;
-    constructor(src: string);
-    getExpression(_fs: FieldSpace): ExprValue;
-}
-export declare class ExprNumber extends ExpressionDef {
-    readonly n: string;
-    elementType: string;
-    constructor(n: string);
-    getExpression(_fs: FieldSpace): ExprValue;
-    constantExpression(): ExprValue;
-}
-export declare class ExprRegEx extends ExpressionDef {
-    readonly regex: string;
-    elementType: string;
-    constructor(regex: string);
-    getExpression(): ExprValue;
-}
-declare abstract class Unary extends ExpressionDef {
-    readonly expr: ExpressionDef;
-    constructor(expr: ExpressionDef);
-}
-export declare class ExprNot extends Unary {
-    elementType: string;
-    legalChildTypes: FragType[];
-    constructor(expr: ExpressionDef);
-    getExpression(fs: FieldSpace): ExprValue;
-}
-export declare class Boolean extends ExpressionDef {
-    readonly value: "true" | "false";
-    elementType: string;
-    constructor(value: "true" | "false");
-    getExpression(): ExprValue;
-}
-export declare class ExprLogicalOp extends BinaryBoolean<"and" | "or"> {
-    elementType: string;
-    legalChildTypes: (FragType | {
-        aggregate: boolean;
-        dataType: FieldValueType;
-        expressionType: ExpressionType;
-    })[];
-}
-export declare class ExprIdReference extends ExpressionDef {
-    readonly fieldReference: FieldReference;
-    elementType: string;
-    constructor(fieldReference: FieldReference);
-    get refString(): string;
-    getExpression(fs: FieldSpace): ExprValue;
-    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
-}
-export declare class ExprNULL extends ExpressionDef {
-    elementType: string;
-    getExpression(): ExprValue;
-}
-export declare class ExprParens extends ExpressionDef {
-    readonly expr: ExpressionDef;
-    elementType: string;
-    constructor(expr: ExpressionDef);
-    requestExpression(fs: FieldSpace): ExprValue | undefined;
-    getExpression(fs: FieldSpace): ExprValue;
-}
-export declare class ExprMinus extends ExpressionDef {
-    readonly expr: ExpressionDef;
-    elementType: string;
-    constructor(expr: ExpressionDef);
-    getExpression(fs: FieldSpace): ExprValue;
-}
-export declare abstract class BinaryNumeric<opType extends string> extends ExpressionDef {
-    readonly left: ExpressionDef;
-    readonly op: opType;
-    readonly right: ExpressionDef;
-    elementType: string;
-    constructor(left: ExpressionDef, op: opType, right: ExpressionDef);
-    getExpression(fs: FieldSpace): ExprValue;
-}
-export declare class ExprAddSub extends BinaryNumeric<"+" | "-"> {
-    elementType: string;
-}
-export declare class ExprMulDiv extends BinaryNumeric<"*" | "/" | "%"> {
-    elementType: string;
-}
-export declare class ExprAlternationTree extends BinaryBoolean<"|" | "&"> {
-    elementType: string;
-    constructor(left: ExpressionDef, op: "|" | "&", right: ExpressionDef);
-    apply(fs: FieldSpace, applyOp: string, expr: ExpressionDef): ExprValue;
-    requestExpression(_fs: FieldSpace): ExprValue | undefined;
-    getExpression(_fs: FieldSpace): ExprValue;
-}
-declare abstract class ExprAggregateFunction extends ExpressionDef {
-    readonly func: string;
-    elementType: string;
-    source?: FieldReference;
-    expr?: ExpressionDef;
-    legalChildTypes: FragType[];
-    constructor(func: string, expr?: ExpressionDef);
-    returns(_forExpression: ExprValue): FieldValueType;
-    getExpression(fs: FieldSpace): ExprValue;
-}
-export declare class ExprMin extends ExprAggregateFunction {
-    legalChildTypes: FragType[];
-    constructor(expr: ExpressionDef);
-    returns(forExpression: ExprValue): FieldValueType;
-}
-export declare class ExprMax extends ExprAggregateFunction {
-    legalChildTypes: FragType[];
-    constructor(expr: ExpressionDef);
-    returns(forExpression: ExprValue): FieldValueType;
-}
-export declare class ExprCountDistinct extends ExprAggregateFunction {
-    legalChildTypes: FragType[];
-    constructor(expr: ExpressionDef);
-}
-declare abstract class ExprAsymmetric extends ExprAggregateFunction {
-    readonly func: "sum" | "avg";
-    readonly expr: ExpressionDef | undefined;
-    readonly source?: FieldReference | undefined;
-    constructor(func: "sum" | "avg", expr: ExpressionDef | undefined, source?: FieldReference | undefined);
-    defaultFieldName(): undefined | string;
-}
-export declare class ExprCount extends ExprAggregateFunction {
-    readonly source?: FieldReference | undefined;
-    elementType: string;
-    constructor(source?: FieldReference | undefined);
-    defaultFieldName(): string | undefined;
-    getExpression(_fs: FieldSpace): ExprValue;
-}
-export declare class ExprAvg extends ExprAsymmetric {
-    constructor(expr: ExpressionDef | undefined, source?: FieldReference);
-}
-export declare class ExprSum extends ExprAsymmetric {
-    constructor(expr: ExpressionDef | undefined, source?: FieldReference);
-}
-export declare class ExprUngroup extends ExpressionDef {
-    readonly control: "all" | "exclude";
-    readonly expr: ExpressionDef;
-    readonly fields: FieldName[];
-    legalChildTypes: FragType[];
-    elementType: string;
-    constructor(control: "all" | "exclude", expr: ExpressionDef, fields: FieldName[]);
-    returns(_forExpression: ExprValue): FieldValueType;
-    getExpression(fs: FieldSpace): ExprValue;
-}
-export declare class WhenClause extends ExpressionDef {
-    readonly whenThis: ExpressionDef;
-    readonly thenThis: ExpressionDef;
-    elementType: string;
-    constructor(whenThis: ExpressionDef, thenThis: ExpressionDef);
-    getExpression(_fs: FieldSpace): ExprValue;
-}
-export declare class ExprCase extends ExpressionDef {
-    readonly when: WhenClause[];
-    readonly elseClause?: ExpressionDef | undefined;
-    elementType: string;
-    constructor(when: WhenClause[], elseClause?: ExpressionDef | undefined);
-    getExpression(fs: FieldSpace): ExprValue;
-}
-export declare class ExprFilter extends ExpressionDef {
-    readonly expr: ExpressionDef;
-    readonly filter: Filter;
-    elementType: string;
-    legalChildTypes: FragType[];
-    constructor(expr: ExpressionDef, filter: Filter);
-    getExpression(fs: FieldSpace): ExprValue;
-}
-declare type CastType = "string" | "number" | "boolean" | "date" | "timestamp";
-export declare function isCastType(t: string): t is CastType;
-export declare class ExprCast extends ExpressionDef {
-    readonly expr: ExpressionDef;
-    readonly castType: CastType;
-    readonly safe: boolean;
-    elementType: string;
-    constructor(expr: ExpressionDef, castType: CastType, safe?: boolean);
-    getExpression(fs: FieldSpace): ExprValue;
-}
-export declare class TopBy extends MalloyElement {
-    readonly by: string | ExpressionDef;
-    elementType: string;
-    constructor(by: string | ExpressionDef);
-    getBy(fs: FieldSpace): By;
-}
-export declare class PickWhen extends MalloyElement {
-    readonly pick: ExpressionDef | undefined;
-    readonly when: ExpressionDef;
-    elementType: string;
-    constructor(pick: ExpressionDef | undefined, when: ExpressionDef);
-}
-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 Apply extends ExprCompare {
-    readonly left: ExpressionDef;
-    readonly right: ExpressionDef;
-    elementType: string;
-    constructor(left: ExpressionDef, right: ExpressionDef);
-}
-export {};