prettier-plugin-multiline-arrays-2 1.0.0

package/dist/preprocessing.js

@@ -0,0 +1,94 @@
+import { stringify } from "@augment-vir/common";
+import { createWrappedMultiTargetProxy } from "proxy-vir";
+import { pluginMarker } from "./plugin-marker.js";
+import { createMultilineArrayPrinter } from "./printer/multiline-array-printer.js";
+import { setOriginalPrinter } from "./printer/original-printer.js";
+function addMultilinePrinter(options) {
+    if ("printer" in options) {
+        setOriginalPrinter(options.printer);
+        /** Overwrite the printer with ours. */
+        options.printer = createMultilineArrayPrinter(options.printer);
+    }
+    else {
+        const astFormat = options.astFormat;
+        if (!astFormat) {
+            throw new Error("Could not find astFormat while adding printer.");
+        }
+        /**
+         * If the printer hasn't already been assigned in options, rearrange
+         * 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]);
+        if (!firstMatchedPlugin || typeof firstMatchedPlugin === "string") {
+            throw new Error(`Matched invalid first plugin: ${firstMatchedPlugin}`);
+        }
+        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 thisPlugin = plugins[thisPluginIndex];
+        if (!thisPlugin) {
+            throw new Error("This plugin was not found.");
+        }
+        /**
+         * Add this plugin to the beginning of the array so its printer is found
+         * first.
+         */
+        plugins.splice(thisPluginIndex, 1);
+        plugins.splice(0, 0, thisPlugin);
+    }
+}
+function findPluginsByParserName(parserName, plugins) {
+    return plugins.filter((plugin) => {
+        return (typeof plugin === "object" &&
+            !(plugin instanceof URL) &&
+            plugin.pluginMarker !== pluginMarker &&
+            !!plugin.parsers?.[parserName]);
+    });
+}
+export function wrapParser(originalParser, parserName) {
+    /**
+     * Create a multi-target proxy of parsers so that we don't block other
+     * plugins.
+     */
+    const parserProxy = createWrappedMultiTargetProxy({
+        initialTarget: originalParser,
+    });
+    async function multilineArraysPluginPreprocess(text, options) {
+        const pluginsFromOptions = options.plugins ?? [];
+        const pluginsWithRelevantParsers = findPluginsByParserName(parserName, pluginsFromOptions);
+        pluginsWithRelevantParsers.forEach((plugin) => {
+            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, {
+                ...options,
+                plugins: pluginsFromOptions.filter((plugin) => plugin.pluginMarker !==
+                    pluginMarker),
+            });
+            if (nextText != undefined) {
+                processedText = nextText;
+            }
+        }
+        addMultilinePrinter(options);
+        return processedText;
+    }
+    parserProxy.proxyModifier.addOverrideTarget({
+        preprocess: multilineArraysPluginPreprocess,
+    });
+    return parserProxy.proxy;
+}

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

@@ -0,0 +1,18 @@
+import type { Doc } from "prettier";
+type Parents = {
+    parent: Doc;
+    childIndexInThisParent: number | undefined;
+};
+/**
+ * @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;
+    debug: boolean;
+    callback: (currentDoc: Doc, parents: Parents[], index: number | undefined) => boolean | void | undefined;
+    parents?: Parents[];
+    index?: number | undefined;
+}>): boolean;
+export {};

package/dist/printer/child-docs.js

@@ -0,0 +1,89 @@
+/**
+ * @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 function walkDoc({ startDoc, debug, callback, parents = [], index, }) {
+    if (!startDoc) {
+        return true;
+    }
+    if (debug) {
+        const parent = parents[0];
+        console.info({
+            firingCallbackFor: startDoc,
+            status: "Calling callback",
+            parent: parent
+                ? {
+                    isArray: Array.isArray(parent),
+                    type: parent?.type ?? typeof parent,
+                }
+                : undefined,
+            index,
+        });
+    }
+    if (!callback(startDoc, parents, index)) {
+        // if the callback returns something falsy, don't try to walk its children
+        return false;
+    }
+    else if (typeof startDoc === "string") {
+        return true;
+    }
+    else if (Array.isArray(startDoc)) {
+        if (debug) {
+            console.info("walking array children");
+        }
+        // one a child returns false, abort walking this array
+        startDoc.every((innerDoc, index) => {
+            return walkDoc({
+                startDoc: innerDoc,
+                debug,
+                callback,
+                parents: [
+                    {
+                        parent: startDoc,
+                        childIndexInThisParent: index,
+                    },
+                    ...parents,
+                ],
+                index,
+            });
+        });
+    }
+    else if ("contents" in startDoc) {
+        if (debug) {
+            console.info("walking contents property");
+        }
+        return walkDoc({
+            startDoc: startDoc.contents,
+            debug,
+            callback,
+            parents: [
+                {
+                    parent: startDoc,
+                    childIndexInThisParent: undefined,
+                },
+                ...parents,
+            ],
+            index: undefined,
+        });
+    }
+    else if ("parts" in startDoc) {
+        if (debug) {
+            console.info("walking parts property");
+        }
+        return walkDoc({
+            startDoc: startDoc.parts,
+            debug,
+            callback,
+            parents: [
+                {
+                    parent: startDoc,
+                    childIndexInThisParent: undefined,
+                },
+                ...parents,
+            ],
+            index: undefined,
+        });
+    }
+    return true;
+}

package/dist/printer/comment-triggers.d.ts

@@ -0,0 +1,25 @@
+import type { Node } from "estree";
+type LineNumberDetails<T> = {
+    [lineNumber: string]: T;
+};
+export type LineCounts = LineNumberDetails<number[]>;
+export type WrapThresholds = LineNumberDetails<number>;
+export type CommentTriggerWithEnding<T> = {
+    [P in keyof T]: {
+        data: T[P];
+        lineEnd: number;
+    };
+};
+export type CommentTriggers = {
+    nextLineCounts: LineCounts;
+    setLineCounts: CommentTriggerWithEnding<LineCounts>;
+    nextWrapThresholds: WrapThresholds;
+    setWrapThresholds: CommentTriggerWithEnding<WrapThresholds>;
+};
+export declare function getCommentTriggers(key: Node, debug: boolean): CommentTriggers;
+export declare function parseNextLineCounts({ input, nextOnly, debug, }: Readonly<{
+    input: string;
+    nextOnly: boolean;
+    debug: boolean;
+}>): number[];
+export {};

package/dist/printer/comment-triggers.js

@@ -0,0 +1,327 @@
+import { check } from "@augment-vir/assert";
+import { getObjectTypedKeys } from "@augment-vir/common";
+import { nextLinePatternComment, nextWrapThresholdComment, resetComment, setLinePatternComment, setWrapThresholdComment, untilNextLinePatternCommentRegExp, untilNextWrapThresholdCommentRegExp, untilSetLinePatternCommentRegExp, untilSetWrapThresholdCommentRegExp, } from "../options.js";
+import { extractComments } from "./comments.js";
+import { isArrayLikeNode } from "./supported-node-types.js";
+const mappedCommentTriggers = new WeakMap();
+const ignoredAstChildKeys = [
+    "comments",
+    "leadingComments",
+    "loc",
+    "range",
+    "raw",
+    "tokens",
+    "trailingComments",
+    "value",
+];
+const descendantBoundaryTypes = [
+    "ArrowFunctionExpression",
+    "ClassDeclaration",
+    "ClassExpression",
+    "FunctionDeclaration",
+    "FunctionExpression",
+];
+export function getCommentTriggers(key, debug) {
+    const alreadyExisting = mappedCommentTriggers.get(key);
+    if (!alreadyExisting) {
+        return setCommentTriggers(key, debug);
+    }
+    return alreadyExisting;
+}
+function setCommentTriggers(rootNode, debug) {
+    // parse comments only on the root node so it only happens once
+    const comments = extractComments(rootNode);
+    if (debug) {
+        console.info({
+            comments,
+        });
+    }
+    const starterTriggers = {
+        nextLineCounts: {},
+        setLineCounts: {},
+        nextWrapThresholds: {},
+        setWrapThresholds: {},
+        resets: [],
+    };
+    const internalCommentTriggers = comments.reduce((accum, currentComment) => {
+        const commentText = currentComment.value?.replace(/\n/g, " ");
+        if (!currentComment.loc) {
+            throw new Error(`Cannot read line location for comment ${currentComment.value}`);
+        }
+        const nextLineCounts = getLineCounts({
+            commentText,
+            nextOnly: true,
+            debug,
+        });
+        if (nextLineCounts.length) {
+            accum.nextLineCounts[currentComment.loc.end.line] =
+                nextLineCounts;
+        }
+        const nextWrapThreshold = getWrapThreshold(commentText, true);
+        if (nextWrapThreshold != undefined) {
+            accum.nextWrapThresholds[currentComment.loc.end.line] =
+                nextWrapThreshold;
+        }
+        const setLineCounts = getLineCounts({
+            commentText,
+            nextOnly: false,
+            debug,
+        });
+        if (setLineCounts.length) {
+            accum.setLineCounts[currentComment.loc.end.line] = {
+                data: setLineCounts,
+                lineEnd: Infinity,
+            };
+        }
+        const setWrapThreshold = getWrapThreshold(commentText, false);
+        if (setWrapThreshold != undefined) {
+            accum.setWrapThresholds[currentComment.loc.end.line] = {
+                data: setWrapThreshold,
+                lineEnd: Infinity,
+            };
+        }
+        const resetComment = isResetComment(commentText);
+        if (resetComment) {
+            accum.resets.push(currentComment.loc.end.line);
+        }
+        return accum;
+    }, starterTriggers);
+    internalCommentTriggers.resets.sort();
+    setResets(internalCommentTriggers);
+    mapNextCommentTriggers({
+        internalCommentTriggers,
+        rootNode,
+    });
+    const commentTriggers = {
+        ...internalCommentTriggers,
+    };
+    delete commentTriggers.resets;
+    // save to a map so we don't have to recalculate these every time
+    mappedCommentTriggers.set(rootNode, commentTriggers);
+    return commentTriggers;
+}
+function mapNextCommentTriggers({ internalCommentTriggers, rootNode, }) {
+    internalCommentTriggers.nextLineCounts = mapNextLineTriggers({
+        rootNode,
+        triggers: internalCommentTriggers.nextLineCounts,
+    });
+    internalCommentTriggers.nextWrapThresholds = mapNextLineTriggers({
+        rootNode,
+        triggers: internalCommentTriggers.nextWrapThresholds,
+    });
+}
+function mapNextLineTriggers({ rootNode, triggers, }) {
+    return getObjectTypedKeys(triggers).reduce((mappedTriggers, triggerLineNumber) => {
+        const trigger = triggers[triggerLineNumber];
+        const targetLineNumber = findArrayLikeTargetLine({
+            nextLineNumber: Number(triggerLineNumber) + 1,
+            rootNode,
+        });
+        if (targetLineNumber == undefined || trigger == undefined) {
+            return mappedTriggers;
+        }
+        return {
+            ...mappedTriggers,
+            [targetLineNumber]: trigger,
+        };
+    }, {});
+}
+function findArrayLikeTargetLine({ rootNode, nextLineNumber, }) {
+    return findAstNodesStartingOnLine({
+        lineNumber: nextLineNumber,
+        rootNode,
+    })
+        .flatMap((node) => {
+        return findArrayLikeDescendantLines({
+            rootNode: node,
+        });
+    })
+        .toSorted((firstLine, secondLine) => {
+        return firstLine - secondLine;
+    })[0];
+}
+function findAstNodesStartingOnLine({ rootNode, lineNumber, }) {
+    return collectAstNodes({
+        input: rootNode,
+        shouldInclude: (node) => {
+            return node.loc?.start.line === lineNumber;
+        },
+    });
+}
+function findArrayLikeDescendantLines({ rootNode, }) {
+    return collectAstNodes({
+        input: rootNode,
+        shouldInclude: (node) => {
+            return isArrayLikeNode(node) && !!node.loc;
+        },
+        shouldWalkChildren: (node, isRootNode) => {
+            return isRootNode || !descendantBoundaryTypes.includes(node.type);
+        },
+    }).flatMap((node) => {
+        if (!node.loc) {
+            return [];
+        }
+        return [node.loc.start.line];
+    });
+}
+function collectAstNodes({ input, shouldInclude, shouldWalkChildren = () => true, seenInputs = new WeakSet(), isRootNode = true, }) {
+    if (check.isArray(input)) {
+        return input.flatMap((child) => {
+            return collectAstNodes({
+                input: child,
+                isRootNode: false,
+                seenInputs,
+                shouldInclude,
+                shouldWalkChildren,
+            });
+        });
+    }
+    else if (!check.isObject(input)) {
+        return [];
+    }
+    else if (seenInputs.has(input)) {
+        return [];
+    }
+    seenInputs.add(input);
+    if (!isAstNode(input)) {
+        return [];
+    }
+    const matchingNode = shouldInclude(input, isRootNode) ? [input] : [];
+    const childNodes = shouldWalkChildren(input, isRootNode)
+        ? getObjectTypedKeys(input).flatMap((nodeKey) => {
+            if (ignoredAstChildKeys.includes(String(nodeKey))) {
+                return [];
+            }
+            return collectAstNodes({
+                input: Reflect.get(input, nodeKey),
+                isRootNode: false,
+                seenInputs,
+                shouldInclude,
+                shouldWalkChildren,
+            });
+        })
+        : [];
+    return [...matchingNode, ...childNodes];
+}
+function isAstNode(input) {
+    return check.isObject(input) && check.isString(input.type);
+}
+function setResets(internalCommentTriggers) {
+    if (!internalCommentTriggers.resets.length) {
+        return;
+    }
+    const setLineCountLineNumbers = getObjectTypedKeys(internalCommentTriggers.setLineCounts);
+    if (setLineCountLineNumbers.length) {
+        setLineCountLineNumbers.forEach((lineNumber) => {
+            const currentLineNumberStats = internalCommentTriggers.setLineCounts[lineNumber];
+            if (!currentLineNumberStats) {
+                throw new Error(`Line number stats were undefined for "${lineNumber}" in "${JSON.stringify(internalCommentTriggers.setLineCounts)}"`);
+            }
+            const endLineNumber = internalCommentTriggers.resets.find((resetLineNumber) => {
+                return Number(lineNumber) < resetLineNumber;
+            }) ?? currentLineNumberStats.lineEnd;
+            currentLineNumberStats.lineEnd = endLineNumber;
+        });
+    }
+}
+function getWrapThreshold(commentText, nextOnly) {
+    const searchText = nextOnly
+        ? nextWrapThresholdComment
+        : setWrapThresholdComment;
+    const searchRegExp = nextOnly
+        ? untilNextWrapThresholdCommentRegExp
+        : untilSetWrapThresholdCommentRegExp;
+    if (commentText?.toLowerCase().includes(searchText)) {
+        const thresholdValue = Number(commentText.toLowerCase().replace(searchRegExp, "").trim());
+        if (isNaN(thresholdValue)) {
+            return undefined;
+        }
+        else {
+            return thresholdValue;
+        }
+    }
+    else {
+        return undefined;
+    }
+}
+export function parseNextLineCounts({ input, nextOnly, debug, }) {
+    if (!input) {
+        return [];
+    }
+    const searchRegExp = nextOnly
+        ? untilNextLinePatternCommentRegExp
+        : untilSetLinePatternCommentRegExp;
+    const split = input
+        .toLowerCase()
+        .replace(searchRegExp, "")
+        .replace(/,/g, "")
+        .split(" ")
+        .filter((entry) => !!entry);
+    const firstSplit = split[0];
+    if (firstSplit === "[") {
+        split.splice(0, 1);
+    }
+    else if (firstSplit?.startsWith("[")) {
+        split[0] = firstSplit.replace(/^\[/, "");
+    }
+    const lastSplitIndex = split.length - 1;
+    const lastSplit = split[lastSplitIndex];
+    if (lastSplit === "]") {
+        split.splice(split.length - 1, 1);
+    }
+    else if (lastSplit?.endsWith("]")) {
+        split[lastSplitIndex] = lastSplit.replace(/\]$/, "");
+    }
+    const numbers = split.map((entry) => entry && !!entry.trim().match(/^\d+$/) ? Number(entry.trim()) : NaN);
+    const invalidNumbers = numbers
+        .map((entry, index) => {
+        return {
+            index,
+            entry,
+            original: split[index],
+        };
+    })
+        .filter((entry) => {
+        return isNaN(entry.entry);
+    });
+    if (invalidNumbers.length) {
+        if (debug) {
+            console.error(invalidNumbers.map((entry) => {
+                return {
+                    index: entry.index,
+                    original: entry.original,
+                    parsed: entry,
+                    split,
+                    input,
+                    numbers,
+                    trim: entry.original?.trim(),
+                    match: entry.original?.trim().match(/^\d+$/),
+                    matched: !!entry.original?.trim().match(/^\d+$/),
+                };
+            }));
+        }
+        console.error(`Invalid number(s) for elements per line option/comment: ${invalidNumbers
+            .map((entry) => entry.original)
+            .join()}`);
+        return [];
+    }
+    return numbers;
+}
+function isResetComment(commentText) {
+    return !!commentText?.toLowerCase().includes(resetComment);
+}
+function getLineCounts({ commentText, nextOnly, debug, }) {
+    const searchText = nextOnly
+        ? nextLinePatternComment
+        : setLinePatternComment;
+    if (commentText?.toLowerCase().includes(searchText)) {
+        return parseNextLineCounts({
+            input: commentText,
+            nextOnly,
+            debug,
+        });
+    }
+    else {
+        return [];
+    }
+}

package/dist/printer/comments.d.ts

@@ -0,0 +1,2 @@
+import type { Comment } from "estree";
+export declare function extractComments(node: any): Comment[];

package/dist/printer/comments.js

@@ -0,0 +1,34 @@
+const ignoreTheseKeys = ["tokens"];
+const ignoreTheseChildTypes = ["string", "number"];
+const commentTypes = [
+    "Line",
+    "Block",
+    "CommentBlock",
+    "CommentLine",
+];
+function isMaybeComment(input) {
+    return !(!input ||
+        typeof input !== "object" ||
+        !("type" in input) ||
+        !commentTypes.includes(input.type) ||
+        !("value" in input));
+}
+export function extractComments(node) {
+    if (!node || typeof node !== "object") {
+        return [];
+    }
+    const comments = [];
+    if (Array.isArray(node)) {
+        comments.push(...node.filter(isMaybeComment));
+    }
+    Object.keys(node).forEach((nodeKey) => {
+        if (!ignoreTheseKeys.includes(nodeKey)) {
+            const nodeChild = node[nodeKey];
+            if (!ignoreTheseChildTypes.includes(typeof nodeChild)) {
+                comments.push(...extractComments(nodeChild));
+            }
+        }
+    });
+    // this might duplicate comments but our later code doesn't care
+    return comments;
+}

package/dist/printer/insert-new-lines.d.ts

@@ -0,0 +1,15 @@
+import type { AstPath, Doc, ParserOptions } from "prettier";
+import { type MultilineArrayOptions } from "../options.js";
+export declare function insertLinesIntoArray({ inputDoc, manualWrap, lineCounts, wrapThreshold, debug, }: Readonly<{
+    inputDoc: Doc;
+    manualWrap: boolean;
+    lineCounts: number[];
+    wrapThreshold: number;
+    debug: boolean;
+}>): Doc;
+export declare function printWithMultilineArrays({ originalFormattedOutput, path, inputOptions, debug, }: Readonly<{
+    originalFormattedOutput: Doc;
+    path: AstPath;
+    inputOptions: MultilineArrayOptions & ParserOptions;
+    debug: boolean;
+}>): Doc;