@timmo001/oxlint-rules 0.6.2 → 0.6.3

package/README.md

@@ -139,8 +139,9 @@ they only run when the consumer enables `typeAware`.
   a `yield* Gh` binding from `@timmo001/effect-gh`, `Api.raw` from that package,
   and calls that launch gh: `"gh"` followed by its arguments, such as
   `executor.run("gh", ...)`, or an argument array starting with `"gh"` passed
-  to a spawn, exec, run or command function, such as `Bun.spawn(["gh", ...])`. Use the
-  package's typed operations, and add one to effect-gh when a command has none.
+  to a spawn, exec, run or command function, such as `Bun.spawn(["gh", ...])`.
+  Use the package's typed operations, and add one to effect-gh when a command
+  has none.
   effect-gh's own relative imports are not reported.
 - `no-try-catch-in-effect-generators`: diagnoses synchronous `try/catch` owned
   by generators passed directly to `Effect.gen` or the curried `Effect.fn`

package/dist/cli.js

@@ -2172,7 +2172,8 @@ var StatementTypes = {
     ]
   ]))
 };
-function createPaddingLineRule(options) {
+function createPaddingLineRule(options, statementTypes) {
+  const customStatementTypes = statementTypes ?? {};
   return {
     meta: {
       type: "layout",
@@ -2288,7 +2289,7 @@ function createPaddingLineRule(options) {
             return !isSingleLine(innerStatementNode);
           return true;
         } else {
-          const statementType = StatementTypes[type];
+          const statementType = customStatementTypes[type] ?? StatementTypes[type];
           if (statementType === undefined)
             throw new Error(`Padding rule invariant: unsupported statement type ${type}`);
           return statementType.test(innerStatementNode, sourceCode);
@@ -2387,6 +2388,20 @@ function createPaddingLineRule(options) {
 }
 
 // vendor/anti-slop/src/rules/require-readable-spacing.ts
+function isSinglelineBinding(node) {
+  const declaration = node.type === "ExportNamedDeclaration" ? node.declaration : node;
+  return declaration?.type === "VariableDeclaration" && node.loc.start.line === node.loc.end.line;
+}
+function hasLeadingComment(node, sourceCode) {
+  const previousLine = sourceCode.getTokenBefore(node)?.loc.end.line;
+  return sourceCode.getCommentsBefore(node).some((comment) => comment.loc.start.line !== previousLine);
+}
+var singlelineBinding = {
+  test: (node) => isSinglelineBinding(node)
+};
+var undocumentedSinglelineBinding = {
+  test: (node, sourceCode) => isSinglelineBinding(node) && !hasLeadingComment(node, sourceCode)
+};
 var paddingRule = createPaddingLineRule([
   { blankLine: "always", prev: "import", next: "*" },
   { blankLine: "always", prev: "*", next: { selector: "Program > :not(ImportDeclaration)" } },
@@ -2406,6 +2421,7 @@ var paddingRule = createPaddingLineRule([
   { blankLine: "always", prev: "*", next: ["return", "if", "switch", "try", "for", "while", "do"] },
   { blankLine: "always", prev: "block-like", next: "*" },
   { blankLine: "any", prev: "import", next: "import" },
+  { blankLine: "any", prev: "singleline-binding", next: "undocumented-singleline-binding" },
   {
     blankLine: "any",
     prev: {
@@ -2415,7 +2431,10 @@ var paddingRule = createPaddingLineRule([
       selector: ':matches(TSDeclareFunction, FunctionDeclaration, ExportNamedDeclaration[declaration.type="TSDeclareFunction"], ExportNamedDeclaration[declaration.type="FunctionDeclaration"])'
     }
   }
-]);
+], {
+  "singleline-binding": singlelineBinding,
+  "undocumented-singleline-binding": undocumentedSinglelineBinding
+});
 var requireReadableSpacingRule = {
   ...paddingRule,
   meta: {

package/dist/configs/recommended-effect.js

@@ -2669,7 +2669,8 @@ var StatementTypes = {
     ]
   ]))
 };
-function createPaddingLineRule(options) {
+function createPaddingLineRule(options, statementTypes) {
+  const customStatementTypes = statementTypes ?? {};
   return {
     meta: {
       type: "layout",
@@ -2785,7 +2786,7 @@ function createPaddingLineRule(options) {
             return !isSingleLine(innerStatementNode);
           return true;
         } else {
-          const statementType = StatementTypes[type];
+          const statementType = customStatementTypes[type] ?? StatementTypes[type];
           if (statementType === undefined)
             throw new Error(`Padding rule invariant: unsupported statement type ${type}`);
           return statementType.test(innerStatementNode, sourceCode);
@@ -2884,6 +2885,20 @@ function createPaddingLineRule(options) {
 }
 
 // vendor/anti-slop/src/rules/require-readable-spacing.ts
+function isSinglelineBinding(node) {
+  const declaration = node.type === "ExportNamedDeclaration" ? node.declaration : node;
+  return declaration?.type === "VariableDeclaration" && node.loc.start.line === node.loc.end.line;
+}
+function hasLeadingComment(node, sourceCode) {
+  const previousLine = sourceCode.getTokenBefore(node)?.loc.end.line;
+  return sourceCode.getCommentsBefore(node).some((comment) => comment.loc.start.line !== previousLine);
+}
+var singlelineBinding = {
+  test: (node) => isSinglelineBinding(node)
+};
+var undocumentedSinglelineBinding = {
+  test: (node, sourceCode) => isSinglelineBinding(node) && !hasLeadingComment(node, sourceCode)
+};
 var paddingRule = createPaddingLineRule([
   { blankLine: "always", prev: "import", next: "*" },
   { blankLine: "always", prev: "*", next: { selector: "Program > :not(ImportDeclaration)" } },
@@ -2903,6 +2918,7 @@ var paddingRule = createPaddingLineRule([
   { blankLine: "always", prev: "*", next: ["return", "if", "switch", "try", "for", "while", "do"] },
   { blankLine: "always", prev: "block-like", next: "*" },
   { blankLine: "any", prev: "import", next: "import" },
+  { blankLine: "any", prev: "singleline-binding", next: "undocumented-singleline-binding" },
   {
     blankLine: "any",
     prev: {
@@ -2912,7 +2928,10 @@ var paddingRule = createPaddingLineRule([
       selector: ':matches(TSDeclareFunction, FunctionDeclaration, ExportNamedDeclaration[declaration.type="TSDeclareFunction"], ExportNamedDeclaration[declaration.type="FunctionDeclaration"])'
     }
   }
-]);
+], {
+  "singleline-binding": singlelineBinding,
+  "undocumented-singleline-binding": undocumentedSinglelineBinding
+});
 var requireReadableSpacingRule = {
   ...paddingRule,
   meta: {

package/dist/configs/recommended.js

@@ -2167,7 +2167,8 @@ var StatementTypes = {
     ]
   ]))
 };
-function createPaddingLineRule(options) {
+function createPaddingLineRule(options, statementTypes) {
+  const customStatementTypes = statementTypes ?? {};
   return {
     meta: {
       type: "layout",
@@ -2283,7 +2284,7 @@ function createPaddingLineRule(options) {
             return !isSingleLine(innerStatementNode);
           return true;
         } else {
-          const statementType = StatementTypes[type];
+          const statementType = customStatementTypes[type] ?? StatementTypes[type];
           if (statementType === undefined)
             throw new Error(`Padding rule invariant: unsupported statement type ${type}`);
           return statementType.test(innerStatementNode, sourceCode);
@@ -2382,6 +2383,20 @@ function createPaddingLineRule(options) {
 }
 
 // vendor/anti-slop/src/rules/require-readable-spacing.ts
+function isSinglelineBinding(node) {
+  const declaration = node.type === "ExportNamedDeclaration" ? node.declaration : node;
+  return declaration?.type === "VariableDeclaration" && node.loc.start.line === node.loc.end.line;
+}
+function hasLeadingComment(node, sourceCode) {
+  const previousLine = sourceCode.getTokenBefore(node)?.loc.end.line;
+  return sourceCode.getCommentsBefore(node).some((comment) => comment.loc.start.line !== previousLine);
+}
+var singlelineBinding = {
+  test: (node) => isSinglelineBinding(node)
+};
+var undocumentedSinglelineBinding = {
+  test: (node, sourceCode) => isSinglelineBinding(node) && !hasLeadingComment(node, sourceCode)
+};
 var paddingRule = createPaddingLineRule([
   { blankLine: "always", prev: "import", next: "*" },
   { blankLine: "always", prev: "*", next: { selector: "Program > :not(ImportDeclaration)" } },
@@ -2401,6 +2416,7 @@ var paddingRule = createPaddingLineRule([
   { blankLine: "always", prev: "*", next: ["return", "if", "switch", "try", "for", "while", "do"] },
   { blankLine: "always", prev: "block-like", next: "*" },
   { blankLine: "any", prev: "import", next: "import" },
+  { blankLine: "any", prev: "singleline-binding", next: "undocumented-singleline-binding" },
   {
     blankLine: "any",
     prev: {
@@ -2410,7 +2426,10 @@ var paddingRule = createPaddingLineRule([
       selector: ':matches(TSDeclareFunction, FunctionDeclaration, ExportNamedDeclaration[declaration.type="TSDeclareFunction"], ExportNamedDeclaration[declaration.type="FunctionDeclaration"])'
     }
   }
-]);
+], {
+  "singleline-binding": singlelineBinding,
+  "undocumented-singleline-binding": undocumentedSinglelineBinding
+});
 var requireReadableSpacingRule = {
   ...paddingRule,
   meta: {

package/dist/upstream/anti-slop.js

@@ -2162,7 +2162,8 @@ var StatementTypes = {
     ]
   ]))
 };
-function createPaddingLineRule(options) {
+function createPaddingLineRule(options, statementTypes) {
+  const customStatementTypes = statementTypes ?? {};
   return {
     meta: {
       type: "layout",
@@ -2278,7 +2279,7 @@ function createPaddingLineRule(options) {
             return !isSingleLine(innerStatementNode);
           return true;
         } else {
-          const statementType = StatementTypes[type];
+          const statementType = customStatementTypes[type] ?? StatementTypes[type];
           if (statementType === undefined)
             throw new Error(`Padding rule invariant: unsupported statement type ${type}`);
           return statementType.test(innerStatementNode, sourceCode);
@@ -2377,6 +2378,20 @@ function createPaddingLineRule(options) {
 }
 
 // vendor/anti-slop/src/rules/require-readable-spacing.ts
+function isSinglelineBinding(node) {
+  const declaration = node.type === "ExportNamedDeclaration" ? node.declaration : node;
+  return declaration?.type === "VariableDeclaration" && node.loc.start.line === node.loc.end.line;
+}
+function hasLeadingComment(node, sourceCode) {
+  const previousLine = sourceCode.getTokenBefore(node)?.loc.end.line;
+  return sourceCode.getCommentsBefore(node).some((comment) => comment.loc.start.line !== previousLine);
+}
+var singlelineBinding = {
+  test: (node) => isSinglelineBinding(node)
+};
+var undocumentedSinglelineBinding = {
+  test: (node, sourceCode) => isSinglelineBinding(node) && !hasLeadingComment(node, sourceCode)
+};
 var paddingRule = createPaddingLineRule([
   { blankLine: "always", prev: "import", next: "*" },
   { blankLine: "always", prev: "*", next: { selector: "Program > :not(ImportDeclaration)" } },
@@ -2396,6 +2411,7 @@ var paddingRule = createPaddingLineRule([
   { blankLine: "always", prev: "*", next: ["return", "if", "switch", "try", "for", "while", "do"] },
   { blankLine: "always", prev: "block-like", next: "*" },
   { blankLine: "any", prev: "import", next: "import" },
+  { blankLine: "any", prev: "singleline-binding", next: "undocumented-singleline-binding" },
   {
     blankLine: "any",
     prev: {
@@ -2405,7 +2421,10 @@ var paddingRule = createPaddingLineRule([
       selector: ':matches(TSDeclareFunction, FunctionDeclaration, ExportNamedDeclaration[declaration.type="TSDeclareFunction"], ExportNamedDeclaration[declaration.type="FunctionDeclaration"])'
     }
   }
-]);
+], {
+  "singleline-binding": singlelineBinding,
+  "undocumented-singleline-binding": undocumentedSinglelineBinding
+});
 var requireReadableSpacingRule = {
   ...paddingRule,
   meta: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timmo001/oxlint-rules",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Shared Oxlint plugins and configs with optional Effect rules.",
   "type": "module",
   "license": "Apache-2.0",
@@ -49,13 +49,13 @@
     "typecheck": "tsc --noEmit"
   },
   "peerDependencies": {
-    "@oxlint/plugins": "1.87.0",
-    "oxlint": "1.87.0"
+    "@oxlint/plugins": "1.88.0",
+    "oxlint": "1.88.0"
   },
   "devDependencies": {
-    "@oxlint/plugins": "1.87.0",
+    "@oxlint/plugins": "1.88.0",
     "@types/bun": "^1.3.14",
-    "oxlint": "1.87.0",
+    "oxlint": "1.88.0",
     "oxlint-tsgolint": "7.0.2004",
     "prettier": "^3.9.5",
     "skills-ref": "0.1.5",

package/vendor/anti-slop/src/rules/require-readable-spacing.ts

@@ -1,40 +1,73 @@
-import type { CreateRule } from "@oxlint/plugins";
+import type { CreateRule, ESTree, SourceCode } from "@oxlint/plugins";
 
 import createPaddingLineRule from "../vendor/eslint-stylistic/padding-line-between-statements.ts";
 
-const paddingRule = createPaddingLineRule([
-  { blankLine: "always", prev: "import", next: "*" },
-  { blankLine: "always", prev: "*", next: { selector: "Program > :not(ImportDeclaration)" } },
-  { blankLine: "always", prev: { selector: "Program > :not(ImportDeclaration)" }, next: "*" },
-  { blankLine: "always", prev: "*", next: ["function", "class", "interface", "type"] },
-  { blankLine: "always", prev: ["function", "class", "interface", "type"], next: "*" },
-  {
-    blankLine: "always",
-    prev: "*",
-    next: ["multiline-const", "multiline-let", "multiline-var", "multiline-using"],
-  },
-  {
-    blankLine: "always",
-    prev: ["multiline-const", "multiline-let", "multiline-var", "multiline-using"],
-    next: "*",
-  },
-  { blankLine: "always", prev: "*", next: ["return", "if", "switch", "try", "for", "while", "do"] },
-  { blankLine: "always", prev: "block-like", next: "*" },
-  { blankLine: "any", prev: "import", next: "import" },
-  {
-    blankLine: "any",
-    prev: {
-      selector:
-        ':matches(TSDeclareFunction, ExportNamedDeclaration[declaration.type="TSDeclareFunction"])',
+import type { NodeTestObject } from "../vendor/eslint-stylistic/padding-line-between-statements.ts";
+
+/** A `const`/`let`/`var`/`using` declaration, optionally exported, written on one line. */
+function isSinglelineBinding(node: ESTree.Node): boolean {
+  const declaration = node.type === "ExportNamedDeclaration" ? node.declaration : node;
+  return declaration?.type === "VariableDeclaration" && node.loc.start.line === node.loc.end.line;
+}
+
+/** Comments above a statement belong to it; a comment trailing the previous line does not. */
+function hasLeadingComment(node: ESTree.Node, sourceCode: SourceCode): boolean {
+  const previousLine = sourceCode.getTokenBefore(node)?.loc.end.line;
+  return sourceCode
+    .getCommentsBefore(node)
+    .some((comment) => comment.loc.start.line !== previousLine);
+}
+
+const singlelineBinding: NodeTestObject = {
+  test: (node) => isSinglelineBinding(node),
+};
+
+const undocumentedSinglelineBinding: NodeTestObject = {
+  test: (node, sourceCode) => isSinglelineBinding(node) && !hasLeadingComment(node, sourceCode),
+};
+
+const paddingRule = createPaddingLineRule(
+  [
+    { blankLine: "always", prev: "import", next: "*" },
+    { blankLine: "always", prev: "*", next: { selector: "Program > :not(ImportDeclaration)" } },
+    { blankLine: "always", prev: { selector: "Program > :not(ImportDeclaration)" }, next: "*" },
+    { blankLine: "always", prev: "*", next: ["function", "class", "interface", "type"] },
+    { blankLine: "always", prev: ["function", "class", "interface", "type"], next: "*" },
+    {
+      blankLine: "always",
+      prev: "*",
+      next: ["multiline-const", "multiline-let", "multiline-var", "multiline-using"],
+    },
+    {
+      blankLine: "always",
+      prev: ["multiline-const", "multiline-let", "multiline-var", "multiline-using"],
+      next: "*",
     },
-    next: {
-      selector:
-        ':matches(TSDeclareFunction, FunctionDeclaration, ExportNamedDeclaration[declaration.type="TSDeclareFunction"], ExportNamedDeclaration[declaration.type="FunctionDeclaration"])',
+    { blankLine: "always", prev: "*", next: ["return", "if", "switch", "try", "for", "while", "do"] },
+    { blankLine: "always", prev: "block-like", next: "*" },
+    { blankLine: "any", prev: "import", next: "import" },
+    // Consecutive single-line bindings form one group at any scope, including
+    // module scope. A binding with its own leading comment starts a new group.
+    { blankLine: "any", prev: "singleline-binding", next: "undocumented-singleline-binding" },
+    {
+      blankLine: "any",
+      prev: {
+        selector:
+          ':matches(TSDeclareFunction, ExportNamedDeclaration[declaration.type="TSDeclareFunction"])',
+      },
+      next: {
+        selector:
+          ':matches(TSDeclareFunction, FunctionDeclaration, ExportNamedDeclaration[declaration.type="TSDeclareFunction"], ExportNamedDeclaration[declaration.type="FunctionDeclaration"])',
+      },
     },
+  ],
+  {
+    "singleline-binding": singlelineBinding,
+    "undocumented-singleline-binding": undocumentedSinglelineBinding,
   },
-]);
+);
 
-/** Restore structural blank lines with whitespace-only fixes; keep local short bindings and overloads grouped. */
+/** Restore structural blank lines with whitespace-only fixes; keep single-line binding groups and overloads grouped. */
 export const requireReadableSpacingRule: CreateRule = {
   ...paddingRule,
   meta: {

package/vendor/anti-slop/src/vendor/eslint-stylistic/UPSTREAM.md

@@ -15,7 +15,7 @@ The rule is MIT-licensed. Keep `LICENSE` with every redistributed copy, includin
 - Replace upstream type aliases with Oxlint's ESTree, context, token/comment, and rule types. Upstream's token type includes comments; Oxlint exposes those separately.
 - Replace `AST_NODE_TYPES` enum members with identical string literals.
 - Guard indexed reads for consuming repositories with `noUncheckedIndexedAccess`. Impossible missing AST/configuration entries raise explicit invariant errors rather than introducing new non-null assertions.
-- Replace the repository-specific `createRule` factory with `createPaddingLineRule(options)`. The anti-slop wrapper supplies typed options directly; it exposes no user configuration options.
+- Replace the repository-specific `createRule` factory with `createPaddingLineRule(options, statementTypes?)`. The anti-slop wrapper supplies typed options directly; it exposes no user configuration options. The optional second argument registers caller-defined statement types, consulted before the upstream table, so a policy can match syntax the upstream matchers do not distinguish (exported bindings, comment ownership) without editing the vendored tables.
 - Implement the small required AST helper surface in `padding-line-ast.ts` using Oxlint's public source-code/token API. `isParenthesized` only needs the one-pair check used to exclude parenthesized directive strings, not the upstream general-purpose overloads.
 - Retain the upstream statement matchers, scope tracking, comment-aware insertion/removal, selector support, and diagnostic text. Upstream naming and non-null assumptions remain localized here to keep future diffs reviewable; the file is not a model for new application code.
 

package/vendor/anti-slop/src/vendor/eslint-stylistic/padding-line-between-statements.ts

@@ -3,9 +3,9 @@ import type { ESTree, Context as RuleContext, SourceCode, Token as SyntaxToken,
 type ASTNode = ESTree.Node
 type Token = SyntaxToken | Comment
 import type {
-  RuleOptions,
+  PaddingType,
   SelectorOption,
-  StatementOption,
+  StatementMatcher,
 } from './padding-line-options.d.ts'
 import {
   isClosingBraceToken,
@@ -42,17 +42,32 @@ type NodeTest = (
   sourceCode: SourceCode,
 ) => boolean
 
-interface NodeTestObject {
+export interface NodeTestObject {
   test: NodeTest
 }
 
+/**
+ * A policy entry may name a caller-defined statement type (registered through
+ * `createPaddingLineRule`) anywhere the upstream statement types are accepted.
+ */
+export type PolicyStatementOption<Extra extends string = never> =
+  | StatementMatcher
+  | Extra
+  | [StatementMatcher | Extra, ...(StatementMatcher | Extra)[]]
+
+export type PolicyOptions<Extra extends string = never> = {
+  blankLine: PaddingType
+  prev: PolicyStatementOption<Extra>
+  next: PolicyStatementOption<Extra>
+}[]
+
 const LT = `[${Array.from(LINEBREAKS).join('')}]`
 const PADDING_LINE_SEQUENCE = new RegExp(
   String.raw`^(\s*?${LT})\s*${LT}(\s*;?)$`,
   'u',
 )
 
-function isSelectorOption(option: StatementOption): option is SelectorOption {
+function isSelectorOption(option: PolicyStatementOption<string>): option is SelectorOption {
   return typeof option === 'object' && !Array.isArray(option)
 }
 
@@ -589,8 +604,16 @@ const StatementTypes: Record<string, NodeTestObject> = {
   ),
 }
 
-/** Build the vendored padding rule with caller-owned, typed policy options. */
-export default function createPaddingLineRule(options: RuleOptions): CreateRule {
+/**
+ * Build the vendored padding rule with caller-owned, typed policy options.
+ * `statementTypes` registers caller-defined statement types, looked up before
+ * the upstream table, for syntax the upstream matchers do not distinguish.
+ */
+export default function createPaddingLineRule<Extra extends string = never>(
+  options: PolicyOptions<NoInfer<Extra>>,
+  statementTypes?: Record<Extra, NodeTestObject>,
+): CreateRule {
+const customStatementTypes: Partial<Record<string, NodeTestObject>> = statementTypes ?? {}
 return {
   meta: {
     type: 'layout',
@@ -667,7 +690,7 @@ return {
     const selectorMatchedNodes = new Map<string, Set<ASTNode>>()
     const pendingPairs: { prevNode: ASTNode, nextNode: ASTNode }[] = []
 
-    function collectSelectorOption(option: StatementOption): void {
+    function collectSelectorOption(option: PolicyStatementOption<Extra>): void {
       if (Array.isArray(option)) {
         for (const item of option)
           collectSelectorOption(item)
@@ -722,7 +745,7 @@ return {
      * @returns `true` if the statement node matched the type.
      * @private
      */
-    function match(node: ASTNode, type: StatementOption): boolean {
+    function match(node: ASTNode, type: PolicyStatementOption<Extra>): boolean {
       let innerStatementNode = node
 
       while (innerStatementNode.type === 'LabeledStatement')
@@ -746,7 +769,7 @@ return {
         return true
       }
       else {
-        const statementType = StatementTypes[type]
+        const statementType = customStatementTypes[type] ?? StatementTypes[type]
         if (statementType === undefined)
           throw new Error(`Padding rule invariant: unsupported statement type ${type}`)
         return statementType.test(innerStatementNode, sourceCode)