@malloydata/malloy 0.0.22-dev230126015148 → 0.0.22-dev230206094309

package/dist/lang/parse-malloy.js

@@ -1,746 +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.
- */
-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.MalloyTranslator = exports.MalloyTranslation = void 0;
-const antlr4ts_1 = require("antlr4ts");
-const MalloyLexer_1 = require("./lib/Malloy/MalloyLexer");
-const MalloyParser_1 = require("./lib/Malloy/MalloyParser");
-const ast = __importStar(require("./ast"));
-const parse_to_ast_1 = require("./parse-to-ast");
-const parse_log_1 = require("./parse-log");
-const find_external_references_1 = require("./parse-tree-walkers/find-external-references");
-const zone_1 = require("./zone");
-const document_symbol_walker_1 = require("./parse-tree-walkers/document-symbol-walker");
-const document_highlight_walker_1 = require("./parse-tree-walkers/document-highlight-walker");
-const document_completion_walker_1 = require("./parse-tree-walkers/document-completion-walker");
-const document_help_context_walker_1 = require("./parse-tree-walkers/document-help-context-walker");
-const reference_list_1 = require("./reference-list");
-/**
- * This ignores a -> popMode when the mode stack is empty, which is a hack,
- * but it let's us parse }%
- */
-class HandlesOverpoppingLexer extends MalloyLexer_1.MalloyLexer {
-    popMode() {
-        if (this._modeStack.isEmpty) {
-            return this._mode;
-        }
-        return super.popMode();
-    }
-}
-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);
-    }
-}
-function isNeedResponse(dr) {
-    return !!dr && (dr.tables || dr.urls || dr.compileSQL) != undefined;
-}
-class ParseStep {
-    step(that) {
-        if (this.response) {
-            return this.response;
-        }
-        if (that.urlIsFullPath === undefined) {
-            try {
-                const _checkFull = new URL(that.sourceURL);
-                that.urlIsFullPath = true;
-            }
-            catch (e) {
-                const msg = e instanceof Error ? e.message : "";
-                that.urlIsFullPath = false;
-                that.root.logger.log({
-                    message: `Could not compute full path URL: ${msg}`,
-                });
-            }
-        }
-        if (!that.urlIsFullPath) {
-            return that.fatalErrors();
-        }
-        const srcEnt = that.root.importZone.getEntry(that.sourceURL);
-        if (srcEnt.status !== "present") {
-            if (srcEnt.status === "error") {
-                const message = srcEnt.message.includes(that.sourceURL)
-                    ? `import error: ${srcEnt.message}`
-                    : `import '${that.sourceURL}' error: ${srcEnt.message}`;
-                const at = srcEnt.firstReference || that.defaultLocation();
-                that.root.logger.log({ message, at });
-                this.response = that.fatalErrors();
-                return this.response;
-            }
-            return { urls: [that.sourceURL] };
-        }
-        const source = srcEnt.value == "" ? "\n" : srcEnt.value;
-        this.sourceInfo = this.getSourceInfo(source);
-        let parse;
-        try {
-            parse = this.runParser(source, that);
-        }
-        catch (parseException) {
-            that.root.logger.log({
-                message: `Malloy internal parser exception [${parseException.message}]`,
-            });
-            parse = undefined;
-        }
-        if (that.root.logger.hasErrors()) {
-            this.response = {
-                parse,
-                ...that.fatalErrors(),
-            };
-        }
-        else {
-            this.response = { parse };
-        }
-        return this.response;
-    }
-    /**
-     * Split the source up into lines so we can correctly compute offset
-     * to the line/char positions favored by LSP and VSCode.
-     */
-    getSourceInfo(code) {
-        const eolRegex = /\r?\n/;
-        const info = {
-            at: [],
-            lines: [],
-            length: code.length,
-        };
-        let src = code;
-        let lineStart = 0;
-        while (src !== "") {
-            const eol = src.match(eolRegex);
-            if (eol && eol.index != undefined) {
-                // line text DOES NOT include the EOL
-                info.lines.push(src.slice(0, eol.index));
-                const lineLength = eol.index + eol[0].length;
-                info.at.push({
-                    begin: lineStart,
-                    end: lineStart + lineLength,
-                });
-                lineStart += lineLength;
-                src = src.slice(lineLength);
-            }
-            else {
-                // last line, does not have a line end
-                info.lines.push(src);
-                info.at.push({ begin: lineStart, end: lineStart + src.length });
-                break;
-            }
-        }
-        return info;
-    }
-    runParser(source, that) {
-        const inputStream = antlr4ts_1.CharStreams.fromString(source);
-        const lexer = new HandlesOverpoppingLexer(inputStream);
-        const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
-        const malloyParser = new MalloyParser_1.MalloyParser(tokenStream);
-        malloyParser.removeErrorListeners();
-        malloyParser.addErrorListener(new MalloyParserErrorHandler(that, that.root.logger));
-        // Admitted code smell here, testing likes to parse from an arbitrary
-        // node and this is the simplest way to allow that.
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const parseFunc = malloyParser[that.grammarRule];
-        if (!parseFunc) {
-            throw new Error(`No such parse rule as ${that.grammarRule}`);
-        }
-        return {
-            root: parseFunc.call(malloyParser),
-            tokenStream: tokenStream,
-            sourceStream: inputStream,
-            // TODO put the real version here
-            malloyVersion: "?.?.?-????",
-            subTranslator: that,
-        };
-    }
-}
-class ImportsAndTablesStep {
-    constructor(parseStep) {
-        this.parseStep = parseStep;
-        this.alreadyLooked = false;
-    }
-    step(that) {
-        const parseReq = this.parseStep.step(that);
-        if (parseReq.parse == undefined) {
-            return parseReq;
-        }
-        if (!this.alreadyLooked) {
-            this.alreadyLooked = true;
-            const parseRefs = (0, find_external_references_1.findReferences)(that, parseReq.parse.tokenStream, parseReq.parse.root);
-            if (parseRefs === null || parseRefs === void 0 ? void 0 : parseRefs.tables) {
-                for (const ref in parseRefs.tables) {
-                    that.root.schemaZone.reference(ref, {
-                        url: that.sourceURL,
-                        range: parseRefs.tables[ref],
-                    });
-                }
-            }
-            if (parseRefs === null || parseRefs === void 0 ? void 0 : parseRefs.urls) {
-                for (const relativeRef in parseRefs.urls) {
-                    const firstRef = parseRefs.urls[relativeRef];
-                    try {
-                        const ref = decodeURI(new URL(relativeRef, that.sourceURL).toString());
-                        that.addChild(ref);
-                        that.root.importZone.reference(ref, {
-                            url: that.sourceURL,
-                            range: firstRef,
-                        });
-                    }
-                    catch (err) {
-                        // This import spec is so bad the URL library threw up, this
-                        // may be impossible, because it will append any garbage
-                        // to the known good rootURL assuming it is relative
-                        that.root.logger.log({
-                            message: `Malformed URL '${relativeRef}'"`,
-                            at: { url: that.sourceURL, range: firstRef },
-                        });
-                    }
-                }
-            }
-        }
-        if (that.root.logger.hasErrors()) {
-            // Since we knew we parsed without errors, this would only be from
-            // having a malformed URL on an import reference.
-            return null;
-        }
-        let allMissing = {};
-        const missingTables = that.root.schemaZone.getUndefined();
-        if (missingTables) {
-            allMissing = { tables: missingTables };
-        }
-        const missingImports = that.root.importZone.getUndefined();
-        if (missingImports) {
-            allMissing = { ...allMissing, urls: missingImports };
-        }
-        if (isNeedResponse(allMissing)) {
-            return allMissing;
-        }
-        for (const child of that.childTranslators.values()) {
-            const kidNeeds = child.importsAndTablesStep.step(child);
-            if (isNeedResponse(kidNeeds)) {
-                return kidNeeds;
-            }
-        }
-        return null;
-    }
-}
-class ASTStep {
-    constructor(importStep) {
-        this.importStep = importStep;
-        this.walked = false;
-    }
-    step(that) {
-        if (this.response) {
-            return this.response;
-        }
-        const mustResolve = this.importStep.step(that);
-        if (mustResolve) {
-            return mustResolve;
-        }
-        const parseResponse = that.parseStep.response;
-        // Errors in self or children will show up here ..
-        if (that.root.logger.hasErrors()) {
-            this.response = that.fatalErrors();
-            return this.response;
-        }
-        const parse = parseResponse === null || parseResponse === void 0 ? void 0 : parseResponse.parse;
-        if (!parse) {
-            throw new Error("TRANSLATOR INTERNAL ERROR: Translator parse response had no errors, but also no parser");
-        }
-        const secondPass = new parse_to_ast_1.MalloyToAST(parse, that.root.logger);
-        const newAst = secondPass.visit(parse.root);
-        if (that.root.logger.hasErrors()) {
-            this.response = that.fatalErrors();
-            return this.response;
-        }
-        if (newAst.elementType === "unimplemented") {
-            throw new Error("TRANSLATOR INTERNAL ERROR: Unimplemented AST node");
-        }
-        // I kind of think table refs should probably also be collected here
-        // instead of in the parse step. Note to myself, do that someday.
-        const sqlExplores = {};
-        if (!this.walked) {
-            newAst.walk((walkedTo) => {
-                if (walkedTo instanceof ast.SQLSource) {
-                    if (!sqlExplores[walkedTo.refName]) {
-                        sqlExplores[walkedTo.refName] = {};
-                    }
-                    sqlExplores[walkedTo.refName].ref = walkedTo;
-                }
-                else if (walkedTo instanceof ast.SQLStatement && walkedTo.is) {
-                    if (!sqlExplores[walkedTo.is]) {
-                        sqlExplores[walkedTo.is] = {};
-                    }
-                    sqlExplores[walkedTo.is].def = walkedTo;
-                }
-                else if (walkedTo instanceof ast.Unimplemented) {
-                    walkedTo.log("INTERNAL COMPILER ERROR: Untranslated parse node");
-                }
-            });
-            this.walked = true;
-        }
-        // If there is a partial ast ...
-        if (that.root.logger.hasErrors()) {
-            this.response = that.fatalErrors();
-            return this.response;
-        }
-        /*
-    TODO we used to scna the AST for SQL blocks here, don't need to do that
-    becausae that happens at the translate step, but the code I need to
-    understand is how a root translate can return the need of a chiold
-    which has an SQL block ...
-    
-    */
-        // Now make sure that every child has fully translated itself
-        // before this tree is ready to also translate ...
-        for (const child of that.childTranslators.values()) {
-            const kidNeeds = child.astStep.step(child);
-            if (isNeedResponse(kidNeeds)) {
-                return kidNeeds;
-            }
-        }
-        newAst.setTranslator(that);
-        this.response = {
-            ...that.errors(),
-            ast: newAst,
-            final: true,
-        };
-        return this.response;
-    }
-}
-class MetadataStep {
-    constructor(parseStep) {
-        this.parseStep = parseStep;
-    }
-    step(that) {
-        if (!this.response) {
-            const tryParse = this.parseStep.step(that);
-            if (!tryParse.parse) {
-                return tryParse;
-            }
-            else {
-                // Wrap the parse tree walker in a try block -- if the parse is bad, this walk
-                // could result in unexpected errors due to the parse tree not looking as expected.
-                // We still want to attempt to walk the tree, to preserve document symbols even
-                // when there's a bad parse, but we also want to be safe about it.
-                let symbols;
-                try {
-                    symbols = (0, document_symbol_walker_1.walkForDocumentSymbols)(that, tryParse.parse.tokenStream, tryParse.parse.root);
-                }
-                catch {
-                    // Do nothing, symbols already `undefined`
-                }
-                let walkHighlights;
-                try {
-                    walkHighlights = (0, document_highlight_walker_1.walkForDocumentHighlights)(tryParse.parse.tokenStream, tryParse.parse.root);
-                }
-                catch {
-                    walkHighlights = [];
-                }
-                this.response = {
-                    symbols,
-                    highlights: (0, document_highlight_walker_1.sortHighlights)([
-                        ...(0, document_highlight_walker_1.passForHighlights)(tryParse.parse.tokenStream),
-                        ...walkHighlights,
-                    ]),
-                    final: true,
-                };
-            }
-        }
-        return this.response;
-    }
-}
-class CompletionsStep {
-    constructor(parseStep) {
-        this.parseStep = parseStep;
-    }
-    step(that, position) {
-        const tryParse = this.parseStep.step(that);
-        if (!tryParse.parse) {
-            return tryParse;
-        }
-        else {
-            let completions = [];
-            if (position !== undefined) {
-                try {
-                    completions = (0, document_completion_walker_1.walkForDocumentCompletions)(tryParse.parse.tokenStream, tryParse.parse.root, position);
-                }
-                catch {
-                    /* Do nothing */
-                }
-            }
-            return {
-                ...tryParse,
-                completions,
-            };
-        }
-    }
-}
-class HelpContextStep {
-    constructor(parseStep) {
-        this.parseStep = parseStep;
-    }
-    step(that, position) {
-        const tryParse = this.parseStep.step(that);
-        if (!tryParse.parse) {
-            return tryParse;
-        }
-        else {
-            let helpContext;
-            if (position !== undefined) {
-                try {
-                    helpContext = (0, document_help_context_walker_1.walkForDocumentHelpContext)(tryParse.parse.root, position);
-                }
-                catch {
-                    /* Do nothing */
-                }
-            }
-            return {
-                ...tryParse,
-                helpContext,
-            };
-        }
-    }
-}
-class TranslateStep {
-    constructor(astStep) {
-        this.astStep = astStep;
-    }
-    step(that, extendingModel) {
-        if (this.response) {
-            return this.response;
-        }
-        const astResponse = this.astStep.step(that);
-        if (isNeedResponse(astResponse)) {
-            return astResponse;
-        }
-        if (!astResponse.ast) {
-            this.response = astResponse;
-            return this.response;
-        }
-        if (that.grammarRule === "malloyDocument") {
-            if (astResponse.ast instanceof ast.Document) {
-                const doc = astResponse.ast;
-                doc.initModelDef(extendingModel);
-                for (;;) {
-                    const docCompile = doc.compile();
-                    if (docCompile.needs) {
-                        return docCompile.needs;
-                    }
-                    else {
-                        that.modelDef = docCompile.modelDef;
-                        that.queryList = docCompile.queryList;
-                        that.sqlBlocks = docCompile.sqlBlocks;
-                        break;
-                    }
-                }
-            }
-            else {
-                that.root.logger.log({
-                    message: `'${that.sourceURL}' did not parse to malloy document`,
-                    at: that.defaultLocation(),
-                });
-            }
-        }
-        if (that.root.logger.hasErrors()) {
-            this.response = that.fatalErrors();
-        }
-        else {
-            this.response = {
-                translated: {
-                    modelDef: that.modelDef,
-                    queryList: that.queryList,
-                    sqlBlocks: that.sqlBlocks,
-                },
-                ...that.errors(),
-                final: true,
-            };
-        }
-        return this.response;
-    }
-}
-class MalloyTranslation {
-    constructor(sourceURL, grammarRule = "malloyDocument") {
-        this.sourceURL = sourceURL;
-        this.grammarRule = grammarRule;
-        this.queryList = [];
-        this.sqlBlocks = [];
-        this.childTranslators = new Map();
-        this.modelDef = {
-            name: sourceURL,
-            exports: [],
-            contents: {},
-        };
-        /**
-         * This is sort of the makefile for the translation, all the steps
-         * and the dependencies of the steps are declared here. Then when
-         * a translator method is called which needs the result of a step,
-         * it asks the step what it needs to complete, and all the right
-         * things will happen automatically.
-         */
-        this.parseStep = new ParseStep();
-        this.metadataStep = new MetadataStep(this.parseStep);
-        this.completionsStep = new CompletionsStep(this.parseStep);
-        this.helpContextStep = new HelpContextStep(this.parseStep);
-        this.importsAndTablesStep = new ImportsAndTablesStep(this.parseStep);
-        this.astStep = new ASTStep(this.importsAndTablesStep);
-        this.translateStep = new TranslateStep(this.astStep);
-        this.references = new reference_list_1.ReferenceList(sourceURL);
-    }
-    addChild(url) {
-        if (!this.childTranslators.get(url)) {
-            this.childTranslators.set(url, new MalloyChildTranslator(url, this.root));
-        }
-    }
-    addReference(reference) {
-        this.references.add(reference);
-    }
-    referenceAt(position) {
-        return this.references.find(position);
-    }
-    fatalErrors() {
-        return {
-            final: true,
-            errors: [...this.root.logger.getLog()],
-        };
-    }
-    /**
-     * The error log can grow as progressively deeper questions are asked.
-     * When returning "errors so far", make a snapshot.
-     */
-    errors() {
-        const errors = this.root.logger.getLog();
-        return { errors: [...errors] };
-    }
-    getLineMap(url) {
-        var _a, _b;
-        if (url == this.sourceURL) {
-            return (_a = this.parseStep.sourceInfo) === null || _a === void 0 ? void 0 : _a.lines;
-        }
-        const theChild = this.childTranslators.get(url);
-        if (theChild) {
-            return (_b = theChild.parseStep.sourceInfo) === null || _b === void 0 ? void 0 : _b.lines;
-        }
-    }
-    prettyErrors() {
-        let lovely = "";
-        let inFile = "";
-        for (const entry of this.root.logger.getLog()) {
-            let cooked = entry.message;
-            let errorURL = this.sourceURL;
-            if (entry.at) {
-                errorURL = entry.at.url;
-                const lineNo = entry.at.range.start.line;
-                const charFrom = entry.at.range.start.character;
-                const lines = this.getLineMap(entry.at.url);
-                if (lines) {
-                    const errorLine = lines[lineNo];
-                    cooked = `line ${lineNo + 1}: ${entry.message}\n  | ${errorLine}`;
-                    if (charFrom > 0) {
-                        cooked = cooked + `\n  | ${" ".repeat(charFrom)}^`;
-                    }
-                }
-                else {
-                    cooked = `line ${lineNo + 1}: char ${charFrom}: ${entry.message}`;
-                }
-            }
-            if (inFile !== errorURL) {
-                cooked = `FILE: ${errorURL}\n` + cooked;
-                inFile = errorURL;
-            }
-            if (lovely !== "") {
-                lovely = `${lovely}\n${cooked}`;
-            }
-            else {
-                lovely = cooked;
-            }
-        }
-        return lovely;
-    }
-    childRequest(importURL) {
-        var _a;
-        const childURL = decodeURI(new URL(importURL, this.sourceURL).toString());
-        const ret = (_a = this.childTranslators.get(childURL)) === null || _a === void 0 ? void 0 : _a.translate();
-        if (ret === null || ret === void 0 ? void 0 : ret.compileSQL) {
-            return {
-                compileSQL: ret.compileSQL,
-                partialModel: ret.partialModel,
-            };
-        }
-    }
-    getChildExports(importURL) {
-        const exports = {};
-        const childURL = decodeURI(new URL(importURL, this.sourceURL).toString());
-        const child = this.childTranslators.get(childURL);
-        if (child) {
-            const did = child.translate();
-            if (did.translated) {
-                for (const fromChild of child.modelDef.exports) {
-                    const modelEntry = child.modelDef.contents[fromChild];
-                    if (modelEntry.type === "struct") {
-                        exports[fromChild] = modelEntry;
-                    }
-                }
-            }
-            // else nothing, assuming there are already errors in the log
-        }
-        return exports;
-    }
-    translate(extendingModel) {
-        if (this.finalAnswer) {
-            return this.finalAnswer;
-        }
-        const attempt = this.translateStep.step(this, extendingModel);
-        if (attempt.final) {
-            this.finalAnswer = attempt;
-        }
-        return attempt;
-    }
-    metadata() {
-        return this.metadataStep.step(this);
-    }
-    completions(position) {
-        return this.completionsStep.step(this, position);
-    }
-    helpContext(position) {
-        return this.helpContextStep.step(this, position);
-    }
-    defaultLocation() {
-        return {
-            url: this.sourceURL,
-            range: {
-                start: { line: 0, character: 0 },
-                end: { line: 0, character: 0 },
-            },
-        };
-    }
-    rangeFromContext(pcx) {
-        return this.rangeFromTokens(pcx.start, pcx.stop || pcx.start);
-    }
-    rangeFromTokens(startToken, stopToken) {
-        const start = {
-            line: startToken.line - 1,
-            character: startToken.charPositionInLine,
-        };
-        if (this.parseStep.sourceInfo && stopToken.stopIndex != -1) {
-            // Find the line which contains the stopIndex
-            const lastLine = this.parseStep.sourceInfo.lines.length - 1;
-            for (let lineNo = startToken.line - 1; lineNo <= lastLine; lineNo++) {
-                const at = this.parseStep.sourceInfo.at[lineNo];
-                if (stopToken.stopIndex >= at.begin && stopToken.stopIndex <= at.end) {
-                    return {
-                        start,
-                        end: {
-                            line: lineNo,
-                            character: stopToken.stopIndex - at.begin + 1,
-                        },
-                    };
-                }
-            }
-            // Should be impossible to get here, but if we do ... return the last
-            // character of the last line of the file
-            return {
-                start,
-                end: {
-                    line: lastLine,
-                    character: this.parseStep.sourceInfo.lines[lastLine].length,
-                },
-            };
-        }
-        return { start, end: start };
-    }
-    rangeFromToken(token) {
-        return this.rangeFromTokens(token, token);
-    }
-}
-exports.MalloyTranslation = MalloyTranslation;
-class MalloyChildTranslator extends MalloyTranslation {
-    constructor(rootURL, root) {
-        super(rootURL);
-        this.root = root;
-    }
-}
-/**
- * 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.
- */
-class MalloyTranslator extends MalloyTranslation {
-    constructor(rootURL, preload = null) {
-        super(rootURL);
-        this.schemaZone = new zone_1.Zone();
-        this.importZone = new zone_1.Zone();
-        this.sqlQueryZone = new zone_1.Zone();
-        this.logger = new parse_log_1.MessageLog();
-        this.root = this;
-        if (preload) {
-            this.update(preload);
-        }
-    }
-    update(dd) {
-        var _a, _b, _c;
-        this.schemaZone.updateFrom(dd.tables, (_a = dd.errors) === null || _a === void 0 ? void 0 : _a.tables);
-        this.importZone.updateFrom(dd.urls, (_b = dd.errors) === null || _b === void 0 ? void 0 : _b.urls);
-        this.sqlQueryZone.updateFrom(dd.compileSQL, (_c = dd.errors) === null || _c === void 0 ? void 0 : _c.compileSQL);
-    }
-}
-exports.MalloyTranslator = MalloyTranslator;
-//# sourceMappingURL=parse-malloy.js.map