@d3lm/lint-preset 1.6.1 → 1.6.3

package/dist/comments.d.cts

@@ -2,11 +2,12 @@ type StyleIssueType = 'semicolon' | 'em-dash' | 'dash' | 'label-colon' | 'emphas
 
 interface WrapOptions {
     /**
-     * Sets whether a line may not end with the first word of a sentence, clause, or parenthetical,
-     * like `This`, `the` after a comma, or `(the`. Such a word moves to the next line instead.
-     * It also sets whether a line avoids ending with the first two words of a sentence, and whether
-     * the first of two lines ends with a sentence instead of the start of the next one, as long as
-     * the second line is then no longer than the first.
+     * Sets whether a line may not end with the first word of a sentence or parenthetical, like
+     * `This` or `(the`, or with the first word after a semicolon or colon. Such a word moves to
+     * the next line instead. The word after a comma may end a line. It also sets whether a line
+     * avoids ending with the first two words of a sentence, and whether the first of two lines
+     * ends with a sentence instead of the start of the next one, as long as the second line is
+     * then no longer than the first.
      */
     readonly avoidSentenceOrphans: boolean;
     /**
@@ -19,7 +20,7 @@ interface WrapOptions {
      */
     readonly parentheticalOverflow?: number;
 }
-type LineIssueType = 'overflow' | 'underfill' | 'orphan' | 'widow' | 'unbalanced' | 'split-parenthetical';
+type LineIssueType = 'overflow' | 'underfill' | 'orphan' | 'widow' | 'unbalanced' | 'wide' | 'split-parenthetical';
 /**
  * Splits text into words. JSDoc writes types and `{@link ...}` tags as `{...}` groups, so they stay
  * intact like code spans.
@@ -54,9 +55,9 @@ interface AnalyzeOptions extends WrapOptions {
      */
     readonly maxWidth?: number;
     /**
-     * Sets the maximum length of the line that holds a comment whose whole text is one
-     * prose paragraph. Such a comment stays on one line up to this length plus `tolerance`,
-     * even past `width`, but never past `maxWidth`. It defaults to `width`.
+     * Sets the maximum length of the line that holds a comment whose whole text is one prose
+     * paragraph. Such a comment stays on one line up to this length plus `tolerance`, even past
+     * `width`, but never past `maxWidth`. It defaults to `width`.
      */
     readonly singleLineWidth?: number;
     readonly tabWidth: number;
@@ -228,26 +229,28 @@ interface CommentsConfig {
      * Sets the maximum length of the line that holds a comment whose whole text is one prose
      * paragraph. Such a comment stays on one line up to this length plus `tolerance`, even past
      * `width`, and is wrapped to `width` beyond it. Defaults to 120, and the line never exceeds
-     * `maxWidth`.
+     * the `maxWidth` limit.
      */
     readonly singleLineWidth?: number;
     /**
      * Sets how many columns prose lines may go past `width` when that saves a line in a paragraph
-     * of three or more lines. A paragraph that already has the layout for a wider `width`, up to
-     * `width` plus this many columns, also passes as it is. So does a paragraph with as many lines
-     * as the rewrap whose lines are each at most this many columns shorter or longer than in the
-     * rewrap. It never goes past `maxWidth`. When `maxWidth` is omitted, it also sets a legacy hard
-     * limit of `width + tolerance`.
+     * of three or more lines. A paragraph that already has the layout for a wider `width`, up
+     * to `width` plus this many columns, also passes as it is. So does a paragraph with as many
+     * lines as the rewrap whose lines, the last aside, are at most this many columns shorter
+     * than the shortest of them in the rewrap, and end at most this many columns past `width`.
+     * It never goes past `maxWidth`. When `maxWidth` is omitted, it also sets a legacy hard limit
+     * of `width + tolerance` columns.
      */
     readonly tolerance?: number;
     /**
      * Keep the first word of a new sentence or parenthetical off the end of a line, e.g.
-     * `...the module. This` or `...reflows (the` followed by the rest on the next line.
-     * A paragraph of two lines also ends its first line with a sentence when the rest fits
-     * on the second line and is no longer than the first, instead of with the start of
-     * the next sentence, like `...the module. This one`. Other lines avoid ending with the
-     * first two words of a sentence, like `...opens. It allocates`, unless that makes them
-     * much less even. Defaults to `true`.
+     * `...the module. This` or `...reflows (the` followed by the rest on the next line. The same
+     * goes for the first word after a semicolon or colon, but not after a comma, so a line may
+     * end with `...the paths, and`. A paragraph of two lines also ends its first line with a
+     * sentence when the rest fits on the second line and is no longer than the first, instead
+     * of with the start of the next sentence, like `...the module. This one`. Other lines avoid
+     * ending with the first two words of a sentence, like `...opens. It allocates`, unless that
+     * makes them much less even. Defaults to `true`.
      */
     readonly avoidSentenceOrphans?: boolean;
     /**

package/dist/comments.d.ts

@@ -2,11 +2,12 @@ type StyleIssueType = 'semicolon' | 'em-dash' | 'dash' | 'label-colon' | 'emphas
 
 interface WrapOptions {
     /**
-     * Sets whether a line may not end with the first word of a sentence, clause, or parenthetical,
-     * like `This`, `the` after a comma, or `(the`. Such a word moves to the next line instead.
-     * It also sets whether a line avoids ending with the first two words of a sentence, and whether
-     * the first of two lines ends with a sentence instead of the start of the next one, as long as
-     * the second line is then no longer than the first.
+     * Sets whether a line may not end with the first word of a sentence or parenthetical, like
+     * `This` or `(the`, or with the first word after a semicolon or colon. Such a word moves to
+     * the next line instead. The word after a comma may end a line. It also sets whether a line
+     * avoids ending with the first two words of a sentence, and whether the first of two lines
+     * ends with a sentence instead of the start of the next one, as long as the second line is
+     * then no longer than the first.
      */
     readonly avoidSentenceOrphans: boolean;
     /**
@@ -19,7 +20,7 @@ interface WrapOptions {
      */
     readonly parentheticalOverflow?: number;
 }
-type LineIssueType = 'overflow' | 'underfill' | 'orphan' | 'widow' | 'unbalanced' | 'split-parenthetical';
+type LineIssueType = 'overflow' | 'underfill' | 'orphan' | 'widow' | 'unbalanced' | 'wide' | 'split-parenthetical';
 /**
  * Splits text into words. JSDoc writes types and `{@link ...}` tags as `{...}` groups, so they stay
  * intact like code spans.
@@ -54,9 +55,9 @@ interface AnalyzeOptions extends WrapOptions {
      */
     readonly maxWidth?: number;
     /**
-     * Sets the maximum length of the line that holds a comment whose whole text is one
-     * prose paragraph. Such a comment stays on one line up to this length plus `tolerance`,
-     * even past `width`, but never past `maxWidth`. It defaults to `width`.
+     * Sets the maximum length of the line that holds a comment whose whole text is one prose
+     * paragraph. Such a comment stays on one line up to this length plus `tolerance`, even past
+     * `width`, but never past `maxWidth`. It defaults to `width`.
      */
     readonly singleLineWidth?: number;
     readonly tabWidth: number;
@@ -228,26 +229,28 @@ interface CommentsConfig {
      * Sets the maximum length of the line that holds a comment whose whole text is one prose
      * paragraph. Such a comment stays on one line up to this length plus `tolerance`, even past
      * `width`, and is wrapped to `width` beyond it. Defaults to 120, and the line never exceeds
-     * `maxWidth`.
+     * the `maxWidth` limit.
      */
     readonly singleLineWidth?: number;
     /**
      * Sets how many columns prose lines may go past `width` when that saves a line in a paragraph
-     * of three or more lines. A paragraph that already has the layout for a wider `width`, up to
-     * `width` plus this many columns, also passes as it is. So does a paragraph with as many lines
-     * as the rewrap whose lines are each at most this many columns shorter or longer than in the
-     * rewrap. It never goes past `maxWidth`. When `maxWidth` is omitted, it also sets a legacy hard
-     * limit of `width + tolerance`.
+     * of three or more lines. A paragraph that already has the layout for a wider `width`, up
+     * to `width` plus this many columns, also passes as it is. So does a paragraph with as many
+     * lines as the rewrap whose lines, the last aside, are at most this many columns shorter
+     * than the shortest of them in the rewrap, and end at most this many columns past `width`.
+     * It never goes past `maxWidth`. When `maxWidth` is omitted, it also sets a legacy hard limit
+     * of `width + tolerance` columns.
      */
     readonly tolerance?: number;
     /**
      * Keep the first word of a new sentence or parenthetical off the end of a line, e.g.
-     * `...the module. This` or `...reflows (the` followed by the rest on the next line.
-     * A paragraph of two lines also ends its first line with a sentence when the rest fits
-     * on the second line and is no longer than the first, instead of with the start of
-     * the next sentence, like `...the module. This one`. Other lines avoid ending with the
-     * first two words of a sentence, like `...opens. It allocates`, unless that makes them
-     * much less even. Defaults to `true`.
+     * `...the module. This` or `...reflows (the` followed by the rest on the next line. The same
+     * goes for the first word after a semicolon or colon, but not after a comma, so a line may
+     * end with `...the paths, and`. A paragraph of two lines also ends its first line with a
+     * sentence when the rest fits on the second line and is no longer than the first, instead
+     * of with the start of the next sentence, like `...the module. This one`. Other lines avoid
+     * ending with the first two words of a sentence, like `...opens. It allocates`, unless that
+     * makes them much less even. Defaults to `true`.
      */
     readonly avoidSentenceOrphans?: boolean;
     /**

package/dist/comments.js

@@ -128,6 +128,7 @@ function findStyleIssues(lines) {
 // src/comments/wrap.ts
 var CLAUSE_END = /[.!?,;:]["')\]*_]*$/;
 var SENTENCE_END = /[.!?]["')\]*_]*$/;
+var STATEMENT_END = /[.!?;:]["')\]*_]*$/;
 var ABBREVIATIONS = /* @__PURE__ */ new Set([
   "e.g.",
   "i.e.",
@@ -359,8 +360,8 @@ function bindParentheticals(tokens, limit) {
   }
   return units;
 }
-function endsClause(token) {
-  return CLAUSE_END.test(token) && !isAbbreviation(token);
+function endsStatement(token) {
+  return STATEMENT_END.test(token) && !isAbbreviation(token);
 }
 function endsSentence(token) {
   return SENTENCE_END.test(token) && !isAbbreviation(token);
@@ -369,7 +370,7 @@ function opensAside(token) {
   return /^[([]/.test(token) && !/[)\]]["'`.,;:!?]*$/.test(token);
 }
 function isOrphan(previous, token) {
-  return opensAside(token) || endsClause(previous) && !CLAUSE_END.test(token);
+  return opensAside(token) || endsStatement(previous) && !CLAUSE_END.test(token);
 }
 function startsBlock(token) {
   return /^(?:\+|-+|=+|\*+|_{3,}|\d+[.)]|#{1,6})$/.test(token) || /^(?:>|@[A-Za-z]|`{3}|~{3}|\||<(?:\/?[A-Za-z]|[!?]))/.test(token);
@@ -770,6 +771,7 @@ var ISSUE_TIERS = {
   underfill: "verdict",
   widow: "verdict",
   unbalanced: "verdict",
+  wide: "verdict",
   orphan: "hint",
   "split-parenthetical": "hint",
   banner: "hint",
@@ -1356,6 +1358,14 @@ function analyzeParagraph(paragraph, options, language) {
       const restLines = layoutTokens(rest, restLimit, restLimit, restOptions);
       return sameLayout(breakAfterSentence(restLines, restLimit, restLimit, restOptions), currentLines.slice(line + 1));
     };
+    const differenceAt = (line) => {
+      const longest = Math.max(...wrapped.map((words) => words.join(" ").length));
+      const wide = currentLines.flatMap((words, position) => {
+        const limit = (position === 0 ? firstLimit : restLimit) + layoutOptions.tolerance;
+        return words.join(" ").length > Math.max(limit, longest) ? [{ type: "wide", line: position }] : [];
+      });
+      return wide.length > 0 ? wide : [{ type: "unbalanced", line }];
+    };
     if (overflow.length === 0 && (currentLines.length === wrapped.length || options.maxWidth !== void 0)) {
       const line = Math.max(
         wrapped.findIndex((words, position) => words.join(" ") !== currentLines[position]?.join(" ")),
@@ -1364,9 +1374,11 @@ function analyzeParagraph(paragraph, options, language) {
       if (lineIssues.length === 0 && (sameLayout(even, currentLines) || keepsOnlySentenceStarts())) {
         lineIssues.push({ type: "orphan", line });
       } else if (lineIssues.length === 0) {
-        lineIssues.push({ type: splitsOnlyParenthetical(line) ? "split-parenthetical" : "unbalanced", line });
+        lineIssues.push(
+          ...splitsOnlyParenthetical(line) ? [{ type: "split-parenthetical", line }] : differenceAt(line)
+        );
       } else if (lineIssues.every((issue) => issue.type === "orphan") && !sameLayout(even, currentLines) && !keepsOnlyOrphans()) {
-        lineIssues.push({ type: "unbalanced", line });
+        lineIssues.push(...differenceAt(line));
       }
     }
     const splitLine = splitTokenLine(currentLines, tokens);
@@ -1384,14 +1396,15 @@ function analyzeParagraph(paragraph, options, language) {
     return false;
   };
   const staysNearLayout = () => {
-    if (currentLines.length !== wrapped.length || splitTokenLine(currentLines, units) !== -1) {
+    if (layoutOptions.tolerance === 0 || currentLines.length !== wrapped.length || splitTokenLine(currentLines, units) !== -1) {
       return false;
     }
+    const shortest = Math.min(...wrapped.slice(0, -1).map((words) => words.join(" ").length));
     return currentLines.every((words, position) => {
       const length = words.join(" ").length;
-      const suggestedLength = wrapped[position].join(" ").length;
       const limit = (position === 0 ? firstLimit : restLimit) + layoutOptions.tolerance;
-      return Math.abs(length - suggestedLength) <= layoutOptions.tolerance && length <= Math.max(suggestedLength, limit);
+      const isLast = position === currentLines.length - 1;
+      return (isLast || length >= shortest - layoutOptions.tolerance) && length <= Math.max(wrapped[position].join(" ").length, limit);
     });
   };
   const hasVerdict = lineIssues.some((issue) => isVerdict(issue));
@@ -1743,7 +1756,7 @@ When rules pull in different directions, the earlier one wins.
 ## Layout
 
 - After you finish, the tool rewraps prose paragraphs, list items, and JSDoc tag descriptions. The width is a preferred target. A parenthetical may extend a line up to the configured maximum so it stays together, and lines may go up to the configured tolerance past the width when that saves a line. In longer paragraphs, balanced lines take priority over keeping every parenthetical on one line. The tool also avoids short last lines where possible. Leave these line breaks to the tool, except for the sentence-orphan case below.
-- Don't end a line with the first word of a new sentence, clause, or parenthetical, like \`This\` after a period, \`the\` after a comma, or \`(the\`. Move it to the next line instead. The same goes for the first two words of a sentence, like \`It allocates\` after a period, when the note points at them. A long word, like an identifier or a code span, may stay at the end of a line when moving it would leave that line far shorter than the lines around it. Then leave the line breaks as they are.
+- Don't end a line with the first word of a new sentence or parenthetical, like \`This\` after a period or \`(the\`, or with the first word after a semicolon or colon. Move it to the next line instead. The same goes for the first two words of a sentence, like \`It allocates\` after a period, when the note points at them. A long word, like an identifier or a code span, may stay at the end of a line when moving it would leave that line far shorter than the lines around it. Then leave the line breaks as they are. The word after a comma is no such word. A line may end with it, like \`and\` in \`...the teardown paths, and\`.
 - In a paragraph of two lines, the first line ends with a sentence whenever the rest fits on the second line and is no longer than the first. Don't end it with the start of the next sentence, like \`A wrap\` in \`...lay out differently. A wrap\`. Move those words to the second line instead.
 - A comment whose whole text is one paragraph stays on a single line when that line fits a separate, larger single-line width, even past the width. Only a longer comment wraps to the width.
 - Separate paragraphs with an empty comment line.