@malloydata/malloy 0.0.385 → 0.0.387

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;

package/dist/lang/prettify/pick-case.js

@@ -0,0 +1,222 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * RULE: PICK — formatPickStatement / formatPickAligned / formatPick
+ *
+ *   pickStatement: pick+ (ELSE pickElse=fieldExpr)?
+ *
+ * Inline if the whole thing fits. Otherwise:
+ *   - each pick on its own line at +1 indent
+ *   - column-align WHEN across picks (pad shorter values)
+ *   - else aligns with `pick` (no value padding for else)
+ *   - if a single pick still doesn't fit when aligned, break that pick at WHEN
+ *     onto two lines.
+ *
+ * RULE: CASE — formatCaseStatement / formatCaseWhen
+ *
+ *   caseStatement: CASE valueExpr? (caseWhen)+ (ELSE caseElse)? END
+ *
+ * Inline if it fits. Otherwise:
+ *   case [valueExpr]
+ *     when COND_A   then RESULT_A
+ *     when LONGCOND then RESULT_B
+ *     else FALLBACK
+ *   end
+ * THEN keyword column-aligns across whens (pad shorter conditions). ELSE/END
+ * live at the case's own indent. If an aligned when still overflows, break it
+ * at THEN onto two lines.
+ */
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPickStatement = formatPickStatement;
+exports.formatPick = formatPick;
+exports.formatCaseStatement = formatCaseStatement;
+const tree_1 = require("antlr4ts/tree");
+const parser = __importStar(require("../lib/Malloy/MalloyParser"));
+const tokens_1 = require("./tokens");
+const leaf_1 = require("./leaf");
+const inline_renderer_1 = require("./inline-renderer");
+function formatPickStatement(f, ctx) {
+    const startIdx = ctx._start.tokenIndex;
+    const stopIdx = ctx._stop.tokenIndex;
+    const inlineLen = (0, leaf_1.approxInlineSpan)(f, startIdx, stopIdx);
+    const hasComments = (0, leaf_1.hasCommentsInRange)(f, startIdx, stopIdx);
+    if (!hasComments && f.o.lineLengthSoFar() + 1 + inlineLen <= tokens_1.LINE_BUDGET) {
+        for (let i = 0; i < ctx.childCount; i++)
+            f.format(ctx.getChild(i));
+        return;
+    }
+    const picks = ctx.pick();
+    const elseTok = ctx.ELSE();
+    const elseExpr = ctx.fieldExpr();
+    const valueStrs = picks.map(p => p._pickValue ? (0, inline_renderer_1.renderItemInline)(f, p._pickValue) : '');
+    const maxValueLen = valueStrs.reduce((m, s) => Math.max(m, s.length), 0);
+    // Use flushHiddenBefore (the leaf walker's emitter) to flush gap comments
+    // between picks. Critical: it advances f.lastEmittedIdx, so when the next
+    // pick takes the broken-at-WHEN form (which goes through f.format → emit-
+    // VisibleToken → flushHiddenBefore), the gap won't be re-emitted.
+    f.o.indent++;
+    for (let i = 0; i < picks.length; i++) {
+        (0, leaf_1.flushHiddenBefore)(f, picks[i]._start.tokenIndex);
+        f.o.nl();
+        formatPickAligned(f, picks[i], maxValueLen);
+    }
+    if (elseTok && elseExpr) {
+        (0, leaf_1.flushHiddenBefore)(f, elseTok.symbol.tokenIndex);
+        f.o.nl();
+        f.format(elseTok);
+        f.format(elseExpr);
+    }
+    f.o.indent--;
+}
+function formatPickAligned(f, pick, maxValueLen) {
+    const valueStr = pick._pickValue ? (0, inline_renderer_1.renderItemInline)(f, pick._pickValue) : '';
+    const condStr = (0, inline_renderer_1.renderItemInline)(f, pick._pickWhen);
+    const padding = ' '.repeat(maxValueLen - valueStr.length);
+    const aligned = valueStr
+        ? `pick ${valueStr}${padding} when ${condStr}`
+        : `pick${padding ? ' ' + padding : ''} when ${condStr}`;
+    // Aligned form drops comments (renderItemInline skips them). If this pick
+    // has internal comments, fall through to the broken-at-WHEN form which uses
+    // f.format() and preserves them.
+    const hasComments = (0, leaf_1.hasCommentsInRange)(f, pick._start.tokenIndex, pick._stop.tokenIndex);
+    if (!hasComments && f.o.lineLengthSoFar() + aligned.length <= tokens_1.LINE_BUDGET) {
+        // Aligned form: emit as a single pre-rendered string so the spacing
+        // between value and `when` is exact regardless of padding width.
+        f.o.text(aligned);
+        (0, leaf_1.note)(f, pick._stop.type, pick._stop.tokenIndex, pick._stop);
+        return;
+    }
+    // Doesn't fit even aligned — break at WHEN, no padding.
+    f.format(pick.PICK());
+    if (pick._pickValue)
+        f.format(pick._pickValue);
+    // Flush hidden tokens between value and WHEN BEFORE the line break, so
+    // same-line comments stay attached to the value's line and the formatted
+    // output is idempotent on a re-parse.
+    (0, leaf_1.flushHiddenBefore)(f, pick.WHEN().symbol.tokenIndex);
+    f.o.nl();
+    f.format(pick.WHEN());
+    f.format(pick._pickWhen);
+}
+// pick: PICK pickValue? WHEN pickWhen
+// Inline if fits; otherwise break at WHEN. (Used when this pick is dispatched
+// outside of a pickStatement context, which is rare but possible.)
+function formatPick(f, ctx) {
+    const inlineLen = (0, leaf_1.approxInlineSpan)(f, ctx._start.tokenIndex, ctx._stop.tokenIndex);
+    if (f.o.lineLengthSoFar() + 1 + inlineLen <= tokens_1.LINE_BUDGET) {
+        for (let i = 0; i < ctx.childCount; i++)
+            f.format(ctx.getChild(i));
+        return;
+    }
+    for (let i = 0; i < ctx.childCount; i++) {
+        const c = ctx.getChild(i);
+        if (c instanceof tree_1.TerminalNode && c.symbol.type === tokens_1.L.WHEN) {
+            // Flush any hidden tokens between the previous child and WHEN before
+            // the line break, so same-line comments stay attached.
+            (0, leaf_1.flushHiddenBefore)(f, c.symbol.tokenIndex);
+            f.o.nl();
+        }
+        f.format(c);
+    }
+}
+function formatCaseStatement(f, ctx) {
+    const startIdx = ctx._start.tokenIndex;
+    const stopIdx = ctx._stop.tokenIndex;
+    const inlineLen = (0, leaf_1.approxInlineSpan)(f, startIdx, stopIdx);
+    const hasComments = (0, leaf_1.hasCommentsInRange)(f, startIdx, stopIdx);
+    if (!hasComments && f.o.lineLengthSoFar() + 1 + inlineLen <= tokens_1.LINE_BUDGET) {
+        for (let i = 0; i < ctx.childCount; i++)
+            f.format(ctx.getChild(i));
+        return;
+    }
+    const whens = ctx.caseWhen();
+    const condStrs = whens.map(w => (0, inline_renderer_1.renderItemInline)(f, w._condition));
+    const maxCondLen = condStrs.reduce((m, s) => Math.max(m, s.length), 0);
+    f.o.indent++;
+    for (let i = 0; i < ctx.childCount; i++) {
+        const c = ctx.getChild(i);
+        if (c instanceof parser.CaseWhenContext) {
+            (0, leaf_1.flushHiddenBefore)(f, c._start.tokenIndex);
+            f.o.nl();
+            formatCaseWhen(f, c, maxCondLen);
+            continue;
+        }
+        if (c instanceof tree_1.TerminalNode && c.symbol.type === tokens_1.L.ELSE) {
+            (0, leaf_1.flushHiddenBefore)(f, c.symbol.tokenIndex);
+            f.o.nl();
+            f.format(c);
+            // emit the else expression on the same line
+            i++;
+            if (i < ctx.childCount)
+                f.format(ctx.getChild(i));
+            continue;
+        }
+        if (c instanceof tree_1.TerminalNode && c.symbol.type === tokens_1.L.END) {
+            (0, leaf_1.flushHiddenBefore)(f, c.symbol.tokenIndex);
+            f.o.indent--;
+            f.o.nl();
+            f.format(c);
+            f.o.indent++;
+            continue;
+        }
+        // CASE keyword and optional valueExpr stay on the head line.
+        f.format(c);
+    }
+    f.o.indent--;
+}
+function formatCaseWhen(f, ctx, maxCondLen) {
+    const condStr = (0, inline_renderer_1.renderItemInline)(f, ctx._condition);
+    const resultStr = (0, inline_renderer_1.renderItemInline)(f, ctx._result);
+    const padding = ' '.repeat(maxCondLen - condStr.length);
+    const aligned = `when ${condStr}${padding} then ${resultStr}`;
+    const hasComments = (0, leaf_1.hasCommentsInRange)(f, ctx._start.tokenIndex, ctx._stop.tokenIndex);
+    if (!hasComments && f.o.lineLengthSoFar() + aligned.length <= tokens_1.LINE_BUDGET) {
+        f.o.text(aligned);
+        (0, leaf_1.note)(f, ctx._stop.type, ctx._stop.tokenIndex, ctx._stop);
+        return;
+    }
+    // Doesn't fit aligned — break at THEN. Flush comments between condition
+    // and THEN before the break for same-line attachment.
+    f.format(ctx.WHEN());
+    f.format(ctx._condition);
+    (0, leaf_1.flushHiddenBefore)(f, ctx.THEN().symbol.tokenIndex);
+    f.o.nl();
+    f.format(ctx.THEN());
+    f.format(ctx._result);
+}
+//# sourceMappingURL=pick-case.js.map

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

@@ -0,0 +1,13 @@
+import type { ParserRuleContext } from 'antlr4ts';
+export type ItemKind = 'fieldEntry' | 'nestEntry' | 'fieldDef' | 'fieldName' | 'collectionMember' | 'orderBySpec' | 'fieldExpr' | 'joinDef' | 'includeField' | 'indexElement';
+export interface SectionRule {
+    ctxClass: new (...args: never[]) => ParserRuleContext;
+    keywordTypes: number[];
+    list: (ctx: ParserRuleContext) => ParserRuleContext | undefined;
+    itemKind: ItemKind;
+}
+export declare const SECTION_STATEMENT_RULES: SectionRule[];
+export declare const STATEMENT_KIND_BY_CTX: Array<{
+    ctxClass: new (...args: never[]) => ParserRuleContext;
+    kind: string;
+}>;

package/dist/lang/prettify/rules.js

@@ -0,0 +1,111 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * Section-statement dispatch table and statement-kind labels.
+ *
+ * SECTION_STATEMENT_RULES is the table of `keyword: items` rules that need
+ * flow-fill, column alignment, or annotation-aware item handling. Section
+ * keywords NOT in this table fall through to the leaf walker, which produces
+ * correct-but-plain output. Add a row here only when the default isn't good
+ * enough.
+ *
+ * STATEMENT_KIND_BY_CTX is the coarse grouping used by the block-body rule
+ * to decide whether two adjacent statements should preserve a user-supplied
+ * blank line (different kinds: yes; same kind: no).
+ *
+ * A maintainer adding a new section-statement lands here first.
+ */
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATEMENT_KIND_BY_CTX = exports.SECTION_STATEMENT_RULES = void 0;
+const parser = __importStar(require("../lib/Malloy/MalloyParser"));
+const tokens_1 = require("./tokens");
+// Constructs a SectionRule with the list-accessor closure typed against the
+// concrete context class. The single internal narrowing is justified: the
+// dispatcher only invokes `rule.list(node)` after `node instanceof
+// rule.ctxClass`, so at runtime the parameter really is of type `C`.
+function rule(ctxClass, keywordTypes, list, itemKind) {
+    return {
+        ctxClass,
+        keywordTypes,
+        list: ctx => list(ctx),
+        itemKind,
+    };
+}
+exports.SECTION_STATEMENT_RULES = [
+    rule(parser.AggregateStatementContext, [tokens_1.L.AGGREGATE], c => c.queryFieldList(), 'fieldEntry'),
+    rule(parser.GroupByStatementContext, [tokens_1.L.GROUP_BY], c => c.queryFieldList(), 'fieldEntry'),
+    rule(parser.CalculateStatementContext, [tokens_1.L.CALCULATE], c => c.queryFieldList(), 'fieldEntry'),
+    rule(parser.NestStatementContext, [tokens_1.L.NEST], c => c.nestedQueryList(), 'nestEntry'),
+    rule(parser.DeclareStatementContext, [tokens_1.L.DECLARE], c => c.defList(), 'fieldDef'),
+    rule(parser.DefMeasuresContext, [tokens_1.L.MEASURE], c => c.defList(), 'fieldDef'),
+    rule(parser.DefDimensionsContext, [tokens_1.L.DIMENSION], c => c.defList(), 'fieldDef'),
+    rule(parser.DefExploreEditFieldContext, [tokens_1.L.ACCEPT, tokens_1.L.EXCEPT], c => c.fieldNameList(), 'fieldName'),
+    rule(parser.ProjectStatementContext, [tokens_1.L.SELECT], c => c.fieldCollection(), 'collectionMember'),
+    rule(parser.OrderByStatementContext, [tokens_1.L.ORDER_BY], c => c.ordering(), 'orderBySpec'),
+    rule(parser.WhereStatementContext, [tokens_1.L.WHERE], c => c.filterClauseList(), 'fieldExpr'),
+    rule(parser.HavingStatementContext, [tokens_1.L.HAVING], c => c.filterClauseList(), 'fieldExpr'),
+    rule(parser.DefJoinOneContext, [tokens_1.L.JOIN_ONE], c => c.joinList(), 'joinDef'),
+    rule(parser.DefJoinManyContext, [tokens_1.L.JOIN_MANY], c => c.joinList(), 'joinDef'),
+    rule(parser.DefJoinCrossContext, [tokens_1.L.JOIN_CROSS], c => c.joinList(), 'joinDef'),
+    // include block items: `public: a, b`, `internal: x, y, z`. The keyword
+    // (PUBLIC/PRIVATE/INTERNAL) lives one level down inside accessLabelProp;
+    // findKeyword in ./sections handles that nested case.
+    rule(parser.IncludeItemContext, [tokens_1.L.PUBLIC, tokens_1.L.PRIVATE, tokens_1.L.INTERNAL], c => c.includeList(), 'includeField'),
+    rule(parser.IndexStatementContext, [tokens_1.L.INDEX], c => c.indexFields(), 'indexElement'),
+];
+// Coarse statement-kind labels for the same-kind-no-blank rule in block
+// bodies. Different kinds preserve a single user-supplied blank line.
+exports.STATEMENT_KIND_BY_CTX = [
+    { ctxClass: parser.JoinStatementContext, kind: 'join' },
+    { ctxClass: parser.QueryJoinStatementContext, kind: 'join' },
+    { ctxClass: parser.DefMeasuresContext, kind: 'measure' },
+    { ctxClass: parser.DefDimensionsContext, kind: 'dimension' },
+    { ctxClass: parser.DeclareStatementContext, kind: 'declare' },
+    { ctxClass: parser.AggregateStatementContext, kind: 'aggregate' },
+    { ctxClass: parser.GroupByStatementContext, kind: 'group_by' },
+    { ctxClass: parser.CalculateStatementContext, kind: 'calculate' },
+    { ctxClass: parser.NestStatementContext, kind: 'nest' },
+    { ctxClass: parser.WhereStatementContext, kind: 'where' },
+    { ctxClass: parser.HavingStatementContext, kind: 'having' },
+    { ctxClass: parser.OrderByStatementContext, kind: 'order_by' },
+    { ctxClass: parser.ProjectStatementContext, kind: 'select' },
+    { ctxClass: parser.DefExploreEditFieldContext, kind: 'edit_field' },
+    { ctxClass: parser.DefExploreRenameContext, kind: 'rename' },
+    { ctxClass: parser.DefExploreQueryContext, kind: 'view' },
+];
+//# sourceMappingURL=rules.js.map

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

@@ -0,0 +1,4 @@
+import { ParserRuleContext } from 'antlr4ts';
+import type { Formatter } from './formatter';
+import type { SectionRule } from './rules';
+export declare function formatSectionStatement(f: Formatter, stmt: ParserRuleContext, rule: SectionRule): void;