@malloydata/malloy 0.0.1

package/dist/lang/lib/Malloy/MalloyVisitor.js

@@ -0,0 +1,4 @@
+"use strict";
+// Generated from Malloy.g4 by ANTLR 4.9.0-SNAPSHOT
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=MalloyVisitor.js.map

package/dist/lang/parse-log.d.ts

@@ -0,0 +1,27 @@
+import { DocumentLocation } from "../model/malloy_types";
+export declare type LogSeverity = "error" | "warn" | "debug";
+/**
+ * Default severity is "error"
+ */
+export interface LogMessage {
+    message: string;
+    at?: DocumentLocation;
+    severity?: LogSeverity;
+}
+export interface MessageLogger {
+    log(logMsg: LogMessage): void;
+    reset(): void;
+    getLog(): LogMessage[];
+    hasErrors(): boolean;
+    noErrors(): boolean;
+    empty(): boolean;
+}
+export declare class MessageLog implements MessageLogger {
+    private rawLog;
+    getLog(): LogMessage[];
+    log(logMsg: LogMessage): void;
+    reset(): void;
+    noErrors(): boolean;
+    hasErrors(): boolean;
+    empty(): boolean;
+}

package/dist/lang/parse-log.js

@@ -0,0 +1,41 @@
+"use strict";
+/*
+ * Copyright 2021 Google LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageLog = void 0;
+class MessageLog {
+    constructor() {
+        this.rawLog = [];
+    }
+    getLog() {
+        return this.rawLog;
+    }
+    log(logMsg) {
+        this.rawLog.push(logMsg);
+    }
+    reset() {
+        this.rawLog.length = 0;
+    }
+    noErrors() {
+        return !this.hasErrors();
+    }
+    hasErrors() {
+        const firstError = this.rawLog.find((l) => l.severity !== "warn");
+        return firstError !== undefined;
+    }
+    empty() {
+        return this.rawLog.length === 0;
+    }
+}
+exports.MessageLog = MessageLog;
+//# sourceMappingURL=parse-log.js.map

package/dist/lang/parse-malloy.d.ts

@@ -0,0 +1,245 @@
+import { Token, CommonTokenStream, ParserRuleContext, CodePointCharStream } from "antlr4ts";
+import type { ParseTree } from "antlr4ts/tree";
+import { Query, NamedStructDefs, StructDef, ModelDef, SQLBlock, DocumentReference, DocumentPosition, DocumentLocation, DocumentRange } from "../model/malloy_types";
+import * as ast from "./ast";
+import { LogMessage, MessageLog } from "./parse-log";
+import { Zone, ZoneData } from "./zone";
+import { DocumentSymbol } from "./parse-tree-walkers/document-symbol-walker";
+import { DocumentHighlight } from "./parse-tree-walkers/document-highlight-walker";
+import { DocumentCompletion } from "./parse-tree-walkers/document-completion-walker";
+import { DocumentHelpContext } from "./parse-tree-walkers/document-help-context-walker";
+import { ReferenceList } from "./reference-list";
+/**
+ * The translation interface is essentially a request/respone protocol, and
+ * this is the list of all the "protocol" messages.
+ */
+interface FinalResponse {
+    final: true;
+}
+interface ErrorResponse {
+    errors: LogMessage[];
+}
+declare type FatalResponse = FinalResponse & ErrorResponse;
+export interface NeedSchemaData {
+    tables: string[];
+}
+export interface NeedURLData {
+    urls: string[];
+}
+/**
+ * An SQL Block contains a unique key inside it, and we use that to
+ * reference and define blocks, since Zone really wants keys to be strings.
+ *
+ * If I had SQLBlocks when Zones were defined, this would not be
+ * a one off class, it would be Zone<keyType,valueType>
+ */
+export declare class SQLExploreZone extends Zone<StructDef> {
+    keyed: Record<string, SQLBlock>;
+    referenceBlock(from: ast.SQLStatement, at: DocumentLocation): void;
+    getUndefinedBlocks(): SQLBlock[] | undefined;
+}
+export interface NeedSQLStruct {
+    sqlStructs: SQLBlock[];
+}
+interface NeededData extends NeedURLData, NeedSchemaData, NeedSQLStruct {
+}
+export declare type DataRequestResponse = Partial<NeededData> | null;
+interface ASTData extends ErrorResponse, NeededData, FinalResponse {
+    ast: ast.MalloyElement;
+}
+declare type ASTResponse = Partial<ASTData>;
+interface Metadata extends NeededData, ErrorResponse, FinalResponse {
+    symbols: DocumentSymbol[];
+    highlights: DocumentHighlight[];
+}
+declare type MetadataResponse = Partial<Metadata>;
+interface Completions extends NeededData, ErrorResponse, FinalResponse {
+    completions: DocumentCompletion[];
+}
+declare type CompletionsResponse = Partial<Completions>;
+interface HelpContext extends NeededData, ErrorResponse, FinalResponse {
+    helpContext: DocumentHelpContext | undefined;
+}
+declare type HelpContextResponse = Partial<HelpContext>;
+interface TranslatedResponseData extends NeededData, ErrorResponse, FinalResponse {
+    translated: {
+        modelDef: ModelDef;
+        queryList: Query[];
+        sqlBlocks: SQLBlock[];
+    };
+}
+export declare type TranslateResponse = Partial<TranslatedResponseData>;
+declare type StepResponses = DataRequestResponse | ASTResponse | TranslateResponse | ParseResponse | MetadataResponse;
+/**
+ * A Translation is a series of translation steps. Each step can depend
+ * on other steps, in which case the preceeding steps will be passed
+ * to the constructor. The translator methods will then ask the final
+ * step for the answer, and it will call up the chain asking all the
+ * steps that it depends on for their answers.
+ *
+ * Any step can return a result which will be ...
+ *   "I had errors, go no further"
+ *   "I hit a spot where I need more data before I can continue"
+ *   "I am done, here is the result of this step"
+ */
+interface TranslationStep {
+    step(that: MalloyTranslation): StepResponses;
+}
+export interface MalloyParseRoot {
+    root: ParseTree;
+    tokenStream: CommonTokenStream;
+    sourceStream: CodePointCharStream;
+    subTranslator: MalloyTranslation;
+    malloyVersion: string;
+}
+interface ParseData extends ErrorResponse, NeedURLData, FinalResponse {
+    parse: MalloyParseRoot;
+}
+declare type ParseResponse = Partial<ParseData>;
+/**
+ * ParseStep -- Parse the source URL
+ */
+interface SourceInfo {
+    lines: string[];
+    at: {
+        begin: number;
+        end: number;
+    }[];
+    length: number;
+}
+declare class ParseStep implements TranslationStep {
+    response?: ParseResponse;
+    sourceInfo?: SourceInfo;
+    step(that: MalloyTranslation): ParseResponse;
+    /**
+     * Split the source up into lines so we can correctly compute offset
+     * to the line/char positions favored by LSP and VSCode.
+     */
+    private getSourceInfo;
+    private runParser;
+}
+declare class ImportsAndTablesStep implements TranslationStep {
+    readonly parseStep: ParseStep;
+    private alreadyLooked;
+    constructor(parseStep: ParseStep);
+    step(that: MalloyTranslation): DataRequestResponse | ParseResponse;
+}
+declare class ASTStep implements TranslationStep {
+    readonly importStep: ImportsAndTablesStep;
+    response?: ASTResponse;
+    private walked;
+    constructor(importStep: ImportsAndTablesStep);
+    step(that: MalloyTranslation): ASTResponse;
+}
+declare class MetadataStep implements TranslationStep {
+    readonly parseStep: ParseStep;
+    response?: MetadataResponse;
+    constructor(parseStep: ParseStep);
+    step(that: MalloyTranslation): MetadataResponse;
+}
+declare class CompletionsStep implements TranslationStep {
+    readonly parseStep: ParseStep;
+    constructor(parseStep: ParseStep);
+    step(that: MalloyTranslation, position?: {
+        line: number;
+        character: number;
+    }): CompletionsResponse;
+}
+declare class HelpContextStep implements TranslationStep {
+    readonly parseStep: ParseStep;
+    constructor(parseStep: ParseStep);
+    step(that: MalloyTranslation, position?: {
+        line: number;
+        character: number;
+    }): HelpContextResponse;
+}
+declare class TranslateStep implements TranslationStep {
+    readonly astStep: ASTStep;
+    response?: TranslateResponse;
+    constructor(astStep: ASTStep);
+    step(that: MalloyTranslation, extendingModel?: ModelDef): TranslateResponse;
+}
+export declare abstract class MalloyTranslation {
+    readonly sourceURL: string;
+    grammarRule: string;
+    abstract root: MalloyTranslator;
+    childTranslators: Map<string, MalloyTranslation>;
+    urlIsFullPath?: boolean;
+    queryList: Query[];
+    sqlBlocks: SQLBlock[];
+    modelDef: ModelDef;
+    readonly parseStep: ParseStep;
+    readonly importsAndTablesStep: ImportsAndTablesStep;
+    readonly astStep: ASTStep;
+    readonly metadataStep: MetadataStep;
+    readonly completionsStep: CompletionsStep;
+    readonly helpContextStep: HelpContextStep;
+    readonly translateStep: TranslateStep;
+    readonly references: ReferenceList;
+    constructor(sourceURL: string, grammarRule?: string);
+    addChild(url: string): void;
+    addReference(reference: DocumentReference): void;
+    referenceAt(position: DocumentPosition): DocumentReference | undefined;
+    fatalErrors(): FatalResponse;
+    /**
+     * The error log can grow as progressively deeper questions are asked.
+     * When returning "errors so far", make a snapshot.
+     */
+    errors(): ErrorResponse;
+    getLineMap(url: string): string[] | undefined;
+    prettyErrors(): string;
+    getChildExports(importURL: string): NamedStructDefs;
+    private finalAnswer?;
+    translate(extendingModel?: ModelDef): TranslateResponse;
+    metadata(): MetadataResponse;
+    completions(position: {
+        line: number;
+        character: number;
+    }): CompletionsResponse;
+    helpContext(position: {
+        line: number;
+        character: number;
+    }): HelpContextResponse;
+    defaultLocation(): DocumentLocation;
+    rangeFromContext(pcx: ParserRuleContext): DocumentRange;
+    rangeFromTokens(startToken: Token, stopToken: Token): DocumentRange;
+    rangeFromToken(token: Token): DocumentRange;
+}
+/**
+ * The main interface to Malloy tranlsation. It has a call pattern
+ * similar to a server. Once a translator is instantiated
+ * you can request tralnsations repeatedly. Responses to that request
+ * will either be "NeedResponse" or "TranslateResponse" objects. The
+ * correct pattern is to call "translation" in a loop, calling
+ * "update" in response to each "NeedResponse" until a "TranslateResponse"
+ * is returned. If you get a response with "final:true", there is
+ * no need to call again, the translation is finished or error'd.
+ */
+export declare class MalloyTranslator extends MalloyTranslation {
+    schemaZone: Zone<StructDef>;
+    importZone: Zone<string>;
+    sqlQueryZone: SQLExploreZone;
+    logger: MessageLog;
+    readonly root: MalloyTranslator;
+    constructor(rootURL: string, preload?: ParseUpdate | null);
+    update(dd: ParseUpdate): void;
+}
+interface ErrorData {
+    tables: Record<string, string>;
+    urls: Record<string, string>;
+    sqlStructs: Record<string, string>;
+}
+export interface URLData {
+    urls: ZoneData<string>;
+}
+export interface SchemaData {
+    tables: ZoneData<StructDef>;
+}
+export interface SQLStructData {
+    sqlStructs: ZoneData<StructDef>;
+}
+export interface UpdateData extends URLData, SchemaData, SQLStructData {
+    errors: Partial<ErrorData>;
+}
+export declare type ParseUpdate = Partial<UpdateData>;
+export {};