prettier-plugin-java 2.6.7 → 2.7.0

package/dist/base-cst-printer.js

@@ -1,55 +0,0 @@
-import { BaseJavaCstVisitor } from "java-parser";
-import { printNodeWithComments } from "./printers/comments/format-comments.js";
-export class BaseCstPrettierPrinter extends BaseJavaCstVisitor {
-    constructor() {
-        super();
-        this.mapVisit = (elements, params) => {
-            if (elements === undefined) {
-                // TODO: can optimize this by returning an immutable empty array singleton.
-                return [];
-            }
-            return elements.map(element => this.visit(element, params));
-        };
-        this.getSingle = (ctx) => {
-            const ctxKeys = Object.keys(ctx);
-            if (ctxKeys.length !== 1) {
-                throw Error(`Expecting single key CST ctx but found: <${ctxKeys.length}> keys`);
-            }
-            const singleElementKey = ctxKeys[0];
-            const singleElementValues = ctx[singleElementKey];
-            if ((singleElementValues === null || singleElementValues === void 0 ? void 0 : singleElementValues.length) !== 1) {
-                throw Error(`Expecting single item in CST ctx key but found: <${singleElementValues === null || singleElementValues === void 0 ? void 0 : singleElementValues.length}> items`);
-            }
-            return singleElementValues[0];
-        };
-        // @ts-ignore
-        this.orgVisit = this.visit;
-        this.visit = function (ctx, inParam) {
-            if (ctx === undefined) {
-                // empty Doc
-                return "";
-            }
-            const node = Array.isArray(ctx) ? ctx[0] : ctx;
-            if (node.ignore) {
-                try {
-                    const startOffset = node.leadingComments !== undefined
-                        ? node.leadingComments[0].startOffset
-                        : node.location.startOffset;
-                    const endOffset = (node.trailingComments !== undefined
-                        ? node.trailingComments[node.trailingComments.length - 1].endOffset
-                        : node.location.endOffset);
-                    return this.prettierOptions.originalText.substring(startOffset, endOffset + 1);
-                }
-                catch (e) {
-                    throw Error(e +
-                        "\nThere might be a problem with prettier-ignore, please report an issue on https://github.com/jhipster/prettier-java/issues");
-                }
-            }
-            return printNodeWithComments(node, this.orgVisit.call(this, node, inParam));
-        };
-        this.visitSingle = function (ctx, params) {
-            const singleElement = this.getSingle(ctx);
-            return this.visit(singleElement, params);
-        };
-    }
-}

package/dist/cst-printer.js

@@ -1,29 +0,0 @@
-import { BaseCstPrettierPrinter } from "./base-cst-printer.js";
-import { ArraysPrettierVisitor } from "./printers/arrays.js";
-import { BlocksAndStatementPrettierVisitor } from "./printers/blocks-and-statements.js";
-import { ClassesPrettierVisitor } from "./printers/classes.js";
-import { ExpressionsPrettierVisitor } from "./printers/expressions.js";
-import { InterfacesPrettierVisitor } from "./printers/interfaces.js";
-import { LexicalStructurePrettierVisitor } from "./printers/lexical-structure.js";
-import { NamesPrettierVisitor } from "./printers/names.js";
-import { TypesValuesAndVariablesPrettierVisitor } from "./printers/types-values-and-variables.js";
-import { PackagesAndModulesPrettierVisitor } from "./printers/packages-and-modules.js";
-// Mixins for the win
-mixInMethods(ArraysPrettierVisitor, BlocksAndStatementPrettierVisitor, ClassesPrettierVisitor, ExpressionsPrettierVisitor, InterfacesPrettierVisitor, LexicalStructurePrettierVisitor, NamesPrettierVisitor, TypesValuesAndVariablesPrettierVisitor, PackagesAndModulesPrettierVisitor);
-function mixInMethods(...classesToMix) {
-    classesToMix.forEach(from => {
-        const fromMethodsNames = Object.getOwnPropertyNames(from.prototype);
-        const fromPureMethodsName = fromMethodsNames.filter(methodName => methodName !== "constructor");
-        fromPureMethodsName.forEach(methodName => {
-            // @ts-ignore
-            BaseCstPrettierPrinter.prototype[methodName] = from.prototype[methodName];
-        });
-    });
-}
-const prettyPrinter = new BaseCstPrettierPrinter();
-// TODO: do we need the "path" and "print" arguments passed by prettier
-// see https://github.com/prettier/prettier/issues/5747
-export function createPrettierDoc(cstNode, options) {
-    prettyPrinter.prettierOptions = options;
-    return prettyPrinter.visit(cstNode);
-}

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,102 +0,0 @@
-import { hasLeadingComments, hasTrailingComments } from "./comments-utils.js";
-export function handleCommentsBinaryExpression(ctx) {
-    moveOperatorLeadingCommentsToNextExpression(ctx);
-    moveExpressionTrailingCommentsToNextOperator(ctx);
-}
-export function handleCommentsParameters(lBrace, parameters, rBrace) {
-    var _a, _b, _c;
-    const lBraceTrailingComments = lBrace.trailingComments;
-    const firstParameter = parameters.at(0);
-    if (lBraceTrailingComments && firstParameter) {
-        delete lBrace.trailingComments;
-        firstParameter.leadingComments = [
-            ...lBraceTrailingComments,
-            ...((_a = firstParameter.leadingComments) !== null && _a !== void 0 ? _a : [])
-        ];
-    }
-    const lastParameter = parameters.at(-1);
-    const rBraceLeadingComments = rBrace.leadingComments;
-    if (rBraceLeadingComments) {
-        delete rBrace.leadingComments;
-        if (lastParameter) {
-            lastParameter.trailingComments = [
-                ...((_b = lastParameter.trailingComments) !== null && _b !== void 0 ? _b : []),
-                ...rBraceLeadingComments
-            ];
-        }
-        else {
-            lBrace.trailingComments = [
-                ...((_c = lBrace.trailingComments) !== null && _c !== void 0 ? _c : []),
-                ...rBraceLeadingComments
-            ];
-        }
-    }
-}
-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 = 0;
-    if (binaryOperators === null || binaryOperators === void 0 ? void 0 : binaryOperators.length) {
-        ctx.unaryExpression.forEach(unaryExpression => {
-            var _a;
-            if (hasTrailingComments(unaryExpression)) {
-                while (binaryOperatorIndex < binaryOperators.length - 1 &&
-                    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;
-            }
-        });
-    }
-}

package/dist/printers/prettier-builder.js

@@ -1,45 +0,0 @@
-import { builders } from "prettier/doc";
-import * as formatComments from "./comments/format-comments.js";
-const processComments = formatComments.processComments;
-/*
- * ------------------------------------------------------------------
- * Wraps the Prettier builder functions to print tokens with comments
- * ------------------------------------------------------------------
- */
-export function concat(docs) {
-    const concatenation = processComments(docs);
-    if (!Array.isArray(docs)) {
-        return "";
-    }
-    return concatenation;
-}
-export function join(sep, docs) {
-    return builders.join(processComments(sep), processComments(docs));
-}
-export function group(docs, opts) {
-    const group = builders.group(processComments(docs), opts);
-    return group.contents === undefined ? "" : group;
-}
-export function fill(docs) {
-    return builders.fill(processComments(docs));
-}
-export function indent(doc) {
-    const processedDoc = processComments(doc);
-    if (processedDoc.length === 0) {
-        return "";
-    }
-    return builders.indent(processedDoc);
-}
-export function dedent(doc) {
-    const processedDoc = processComments(doc);
-    if (processedDoc.length === 0) {
-        return "";
-    }
-    return builders.dedent(processComments(doc));
-}
-export function ifBreak(breakContents, flatContents) {
-    return builders.ifBreak(processComments(breakContents), processComments(flatContents));
-}
-export function indentIfBreak(contents, opts) {
-    return builders.indentIfBreak(processComments(contents), opts);
-}