@aforemendude/prettier-plugin-wrap-comments 1.0.6 → 1.1.0

package/dist/comments/prettier-ignore.js

@@ -0,0 +1,145 @@
+import { getCommentBody } from './comment-body.js';
+import { isPrettierIgnoreComment } from './comment-directives.js';
+import { shouldSkipBlockComment, shouldSkipLineComment } from './comment-eligibility.js';
+import { areCommentsOnAdjacentLines, isCommentAdjacentBeforeIndex, isStandaloneBlockComment, isStandaloneComment, isStandaloneLineComment, } from './comment-location.js';
+import { collectCommentEntries } from './comment-ranges.js';
+import { getAstNodeRange, visitAstNodes } from '../utils/ast.js';
+import { getLineEnd, getLineStart } from '../utils/source-lines.js';
+import { skipWhitespace } from '../utils/whitespace.js';
+const NEUTRALIZED_PRETTIER_IGNORE_COMMENT = 'prettier-ignore wrap-comments';
+export function neutralizePrettierIgnoreForIgnoredComments(text, ast) {
+    const comments = collectCommentEntries(ast, text);
+    for (let index = 0; index < comments.length; index += 1) {
+        const entry = comments[index];
+        const previousEntry = comments[index - 1];
+        const shouldNeutralize = entry !== undefined &&
+            previousEntry !== undefined &&
+            ((isPrettierIgnoredBlockComment(text, comments, index) && !shouldSkipBlockComment(text, entry.range)) ||
+                (isPrettierIgnoredStandaloneLineComment(text, comments, index) && !shouldSkipLineComment(text, entry.range)));
+        if (shouldNeutralize) {
+            previousEntry.raw.value = NEUTRALIZED_PRETTIER_IGNORE_COMMENT;
+        }
+    }
+    return ast;
+}
+export function collectPrettierIgnoredLineRanges(text, ast, comments) {
+    const nodeRanges = collectAstNodeRanges(ast);
+    const ignoredLineRanges = [];
+    for (let index = 0; index < comments.length; index += 1) {
+        const comment = comments[index]?.range;
+        if (comment === undefined ||
+            !isStandaloneComment(text, comment) ||
+            !isPrettierIgnoreComment(getCommentBody(text, comment))) {
+            continue;
+        }
+        const targetStart = getPrettierIgnoreTargetStart(text, comments, index);
+        if (targetStart === undefined) {
+            continue;
+        }
+        const targetRange = nodeRanges.find((range) => range.start === targetStart);
+        if (targetRange === undefined) {
+            continue;
+        }
+        ignoredLineRanges.push({
+            end: getLineEnd(text, targetRange.end),
+            start: getLineStart(text, targetRange.start),
+        });
+    }
+    return ignoredLineRanges;
+}
+export function isCommentInIgnoredLineRange(comment, ignoredLineRanges) {
+    return ignoredLineRanges.some((range) => comment.start >= range.start && comment.start < range.end);
+}
+export function isPrettierIgnoredBlockComment(text, comments, index) {
+    const comment = comments[index]?.range;
+    const previousComment = comments[index - 1]?.range;
+    if (comment === undefined ||
+        comment.kind !== 'block' ||
+        !isStandaloneBlockComment(text, comment) ||
+        previousComment === undefined) {
+        return false;
+    }
+    if (!isStandaloneComment(text, previousComment) || !areCommentsOnAdjacentLines(text, previousComment, comment)) {
+        return false;
+    }
+    return isPrettierIgnoreComment(getCommentBody(text, previousComment));
+}
+export function isPrettierIgnoredStandaloneLineComment(text, comments, index) {
+    const comment = comments[index]?.range;
+    const previousComment = comments[index - 1]?.range;
+    if (comment === undefined ||
+        comment.kind !== 'line' ||
+        !isStandaloneLineComment(text, comment) ||
+        previousComment === undefined ||
+        previousComment.kind !== 'line') {
+        return false;
+    }
+    if (!isStandaloneComment(text, previousComment) || !areCommentsOnAdjacentLines(text, previousComment, comment)) {
+        return false;
+    }
+    return isPrettierIgnoreComment(getCommentBody(text, previousComment));
+}
+export function isPrettierIgnoredTrailingLineComment(text, comments, index) {
+    const comment = comments[index]?.range;
+    if (comment === undefined || comment.kind !== 'line' || isStandaloneLineComment(text, comment)) {
+        return false;
+    }
+    let cursor = getLineStart(text, comment.start);
+    for (let previousIndex = index - 1; previousIndex >= 0; previousIndex -= 1) {
+        const previousComment = comments[previousIndex]?.range;
+        if (previousComment !== undefined && previousComment.end > cursor) {
+            continue;
+        }
+        if (previousComment === undefined || !isStandaloneComment(text, previousComment)) {
+            return false;
+        }
+        if (!isCommentAdjacentBeforeIndex(text, previousComment, cursor)) {
+            return false;
+        }
+        const body = getCommentBody(text, previousComment);
+        if (isPrettierIgnoreComment(body)) {
+            return true;
+        }
+        if (!isSkippableCommentBetweenIgnoreAndTarget(text, previousComment)) {
+            return false;
+        }
+        cursor = getLineStart(text, previousComment.start);
+    }
+    return false;
+}
+function collectAstNodeRanges(ast) {
+    const ranges = [];
+    visitAstNodes(ast, (node) => {
+        const range = getAstNodeRange(node);
+        if (range !== undefined) {
+            ranges.push(range);
+        }
+    });
+    return ranges.sort((left, right) => left.start - right.start || right.end - left.end);
+}
+function getPrettierIgnoreTargetStart(text, comments, ignoreCommentIndex) {
+    const ignoreComment = comments[ignoreCommentIndex]?.range;
+    if (ignoreComment === undefined) {
+        return undefined;
+    }
+    let cursor = ignoreComment.end;
+    for (let index = ignoreCommentIndex + 1; index < comments.length; index += 1) {
+        cursor = skipWhitespace(text, cursor);
+        const comment = comments[index]?.range;
+        if (comment === undefined || comment.start !== cursor) {
+            break;
+        }
+        if (!isStandaloneComment(text, comment) || !isSkippableCommentBetweenIgnoreAndTarget(text, comment)) {
+            return undefined;
+        }
+        cursor = comment.end;
+    }
+    const targetStart = skipWhitespace(text, cursor);
+    return targetStart >= text.length ? undefined : targetStart;
+}
+function isSkippableCommentBetweenIgnoreAndTarget(text, comment) {
+    if (comment.kind === 'block') {
+        return shouldSkipBlockComment(text, comment);
+    }
+    return shouldSkipLineComment(text, comment) && !isPrettierIgnoreComment(getCommentBody(text, comment));
+}

package/dist/comments/printer-layout.d.ts

@@ -0,0 +1,17 @@
+import type { CommentEntry } from './comment-ranges.js';
+import type { JsxExpressionContainerRange } from './jsx-expression-layout.js';
+export type PrinterLayoutSource = {
+    ast: unknown;
+    text: string;
+};
+export type PrinterCommentLayout = {
+    lineIndentColumn: number;
+    lineWidth: number;
+    markerColumn: number;
+    suffixWidth: number;
+};
+export type PrinterLayout = {
+    comments: Array<PrinterCommentLayout | undefined>;
+    jsxCommentMarkerColumns: Array<number | undefined>;
+};
+export declare function getPrinterLayout(text: string, commentEntries: CommentEntry[], jsxExpressionContainers: JsxExpressionContainerRange[], source: PrinterLayoutSource | undefined, tabWidth: number): PrinterLayout;

package/dist/comments/printer-layout.js

@@ -0,0 +1,64 @@
+import { collectCommentEntries } from './comment-ranges.js';
+import { collectJsxExpressionContainerRanges, getPrintedJsxCommentMarkerColumn } from './jsx-expression-layout.js';
+import { getColumns } from '../utils/display-width.js';
+import { getLeadingIndent } from '../utils/indentation.js';
+import { getLineEnd, getLineStart } from '../utils/source-lines.js';
+export function getPrinterLayout(text, commentEntries, jsxExpressionContainers, source, tabWidth) {
+    if (source === undefined) {
+        return {
+            comments: [],
+            jsxCommentMarkerColumns: [],
+        };
+    }
+    const outputCommentEntries = collectCommentEntries(source.ast, source.text);
+    const alignedOutputComments = alignOutputComments(text, commentEntries, source.text, outputCommentEntries);
+    const outputJsxExpressionContainers = collectJsxExpressionContainerRanges(source.ast);
+    const jsxCommentMarkerColumns = outputJsxExpressionContainers.length === jsxExpressionContainers.length
+        ? outputJsxExpressionContainers.map((container) => getPrintedJsxCommentMarkerColumn(source.text, container, tabWidth))
+        : [];
+    return {
+        comments: alignedOutputComments.map((comment) => comment === undefined ? undefined : getPrinterCommentLayout(source.text, comment.range, tabWidth)),
+        jsxCommentMarkerColumns,
+    };
+}
+function alignOutputComments(text, comments, outputText, outputComments) {
+    if (comments.length === outputComments.length &&
+        comments.every((comment, index) => comment.range.kind === outputComments[index]?.range.kind)) {
+        return outputComments;
+    }
+    const alignedComments = [];
+    let outputIndex = 0;
+    for (const comment of comments) {
+        const raw = normalizeCommentForMatching(text.slice(comment.range.start, comment.range.end));
+        let matchingComment;
+        while (outputIndex < outputComments.length) {
+            const candidate = outputComments[outputIndex];
+            outputIndex += 1;
+            if (candidate !== undefined &&
+                candidate.range.kind === comment.range.kind &&
+                normalizeCommentForMatching(outputText.slice(candidate.range.start, candidate.range.end)) === raw) {
+                matchingComment = candidate;
+                break;
+            }
+        }
+        alignedComments.push(matchingComment);
+    }
+    return alignedComments;
+}
+function normalizeCommentForMatching(raw) {
+    return raw.replace(/\r\n?/gu, '\n');
+}
+function getPrinterCommentLayout(text, comment, tabWidth) {
+    const lineStart = getLineStart(text, comment.start);
+    const lineEnd = getLineEnd(text, comment.end);
+    const linePrefix = text.slice(lineStart, comment.start);
+    const lineIndent = getLeadingIndent(linePrefix);
+    const lineText = text.slice(lineStart, lineEnd).replace(/[ \t]+$/u, '');
+    const suffix = text.slice(comment.end, lineEnd).replace(/[ \t]+$/u, '');
+    return {
+        lineIndentColumn: getColumns(lineIndent, tabWidth),
+        lineWidth: getColumns(lineText, tabWidth),
+        markerColumn: getColumns(linePrefix, tabWidth),
+        suffixWidth: getColumns(suffix, tabWidth),
+    };
+}

package/dist/comments/{block.d.ts → wrap-block-comment.d.ts}

@@ -1,10 +1,13 @@
-import type { CommentRange, Replacement, WrapOptions } from '../shared/types.js';
+import type { CommentRange } from './comment-ranges.js';
+import type { Replacement } from '../utils/replacements.js';
+import type { WrapOptions } from '../utils/wrap-options.js';
 export type BlockCommentLayout = {
     contentColumn?: number;
     leadingMove?: {
         removeEnd: number;
         removeStart: number;
     };
+    markerColumn?: number;
     multilineIndent?: string;
     placement: 'inline' | 'standalone' | 'trailing';
     singleLineSuffixWidth?: number;

package/dist/comments/{block.js → wrap-block-comment.js}

@@ -1,18 +1,18 @@
-import { hasPreserveCommentMarker, isDirectiveComment, normalizeBlockCommentBody } from './core.js';
-import { formatMarkdownLines } from '../shared/markdown.js';
-import { getAvailableContentWidth, getPrintWidth, getTabWidth } from '../shared/options.js';
-import { getColumnAt, getColumns, getLinePrefix, getPreferredNewline, isStandaloneBlockComment, } from '../shared/text.js';
+import { normalizeBlockCommentBody } from './comment-body.js';
+import { shouldSkipBlockComment } from './comment-eligibility.js';
+import { isStandaloneBlockComment } from './comment-location.js';
+import { getColumnAt, getColumns } from '../utils/display-width.js';
+import { formatMarkdownLines } from '../utils/format-markdown.js';
+import { getLinePrefix, getPreferredNewline } from '../utils/source-lines.js';
+import { getAvailableContentWidth, getPrintWidth, getTabWidth } from '../utils/wrap-options.js';
 export async function wrapBlockComment(text, comment, options, layout = getDefaultBlockCommentLayout(text, comment)) {
-    const raw = text.slice(comment.start, comment.end);
-    if (raw.startsWith('/**') || hasPreserveCommentMarker(raw)) {
+    if (shouldSkipBlockComment(text, comment)) {
         return undefined;
     }
+    const raw = text.slice(comment.start, comment.end);
     const markdown = normalizeBlockCommentBody(raw);
-    if (markdown.trim() === '' || isDirectiveComment(markdown)) {
-        return undefined;
-    }
     const tabWidth = getTabWidth(options);
-    const markerColumn = getColumnAt(text, comment.start, tabWidth);
+    const markerColumn = layout.markerColumn ?? getColumnAt(text, comment.start, tabWidth);
     const availableWidth = getAvailableContentWidth(options, layout.contentColumn ?? markerColumn + 3);
     const formattedLines = await formatMarkdownLines(markdown, availableWidth, options);
     const replacement = buildBlockReplacement(text, comment, formattedLines, options, layout);
@@ -33,7 +33,7 @@ export async function wrapBlockComment(text, comment, options, layout = getDefau
 }
 function buildBlockReplacement(text, comment, formattedLines, options, layout) {
     const tabWidth = getTabWidth(options);
-    const markerColumn = getColumnAt(text, comment.start, tabWidth);
+    const markerColumn = layout.markerColumn ?? getColumnAt(text, comment.start, tabWidth);
     const singleLine = `/* ${formattedLines.join(' ')} */`;
     const singleLineWidth = getColumns(singleLine, tabWidth);
     const singleLineSuffixWidth = layout.singleLineSuffixWidth ?? 0;
@@ -46,12 +46,13 @@ function buildBlockReplacement(text, comment, formattedLines, options, layout) {
     const newline = getPreferredNewline(text, options);
     const indent = layout.multilineIndent ?? getLinePrefix(text, comment.start);
     const replacementText = buildMultilineBlockReplacement(formattedLines, newline, indent);
+    const replacementTextWithNewline = [replacementText, ''].join(newline);
     if (layout.trailingMove !== undefined) {
         return [
             {
                 end: layout.trailingMove.insertAt,
                 start: layout.trailingMove.insertAt,
-                text: `${replacementText}${newline}`,
+                text: replacementTextWithNewline,
             },
             {
                 end: layout.trailingMove.removeEnd,
@@ -65,7 +66,7 @@ function buildBlockReplacement(text, comment, formattedLines, options, layout) {
             {
                 end: comment.end,
                 start: comment.start,
-                text: `${replacementText}${newline}`,
+                text: replacementTextWithNewline,
             },
             {
                 end: layout.leadingMove.removeEnd,
@@ -78,7 +79,7 @@ function buildBlockReplacement(text, comment, formattedLines, options, layout) {
 }
 function buildMultilineBlockReplacement(formattedLines, newline, indent) {
     const body = formattedLines.map((line) => `${indent} *${line.length === 0 ? '' : ` ${line}`}`).join(newline);
-    return `/*${newline}${body}${newline}${indent} */`;
+    return ['/*', body, `${indent} */`].join(newline);
 }
 function getDefaultBlockCommentLayout(text, comment) {
     return {

package/dist/comments/wrap-comments.d.ts

@@ -0,0 +1,9 @@
+import type { PrinterLayoutSource } from './printer-layout.js';
+import type { JsxBlockCommentRewrite } from '../plugin/jsx-comment-rewrite-metadata.js';
+import type { WrapOptions } from '../utils/wrap-options.js';
+export type WrapCommentsResult = {
+    jsxBlockCommentRewrites: JsxBlockCommentRewrite[];
+    text: string;
+};
+export declare function wrapComments<T>(text: string, ast: T, options: WrapOptions, printerLayoutSource?: PrinterLayoutSource): Promise<string>;
+export declare function wrapCommentsWithMetadata<T>(text: string, ast: T, options: WrapOptions, printerLayoutSource?: PrinterLayoutSource): Promise<WrapCommentsResult>;

package/dist/comments/wrap-comments.js

@@ -0,0 +1,101 @@
+import { shouldSkipLineComment } from './comment-eligibility.js';
+import { isStandaloneBlockComment, isStandaloneLineComment } from './comment-location.js';
+import { collectCommentEntries } from './comment-ranges.js';
+import { collectEmbeddedExpressionRanges, doesBlockCommentSeparateEmbeddedTrailingLineComment, getEmbeddedTrailingLineCommentMove, isCommentInEmbeddedExpression, } from './embedded-expression-ranges.js';
+import { collectJsxExpressionContainerRanges, getJsxExpressionBlockCommentLayout } from './jsx-expression-layout.js';
+import { collectLineCommentGroup } from './line-comment-groups.js';
+import { collectPrettierIgnoredLineRanges, isCommentInIgnoredLineRange, isPrettierIgnoredBlockComment, isPrettierIgnoredStandaloneLineComment, isPrettierIgnoredTrailingLineComment, } from './prettier-ignore.js';
+import { getPrinterLayout } from './printer-layout.js';
+import { wrapBlockComment } from './wrap-block-comment.js';
+import { wrapLineCommentGroup } from './wrap-line-comment-group.js';
+import { wrapTrailingLineComment } from './wrap-trailing-line-comment.js';
+import { applyReplacements } from '../utils/replacements.js';
+import { getTabWidth } from '../utils/wrap-options.js';
+export async function wrapComments(text, ast, options, printerLayoutSource) {
+    return (await wrapCommentsWithMetadata(text, ast, options, printerLayoutSource)).text;
+}
+export async function wrapCommentsWithMetadata(text, ast, options, printerLayoutSource) {
+    const commentEntries = collectCommentEntries(ast, text);
+    const comments = commentEntries.map((entry) => entry.range);
+    const embeddedExpressionRanges = collectEmbeddedExpressionRanges(ast);
+    const jsxExpressionContainers = collectJsxExpressionContainerRanges(ast);
+    const ignoredLineRanges = collectPrettierIgnoredLineRanges(text, ast, commentEntries);
+    if (comments.length === 0) {
+        return { jsxBlockCommentRewrites: [], text };
+    }
+    const replacements = [];
+    const jsxBlockCommentRewrites = [];
+    const tabWidth = getTabWidth(options);
+    const printerLayout = getPrinterLayout(text, commentEntries, jsxExpressionContainers, printerLayoutSource, tabWidth);
+    let blockCommentIndex = -1;
+    for (let index = 0; index < comments.length; index += 1) {
+        const comment = comments[index];
+        const outputCommentLayout = printerLayout.comments[index];
+        if (comment?.kind === 'block') {
+            blockCommentIndex += 1;
+        }
+        if (comment === undefined || isCommentInIgnoredLineRange(comment, ignoredLineRanges)) {
+            continue;
+        }
+        if (comment.kind === 'block') {
+            if (isPrettierIgnoredBlockComment(text, commentEntries, index)) {
+                continue;
+            }
+            const jsxLayout = getJsxExpressionBlockCommentLayout(text, comment, comments[index - 1], jsxExpressionContainers, tabWidth, outputCommentLayout, printerLayout.jsxCommentMarkerColumns);
+            if (jsxLayout?.placement === 'inline') {
+                continue;
+            }
+            const outputLayout = outputCommentLayout === undefined
+                ? undefined
+                : {
+                    markerColumn: outputCommentLayout.markerColumn,
+                    placement: isStandaloneBlockComment(text, comment) ? 'standalone' : 'inline',
+                };
+            const replacement = await wrapBlockComment(text, comment, options, jsxLayout ?? outputLayout);
+            const preservesEmbeddedCommentOrder = doesBlockCommentSeparateEmbeddedTrailingLineComment(text, comment, comments[index + 1], embeddedExpressionRanges);
+            if (Array.isArray(replacement)) {
+                if (!preservesEmbeddedCommentOrder) {
+                    replacements.push(...replacement);
+                }
+            }
+            else if (replacement !== undefined) {
+                replacements.push(replacement);
+                if (jsxLayout !== undefined) {
+                    jsxBlockCommentRewrites.push({ blockCommentIndex, text: replacement.text });
+                }
+            }
+            continue;
+        }
+        if (shouldSkipLineComment(text, comment)) {
+            continue;
+        }
+        if (isPrettierIgnoredStandaloneLineComment(text, commentEntries, index)) {
+            index = collectLineCommentGroup(text, comments, index, tabWidth).endIndex;
+            continue;
+        }
+        if (!isStandaloneLineComment(text, comment)) {
+            if (isPrettierIgnoredTrailingLineComment(text, commentEntries, index)) {
+                continue;
+            }
+            const embeddedMove = getEmbeddedTrailingLineCommentMove(text, comment, embeddedExpressionRanges);
+            if (embeddedMove === undefined && isCommentInEmbeddedExpression(comment, embeddedExpressionRanges)) {
+                continue;
+            }
+            const replacement = await wrapTrailingLineComment(text, comment, options, outputCommentLayout, embeddedMove);
+            if (replacement !== undefined) {
+                replacements.push(...replacement);
+            }
+            continue;
+        }
+        const group = collectLineCommentGroup(text, comments, index, tabWidth);
+        index = group.endIndex;
+        const replacement = await wrapLineCommentGroup(text, group.comments, options, outputCommentLayout?.markerColumn);
+        if (replacement !== undefined) {
+            replacements.push(replacement);
+        }
+    }
+    return {
+        jsxBlockCommentRewrites,
+        text: applyReplacements(text, replacements),
+    };
+}

package/dist/comments/wrap-line-comment-group.d.ts

@@ -0,0 +1,4 @@
+import type { CommentRange } from './comment-ranges.js';
+import type { Replacement } from '../utils/replacements.js';
+import type { WrapOptions } from '../utils/wrap-options.js';
+export declare function wrapLineCommentGroup(text: string, comments: CommentRange[], options: WrapOptions, outputMarkerColumn?: number): Promise<Replacement | undefined>;

package/dist/comments/wrap-line-comment-group.js

@@ -0,0 +1,39 @@
+import { normalizeLineCommentBody } from './comment-body.js';
+import { getColumnAt } from '../utils/display-width.js';
+import { formatMarkdownLines } from '../utils/format-markdown.js';
+import { getContinuationIndent } from '../utils/indentation.js';
+import { getPreferredNewline } from '../utils/source-lines.js';
+import { getAvailableContentWidth, getTabWidth } from '../utils/wrap-options.js';
+export async function wrapLineCommentGroup(text, comments, options, outputMarkerColumn) {
+    const firstComment = comments[0];
+    if (firstComment === undefined) {
+        return undefined;
+    }
+    const lastComment = comments.at(-1) ?? firstComment;
+    const bodyLines = comments.map((comment) => normalizeLineCommentBody(text.slice(comment.start + 2, comment.end)));
+    if (bodyLines.every((line) => line.trim() === '')) {
+        return undefined;
+    }
+    const tabWidth = getTabWidth(options);
+    const markerColumn = outputMarkerColumn ?? getColumnAt(text, firstComment.start, tabWidth);
+    const availableWidth = getAvailableContentWidth(options, markerColumn + 3);
+    const formattedLines = await formatMarkdownLines(bodyLines.join('\n'), availableWidth, options);
+    const newline = getPreferredNewline(text, options);
+    const continuationIndent = getContinuationIndent(text, firstComment.start, markerColumn, options);
+    const replacementText = formattedLines
+        .map((line, index) => {
+        const commentText = line.length === 0 ? '//' : `// ${line}`;
+        return `${index === 0 ? '' : continuationIndent}${commentText}`;
+    })
+        .join(newline);
+    const start = firstComment.start;
+    const end = lastComment.end;
+    if (replacementText === text.slice(start, end)) {
+        return undefined;
+    }
+    return {
+        end,
+        start,
+        text: replacementText,
+    };
+}

package/dist/comments/wrap-trailing-line-comment.d.ts

@@ -0,0 +1,9 @@
+import type { CommentRange } from './comment-ranges.js';
+import type { EmbeddedTrailingLineCommentMove } from './embedded-expression-ranges.js';
+import type { Replacement } from '../utils/replacements.js';
+import type { WrapOptions } from '../utils/wrap-options.js';
+export type TrailingLineCommentLayout = {
+    lineIndentColumn: number;
+    lineWidth: number;
+};
+export declare function wrapTrailingLineComment(text: string, comment: CommentRange, options: WrapOptions, outputLayout?: TrailingLineCommentLayout, move?: EmbeddedTrailingLineCommentMove): Promise<Replacement[] | undefined>;

package/dist/comments/wrap-trailing-line-comment.js

@@ -0,0 +1,78 @@
+import { normalizeLineCommentBody } from './comment-body.js';
+import { getColumnAt, getColumns } from '../utils/display-width.js';
+import { formatMarkdownLines } from '../utils/format-markdown.js';
+import { getLeadingIndent, makeIndent } from '../utils/indentation.js';
+import { getLineEnd, getLineStart, getPreferredNewline } from '../utils/source-lines.js';
+import { getAvailableContentWidth, getPrintWidth, getTabWidth } from '../utils/wrap-options.js';
+export async function wrapTrailingLineComment(text, comment, options, outputLayout, move) {
+    const lineStart = getLineStart(text, comment.start);
+    const lineEnd = getLineEnd(text, comment.start);
+    if (comment.end > lineEnd) {
+        return undefined;
+    }
+    if (isTrailingLineCommentWithinPrintWidth(text, lineStart, lineEnd, options, outputLayout?.lineWidth)) {
+        return undefined;
+    }
+    const linePrefix = text.slice(lineStart, comment.start);
+    const codeText = linePrefix.replace(/[ \t]+$/u, '');
+    if (codeText.trim() === '') {
+        return undefined;
+    }
+    const body = normalizeLineCommentBody(text.slice(comment.start + 2, comment.end));
+    if (body.trim() === '') {
+        return undefined;
+    }
+    const tabWidth = getTabWidth(options);
+    const markerColumn = move === undefined ? undefined : (outputLayout?.lineIndentColumn ?? getColumnAt(text, move.insertAt, tabWidth));
+    const indent = markerColumn === undefined
+        ? getTrailingCommentIndent(codeText, linePrefix, options, outputLayout?.lineIndentColumn)
+        : makeIndent(markerColumn, options);
+    const availableWidth = getAvailableContentWidth(options, getColumns(indent, tabWidth) + 3);
+    const formattedLines = await formatMarkdownLines(body, availableWidth, options);
+    const newline = getPreferredNewline(text, options);
+    const leadingCommentText = buildLeadingCommentText(formattedLines, indent, newline, move !== undefined);
+    const codeEnd = lineStart + codeText.length;
+    const insertAt = move?.insertAt ?? lineStart;
+    const insertionSuffix = move === undefined ? '' : indent;
+    return [
+        {
+            end: insertAt,
+            start: insertAt,
+            text: [leadingCommentText, insertionSuffix].join(newline),
+        },
+        {
+            end: lineEnd,
+            start: move?.removeStart ?? codeEnd,
+            text: '',
+        },
+    ];
+}
+function buildLeadingCommentText(formattedLines, indent, newline, startsAtExpression) {
+    return formattedLines
+        .map((line, index) => {
+        const lineIndent = startsAtExpression && index === 0 ? '' : indent;
+        return `${lineIndent}${line.length === 0 ? '//' : `// ${line}`}`;
+    })
+        .join(newline);
+}
+function isTrailingLineCommentWithinPrintWidth(text, lineStart, lineEnd, options, outputLineWidth) {
+    if (outputLineWidth !== undefined) {
+        return outputLineWidth <= getPrintWidth(options);
+    }
+    const tabWidth = getTabWidth(options);
+    const lineText = text.slice(lineStart, lineEnd).replace(/[ \t]+$/u, '');
+    return getColumns(lineText, tabWidth) <= getPrintWidth(options);
+}
+function getTrailingCommentIndent(codeText, linePrefix, options, outputLineIndentColumn) {
+    const indent = getLeadingIndent(linePrefix);
+    if (outputLineIndentColumn === undefined && !isClosingDelimiterLine(codeText)) {
+        return indent;
+    }
+    const tabWidth = getTabWidth(options);
+    const indentColumn = outputLineIndentColumn ?? getColumns(indent, tabWidth);
+    const commentIndentColumn = isClosingDelimiterLine(codeText) ? indentColumn + tabWidth : indentColumn;
+    return makeIndent(commentIndentColumn, options);
+}
+function isClosingDelimiterLine(codeText) {
+    return /^[ \t]*[\])}]+[\])};,]*[ \t]*$/u.test(codeText);
+}

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import type { Plugin } from 'prettier';
 declare const parsers: {
     [parserName: string]: import("prettier").Parser<any>;
-} | undefined;
+};
 declare const printers: {
     [astFormat: string]: import("prettier").Printer<any>;
-} | undefined;
+};
 declare const plugin: Plugin;
 export { parsers, printers };
 export default plugin;

package/dist/index.js

@@ -1,7 +1,7 @@
-import { buildParsers } from './plugin/parsers.js';
-import { buildPrinters } from './plugin/printers.js';
-const parsers = buildParsers();
-const printers = buildPrinters();
+import { createParsers } from './plugin/create-parsers.js';
+import { createPrinters } from './plugin/create-printers.js';
+const parsers = createParsers();
+const printers = createPrinters();
 const plugin = {
     parsers,
     printers,

package/dist/plugin/create-parsers.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'prettier';
+export declare function createParsers(): NonNullable<Plugin['parsers']>;

package/dist/plugin/create-parsers.js

@@ -0,0 +1,57 @@
+import * as babelPlugin from 'prettier/plugins/babel';
+import * as typescriptPlugin from 'prettier/plugins/typescript';
+import { collectAstComments } from '../comments/comment-ranges.js';
+import { neutralizePrettierIgnoreForIgnoredComments } from '../comments/prettier-ignore.js';
+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';
+export function createParsers() {
+    const parsers = {};
+    for (const parserName of SUPPORTED_PARSER_NAMES) {
+        const sourceParsers = parserName === 'typescript' ? typescriptPlugin.parsers : babelPlugin.parsers;
+        const parser = sourceParsers[parserName];
+        if (parser !== undefined) {
+            parsers[parserName] = createWrappedParser(parserName, parser);
+        }
+    }
+    return parsers;
+}
+function createWrappedParser(parserName, parser) {
+    return {
+        ...parser,
+        async parse(text, options) {
+            const ast = await parser.parse(text, 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);
+            if (hasOffsetSensitiveFormatting(text, options)) {
+                return preprocessed;
+            }
+            let ast;
+            try {
+                ast = await parser.parse(preprocessed, options);
+            }
+            catch {
+                return preprocessed;
+            }
+            if (collectAstComments(ast).length === 0) {
+                return preprocessed;
+            }
+            const printerLayoutSource = await getPrinterLayoutSource(preprocessed, ast, parserName, parser, options);
+            const result = await wrapCommentsWithMetadata(preprocessed, ast, options, printerLayoutSource);
+            setJsxBlockCommentRewrites(options, result.jsxBlockCommentRewrites);
+            return result.text;
+        },
+    };
+}
+function hasOffsetSensitiveFormatting(text, options) {
+    const cursorOffset = options['cursorOffset'];
+    const hasCursor = typeof cursorOffset === 'number' && cursorOffset >= 0;
+    const hasPartialRange = options.rangeStart > 0 || options.rangeEnd < text.length;
+    return hasCursor || hasPartialRange;
+}

package/dist/plugin/create-printers.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'prettier';
+export declare function createPrinters(): NonNullable<Plugin['printers']>;