NeovimでDenoのファイル保存時にDeno fmtを走らせる

import { Denops } from "https://deno.land/x/denops_std@v5.0.1/mod.ts";
import * as fn from "https://deno.land/x/denops_std@v5.0.1/function/mod.ts";
import * as batch from "https://deno.land/x/denops_std@v5.0.1/batch/mod.ts";
import { execPipedCmd } from "./shell.ts";

type CocActionResult = {
  id: string;
  state: "init" | "starting" | "runnnig";
}[];

type DiffItem = {
  beforeFileName: string;
  afterFileName: string;
  hunks: {
    header: {
      beforeStartLine: number;
      beforeLines: number;
      afterStartLine: number;
      afterLines: number;
    };
    lines: {
      text: string;
      mark: "nomodified" | "add" | "delete";
    }[];
  }[];
};

type DiffType = DiffItem[];

export const main = async (denops: Denops): Promise<void> => {
  denops.dispatcher = {
    fmt: () => {
      return bufDenoFmt();
    },
  };

  const bufDenoFmt = async () => {
    const lspList =
      (await fn.call(denops, "CocAction", ["services"])) as CocActionResult;
    const isRunningDenoLs = lspList.some((lsp) => lsp.id === "deno");

    console.log("start");
    if (!isRunningDenoLs) {
      return;
    }

    const curpos = await fn.getcurpos(denops);
    const bufnr = await fn.bufnr(denops, "%");

    const currentLines = (await denops.call(
      "getbufline",
      bufnr,
      1,
      "$",
    )) as string[];

    const cc = currentLines.join("\n");
    const fc = await execDenoFmt(cc);
    if (fc.stderr !== "") {
      console.log(`stderr ${fc.stderr}`);
      return;
    }

    const diff = await execDiff(cc, fc.stdout.trim());
    if (diff == null || diff.stdout == "" || diff.stderr !== "") {
      return;
    }
    console.log(`diff: ${diff.stdout}`)

    const pDiff = parse(diff.stdout) as DiffType;
    if (pDiff == null || pDiff.length == 0) {
      return;
    }
    console.log(`pdff: ${JSON.stringify(pDiff)}`)

    let promises: Promise<unknown>[] = [];

    const edited = {
      deleted: 0,
      added: 0,
    };

    for (const hunk of pDiff[0].hunks) {
      let lpos = hunk.header.beforeStartLine - edited.deleted + edited.added;

      for (let i = 0; i < hunk.header.beforeLines; i++) {
        if (hunk.lines[i].mark === "delete") {
          console.log(`del :${lpos}`);
          promises = [...promises, fn.deletebufline(denops, bufnr, lpos)];
          edited.deleted += 1;
        } else if (hunk.lines[i].mark === "nomodified") {
          lpos += 1;
        } else if (hunk.lines[i].mark === "add") {
          console.log(`add :${lpos - 1}`);
          promises = [
            ...promises,
            fn.appendbufline(denops, bufnr, lpos - 1, hunk.lines[i].text),
          ];
          edited.added += 1;
          lpos += 1;
        }
      }
    }

    await batch.collect(denops, () => promises);
    await fn.setpos(denops, ".", curpos);
  };
};

const execDiff = async (a: string, b: string) => {
  const diffCmd = [
    "diff",
    "-u",
    `<(echo '${escape(a)}')`,
    `<(echo '${escape(b)}')`,
  ];
  return await execPipedCmd(diffCmd.join(" "));
};

const execDenoFmt = async (content: string) => {
  const fmtCmd = [
    "echo",
    "-n",
    `'${escape(escape(content))}'`,
    "|",
    "deno",
    "fmt",
    "-",
  ];
  Deno.writeTextFile("a", fmtCmd.join(" "));

  return await execPipedCmd(fmtCmd.join(" "));
};

const escape = (text: string): string => {
  return text.replace(/'/g, "''").replace(/\\/g, "\\\\\\\\");
};