prettier-plugin-java 2.6.0 → 2.6.1

package/dist/printers/comments/comments-utils.js

@@ -1,21 +0,0 @@
-export function hasLeadingComments(token) {
-    return token.leadingComments !== undefined;
-}
-export function hasTrailingComments(token) {
-    return token.trailingComments !== undefined;
-}
-export function hasLeadingLineComments(token) {
-    return (token.leadingComments !== undefined &&
-        token.leadingComments.length !== 0 &&
-        token.leadingComments[token.leadingComments.length - 1].tokenType.name ===
-            "LineComment");
-}
-export function hasTrailingLineComments(token) {
-    return (token.trailingComments !== undefined &&
-        token.trailingComments.length !== 0 &&
-        token.trailingComments[token.trailingComments.length - 1].tokenType.name ===
-            "LineComment");
-}
-export function hasComments(token) {
-    return hasLeadingComments(token) || hasTrailingComments(token);
-}

package/dist/printers/comments/format-comments.js

@@ -1,171 +0,0 @@
-import { builders } from "prettier/doc";
-import { isCstElementOrUndefinedIToken } from "../../types/utils.js";
-import { doc } from "prettier";
-import isEmptyDoc from "../../utils/isEmptyDoc.js";
-const { hardline, lineSuffix, breakParent, literalline } = builders;
-/**
- * Takes a token and return a doc with:
- * - concatenated leading comments
- * - the token image
- * - concatenated trailing comments
- *
- * @param {IToken} token
- * @return a doc with the token and its comments
- */
-export function printTokenWithComments(token) {
-    return printWithComments(token, token.image.includes("\n")
-        ? doc.utils.replaceEndOfLine(token.image)
-        : token.image, getTokenLeadingComments, getTokenTrailingComments);
-}
-/**
- * Takes a node and return a doc with:
- * - concatenated leading comments
- * - the node doc value
- * - concatenated trailing comments
- *
- * @param {CstNode} node
- * @param {Doc} value - the converted node value
- * @return a doc with the token and its comments
- */
-export function printNodeWithComments(node, value) {
-    return printWithComments(node, value, getNodeLeadingComments, getNodeTrailingComments);
-}
-function printWithComments(nodeOrToken, value, getLeadingComments, getTrailingComments) {
-    const leadingComments = getLeadingComments(nodeOrToken);
-    const trailingComments = getTrailingComments(nodeOrToken, value);
-    return leadingComments.length === 0 && trailingComments.length === 0
-        ? value
-        : [...leadingComments, value, ...trailingComments];
-}
-/**
- * @param {IToken} token
- * @return an array containing processed leading comments and separators
- */
-export function getTokenLeadingComments(token) {
-    return getLeadingComments(token, token);
-}
-/**
- * @param {CstNode} node
- * @return an array containing processed leading comments and separators
- */
-function getNodeLeadingComments(node) {
-    return getLeadingComments(node, node.location);
-}
-function getLeadingComments(nodeOrToken, location) {
-    const arr = [];
-    if (nodeOrToken.leadingComments !== undefined) {
-        let previousEndLine = nodeOrToken.leadingComments[0].endLine;
-        let step;
-        arr.push(formatComment(nodeOrToken.leadingComments[0]));
-        for (let i = 1; i < nodeOrToken.leadingComments.length; i++) {
-            step = nodeOrToken.leadingComments[i].startLine - previousEndLine;
-            if (step === 1 ||
-                nodeOrToken.leadingComments[i].startOffset > location.startOffset) {
-                arr.push(hardline);
-            }
-            else if (step > 1) {
-                arr.push(hardline, hardline);
-            }
-            arr.push(formatComment(nodeOrToken.leadingComments[i]));
-            previousEndLine = nodeOrToken.leadingComments[i].endLine;
-        }
-        step = location.startLine - previousEndLine;
-        if (step === 1 ||
-            nodeOrToken.leadingComments[nodeOrToken.leadingComments.length - 1]
-                .startOffset > location.startOffset) {
-            arr.push(hardline);
-        }
-        else if (step > 1) {
-            arr.push(hardline, hardline);
-        }
-    }
-    return arr;
-}
-/**
- * @param {IToken} token
- * @return an array containing processed trailing comments and separators
- */
-function getTokenTrailingComments(token) {
-    return getTrailingComments(token, token.image, token);
-}
-/**
- * @param {CstNode} node
- * @param {string} value
- * @return an array containing processed trailing comments and separators
- */
-function getNodeTrailingComments(node, value) {
-    return getTrailingComments(node, value, node.location);
-}
-function getTrailingComments(nodeOrToken, value, location) {
-    const arr = [];
-    let previousEndLine = location.endLine;
-    if (nodeOrToken.trailingComments !== undefined) {
-        nodeOrToken.trailingComments.forEach((comment, idx) => {
-            let separator = "";
-            if (comment.startLine !== previousEndLine) {
-                arr.push(hardline);
-            }
-            else if (!isEmptyDoc(value) && idx === 0) {
-                separator = " ";
-            }
-            if (comment.tokenType.name === "LineComment") {
-                arr.push(lineSuffix([separator, formatComment(comment), breakParent]));
-            }
-            else {
-                arr.push(formatComment(comment));
-            }
-            previousEndLine = comment.endLine;
-        });
-    }
-    return arr;
-}
-function isJavaDoc(comment, lines) {
-    let isJavaDoc = true;
-    if (comment.tokenType.name === "TraditionalComment" && lines.length > 1) {
-        for (let i = 1; i < lines.length; i++) {
-            if (lines[i].trim().charAt(0) !== "*") {
-                isJavaDoc = false;
-                break;
-            }
-        }
-    }
-    else {
-        isJavaDoc = false;
-    }
-    return isJavaDoc;
-}
-function formatJavaDoc(lines) {
-    const res = [lines[0].trim()];
-    for (let i = 1; i < lines.length; i++) {
-        res.push(hardline);
-        res.push(" " + lines[i].trim());
-    }
-    return res;
-}
-function formatComment(comment) {
-    const res = [];
-    const lines = comment.image.split("\n");
-    if (isJavaDoc(comment, lines)) {
-        return formatJavaDoc(lines);
-    }
-    lines.forEach(line => {
-        res.push(line);
-        res.push(literalline);
-    });
-    res.pop();
-    return res;
-}
-export function processComments(docs) {
-    if (!Array.isArray(docs)) {
-        if (isCstElementOrUndefinedIToken(docs)) {
-            return printTokenWithComments(docs);
-        }
-        return docs;
-    }
-    return docs.map(elt => {
-        if (isCstElementOrUndefinedIToken(elt)) {
-            return printTokenWithComments(elt);
-        }
-        return elt;
-    });
-}

package/dist/printers/comments/handle-comments.js

@@ -1,73 +0,0 @@
-import { hasLeadingComments, hasTrailingComments } from "./comments-utils.js";
-export function handleCommentsBinaryExpression(ctx) {
-    moveOperatorLeadingCommentsToNextExpression(ctx);
-    moveExpressionTrailingCommentsToNextOperator(ctx);
-}
-function moveOperatorLeadingCommentsToNextExpression(ctx) {
-    var _a;
-    let unaryExpressionIndex = 1;
-    (_a = ctx.BinaryOperator) === null || _a === void 0 ? void 0 : _a.forEach(binaryOperator => {
-        if (hasLeadingComments(binaryOperator)) {
-            while (ctx.unaryExpression[unaryExpressionIndex].location.startOffset <
-                binaryOperator.endOffset) {
-                unaryExpressionIndex++;
-            }
-            // Adapt the position of the operator and its leading comments
-            const shiftUp = binaryOperator.leadingComments[0].startLine -
-                1 -
-                binaryOperator.startLine;
-            if (binaryOperator.startLine !==
-                ctx.unaryExpression[unaryExpressionIndex].location.startLine) {
-                binaryOperator.leadingComments.forEach(comment => {
-                    comment.startLine += 1;
-                    comment.endLine += 1;
-                });
-            }
-            binaryOperator.startLine += shiftUp;
-            binaryOperator.endLine += shiftUp;
-            // Move binaryOperator's leading comments to the following
-            // unaryExpression
-            ctx.unaryExpression[unaryExpressionIndex].leadingComments =
-                ctx.unaryExpression[unaryExpressionIndex].leadingComments || [];
-            ctx.unaryExpression[unaryExpressionIndex].leadingComments.unshift(...binaryOperator.leadingComments);
-            delete binaryOperator.leadingComments;
-        }
-    });
-}
-function moveExpressionTrailingCommentsToNextOperator(ctx) {
-    const binaryOperators = ctx.BinaryOperator;
-    let binaryOperatorIndex = 1;
-    if (binaryOperators === null || binaryOperators === void 0 ? void 0 : binaryOperators.length) {
-        ctx.unaryExpression.forEach(unaryExpression => {
-            var _a;
-            if (hasTrailingComments(unaryExpression)) {
-                while (binaryOperatorIndex < binaryOperators.length &&
-                    unaryExpression.location.endOffset &&
-                    binaryOperators[binaryOperatorIndex].startOffset <
-                        unaryExpression.location.endOffset) {
-                    binaryOperatorIndex++;
-                }
-                const binaryOperator = binaryOperators[binaryOperatorIndex];
-                // Adapt the position of the expression and its trailing comments
-                const shiftUp = unaryExpression.trailingComments[0].startLine -
-                    1 -
-                    unaryExpression.location.startLine;
-                if (unaryExpression.location.startLine !== binaryOperator.startLine) {
-                    unaryExpression.trailingComments.forEach(comment => {
-                        comment.startLine += 1;
-                        comment.endLine += 1;
-                    });
-                }
-                unaryExpression.location.startLine += shiftUp;
-                if (unaryExpression.location.endLine !== undefined) {
-                    unaryExpression.location.endLine += shiftUp;
-                }
-                // Move unaryExpression's trailing comments to the following
-                // binaryOperator
-                binaryOperator.trailingComments = (_a = binaryOperator.trailingComments) !== null && _a !== void 0 ? _a : [];
-                binaryOperator.trailingComments.unshift(...unaryExpression.trailingComments);
-                delete unaryExpression.trailingComments;
-            }
-        });
-    }
-}