@aforemendude/prettier-plugin-wrap-comments 1.1.1 → 1.2.0

package/README.md

@@ -31,6 +31,20 @@ Then run Prettier normally:
 npx prettier --write .
 ```
 
+### Use With `prettier-plugin-jsdoc`
+
+When using both plugins, `@aforemendude/prettier-plugin-wrap-comments` must be loaded after `prettier-plugin-jsdoc`:
+
+```json
+{
+  "plugins": ["prettier-plugin-jsdoc", "@aforemendude/prettier-plugin-wrap-comments"]
+}
+```
+
+This order is required regardless of `prettier-plugin-jsdoc`'s documentation saying that it should be the last plugin.
+With wrap-comments last, ordinary comments are handled here and parsing is delegated to the preceding JSDoc plugin, so
+JSDoc comments are formatted as well.
+
 ### Cache Repeated CLI Runs
 
 Prettier's CLI cache skips files that have not changed since a successful formatting pass. Enable it in package scripts
@@ -59,9 +73,10 @@ for cache keys, strategies, and custom cache locations.
 ## Behavior
 
 The plugin wraps comments for Prettier's `babel`, `babel-ts`, and `typescript` parsers. It runs during parser
-preprocessing: the underlying Prettier parser preprocesses and parses the source first, the plugin rewrites eligible
-comments from that parsed comment list, and Prettier then formats the rewritten source with its built-in JavaScript and
-TypeScript printers. If the parser cannot parse the preprocessed source, the plugin leaves the source unchanged.
+preprocessing: the nearest preceding plugin for the selected parser, or Prettier's built-in parser when there is none,
+preprocesses and parses the source first. This plugin rewrites eligible comments from that parsed comment list, and
+Prettier then formats the rewritten source with its built-in JavaScript and TypeScript printers. If the parser cannot
+parse the preprocessed source, the plugin leaves the source unchanged.
 
 Offset-sensitive formatting is conservative. Full-file `formatWithCursor` calls skip comment rewriting so Prettier can
 map the cursor from the original source. During range formatting, preprocessing does not rewrite text outside Prettier's

package/dist/index.d.ts

@@ -1,10 +1,14 @@
 import type { Plugin } from 'prettier';
+declare const name = "@aforemendude/prettier-plugin-wrap-comments";
 declare const parsers: {
     [parserName: string]: import("prettier").Parser<any>;
 };
 declare const printers: {
     [astFormat: string]: import("prettier").Printer<any>;
 };
-declare const plugin: Plugin;
-export { parsers, printers };
+declare const plugin: NamedPlugin;
+export { name, parsers, printers };
 export default plugin;
+interface NamedPlugin extends Plugin {
+    name: string;
+}

package/dist/index.js

@@ -1,10 +1,13 @@
 import { createParsers } from './plugin/create-parsers.js';
 import { createPrinters } from './plugin/create-printers.js';
+import { PLUGIN_NAME } from './plugin/plugin-name.js';
+const name = PLUGIN_NAME;
 const parsers = createParsers();
 const printers = createPrinters();
 const plugin = {
+    name,
     parsers,
     printers,
 };
-export { parsers, printers };
+export { name, parsers, printers };
 export default plugin;

package/dist/plugin/create-parsers.js

@@ -6,6 +6,7 @@ import { wrapCommentsWithMetadata } from '../comments/wrap-comments.js';
 import { getPrinterLayoutSource } from './get-printer-layout-source.js';
 import { markRewrittenJsxBlockComments, setJsxBlockCommentRewrites } from './jsx-comment-rewrite-metadata.js';
 import { SUPPORTED_PARSER_NAMES } from './parser-names.js';
+import { PLUGIN_NAME } from './plugin-name.js';
 export function createParsers() {
     const parsers = {};
     for (const parserName of SUPPORTED_PARSER_NAMES) {
@@ -18,17 +19,19 @@ export function createParsers() {
     return parsers;
 }
 function createWrappedParser(parserName, parser) {
-    return {
+    const wrappedParser = {
         ...parser,
         async parse(text, options) {
-            const ast = await parser.parse(text, options);
+            const delegate = await resolveParserDelegate(parserName, parser, wrappedParser, options);
+            const ast = await parseWithDelegate(text, delegate, options);
             const neutralizedAst = neutralizePrettierIgnoreForIgnoredComments(text, ast);
             markRewrittenJsxBlockComments(text, neutralizedAst, options);
             return neutralizedAst;
         },
         async preprocess(text, options) {
             setJsxBlockCommentRewrites(options, []);
-            const preprocessed = parser.preprocess === undefined ? text : await parser.preprocess(text, options);
+            const delegate = await resolveParserDelegate(parserName, parser, wrappedParser, options);
+            const preprocessed = await preprocessWithDelegate(text, delegate, options);
             if (hasOffsetSensitiveFormatting(text, options)) {
                 return preprocessed;
             }
@@ -37,7 +40,7 @@ function createWrappedParser(parserName, parser) {
             }
             let ast;
             try {
-                ast = await parser.parse(preprocessed, { ...options, parser: parserName });
+                ast = await parseWithDelegate(preprocessed, delegate, { ...options, parser: parserName });
             }
             catch {
                 return preprocessed;
@@ -45,12 +48,93 @@ function createWrappedParser(parserName, parser) {
             if (collectAstComments(ast).length === 0) {
                 return preprocessed;
             }
-            const printerLayoutSource = await getPrinterLayoutSource(preprocessed, ast, parserName, parser, options);
+            const printerLayoutSource = await getPrinterLayoutSource(preprocessed, ast, parserName, delegate.parser, createDelegateOptions(options, delegate.plugins));
             const result = await wrapCommentsWithMetadata(preprocessed, ast, options, printerLayoutSource);
             setJsxBlockCommentRewrites(options, result.jsxBlockCommentRewrites);
             return result.text;
         },
     };
+    return wrappedParser;
+}
+async function resolveParserDelegate(parserName, nativeParser, wrappedParser, options) {
+    const plugins = options.plugins ?? [];
+    const wrappedPluginIndex = findWrappedPluginIndex(plugins, parserName, wrappedParser);
+    if (wrappedPluginIndex === -1) {
+        return { parser: nativeParser };
+    }
+    for (let index = wrappedPluginIndex - 1; index >= 0; index -= 1) {
+        const plugin = getPlugin(plugins[index]);
+        const parserEntry = getParserEntry(plugin, parserName);
+        if (parserEntry === undefined) {
+            continue;
+        }
+        const precedingParser = typeof parserEntry === 'function' ? await parserEntry() : parserEntry;
+        if (isParser(precedingParser)) {
+            return {
+                parser: precedingParser,
+                plugins: plugins.slice(0, wrappedPluginIndex),
+            };
+        }
+    }
+    return { parser: nativeParser };
+}
+async function parseWithDelegate(text, delegate, options) {
+    return withDelegatePlugins(options, delegate.plugins, async () => delegate.parser.parse(text, options));
+}
+async function preprocessWithDelegate(text, delegate, options) {
+    const preprocess = delegate.parser.preprocess;
+    if (preprocess === undefined) {
+        return text;
+    }
+    return withDelegatePlugins(options, delegate.plugins, async () => preprocess(text, options));
+}
+async function withDelegatePlugins(options, plugins, callback) {
+    if (plugins === undefined) {
+        return callback();
+    }
+    const originalPlugins = options.plugins;
+    options.plugins = plugins;
+    try {
+        return await callback();
+    }
+    finally {
+        options.plugins = originalPlugins;
+    }
+}
+function createDelegateOptions(options, plugins) {
+    return plugins === undefined ? options : { ...options, plugins };
+}
+function findWrappedPluginIndex(plugins, parserName, wrappedParser) {
+    for (let index = plugins.length - 1; index >= 0; index -= 1) {
+        const plugin = getPlugin(plugins[index]);
+        const parserEntry = getParserEntry(plugin, parserName);
+        if (parserEntry === wrappedParser) {
+            return index;
+        }
+    }
+    for (let index = plugins.length - 1; index >= 0; index -= 1) {
+        const plugin = getPlugin(plugins[index]);
+        const parserEntry = getParserEntry(plugin, parserName);
+        if (plugin?.name === PLUGIN_NAME && parserEntry !== undefined) {
+            return index;
+        }
+    }
+    return -1;
+}
+function getPlugin(plugin) {
+    if (typeof plugin !== 'object' || plugin === null || plugin instanceof URL) {
+        return undefined;
+    }
+    return plugin;
+}
+function getParserEntry(plugin, parserName) {
+    if (plugin?.parsers === undefined || !Object.hasOwn(plugin.parsers, parserName)) {
+        return undefined;
+    }
+    return plugin.parsers[parserName];
+}
+function isParser(value) {
+    return typeof value === 'object' && value !== null && 'parse' in value && typeof value.parse === 'function';
 }
 function hasOffsetSensitiveFormatting(text, options) {
     const cursorOffset = options['cursorOffset'];

package/dist/plugin/plugin-name.d.ts

@@ -0,0 +1 @@
+export declare const PLUGIN_NAME = "@aforemendude/prettier-plugin-wrap-comments";

package/dist/plugin/plugin-name.js

@@ -0,0 +1 @@
+export const PLUGIN_NAME = '@aforemendude/prettier-plugin-wrap-comments';

package/package.json

@@ -7,7 +7,8 @@
   "devDependencies": {
     "@types/node": "20.19.43",
     "prettier": "3.9.6",
-    "prettier-plugin-wrap-comments-stable": "npm:@aforemendude/prettier-plugin-wrap-comments@1.0.6",
+    "prettier-plugin-jsdoc": "1.8.1",
+    "prettier-plugin-wrap-comments-stable": "npm:@aforemendude/prettier-plugin-wrap-comments@1.1.1",
     "typescript": "7.0.2",
     "vite": "8.2.0",
     "vitest": "4.1.10"
@@ -67,5 +68,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.1.1"
+  "version": "1.2.0"
 }