@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207180844

package/dist/lang/parse-error-handler.d.ts

@@ -0,0 +1,9 @@
+import { ANTLRErrorListener, Token } from "antlr4ts";
+import { MessageLogger } from "./parse-log";
+import { MalloyTranslation } from "./parse-malloy";
+export declare class MalloyParserErrorHandler implements ANTLRErrorListener<Token> {
+    readonly translator: MalloyTranslation;
+    readonly messages: MessageLogger;
+    constructor(translator: MalloyTranslation, messages: MessageLogger);
+    syntaxError(recognizer: unknown, offendingSymbol: Token | undefined, line: number, charPositionInLine: number, msg: string, _e: unknown): void;
+}

package/dist/lang/parse-error-handler.js

@@ -0,0 +1,44 @@
+"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.MalloyParserErrorHandler = void 0;
+class MalloyParserErrorHandler {
+    constructor(translator, messages) {
+        this.translator = translator;
+        this.messages = messages;
+    }
+    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, _e) {
+        const errAt = { line: line - 1, character: charPositionInLine };
+        const range = offendingSymbol
+            ? this.translator.rangeFromToken(offendingSymbol)
+            : { start: errAt, end: errAt };
+        const error = {
+            message: msg,
+            at: { url: this.translator.sourceURL, range },
+        };
+        this.messages.log(error);
+    }
+}
+exports.MalloyParserErrorHandler = MalloyParserErrorHandler;
+//# sourceMappingURL=parse-error-handler.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,51 @@
+"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.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,182 @@
+import { Token, CommonTokenStream, ParserRuleContext, CodePointCharStream } from "antlr4ts";
+import type { ParseTree } from "antlr4ts/tree";
+import { Query, NamedStructDefs, StructDef, ModelDef, DocumentReference, DocumentPosition, DocumentLocation, DocumentRange, SQLBlockStructDef } from "../model/malloy_types";
+import { MessageLog } from "./parse-log";
+import { Zone, ZoneData } from "./zone";
+import { ReferenceList } from "./reference-list";
+import { ErrorResponse, NeedURLData, FinalResponse, DataRequestResponse, ASTResponse, MetadataResponse, CompletionsResponse, HelpContextResponse, TranslateResponse, FatalResponse, ModelDataRequest } from "./translate-response";
+export 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;
+}
+export 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: SQLBlockStructDef[];
+    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;
+    childRequest(importURL: string): ModelDataRequest;
+    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: Zone<SQLBlockStructDef>;
+    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>;
+    compileSQL: Record<string, string>;
+}
+export interface URLData {
+    urls: ZoneData<string>;
+}
+export interface SchemaData {
+    tables: ZoneData<StructDef>;
+}
+export interface SQLBlockData {
+    compileSQL: ZoneData<SQLBlockStructDef>;
+}
+export interface UpdateData extends URLData, SchemaData, SQLBlockData {
+    errors: Partial<ErrorData>;
+}
+export declare type ParseUpdate = Partial<UpdateData>;
+export {};