prettier-plugin-java 2.6.2 → 2.6.3

package/dist/printers/interfaces.js

@@ -1,222 +0,0 @@
-import { concat, group, indent } from "./prettier-builder.js";
-import { printTokenWithComments } from "./comments/format-comments.js";
-import { handleCommentsParameters } from "./comments/handle-comments.js";
-import { displaySemicolon, getInterfaceBodyDeclarationsSeparator, isStatementEmptyStatement, printArrayList, putIntoBraces, rejectAndConcat, rejectAndJoin, rejectAndJoinSeps, sortModifiers } from "./printer-utils.js";
-import { builders } from "prettier/doc";
-import { BaseCstPrettierPrinter } from "../base-cst-printer.js";
-const { line, softline, hardline } = builders;
-export class InterfacesPrettierVisitor extends BaseCstPrettierPrinter {
-    interfaceDeclaration(ctx) {
-        const modifiers = sortModifiers(ctx.interfaceModifier);
-        const firstAnnotations = this.mapVisit(modifiers[0]);
-        const otherModifiers = this.mapVisit(modifiers[1]);
-        const declaration = ctx.normalInterfaceDeclaration
-            ? this.visit(ctx.normalInterfaceDeclaration)
-            : this.visit(ctx.annotationInterfaceDeclaration);
-        return rejectAndJoin(hardline, [
-            rejectAndJoin(hardline, firstAnnotations),
-            rejectAndJoin(" ", [rejectAndJoin(" ", otherModifiers), declaration])
-        ]);
-    }
-    normalInterfaceDeclaration(ctx) {
-        const typeIdentifier = this.visit(ctx.typeIdentifier);
-        const typeParameters = this.visit(ctx.typeParameters);
-        const interfaceExtends = this.visit(ctx.interfaceExtends);
-        const optionalInterfacePermits = this.visit(ctx.interfacePermits);
-        const interfaceBody = this.visit(ctx.interfaceBody);
-        let interfaceExtendsPart = "";
-        if (interfaceExtends) {
-            interfaceExtendsPart = indent(rejectAndConcat([softline, interfaceExtends]));
-        }
-        let interfacePermits = "";
-        if (optionalInterfacePermits) {
-            interfacePermits = indent(rejectAndConcat([softline, optionalInterfacePermits]));
-        }
-        return rejectAndJoin(" ", [
-            group(rejectAndJoin(" ", [
-                ctx.Interface[0],
-                concat([typeIdentifier, typeParameters]),
-                interfaceExtendsPart,
-                interfacePermits
-            ])),
-            interfaceBody
-        ]);
-    }
-    interfaceModifier(ctx) {
-        if (ctx.annotation) {
-            return this.visitSingle(ctx);
-        }
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    interfaceExtends(ctx) {
-        const interfaceTypeList = this.visit(ctx.interfaceTypeList);
-        return group(rejectAndConcat([
-            ctx.Extends[0],
-            indent(rejectAndConcat([line, interfaceTypeList]))
-        ]));
-    }
-    interfacePermits(ctx) {
-        return this.classPermits(ctx);
-    }
-    interfaceBody(ctx) {
-        let joinedInterfaceMemberDeclaration = "";
-        if (ctx.interfaceMemberDeclaration !== undefined) {
-            const interfaceMemberDeclaration = this.mapVisit(ctx.interfaceMemberDeclaration);
-            const separators = getInterfaceBodyDeclarationsSeparator(ctx.interfaceMemberDeclaration);
-            joinedInterfaceMemberDeclaration = rejectAndJoinSeps(separators, interfaceMemberDeclaration);
-        }
-        return putIntoBraces(joinedInterfaceMemberDeclaration, hardline, ctx.LCurly[0], ctx.RCurly[0]);
-    }
-    interfaceMemberDeclaration(ctx) {
-        if (ctx.Semicolon) {
-            return displaySemicolon(ctx.Semicolon[0]);
-        }
-        return this.visitSingle(ctx);
-    }
-    constantDeclaration(ctx) {
-        const modifiers = sortModifiers(ctx.constantModifier);
-        const firstAnnotations = this.mapVisit(modifiers[0]);
-        const otherModifiers = this.mapVisit(modifiers[1]);
-        const unannType = this.visit(ctx.unannType);
-        const variableDeclaratorList = this.visit(ctx.variableDeclaratorList);
-        return rejectAndJoin(hardline, [
-            rejectAndJoin(hardline, firstAnnotations),
-            rejectAndJoin(" ", [
-                rejectAndJoin(" ", otherModifiers),
-                unannType,
-                rejectAndConcat([variableDeclaratorList, ctx.Semicolon[0]])
-            ])
-        ]);
-    }
-    constantModifier(ctx) {
-        if (ctx.annotation) {
-            return this.visitSingle(ctx);
-        }
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    interfaceMethodDeclaration(ctx) {
-        const modifiers = sortModifiers(ctx.interfaceMethodModifier);
-        const firstAnnotations = this.mapVisit(modifiers[0]);
-        const otherModifiers = this.mapVisit(modifiers[1]);
-        const methodHeader = this.visit(ctx.methodHeader);
-        const methodBody = this.visit(ctx.methodBody);
-        const separator = isStatementEmptyStatement(methodBody) ? "" : " ";
-        return rejectAndJoin(hardline, [
-            rejectAndJoin(hardline, firstAnnotations),
-            rejectAndJoin(" ", [
-                rejectAndJoin(" ", otherModifiers),
-                rejectAndJoin(separator, [methodHeader, methodBody])
-            ])
-        ]);
-    }
-    interfaceMethodModifier(ctx) {
-        if (ctx.annotation) {
-            return this.visitSingle(ctx);
-        }
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    annotationInterfaceDeclaration(ctx) {
-        const typeIdentifier = this.visit(ctx.typeIdentifier);
-        const annotationInterfaceBody = this.visit(ctx.annotationInterfaceBody);
-        return rejectAndJoin(" ", [
-            concat([ctx.At[0], ctx.Interface[0]]),
-            typeIdentifier,
-            annotationInterfaceBody
-        ]);
-    }
-    annotationInterfaceBody(ctx) {
-        const annotationInterfaceMemberDeclaration = this.mapVisit(ctx.annotationInterfaceMemberDeclaration);
-        return rejectAndJoin(line, [
-            indent(rejectAndJoin(line, [
-                ctx.LCurly[0],
-                rejectAndJoin(concat([line, line]), annotationInterfaceMemberDeclaration)
-            ])),
-            ctx.RCurly[0]
-        ]);
-    }
-    annotationInterfaceMemberDeclaration(ctx) {
-        if (ctx.Semicolon) {
-            return printTokenWithComments(this.getSingle(ctx));
-        }
-        return this.visitSingle(ctx);
-    }
-    annotationInterfaceElementDeclaration(ctx) {
-        const modifiers = sortModifiers(ctx.annotationInterfaceElementModifier);
-        const firstAnnotations = this.mapVisit(modifiers[0]);
-        const otherModifiers = this.mapVisit(modifiers[1]);
-        const unannType = this.visit(ctx.unannType);
-        const identifier = ctx.Identifier[0];
-        const dims = this.visit(ctx.dims);
-        const defaultValue = ctx.defaultValue
-            ? concat([" ", this.visit(ctx.defaultValue)])
-            : "";
-        return rejectAndJoin(hardline, [
-            rejectAndJoin(hardline, firstAnnotations),
-            rejectAndJoin(" ", [
-                rejectAndJoin(" ", otherModifiers),
-                unannType,
-                rejectAndConcat([
-                    identifier,
-                    concat([ctx.LBrace[0], ctx.RBrace[0]]),
-                    dims,
-                    defaultValue,
-                    ctx.Semicolon[0]
-                ])
-            ])
-        ]);
-    }
-    annotationInterfaceElementModifier(ctx) {
-        if (ctx.annotation) {
-            return this.visitSingle(ctx);
-        }
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    defaultValue(ctx) {
-        const elementValue = this.visit(ctx.elementValue);
-        return rejectAndJoin(" ", [ctx.Default[0], elementValue]);
-    }
-    annotation(ctx) {
-        var _a, _b, _c;
-        const fqn = this.visit(ctx.typeName);
-        let annoArgs = "";
-        if (ctx.LBrace) {
-            const elementValues = (_c = (_b = (_a = ctx.elementValuePairList) === null || _a === void 0 ? void 0 : _a[0].children.elementValuePair) !== null && _b !== void 0 ? _b : ctx.elementValue) !== null && _c !== void 0 ? _c : [];
-            handleCommentsParameters(ctx.LBrace[0], elementValues, ctx.RBrace[0]);
-            if (ctx.elementValuePairList) {
-                annoArgs = putIntoBraces(this.visit(ctx.elementValuePairList), softline, ctx.LBrace[0], ctx.RBrace[0]);
-            }
-            else if (ctx.elementValue) {
-                annoArgs = putIntoBraces(this.visit(ctx.elementValue), softline, ctx.LBrace[0], ctx.RBrace[0]);
-            }
-        }
-        return group(rejectAndConcat([ctx.At[0], fqn, annoArgs]));
-    }
-    elementValuePairList(ctx) {
-        const elementValuePairs = this.mapVisit(ctx.elementValuePair);
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, line])) : [];
-        return rejectAndJoinSeps(commas, elementValuePairs);
-    }
-    elementValuePair(ctx) {
-        const identifier = ctx.Identifier[0];
-        const elementValue = this.visit(ctx.elementValue);
-        return rejectAndJoin(" ", [identifier, ctx.Equals[0], elementValue]);
-    }
-    elementValue(ctx) {
-        return this.visitSingle(ctx);
-    }
-    elementValueArrayInitializer(ctx) {
-        const elementValueList = this.visit(ctx.elementValueList);
-        return printArrayList({
-            list: elementValueList,
-            extraComma: ctx.Comma,
-            LCurly: ctx.LCurly[0],
-            RCurly: ctx.RCurly[0],
-            trailingComma: this.prettierOptions.trailingComma
-        });
-    }
-    elementValueList(ctx) {
-        const elementValues = this.mapVisit(ctx.elementValue);
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, line])) : [];
-        return group(rejectAndConcat([rejectAndJoinSeps(commas, elementValues)]));
-    }
-}

package/dist/printers/lexical-structure.js

@@ -1,31 +0,0 @@
-import { printTokenWithComments } from "./comments/format-comments.js";
-import { join } from "./prettier-builder.js";
-import { BaseCstPrettierPrinter } from "../base-cst-printer.js";
-import { builders } from "prettier/doc";
-const { hardline } = builders;
-export class LexicalStructurePrettierVisitor extends BaseCstPrettierPrinter {
-    literal(ctx) {
-        if (ctx.TextBlock) {
-            const lines = ctx.TextBlock[0].image.split("\n");
-            const open = lines.shift();
-            const baseIndent = Math.min(...lines.map(line => line.search(/\S/)).filter(indent => indent >= 0));
-            return join(hardline, [
-                open,
-                ...lines.map(line => line.slice(baseIndent))
-            ]);
-        }
-        if (ctx.CharLiteral || ctx.StringLiteral || ctx.Null) {
-            return printTokenWithComments(this.getSingle(ctx));
-        }
-        return this.visitSingle(ctx);
-    }
-    integerLiteral(ctx) {
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    floatingPointLiteral(ctx) {
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    booleanLiteral(ctx) {
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-}

package/dist/printers/names.js

@@ -1,29 +0,0 @@
-import { buildFqn } from "./printer-utils.js";
-import { printTokenWithComments } from "./comments/format-comments.js";
-import { BaseCstPrettierPrinter } from "../base-cst-printer.js";
-export class NamesPrettierVisitor extends BaseCstPrettierPrinter {
-    typeIdentifier(ctx) {
-        return printTokenWithComments(ctx.Identifier[0]);
-    }
-    moduleName(ctx) {
-        return buildFqn(ctx.Identifier, ctx.Dot);
-    }
-    packageName(ctx) {
-        return buildFqn(ctx.Identifier, ctx.Dot);
-    }
-    typeName(ctx) {
-        return buildFqn(ctx.Identifier, ctx.Dot);
-    }
-    expressionName(ctx) {
-        return buildFqn(ctx.Identifier, ctx.Dot);
-    }
-    methodName(ctx) {
-        return printTokenWithComments(ctx.Identifier[0]);
-    }
-    packageOrTypeName(ctx) {
-        return buildFqn(ctx.Identifier, ctx.Dot);
-    }
-    ambiguousName(ctx) {
-        return buildFqn(ctx.Identifier, ctx.Dot);
-    }
-}

package/dist/printers/packages-and-modules.js

@@ -1,171 +0,0 @@
-import { concat, join } from "./prettier-builder.js";
-import { printTokenWithComments } from "./comments/format-comments.js";
-import { buildFqn, displaySemicolon, getBlankLinesSeparator, putIntoBraces, rejectAndConcat, rejectAndJoin, rejectAndJoinSeps, sortImports } from "./printer-utils.js";
-import { builders } from "prettier/doc";
-import { BaseCstPrettierPrinter } from "../base-cst-printer.js";
-import { isOrdinaryCompilationUnitCtx } from "../types/utils.js";
-const { line, hardline, indent, group } = builders;
-export class PackagesAndModulesPrettierVisitor extends BaseCstPrettierPrinter {
-    compilationUnit(ctx) {
-        const compilationUnit = isOrdinaryCompilationUnitCtx(ctx)
-            ? ctx.ordinaryCompilationUnit
-            : ctx.modularCompilationUnit;
-        return concat([this.visit(compilationUnit[0]), line]);
-    }
-    ordinaryCompilationUnit(ctx) {
-        const packageDecl = this.visit(ctx.packageDeclaration);
-        const sortedImportsDecl = sortImports(ctx.importDeclaration);
-        const nonStaticImports = this.mapVisit(sortedImportsDecl.nonStaticImports);
-        const staticImports = this.mapVisit(sortedImportsDecl.staticImports);
-        const typesDecl = this.mapVisit(ctx.typeDeclaration);
-        // TODO: utility to add item+line (or multiple lines) but only if an item exists
-        return rejectAndConcat([
-            rejectAndJoin(concat([hardline, hardline]), [
-                packageDecl,
-                rejectAndJoin(hardline, staticImports),
-                rejectAndJoin(hardline, nonStaticImports),
-                rejectAndJoin(concat([hardline, hardline]), typesDecl)
-            ])
-        ]);
-    }
-    modularCompilationUnit(ctx) {
-        const sortedImportsDecl = sortImports(ctx.importDeclaration);
-        const nonStaticImports = this.mapVisit(sortedImportsDecl.nonStaticImports);
-        const staticImports = this.mapVisit(sortedImportsDecl.staticImports);
-        const moduleDeclaration = this.visit(ctx.moduleDeclaration);
-        return rejectAndConcat([
-            rejectAndJoin(concat([hardline, hardline]), [
-                rejectAndJoin(hardline, staticImports),
-                rejectAndJoin(hardline, nonStaticImports),
-                moduleDeclaration
-            ])
-        ]);
-    }
-    packageDeclaration(ctx) {
-        const modifiers = this.mapVisit(ctx.packageModifier);
-        const name = buildFqn(ctx.Identifier, ctx.Dot);
-        return rejectAndJoin(hardline, [
-            rejectAndJoin(hardline, modifiers),
-            concat([ctx.Package[0], " ", name, ctx.Semicolon[0]])
-        ]);
-    }
-    packageModifier(ctx) {
-        return this.visitSingle(ctx);
-    }
-    importDeclaration(ctx) {
-        if (ctx.emptyStatement !== undefined) {
-            return this.visit(ctx.emptyStatement);
-        }
-        const optionalStatic = ctx.Static ? ctx.Static[0] : "";
-        const packageOrTypeName = this.visit(ctx.packageOrTypeName);
-        const optionalDotStar = ctx.Dot ? concat([ctx.Dot[0], ctx.Star[0]]) : "";
-        return rejectAndJoin(" ", [
-            ctx.Import[0],
-            optionalStatic,
-            rejectAndConcat([packageOrTypeName, optionalDotStar, ctx.Semicolon[0]])
-        ]);
-    }
-    typeDeclaration(ctx) {
-        if (ctx.Semicolon) {
-            return displaySemicolon(ctx.Semicolon[0]);
-        }
-        return this.visitSingle(ctx);
-    }
-    moduleDeclaration(ctx) {
-        const annotations = this.mapVisit(ctx.annotation);
-        const optionalOpen = ctx.Open ? ctx.Open[0] : "";
-        const name = buildFqn(ctx.Identifier, ctx.Dot);
-        const moduleDirectives = this.mapVisit(ctx.moduleDirective);
-        const content = rejectAndJoinSeps(getBlankLinesSeparator(ctx.moduleDirective), moduleDirectives);
-        return rejectAndJoin(" ", [
-            join(" ", annotations),
-            optionalOpen,
-            ctx.Module[0],
-            name,
-            putIntoBraces(content, hardline, ctx.LCurly[0], ctx.RCurly[0])
-        ]);
-    }
-    moduleDirective(ctx) {
-        return this.visitSingle(ctx);
-    }
-    requiresModuleDirective(ctx) {
-        const modifiers = this.mapVisit(ctx.requiresModifier);
-        const moduleName = this.visit(ctx.moduleName);
-        return rejectAndJoin(" ", [
-            ctx.Requires[0],
-            join(" ", modifiers),
-            concat([moduleName, ctx.Semicolon[0]])
-        ]);
-    }
-    exportsModuleDirective(ctx) {
-        const packageName = this.visit(ctx.packageName);
-        const moduleNames = this.mapVisit(ctx.moduleName);
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, line])) : [];
-        if (ctx.To) {
-            return group(rejectAndConcat([
-                indent(rejectAndJoin(line, [
-                    rejectAndJoin(" ", [ctx.Exports[0], packageName]),
-                    group(indent(rejectAndJoin(line, [
-                        ctx.To[0],
-                        rejectAndJoinSeps(commas, moduleNames)
-                    ])))
-                ])),
-                ctx.Semicolon[0]
-            ]));
-        }
-        return rejectAndConcat([
-            concat([ctx.Exports[0], " "]),
-            packageName,
-            ctx.Semicolon[0]
-        ]);
-    }
-    opensModuleDirective(ctx) {
-        const packageName = this.visit(ctx.packageName);
-        const to = ctx.To ? ctx.To[0] : "";
-        const moduleNames = this.mapVisit(ctx.moduleName);
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, line])) : [];
-        if (ctx.To) {
-            return group(rejectAndConcat([
-                indent(rejectAndJoin(line, [
-                    rejectAndJoin(" ", [ctx.Opens[0], packageName]),
-                    group(indent(rejectAndJoin(line, [
-                        ctx.To[0],
-                        rejectAndJoinSeps(commas, moduleNames)
-                    ])))
-                ])),
-                ctx.Semicolon[0]
-            ]));
-        }
-        return rejectAndConcat([
-            concat([ctx.Opens[0], " "]),
-            packageName,
-            ctx.Semicolon[0]
-        ]);
-    }
-    usesModuleDirective(ctx) {
-        const typeName = this.visit(ctx.typeName);
-        return rejectAndConcat([
-            concat([ctx.Uses[0], " "]),
-            typeName,
-            ctx.Semicolon[0]
-        ]);
-    }
-    providesModuleDirective(ctx) {
-        const firstTypeName = this.visit(ctx.typeName[0]);
-        const otherTypeNames = this.mapVisit(ctx.typeName.slice(1));
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, line])) : [];
-        return group(rejectAndConcat([
-            indent(rejectAndJoin(line, [
-                rejectAndJoin(" ", [ctx.Provides[0], firstTypeName]),
-                group(indent(rejectAndJoin(line, [
-                    ctx.With[0],
-                    rejectAndJoinSeps(commas, otherTypeNames)
-                ])))
-            ])),
-            ctx.Semicolon[0]
-        ]));
-    }
-    requiresModifier(ctx) {
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-}

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);
-}