@isentinel/eslint-plugin-comment-length/lib/rules/limit-multi-line-comments/util.capture-next-block.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.captureNextBlock = void 0;
const is_line_overflowing_1 = require("../../utils/is-line-overflowing");
/**
 * captures the next logical group/block in the provided multi-line comment
 * content, based on a set of rules.
 *
 * 1) Everything within a set of back-ticks (``) is ignored, as this is used
 * to explicitly declare that the content should not be auto-fixed.
 *
 * 2) Lines that are not on the same indentation-level will not be recognized
 * as part of the same block.
 *
 * 3) Lines separated by a new-line will not be considered as part of the same
 * block.
 *
 * 4) Lines will only be grouped in case the current line of the block to be
 * constructed actually is overflowing. This avoids issues where auto-fixing
 * 'sucks' a line up even though the previous line should have been considered
 * a logical end to a block.
 */
function captureNextBlock(ignoreFollowingLines, initialStartIndex, context) {
    let ignoreLines = ignoreFollowingLines;
    let startIndex = initialStartIndex;
    // the provided startIndex may not necessarily indicate the startIndex of the
    // next logical block. (it may e.g. just point to a blank line)
    // as such we need to determine the actual start of the next block.
    for (let i = initialStartIndex; i < context.comment.lines.length; i++) {
        const line = context.comment.lines[i];
        // ensure that lines within backticks is skipped (and that the line itself
        // is ignored as it acts as a marker).
        if (line?.trimStart().startsWith("` ") ||
            line?.trimStart().startsWith("``")) {
            ignoreLines = !ignoreLines;
            continue;
        }
        startIndex = i;
        if (line && line.trim() !== "" && !ignoreLines) {
            break;
        }
    }
    const blockLines = context.comment.lines.slice(startIndex, startIndex + 1);
    // In case we could not resolve the start of a new block, then we cannot
    // continue...
    if (blockLines.length === 0) {
        return [
            {
                lines: blockLines,
                startIndex,
                endIndex: startIndex,
                lineOffsets: [],
            },
            ignoreLines,
        ];
    }
    // ... else we can begin analysing the following lines to determine if they
    // are to be added to the current group
    for (let i = startIndex; i < context.comment.lines.length; i++) {
        const currLine = context.comment.lines[i];
        const nextLine = context.comment.lines[i + 1];
        if (!currLine) {
            break;
        }
        const currLineOffset = currLine
            .match(/^( |\t)*/)?.[0]
            ?.split("")
            .reduce((acc, curr) => acc + (curr === "\t" ? context.tabSize : 1), 0) ?? 0;
        const nextLineOffset = nextLine
            ?.match(/^( |\t)*/)?.[0]
            ?.split("")
            .reduce((acc, curr) => acc + (curr === "\t" ? context.tabSize : 1), 0) ?? 0;
        if (!nextLine ||
            nextLine.trim() === "" ||
            currLineOffset !== nextLineOffset ||
            (context.mode === "overflow-only" &&
                !(0, is_line_overflowing_1.isLineOverflowing)(`${currLine} ${nextLine.trimStart().split(" ")[0] ?? ""}`.trimEnd(), context))) {
            return [
                {
                    lines: blockLines,
                    startIndex,
                    endIndex: i,
                    lineOffsets: blockLines.map((it, lineIndex) => {
                        const whitespaceString = context.comment.value
                            .split("\n")[startIndex + lineIndex]?.includes("*")
                            ? it.match(/^( |\t)*/)?.[0] ?? ""
                            : " ";
                        return {
                            string: whitespaceString,
                            size: whitespaceString
                                .split("")
                                .reduce((acc, curr) => acc + (curr === "\t" ? context.tabSize : 1), 0) ?? 0,
                        };
                    }),
                },
                ignoreLines,
            ];
        }
        blockLines.push(nextLine);
    }
    return [
        {
            lines: blockLines,
            startIndex,
            endIndex: context.comment.lines.length,
            lineOffsets: blockLines.map((it, lineIndex) => {
                const whitespaceString = context.comment.value
                    .split("\n")[startIndex + lineIndex]?.includes("*")
                    ? it.match(/^( |\t)*/)?.[0] ?? ""
                    : " ";
                return {
                    string: whitespaceString,
                    size: whitespaceString
                        .split("")
                        .reduce((acc, curr) => acc + (curr === "\t" ? context.tabSize : 1), 0) ?? 0,
                };
            }),
        },
        ignoreLines,
    ];
}
exports.captureNextBlock = captureNextBlock;
//# sourceMappingURL=util.capture-next-block.js.map