Function serializeToStringArray

src/Source.ts:197–261

(source: Source)

    }

    function serializeToStringArray(source: Source): void {
        switch (source.kind) {
            case "text":
                indentIfNeeded();
                currentLine.push(source.text);
                break;
            case "newline":
                finishLine();
                indent += source.indentationChange;
                indentNeeded = indent;
                break;
            case "sequence":
                source.sequence.forEach((s: Source) => serializeToStringArray(s));
                break;
            case "table":
                const t = source.table;
                const widths = t
                    .map((l: List<Source>) => l.map((s: Source) => sourceLineLength(s, names)).toList())
                    .toList();
                const numRows = t.size;
                if (numRows === 0) break;
                const numColumns = defined(t.map((l: List<Source>) => l.size).max());
                if (numColumns === 0) break;
                const columnWidths = defined(
                    Range(0, numColumns).map((i: number) => widths.map((l: List<number>) => l.get(i) || 0).max())
                );
                for (let y = 0; y < numRows; y++) {
                    indentIfNeeded();
                    const row = defined(t.get(y));
                    const rowWidths = defined(widths.get(y));
                    for (let x = 0; x < numColumns; x++) {
                        const colWidth = defined(columnWidths.get(x));
                        const src = row.get(x) || { kind: "text", text: "" };
                        const srcWidth = rowWidths.get(x) || 0;
                        serializeToStringArray(src);
                        if (x < numColumns - 1 && srcWidth < colWidth) {
                            currentLine.push(_.repeat(" ", colWidth - srcWidth));
                        }
                    }
                    if (y < numRows - 1) {
                        finishLine();
                        indentNeeded = indent;
                    }
                }
                break;
            case "annotated":
                const start = currentLocation();
                serializeToStringArray(source.source);
                const end = currentLocation();
                annotations.push({ annotation: source.annotation, span: { start, end } });
                break;
            case "name":
                assert(names.has(source.named), "No name for Named");
                indentIfNeeded();
                currentLine.push(defined(names.get(source.named)));
                break;
            case "modified":
                const serialized = serializeRenderResult({ rootSource: source.source, names }, indentation).lines;