@zgeoff/format-codemod 0.0.2 → 0.0.4

package/README.md

@@ -19,11 +19,18 @@ no "never" rules.
 - after a `function` or `class` declaration
 - on both sides of a control-flow block: `if`, `for`, `for…in`, `for…of`, `while`, `switch`, `try`
 - on both sides of any statement that spans multiple lines
-- at the boundary between statement kinds — a `const`/`let`/`var` declaration, a call statement, an
-  assignment/increment statement — in any order; runs of one kind stay tight
+- at the boundary between statement kinds — a `const`/`let`/`var` declaration, a
+  `using`/`await using` declaration, a call statement, an assignment/increment statement — in any
+  order; runs of one kind stay tight
+- after a `using`/`await using` block, before any statement of another kind
 - at the boundary between an instantiation-headed statement (`new` at the head of its expression
   chain, as in `new X(…)` or `new X(…).method()`) and any other statement kind — `new` in argument
   position doesn't count, and runs of instantiations stay glued
+- at the boundary between an awaited and a non-awaited statement — awaited means an `await using`
+  declaration, or an `await` in the head of the statement's value chain (`await f()`,
+  `const x = await f()`, `x = (await f()).prop`); an `await` in argument position (`use(await f())`)
+  or under a non-chain head (`flag ? await f() : g()`) doesn't count, and runs of awaited statements
+  stay glued
 
 **`@stylistic/lines-between-class-members`** — one blank line between class members.
 
@@ -32,8 +39,10 @@ no "never" rules.
 - **Consecutive single-line `const`/`let`/`var` declarations stay glued** (no blank between them); a
   multiline declaration is separated like any other multiline statement.
 - **Bare declarations only.** `export const`, `export function`, and `export class` are not matched
-  — ESLint's selectors do not look through `export`, and neither does this. `await using` is
-  likewise not a var declaration.
+  — ESLint's selectors do not look through `export`, and neither does this. `using`/`await using`
+  declarations are not var declarations; they form their own statement kind.
+- **The `using` and awaited-boundary rules go beyond ESLint** — `padding-line-between-statements`
+  cannot express either, so on these the codemod is the spec.
 - **`.d.ts` files are skipped.**
 
 ## CLI

package/dist/cli.js

@@ -53,7 +53,7 @@ function isIgnored(file, patterns) {
 import { parseArgs } from "node:util";
 function parseCLIArgs(argv) {
   try {
-    const { values, positionals } = parseArgs({
+    const parsed = parseArgs({
       args: [...argv],
       options: {
         check: { type: "boolean", default: false },
@@ -68,13 +68,13 @@ function parseCLIArgs(argv) {
       strict: true
     });
     return {
-      mode: pickMode(values.check, values.dry),
-      quiet: values.quiet,
-      bench: values.bench,
-      help: values.help,
-      version: values.version,
-      ignore: values.ignore,
-      inputs: positionals
+      mode: pickMode(parsed.values.check, parsed.values.dry),
+      quiet: parsed.values.quiet,
+      bench: parsed.values.bench,
+      help: parsed.values.help,
+      version: parsed.values.version,
+      ignore: parsed.values.ignore,
+      inputs: parsed.positionals
     };
   } catch (error) {
     return error instanceof Error ? error.message : String(error);
@@ -190,6 +190,128 @@ function collectChildNodes(node) {
   return children;
 }
 
+// src/transform/needs-blank-line.ts
+var CONTROL_FLOW_TYPES = new Set([
+  "IfStatement",
+  "ForStatement",
+  "ForInStatement",
+  "ForOfStatement",
+  "WhileStatement",
+  "SwitchStatement",
+  "TryStatement"
+]);
+function needsBlankLine(container, prev, next) {
+  if (container.type === "ClassBody") {
+    return true;
+  }
+  if (isVarDecl(prev) && !isVarDecl(next) || isUsingDecl(prev) && !isUsingDecl(next)) {
+    return true;
+  }
+  if (next.type === "ReturnStatement") {
+    return true;
+  }
+  if (isFnOrClassDecl(prev)) {
+    return true;
+  }
+  return isNewHeaded(prev) !== isNewHeaded(next) || isAwaitHeaded(prev) !== isAwaitHeaded(next) || isKindBoundary(prev, next) || CONTROL_FLOW_TYPES.has(next.type) || CONTROL_FLOW_TYPES.has(prev.type);
+}
+function isNewHeaded(node) {
+  return getStatementValues(node).some((value) => getExpressionHead(value).type === "NewExpression");
+}
+function getStatementValues(node) {
+  if (node.type === "VariableDeclaration") {
+    return collectASTNodes(node["declarations"]).map((declarator) => declarator["init"]).filter((init) => isASTNode(init));
+  }
+  const expression = node["expression"];
+  if (node.type !== "ExpressionStatement" || !isASTNode(expression)) {
+    return [];
+  }
+  const right = expression["right"];
+  if (expression.type === "AssignmentExpression" && isASTNode(right)) {
+    return [right];
+  }
+  return [expression];
+}
+var HEAD_PROPERTY = {
+  CallExpression: "callee",
+  MemberExpression: "object",
+  ChainExpression: "expression",
+  AwaitExpression: "argument",
+  TSNonNullExpression: "expression",
+  ParenthesizedExpression: "expression"
+};
+function getExpressionHead(node) {
+  let current = node;
+  let property = HEAD_PROPERTY[current.type];
+  while (property !== undefined) {
+    const inner = current[property];
+    if (!isASTNode(inner)) {
+      break;
+    }
+    current = inner;
+    property = HEAD_PROPERTY[current.type];
+  }
+  return current;
+}
+function isAwaitHeaded(node) {
+  if (node.type === "VariableDeclaration" && node.kind === "await using") {
+    return true;
+  }
+  return getStatementValues(node).some((value) => hasAwaitInHeadChain(value));
+}
+function hasAwaitInHeadChain(node) {
+  let current = node;
+  while (current !== undefined) {
+    if (current.type === "AwaitExpression") {
+      return true;
+    }
+    const property = HEAD_PROPERTY[current.type];
+    const inner = property === undefined ? undefined : current[property];
+    current = isASTNode(inner) ? inner : undefined;
+  }
+  return false;
+}
+var CALL_TYPES = ["CallExpression", "AwaitExpression"];
+var MUTATION_TYPES = ["AssignmentExpression", "UpdateExpression"];
+function isKindBoundary(prev, next) {
+  const prevKind = getStatementKind(prev);
+  const nextKind = getStatementKind(next);
+  return prevKind !== null && nextKind !== null && prevKind !== nextKind;
+}
+function getStatementKind(node) {
+  if (isUsingDecl(node)) {
+    return "using";
+  }
+  if (isVarDecl(node)) {
+    return "declaration";
+  }
+  if (isExpressionStatementOf(node, CALL_TYPES)) {
+    return "call";
+  }
+  return isExpressionStatementOf(node, MUTATION_TYPES) ? "mutation" : null;
+}
+function isExpressionStatementOf(node, types) {
+  const expression = node["expression"];
+  return node.type === "ExpressionStatement" && isASTNode(expression) && types.includes(expression.type);
+}
+var VAR_DECL_KINDS = new Set(["const", "let", "var"]);
+function isVarDecl(node) {
+  if (node.type === "VariableDeclaration") {
+    return node.kind !== undefined && VAR_DECL_KINDS.has(node.kind);
+  }
+  return false;
+}
+var USING_DECL_KINDS = new Set(["using", "await using"]);
+function isUsingDecl(node) {
+  if (node.type === "VariableDeclaration") {
+    return node.kind !== undefined && USING_DECL_KINDS.has(node.kind);
+  }
+  return false;
+}
+function isFnOrClassDecl(node) {
+  return node.type === "FunctionDeclaration" || node.type === "ClassDeclaration";
+}
+
 // src/transform/plan-gap-edit.ts
 function planGapEdit(file, prev, next) {
   const gap = buildGap(file, prev, next);
@@ -326,98 +448,6 @@ function isMultiline(src, node) {
   return typeof node.start === "number" && typeof node.end === "number" && src.slice(node.start, node.end).includes(`
 `);
 }
-var CONTROL_FLOW_TYPES = new Set([
-  "IfStatement",
-  "ForStatement",
-  "ForInStatement",
-  "ForOfStatement",
-  "WhileStatement",
-  "SwitchStatement",
-  "TryStatement"
-]);
-function needsBlankLine(container, prev, next) {
-  if (container.type === "ClassBody") {
-    return true;
-  }
-  if (isVarDecl(prev) && !isVarDecl(next)) {
-    return true;
-  }
-  if (next.type === "ReturnStatement") {
-    return true;
-  }
-  if (isFnOrClassDecl(prev)) {
-    return true;
-  }
-  return isNewHeaded(prev) !== isNewHeaded(next) || isKindBoundary(prev, next) || CONTROL_FLOW_TYPES.has(next.type) || CONTROL_FLOW_TYPES.has(prev.type);
-}
-function isNewHeaded(node) {
-  return getStatementValues(node).some((value) => getExpressionHead(value).type === "NewExpression");
-}
-function getStatementValues(node) {
-  if (node.type === "VariableDeclaration") {
-    return collectASTNodes(node["declarations"]).map((declarator) => declarator["init"]).filter((init) => isASTNode(init));
-  }
-  const { expression } = node;
-  if (node.type !== "ExpressionStatement" || !isASTNode(expression)) {
-    return [];
-  }
-  const { right } = expression;
-  if (expression.type === "AssignmentExpression" && isASTNode(right)) {
-    return [right];
-  }
-  return [expression];
-}
-var HEAD_PROPERTY = {
-  CallExpression: "callee",
-  MemberExpression: "object",
-  ChainExpression: "expression",
-  AwaitExpression: "argument",
-  TSNonNullExpression: "expression",
-  ParenthesizedExpression: "expression"
-};
-function getExpressionHead(node) {
-  let current = node;
-  let property = HEAD_PROPERTY[current.type];
-  while (property !== undefined) {
-    const inner = current[property];
-    if (!isASTNode(inner)) {
-      break;
-    }
-    current = inner;
-    property = HEAD_PROPERTY[current.type];
-  }
-  return current;
-}
-var CALL_TYPES = ["CallExpression", "AwaitExpression"];
-var MUTATION_TYPES = ["AssignmentExpression", "UpdateExpression"];
-function isKindBoundary(prev, next) {
-  const prevKind = getStatementKind(prev);
-  const nextKind = getStatementKind(next);
-  return prevKind !== null && nextKind !== null && prevKind !== nextKind;
-}
-function getStatementKind(node) {
-  if (isVarDecl(node)) {
-    return "declaration";
-  }
-  if (isExpressionStatementOf(node, CALL_TYPES)) {
-    return "call";
-  }
-  return isExpressionStatementOf(node, MUTATION_TYPES) ? "mutation" : null;
-}
-function isExpressionStatementOf(node, types) {
-  const { expression } = node;
-  return node.type === "ExpressionStatement" && isASTNode(expression) && types.includes(expression.type);
-}
-var VAR_DECL_KINDS = new Set(["const", "let", "var"]);
-function isVarDecl(node) {
-  if (node.type === "VariableDeclaration") {
-    return node.kind !== undefined && VAR_DECL_KINDS.has(node.kind);
-  }
-  return false;
-}
-function isFnOrClassDecl(node) {
-  return node.type === "FunctionDeclaration" || node.type === "ClassDeclaration";
-}
 
 // src/transform/parse-source.ts
 import { parseSync } from "oxc-parser";
@@ -523,10 +553,11 @@ class MyersDiff {
     return ops.toReversed();
   }
   unwindRound(pos, d) {
-    const { prev, moveDown } = this.findPrevious(pos, d);
+    const previous = this.findPrevious(pos, d);
+    const prev = previous.prev;
     const ops = this.buildEqualOps(pos, prev);
     if (d > 0) {
-      const changeOp = moveDown ? { kind: "+", text: this.b[prev.y] ?? "" } : { kind: "-", text: this.a[prev.x] ?? "" };
+      const changeOp = previous.moveDown ? { kind: "+", text: this.b[prev.y] ?? "" } : { kind: "-", text: this.a[prev.x] ?? "" };
       ops.push(changeOp);
     }
     return { ops, pos: prev };
@@ -541,7 +572,8 @@ class MyersDiff {
   }
   buildEqualOps(pos, prev) {
     const ops = [];
-    let { x, y } = pos;
+    let x = pos.x;
+    let y = pos.y;
     while (x > prev.x && y > prev.y) {
       ops.push({ kind: " ", text: this.a[x - 1] ?? "" });
       x--;
@@ -571,12 +603,12 @@ function buildWindows(ops) {
   return windows;
 }
 function buildHunk(ops, w) {
-  const { aLine, bLine } = countPrecedingLines(ops, w.from);
+  const preceding = countPrecedingLines(ops, w.from);
   const slice = ops.slice(w.from, w.to);
   const aCount = slice.filter((o) => o.kind !== "+").length;
   const bCount = slice.filter((o) => o.kind !== "-").length;
   return {
-    header: `@@ -${formatRange(aLine, aCount)} +${formatRange(bLine, bCount)} @@
+    header: `@@ -${formatRange(preceding.aLine, aCount)} +${formatRange(preceding.bLine, bCount)} @@
 `,
     lines: slice.map((o) => `${o.kind}${o.text}
 `)
@@ -653,20 +685,23 @@ if (typeof parsedArgs === "string") {
   console.error(parsedArgs);
   process.exit(2);
 }
-var { mode, quiet, bench, help, version, ignore, inputs } = parsedArgs;
-if (help || inputs.length === 0 && !version) {
+var mode = parsedArgs.mode;
+var quiet = parsedArgs.quiet;
+var bench = parsedArgs.bench;
+var inputs = parsedArgs.inputs;
+if (parsedArgs.help || inputs.length === 0 && !parsedArgs.version) {
   const exitCode = inputs.length === 0 ? 2 : 0;
   printHelp();
   process.exit(exitCode);
 }
-if (version) {
+if (parsedArgs.version) {
   const pkgPath = fileURLToPath(new URL("../package.json", import.meta.url));
   process.stdout.write(`${readPackageVersion(pkgPath)}
 `);
   process.exit(0);
 }
 var t0 = Date.now();
-var files = await expandInputs(inputs, ignore);
+var files = await expandInputs(inputs, parsedArgs.ignore);
 if (files.length === 0) {
   console.error("no files matched");
   process.exit(2);

package/dist/index.js

@@ -40,6 +40,128 @@ function collectChildNodes(node) {
   return children;
 }
 
+// src/transform/needs-blank-line.ts
+var CONTROL_FLOW_TYPES = new Set([
+  "IfStatement",
+  "ForStatement",
+  "ForInStatement",
+  "ForOfStatement",
+  "WhileStatement",
+  "SwitchStatement",
+  "TryStatement"
+]);
+function needsBlankLine(container, prev, next) {
+  if (container.type === "ClassBody") {
+    return true;
+  }
+  if (isVarDecl(prev) && !isVarDecl(next) || isUsingDecl(prev) && !isUsingDecl(next)) {
+    return true;
+  }
+  if (next.type === "ReturnStatement") {
+    return true;
+  }
+  if (isFnOrClassDecl(prev)) {
+    return true;
+  }
+  return isNewHeaded(prev) !== isNewHeaded(next) || isAwaitHeaded(prev) !== isAwaitHeaded(next) || isKindBoundary(prev, next) || CONTROL_FLOW_TYPES.has(next.type) || CONTROL_FLOW_TYPES.has(prev.type);
+}
+function isNewHeaded(node) {
+  return getStatementValues(node).some((value) => getExpressionHead(value).type === "NewExpression");
+}
+function getStatementValues(node) {
+  if (node.type === "VariableDeclaration") {
+    return collectASTNodes(node["declarations"]).map((declarator) => declarator["init"]).filter((init) => isASTNode(init));
+  }
+  const expression = node["expression"];
+  if (node.type !== "ExpressionStatement" || !isASTNode(expression)) {
+    return [];
+  }
+  const right = expression["right"];
+  if (expression.type === "AssignmentExpression" && isASTNode(right)) {
+    return [right];
+  }
+  return [expression];
+}
+var HEAD_PROPERTY = {
+  CallExpression: "callee",
+  MemberExpression: "object",
+  ChainExpression: "expression",
+  AwaitExpression: "argument",
+  TSNonNullExpression: "expression",
+  ParenthesizedExpression: "expression"
+};
+function getExpressionHead(node) {
+  let current = node;
+  let property = HEAD_PROPERTY[current.type];
+  while (property !== undefined) {
+    const inner = current[property];
+    if (!isASTNode(inner)) {
+      break;
+    }
+    current = inner;
+    property = HEAD_PROPERTY[current.type];
+  }
+  return current;
+}
+function isAwaitHeaded(node) {
+  if (node.type === "VariableDeclaration" && node.kind === "await using") {
+    return true;
+  }
+  return getStatementValues(node).some((value) => hasAwaitInHeadChain(value));
+}
+function hasAwaitInHeadChain(node) {
+  let current = node;
+  while (current !== undefined) {
+    if (current.type === "AwaitExpression") {
+      return true;
+    }
+    const property = HEAD_PROPERTY[current.type];
+    const inner = property === undefined ? undefined : current[property];
+    current = isASTNode(inner) ? inner : undefined;
+  }
+  return false;
+}
+var CALL_TYPES = ["CallExpression", "AwaitExpression"];
+var MUTATION_TYPES = ["AssignmentExpression", "UpdateExpression"];
+function isKindBoundary(prev, next) {
+  const prevKind = getStatementKind(prev);
+  const nextKind = getStatementKind(next);
+  return prevKind !== null && nextKind !== null && prevKind !== nextKind;
+}
+function getStatementKind(node) {
+  if (isUsingDecl(node)) {
+    return "using";
+  }
+  if (isVarDecl(node)) {
+    return "declaration";
+  }
+  if (isExpressionStatementOf(node, CALL_TYPES)) {
+    return "call";
+  }
+  return isExpressionStatementOf(node, MUTATION_TYPES) ? "mutation" : null;
+}
+function isExpressionStatementOf(node, types) {
+  const expression = node["expression"];
+  return node.type === "ExpressionStatement" && isASTNode(expression) && types.includes(expression.type);
+}
+var VAR_DECL_KINDS = new Set(["const", "let", "var"]);
+function isVarDecl(node) {
+  if (node.type === "VariableDeclaration") {
+    return node.kind !== undefined && VAR_DECL_KINDS.has(node.kind);
+  }
+  return false;
+}
+var USING_DECL_KINDS = new Set(["using", "await using"]);
+function isUsingDecl(node) {
+  if (node.type === "VariableDeclaration") {
+    return node.kind !== undefined && USING_DECL_KINDS.has(node.kind);
+  }
+  return false;
+}
+function isFnOrClassDecl(node) {
+  return node.type === "FunctionDeclaration" || node.type === "ClassDeclaration";
+}
+
 // src/transform/plan-gap-edit.ts
 function planGapEdit(file, prev, next) {
   const gap = buildGap(file, prev, next);
@@ -176,98 +298,6 @@ function isMultiline(src, node) {
   return typeof node.start === "number" && typeof node.end === "number" && src.slice(node.start, node.end).includes(`
 `);
 }
-var CONTROL_FLOW_TYPES = new Set([
-  "IfStatement",
-  "ForStatement",
-  "ForInStatement",
-  "ForOfStatement",
-  "WhileStatement",
-  "SwitchStatement",
-  "TryStatement"
-]);
-function needsBlankLine(container, prev, next) {
-  if (container.type === "ClassBody") {
-    return true;
-  }
-  if (isVarDecl(prev) && !isVarDecl(next)) {
-    return true;
-  }
-  if (next.type === "ReturnStatement") {
-    return true;
-  }
-  if (isFnOrClassDecl(prev)) {
-    return true;
-  }
-  return isNewHeaded(prev) !== isNewHeaded(next) || isKindBoundary(prev, next) || CONTROL_FLOW_TYPES.has(next.type) || CONTROL_FLOW_TYPES.has(prev.type);
-}
-function isNewHeaded(node) {
-  return getStatementValues(node).some((value) => getExpressionHead(value).type === "NewExpression");
-}
-function getStatementValues(node) {
-  if (node.type === "VariableDeclaration") {
-    return collectASTNodes(node["declarations"]).map((declarator) => declarator["init"]).filter((init) => isASTNode(init));
-  }
-  const { expression } = node;
-  if (node.type !== "ExpressionStatement" || !isASTNode(expression)) {
-    return [];
-  }
-  const { right } = expression;
-  if (expression.type === "AssignmentExpression" && isASTNode(right)) {
-    return [right];
-  }
-  return [expression];
-}
-var HEAD_PROPERTY = {
-  CallExpression: "callee",
-  MemberExpression: "object",
-  ChainExpression: "expression",
-  AwaitExpression: "argument",
-  TSNonNullExpression: "expression",
-  ParenthesizedExpression: "expression"
-};
-function getExpressionHead(node) {
-  let current = node;
-  let property = HEAD_PROPERTY[current.type];
-  while (property !== undefined) {
-    const inner = current[property];
-    if (!isASTNode(inner)) {
-      break;
-    }
-    current = inner;
-    property = HEAD_PROPERTY[current.type];
-  }
-  return current;
-}
-var CALL_TYPES = ["CallExpression", "AwaitExpression"];
-var MUTATION_TYPES = ["AssignmentExpression", "UpdateExpression"];
-function isKindBoundary(prev, next) {
-  const prevKind = getStatementKind(prev);
-  const nextKind = getStatementKind(next);
-  return prevKind !== null && nextKind !== null && prevKind !== nextKind;
-}
-function getStatementKind(node) {
-  if (isVarDecl(node)) {
-    return "declaration";
-  }
-  if (isExpressionStatementOf(node, CALL_TYPES)) {
-    return "call";
-  }
-  return isExpressionStatementOf(node, MUTATION_TYPES) ? "mutation" : null;
-}
-function isExpressionStatementOf(node, types) {
-  const { expression } = node;
-  return node.type === "ExpressionStatement" && isASTNode(expression) && types.includes(expression.type);
-}
-var VAR_DECL_KINDS = new Set(["const", "let", "var"]);
-function isVarDecl(node) {
-  if (node.type === "VariableDeclaration") {
-    return node.kind !== undefined && VAR_DECL_KINDS.has(node.kind);
-  }
-  return false;
-}
-function isFnOrClassDecl(node) {
-  return node.type === "FunctionDeclaration" || node.type === "ClassDeclaration";
-}
 
 // src/transform/parse-source.ts
 import { parseSync } from "oxc-parser";

package/dist/transform/needs-blank-line.d.ts

@@ -0,0 +1,11 @@
+import type { ASTNode } from '../types.ts';
+/**
+ * The "always" rules: a blank line between class members, after a var or
+ * using block before a statement of any other kind, before a return, after a
+ * function/class declaration, on both sides of a control-flow block — its
+ * closing brace ends a visual unit just like its opening keyword starts one —
+ * and at the boundary between statement kinds: call vs mutation,
+ * instantiation vs anything else, and awaited vs non-awaited. There are no
+ * "never" rules, so any match means one blank.
+ */
+export declare function needsBlankLine(container: ASTNode, prev: ASTNode, next: ASTNode): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/format-codemod",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Enforce blank-line padding conventions in TypeScript via a fast text-splice codemod",
   "license": "MIT",
   "repository": {