@malloydata/malloy 0.0.385 → 0.0.386

package/dist/lang/prettify/tokens.js

@@ -0,0 +1,160 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * Token classification, layout config, and small token utilities used by the
+ * prettifier's leaf walker and rule formatters.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BINARY_OPS = exports.CALL_HUG_AFTER = exports.TOP_LEVEL_STARTERS = exports.SECTION_TOKENS = exports.INDENT_STR = exports.LINE_BUDGET = exports.L = void 0;
+exports.leadingAction = leadingAction;
+exports.endLineOf = endLineOf;
+exports.findMatching = findMatching;
+const MalloyLexer_1 = require("../lib/Malloy/MalloyLexer");
+exports.L = MalloyLexer_1.MalloyLexer;
+// ---------- Global formatting config ----------
+exports.LINE_BUDGET = 100;
+exports.INDENT_STR = '  '; // two spaces per indent level
+// ---------- Token classification ----------
+// Section keywords that introduce a `keyword: items` block (or a single value
+// for some). Used by the leaf walker as a fallback newline rule when no
+// explicit section-statement handler caught us.
+exports.SECTION_TOKENS = new Set([
+    exports.L.ACCEPT,
+    exports.L.AGGREGATE,
+    exports.L.CALCULATE,
+    exports.L.CALCULATION,
+    exports.L.CONNECTION,
+    exports.L.DECLARE,
+    exports.L.DIMENSION,
+    exports.L.DRILL,
+    exports.L.EXCEPT,
+    exports.L.EXTENDQ,
+    exports.L.GROUP_BY,
+    exports.L.GROUPED_BY,
+    exports.L.HAVING,
+    exports.L.INDEX,
+    exports.L.INTERNAL,
+    exports.L.JOIN_CROSS,
+    exports.L.JOIN_ONE,
+    exports.L.JOIN_MANY,
+    exports.L.LIMIT,
+    exports.L.MEASURE,
+    exports.L.NEST,
+    exports.L.ORDER_BY,
+    exports.L.PARTITION_BY,
+    exports.L.PRIMARY_KEY,
+    exports.L.PRIVATE,
+    exports.L.PROJECT,
+    exports.L.PUBLIC,
+    exports.L.QUERY,
+    exports.L.RENAME,
+    exports.L.RUN,
+    exports.L.SAMPLE,
+    exports.L.SELECT,
+    exports.L.SOURCE,
+    exports.L.TYPE,
+    exports.L.TOP,
+    exports.L.WHERE,
+    exports.L.VIEW,
+    exports.L.TIMEZONE,
+]);
+// Top-level statement starters. At column 0 each gets a blank line before it
+// when introducing a new statement (subject to the same-kind-no-blank rule).
+exports.TOP_LEVEL_STARTERS = new Set([
+    exports.L.SOURCE,
+    exports.L.QUERY,
+    exports.L.RUN,
+    exports.L.IMPORT,
+]);
+// Token types after which an immediately following `(` or `[` is a call /
+// subscript and should hug (no leading space). Anything else (binary ops,
+// IS/AS/EXTEND/ON/WHEN/PICK/etc.) gets a space — the `(` is grouping.
+exports.CALL_HUG_AFTER = new Set([
+    exports.L.IDENTIFIER,
+    exports.L.CPAREN,
+    exports.L.CBRACK,
+    // Aggregate / built-in callable keywords commonly used as function names.
+    exports.L.COUNT,
+    exports.L.SUM,
+    exports.L.AVG,
+    exports.L.MIN,
+    exports.L.MAX,
+    exports.L.TABLE,
+    exports.L.SQL,
+    exports.L.COMPOSE,
+    exports.L.CAST,
+    exports.L.NOW,
+    exports.L.LAST,
+]);
+// Binary operators that get spaces on both sides at the leaf level.
+// (Chain wrapping for and/or/??/+/- happens at parse-tree level — see
+// formatBinaryChain.)
+exports.BINARY_OPS = new Set([
+    exports.L.PLUS,
+    exports.L.MINUS,
+    exports.L.STAR,
+    exports.L.SLASH,
+    exports.L.PERCENT,
+    exports.L.STARSTAR,
+    exports.L.EQ,
+    exports.L.NE,
+    exports.L.LT,
+    exports.L.GT,
+    exports.L.LTE,
+    exports.L.GTE,
+    exports.L.AND,
+    exports.L.OR,
+    exports.L.MATCH,
+    exports.L.NOT_MATCH,
+    exports.L.ARROW,
+    exports.L.FAT_ARROW,
+    exports.L.BAR,
+    exports.L.AMPER,
+]);
+function leadingAction(prevType, nextType) {
+    if (nextType === exports.L.DOT ||
+        nextType === exports.L.COMMA ||
+        nextType === exports.L.SEMI ||
+        nextType === exports.L.COLON ||
+        nextType === exports.L.TRIPLECOLON ||
+        nextType === exports.L.CPAREN ||
+        nextType === exports.L.CBRACK) {
+        return 'glue';
+    }
+    if ((nextType === exports.L.OPAREN || nextType === exports.L.OBRACK) &&
+        prevType !== null &&
+        exports.CALL_HUG_AFTER.has(prevType)) {
+        return 'hug';
+    }
+    return 'space';
+}
+// ---------- Token utilities ----------
+function endLineOf(t) {
+    var _a, _b;
+    const text = (_a = t.text) !== null && _a !== void 0 ? _a : '';
+    const newlines = ((_b = text.match(/\n/g)) !== null && _b !== void 0 ? _b : []).length;
+    return t.line + newlines;
+}
+// Find the index of the closing token that matches the opener at startIdx.
+// Counts nested begin/end pairs of the same types.
+//
+// Precondition: must not be called inside an SQL string region — depth
+// tracking only knows about the begin/end token types passed in, not about
+// embedded SQL. In practice we never call this inside an SQL block (we skip
+// past them).
+function findMatching(tokens, startIdx, beginType, endType) {
+    let depth = 1;
+    for (let j = startIdx + 1; j < tokens.length; j++) {
+        if (tokens[j].type === beginType)
+            depth++;
+        else if (tokens[j].type === endType) {
+            depth--;
+            if (depth === 0)
+                return j;
+        }
+    }
+    return tokens.length - 1;
+}
+//# sourceMappingURL=tokens.js.map

package/dist/lang/prettify/types.d.ts

@@ -0,0 +1,9 @@
+export interface PrettifyError {
+    message: string;
+    line: number;
+    column: number;
+}
+export interface PrettifyResult {
+    result: string;
+    errors: PrettifyError[];
+}

package/dist/lang/prettify/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/lang/run-malloy-parser.d.ts

@@ -1,3 +1,26 @@
+import { CommonTokenStream } from 'antlr4ts';
+import type { ANTLRErrorListener, Token, CodePointCharStream } from 'antlr4ts';
+import { MalloyParser } from './lib/Malloy/MalloyParser';
 import type { MessageLogger } from './parse-log';
 import type { ParseInfo, SourceInfo } from './utils';
+export interface MalloyParserSetupOptions {
+    lexerErrorListener?: ANTLRErrorListener<any>;
+    parserErrorListener?: ANTLRErrorListener<Token>;
+}
+/**
+ * Build a Malloy lexer/token-stream/parser triplet ready to invoke a grammar
+ * rule on `code`. Centralises the lexer fix (HandlesOverpoppingLexer for
+ * unmatched `}%`) and the project's MalloyErrorStrategy so callers can't
+ * accidentally diverge on those.
+ *
+ * The token stream is NOT pre-filled. Callers that need all tokens up front
+ * (e.g. the prettifier's leaf walker) should call `tokenStream.fill()` before
+ * iterating; callers that only need parser-driven access can leave it alone
+ * — the parser pulls tokens as it consumes the rule.
+ */
+export declare function makeMalloyParser(code: string, options?: MalloyParserSetupOptions): {
+    inputStream: CodePointCharStream;
+    tokenStream: CommonTokenStream;
+    parser: MalloyParser;
+};
 export declare function runMalloyParser(code: string, sourceURL: string, sourceInfo: SourceInfo, logger: MessageLogger, grammarRule?: string): ParseInfo;

package/dist/lang/run-malloy-parser.js

@@ -6,6 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMalloyParser = makeMalloyParser;
 exports.runMalloyParser = runMalloyParser;
 const antlr4ts_1 = require("antlr4ts");
 const MalloyLexer_1 = require("./lib/Malloy/MalloyLexer");
@@ -24,24 +25,47 @@ class HandlesOverpoppingLexer extends MalloyLexer_1.MalloyLexer {
         return super.popMode();
     }
 }
-function runMalloyParser(code, sourceURL, sourceInfo, logger, grammarRule = 'malloyDocument') {
+/**
+ * Build a Malloy lexer/token-stream/parser triplet ready to invoke a grammar
+ * rule on `code`. Centralises the lexer fix (HandlesOverpoppingLexer for
+ * unmatched `}%`) and the project's MalloyErrorStrategy so callers can't
+ * accidentally diverge on those.
+ *
+ * The token stream is NOT pre-filled. Callers that need all tokens up front
+ * (e.g. the prettifier's leaf walker) should call `tokenStream.fill()` before
+ * iterating; callers that only need parser-driven access can leave it alone
+ * — the parser pulls tokens as it consumes the rule.
+ */
+function makeMalloyParser(code, options = {}) {
     const inputStream = antlr4ts_1.CharStreams.fromString(code);
     const lexer = new HandlesOverpoppingLexer(inputStream);
+    if (options.lexerErrorListener) {
+        lexer.removeErrorListeners();
+        lexer.addErrorListener(options.lexerErrorListener);
+    }
     const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
-    const malloyParser = new MalloyParser_1.MalloyParser(tokenStream);
-    malloyParser.removeErrorListeners();
-    malloyParser.addErrorListener(new malloy_parser_error_listener_1.MalloyParserErrorListener(logger, sourceURL, sourceInfo));
-    malloyParser.errorHandler = new malloy_error_strategy_1.MalloyErrorStrategy();
+    const parser = new MalloyParser_1.MalloyParser(tokenStream);
+    if (options.parserErrorListener) {
+        parser.removeErrorListeners();
+        parser.addErrorListener(options.parserErrorListener);
+    }
+    parser.errorHandler = new malloy_error_strategy_1.MalloyErrorStrategy();
+    return { inputStream, tokenStream, parser };
+}
+function runMalloyParser(code, sourceURL, sourceInfo, logger, grammarRule = 'malloyDocument') {
+    const { inputStream, tokenStream, parser } = makeMalloyParser(code, {
+        parserErrorListener: new malloy_parser_error_listener_1.MalloyParserErrorListener(logger, sourceURL, sourceInfo),
+    });
     // 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[grammarRule];
+    const parseFunc = parser[grammarRule];
     if (!parseFunc) {
         throw new Error(`No such parse rule as ${grammarRule}`);
     }
     return {
-        root: parseFunc.call(malloyParser),
-        tokenStream: tokenStream,
+        root: parseFunc.call(parser),
+        tokenStream,
         sourceStream: inputStream,
         sourceInfo,
         sourceURL,

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.385";
+export declare const MALLOY_VERSION = "0.0.386";

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.385';
+exports.MALLOY_VERSION = '0.0.386';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.385",
+  "version": "0.0.386",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -51,9 +51,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "0.0.385",
-    "@malloydata/malloy-interfaces": "0.0.385",
-    "@malloydata/malloy-tag": "0.0.385",
+    "@malloydata/malloy-filter": "0.0.386",
+    "@malloydata/malloy-interfaces": "0.0.386",
+    "@malloydata/malloy-tag": "0.0.386",
     "@noble/hashes": "^1.8.0",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",