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

package/dist/printer/child-docs.js

@@ -1,88 +1,114 @@
+import { arrayFirst, objectHasIn } from "ts-extras";
+function hasDocChildProperty(input, key) {
+    return objectHasIn(input, key);
+}
+function logWalkVisit({ startDoc, parents, index, }) {
+    const parent = arrayFirst(parents);
+    const parentDoc = parent?.parent;
+    console.info({
+        firingCallbackFor: startDoc,
+        status: "Calling callback",
+        parent: parent
+            ? {
+                isArray: Array.isArray(parentDoc),
+                type: parentDoc && objectHasIn(parentDoc, "type")
+                    ? parentDoc.type
+                    : typeof parentDoc,
+            }
+            : undefined,
+        index,
+    });
+}
+function walkArrayChildren({ arrayDoc, debug, visitDoc, parents, }) {
+    if (debug) {
+        console.info("walking array children");
+    }
+    // Once a child returns false, abort walking this array.
+    arrayDoc.every((innerDoc, childIndex) => walkDoc({
+        startDoc: innerDoc,
+        debug,
+        callback: visitDoc,
+        parents: [
+            {
+                parent: arrayDoc,
+                childIndexInThisParent: childIndex,
+            },
+            ...parents,
+        ],
+        index: childIndex,
+    }));
+}
+function walkDocChildProperty({ startDoc, property, debug, visitDoc, parents, }) {
+    const childDoc = startDoc[property];
+    if (childDoc == undefined) {
+        return true;
+    }
+    if (debug) {
+        console.info(`walking ${property} property`);
+    }
+    return walkDoc({
+        startDoc: childDoc,
+        debug,
+        callback: visitDoc,
+        parents: [
+            {
+                parent: startDoc,
+                childIndexInThisParent: undefined,
+            },
+            ...parents,
+        ],
+        index: undefined,
+    });
+}
 /**
+ * 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 function walkDoc({ startDoc, debug, callback, parents = [], index, }) {
+export function walkDoc({ startDoc, debug, callback: visitDoc, 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,
+        logWalkVisit({
+            startDoc,
+            parents,
             index,
         });
     }
-    if (!callback(startDoc, parents, index)) {
-        // if the callback returns something falsy, don't try to walk its children
+    if (!visitDoc(startDoc, parents, index)) {
+        // If the callback returns something falsy, don't try to walk its children
         return false;
     }
-    else if (typeof startDoc === "string") {
+    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,
-            });
+    if (Array.isArray(startDoc)) {
+        walkArrayChildren({
+            arrayDoc: startDoc,
+            debug,
+            visitDoc,
+            parents,
         });
     }
-    else if ("contents" in startDoc) {
-        if (debug) {
-            console.info("walking contents property");
-        }
-        return walkDoc({
-            startDoc: startDoc.contents,
+    if (hasDocChildProperty(startDoc, "contents")) {
+        return walkDocChildProperty({
+            startDoc,
+            property: "contents",
             debug,
-            callback,
-            parents: [
-                {
-                    parent: startDoc,
-                    childIndexInThisParent: undefined,
-                },
-                ...parents,
-            ],
-            index: undefined,
+            parents,
+            visitDoc,
         });
     }
-    else if ("parts" in startDoc) {
-        if (debug) {
-            console.info("walking parts property");
-        }
-        return walkDoc({
-            startDoc: startDoc.parts,
+    if (hasDocChildProperty(startDoc, "parts")) {
+        return walkDocChildProperty({
+            startDoc,
+            property: "parts",
             debug,
-            callback,
-            parents: [
-                {
-                    parent: startDoc,
-                    childIndexInThisParent: undefined,
-                },
-                ...parents,
-            ],
-            index: undefined,
+            parents,
+            visitDoc,
         });
     }
     return true;

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

@@ -1,7 +1,5 @@
 import type { Node } from "estree";
-type LineNumberDetails<T> = {
-    [lineNumber: string]: T;
-};
+type LineNumberDetails<T> = Record<string, T>;
 export type LineCounts = LineNumberDetails<number[]>;
 export type WrapThresholds = LineNumberDetails<number>;
 export type CommentTriggerWithEnding<T> = {
@@ -10,16 +8,16 @@ export type CommentTriggerWithEnding<T> = {
         lineEnd: number;
     };
 };
-export type CommentTriggers = {
+export interface CommentTriggers {
     nextLineCounts: LineCounts;
-    setLineCounts: CommentTriggerWithEnding<LineCounts>;
     nextWrapThresholds: WrapThresholds;
+    setLineCounts: CommentTriggerWithEnding<LineCounts>;
     setWrapThresholds: CommentTriggerWithEnding<WrapThresholds>;
-};
+}
 export declare function getCommentTriggers(key: Node, debug: boolean): CommentTriggers;
 export declare function parseNextLineCounts({ input, nextOnly, debug, }: Readonly<{
+    debug: boolean;
     input: string;
     nextOnly: boolean;
-    debug: boolean;
 }>): number[];
 export {};

package/dist/printer/comment-triggers.js

@@ -1,10 +1,11 @@
 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 { arrayFirst, arrayJoin, isEmpty, safeCastTo, setHas, stringSplit, } from "ts-extras";
+import { nextLinePatternComment, nextWrapThresholdComment, resetComment, setLinePatternComment, setWrapThresholdComment, stripTextUntilCommentTrigger, } from "../options.js";
 import { extractComments } from "./comments.js";
 import { isArrayLikeNode } from "./supported-node-types.js";
 const mappedCommentTriggers = new WeakMap();
-const ignoredAstChildKeys = [
+const ignoredAstChildKeys = new Set([
     "comments",
     "leadingComments",
     "loc",
@@ -13,14 +14,14 @@ const ignoredAstChildKeys = [
     "tokens",
     "trailingComments",
     "value",
-];
-const descendantBoundaryTypes = [
+]);
+const descendantBoundaryTypes = new Set([
     "ArrowFunctionExpression",
     "ClassDeclaration",
     "ClassExpression",
     "FunctionDeclaration",
     "FunctionExpression",
-];
+]);
 export function getCommentTriggers(key, debug) {
     const alreadyExisting = mappedCommentTriggers.get(key);
     if (!alreadyExisting) {
@@ -29,7 +30,7 @@ export function getCommentTriggers(key, debug) {
     return alreadyExisting;
 }
 function setCommentTriggers(rootNode, debug) {
-    // parse comments only on the root node so it only happens once
+    // Parse comments only on the root node so it only happens once
     const comments = extractComments(rootNode);
     if (debug) {
         console.info({
@@ -43,8 +44,9 @@ function setCommentTriggers(rootNode, debug) {
         setWrapThresholds: {},
         resets: [],
     };
-    const internalCommentTriggers = comments.reduce((accum, currentComment) => {
-        const commentText = currentComment.value?.replace(/\n/g, " ");
+    const internalCommentTriggers = starterTriggers;
+    for (const currentComment of comments) {
+        const commentText = safeCastTo(currentComment.value)?.replaceAll("\n", " ");
         if (!currentComment.loc) {
             throw new Error(`Cannot read line location for comment ${currentComment.value}`);
         }
@@ -53,40 +55,38 @@ function setCommentTriggers(rootNode, debug) {
             nextOnly: true,
             debug,
         });
-        if (nextLineCounts.length) {
-            accum.nextLineCounts[currentComment.loc.end.line] =
-                nextLineCounts;
+        if (nextLineCounts.length > 0) {
+            internalCommentTriggers.nextLineCounts[currentComment.loc.end.line] = nextLineCounts;
         }
         const nextWrapThreshold = getWrapThreshold(commentText, true);
         if (nextWrapThreshold != undefined) {
-            accum.nextWrapThresholds[currentComment.loc.end.line] =
-                nextWrapThreshold;
+            internalCommentTriggers.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,
-            };
+        if (setLineCounts.length > 0) {
+            internalCommentTriggers.setLineCounts[currentComment.loc.end.line] =
+                {
+                    data: setLineCounts,
+                    lineEnd: Infinity,
+                };
         }
         const setWrapThreshold = getWrapThreshold(commentText, false);
         if (setWrapThreshold != undefined) {
-            accum.setWrapThresholds[currentComment.loc.end.line] = {
+            internalCommentTriggers.setWrapThresholds[currentComment.loc.end.line] = {
                 data: setWrapThreshold,
                 lineEnd: Infinity,
             };
         }
-        const resetComment = isResetComment(commentText);
-        if (resetComment) {
-            accum.resets.push(currentComment.loc.end.line);
+        const shouldReset = isResetComment(commentText);
+        if (shouldReset) {
+            internalCommentTriggers.resets.push(currentComment.loc.end.line);
         }
-        return accum;
-    }, starterTriggers);
-    internalCommentTriggers.resets.sort();
+    }
+    internalCommentTriggers.resets.sort((firstLine, secondLine) => firstLine - secondLine);
     setResets(internalCommentTriggers);
     mapNextCommentTriggers({
         internalCommentTriggers,
@@ -95,8 +95,8 @@ function setCommentTriggers(rootNode, debug) {
     const commentTriggers = {
         ...internalCommentTriggers,
     };
-    delete commentTriggers.resets;
-    // save to a map so we don't have to recalculate these every time
+    delete safeCastTo(commentTriggers).resets;
+    // Save to a map so we don't have to recalculate these every time
     mappedCommentTriggers.set(rootNode, commentTriggers);
     return commentTriggers;
 }
@@ -111,52 +111,41 @@ function mapNextCommentTriggers({ internalCommentTriggers, rootNode, }) {
     });
 }
 function mapNextLineTriggers({ rootNode, triggers, }) {
-    return getObjectTypedKeys(triggers).reduce((mappedTriggers, triggerLineNumber) => {
+    const mappedTriggers = {};
+    for (const triggerLineNumber of getObjectTypedKeys(triggers)) {
         const trigger = triggers[triggerLineNumber];
         const targetLineNumber = findArrayLikeTargetLine({
             nextLineNumber: Number(triggerLineNumber) + 1,
             rootNode,
         });
-        if (targetLineNumber == undefined || trigger == undefined) {
-            return mappedTriggers;
+        if (targetLineNumber != undefined && trigger != undefined) {
+            mappedTriggers[targetLineNumber] = trigger;
         }
-        return {
-            ...mappedTriggers,
-            [targetLineNumber]: trigger,
-        };
-    }, {});
+    }
+    return mappedTriggers;
 }
 function findArrayLikeTargetLine({ rootNode, nextLineNumber, }) {
-    return findAstNodesStartingOnLine({
+    const descendantLines = findAstNodesStartingOnLine({
         lineNumber: nextLineNumber,
         rootNode,
-    })
-        .flatMap((node) => {
-        return findArrayLikeDescendantLines({
-            rootNode: node,
-        });
-    })
-        .toSorted((firstLine, secondLine) => {
-        return firstLine - secondLine;
-    })[0];
+    }).flatMap((node) => findArrayLikeDescendantLines({
+        rootNode: node,
+    }));
+    return descendantLines.length > 0
+        ? Math.min(...descendantLines)
+        : undefined;
 }
 function findAstNodesStartingOnLine({ rootNode, lineNumber, }) {
     return collectAstNodes({
         input: rootNode,
-        shouldInclude: (node) => {
-            return node.loc?.start.line === lineNumber;
-        },
+        shouldInclude: (node) => 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);
-        },
+        shouldInclude: (node) => isArrayLikeNode(node) && Boolean(node.loc),
+        shouldWalkChildren: (node, isRootNode) => isRootNode || !setHas(descendantBoundaryTypes, node.type),
     }).flatMap((node) => {
         if (!node.loc) {
             return [];
@@ -166,20 +155,15 @@ function findArrayLikeDescendantLines({ rootNode, }) {
 }
 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 [];
+        return input.flatMap((child) => collectAstNodes({
+            input: child,
+            isRootNode: false,
+            seenInputs,
+            shouldInclude,
+            shouldWalkChildren,
+        }));
     }
-    else if (seenInputs.has(input)) {
+    if (!check.isObject(input) || seenInputs.has(input)) {
         return [];
     }
     seenInputs.add(input);
@@ -189,7 +173,7 @@ function collectAstNodes({ input, shouldInclude, shouldWalkChildren = () => true
     const matchingNode = shouldInclude(input, isRootNode) ? [input] : [];
     const childNodes = shouldWalkChildren(input, isRootNode)
         ? getObjectTypedKeys(input).flatMap((nodeKey) => {
-            if (ignoredAstChildKeys.includes(String(nodeKey))) {
+            if (setHas(ignoredAstChildKeys, String(nodeKey))) {
                 return [];
             }
             return collectAstNodes({
@@ -206,109 +190,97 @@ function collectAstNodes({ input, shouldInclude, shouldWalkChildren = () => true
 function isAstNode(input) {
     return check.isObject(input) && check.isString(input.type);
 }
+function isIntegerString(entry) {
+    if (entry.length === 0) {
+        return false;
+    }
+    for (const character of entry) {
+        if (character < "0" || character > "9") {
+            return false;
+        }
+    }
+    return true;
+}
 function setResets(internalCommentTriggers) {
-    if (!internalCommentTriggers.resets.length) {
+    if (isEmpty(internalCommentTriggers.resets)) {
         return;
     }
     const setLineCountLineNumbers = getObjectTypedKeys(internalCommentTriggers.setLineCounts);
-    if (setLineCountLineNumbers.length) {
-        setLineCountLineNumbers.forEach((lineNumber) => {
+    if (setLineCountLineNumbers.length > 0) {
+        for (const lineNumber of setLineCountLineNumbers) {
             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;
+            const endLineNumber = internalCommentTriggers.resets.find((resetLineNumber) => 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)) {
+        const thresholdValue = Number(stripTextUntilCommentTrigger(commentText.toLowerCase(), searchText).trim());
+        if (Number.isNaN(thresholdValue)) {
             return undefined;
         }
-        else {
-            return thresholdValue;
-        }
-    }
-    else {
-        return undefined;
+        return thresholdValue;
     }
+    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];
+    const searchText = nextOnly
+        ? nextLinePatternComment
+        : setLinePatternComment;
+    let split = stringSplit(stripTextUntilCommentTrigger(input.toLowerCase(), searchText).replaceAll(",", ""), " ").filter(Boolean);
+    const firstSplit = arrayFirst(split);
     if (firstSplit === "[") {
-        split.splice(0, 1);
+        split = split.slice(1);
     }
     else if (firstSplit?.startsWith("[")) {
-        split[0] = firstSplit.replace(/^\[/, "");
+        split[0] = firstSplit.slice(1);
     }
-    const lastSplitIndex = split.length - 1;
-    const lastSplit = split[lastSplitIndex];
+    const [lastSplit] = split.toReversed();
     if (lastSplit === "]") {
-        split.splice(split.length - 1, 1);
+        split = split.slice(0, -1);
     }
     else if (lastSplit?.endsWith("]")) {
-        split[lastSplitIndex] = lastSplit.replace(/\]$/, "");
+        const lastSplitIndex = split.length - 1;
+        split[lastSplitIndex] = lastSplit.slice(0, -1);
     }
-    const numbers = split.map((entry) => entry && !!entry.trim().match(/^\d+$/) ? Number(entry.trim()) : NaN);
+    const numbers = split.map((entry) => isIntegerString(entry.trim()) ? Number(entry.trim()) : Number.NaN);
     const invalidNumbers = numbers
-        .map((entry, index) => {
-        return {
-            index,
-            entry,
-            original: split[index],
-        };
-    })
-        .filter((entry) => {
-        return isNaN(entry.entry);
-    });
-    if (invalidNumbers.length) {
+        .map((entry, index) => ({
+        index,
+        entry,
+        original: split[index],
+    }))
+        .filter((entry) => Number.isNaN(entry.entry));
+    if (invalidNumbers.length > 0) {
         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(invalidNumbers.map((entry) => ({
+                index: entry.index,
+                original: entry.original,
+                parsed: entry,
+                split,
+                input,
+                numbers,
+                trim: entry.original?.trim(),
+                matched: isIntegerString(entry.original?.trim() ?? ""),
+            })));
         }
-        console.error(`Invalid number(s) for elements per line option/comment: ${invalidNumbers
-            .map((entry) => entry.original)
-            .join()}`);
+        console.error(`Invalid number(s) for elements per line option/comment: ${arrayJoin(invalidNumbers.map((entry) => entry.original), ",")}`);
         return [];
     }
     return numbers;
 }
 function isResetComment(commentText) {
-    return !!commentText?.toLowerCase().includes(resetComment);
+    return Boolean(commentText?.toLowerCase().includes(resetComment));
 }
 function getLineCounts({ commentText, nextOnly, debug, }) {
     const searchText = nextOnly
@@ -321,7 +293,5 @@ function getLineCounts({ commentText, nextOnly, debug, }) {
             debug,
         });
     }
-    else {
-        return [];
-    }
+    return [];
 }

package/dist/printer/comments.d.ts

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

package/dist/printer/comments.js

@@ -1,17 +1,16 @@
-const ignoreTheseKeys = ["tokens"];
-const ignoreTheseChildTypes = ["string", "number"];
+import { arrayIncludes, objectEntries, objectHasIn } from "ts-extras";
 const commentTypes = [
-    "Line",
     "Block",
     "CommentBlock",
     "CommentLine",
+    "Line",
 ];
 function isMaybeComment(input) {
-    return !(!input ||
-        typeof input !== "object" ||
-        !("type" in input) ||
-        !commentTypes.includes(input.type) ||
-        !("value" in input));
+    return Boolean(input &&
+        typeof input === "object" &&
+        objectHasIn(input, "type") &&
+        arrayIncludes(commentTypes, input.type) &&
+        objectHasIn(input, "value"));
 }
 export function extractComments(node) {
     if (!node || typeof node !== "object") {
@@ -21,14 +20,14 @@ export function extractComments(node) {
     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));
-            }
+    for (const [nodeKey, nodeChild] of objectEntries(node)) {
+        if (nodeKey === "tokens") {
+            continue;
         }
-    });
-    // this might duplicate comments but our later code doesn't care
+        if (typeof nodeChild !== "number" && typeof nodeChild !== "string") {
+            comments.push(...extractComments(nodeChild));
+        }
+    }
+    // This might duplicate comments but our later code doesn't care
     return comments;
 }