@zgeoff/format-codemod 0.0.2 → 0.0.3

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

@@ -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;
+  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;
+}
+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;
+  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";

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;
+  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;
+}
+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;
+  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.3",
   "description": "Enforce blank-line padding conventions in TypeScript via a fast text-splice codemod",
   "license": "MIT",
   "repository": {