refactor: rename to DetailUnit

Author: lambdalisue

action.ts

@@ -1,7 +1,7 @@
 import type { Denops } from "@denops/std";
 
 import type { Promish } from "./_typeutil.ts";
-import type { Detail, IdItem, UnitDetail } from "./item.ts";
+import type { Detail, DetailUnit, IdItem } from "./item.ts";
 
 /**
  * Parameters for invoking an action.
@@ -28,7 +28,7 @@ export type InvokeParams<T extends Detail> = {
 /**
  * An action that can be invoked from the picker.
  */
-export type Action<T extends Detail = UnitDetail> = {
+export type Action<T extends Detail = DetailUnit> = {
   /**
    * Invoke the action.
    *

action_test.ts

@@ -1,13 +1,13 @@
 import { assertType, type IsExact } from "@std/testing/types";
 import { DenopsStub } from "@denops/test/stub";
-import type { Detail, UnitDetail } from "./item.ts";
+import type { Detail, DetailUnit } from "./item.ts";
 import type { Action, InvokeParams } from "./action.ts";
 
 Deno.test("Action", async (t) => {
   const denops = new DenopsStub();
 
   await t.step("without type constraint is equal to UnitDetail", () => {
-    assertType<IsExact<Action, Action<UnitDetail>>>(true);
+    assertType<IsExact<Action, Action<DetailUnit>>>(true);
   });
 
   await t.step("invoke follows the type constraint", () => {
@@ -19,6 +19,6 @@ Deno.test("Action", async (t) => {
     // @ts-expect-error: 'a' is missing
     action.invoke(denops, {} as InvokeParams<Detail>, {});
     // @ts-expect-error: 'a' is missing
-    action.invoke(denops, {} as InvokeParams<UnitDetail>, {});
+    action.invoke(denops, {} as InvokeParams<DetailUnit>, {});
   });
 });

item.ts

@@ -6,7 +6,7 @@ export type Detail = Record<PropertyKey, unknown>;
 /**
  * An unit of Detail.
  */
-export type UnitDetail = Record<never, never>;
+export type DetailUnit = Record<never, never>;
 
 /**
  * An item processed by the picker.

item_test.ts

@@ -1,5 +1,5 @@
 import { assertType, type IsExact } from "@std/testing/types";
-import type { Detail, UnitDetail } from "./item.ts";
+import type { Detail, DetailUnit } from "./item.ts";
 
 Deno.test("Detail", async (t) => {
   await t.step("is usable as a type constraint", () => {
@@ -30,9 +30,9 @@ Deno.test("Detail", async (t) => {
   });
 });
 
-Deno.test("UnitDetail", async (t) => {
+Deno.test("DetailUnit", async (t) => {
   await t.step("is NOT usable as a type constraint", () => {
-    function constraint<T extends UnitDetail>(_: T) {}
+    function constraint<T extends DetailUnit>(_: T) {}
     constraint({});
     constraint({ a: "" });
     constraint({ a: "", b: "" });
@@ -51,10 +51,10 @@ Deno.test("UnitDetail", async (t) => {
   });
 
   await t.step("is an unit of Detail", () => {
-    assertType<IsExact<UnitDetail & { a: string }, { a: string }>>(true);
+    assertType<IsExact<DetailUnit & { a: string }, { a: string }>>(true);
     // misc
-    assertType<IsExact<UnitDetail, UnitDetail>>(true);
-    assertType<IsExact<UnitDetail & UnitDetail, UnitDetail>>(true);
-    assertType<IsExact<UnitDetail & Detail, Detail>>(true);
+    assertType<IsExact<DetailUnit, DetailUnit>>(true);
+    assertType<IsExact<DetailUnit & DetailUnit, DetailUnit>>(true);
+    assertType<IsExact<DetailUnit & Detail, Detail>>(true);
   });
 });

matcher.ts

@@ -1,6 +1,6 @@
 import type { Denops } from "@denops/std";
 
-import type { Detail, IdItem, UnitDetail } from "./item.ts";
+import type { Detail, DetailUnit, IdItem } from "./item.ts";
 
 /**
  * Parameters for matching items.
@@ -19,7 +19,7 @@ export type MatchParams<T extends Detail> = {
 /**
  * Matcher that filters items based on user input.
  */
-export type Matcher<T extends Detail = UnitDetail> = {
+export type Matcher<T extends Detail = DetailUnit> = {
   __phantom?: (_: T) => void; // This is required for type constraint.
 
   /**

matcher_test.ts

@@ -1,13 +1,13 @@
 import { assertType, type IsExact } from "@std/testing/types";
 import { DenopsStub } from "@denops/test/stub";
-import type { UnitDetail } from "./item.ts";
+import type { DetailUnit } from "./item.ts";
 import type { Matcher, MatchParams } from "./matcher.ts";
 
 Deno.test("Matcher", async (t) => {
   const denops = new DenopsStub();
 
   await t.step("without type constraint is equal to UnitDetail", () => {
-    assertType<IsExact<Matcher, Matcher<UnitDetail>>>(true);
+    assertType<IsExact<Matcher, Matcher<DetailUnit>>>(true);
   });
 
   await t.step("match follows the type constraint", () => {
@@ -19,6 +19,6 @@ Deno.test("Matcher", async (t) => {
     // @ts-expect-error: 'a' is missing
     matcher.match(denops, {} as MatchParams<Detail>, {});
     // @ts-expect-error: 'a' is missing
-    matcher.match(denops, {} as MatchParams<UnitDetail>, {});
+    matcher.match(denops, {} as MatchParams<DetailUnit>, {});
   });
 });

previewer.ts

@@ -1,6 +1,6 @@
 import type { Denops } from "@denops/std";
 import type { Promish } from "./_typeutil.ts";
-import type { Detail, IdItem, PreviewItem, UnitDetail } from "./item.ts";
+import type { Detail, DetailUnit, IdItem, PreviewItem } from "./item.ts";
 
 /**
  * Parameters for previewing an item.
@@ -15,7 +15,7 @@ export type PreviewParams<T extends Detail> = {
 /**
  * Previewer that generates a preview for an item.
  */
-export type Previewer<T extends Detail = UnitDetail> = {
+export type Previewer<T extends Detail = DetailUnit> = {
   /**
    * Generates a preview for the specified item.
    *

previewer_test.ts

@@ -1,13 +1,13 @@
 import { assertType, type IsExact } from "@std/testing/types";
 import { DenopsStub } from "@denops/test/stub";
-import type { UnitDetail } from "./item.ts";
+import type { DetailUnit } from "./item.ts";
 import type { Previewer, PreviewParams } from "./previewer.ts";
 
 Deno.test("Previewer", async (t) => {
   const denops = new DenopsStub();
 
   await t.step("without type constraint is equal to UnitDetail", () => {
-    assertType<IsExact<Previewer, Previewer<UnitDetail>>>(true);
+    assertType<IsExact<Previewer, Previewer<DetailUnit>>>(true);
   });
 
   await t.step("preview follows the type constraint", () => {
@@ -23,6 +23,6 @@ Deno.test("Previewer", async (t) => {
     // @ts-expect-error: 'a' is missing
     previewer.preview(denops, {} as PreviewParams<Detail>, {});
     // @ts-expect-error: 'a' is missing
-    previewer.preview(denops, {} as PreviewParams<UnitDetail>, {});
+    previewer.preview(denops, {} as PreviewParams<DetailUnit>, {});
   });
 });

renderer.ts

@@ -1,6 +1,6 @@
 import type { Denops } from "@denops/std";
 import type { Promish } from "./_typeutil.ts";
-import type { Detail, DisplayItem, UnitDetail } from "./item.ts";
+import type { Detail, DetailUnit, DisplayItem } from "./item.ts";
 
 /**
  * Parameters for rendering items.
@@ -15,7 +15,7 @@ export type RenderParams<T extends Detail> = {
 /**
  * Renderer responsible for rendering items.
  */
-export type Renderer<T extends Detail = UnitDetail> = {
+export type Renderer<T extends Detail = DetailUnit> = {
   /**
    * Renders items in place.
    *

renderer_test.ts

@@ -1,13 +1,13 @@
 import { assertType, type IsExact } from "@std/testing/types";
 import { DenopsStub } from "@denops/test/stub";
-import type { UnitDetail } from "./item.ts";
+import type { DetailUnit } from "./item.ts";
 import type { Renderer, RenderParams } from "./renderer.ts";
 
 Deno.test("Renderer", async (t) => {
   const denops = new DenopsStub();
 
   await t.step("without type constraint is equal to UnitDetail", () => {
-    assertType<IsExact<Renderer, Renderer<UnitDetail>>>(true);
+    assertType<IsExact<Renderer, Renderer<DetailUnit>>>(true);
   });
 
   await t.step("render follows the type constraint", () => {
@@ -19,6 +19,6 @@ Deno.test("Renderer", async (t) => {
     // @ts-expect-error: 'a' is missing
     renderer.render(denops, {} as RenderParams<Detail>, {});
     // @ts-expect-error: 'a' is missing
-    renderer.render(denops, {} as RenderParams<UnitDetail>, {});
+    renderer.render(denops, {} as RenderParams<DetailUnit>, {});
   });
 });

sorter.ts

@@ -1,6 +1,6 @@
 import type { Denops } from "@denops/std";
 import type { Promish } from "./_typeutil.ts";
-import type { Detail, IdItem, UnitDetail } from "./item.ts";
+import type { Detail, DetailUnit, IdItem } from "./item.ts";
 
 /**
  * Parameters for sorting items.
@@ -15,7 +15,7 @@ export type SortParams<T extends Detail> = {
 /**
  * Sorter that arranges items in order.
  */
-export type Sorter<T extends Detail = UnitDetail> = {
+export type Sorter<T extends Detail = DetailUnit> = {
   /**
    * Sorts items in place.
    *

sorter_test.ts

@@ -1,13 +1,13 @@
 import { assertType, type IsExact } from "@std/testing/types";
 import { DenopsStub } from "@denops/test/stub";
-import type { UnitDetail } from "./item.ts";
+import type { DetailUnit } from "./item.ts";
 import type { Sorter, SortParams } from "./sorter.ts";
 
 Deno.test("Sorter", async (t) => {
   const denops = new DenopsStub();
 
   await t.step("without type constraint is equal to UnitDetail", () => {
-    assertType<IsExact<Sorter, Sorter<UnitDetail>>>(true);
+    assertType<IsExact<Sorter, Sorter<DetailUnit>>>(true);
   });
 
   await t.step("sort follows the type constraint", () => {
@@ -19,6 +19,6 @@ Deno.test("Sorter", async (t) => {
     // @ts-expect-error: 'a' is missing
     sorter.sort(denops, {} as SortParams<Detail>, {});
     // @ts-expect-error: 'a' is missing
-    sorter.sort(denops, {} as SortParams<UnitDetail>, {});
+    sorter.sort(denops, {} as SortParams<DetailUnit>, {});
   });
 });