feat!: remove Projector and add Modifier and Filter

Author: lambdalisue

builtin/filter/cwd.ts

@@ -1,6 +1,6 @@
 import * as fn from "@denops/std/function";
 
-import { defineProjector, type Projector } from "../../projector.ts";
+import { defineFilter, type Filter } from "../../filter.ts";
 
 /**
  * Represents detailed information for each item, specifically the file path.
@@ -10,14 +10,14 @@ type Detail = {
 };
 
 /**
- * Creates a Projector that filters items based on the current working directory.
+ * Creates a Filter that filters items based on the current working directory.
  *
- * This Projector yields only those items whose `path` is within the current working directory.
+ * This Filter yields only those items whose `path` is within the current working directory.
  *
- * @returns A Projector that filters items according to the current working directory.
+ * @returns A Filter that filters items according to the current working directory.
  */
-export function cwd<T extends Detail>(): Projector<T> {
-  return defineProjector<T>(async function* (denops, { items }, { signal }) {
+export function cwd<T extends Detail>(): Filter<T> {
+  return defineFilter<T>(async function* (denops, { items }, { signal }) {
     // Retrieve the current working directory
     const cwd = await fn.getcwd(denops);
     signal?.throwIfAborted();

builtin/filter/exists.ts

@@ -1,6 +1,6 @@
 import { exists as exists_ } from "@std/fs/exists";
 
-import { defineProjector, type Projector } from "../../projector.ts";
+import { defineFilter, type Filter } from "../../filter.ts";
 
 /**
  * Represents detailed information for each item, specifically the file path.
@@ -10,15 +10,15 @@ type Detail = {
 };
 
 /**
- * Creates a Projector that filters items based on file existence.
+ * Creates a Filter that filters items based on file existence.
  *
- * This Projector checks each item's `path` and yields only those items
+ * This Filter checks each item's `path` and yields only those items
  * where the path exists in the filesystem.
  *
- * @returns A Projector that filters items according to file existence.
+ * @returns A Filter that filters items according to file existence.
  */
-export function exists(): Projector<Detail> {
-  return defineProjector(async function* (_denops, { items }, { signal }) {
+export function exists(): Filter<Detail> {
+  return defineFilter(async function* (_denops, { items }, { signal }) {
     // Check each item's path for existence and yield it if the file exists
     for await (const item of items) {
       if (await exists_(item.detail.path)) {

builtin/filter/noop.ts

@@ -1,13 +1,13 @@
-import { defineProjector, type Projector } from "../../projector.ts";
+import { defineFilter, type Filter } from "../../filter.ts";
 
 /**
- * A no-operation (noop) Projector.
+ * A no-operation (noop) Filter.
  *
- * This Projector does nothing and yields no items. It can be used as a placeholder
- * or a default value where a Projector is required but no action is needed.
+ * This Filter does nothing and yields no items. It can be used as a placeholder
+ * or a default value where a Filter is required but no action is needed.
  *
- * @returns A Projector that yields nothing.
+ * @returns A Filter that yields nothing.
  */
-export function noop<T>(): Projector<T> {
-  return defineProjector<T>(async function* () {});
+export function noop<T>(): Filter<T> {
+  return defineFilter<T>(async function* () {});
 }

builtin/filter/regexp.ts

@@ -1,4 +1,4 @@
-import { defineProjector, type Projector } from "../../projector.ts";
+import { defineFilter, type Filter } from "../../filter.ts";
 
 /**
  * Options for filtering items by regular expressions.
@@ -27,19 +27,19 @@ type Detail = {
 };
 
 /**
- * Creates a Projector that filters items based on regular expression patterns.
+ * Creates a Filter that filters items based on regular expression patterns.
  *
- * The `regexp` Projector filters items using `includes` and/or `excludes` patterns.
+ * The `regexp` Filter filters items using `includes` and/or `excludes` patterns.
  * - If `includes` patterns are provided, only items that match at least one pattern are yielded.
  * - If `excludes` patterns are provided, any item that matches at least one pattern is excluded.
  *
  * @param options - Filtering options specifying `includes` and/or `excludes` patterns.
- * @returns A Projector that yields items matching the specified patterns.
+ * @returns A Filter that yields items matching the specified patterns.
  */
 export function regexp<T extends Detail>(
   { includes, excludes }: Readonly<Options>,
-): Projector<T> {
-  return defineProjector<T>(async function* (_denops, { items }, { signal }) {
+): Filter<T> {
+  return defineFilter<T>(async function* (_denops, { items }, { signal }) {
     signal?.throwIfAborted();
 
     // Process each item and yield only those matching the filter conditions

builtin/modifier/mod.ts

@@ -1,3 +1,2 @@
 // This file is generated by gen-mod.ts
-export * from "./noop.ts";
 export * from "./relative_path.ts";

builtin/modifier/noop.ts

@@ -2,7 +2,7 @@ import * as fn from "@denops/std/function";
 import { relative } from "@std/path/relative";
 
 import type { IdItem } from "../../item.ts";
-import { defineProjector, type Projector } from "../../projector.ts";
+import { defineModifier, type Modifier } from "../../modifier.ts";
 
 /**
  * Represents item details with a file path.
@@ -30,8 +30,8 @@ type DetailAfter = {
 export function relativePath<
   T extends Detail,
   U extends T & DetailAfter,
->(): Projector<T, U> {
-  return defineProjector(async function* (denops, { items }, { signal }) {
+>(): Modifier<T, U> {
+  return defineModifier<T, U>(async function* (denops, { items }, { signal }) {
     // Get the current working directory
     const cwd = await fn.getcwd(denops);
     signal?.throwIfAborted();
@@ -50,7 +50,7 @@ export function relativePath<
           path: relpath,
           abspath: item.detail.path,
         },
-      } as IdItem<U>;
+      } as IdItem<T & U>;
     }
   });
 }

builtin/modifier/relative_path.ts

@@ -37,7 +37,6 @@
     "./builtin/matcher/regexp": "./builtin/matcher/regexp.ts",
     "./builtin/matcher/substring": "./builtin/matcher/substring.ts",
     "./builtin/modifier": "./builtin/modifier/mod.ts",
-    "./builtin/modifier/noop": "./builtin/modifier/noop.ts",
     "./builtin/modifier/relative-path": "./builtin/modifier/relative_path.ts",
     "./builtin/previewer": "./builtin/previewer/mod.ts",
     "./builtin/previewer/buffer": "./builtin/previewer/buffer.ts",
@@ -70,10 +69,11 @@
     "./config": "./config.ts",
     "./coordinator": "./coordinator.ts",
     "./curator": "./curator.ts",
+    "./filter": "./filter.ts",
     "./item": "./item.ts",
     "./matcher": "./matcher.ts",
+    "./modifier": "./modifier.ts",
     "./previewer": "./previewer.ts",
-    "./projector": "./projector.ts",
     "./renderer": "./renderer.ts",
     "./sorter": "./sorter.ts",
     "./source": "./source.ts",
@@ -123,7 +123,7 @@
     "@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.3",
+    "@vim-fall/core": "jsr:@vim-fall/core@^0.1.4",
     "fzf": "npm:fzf@^0.5.2",
     "jsr:@vim-fall/std@^0.1.0": "./mod.ts",
     "jsr:@vim-fall/std@^0.1.0/builtin": "./builtin/mod.ts"

deno.jsonc

@@ -0,0 +1,39 @@
+import type { Denops } from "@denops/std";
+import type { IdItem } from "@vim-fall/core/item";
+
+import { defineSource, type Source } from "./source.ts";
+import { type Curator, defineCurator } from "./curator.ts";
+
+export type FilterParams<T> = {
+  readonly items: AsyncIterable<IdItem<T>>;
+};
+
+export type Filter<T> = (<S extends Source<T> | Curator<T>>(source: S) => S) & {
+  __phantom?: T;
+};
+
+export function defineFilter<T>(
+  modify: (
+    denops: Denops,
+    params: FilterParams<T>,
+    options: { signal?: AbortSignal },
+  ) => AsyncIterableIterator<IdItem<T>>,
+): Filter<T> {
+  return ((source) => {
+    if ("collect" in source) {
+      return defineSource(
+        (denops, params, options) => {
+          const items = source.collect(denops, params, options);
+          return modify(denops, { items }, options);
+        },
+      );
+    } else {
+      return defineCurator(
+        (denops, params, options) => {
+          const items = source.curate(denops, params, options);
+          return modify(denops, { items }, options);
+        },
+      );
+    }
+  }) as Filter<T>;
+}

filter.ts

@@ -0,0 +1,125 @@
+import { assertEquals } from "@std/assert";
+import { assertType, type IsExact } from "@std/testing/types";
+
+import { defineFilter, type Filter, type FilterParams } from "./filter.ts";
+import type { Source } from "./source.ts";
+import type { Curator } from "./curator.ts";
+
+Deno.test("Filter", async (t) => {
+  await t.step("with Source", async (t) => {
+    const filter = (() => {}) as Filter<{ a: string }>;
+
+    await t.step("passed type is equal to the type restriction", () => {
+      const modified = filter({} as Source<{ a: string }>);
+      assertType<
+        IsExact<
+          typeof modified,
+          Source<{ a: string }>
+        >
+      >(true);
+    });
+
+    await t.step("passed type establishes the type restriction", () => {
+      const modified = filter({} as Source<{ a: string; b: string }>);
+      assertType<
+        IsExact<
+          typeof modified,
+          Source<{ a: string; b: string }>
+        >
+      >(true);
+    });
+
+    await t.step(
+      "passed type does not establish the type restriction",
+      () => {
+        // @ts-expect-error: 'a' is missing
+        filter({} as Source<{ b: string }>);
+      },
+    );
+
+    await t.step(
+      "check if the type constraint correctly triggers the type checking",
+      () => {
+        const filter1 = (() => {}) as Filter<{ a: string }>;
+        const filter2 = (() => {}) as Filter<{ b: string }>;
+        const filter3 = (() => {}) as Filter<{ c: string }>;
+        function strictFunction<T extends { a: string }>(_: Filter<T>) {}
+        strictFunction(filter1);
+        // @ts-expect-error: 'a' is missing
+        strictFunction(filter2);
+        // @ts-expect-error: 'a' is missing
+        strictFunction(filter3);
+      },
+    );
+  });
+
+  await t.step("with Curator", async (t) => {
+    const filter = (() => {}) as Filter<{ a: string }>;
+
+    await t.step("passed type is equal to the type restriction", () => {
+      const modified = filter({} as Curator<{ a: string }>);
+      assertType<
+        IsExact<
+          typeof modified,
+          Curator<{ a: string }>
+        >
+      >(true);
+    });
+
+    await t.step("passed type establishes the type restriction", () => {
+      const modified = filter({} as Curator<{ a: string; b: string }>);
+      assertType<
+        IsExact<
+          typeof modified,
+          Curator<{ a: string; b: string }>
+        >
+      >(true);
+    });
+
+    await t.step(
+      "passed type does not establish the type restriction",
+      () => {
+        // @ts-expect-error: 'a' is missing
+        filter({} as Curator<{ b: string }>);
+      },
+    );
+
+    await t.step(
+      "check if the type constraint correctly triggers the type checking",
+      () => {
+        const filter1 = (() => {}) as Filter<{ a: string }>;
+        const filter2 = (() => {}) as Filter<{ b: string }>;
+        const filter3 = (() => {}) as Filter<{ c: string }>;
+        function strictFunction<T extends { a: string }>(_: Filter<T>) {}
+        strictFunction(filter1);
+        // @ts-expect-error: 'a' is missing
+        strictFunction(filter2);
+        // @ts-expect-error: 'a' is missing
+        strictFunction(filter3);
+      },
+    );
+  });
+});
+
+Deno.test("defineFilter", async (t) => {
+  await t.step("without type constraint", () => {
+    const filter = defineFilter(async function* (_denops, params) {
+      // @ts-expect-error: `params` is not type restrained
+      const _: FilterParams<{ a: string }> = params;
+      yield* [];
+    });
+    assertEquals(typeof filter, "function");
+    assertType<IsExact<typeof filter, Filter<unknown>>>(true);
+  });
+
+  await t.step("without type constraint T", () => {
+    const filter = defineFilter<{ a: string }>(
+      async function* (_denops, params) {
+        const _: FilterParams<{ a: string }> = params;
+        yield* [];
+      },
+    );
+    assertEquals(typeof filter, "function");
+    assertType<IsExact<typeof filter, Filter<{ a: string }>>>(true);
+  });
+});