@zgeoff/format-codemod 0.1.0 → 0.2.0

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

@@ -8,4 +8,4 @@ export interface CLIArgs {
     readonly ignore: readonly string[];
     readonly inputs: readonly string[];
 }
-export declare function parseCLIArgs(argv: readonly string[]): CLIArgs | string;
+export declare function parseCLIArgs(argv: readonly string[]): Promise<CLIArgs | string>;

package/dist/cli.js

@@ -62,35 +62,43 @@ function loadFormatIgnore(dir) {
 }
 
 // src/cli/parse-cli-args.ts
-import { parseArgs } from "node:util";
-function parseCLIArgs(argv) {
+import { cli } from "gunshi/bone";
+import { define } from "gunshi/definition";
+var CLI_ARGS = {
+  check: { type: "boolean", default: false },
+  dry: { type: "boolean", default: false },
+  bench: { type: "boolean", default: false },
+  quiet: { type: "boolean", default: false },
+  version: { type: "boolean", default: false },
+  help: { type: "boolean", default: false },
+  ignore: { type: "string", multiple: true }
+};
+async function parseCLIArgs(argv) {
+  let parsed = null;
+  const command = define({
+    name: "format-codemod",
+    args: CLI_ARGS,
+    run: (ctx) => {
+      if (ctx.validationError !== undefined) {
+        throw ctx.validationError;
+      }
+      parsed = {
+        mode: pickMode(ctx.values.check, ctx.values.dry),
+        quiet: ctx.values.quiet,
+        bench: ctx.values.bench,
+        help: ctx.values.help,
+        version: ctx.values.version,
+        ignore: ctx.values.ignore ?? [],
+        inputs: [...ctx.positionals, ...ctx.rest]
+      };
+    }
+  });
   try {
-    const parsed = parseArgs({
-      args: [...argv],
-      options: {
-        check: { type: "boolean", default: false },
-        dry: { type: "boolean", default: false },
-        bench: { type: "boolean", default: false },
-        quiet: { type: "boolean", default: false },
-        version: { type: "boolean", default: false },
-        help: { type: "boolean", default: false },
-        ignore: { type: "string", multiple: true, default: [] }
-      },
-      allowPositionals: true,
-      strict: true
-    });
-    return {
-      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
-    };
+    await cli([...argv], command, { strict: true });
   } catch (error) {
-    return error instanceof Error ? error.message : String(error);
+    return formatParseError(error);
   }
+  return parsed ?? "the command line could not be parsed";
 }
 function pickMode(check, dry) {
   if (check) {
@@ -98,6 +106,13 @@ function pickMode(check, dry) {
   }
   return dry ? "dry" : "write";
 }
+function formatParseError(error) {
+  if (error instanceof AggregateError) {
+    return error.errors.map((reason) => formatParseError(reason)).join(`
+`);
+  }
+  return error instanceof Error ? error.message : String(error);
+}
 
 // src/cli/print-help.ts
 function printHelp() {
@@ -531,8 +546,8 @@ import fs4 from "node:fs";
 
 // src/cli/build-unified-diff.ts
 function buildUnifiedDiff(before, after, label) {
-  const ops = new MyersDiff(splitLines(before), splitLines(after)).buildOps();
-  const hunks = buildHunks(ops);
+  const operations = buildDiffOps({ before: splitLines(before), after: splitLines(after) });
+  const hunks = buildHunks(operations);
   if (hunks.length === 0) {
     return "";
   }
@@ -548,88 +563,82 @@ function splitLines(s) {
   }
   return lines;
 }
-
-class MyersDiff {
-  a;
-  b;
-  v = new Map([[1, 0]]);
-  trace = [];
-  constructor(a, b) {
-    this.a = a;
-    this.b = b;
-  }
-  buildOps() {
-    this.updateTrace();
-    return this.backtrack();
-  }
-  updateTrace() {
-    for (let d = 0;d <= this.a.length + this.b.length; d++) {
-      this.trace.push(new Map(this.v));
-      if (this.stepRound(d)) {
-        return;
-      }
-    }
-  }
-  stepRound(d) {
-    for (let k = -d;k <= d; k += 2) {
-      const x = this.slideDiagonal(this.pickX(k, d), k);
-      this.v.set(k, x);
-      if (x >= this.a.length && x - k >= this.b.length) {
-        return true;
-      }
+function buildDiffOps(lines) {
+  return backtrack(lines, buildTrace(lines));
+}
+function buildTrace(lines) {
+  const furthestX = new Map([[1, 0]]);
+  const trace = [];
+  for (let depth = 0;depth <= lines.before.length + lines.after.length; depth++) {
+    trace.push(new Map(furthestX));
+    if (stepRound(lines, furthestX, depth)) {
+      break;
     }
-    return false;
-  }
-  pickX(k, d) {
-    const moveDown = k === -d || k !== d && (this.v.get(k - 1) ?? 0) < (this.v.get(k + 1) ?? 0);
-    return moveDown ? this.v.get(k + 1) ?? 0 : (this.v.get(k - 1) ?? 0) + 1;
   }
-  slideDiagonal(x, k) {
-    let nx = x;
-    while (nx < this.a.length && nx - k < this.b.length && this.a[nx] === this.b[nx - k]) {
-      nx++;
-    }
-    return nx;
-  }
-  backtrack() {
-    const ops = [];
-    let pos = { x: this.a.length, y: this.b.length };
-    for (let d = this.trace.length - 1;d >= 0; d--) {
-      const round = this.unwindRound(pos, d);
-      ops.push(...round.ops);
-      pos = round.pos;
-    }
-    return ops.toReversed();
-  }
-  unwindRound(pos, d) {
-    const previous = this.findPrevious(pos, d);
-    const prev = previous.prev;
-    const ops = this.buildEqualOps(pos, prev);
-    if (d > 0) {
-      const changeOp = previous.moveDown ? { kind: "+", text: this.b[prev.y] ?? "" } : { kind: "-", text: this.a[prev.x] ?? "" };
-      ops.push(changeOp);
-    }
-    return { ops, pos: prev };
-  }
-  findPrevious(pos, d) {
-    const v = this.trace[d] ?? new Map;
-    const k = pos.x - pos.y;
-    const moveDown = k === -d || k !== d && (v.get(k - 1) ?? 0) < (v.get(k + 1) ?? 0);
-    const prevK = moveDown ? k + 1 : k - 1;
-    const prevX = v.get(prevK) ?? 0;
-    return { prev: { x: prevX, y: prevX - prevK }, moveDown };
-  }
-  buildEqualOps(pos, prev) {
-    const ops = [];
-    let x = pos.x;
-    let y = pos.y;
-    while (x > prev.x && y > prev.y) {
-      ops.push({ kind: " ", text: this.a[x - 1] ?? "" });
-      x--;
-      y--;
+  return trace;
+}
+function stepRound(lines, furthestX, depth) {
+  for (let diagonal = -depth;diagonal <= depth; diagonal += 2) {
+    const x = slideDiagonal(lines, pickX(furthestX, diagonal, depth), diagonal);
+    furthestX.set(diagonal, x);
+    if (x >= lines.before.length && x - diagonal >= lines.after.length) {
+      return true;
     }
-    return ops;
   }
+  return false;
+}
+function pickX(furthestX, diagonal, depth) {
+  const below = furthestX.get(diagonal - 1) ?? 0;
+  const above = furthestX.get(diagonal + 1) ?? 0;
+  const moveDown = diagonal === -depth || diagonal !== depth && below < above;
+  return moveDown ? above : below + 1;
+}
+function slideDiagonal(lines, x, diagonal) {
+  let endX = x;
+  while (endX < lines.before.length && endX - diagonal < lines.after.length && lines.before[endX] === lines.after[endX - diagonal]) {
+    endX++;
+  }
+  return endX;
+}
+function backtrack(lines, trace) {
+  const operations = [];
+  let position = { x: lines.before.length, y: lines.after.length };
+  for (let depth = trace.length - 1;depth >= 0; depth--) {
+    const round = unwindRound(lines, trace, position, depth);
+    operations.push(...round.operations);
+    position = round.position;
+  }
+  return operations.toReversed();
+}
+function unwindRound(lines, trace, position, depth) {
+  const step = findPreviousStep(trace, position, depth);
+  const operations = buildEqualOps(lines, position, step.position);
+  if (depth > 0) {
+    const changeOp = step.moveDown ? { kind: "+", text: lines.after[step.position.y] ?? "" } : { kind: "-", text: lines.before[step.position.x] ?? "" };
+    operations.push(changeOp);
+  }
+  return { operations, position: step.position };
+}
+function findPreviousStep(trace, position, depth) {
+  const furthestX = trace[depth] ?? new Map;
+  const diagonal = position.x - position.y;
+  const below = furthestX.get(diagonal - 1) ?? 0;
+  const above = furthestX.get(diagonal + 1) ?? 0;
+  const moveDown = diagonal === -depth || diagonal !== depth && below < above;
+  const previousDiagonal = moveDown ? diagonal + 1 : diagonal - 1;
+  const previousX = furthestX.get(previousDiagonal) ?? 0;
+  return { position: { x: previousX, y: previousX - previousDiagonal }, moveDown };
+}
+function buildEqualOps(lines, position, previous) {
+  const operations = [];
+  let x = position.x;
+  let y = position.y;
+  while (x > previous.x && y > previous.y) {
+    operations.push({ kind: " ", text: lines.before[x - 1] ?? "" });
+    x--;
+    y--;
+  }
+  return operations;
 }
 function buildHunks(ops) {
   return buildWindows(ops).map((w) => buildHunk(ops, w));
@@ -729,7 +738,7 @@ function tryCheckFile(file, mode) {
 }
 
 // src/cli.ts
-var parsedArgs = parseCLIArgs(process.argv.slice(2));
+var parsedArgs = await parseCLIArgs(process.argv.slice(2));
 if (typeof parsedArgs === "string") {
   console.error(parsedArgs);
   process.exit(2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/format-codemod",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Enforce blank-line padding conventions in TypeScript via a fast text-splice codemod",
   "license": "MIT",
   "repository": {
@@ -30,11 +30,12 @@
     "typecheck": "tsc"
   },
   "dependencies": {
-    "oxc-parser": "0.137.0"
+    "gunshi": "1.0.0-rc.1",
+    "oxc-parser": "0.153.0"
   },
   "devDependencies": {
-    "@types/bun": "1.3.14",
-    "typescript": "7.0.1-rc"
+    "@types/bun": "1.4.2",
+    "typescript": "7.0.2"
   },
   "engines": {
     "bun": ">=1.3",