prettier-plugin-multiline-arrays-2 1.0.0 → 5.0.0

package/README.md

@@ -1,12 +1,11 @@
 # prettier-plugin-multiline-arrays-2
 
-[![npm](https://img.shields.io/npm/v/prettier-plugin-multiline-arrays-2.svg)](https://www.npmjs.com/package/prettier-plugin-multiline-arrays-2)
-[![CI](https://github.com/Nick2bad4u/prettier-plugin-multiline-arrays-2/actions/workflows/ci.yml/badge.svg)](https://github.com/Nick2bad4u/prettier-plugin-multiline-arrays-2/actions/workflows/ci.yml)
-[![License: MIT OR CC0-1.0](https://img.shields.io/badge/license-MIT%20OR%20CC0--1.0-blue.svg)](LICENSE-MIT)
+[![NPM license.](https://flat.badgen.net/npm/license/prettier-plugin-multiline-arrays-2?color=purple)](https://github.com/Nick2bad4u/prettier-plugin-multiline-arrays-2/blob/main/LICENSE) [![NPM total downloads.](https://flat.badgen.net/npm/dt/prettier-plugin-multiline-arrays-2?color=pink)](https://www.npmjs.com/package/prettier-plugin-multiline-arrays-2) [![Latest GitHub release.](https://flat.badgen.net/github/release/Nick2bad4u/prettier-plugin-multiline-arrays-2?color=cyan)](https://github.com/Nick2bad4u/prettier-plugin-multiline-arrays-2/releases) [![GitHub stars.](https://flat.badgen.net/github/stars/Nick2bad4u/prettier-plugin-multiline-arrays-2?color=yellow)](https://github.com/Nick2bad4u/prettier-plugin-multiline-arrays-2/stargazers) [![GitHub forks.](https://flat.badgen.net/github/forks/Nick2bad4u/prettier-plugin-multiline-arrays-2?color=orange)](https://github.com/Nick2bad4u/prettier-plugin-multiline-arrays-2/forks) [![GitHub open issues.](https://flat.badgen.net/github/open-issues/Nick2bad4u/prettier-plugin-multiline-arrays-2?color=red)](https://github.com/Nick2bad4u/prettier-plugin-multiline-arrays-2/issues) [![Codecov.](https://flat.badgen.net/codecov/github/Nick2bad4u/prettier-plugin-multiline-arrays-2?color=blue)](https://codecov.io/gh/Nick2bad4u/prettier-plugin-multiline-arrays-2) [![Repo Checks.](https://flat.badgen.net/github/checks/Nick2bad4u/prettier-plugin-multiline-arrays-2?color=green)](https://github.com/Nick2bad4u/prettier-plugin-multiline-arrays-2/actions)
 
 Prettier plugin to force array elements to wrap onto new lines, even when there is only one element. It supports TypeScript, JavaScript, JSON, and JSON5, with options for wrap thresholds and per-line element patterns.
 
-This is a maintained fork of [electrovir/prettier-plugin-multiline-arrays](https://github.com/electrovir/prettier-plugin-multiline-arrays). Credit to the original plugin for the core idea and implementation.
+> [!NOTE]
+> This is a maintained fork of [electrovir/prettier-plugin-multiline-arrays](https://github.com/electrovir/prettier-plugin-multiline-arrays). Credit to the original plugin for the core idea and implementation.
 
 ## Install
 
@@ -27,7 +26,7 @@ When combining this plugin with parser/preprocessor plugins such as `prettier-pl
 ## Options
 
 - `multilineArraysWrapThreshold`: number. Arrays with more elements than this value are forced to wrap. The default is `-1`, which disables automatic threshold wrapping.
-- `multilineArraysLinePattern`: string. Space- or comma-separated list of numbers controlling how many elements appear on each line. The pattern repeats for longer arrays. The default is `"1"`.
+- `multilineArraysLinePattern`: string. Space- or comma-separated list of numbers controlling the element count per line. The pattern repeats for longer arrays. The default is `"1"`.
 
 Example:
 
@@ -75,17 +74,4 @@ npm test
 npm run release:check
 ```
 
-The test suite runs against Node's built-in test runner through `tsx` and includes a `test:prettier-latest` check to verify compatibility with the current npm `latest` Prettier release.
-
-## Publishing
-
-This package is prepared for npm trusted publishing from GitHub Actions. Before the first release, create the package on npm and add a trusted publisher with these values:
-
-- Package: `prettier-plugin-multiline-arrays-2`
-- Provider: GitHub Actions
-- Repository owner: `Nick2bad4u`
-- Repository name: `prettier-plugin-multiline-arrays-2`
-- Workflow filename: `npm-release.yml`
-- Environment: leave unset unless you add a matching GitHub environment to the workflow
-
-The release workflow uses GitHub OIDC through `id-token: write` and publishes with provenance. It intentionally does not require an npm automation token.
+The test suite runs with Vitest coverage and includes a `test:prettier-latest` check to verify compatibility with the current npm `latest` Prettier release.

package/dist/augments/array.d.ts

@@ -1,3 +1,9 @@
 import type { SourceLocation } from "estree";
-/** Both line and column in "range" are 0 indexed. */
-export declare function extractTextBetweenRanges(input: string[], range: Omit<SourceLocation, "source">): string;
+type SourceRange = Pick<SourceLocation, "end" | "start">;
+/**
+ * Both line and column in "range" are 0 indexed.
+ *
+ * @throws If the range starts after it ends.
+ */
+export declare function extractTextBetweenRanges(input: string[], range: SourceRange): string;
+export {};

package/dist/augments/array.js

@@ -1,9 +1,14 @@
-/** Both line and column in "range" are 0 indexed. */
+import { assertDefined } from "ts-extras";
+/**
+ * Both line and column in "range" are 0 indexed.
+ *
+ * @throws If the range starts after it ends.
+ */
 export function extractTextBetweenRanges(input, range) {
     if (range.start.line > range.end.line) {
         throw new Error(`Start line "${range.start.line}" cannot be greater than end line "${range.end.line}"`);
     }
-    else if (range.start.line === range.end.line) {
+    if (range.start.line === range.end.line) {
         if (range.start.column >= range.end.column) {
             throw new Error(`When start and end are on the same line, the start column "${range.start.column}" must be less than the end column "${range.end.column}".`);
         }
@@ -11,9 +16,10 @@ export function extractTextBetweenRanges(input, range) {
     }
     let extractedText = input[range.start.line]?.slice(range.start.column + 1) ?? "";
     extractedText += "\n";
-    for (let lineIndex = range.start.line + 1; lineIndex < range.end.line; lineIndex++) {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        extractedText += input[lineIndex];
+    for (let lineIndex = range.start.line + 1; lineIndex < range.end.line; lineIndex += 1) {
+        const inputLine = input[lineIndex];
+        assertDefined(inputLine);
+        extractedText += inputLine;
         extractedText += "\n";
     }
     extractedText += input[range.end.line]?.slice(0, range.end.column) ?? "";

package/dist/augments/doc.d.ts

@@ -1,5 +1,5 @@
 import type { Doc, doc } from "prettier";
-type NestedStringArray = (string | NestedStringArray)[];
+type NestedStringArray = (NestedStringArray | string)[];
 export declare function stringifyDoc(input: Doc | null | undefined, recursive?: boolean): NestedStringArray;
-export declare function isDocCommand(inputDoc: Doc | undefined | null): inputDoc is doc.builders.DocCommand;
+export declare function isDocCommand(inputDoc: Doc | null | undefined): inputDoc is doc.builders.DocCommand;
 export {};

package/dist/augments/doc.js

@@ -1,4 +1,5 @@
 import { stringify } from "@augment-vir/common";
+import { objectHasIn } from "ts-extras";
 const childProperties = [
     "breakContents",
     "contents",
@@ -9,22 +10,24 @@ export function stringifyDoc(input, recursive = false) {
     if (typeof input === "string" || !input) {
         return [stringify(input)];
     }
-    else if (Array.isArray(input)) {
+    if (Array.isArray(input)) {
         return input.map((entry) => stringifyDoc(entry, recursive));
     }
-    else if (recursive) {
-        const children = childProperties.reduce((accum, currentProperty) => {
-            if (currentProperty in input) {
-                accum.push(`${currentProperty}:`, stringifyDoc(input[currentProperty], recursive));
+    if (recursive) {
+        const children = [];
+        for (const currentProperty of childProperties) {
+            if (objectHasIn(input, currentProperty)) {
+                children.push(`${currentProperty}:`, stringifyDoc(input[currentProperty], recursive));
             }
-            return accum;
-        }, []);
-        if (children.length) {
+        }
+        if (children.length > 0) {
             return [`${input.type}:`, stringifyDoc(children, recursive)];
         }
     }
     return [input.type];
 }
 export function isDocCommand(inputDoc) {
-    return (!!inputDoc && typeof inputDoc !== "string" && !Array.isArray(inputDoc));
+    return (Boolean(inputDoc) &&
+        typeof inputDoc !== "string" &&
+        !Array.isArray(inputDoc));
 }

package/dist/augments/string.js

@@ -2,5 +2,5 @@ export function capitalizeFirst(input) {
     if (!input) {
         return input;
     }
-    return (input[0] || "").toUpperCase() + input.slice(1);
+    return (input[0] ?? "").toUpperCase() + input.slice(1);
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { type Parser, type RequiredOptions, type SupportOption } from "prettier";
+import type { Parser, RequiredOptions, SupportOption } from "prettier";
 import { type MultilineArrayOptions } from "./options.js";
 export * from "./options.js";
 export { pluginMarker } from "./plugin-marker.js";

package/dist/index.js

@@ -1,5 +1,4 @@
 import { getObjectTypedKeys, mapObjectValues } from "@augment-vir/common";
-import {} from "prettier";
 import { parsers as babelParsers } from "prettier/plugins/babel";
 import { parsers as tsParsers } from "prettier/plugins/typescript";
 import { defaultMultilineArrayOptions, optionHelp, } from "./options.js";
@@ -14,30 +13,53 @@ export const parsers = mapObjectValues({
     "babel-ts": babelParsers["babel-ts"],
     json: babelParsers.json,
     json5: babelParsers.json5,
-}, (languageName, parserEntry) => {
-    return wrapParser(parserEntry, languageName);
-});
+}, (languageName, parserEntry) => wrapParser(parserEntry, languageName));
 const printers = {
     estree: multilineArrayPrinter,
     "estree-json": multilineArrayPrinter,
 };
-export const options = getObjectTypedKeys(defaultMultilineArrayOptions).reduce((accum, key) => {
-    const defaultValue = defaultMultilineArrayOptions[key];
-    const supportOption = {
-        name: key,
-        type: (typeof defaultValue === "number"
-            ? "int"
-            : typeof defaultValue),
-        category: "multilineArray",
-        default: defaultValue,
-        description: optionHelp[key],
-    };
-    accum[key] = supportOption;
-    return accum;
-}, {});
-export const defaultOptions = defaultMultilineArrayOptions;
+function createOptions() {
+    const output = {};
+    for (const key of getObjectTypedKeys(defaultMultilineArrayOptions)) {
+        const defaultValue = defaultMultilineArrayOptions[key];
+        let supportOption;
+        if (typeof defaultValue === "number") {
+            supportOption = {
+                name: key,
+                type: "int",
+                category: "multilineArray",
+                default: defaultValue,
+                description: optionHelp[key],
+            };
+        }
+        else if (typeof defaultValue === "boolean") {
+            supportOption = {
+                name: key,
+                type: "boolean",
+                category: "multilineArray",
+                default: defaultValue,
+                description: optionHelp[key],
+            };
+        }
+        else {
+            supportOption = {
+                name: key,
+                type: "string",
+                category: "multilineArray",
+                default: defaultValue,
+                description: optionHelp[key],
+            };
+        }
+        output[key] = supportOption;
+    }
+    return output;
+}
+export const options = createOptions();
+export const defaultOptions = {
+    ...defaultMultilineArrayOptions,
+};
 /** Not actually exported: this is just for type checking purposes. */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- The sentinel validates named exports against Prettier's Plugin shape.
 const plugin = {
     options,
     printers,

package/dist/options.d.ts

@@ -1,16 +1,13 @@
 import { type Values } from "@augment-vir/common";
-import type { SupportOptionType as PrettierOptionType } from "prettier";
 export declare const envDebugKey = "MULTILINE_DEBUG";
 export declare const nextLinePatternComment = "prettier-multiline-arrays-next-line-pattern:";
-export declare const untilNextLinePatternCommentRegExp: RegExp;
 export declare const setLinePatternComment = "prettier-multiline-arrays-set-line-pattern:";
-export declare const untilSetLinePatternCommentRegExp: RegExp;
 export declare const nextWrapThresholdComment = "prettier-multiline-arrays-next-threshold:";
-export declare const untilNextWrapThresholdCommentRegExp: RegExp;
 export declare const setWrapThresholdComment = "prettier-multiline-arrays-set-threshold:";
-export declare const untilSetWrapThresholdCommentRegExp: RegExp;
 export declare const resetComment = "prettier-multiline-arrays-reset";
-export type MultilineArrayOptions = {
+export declare function stripTextUntilCommentTrigger(input: string, commentTrigger: string): string;
+export interface MultilineArrayOptions {
+    multilineArraysLinePattern: string;
     /**
      * If there are MORE elements in the array than this, the array will be
      * forced to wrap.
@@ -21,12 +18,12 @@ export type MultilineArrayOptions = {
      * Set to 2 to only wrap if there are more than 2 element. Etc.
      */
     multilineArraysWrapThreshold: number;
-    multilineArraysLinePattern: string;
-};
+}
 export declare const optionHelp: Record<keyof MultilineArrayOptions, string>;
 export declare const optionPropertyValidators: {
     [Property in keyof MultilineArrayOptions]: (input: unknown) => input is MultilineArrayOptions[Property];
 };
 export declare const defaultMultilineArrayOptions: MultilineArrayOptions;
-export declare function getPrettierOptionType(input: Values<MultilineArrayOptions>): PrettierOptionType;
+export type MultilinePrettierOptionType = "boolean" | "int" | "string";
+export declare function getPrettierOptionType(input: Values<MultilineArrayOptions>): MultilinePrettierOptionType;
 export declare function fillInOptions<T extends object>(input: T | undefined): MultilineArrayOptions & T;

package/dist/options.js

@@ -1,34 +1,32 @@
 import { getObjectTypedKeys } from "@augment-vir/common";
+import { objectHasIn, safeCastTo, stringSplit } from "ts-extras";
 export const envDebugKey = "MULTILINE_DEBUG";
 export const nextLinePatternComment = "prettier-multiline-arrays-next-line-pattern:";
-// all the text up until the comment trigger
-export const untilNextLinePatternCommentRegExp = new RegExp(`.*${nextLinePatternComment}`);
 export const setLinePatternComment = "prettier-multiline-arrays-set-line-pattern:";
-// all the text up until the comment trigger
-export const untilSetLinePatternCommentRegExp = new RegExp(`.*${setLinePatternComment}`);
 export const nextWrapThresholdComment = "prettier-multiline-arrays-next-threshold:";
-// all the text up until the comment trigger
-export const untilNextWrapThresholdCommentRegExp = new RegExp(`.*${nextWrapThresholdComment}`);
 export const setWrapThresholdComment = "prettier-multiline-arrays-set-threshold:";
-// all the text up until the comment trigger
-export const untilSetWrapThresholdCommentRegExp = new RegExp(`.*${setWrapThresholdComment}`);
 export const resetComment = "prettier-multiline-arrays-reset";
+export function stripTextUntilCommentTrigger(input, commentTrigger) {
+    const triggerIndex = input.indexOf(commentTrigger);
+    if (triggerIndex === -1) {
+        return input;
+    }
+    return input.slice(triggerIndex + commentTrigger.length);
+}
 export const optionHelp = {
     multilineArraysWrapThreshold: `A number indicating that all arrays should wrap when they have MORE than the specified number. Defaults to -1, indicating that no special wrapping enforcement will take place.\nExample: multilineArraysWrapThreshold: 3\nCan be overridden with a comment starting with ${nextWrapThresholdComment}.\nComment example: // ${nextWrapThresholdComment} 5`,
     multilineArraysLinePattern: `A string with a space separated list of numbers indicating how many elements should be on each line. The pattern repeats if an array is longer than the pattern. Defaults to an empty string. Any invalid numbers causes the whole pattern to revert to the default. This overrides the wrap threshold option.\nExample: elementsPerLinePattern: "3 2 1"\nCan be overridden with a comment starting with ${nextLinePatternComment}.\nComment example: // ${nextLinePatternComment} 3 2 1\nThis option overrides Prettier's default wrapping; multiple elements on one line will not be wrapped even if they don't fit within the column count.`,
 };
 export const optionPropertyValidators = {
-    multilineArraysWrapThreshold(input) {
-        return typeof input === "number" && !isNaN(input);
-    },
+    multilineArraysWrapThreshold: (input) => typeof input === "number" && !Number.isNaN(input),
     multilineArraysLinePattern(input) {
         if (typeof input !== "string") {
             return false;
         }
-        const splitNumbers = input.split(" ");
+        const splitNumbers = stringSplit(input, " ");
         return splitNumbers.every((splitNumber) => {
             const numericSplit = Number(splitNumber);
-            return !isNaN(numericSplit);
+            return !Number.isNaN(numericSplit);
         });
     },
 };
@@ -46,9 +44,7 @@ export function getPrettierOptionType(input) {
     if (mappedType) {
         return mappedType;
     }
-    else {
-        throw new Error(`Unmapped option type: '${typeof input}'`);
-    }
+    throw new Error(`Unmapped option type: '${typeof input}'`);
 }
 export function fillInOptions(input) {
     if (!input || typeof input !== "object") {
@@ -57,15 +53,14 @@ export function fillInOptions(input) {
     const newOptions = {
         ...input,
     };
-    getObjectTypedKeys(defaultMultilineArrayOptions).forEach((optionsKey) => {
-        const inputValue = input[optionsKey];
+    for (const optionsKey of getObjectTypedKeys(defaultMultilineArrayOptions)) {
+        const inputValue = objectHasIn(input, optionsKey)
+            ? input[optionsKey]
+            : undefined;
         const defaultValue = defaultMultilineArrayOptions[optionsKey];
-        if (optionPropertyValidators[optionsKey](inputValue)) {
-            newOptions[optionsKey] = inputValue;
-        }
-        else {
-            newOptions[optionsKey] = defaultValue;
-        }
-    });
+        safeCastTo(newOptions)[optionsKey] = optionPropertyValidators[optionsKey](inputValue)
+            ? inputValue
+            : defaultValue;
+    }
     return newOptions;
 }

package/dist/plugin-marker.js

@@ -1,2 +1,2 @@
-// used to find our own plugin
+// Used to find our own plugin
 export const pluginMarker = {};

package/dist/preprocessing.d.ts

@@ -1,2 +1,2 @@
 import type { Parser } from "prettier";
-export declare function wrapParser(originalParser: Parser, parserName: string): Parser<any>;
+export declare function wrapParser(originalParser: Parser, parserName: string): Parser;

package/dist/preprocessing.js

@@ -1,13 +1,32 @@
 import { stringify } from "@augment-vir/common";
 import { createWrappedMultiTargetProxy } from "proxy-vir";
+import { not, objectHasIn } from "ts-extras";
 import { pluginMarker } from "./plugin-marker.js";
 import { createMultilineArrayPrinter } from "./printer/multiline-array-printer.js";
 import { setOriginalPrinter } from "./printer/original-printer.js";
+function hasThisPluginMarker(plugin) {
+    return (typeof plugin === "object" &&
+        plugin != undefined &&
+        !(plugin instanceof URL) &&
+        objectHasIn(plugin, "pluginMarker") &&
+        plugin.pluginMarker === pluginMarker);
+}
+async function runPreprocessSteps(preprocessSteps, text, index = 0) {
+    const preprocessStep = preprocessSteps[index];
+    if (!preprocessStep) {
+        return text;
+    }
+    return runPreprocessSteps(preprocessSteps, await preprocessStep(text), index + 1);
+}
 function addMultilinePrinter(options) {
-    if ("printer" in options) {
-        setOriginalPrinter(options.printer);
+    if (objectHasIn(options, "printer")) {
+        const originalPrinter = options.printer;
+        if (!originalPrinter) {
+            throw new Error("Could not find printer while adding printer.");
+        }
+        setOriginalPrinter(originalPrinter);
         /** Overwrite the printer with ours. */
-        options.printer = createMultilineArrayPrinter(options.printer);
+        options.printer = createMultilineArrayPrinter(originalPrinter);
     }
     else {
         const astFormat = options.astFormat;
@@ -19,21 +38,26 @@ function addMultilinePrinter(options) {
          * plugins so that ours gets chosen.
          */
         const plugins = options.plugins ?? [];
-        const firstMatchedPlugin = plugins.find((plugin) => typeof plugin !== "string" &&
-            !(plugin instanceof URL) &&
-            !!plugin.printers &&
-            !!plugin.printers[astFormat]);
+        const firstMatchedPlugin = plugins.find((plugin) => {
+            if (typeof plugin === "string" || plugin instanceof URL) {
+                return false;
+            }
+            const printers = plugin.printers;
+            if (!printers) {
+                return false;
+            }
+            const matchedPrinter = printers[astFormat];
+            return Boolean(matchedPrinter);
+        });
         if (!firstMatchedPlugin || typeof firstMatchedPlugin === "string") {
-            throw new Error(`Matched invalid first plugin: ${firstMatchedPlugin}`);
+            throw new Error(`Matched invalid first plugin: ${String(firstMatchedPlugin)}`);
         }
-        const matchedPrinter = firstMatchedPlugin.printers?.[astFormat];
+        const matchedPrinter = firstMatchedPlugin.printers[astFormat];
         if (!matchedPrinter) {
             throw new Error(`Printer not found on matched plugin: ${stringify(firstMatchedPlugin)}`);
         }
         setOriginalPrinter(matchedPrinter);
-        const thisPluginIndex = plugins.findIndex((plugin) => {
-            return (plugin.pluginMarker === pluginMarker);
-        });
+        const thisPluginIndex = plugins.findIndex((plugin) => hasThisPluginMarker(plugin));
         const thisPlugin = plugins[thisPluginIndex];
         if (!thisPlugin) {
             throw new Error("This plugin was not found.");
@@ -42,16 +66,25 @@ function addMultilinePrinter(options) {
          * Add this plugin to the beginning of the array so its printer is found
          * first.
          */
-        plugins.splice(thisPluginIndex, 1);
-        plugins.splice(0, 0, thisPlugin);
+        options.plugins = [
+            thisPlugin,
+            ...plugins.toSpliced(thisPluginIndex, 1),
+        ];
     }
 }
 function findPluginsByParserName(parserName, plugins) {
     return plugins.filter((plugin) => {
-        return (typeof plugin === "object" &&
-            !(plugin instanceof URL) &&
-            plugin.pluginMarker !== pluginMarker &&
-            !!plugin.parsers?.[parserName]);
+        if (typeof plugin !== "object" ||
+            plugin instanceof URL ||
+            hasThisPluginMarker(plugin)) {
+            return false;
+        }
+        const parsers = plugin.parsers;
+        if (!parsers) {
+            return false;
+        }
+        const matchedParser = parsers[parserName];
+        return Boolean(matchedParser);
     });
 }
 export function wrapParser(originalParser, parserName) {
@@ -65,25 +98,22 @@ export function wrapParser(originalParser, parserName) {
     async function multilineArraysPluginPreprocess(text, options) {
         const pluginsFromOptions = options.plugins ?? [];
         const pluginsWithRelevantParsers = findPluginsByParserName(parserName, pluginsFromOptions);
-        pluginsWithRelevantParsers.forEach((plugin) => {
+        for (const plugin of pluginsWithRelevantParsers) {
             const currentParser = plugin.parsers?.[parserName];
             if (currentParser &&
                 plugin?.name?.includes("prettier-plugin-sort-json")) {
                 parserProxy.proxyModifier.addOverrideTarget(currentParser);
             }
-        });
-        const pluginsWithPreprocessor = pluginsWithRelevantParsers.filter((plugin) => !!plugin.parsers?.[parserName]?.preprocess);
-        let processedText = text;
-        for (const pluginWithPreprocessor of pluginsWithPreprocessor) {
-            const nextText = await pluginWithPreprocessor.parsers?.[parserName]?.preprocess?.(processedText, {
+        }
+        const pluginsWithPreprocessor = pluginsWithRelevantParsers.filter((plugin) => Boolean(plugin.parsers?.[parserName]?.preprocess));
+        const preprocessSteps = pluginsWithPreprocessor.map((pluginWithPreprocessor) => async (previousProcessedText) => {
+            const nextText = await pluginWithPreprocessor.parsers?.[parserName]?.preprocess?.(previousProcessedText, {
                 ...options,
-                plugins: pluginsFromOptions.filter((plugin) => plugin.pluginMarker !==
-                    pluginMarker),
+                plugins: pluginsFromOptions.filter(not(hasThisPluginMarker)),
             });
-            if (nextText != undefined) {
-                processedText = nextText;
-            }
-        }
+            return nextText ?? previousProcessedText;
+        });
+        const processedText = await runPreprocessSteps(preprocessSteps, text);
         addMultilinePrinter(options);
         return processedText;
     }

package/dist/printer/child-docs.d.ts

@@ -1,18 +1,20 @@
 import type { Doc } from "prettier";
-type Parents = {
-    parent: Doc;
+interface Parents {
     childIndexInThisParent: number | undefined;
-};
+    parent: Doc;
+}
 /**
+ * Walk a Prettier doc tree from the given starting node.
+ *
  * @returns Boolean true means keep walking children and siblings, false means
  *   stop walking children and siblings. Returning false does not stop walking
  *   of aunts/uncles or ancestors.
  */
-export declare function walkDoc({ startDoc, debug, callback, parents, index, }: Readonly<{
-    startDoc: Doc;
+export declare function walkDoc({ startDoc, debug, callback: visitDoc, parents, index, }: Readonly<{
+    callback: (currentDoc: Doc, parents: Parents[], index: number | undefined) => boolean | undefined;
     debug: boolean;
-    callback: (currentDoc: Doc, parents: Parents[], index: number | undefined) => boolean | void | undefined;
-    parents?: Parents[];
     index?: number | undefined;
+    parents?: Parents[];
+    startDoc: Doc;
 }>): boolean;
 export {};