@zgeoff/format-codemod 0.0.1 → 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/expand-inputs.d.ts

@@ -1,5 +1,7 @@
 /**
  * Deduped: overlapping patterns (a `src/**` glob plus a file inside src/) must
- * not process — or report — the same file twice.
+ * not process — or report — the same file twice. Ignore globs filter the final
+ * list uniformly, so a file is skipped whether it arrived via a directory,
+ * a glob, or an explicit path argument.
  */
-export declare function expandInputs(patterns: readonly string[]): Promise<string[]>;
+export declare function expandInputs(patterns: readonly string[], ignore?: readonly string[]): Promise<string[]>;

package/dist/cli/parse-cli-args.d.ts

@@ -5,6 +5,7 @@ export interface CLIArgs {
     readonly bench: boolean;
     readonly help: boolean;
     readonly version: boolean;
+    readonly ignore: readonly string[];
     readonly inputs: readonly string[];
 }
 /**

package/dist/cli.js

@@ -20,9 +20,9 @@ function buildBenchStatsFromReports(reports, ms) {
 // src/cli/expand-inputs.ts
 import fs from "node:fs";
 import path from "node:path";
-async function expandInputs(patterns) {
+async function expandInputs(patterns, ignore = []) {
   const lists = await Promise.all(patterns.map((p) => expandPattern(p)));
-  return [...new Set(lists.flat())];
+  return [...new Set(lists.flat())].filter((file) => !isIgnored(file, ignore));
 }
 function expandPattern(p) {
   if (fs.existsSync(p)) {
@@ -41,6 +41,13 @@ function isExcluded(entry) {
   const p = typeof entry === "string" ? entry : path.join(entry.parentPath ?? "", entry.name);
   return p.split(/[\\/]/u).some((seg) => seg === "node_modules" || seg === ".git");
 }
+function isIgnored(file, patterns) {
+  if (patterns.length === 0) {
+    return false;
+  }
+  const relative = path.relative(process.cwd(), file);
+  return patterns.some((pattern) => path.matchesGlob(file, pattern) || path.matchesGlob(relative, pattern));
+}
 
 // src/cli/parse-cli-args.ts
 import { parseArgs } from "node:util";
@@ -54,7 +61,8 @@ function parseCLIArgs(argv) {
         bench: { type: "boolean", default: false },
         quiet: { type: "boolean", default: false },
         version: { type: "boolean", default: false },
-        help: { type: "boolean", default: false }
+        help: { type: "boolean", default: false },
+        ignore: { type: "string", multiple: true, default: [] }
       },
       allowPositionals: true,
       strict: true
@@ -65,6 +73,7 @@ function parseCLIArgs(argv) {
       bench: values.bench,
       help: values.help,
       version: values.version,
+      ignore: values.ignore,
       inputs: positionals
     };
   } catch (error) {
@@ -86,10 +95,11 @@ usage:
   format-codemod [options] <file|dir|glob> ...
 
 options:
-  --check     exit 1 if any file would change (no writes)
-  --dry       print unified diff to stdout (no writes)
-  --bench     print parse stats as JSON to stderr
-  --quiet     only print files that would change
+  --check            exit 1 if any file would change (no writes)
+  --dry              print unified diff to stdout (no writes)
+  --bench            print parse stats as JSON to stderr
+  --quiet            only print files that would change
+  --ignore <glob>    skip files matching the glob (repeatable)
   --version
   --help
 
@@ -102,6 +112,7 @@ examples:
   format-codemod 'src/**/*.ts'
   format-codemod --check 'src/**/*.{ts,tsx}'
   format-codemod --dry path/to/file.ts
+  format-codemod --ignore 'src/generated/**' .
 `);
 }
 
@@ -149,6 +160,158 @@ function applyEdits(src, edits) {
   return segments.toReversed().join("");
 }
 
+// src/transform/is-ast-node.ts
+function isASTNode(value) {
+  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+
+// src/transform/collect-ast-nodes.ts
+function collectASTNodes(value) {
+  if (!Array.isArray(value)) {
+    return isASTNode(value) ? [value] : [];
+  }
+  const nodes = [];
+  for (const item of value) {
+    if (isASTNode(item)) {
+      nodes.push(item);
+    }
+  }
+  return nodes;
+}
+
+// src/transform/collect-child-nodes.ts
+function collectChildNodes(node) {
+  const children = [];
+  for (const key of Object.keys(node)) {
+    if (key !== "loc" && key !== "parent") {
+      children.push(...collectASTNodes(node[key]));
+    }
+  }
+  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);
@@ -269,7 +432,7 @@ function buildPairEdits(file, container, body) {
   for (let i = 0;i < body.length - 1; i++) {
     const prev = body[i];
     const next = body[i + 1];
-    if (prev !== undefined && next !== undefined && (needsBlankLine(container, prev, next) || isMultiline(file.src, prev) || isMultiline(file.src, next))) {
+    if (prev !== undefined && next !== undefined && !isImportPair(prev, next) && (needsBlankLine(container, prev, next) || isMultiline(file.src, prev) || isMultiline(file.src, next))) {
       const edit = planGapEdit(file, prev, next);
       if (edit !== null) {
         edits.push(edit);
@@ -278,126 +441,13 @@ function buildPairEdits(file, container, body) {
   }
   return edits;
 }
+function isImportPair(prev, next) {
+  return prev.type === "ImportDeclaration" && next.type === "ImportDeclaration";
+}
 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";
-}
-function collectChildNodes(node) {
-  const children = [];
-  for (const key of Object.keys(node)) {
-    if (key !== "loc" && key !== "parent") {
-      children.push(...collectASTNodes(node[key]));
-    }
-  }
-  return children;
-}
-function collectASTNodes(value) {
-  if (!Array.isArray(value)) {
-    return isASTNode(value) ? [value] : [];
-  }
-  const nodes = [];
-  for (const item of value) {
-    if (isASTNode(item)) {
-      nodes.push(item);
-    }
-  }
-  return nodes;
-}
-function isASTNode(value) {
-  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
-}
 
 // src/transform/parse-source.ts
 import { parseSync } from "oxc-parser";
@@ -633,7 +683,7 @@ if (typeof parsedArgs === "string") {
   console.error(parsedArgs);
   process.exit(2);
 }
-var { mode, quiet, bench, help, version, inputs } = parsedArgs;
+var { mode, quiet, bench, help, version, ignore, inputs } = parsedArgs;
 if (help || inputs.length === 0 && !version) {
   const exitCode = inputs.length === 0 ? 2 : 0;
   printHelp();
@@ -646,7 +696,7 @@ if (version) {
   process.exit(0);
 }
 var t0 = Date.now();
-var files = await expandInputs(inputs);
+var files = await expandInputs(inputs, ignore);
 if (files.length === 0) {
   console.error("no files matched");
   process.exit(2);

package/dist/index.js

@@ -10,6 +10,158 @@ function applyEdits(src, edits) {
   return segments.toReversed().join("");
 }
 
+// src/transform/is-ast-node.ts
+function isASTNode(value) {
+  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+
+// src/transform/collect-ast-nodes.ts
+function collectASTNodes(value) {
+  if (!Array.isArray(value)) {
+    return isASTNode(value) ? [value] : [];
+  }
+  const nodes = [];
+  for (const item of value) {
+    if (isASTNode(item)) {
+      nodes.push(item);
+    }
+  }
+  return nodes;
+}
+
+// src/transform/collect-child-nodes.ts
+function collectChildNodes(node) {
+  const children = [];
+  for (const key of Object.keys(node)) {
+    if (key !== "loc" && key !== "parent") {
+      children.push(...collectASTNodes(node[key]));
+    }
+  }
+  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);
@@ -130,7 +282,7 @@ function buildPairEdits(file, container, body) {
   for (let i = 0;i < body.length - 1; i++) {
     const prev = body[i];
     const next = body[i + 1];
-    if (prev !== undefined && next !== undefined && (needsBlankLine(container, prev, next) || isMultiline(file.src, prev) || isMultiline(file.src, next))) {
+    if (prev !== undefined && next !== undefined && !isImportPair(prev, next) && (needsBlankLine(container, prev, next) || isMultiline(file.src, prev) || isMultiline(file.src, next))) {
       const edit = planGapEdit(file, prev, next);
       if (edit !== null) {
         edits.push(edit);
@@ -139,126 +291,13 @@ function buildPairEdits(file, container, body) {
   }
   return edits;
 }
+function isImportPair(prev, next) {
+  return prev.type === "ImportDeclaration" && next.type === "ImportDeclaration";
+}
 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";
-}
-function collectChildNodes(node) {
-  const children = [];
-  for (const key of Object.keys(node)) {
-    if (key !== "loc" && key !== "parent") {
-      children.push(...collectASTNodes(node[key]));
-    }
-  }
-  return children;
-}
-function collectASTNodes(value) {
-  if (!Array.isArray(value)) {
-    return isASTNode(value) ? [value] : [];
-  }
-  const nodes = [];
-  for (const item of value) {
-    if (isASTNode(item)) {
-      nodes.push(item);
-    }
-  }
-  return nodes;
-}
-function isASTNode(value) {
-  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
-}
 
 // src/transform/parse-source.ts
 import { parseSync } from "oxc-parser";

package/dist/transform/collect-ast-nodes.d.ts

@@ -0,0 +1,6 @@
+import type { ASTNode } from '../types.ts';
+/**
+ * The AST nodes in a property value: the node itself, an array's node
+ * elements, or nothing for non-node values.
+ */
+export declare function collectASTNodes(value: unknown): ASTNode[];

package/dist/transform/collect-child-nodes.d.ts

@@ -0,0 +1,6 @@
+import type { ASTNode } from '../types.ts';
+/**
+ * A node's direct child nodes across all properties, skipping the location
+ * and parent back-references a traversal must not follow.
+ */
+export declare function collectChildNodes(node: ASTNode): ASTNode[];

package/dist/transform/is-ast-node.d.ts

@@ -0,0 +1,2 @@
+import type { ASTNode } from '../types.ts';
+export declare function isASTNode(value: unknown): value is ASTNode;

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