prettier-plugin-java 2.6.8 → 2.7.1

package/dist/parser.d.ts

@@ -0,0 +1,9 @@
+import { type JavaNode, type JavaNonTerminal, type JavaParserOptions } from "./printers/helpers.js";
+declare const _default: {
+    parse(text: string, options: JavaParserOptions): JavaNonTerminal;
+    astFormat: string;
+    hasPragma(text: string): boolean;
+    locStart(node: JavaNode): number;
+    locEnd(node: JavaNode): number;
+};
+export default _default;

package/dist/parser.js

@@ -1,4 +1,24 @@
-import javaParser from "java-parser";
-export default function parse(text, parsers, opts) {
-    return javaParser.parse(text, opts.entrypoint);
-}
+import { parse } from "java-parser";
+import { determineFormatterOffOnRanges } from "./comments.js";
+import { isTerminal } from "./printers/helpers.js";
+export default {
+    parse(text, options) {
+        var _a;
+        const cst = parse(text, options.entrypoint);
+        (_a = cst.comments) === null || _a === void 0 ? void 0 : _a.forEach(comment => {
+            comment.value = comment.image;
+        });
+        determineFormatterOffOnRanges(cst);
+        return cst;
+    },
+    astFormat: "java",
+    hasPragma(text) {
+        return /^\/\*\*\n\s+\*\s@(format|prettier)\n\s+\*\//.test(text);
+    },
+    locStart(node) {
+        return isTerminal(node) ? node.startOffset : node.location.startOffset;
+    },
+    locEnd(node) {
+        return (isTerminal(node) ? node.endOffset : node.location.endOffset) + 1;
+    }
+};

package/dist/printer.d.ts

@@ -0,0 +1,18 @@
+import type { AstPath } from "prettier";
+import { canAttachComment, handleLineComment, handleRemainingComment } from "./comments.js";
+import { type JavaNode } from "./printers/helpers.js";
+declare const _default: {
+    print(path: DistributedAstPath<JavaNode>, options: import("prettier").ParserOptions<JavaNode>, print: (path: AstPath<JavaNode>) => import("prettier").Doc, args: unknown): import("prettier/doc.js").builders.Doc;
+    hasPrettierIgnore(path: AstPath<JavaNode>): boolean;
+    canAttachComment: typeof canAttachComment;
+    isBlockComment(node: JavaNode): boolean;
+    printComment(commentPath: AstPath<JavaNode>): string | import("prettier/doc.js").builders.Doc[];
+    getCommentChildNodes(node: JavaNode): any[];
+    handleComments: {
+        ownLine: typeof handleLineComment;
+        endOfLine: typeof handleLineComment;
+        remaining: typeof handleRemainingComment;
+    };
+};
+export default _default;
+type DistributedAstPath<T> = T extends any ? AstPath<T> : never;

package/dist/printer.js

@@ -1,6 +1,40 @@
-import { createPrettierDoc } from "./cst-printer.js";
-// eslint-disable-next-line no-unused-vars
-export default function genericPrint(path, options, print) {
-    const node = path.getValue();
-    return createPrettierDoc(node, options);
+import { canAttachComment, handleLineComment, handleRemainingComment, isFullyBetweenFormatterOffOn } from "./comments.js";
+import { isNonTerminal, isTerminal, printComment } from "./printers/helpers.js";
+import { printerForNodeType } from "./printers/index.js";
+export default {
+    print(path, options, print, args) {
+        return hasTerminal(path)
+            ? path.node.image
+            : printerForNodeType(path.node.name)(path, print, options, args);
+    },
+    hasPrettierIgnore(path) {
+        var _a;
+        const { node } = path;
+        return (((_a = node.comments) === null || _a === void 0 ? void 0 : _a.some(({ image }) => /^(\/\/\s*prettier-ignore|\/\*\s*prettier-ignore\s*\*\/)$/.test(image))) === true ||
+            (canAttachComment(node) && isFullyBetweenFormatterOffOn(path)));
+    },
+    canAttachComment,
+    isBlockComment(node) {
+        return isTerminal(node) && node.tokenType.name === "TraditionalComment";
+    },
+    printComment(commentPath) {
+        const { node } = commentPath;
+        if (isNonTerminal(node) || node.tokenType.GROUP !== "comments") {
+            throw new Error(`Not a comment: ${JSON.stringify(node)}`);
+        }
+        return printComment(node);
+    },
+    getCommentChildNodes(node) {
+        return isNonTerminal(node)
+            ? Object.values(node.children).flatMap(child => child)
+            : [];
+    },
+    handleComments: {
+        ownLine: handleLineComment,
+        endOfLine: handleLineComment,
+        remaining: handleRemainingComment
+    }
+};
+function hasTerminal(path) {
+    return isTerminal(path.node);
 }

package/dist/printers/arrays.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    arrayInitializer(path: import("prettier").AstPath<import("../../../java-parser/api.js").ArrayInitializerCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn, options: import("./helpers.js").JavaParserOptions): import("prettier/doc.js").builders.Group | "{}";
+    variableInitializerList(path: import("prettier").AstPath<import("../../../java-parser/api.js").VariableInitializerListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): import("prettier/doc.js").builders.Doc[];
+};
+export default _default;

package/dist/printers/arrays.js

@@ -1,25 +1,9 @@
-import { printArrayList, rejectAndConcat, rejectAndJoinSeps } from "./printer-utils.js";
-import { builders } from "prettier/doc";
-import { BaseCstPrettierPrinter } from "../base-cst-printer.js";
-const { line } = builders;
-export class ArraysPrettierVisitor extends BaseCstPrettierPrinter {
-    arrayInitializer(ctx) {
-        const optionalVariableInitializerList = this.visit(ctx.variableInitializerList);
-        return printArrayList({
-            list: optionalVariableInitializerList,
-            extraComma: ctx.Comma,
-            LCurly: ctx.LCurly[0],
-            RCurly: ctx.RCurly[0],
-            trailingComma: this.prettierOptions.trailingComma
-        });
+import { printArrayInitializer, printList } from "./helpers.js";
+export default {
+    arrayInitializer(path, print, options) {
+        return printArrayInitializer(path, print, options, "variableInitializerList");
+    },
+    variableInitializerList(path, print) {
+        return printList(path, print, "variableInitializer");
     }
-    variableInitializerList(ctx) {
-        const variableInitializers = this.mapVisit(ctx.variableInitializer);
-        const commas = ctx.Comma
-            ? ctx.Comma.map(comma => {
-                return rejectAndConcat([comma, line]);
-            })
-            : [];
-        return rejectAndJoinSeps(commas, variableInitializers);
-    }
-}
+};

package/dist/printers/blocks-and-statements.d.ts

@@ -0,0 +1,117 @@
+import { builders } from "prettier/doc";
+import { printSingle } from "./helpers.js";
+declare const _default: {
+    block(path: import("prettier").AstPath<import("../../../java-parser/api.js").BlockCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    blockStatements(path: import("prettier").AstPath<import("../../../java-parser/api.js").BlockStatementsCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    blockStatement: typeof printSingle;
+    localVariableDeclarationStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").LocalVariableDeclarationStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    localVariableDeclaration(path: import("prettier").AstPath<import("../../../java-parser/api.js").LocalVariableDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    localVariableType: typeof printSingle;
+    statement: typeof printSingle;
+    statementWithoutTrailingSubstatement: typeof printSingle;
+    emptyStatement(): string;
+    labeledStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").LabeledStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    expressionStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").ExpressionStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    statementExpression: typeof printSingle;
+    ifStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").IfStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    assertStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").AssertStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    switchStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").SwitchStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    switchBlock(path: import("prettier").AstPath<import("../../../java-parser/api.js").SwitchBlockCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    switchBlockStatementGroup(path: import("prettier").AstPath<import("../../../java-parser/api.js").SwitchBlockStatementGroupCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    switchLabel(path: import("prettier").AstPath<import("../../../java-parser/api.js").SwitchLabelCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): "default" | builders.Group | builders.Doc[];
+    switchRule(path: import("prettier").AstPath<import("../../../java-parser/api.js").SwitchRuleCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    caseConstant: typeof printSingle;
+    casePattern: typeof printSingle;
+    whileStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").WhileStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    doStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").DoStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): (string | builders.Group | builders.Doc[])[];
+    forStatement: typeof printSingle;
+    basicForStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").BasicForStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    forInit: typeof printSingle;
+    forUpdate: typeof printSingle;
+    statementExpressionList(path: import("prettier").AstPath<import("../../../java-parser/api.js").StatementExpressionListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group;
+    enhancedForStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").EnhancedForStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group;
+    breakStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").BreakStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[] | "break;";
+    continueStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").ContinueStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[] | "continue;";
+    returnStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").ReturnStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    throwStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").ThrowStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    synchronizedStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").SynchronizedStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    tryStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").TryStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc;
+    catches(path: import("prettier").AstPath<import("../../../java-parser/api.js").CatchesCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    catchClause(path: import("prettier").AstPath<import("../../../java-parser/api.js").CatchClauseCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    catchFormalParameter(path: import("prettier").AstPath<import("../../../java-parser/api.js").CatchFormalParameterCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    catchType(path: import("prettier").AstPath<import("../../../java-parser/api.js").CatchTypeCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    finally(path: import("prettier").AstPath<import("../../../java-parser/api.js").FinallyCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    tryWithResourcesStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").TryWithResourcesStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    resourceSpecification(path: import("prettier").AstPath<import("../../../java-parser/api.js").ResourceSpecificationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Group | "()";
+    resourceList(path: import("prettier").AstPath<import("../../../java-parser/api.js").ResourceListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    resource: typeof printSingle;
+    yieldStatement(path: import("prettier").AstPath<import("../../../java-parser/api.js").YieldStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    variableAccess: typeof printSingle;
+};
+export default _default;