prettier-plugin-java 2.8.1 → 2.9.0

package/package.json

@@ -1,45 +1,83 @@
 {
   "name": "prettier-plugin-java",
-  "version": "2.8.1",
+  "version": "2.9.0",
   "description": "Prettier Java Plugin",
+  "homepage": "https://jhipster.github.io/prettier-java/",
+  "repository": "https://github.com/jhipster/prettier-java",
+  "license": "Apache-2.0",
   "type": "module",
   "exports": {
-    "types": "./dist/index.d.ts",
-    "default": "./dist/index.js"
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
   },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
   "files": [
     "dist"
   ],
-  "homepage": "https://jhipster.github.io/prettier-java/",
-  "repository": "https://github.com/jhipster/prettier-java",
-  "license": "Apache-2.0",
-  "dependencies": {
-    "java-parser": "3.0.1"
-  },
   "scripts": {
+    "build": "tsdown && cp node_modules/tree-sitter-java-orchard/tree-sitter-java_orchard.wasm dist/",
+    "ci": "yarn build && yarn lint && yarn format:validate && yarn test",
+    "clone-samples": "node scripts/clone-samples.js",
+    "format:fix": "prettier --write \"**/*.@(js|json|ts)\"",
+    "format:validate": "prettier --list-different \"**/*.@(js|json|ts)\"",
+    "postinstall": "node scripts/generate-node-types.ts && prettier --write src/node-types.ts",
+    "lerna:publish": "lerna publish from-git --yes",
+    "lerna:version": "lerna version --exact --no-private",
+    "lint": "eslint src test",
+    "prepare": "husky",
     "test": "yarn run test:unit && yarn run test:e2e-core",
-    "test:unit": "mocha \"test/unit-test/**/*.spec.ts\" \"test/unit-test/**/*-spec.ts\"",
+    "test:all": "yarn run test && yarn run test:e2e-jhipster1 && yarn run test:e2e-jhipster2",
     "test:e2e-core": "node scripts/clone-samples e2e-core && mocha \"test/repository-test/core-test.ts\"",
     "test:e2e-jhipster1": "node scripts/clone-samples e2e-jhipster1 && mocha \"test/repository-test/jhipster-1-test.ts\"",
     "test:e2e-jhipster2": "node scripts/clone-samples e2e-jhipster2 && mocha \"test/repository-test/jhipster-2-test.ts\"",
-    "test:all": "yarn run test && yarn run test:e2e-jhipster1 && yarn run test:e2e-jhipster2",
-    "clone-samples": "node scripts/clone-samples.js",
-    "build": "tsc",
-    "build:watch": "tsc --inlineSourceMap -w"
+    "test:unit": "mocha \"test/unit-test/**/*.spec.ts\" \"test/unit-test/**/*-spec.ts\"",
+    "typecheck": "tsc",
+    "update-test-outputs": "node scripts/update-test-output.js"
+  },
+  "lint-staged": {
+    "*.json": [
+      "prettier --write"
+    ],
+    "*.js,*.ts": [
+      "eslint --fix",
+      "prettier --write"
+    ]
+  },
+  "dependencies": {
+    "web-tree-sitter": "0.26.8"
   },
   "devDependencies": {
-    "@chevrotain/types": "11.0.3",
-    "@types/chai": "5.0.1",
-    "@types/fs-extra": "11.0.4",
-    "@types/jest": "29.5.14",
-    "@types/klaw-sync": "6.0.5",
-    "@types/node": "18.19.64",
-    "@types/sinon": "17.0.3",
-    "ts-node": "10.9.2",
-    "typescript": "5.6.3"
+    "@eslint/js": "^10.0.1",
+    "@types/chai": "^5.2.3",
+    "@types/emscripten": "^1.41.5",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^25.5.0",
+    "chai": "^6.2.2",
+    "eslint": "^10.1.0",
+    "globals": "^17.4.0",
+    "husky": "^9.1.7",
+    "lerna": "^9.0.7",
+    "lint-staged": "^17.0.2",
+    "mitata": "^1.0.34",
+    "mocha": "^11.7.5",
+    "prettier": "^3.8.1",
+    "tree-sitter-java-orchard": "0.5.6",
+    "tsdown": "^0.22.0",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.57.1"
   },
   "peerDependencies": {
     "prettier": "^3.0.0"
   },
-  "gitHead": "f403f75d5f308e388ac5d27550a177bb0bd6bef4"
+  "packageManager": "yarn@1.22.22",
+  "gitHead": "6e94f5ee92ff695918ce05f91ba12ef45d076afa"
 }

package/dist/comments.d.ts

@@ -1,17 +0,0 @@
-import type { IToken } from "java-parser";
-import { type AstPath } from "prettier";
-import { type JavaNode, type JavaNonTerminal, type JavaParserOptions } from "./printers/helpers.js";
-export declare function determinePrettierIgnoreRanges(cst: JavaNonTerminal): void;
-export declare function isFullyBetweenPrettierIgnore(path: AstPath<JavaNode>): boolean;
-export declare function canAttachComment(node: JavaNode): boolean;
-export declare function handleLineComment(commentNode: JavaComment, _: string, options: JavaParserOptions): boolean;
-export declare function handleRemainingComment(commentNode: JavaComment): boolean;
-export type JavaComment = IToken & {
-    value: string;
-    leading: boolean;
-    trailing: boolean;
-    printed: boolean;
-    enclosingNode?: JavaNonTerminal;
-    precedingNode?: JavaNode;
-    followingNode?: JavaNode;
-};

package/dist/comments.js

@@ -1,229 +0,0 @@
-import { util } from "prettier";
-import parser from "./parser.js";
-import { isEmptyStatement, isNonTerminal, isTerminal } from "./printers/helpers.js";
-const prettierIgnoreRangesByCst = new WeakMap();
-export function determinePrettierIgnoreRanges(cst) {
-    const { comments } = cst;
-    if (!comments) {
-        return;
-    }
-    const ranges = comments
-        .filter(({ image }) => /^\/(?:\/\s*(?:prettier-ignore-(?:start|end)|@formatter:(?:off|on))\s*|\*\s*(?:prettier-ignore-(?:start|end)|@formatter:(?:off|on))\s*\*\/)$/.test(image))
-        .reduce((ranges, { image, startOffset }) => {
-        const previous = ranges.at(-1);
-        if (image.includes("start") || image.includes("off")) {
-            if ((previous === null || previous === void 0 ? void 0 : previous.end) !== Infinity) {
-                ranges.push({ start: startOffset, end: Infinity });
-            }
-        }
-        else if ((previous === null || previous === void 0 ? void 0 : previous.end) === Infinity) {
-            previous.end = startOffset;
-        }
-        return ranges;
-    }, new Array());
-    prettierIgnoreRangesByCst.set(cst, ranges);
-}
-export function isFullyBetweenPrettierIgnore(path) {
-    var _a;
-    const { node, root } = path;
-    const start = parser.locStart(node);
-    const end = parser.locEnd(node);
-    return (((_a = prettierIgnoreRangesByCst
-        .get(root)) === null || _a === void 0 ? void 0 : _a.some(range => range.start < start && end < range.end)) === true);
-}
-export function canAttachComment(node) {
-    var _a, _b, _c;
-    if (isTerminal(node)) {
-        const { name, CATEGORIES } = node.tokenType;
-        return (name === "Identifier" ||
-            (CATEGORIES === null || CATEGORIES === void 0 ? void 0 : CATEGORIES.find(({ name }) => name === "BinaryOperator")) !== undefined);
-    }
-    const { children, name } = node;
-    switch (name) {
-        case "argumentList":
-        case "blockStatements":
-        case "emptyStatement":
-        case "enumBodyDeclarations":
-            return false;
-        case "annotationInterfaceMemberDeclaration":
-        case "classMemberDeclaration":
-        case "interfaceMemberDeclaration":
-        case "methodBody":
-            return !children.Semicolon;
-        case "blockStatement":
-            return !children.statement || !isEmptyStatement(children.statement[0]);
-        case "classBodyDeclaration":
-            return !((_a = children.classMemberDeclaration) === null || _a === void 0 ? void 0 : _a[0].children.Semicolon);
-        case "recordBodyDeclaration":
-            return !((_c = (_b = children.classBodyDeclaration) === null || _b === void 0 ? void 0 : _b[0].children.classMemberDeclaration) === null || _c === void 0 ? void 0 : _c[0].children.Semicolon);
-        case "statement":
-            return !isEmptyStatement(node);
-        case "statementWithoutTrailingSubstatement":
-            return !children.emptyStatement;
-        default:
-            return true;
-    }
-}
-export function handleLineComment(commentNode, _, options) {
-    return [
-        handleBinaryExpressionComments,
-        handleConditionalExpressionComments,
-        handleFqnOrRefTypeComments,
-        handleIfStatementComments,
-        handleJumpStatementComments,
-        handleLabeledStatementComments,
-        handleNameComments,
-        handleTryStatementComments
-    ].some(fn => fn(commentNode, options));
-}
-export function handleRemainingComment(commentNode) {
-    return [
-        handleFqnOrRefTypeComments,
-        handleMethodDeclaratorComments,
-        handleNameComments,
-        handleJumpStatementComments
-    ].some(fn => fn(commentNode));
-}
-function handleBinaryExpressionComments(commentNode, options) {
-    const { enclosingNode, precedingNode, followingNode } = commentNode;
-    if ((enclosingNode === null || enclosingNode === void 0 ? void 0 : enclosingNode.name) === "binaryExpression") {
-        if (isBinaryOperator(followingNode)) {
-            if (options.experimentalOperatorPosition === "start") {
-                util.addLeadingComment(followingNode, commentNode);
-            }
-            else {
-                util.addTrailingComment(followingNode, commentNode);
-            }
-            return true;
-        }
-        else if (options.experimentalOperatorPosition === "start" &&
-            isBinaryOperator(precedingNode)) {
-            util.addLeadingComment(precedingNode, commentNode);
-            return true;
-        }
-    }
-    return false;
-}
-function handleConditionalExpressionComments(commentNode) {
-    const { startLine, endLine, enclosingNode, precedingNode, followingNode } = commentNode;
-    if ((enclosingNode === null || enclosingNode === void 0 ? void 0 : enclosingNode.name) === "conditionalExpression" &&
-        precedingNode &&
-        followingNode &&
-        isNonTerminal(precedingNode) &&
-        isNonTerminal(followingNode) &&
-        precedingNode.location.endLine < startLine &&
-        endLine < followingNode.location.startLine) {
-        util.addLeadingComment(followingNode, commentNode);
-        return true;
-    }
-    return false;
-}
-function handleFqnOrRefTypeComments(commentNode) {
-    const { enclosingNode, followingNode } = commentNode;
-    if ((enclosingNode === null || enclosingNode === void 0 ? void 0 : enclosingNode.name) === "fqnOrRefType" && followingNode) {
-        util.addLeadingComment(followingNode, commentNode);
-        return true;
-    }
-    return false;
-}
-function handleIfStatementComments(commentNode) {
-    const { enclosingNode, precedingNode } = commentNode;
-    if ((enclosingNode === null || enclosingNode === void 0 ? void 0 : enclosingNode.name) === "ifStatement" &&
-        precedingNode &&
-        isNonTerminal(precedingNode) &&
-        precedingNode.name === "statement") {
-        util.addDanglingComment(enclosingNode, commentNode, undefined);
-        return true;
-    }
-    return false;
-}
-function handleJumpStatementComments(commentNode) {
-    const { enclosingNode, precedingNode, followingNode } = commentNode;
-    if (enclosingNode &&
-        !precedingNode &&
-        !followingNode &&
-        ["breakStatement", "continueStatement", "returnStatement"].includes(enclosingNode.name)) {
-        util.addTrailingComment(enclosingNode, commentNode);
-        return true;
-    }
-    return false;
-}
-function handleLabeledStatementComments(commentNode) {
-    const { enclosingNode, precedingNode } = commentNode;
-    if ((enclosingNode === null || enclosingNode === void 0 ? void 0 : enclosingNode.name) === "labeledStatement" &&
-        precedingNode &&
-        isTerminal(precedingNode) &&
-        precedingNode.tokenType.name === "Identifier") {
-        util.addLeadingComment(precedingNode, commentNode);
-        return true;
-    }
-    return false;
-}
-function handleMethodDeclaratorComments(commentNode) {
-    const { enclosingNode } = commentNode;
-    if ((enclosingNode === null || enclosingNode === void 0 ? void 0 : enclosingNode.name) === "methodDeclarator" &&
-        !enclosingNode.children.receiverParameter &&
-        !enclosingNode.children.formalParameterList &&
-        enclosingNode.children.LBrace[0].startOffset < commentNode.startOffset &&
-        commentNode.startOffset < enclosingNode.children.RBrace[0].startOffset) {
-        util.addDanglingComment(enclosingNode, commentNode, undefined);
-        return true;
-    }
-    return false;
-}
-function handleNameComments(commentNode) {
-    const { enclosingNode, precedingNode } = commentNode;
-    if (enclosingNode &&
-        precedingNode &&
-        isTerminal(precedingNode) &&
-        precedingNode.tokenType.name === "Identifier" &&
-        [
-            "ambiguousName",
-            "classOrInterfaceTypeToInstantiate",
-            "expressionName",
-            "moduleDeclaration",
-            "moduleName",
-            "packageDeclaration",
-            "packageName",
-            "packageOrTypeName",
-            "typeName"
-        ].includes(enclosingNode.name)) {
-        util.addTrailingComment(precedingNode, commentNode);
-        return true;
-    }
-    return false;
-}
-function handleTryStatementComments(commentNode) {
-    var _a, _b;
-    const { enclosingNode, followingNode } = commentNode;
-    if (enclosingNode &&
-        ["catches", "tryStatement"].includes(enclosingNode.name) &&
-        followingNode &&
-        isNonTerminal(followingNode)) {
-        const block = (_a = (followingNode.name === "catches"
-            ? followingNode.children.catchClause[0]
-            : followingNode.name === "catchClause" ||
-                followingNode.name === "finally"
-                ? followingNode
-                : null)) === null || _a === void 0 ? void 0 : _a.children.block[0];
-        if (!block) {
-            return false;
-        }
-        const blockStatement = (_b = block.children.blockStatements) === null || _b === void 0 ? void 0 : _b[0].children.blockStatement[0];
-        if (blockStatement) {
-            util.addLeadingComment(blockStatement, commentNode);
-        }
-        else {
-            util.addDanglingComment(block, commentNode, undefined);
-        }
-        return true;
-    }
-    return false;
-}
-function isBinaryOperator(node) {
-    var _a;
-    return (node !== undefined &&
-        (isNonTerminal(node)
-            ? node.name === "shiftOperator"
-            : (_a = node.tokenType.CATEGORIES) === null || _a === void 0 ? void 0 : _a.some(({ name }) => name === "BinaryOperator")));
-}