feat: follow IdItem changes

Author: lambdalisue

action.ts

@@ -1,6 +1,9 @@
+export type * from "@vim-fall/core/action";
+
 import type { Denops } from "@denops/std";
 import type { Action, InvokeParams } from "@vim-fall/core/action";
 
+import type { Detail, DetailUnit } from "./item.ts";
 import type { Promish } from "./util/_typeutil.ts";
 import { type DerivableArray, deriveArray } from "./util/derivable.ts";
 
@@ -10,16 +13,14 @@ import { type DerivableArray, deriveArray } from "./util/derivable.ts";
  * @param invoke - The function to invoke the action.
  * @returns The defined action.
  */
-export function defineAction<T>(
+export function defineAction<T extends Detail = DetailUnit>(
   invoke: (
     denops: Denops,
     params: InvokeParams<T>,
     options: { signal?: AbortSignal },
   ) => Promish<void | true>,
 ): Action<T> {
-  return {
-    invoke,
-  };
+  return { invoke };
 }
 
 /**
@@ -30,10 +31,9 @@ export function defineAction<T>(
  * @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> {
+export function composeActions<T extends Detail>(
+  ...actions: DerivableArray<[Action<T>, ...Action<T>[]]>
+): Action<T> {
   return {
     invoke: async (denops, params, options) => {
       for (const action of deriveArray(actions)) {
@@ -42,5 +42,3 @@ export function composeActions<
     },
   };
 }
-
-export type * from "@vim-fall/core/action";

action_test.ts

@@ -1,32 +1,99 @@
 import { assertEquals } from "@std/assert";
-import { assertType, type IsExact } from "@std/testing/types";
+import { type AssertTrue, assertType, type IsExact } from "@std/testing/types";
 import { DenopsStub } from "@denops/test/stub";
-import { type Action, composeActions, defineAction } from "./action.ts";
+import type { DetailUnit } from "./item.ts";
+import {
+  type Action,
+  composeActions,
+  defineAction,
+  type InvokeParams,
+} from "./action.ts";
 
-Deno.test("defineAction", () => {
-  const action = defineAction(async () => {});
-  assertEquals(typeof action.invoke, "function");
-  assertType<IsExact<typeof action, Action<unknown>>>(true);
-});
+Deno.test("defineAction", async (t) => {
+  await t.step("without type contraint", () => {
+    const action = defineAction((_denops, params) => {
+      type _ = AssertTrue<IsExact<typeof params, InvokeParams<DetailUnit>>>;
+    });
+    assertType<IsExact<typeof action, Action<DetailUnit>>>(true);
+  });
 
-Deno.test("composeActions", async () => {
-  const results: string[] = [];
-  const action1 = defineAction(() => {
-    results.push("action1");
+  await t.step("with type contraint", () => {
+    type C = { a: string };
+    const action = defineAction<C>((_denops, params) => {
+      type _ = AssertTrue<IsExact<typeof params, InvokeParams<C>>>;
+    });
+    assertType<IsExact<typeof action, Action<C>>>(true);
   });
-  const action2 = defineAction(() => {
-    results.push("action2");
+});
+
+Deno.test("composeActions", async (t) => {
+  await t.step("with bear actions", async (t) => {
+    await t.step("actions are invoked in order", async () => {
+      const results: string[] = [];
+      const action1 = defineAction(() => void results.push("action1"));
+      const action2 = defineAction(() => void results.push("action2"));
+      const action3 = defineAction(() => void 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"]);
+    });
+
+    await t.step("without type contraint", () => {
+      const action1 = defineAction(() => {});
+      const action2 = defineAction(() => {});
+      const action3 = defineAction(() => {});
+      const action = composeActions(action2, action1, action3);
+      assertType<IsExact<typeof action, Action<DetailUnit>>>(true);
+    });
+
+    await t.step("with type contraint", () => {
+      type C = { a: string };
+      const action1 = defineAction<C>(() => {});
+      const action2 = defineAction<C>(() => {});
+      const action3 = defineAction<C>(() => {});
+      const action = composeActions(action2, action1, action3);
+      assertType<IsExact<typeof action, Action<C>>>(true);
+    });
   });
-  const action3 = defineAction(() => {
-    results.push("action3");
+
+  await t.step("with derivable actions", async (t) => {
+    await t.step("actions are invoked in order", async () => {
+      const results: string[] = [];
+      const action1 = () => defineAction(() => void results.push("action1"));
+      const action2 = () => defineAction(() => void results.push("action2"));
+      const action3 = () => defineAction(() => void 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"]);
+    });
+
+    await t.step("without type contraint", () => {
+      const action1 = () => defineAction(() => {});
+      const action2 = () => defineAction(() => {});
+      const action3 = () => defineAction(() => {});
+      const action = composeActions(action2, action1, action3);
+      assertType<IsExact<typeof action, Action<DetailUnit>>>(true);
+    });
+
+    await t.step("with type contraint", () => {
+      type C = { a: string };
+      const action1 = () => defineAction<C>(() => {});
+      const action2 = () => defineAction<C>(() => {});
+      const action3 = () => defineAction<C>(() => {});
+      const action = composeActions(action2, action1, action3);
+      assertType<IsExact<typeof action, Action<C>>>(true);
+    });
   });
-  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"]);
 });

builtin/action/buffer.ts

@@ -8,12 +8,6 @@ type Detail = {
   path: string;
 };
 
-/**
- * Retrieves the appropriate attribute (either `bufname` or `path`) from the item's detail.
- *
- * @param item - The item containing either a `bufname` or a `path`.
- * @returns The `path` if present; otherwise, the `bufname`.
- */
 function attrGetter({ detail }: IdItem<Detail>): string {
   if ("path" in detail) {
     return detail.path;
@@ -22,9 +16,6 @@ function attrGetter({ detail }: IdItem<Detail>): string {
   }
 }
 
-/**
- * Unloads the buffer without deleting it.
- */
 export const bunload: Action<Detail> = cmd({
   attrGetter,
   immediate: true,
@@ -33,9 +24,6 @@ export const bunload: Action<Detail> = cmd({
   fnameescape: true,
 });
 
-/**
- * Deletes the buffer, removing it from the buffer list.
- */
 export const bdelete: Action<Detail> = cmd({
   attrGetter,
   immediate: true,
@@ -44,9 +32,6 @@ export const bdelete: Action<Detail> = cmd({
   fnameescape: true,
 });
 
-/**
- * Wipes out the buffer, clearing it from memory.
- */
 export const bwipeout: Action<Detail> = cmd({
   attrGetter,
   immediate: true,
@@ -55,9 +40,6 @@ export const bwipeout: Action<Detail> = cmd({
   fnameescape: true,
 });
 
-/**
- * Opens the buffer in a new tab, writes any changes, and then closes the tab.
- */
 export const write: Action<Detail> = cmd({
   attrGetter,
   immediate: true,
@@ -66,9 +48,6 @@ export const write: Action<Detail> = cmd({
   fnameescape: true,
 });
 
-/**
- * A collection of default actions for buffer management.
- */
 export const defaultBufferActions: {
   bunload: Action<Detail>;
   bdelete: Action<Detail>;

builtin/action/cmd.ts

@@ -3,12 +3,12 @@ import * as fn from "@denops/std/function";
 import { input } from "@denops/std/helper/input";
 import { dirname } from "@std/path/dirname";
 
-import type { IdItem } from "../../item.ts";
+import type { Detail, DetailUnit, IdItem } from "../../item.ts";
 import { type Action, defineAction } from "../../action.ts";
 
 type Restriction = "file" | "directory" | "directory-or-parent" | "buffer";
 
-type Options<T> = {
+export type CmdOptions<T extends Detail> = {
   /**
    * Function to retrieve the attribute from an item. Defaults to `item.value`.
    */
@@ -41,7 +41,9 @@ type Options<T> = {
  * @param options - Configuration options for the command execution.
  * @returns An action that executes the command.
  */
-export function cmd<T>(options: Options<T> = {}): Action<T> {
+export function cmd<T extends Detail = DetailUnit>(
+  options: CmdOptions<T> = {},
+): Action<T> {
   const attrGetter = options.attrGetter ?? ((item) => item.value);
   const immediate = options.immediate ?? false;
   const template = options.template ?? "{}";
@@ -152,7 +154,7 @@ async function execute(
  * Default command actions.
  */
 export const defaultCmdActions: {
-  cmd: Action<unknown>;
+  cmd: Action<DetailUnit>;
 } = {
   cmd: cmd(),
 };

builtin/action/echo.ts

@@ -7,7 +7,7 @@ import { type Action, defineAction } from "../../action.ts";
  *
  * @returns An action that logs the item.
  */
-export function echo<T>(): Action<T> {
+export function echo(): Action {
   return defineAction((_denops, { item }, _options) => {
     console.log(JSON.stringify(item, null, 2));
   });
@@ -17,7 +17,7 @@ export function echo<T>(): Action<T> {
  * Default action for echoing items to the console.
  */
 export const defaultEchoActions: {
-  echo: Action<unknown>;
+  echo: Action;
 } = {
   echo: echo(),
 };

builtin/action/noop.ts

@@ -7,15 +7,15 @@ import { type Action, defineAction } from "../../action.ts";
  *
  * @returns An action that does nothing.
  */
-export function noop<T>(): Action<T> {
+export function noop(): Action {
   return defineAction(() => {});
 }
 
 /**
  * Default action set containing the noop action.
  */
 export const defaultNoopActions: {
-  noop: Action<unknown>;
+  noop: Action;
 } = {
   noop: noop(),
 };