Merge pull request #2 from vim-fall/fix-types

lambdalisue · web-flow · commit 933a8339e585 · 2024-11-10T03:36:44.000+09:00
Fix types
diff --git a/action_test.ts b/action_test.ts
@@ -0,0 +1,53 @@
+import { assertType, type IsExact } from "@std/testing/types";
+import { DenopsStub } from "@denops/test/stub";
+import type { Promish } from "./_typeutil.ts";
+import type { Action, InvokeParams } from "./action.ts";
+
+Deno.test("Action", async (t) => {
+  const denops = new DenopsStub();
+  const action: Action<{ a: string }> = {
+    invoke: () => {},
+  };
+  await t.step("passed type is equal to the type restriction", () => {
+    const items = action.invoke(
+      denops,
+      {} as InvokeParams<{ a: string }>,
+      {},
+    );
+    assertType<
+      IsExact<
+        typeof items,
+        Promish<void | true>
+      >
+    >(true);
+  });
+
+  await t.step("passed type establishes the type restriction", () => {
+    const items = action.invoke(
+      denops,
+      {} as InvokeParams<{ a: string; b: string }>,
+      {},
+    );
+    assertType<
+      IsExact<
+        typeof items,
+        Promish<void | true>
+      >
+    >(true);
+  });
+
+  await t.step("passed type does not establish the type restriction", () => {
+    const items = action.invoke(
+      denops,
+      // @ts-expect-error: 'a' is missing
+      {} as InvokeParams<{ b: string }>,
+      {},
+    );
+    assertType<
+      IsExact<
+        typeof items,
+        Promish<void | true>
+      >
+    >(true);
+  });
+});
diff --git a/curator_test.ts b/curator_test.ts
@@ -0,0 +1,22 @@
+import { assertType, type IsExact } from "@std/testing/types";
+import { DenopsStub } from "@denops/test/stub";
+import type { IdItem } from "./item.ts";
+import type { CurateParams, Curator } from "./curator.ts";
+
+Deno.test("Curator", () => {
+  const denops = new DenopsStub();
+  const curator: Curator<{ a: string }> = {
+    curate: async function* () {},
+  };
+  const items = curator.curate(
+    denops,
+    {} as CurateParams,
+    {},
+  );
+  assertType<
+    IsExact<
+      typeof items,
+      AsyncIterableIterator<IdItem<{ a: string }>>
+    >
+  >(true);
+});
diff --git a/deno.jsonc b/deno.jsonc
@@ -9,7 +9,6 @@
     "./item": "./item.ts",
     "./matcher": "./matcher.ts",
     "./previewer": "./previewer.ts",
-    "./projector": "./projector.ts",
     "./renderer": "./renderer.ts",
     "./sorter": "./sorter.ts",
     "./source": "./source.ts",
@@ -29,11 +28,15 @@
   "tasks": {
     "check": "deno check ./**/*.ts",
     "test": "deno test -A --parallel --shuffle --doc",
+    "test:coverage": "deno task test --coverage=.coverage",
+    "coverage": "deno coverage .coverage --exclude=testdata/",
     "update": "deno run --allow-env --allow-read --allow-write=. --allow-run=git,deno --allow-net=deno.land,jsr.io,registry.npmjs.org jsr:@molt/cli ./**/*.ts",
     "update:write": "deno task -q update --write",
     "update:commit": "deno task -q update --commit --prefix :package: --pre-commit=fmt,lint"
   },
   "imports": {
-    "@denops/std": "jsr:@denops/std@^7.3.0"
+    "@denops/std": "jsr:@denops/std@^7.3.0",
+    "@denops/test": "jsr:@denops/test@^3.0.4",
+    "@std/testing": "jsr:@std/testing@^1.0.4"
   }
 }
diff --git a/matcher.ts b/matcher.ts
@@ -27,9 +27,12 @@ export type Matcher<T> = {
    * @param options - Additional options, including an abort signal.
    * @returns An async iterator over matched `IdItem` elements.
    */
-  match(
+  match<
+    M extends MatchParams<T>,
+    V extends M extends MatchParams<infer V> ? V : never,
+  >(
     denops: Denops,
-    params: MatchParams<T>,
+    params: M,
     options: { signal?: AbortSignal },
-  ): AsyncIterableIterator<IdItem<T>>;
+  ): AsyncIterableIterator<IdItem<V>>;
 };
diff --git a/matcher_test.ts b/matcher_test.ts
@@ -0,0 +1,54 @@
+import { assertType, type IsExact } from "@std/testing/types";
+import { DenopsStub } from "@denops/test/stub";
+import type { IdItem } from "./item.ts";
+import type { Matcher, MatchParams } from "./matcher.ts";
+
+Deno.test("Matcher", async (t) => {
+  const denops = new DenopsStub();
+  const matcher: Matcher<{ a: string }> = {
+    match: async function* () {},
+  };
+
+  await t.step("passed type is equal to the type restriction", () => {
+    const items = matcher.match(
+      denops,
+      {} as MatchParams<{ a: string }>,
+      {},
+    );
+    assertType<
+      IsExact<
+        typeof items,
+        AsyncIterableIterator<IdItem<{ a: string }>>
+      >
+    >(true);
+  });
+
+  await t.step("passed type establishes the type restriction", () => {
+    const items = matcher.match(
+      denops,
+      {} as MatchParams<{ a: string; b: string }>,
+      {},
+    );
+    assertType<
+      IsExact<
+        typeof items,
+        AsyncIterableIterator<IdItem<{ a: string; b: string }>>
+      >
+    >(true);
+  });
+
+  await t.step("passed type does not establish the type restriction", () => {
+    const items = matcher.match(
+      denops,
+      // @ts-expect-error: 'a' is missing
+      {} as MatchParams<{ b: string }>,
+      {},
+    );
+    assertType<
+      IsExact<
+        typeof items,
+        AsyncIterableIterator<IdItem<{ a: string }>>
+      >
+    >(true);
+  });
+});
diff --git a/mod.ts b/mod.ts
@@ -15,7 +15,6 @@ export * from "./curator.ts";
 export * from "./item.ts";
 export * from "./matcher.ts";
 export * from "./previewer.ts";
-export * from "./projector.ts";
 export * from "./renderer.ts";
 export * from "./sorter.ts";
 export * from "./source.ts";
diff --git a/previewer_test.ts b/previewer_test.ts
@@ -0,0 +1,55 @@
+import { assertType, type IsExact } from "@std/testing/types";
+import { DenopsStub } from "@denops/test/stub";
+import type { Promish } from "./_typeutil.ts";
+import type { PreviewItem } from "./item.ts";
+import type { Previewer, PreviewParams } from "./previewer.ts";
+
+Deno.test("Previewer", async (t) => {
+  const denops = new DenopsStub();
+  const previewer: Previewer<{ a: string }> = {
+    preview: () => {},
+  };
+
+  await t.step("passed type is equal to the type restriction", () => {
+    const items = previewer.preview(
+      denops,
+      {} as PreviewParams<{ a: string }>,
+      {},
+    );
+    assertType<
+      IsExact<
+        typeof items,
+        Promish<void | PreviewItem>
+      >
+    >(true);
+  });
+
+  await t.step("passed type establishes the type restriction", () => {
+    const items = previewer.preview(
+      denops,
+      {} as PreviewParams<{ a: string; b: string }>,
+      {},
+    );
+    assertType<
+      IsExact<
+        typeof items,
+        Promish<void | PreviewItem>
+      >
+    >(true);
+  });
+
+  await t.step("passed type does not establish the type restriction", () => {
+    const items = previewer.preview(
+      denops,
+      // @ts-expect-error: 'a' is missing
+      {} as PreviewParams<{ b: string }>,
+      {},
+    );
+    assertType<
+      IsExact<
+        typeof items,
+        Promish<void | PreviewItem>
+      >
+    >(true);
+  });
+});
diff --git a/projector.ts b/projector.ts
diff --git a/renderer_test.ts b/renderer_test.ts
@@ -0,0 +1,54 @@
+import { assertType, type IsExact } from "@std/testing/types";
+import { DenopsStub } from "@denops/test/stub";
+import type { Promish } from "./_typeutil.ts";
+import type { Renderer, RenderParams } from "./renderer.ts";
+
+Deno.test("Renderer", async (t) => {
+  const denops = new DenopsStub();
+  const renderer: Renderer<{ a: string }> = {
+    render: () => {},
+  };
+
+  await t.step("passed type is equal to the type restriction", () => {
+    const items = renderer.render(
+      denops,
+      {} as RenderParams<{ a: string }>,
+      {},
+    );
+    assertType<
+      IsExact<
+        typeof items,
+        Promish<void>
+      >
+    >(true);
+  });
+
+  await t.step("passed type establishes the type restriction", () => {
+    const items = renderer.render(
+      denops,
+      {} as RenderParams<{ a: string; b: string }>,
+      {},
+    );
+    assertType<
+      IsExact<
+        typeof items,
+        Promish<void>
+      >
+    >(true);
+  });
+
+  await t.step("passed type does not establish the type restriction", () => {
+    const items = renderer.render(
+      denops,
+      // @ts-expect-error: 'a' is missing
+      {} as RenderParams<{ b: string }>,
+      {},
+    );
+    assertType<
+      IsExact<
+        typeof items,
+        Promish<void>
+      >
+    >(true);
+  });
+});
diff --git a/sorter_test.ts b/sorter_test.ts
@@ -0,0 +1,54 @@
+import { assertType, type IsExact } from "@std/testing/types";
+import { DenopsStub } from "@denops/test/stub";
+import type { Promish } from "./_typeutil.ts";
+import type { Sorter, SortParams } from "./sorter.ts";
+
+Deno.test("Sorter", async (t) => {
+  const denops = new DenopsStub();
+  const sorter: Sorter<{ a: string }> = {
+    sort: () => {},
+  };
+
+  await t.step("passed type is equal to the type restriction", () => {
+    const items = sorter.sort(
+      denops,
+      {} as SortParams<{ a: string }>,
+      {},
+    );
+    assertType<
+      IsExact<
+        typeof items,
+        Promish<void>
+      >
+    >(true);
+  });
+
+  await t.step("passed type establishes the type restriction", () => {
+    const items = sorter.sort(
+      denops,
+      {} as SortParams<{ a: string; b: string }>,
+      {},
+    );
+    assertType<
+      IsExact<
+        typeof items,
+        Promish<void>
+      >
+    >(true);
+  });
+
+  await t.step("passed type does not establish the type restriction", () => {
+    const items = sorter.sort(
+      denops,
+      // @ts-expect-error: 'a' is missing
+      {} as SortParams<{ b: string }>,
+      {},
+    );
+    assertType<
+      IsExact<
+        typeof items,
+        Promish<void>
+      >
+    >(true);
+  });
+});
diff --git a/source_test.ts b/source_test.ts
