feat!: remove and unite filter, modifier into refiner

Author: lambdalisue

builtin/filter/cwd.ts

@@ -0,0 +1,30 @@
+import * as fn from "@denops/std/function";
+
+import { defineRefiner, type Refiner } from "../../refiner.ts";
+
+type Detail = {
+  path: string;
+};
+
+/**
+ * Creates a Refiner that filters items based on the current working directory.
+ *
+ * This Refiner yields only those items whose `path` is within the current working directory.
+ *
+ * @returns A Refiner that filters items according to the current working directory.
+ */
+export function cwd(): Refiner<Detail> {
+  return defineRefiner(async function* (denops, { items }, { signal }) {
+    // Retrieve the current working directory
+    const cwd = await fn.getcwd(denops);
+    signal?.throwIfAborted();
+
+    // Yield each item that matches the current working directory
+    for await (const item of items) {
+      signal?.throwIfAborted();
+      if (item.detail.path.startsWith(cwd)) {
+        yield item;
+      }
+    }
+  });
+}

builtin/filter/exists.ts

@@ -0,0 +1,28 @@
+import { exists as exists_ } from "@std/fs/exists";
+
+import { defineRefiner, type Refiner } from "../../refiner.ts";
+
+type Detail = {
+  path: string;
+};
+
+/**
+ * Creates a Refiner that filters items based on file existence.
+ *
+ * This Refiner checks each item's `path` and yields only those items
+ * where the path exists in the filesystem.
+ *
+ * @returns A Refiner that filters items according to file existence.
+ */
+export function exists(): Refiner<Detail> {
+  return defineRefiner(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)) {
+        yield item;
+      }
+      // Abort the iteration if the signal is triggered
+      signal?.throwIfAborted();
+    }
+  });
+}

builtin/filter/noop.ts

@@ -3,3 +3,4 @@ export * from "./cwd.ts";
 export * from "./exists.ts";
 export * from "./noop.ts";
 export * from "./regexp.ts";
+export * from "./relative_path.ts";

builtin/modifier/mod.ts

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

builtin/modifier/relative_path.ts

@@ -1,4 +1,4 @@
-import { defineFilter, type Filter } from "../../filter.ts";
+import { defineRefiner, type Refiner } from "../../refiner.ts";
 
 /**
  * Options for filtering items by regular expressions.
@@ -8,7 +8,7 @@ import { defineFilter, type Filter } from "../../filter.ts";
  *
  * One of `includes` or `excludes` must be provided, or both can be used together.
  */
-type Options = {
+export type RegexpOptions = {
   includes: RegExp[];
   excludes?: undefined;
 } | {
@@ -20,26 +20,19 @@ type Options = {
 };
 
 /**
- * Represents detailed information for each item, specifically the file path.
- */
-type Detail = {
-  path: string;
-};
-
-/**
- * Creates a Filter that filters items based on regular expression patterns.
+ * Creates a Refiner that filters items based on regular expression patterns.
  *
- * The `regexp` Filter filters items using `includes` and/or `excludes` patterns.
+ * The `regexp` Refiner 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 Filter that yields items matching the specified patterns.
+ * @param options - Refinering options specifying `includes` and/or `excludes` patterns.
+ * @returns A Refiner that yields items matching the specified patterns.
  */
-export function regexp<T extends Detail>(
-  { includes, excludes }: Readonly<Options>,
-): Filter<T> {
-  return defineFilter<T>(async function* (_denops, { items }, { signal }) {
+export function regexp(
+  { includes, excludes }: Readonly<RegexpOptions>,
+): Refiner {
+  return defineRefiner(async function* (_denops, { items }, { signal }) {
     signal?.throwIfAborted();
 
     // Process each item and yield only those matching the filter conditions