@malloydata/malloy 0.0.384 → 0.0.386

package/dist/lang/prettify/inline-renderer.js

@@ -0,0 +1,101 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * renderItemInline — flat-string form of a parse-rule's token range.
+ *
+ * Used by:
+ *   - section-list inline measurement and bare-item flow-fill
+ *   - postfix `{…}` inline form
+ *   - pick / case alignment (rendering values and conditions to strings)
+ *
+ * Inter-token spacing comes from `leadingAction` in ./tokens, the same
+ * classifier the leaf walker (./leaf) consults. Both walkers therefore agree
+ * on what spacing goes between any two adjacent tokens; inline measurement
+ * predicts actual emission.
+ *
+ * Walker-specific divergence:
+ *   - This produces a flat string (no newlines, no indentation).
+ *   - SEMI emits `; ` (compact-inline form), not a newline.
+ *   - COMMA emits `, ` (intra-line form), not a newline.
+ *   - The space-coalescing skip-list omits `\n` (we never emit one) but is
+ *     otherwise the same as Out.space.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderItemInline = renderItemInline;
+const antlr4ts_1 = require("antlr4ts");
+const tokens_1 = require("./tokens");
+function renderItemInline(f, ctx) {
+    var _a;
+    let buf = '';
+    let lastType = null;
+    // Coalescing space: skip if buffer is empty or last char already provides
+    // separation. Mirrors Out.space() (./out) minus the newline check, since
+    // this renderer never emits a newline.
+    const space = () => {
+        if (buf.length === 0)
+            return;
+        const last = buf[buf.length - 1];
+        if (last === ' ' || last === '(' || last === '[' || last === '.')
+            return;
+        buf += ' ';
+    };
+    const trim = () => {
+        buf = buf.replace(/ +$/, '');
+    };
+    for (let i = ctx._start.tokenIndex; i <= ctx._stop.tokenIndex; i++) {
+        const t = f.tokens[i];
+        if (t.channel === antlr4ts_1.Token.HIDDEN_CHANNEL)
+            continue;
+        const text = (_a = t.text) !== null && _a !== void 0 ? _a : '';
+        if (t.type === tokens_1.L.SQL_BEGIN) {
+            const endIdx = (0, tokens_1.findMatching)(f.tokens, i, tokens_1.L.SQL_BEGIN, tokens_1.L.SQL_END);
+            const stop = f.tokens[endIdx].stopIndex;
+            space();
+            buf += f.src.substring(t.startIndex, stop + 1);
+            i = endIdx;
+            lastType = tokens_1.L.SQL_END;
+            continue;
+        }
+        if (t.type === tokens_1.L.CCURLY) {
+            // `{}` empty: no inner space. `{ x }`: both inner spaces.
+            if (buf.length > 0 && !buf.endsWith('{') && !buf.endsWith(' '))
+                buf += ' ';
+            else
+                trim();
+            buf += '}';
+            lastType = t.type;
+            continue;
+        }
+        // Walker-specific divergence: COMMA and SEMI use compact-inline form
+        // (`, ` and `; `). The leaf walker (./leaf) emits newlines for these in
+        // wrapped contexts.
+        if (t.type === tokens_1.L.COMMA) {
+            trim();
+            buf += ', ';
+            lastType = t.type;
+            continue;
+        }
+        if (t.type === tokens_1.L.SEMI) {
+            trim();
+            buf += '; ';
+            lastType = t.type;
+            continue;
+        }
+        // Everything else: classifier-driven leading separator + text + (if a
+        // binary op) trailing space. Same shape as the leaf walker's default.
+        const action = (0, tokens_1.leadingAction)(lastType, t.type);
+        if (action === 'glue')
+            trim();
+        else if (action === 'space')
+            space();
+        // 'hug' — emit nothing before
+        buf += text;
+        if (tokens_1.BINARY_OPS.has(t.type))
+            buf += ' ';
+        lastType = t.type;
+    }
+    return buf;
+}
+//# sourceMappingURL=inline-renderer.js.map

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

@@ -0,0 +1,9 @@
+import { Token } from 'antlr4ts';
+import type { Formatter } from './formatter';
+export declare function note(f: Formatter, tokenType: number, idx: number, endTok: Token): void;
+export declare function flushHiddenBefore(f: Formatter, idx: number): void;
+export declare function startStatementLine(f: Formatter): void;
+export declare function approxInlineSpan(f: Formatter, fromIdx: number, toIdx: number): number;
+export declare function hasCommentsInRange(f: Formatter, fromIdx: number, toIdx: number): boolean;
+export declare function emitVisibleToken(f: Formatter, t: Token, idx: number): void;
+export declare function formatTokenRange(f: Formatter, fromIdx: number, toIdx: number): void;

package/dist/lang/prettify/leaf.js

@@ -0,0 +1,313 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * Leaf walker: per-token spacing, structural punctuation, comment placement,
+ * and the small helpers the rule formatters use to look at adjacent tokens.
+ *
+ * Per-rule formatters call into here via:
+ *   - emitVisibleToken         — the leaf
+ *   - flushHiddenBefore        — emit pending comments before a target index
+ *   - note                     — atomic per-token state update
+ *   - startStatementLine       — newline (consuming `needBlank`) for stmt start
+ *   - approxInlineSpan         — line-budget overestimate for a token range
+ *   - hasCommentsInRange       — comment-presence check (gates inline form)
+ *   - formatTokenRange         — emit a span via the leaf walker
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.note = note;
+exports.flushHiddenBefore = flushHiddenBefore;
+exports.startStatementLine = startStatementLine;
+exports.approxInlineSpan = approxInlineSpan;
+exports.hasCommentsInRange = hasCommentsInRange;
+exports.emitVisibleToken = emitVisibleToken;
+exports.formatTokenRange = formatTokenRange;
+const antlr4ts_1 = require("antlr4ts");
+const tokens_1 = require("./tokens");
+// Update per-token state after emitting a token (or a token-like span).
+function note(f, tokenType, idx, endTok) {
+    f.lastEmittedType = tokenType;
+    f.prevTokenEndLine = (0, tokens_1.endLineOf)(endTok);
+    f.lastEmittedIdx = idx;
+}
+// Emit any hidden-channel tokens (comments) sitting between f.lastEmittedIdx
+// and idx-1, advancing f.lastEmittedIdx so they are not re-emitted by a later
+// call. Visible tokens in the same range (e.g. commas the section-list rule
+// chose to drop) are skipped.
+function flushHiddenBefore(f, idx) {
+    if (idx <= f.lastEmittedIdx + 1)
+        return;
+    for (let j = f.lastEmittedIdx + 1; j < idx; j++) {
+        const t = f.tokens[j];
+        if (t.channel === antlr4ts_1.Token.HIDDEN_CHANNEL) {
+            emitHiddenToken(f, t);
+        }
+    }
+    f.lastEmittedIdx = idx - 1;
+}
+// Hidden-channel tokens (comments). Trailing comments (same line as previous
+// token) attach with a space; leading comments (own line) start a fresh line.
+function emitHiddenToken(f, t) {
+    var _a;
+    const text = (_a = t.text) !== null && _a !== void 0 ? _a : '';
+    const sameLine = f.prevTokenEndLine !== 0 && t.line === f.prevTokenEndLine;
+    if (t.type === tokens_1.L.COMMENT_TO_EOL) {
+        if (sameLine) {
+            f.o.space();
+            f.o.text(text.replace(/\s+$/, ''));
+            f.o.nl();
+        }
+        else {
+            if (f.o.indent === 0)
+                startStatementLine(f);
+            else
+                f.o.nl();
+            f.o.text(text.replace(/\s+$/, ''));
+            f.o.nl();
+        }
+    }
+    else if (t.type === tokens_1.L.BLOCK_COMMENT) {
+        if (sameLine) {
+            f.o.space();
+            f.o.text(text);
+            f.o.space();
+        }
+        else {
+            if (f.o.indent === 0)
+                startStatementLine(f);
+            else
+                f.o.nl();
+            f.o.text(text);
+            f.o.nl();
+        }
+    }
+    f.prevTokenEndLine = (0, tokens_1.endLineOf)(t);
+}
+// Either consume `needBlank` (emit blank line) or just newline.
+function startStatementLine(f) {
+    if (f.needBlank) {
+        f.o.blank();
+        f.needBlank = false;
+    }
+    else {
+        f.o.nl();
+    }
+}
+// Approximate length of the inline form of tokens [fromIdx, toIdx]: sum of
+// visible token text + 1 char between adjacent tokens. Used for budget checks
+// (paren wrap, pickStatement wrap, etc.). It's an overestimate for dotted-paths
+// and similar (`a.b` is 3 chars, our estimate is 5) but the direction is
+// conservative — we wrap a touch sooner than strictly needed.
+function approxInlineSpan(f, fromIdx, toIdx) {
+    var _a;
+    let len = 0;
+    let prev = -1;
+    for (let i = fromIdx; i <= toIdx; i++) {
+        const t = f.tokens[i];
+        if (t.channel === antlr4ts_1.Token.HIDDEN_CHANNEL)
+            continue;
+        if (t.type === antlr4ts_1.Token.EOF)
+            continue;
+        if (prev >= 0)
+            len += 1;
+        len += ((_a = t.text) !== null && _a !== void 0 ? _a : '').length;
+        prev = i;
+    }
+    return len;
+}
+// Are there any hidden-channel tokens (comments) in [fromIdx, toIdx]? Used to
+// gate inline-form candidates: any path that goes through `renderItemInline`
+// strips comments, so candidates with comments must fall back to wrapped or
+// broken form where the leaf walker preserves them.
+function hasCommentsInRange(f, fromIdx, toIdx) {
+    for (let i = fromIdx; i <= toIdx; i++) {
+        if (f.tokens[i].channel === antlr4ts_1.Token.HIDDEN_CHANNEL)
+            return true;
+    }
+    return false;
+}
+// Does the paren-pair at [openIdx, closeIdx] have any COMMA at its own depth?
+// (Used to distinguish "function call with multiple args" from "single-arg
+// call" / "empty parens".)
+function hasCommaAtDepth1(f, openIdx, closeIdx) {
+    let depth = 0;
+    for (let i = openIdx + 1; i < closeIdx; i++) {
+        const t = f.tokens[i];
+        if (t.channel === antlr4ts_1.Token.HIDDEN_CHANNEL)
+            continue;
+        if (t.type === tokens_1.L.OPAREN || t.type === tokens_1.L.OBRACK || t.type === tokens_1.L.OCURLY)
+            depth++;
+        else if (t.type === tokens_1.L.CPAREN || t.type === tokens_1.L.CBRACK || t.type === tokens_1.L.CCURLY)
+            depth--;
+        else if (t.type === tokens_1.L.COMMA && depth === 0)
+            return true;
+    }
+    return false;
+}
+// The big switch. Each branch ends with `note(...)`.
+function emitVisibleToken(f, t, idx) {
+    var _a, _b;
+    if (idx <= f.lastEmittedIdx)
+        return; // already emitted (e.g. SQL block range)
+    flushHiddenBefore(f, idx);
+    const text = (_a = t.text) !== null && _a !== void 0 ? _a : '';
+    // ---- Verbatim regions: SQL strings and block annotations ----
+    // We don't own a SQL formatter. Annotation indentation is significant.
+    if (t.type === tokens_1.L.SQL_BEGIN) {
+        const endIdx = (0, tokens_1.findMatching)(f.tokens, idx, tokens_1.L.SQL_BEGIN, tokens_1.L.SQL_END);
+        const stop = f.tokens[endIdx].stopIndex;
+        f.o.space();
+        f.o.text(f.src.substring(t.startIndex, stop + 1));
+        note(f, tokens_1.L.SQL_END, endIdx, f.tokens[endIdx]);
+        return;
+    }
+    if (t.type === tokens_1.L.BLOCK_ANNOTATION_BEGIN ||
+        t.type === tokens_1.L.DOC_BLOCK_ANNOTATION_BEGIN) {
+        const endIdx = (0, tokens_1.findMatching)(f.tokens, idx, t.type, tokens_1.L.BLOCK_ANNOTATION_END);
+        const stop = f.tokens[endIdx].stopIndex;
+        if (f.o.indent === 0)
+            startStatementLine(f);
+        else
+            f.o.nl();
+        f.o.text(f.src.substring(t.startIndex, stop + 1));
+        f.o.nl();
+        note(f, tokens_1.L.BLOCK_ANNOTATION_END, endIdx, f.tokens[endIdx]);
+        return;
+    }
+    // ---- Single-line annotations on their own line ----
+    if (t.type === tokens_1.L.ANNOTATION || t.type === tokens_1.L.DOC_ANNOTATION) {
+        if (f.o.indent === 0)
+            startStatementLine(f);
+        else
+            f.o.nl();
+        f.o.text(text.replace(/\s+$/, ''));
+        f.o.nl();
+        note(f, t.type, idx, t);
+        return;
+    }
+    // ---- Curly braces: indent in/out around block bodies ----
+    if (t.type === tokens_1.L.OCURLY) {
+        f.o.space();
+        f.o.text('{');
+        f.o.indent++;
+        f.o.nl();
+        note(f, t.type, idx, t);
+        return;
+    }
+    if (t.type === tokens_1.L.CCURLY) {
+        f.o.indent = Math.max(0, f.o.indent - 1);
+        f.o.nl();
+        f.o.text('}');
+        if (f.o.indent === 0)
+            f.needBlank = true;
+        note(f, t.type, idx, t);
+        return;
+    }
+    // ---- Statement separators ----
+    // `;` in wrapped form is dropped — newlines do the job. (Inline `;` appears
+    // via renderItemInline, not here.)
+    if (t.type === tokens_1.L.SEMI) {
+        f.o.trimTrailingSpace();
+        f.o.nl();
+        if (f.o.indent === 0)
+            f.needBlank = true;
+        note(f, t.type, idx, t);
+        return;
+    }
+    // ---- Commas ----
+    // At top level (parenDepth==0) → newline. Inside parens that the wrap logic
+    // flagged as multi-line → newline. Otherwise inline (just space).
+    if (t.type === tokens_1.L.COMMA) {
+        f.o.trimTrailingSpace();
+        f.o.text(',');
+        const innerBreaks = f.parenBreaks.length > 0 && f.parenBreaks[f.parenBreaks.length - 1];
+        if (f.parenDepth === 0 || innerBreaks)
+            f.o.nl();
+        note(f, t.type, idx, t);
+        return;
+    }
+    // ---- Open paren / bracket: decide call-hug vs grouping, decide wrap ----
+    if (t.type === tokens_1.L.OPAREN || t.type === tokens_1.L.OBRACK) {
+        const action = (0, tokens_1.leadingAction)(f.lastEmittedType, t.type);
+        if (action === 'space')
+            f.o.space();
+        f.o.text(text);
+        // Decide whether the contents will exceed the line budget when laid out
+        // inline. Break only if there's somewhere useful to break:
+        //   - call/subscript parens (action='hug'): must have ≥ 2 args (commas at
+        //     this depth);
+        //   - grouping parens (action='space'): any overflow — content's own
+        //     rules will wrap.
+        const closeType = t.type === tokens_1.L.OPAREN ? tokens_1.L.CPAREN : tokens_1.L.CBRACK;
+        const matchIdx = (0, tokens_1.findMatching)(f.tokens, idx, t.type, closeType);
+        const inlineLen = approxInlineSpan(f, idx, matchIdx);
+        const wouldOverflow = f.o.lineLengthSoFar() + inlineLen > tokens_1.LINE_BUDGET;
+        const hasArgCommas = hasCommaAtDepth1(f, idx, matchIdx);
+        const isCall = action === 'hug';
+        const willBreak = wouldOverflow && (hasArgCommas || !isCall);
+        f.parenBreaks.push(willBreak);
+        f.parenDepth++;
+        if (willBreak) {
+            f.o.indent++;
+            f.o.nl();
+        }
+        note(f, t.type, idx, t);
+        return;
+    }
+    if (t.type === tokens_1.L.CPAREN || t.type === tokens_1.L.CBRACK) {
+        const wasBreak = (_b = f.parenBreaks.pop()) !== null && _b !== void 0 ? _b : false;
+        if (wasBreak) {
+            f.o.indent = Math.max(0, f.o.indent - 1);
+            f.o.nl();
+        }
+        else {
+            f.o.trimTrailingSpace();
+        }
+        f.o.text(text);
+        f.parenDepth = Math.max(0, f.parenDepth - 1);
+        note(f, t.type, idx, t);
+        return;
+    }
+    // ---- Section keyword fallback (no explicit handler took it) ----
+    // Inside a brace block, force a fresh line. Keeps v1-style readable output
+    // even for sections we don't yet handle.
+    if (tokens_1.SECTION_TOKENS.has(t.type) && f.o.indent > 0) {
+        f.o.nl();
+        f.o.text(text.replace(/\s+/g, ''));
+        note(f, t.type, idx, t);
+        return;
+    }
+    // ---- Top-level statement starter ----
+    if (tokens_1.TOP_LEVEL_STARTERS.has(t.type) &&
+        f.o.indent === 0 &&
+        f.parenDepth === 0) {
+        startStatementLine(f);
+        f.o.text(text.replace(/\s+/g, ''));
+        note(f, t.type, idx, t);
+        return;
+    }
+    // ---- Default: identifier / literal / keyword / DOT / COLON / TRIPLECOLON
+    //      / binary op. Leading separator from the classifier; binary ops also
+    //      get a trailing space.
+    const action = (0, tokens_1.leadingAction)(f.lastEmittedType, t.type);
+    if (action === 'glue')
+        f.o.trimTrailingSpace();
+    else if (action === 'space')
+        f.o.space();
+    // 'hug' — emit nothing before
+    f.o.text(text);
+    if (tokens_1.BINARY_OPS.has(t.type))
+        f.o.space();
+    note(f, t.type, idx, t);
+}
+// Emit each visible token in [fromIdx, toIdx] via the leaf walker.
+function formatTokenRange(f, fromIdx, toIdx) {
+    for (let i = fromIdx; i <= toIdx; i++) {
+        const t = f.tokens[i];
+        if (t.channel !== antlr4ts_1.Token.HIDDEN_CHANNEL && t.type !== antlr4ts_1.Token.EOF) {
+            emitVisibleToken(f, t, i);
+        }
+    }
+}
+//# sourceMappingURL=leaf.js.map

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

@@ -0,0 +1,12 @@
+export declare class Out {
+    buf: string;
+    indent: number;
+    text(s: string): void;
+    space(): void;
+    nl(): void;
+    blank(): void;
+    trimTrailingSpace(): void;
+    trimTrailingNewlines(): void;
+    lineLengthSoFar(): number;
+    toString(): string;
+}

package/dist/lang/prettify/out.js

@@ -0,0 +1,74 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Out = void 0;
+const tokens_1 = require("./tokens");
+// Append-only buffer with helpers for indentation, single-space coalescing,
+// and newlines. Knows nothing about Malloy; the formatting rules call into it.
+class Out {
+    constructor() {
+        this.buf = '';
+        this.indent = 0;
+    }
+    // Append text. If the buffer ended with a newline, prepend the current
+    // indent first so the new text starts at the right column.
+    text(s) {
+        if (this.buf.endsWith('\n'))
+            this.buf += tokens_1.INDENT_STR.repeat(this.indent);
+        this.buf += s;
+    }
+    // Append at most one space. No-op at start of buffer, after newline, or
+    // after `(`, `[`, `.` (so `f(x` stays glued).
+    space() {
+        if (this.buf.length === 0)
+            return;
+        const last = this.buf[this.buf.length - 1];
+        if (last === ' ' ||
+            last === '\n' ||
+            last === '(' ||
+            last === '[' ||
+            last === '.')
+            return;
+        this.buf += ' ';
+    }
+    // Force the next emit onto a new line. Trailing spaces are stripped.
+    nl() {
+        if (this.buf.length === 0)
+            return;
+        this.buf = this.buf.replace(/ +$/, '');
+        if (!this.buf.endsWith('\n'))
+            this.buf += '\n';
+    }
+    // Force a blank line before the next emit. No-op at start of buffer.
+    blank() {
+        if (this.buf.length === 0)
+            return;
+        this.nl();
+        if (!this.buf.endsWith('\n\n'))
+            this.buf += '\n';
+    }
+    trimTrailingSpace() {
+        this.buf = this.buf.replace(/ +$/, '');
+    }
+    trimTrailingNewlines() {
+        this.buf = this.buf.replace(/\n+$/, '');
+    }
+    // The column the next emit will land at. When the buffer ends with a
+    // newline the indent isn't yet in `buf`, so we have to add the pending
+    // indent width to predict where the next text will appear.
+    lineLengthSoFar() {
+        if (this.buf.length === 0 || this.buf.endsWith('\n')) {
+            return this.indent * tokens_1.INDENT_STR.length;
+        }
+        const lastNl = this.buf.lastIndexOf('\n');
+        return this.buf.length - (lastNl + 1);
+    }
+    toString() {
+        return this.buf.replace(/\n*$/, '\n');
+    }
+}
+exports.Out = Out;
+//# sourceMappingURL=out.js.map

package/dist/lang/prettify/pick-case.d.ts

@@ -0,0 +1,5 @@
+import * as parser from '../lib/Malloy/MalloyParser';
+import type { Formatter } from './formatter';
+export declare function formatPickStatement(f: Formatter, ctx: parser.PickStatementContext): void;
+export declare function formatPick(f: Formatter, ctx: parser.PickContext): void;
+export declare function formatCaseStatement(f: Formatter, ctx: parser.CaseStatementContext): void;