Merge pull request #83 from vim-denops/imp-mapping

👍 Support array `mode` for `map()` and `unmap()` in `mapping` module

Author: lambdalisue

denops_std/mapping/README.md

@@ -22,6 +22,19 @@ export async function main(denops: Denops): Promise<void> {
 }
 ```
 
+Users can specify multiple `mode` value like:
+
+```typescript
+import { Denops } from "https://deno.land/x/denops_std/mod.ts";
+import * as mapping from "https://deno.land/x/denops_std/mapping/mod.ts";
+
+export async function main(denops: Denops): Promise<void> {
+  await mapping.map(denops, "<Plug>(test-denops-std)", "Hello", {
+    mode: ["n", "i", "x"],
+  });
+}
+```
+
 ### unmap
 
 Use `unmap()` to unregister a mapping like:
@@ -43,6 +56,23 @@ export async function main(denops: Denops): Promise<void> {
 }
 ```
 
+Users can specify multiple `mode` value like:
+
+```typescript
+import { Denops } from "https://deno.land/x/denops_std/mod.ts";
+import * as mapping from "https://deno.land/x/denops_std/mapping/mod.ts";
+
+export async function main(denops: Denops): Promise<void> {
+  await mapping.map(denops, "<Plug>(test-denops-std)", "Hello", {
+    mode: ["n", "i", "x"],
+  });
+
+  await mapping.unmap(denops, "<Plug>(test-denops-std)", {
+    mode: ["n", "i", "x"],
+  });
+}
+```
+
 ### read
 
 Use `read()` to read a mapping like:

denops_std/mapping/mod.ts

@@ -1,10 +1,11 @@
 import { Denops } from "../deps.ts";
 import * as fn from "../function/mod.ts";
+import * as batch from "../batch/mod.ts";
 import { Mapping, Mode } from "./types.ts";
 import { parse } from "./parser.ts";
 
 export type MapOptions = {
-  mode?: Mode;
+  mode?: Mode | Mode[];
   noremap?: boolean;
   script?: boolean;
   buffer?: boolean;
@@ -23,7 +24,7 @@ export async function map(
   rhs: string,
   options: MapOptions = {},
 ): Promise<void> {
-  const mode = options.mode ?? "";
+  const modes = forceArray(options.mode ?? "");
   const prefix = options.noremap ? "nore" : "";
   const arg = [
     options.buffer ? "<buffer>" : "",
@@ -33,11 +34,15 @@ export async function map(
     options.expr ? "<expr>" : "",
     options.unique ? "<unique>" : "",
   ].filter((v) => v).join("");
-  await denops.cmd(`${mode}${prefix}map ${arg} ${lhs} ${rhs}`);
+  await batch.batch(denops, async (denops) => {
+    for (const mode of modes) {
+      await denops.cmd(`${mode}${prefix}map ${arg} ${lhs} ${rhs}`);
+    }
+  });
 }
 
 export type UnmapOptions = {
-  mode?: Mode;
+  mode?: Mode | Mode[];
 };
 
 /**
@@ -48,8 +53,12 @@ export async function unmap(
   lhs: string,
   options: UnmapOptions = {},
 ): Promise<void> {
-  const mode = options.mode ?? "";
-  await denops.cmd(`${mode}unmap ${lhs}`);
+  const modes = forceArray(options.mode ?? "");
+  await batch.batch(denops, async (denops) => {
+    for (const mode of modes) {
+      await denops.cmd(`${mode}unmap ${lhs}`);
+    }
+  });
 }
 
 export type ReadOptions = {
@@ -109,3 +118,7 @@ export async function list(
   const result = await fn.execute(denops, `${mode}map ${lhs}`) as string;
   return result.split(/\r?\n/).filter((v) => v).map(parse);
 }
+
+function forceArray<T>(v: T | T[]): T[] {
+  return Array.isArray(v) ? v : [v];
+}

denops_std/mapping/mod_test.ts

@@ -66,6 +66,58 @@ for (const mode of modes) {
     },
   });
 }
+test({
+  mode: "all",
+  name: `map() registers multiple mappings (Xmap)`,
+  fn: async (denops) => {
+    const modes: Mode[] = ["n", "i", "x"];
+    await mapping.map(denops, "<Plug>(test-denops-std)", "Hello", {
+      mode: modes,
+    });
+    for (const mode of modes) {
+      assertEquals(
+        {
+          ...await mapping.read(denops, "<Plug>(test-denops-std)", { mode }),
+          sid: 0,
+          lnum: 0,
+        },
+        {
+          ...skeleton,
+          mode,
+          lhs: "<Plug>(test-denops-std)",
+          rhs: "Hello",
+        },
+      );
+    }
+  },
+});
+test({
+  mode: "all",
+  name: `map() registers mapping (Xnoremap)`,
+  fn: async (denops) => {
+    const modes: Mode[] = ["n", "i", "x"];
+    await mapping.map(denops, "<Plug>(test-denops-std)", "Hello", {
+      mode: modes,
+      noremap: true,
+    });
+    for (const mode of modes) {
+      assertEquals(
+        {
+          ...await mapping.read(denops, "<Plug>(test-denops-std)", { mode }),
+          sid: 0,
+          lnum: 0,
+        },
+        {
+          ...skeleton,
+          mode,
+          lhs: "<Plug>(test-denops-std)",
+          rhs: "Hello",
+          noremap: true,
+        },
+      );
+    }
+  },
+});
 test({
   mode: "all",
   name: `map() registers mapping (script)`,
@@ -235,6 +287,29 @@ for (const mode of modes) {
     prelude: ["let g:denops#enable_workaround_vim_before_8_2_3081 = 1"],
   });
 }
+test({
+  mode: "all",
+  name: `unmap() removes multiple mappings (Xunmap)`,
+  fn: async (denops) => {
+    const modes: Mode[] = ["n", "i", "x"];
+    await mapping.map(denops, "<Plug>(test-denops-std)", "Hello", {
+      mode: modes,
+    });
+    await mapping.unmap(denops, "<Plug>(test-denops-std)", {
+      mode: modes,
+    });
+    for (const mode of modes) {
+      await assertThrowsAsync(
+        async () => {
+          await mapping.read(denops, "<Plug>(test-denops-std)", { mode });
+        },
+        undefined,
+        "No mapping found for",
+      );
+    }
+  },
+  prelude: ["let g:denops#enable_workaround_vim_before_8_2_3081 = 1"],
+});
 
 for (const mode of modes) {
   test({