feat: Add more compose function and tests

Author: lambdalisue

action.ts

@@ -2,6 +2,7 @@ import type { Denops } from "@denops/std";
 import type { Action, InvokeParams } from "@vim-fall/core/action";
 
 import type { Promish } from "./util/_typeutil.ts";
+import { type DerivableArray, deriveArray } from "./util/derivable.ts";
 
 /**
  * Define an action.
@@ -21,4 +22,25 @@ export function defineAction<T>(
   };
 }
 
+/**
+ * Compose multiple actions.
+ *
+ * The actions are invoked in the order they are passed.
+ *
+ * @param actions The actions to compose.
+ * @returns The composed action.
+ */
+export function composeActions<
+  T,
+  A extends DerivableArray<[Action<T>, ...Action<T>[]]>,
+>(...actions: A): Action<T> {
+  return {
+    invoke: async (denops, params, options) => {
+      for (const action of deriveArray(actions)) {
+        await action.invoke(denops, params, options);
+      }
+    },
+  };
+}
+
 export type * from "@vim-fall/core/action";

action_test.ts

@@ -0,0 +1,32 @@
+import { assertEquals } from "@std/assert";
+import { assertType, type IsExact } from "@std/testing/types";
+import { DenopsStub } from "@denops/test/stub";
+import { type Action, composeActions, defineAction } from "./action.ts";
+
+Deno.test("defineAction", () => {
+  const action = defineAction(async () => {});
+  assertEquals(typeof action.invoke, "function");
+  assertType<IsExact<typeof action, Action<unknown>>>(true);
+});
+
+Deno.test("composeActions", async () => {
+  const results: string[] = [];
+  const action1 = defineAction(() => {
+    results.push("action1");
+  });
+  const action2 = defineAction(() => {
+    results.push("action2");
+  });
+  const action3 = defineAction(() => {
+    results.push("action3");
+  });
+  const action = composeActions(action2, action1, action3);
+  const denops = new DenopsStub();
+  const params = {
+    item: undefined,
+    selectedItems: [],
+    filteredItems: [],
+  };
+  await action.invoke(denops, params, {});
+  assertEquals(results, ["action2", "action1", "action3"]);
+});

curator_test.ts

@@ -0,0 +1,9 @@
+import { assertEquals } from "@std/assert";
+import { assertType, type IsExact } from "@std/testing/types";
+import { type Curator, defineCurator } from "./curator.ts";
+
+Deno.test("defineCurator", () => {
+  const curator = defineCurator(async function* () {});
+  assertEquals(typeof curator.curate, "function");
+  assertType<IsExact<typeof curator, Curator<unknown>>>(true);
+});

deno.jsonc

@@ -115,12 +115,14 @@
     "@core/errorutil": "jsr:@core/errorutil@^1.2.0",
     "@core/iterutil": "jsr:@core/iterutil@^0.9.0",
     "@denops/std": "jsr:@denops/std@^7.3.0",
+    "@denops/test": "jsr:@denops/test@^3.0.4",
     "@lambdalisue/systemopen": "jsr:@lambdalisue/systemopen@^1.0.0",
     "@std/assert": "jsr:@std/assert@^1.0.7",
     "@std/fs": "jsr:@std/fs@^1.0.5",
     "@std/jsonc": "jsr:@std/jsonc@^1.0.1",
     "@std/path": "jsr:@std/path@^1.0.8",
     "@std/streams": "jsr:@std/streams@^1.0.8",
+    "@std/testing": "jsr:@std/testing@^1.0.4",
     "@vim-fall/core": "jsr:@vim-fall/core@^0.1.0-pre.0",
     "fzf": "npm:fzf@^0.5.2"
   }

matcher.ts

@@ -2,6 +2,8 @@ import type { Denops } from "@denops/std";
 import type { IdItem } from "@vim-fall/core/item";
 import type { Matcher, MatchParams } from "@vim-fall/core/matcher";
 
+import { type DerivableArray, deriveArray } from "./util/derivable.ts";
+
 /**
  * Define a matcher.
  *
@@ -18,4 +20,28 @@ export function defineMatcher<T>(
   return { match };
 }
 
+/**
+ * Compose multiple matchers.
+ *
+ * The matchers are applied in the order they are passed.
+ *
+ * @param matchers The matchers to compose.
+ * @returns The composed matcher.
+ */
+export function composeMatchers<
+  T,
+  M extends DerivableArray<[Matcher<T>, ...Matcher<T>[]]>,
+>(...matchers: M): Matcher<T> {
+  return {
+    match: async function* (denops, { items, query }, options) {
+      for (const matcher of deriveArray(matchers)) {
+        items = await Array.fromAsync(
+          matcher.match(denops, { items, query }, options),
+        );
+      }
+      yield* items;
+    },
+  };
+}
+
 export type * from "@vim-fall/core/matcher";

matcher_test.ts

@@ -0,0 +1,46 @@
+import { assertEquals } from "@std/assert";
+import { assertType, type IsExact } from "@std/testing/types";
+import { DenopsStub } from "@denops/test/stub";
+import { composeMatchers, defineMatcher, type Matcher } from "./matcher.ts";
+
+Deno.test("defineMatcher", () => {
+  const matcher = defineMatcher(async function* () {});
+  assertEquals(typeof matcher.match, "function");
+  assertType<IsExact<typeof matcher, Matcher<unknown>>>(true);
+});
+
+Deno.test("composeMatchers", async () => {
+  const results: string[] = [];
+  const matcher1 = defineMatcher(async function* (_denops, { items }) {
+    results.push("matcher1");
+    yield* items.filter((item) => item.value.includes("1"));
+  });
+  const matcher2 = defineMatcher(async function* (_denops, { items }) {
+    results.push("matcher2");
+    yield* items.filter((item) => item.value.includes("2"));
+  });
+  const matcher3 = defineMatcher(async function* (_denops, { items }) {
+    results.push("matcher3");
+    yield* items.filter((item) => item.value.includes("3"));
+  });
+  const matcher = composeMatchers(matcher2, matcher1, matcher3);
+  const denops = new DenopsStub();
+  const params = {
+    query: "",
+    items: Array.from({ length: 1000 }).map((_, id) => ({
+      id,
+      value: id.toString(),
+      detail: undefined,
+    })),
+  };
+  const items = await Array.fromAsync(matcher.match(denops, params, {}));
+  assertEquals(results, ["matcher2", "matcher1", "matcher3"]);
+  assertEquals(items.map((item) => item.value), [
+    "123",
+    "132",
+    "213",
+    "231",
+    "312",
+    "321",
+  ]);
+});

previewer.ts

@@ -3,6 +3,7 @@ import type { PreviewItem } from "@vim-fall/core/item";
 import type { Previewer, PreviewParams } from "@vim-fall/core/previewer";
 
 import type { Promish } from "./util/_typeutil.ts";
+import { type DerivableArray, deriveArray } from "./util/derivable.ts";
 
 /**
  * Define a previewer.
@@ -20,4 +21,30 @@ export function definePreviewer<T>(
   return { preview };
 }
 
+/**
+ * Compose multiple previewers.
+ *
+ * The previewers are tried in the order they are passed.
+ * Once a previewer returns a non-`undefined` value, the previewing process is
+ * stopped.
+ *
+ * @param previewers The previewers to compose.
+ * @returns The composed previewer.
+ */
+export function composePreviewers<
+  T,
+  P extends DerivableArray<[Previewer<T>, ...Previewer<T>[]]>,
+>(...previewers: P): Previewer<T> {
+  return {
+    preview: async (denops, params, options) => {
+      for (const previewer of deriveArray(previewers)) {
+        const item = await previewer.preview(denops, params, options);
+        if (item) {
+          return item;
+        }
+      }
+    },
+  };
+}
+
 export type * from "@vim-fall/core/previewer";

previewer_test.ts

@@ -0,0 +1,43 @@
+import { assertEquals } from "@std/assert";
+import { assertType, type IsExact } from "@std/testing/types";
+import { DenopsStub } from "@denops/test/stub";
+import {
+  composePreviewers,
+  definePreviewer,
+  type Previewer,
+} from "./previewer.ts";
+
+Deno.test("definePreviewer", () => {
+  const previewer = definePreviewer(async () => {});
+  assertEquals(typeof previewer.preview, "function");
+  assertType<IsExact<typeof previewer, Previewer<unknown>>>(true);
+});
+
+Deno.test("composePreviewers", async () => {
+  const results: string[] = [];
+  const previewer1 = definePreviewer(() => {
+    results.push("previewer1");
+    return { content: ["Hello world"] };
+  });
+  const previewer2 = definePreviewer(() => {
+    results.push("previewer2");
+  });
+  const previewer3 = definePreviewer(() => {
+    results.push("previewer3");
+    return { content: ["Goodbye world"] };
+  });
+  const previewer = composePreviewers(previewer2, previewer1, previewer3);
+  const denops = new DenopsStub();
+  const params = {
+    item: {
+      id: 0,
+      value: "123",
+      detail: undefined,
+    },
+  };
+  const item = await previewer.preview(denops, params, {});
+  assertEquals(results, ["previewer2", "previewer1"]);
+  assertEquals(item, {
+    content: ["Hello world"],
+  });
+});

projector.ts

@@ -30,6 +30,8 @@ export function defineProjector<T, U = T>(
 
 /**
  * Compose multiple projectors.
+ *
+ * The projectors are applied in the order they are passed.
  */
 export function composeProjectors<
   T extends FirstType<P> extends Derivable<Projector<infer T, unknown>> ? T
@@ -59,6 +61,8 @@ export function composeProjectors<
 /**
  * Pipe projectors to a source or a curator.
  *
+ * The projectors are applied in the order they are passed.
+ *
  * @param source The source or curator.
  * @param projectors The projectors.
  * @returns The source or curator.