feat: follow the latest submatch

Author: lambdalisue

builtin/action/submatch.ts

@@ -5,11 +5,9 @@ import type {
   Matcher,
   Previewer,
   Renderer,
-  Size,
   Sorter,
   Theme,
 } from "@vim-fall/core";
-import type { GlobalConfig } from "@vim-fall/config/global-config";
 import type { ItemPickerParams } from "@vim-fall/config/item-picker";
 import {
   type Derivable,
@@ -19,62 +17,42 @@ import {
   deriveArray,
   deriveMap,
 } from "@vim-fall/config/derivable";
+import { unnullish } from "@lambdalisue/unnullish";
 
 import { type Action, defineAction } from "../../action.ts";
-import { list } from "../source/list.ts";
 import { fzf } from "../matcher/fzf.ts";
 import { substring } from "../matcher/substring.ts";
 import { regexp } from "../matcher/regexp.ts";
 
-type Actions<T extends Detail, A extends string> = ItemPickerParams<
-  T,
-  A
->["actions"];
-
 export type SubmatchOptions<T extends Detail, A extends string> = {
   /**
    * Actions available for the submatch picker.
    */
-  actions?: DerivableMap<Actions<T, A>>;
+  actions?: DerivableMap<ItemPickerParams<T, A>["actions"]>;
   /**
    * Default action to invoke.
    */
   defaultAction?: A;
   /**
    * Sorters to apply to matched items.
    */
-  sorters?: DerivableArray<Sorter<T>[]> | null;
+  sorters?: DerivableArray<readonly Sorter<T>[]>;
   /**
    * Renderers to display matched items.
    */
-  renderers?: DerivableArray<Renderer<T>[]> | null;
+  renderers?: DerivableArray<readonly Renderer<T>[]>;
   /**
    * Previewers for item previews.
    */
-  previewers?: DerivableArray<Previewer<T>[]> | null;
+  previewers?: DerivableArray<readonly Previewer<T>[]>;
   /**
    * Coordinator to handle layout.
    */
-  coordinator?: Derivable<Coordinator> | null;
+  coordinator?: Derivable<Coordinator>;
   /**
    * Theme to style the picker.
    */
-  theme?: Derivable<Theme> | null;
-};
-
-type Context<T extends Detail, A extends string> = {
-  /**
-   * The screen size.
-   */
-  readonly screen: Size;
-  /**
-   * The global configuration.
-   */
-  readonly globalConfig: GlobalConfig;
-  /**
-   * The picker parameters.
-   */
-  readonly pickerParams: ItemPickerParams<T, A> & GlobalConfig;
+  theme?: Derivable<Theme>;
 };
 
 /**
@@ -88,83 +66,35 @@ type Context<T extends Detail, A extends string> = {
  * @returns An action that performs submatching.
  */
 export function submatch<T extends Detail, A extends string>(
-  matchers: DerivableArray<[Matcher<T>, ...Matcher<T>[]]>,
+  matchers: DerivableArray<readonly [Matcher<T>, ...Matcher<T>[]]>,
   options: SubmatchOptions<T, A> = {},
 ): Action<T> {
+  const submatchParams = {
+    matchers: deriveArray(matchers),
+    actions: unnullish(options.actions, deriveMap),
+    defaultAction: options.defaultAction,
+    sorters: unnullish(options.sorters, deriveArray),
+    renderers: unnullish(options.renderers, deriveArray),
+    previewers: unnullish(options.previewers, deriveArray),
+    coordinator: unnullish(options.coordinator, derive),
+    theme: unnullish(options.theme, derive),
+  };
   return defineAction<T>(
-    async (denops, { selectedItems, filteredItems, ...params }, { signal }) => {
-      const context = getContext(params);
-
-      const pickerParams: ItemPickerParams<T, string> & GlobalConfig = {
-        ...context.pickerParams,
-        source: list(selectedItems ?? filteredItems),
-        matchers: deriveArray(matchers),
-      };
-
-      if (options.actions) {
-        pickerParams.actions = deriveMap(pickerParams.actions);
-      }
-      if (options.defaultAction) {
-        pickerParams.defaultAction = options.defaultAction;
-      }
-      if (options.sorters !== undefined) {
-        pickerParams.sorters = options.sorters
-          ? deriveArray(options.sorters)
-          : undefined;
-      }
-      if (options.renderers !== undefined) {
-        pickerParams.renderers = options.renderers
-          ? deriveArray(options.renderers)
-          : undefined;
-      }
-      if (options.previewers !== undefined) {
-        pickerParams.previewers = options.previewers
-          ? deriveArray(options.previewers)
-          : undefined;
-      }
-      if (options.coordinator !== undefined) {
-        pickerParams.coordinator = derive(options.coordinator) ??
-          context.globalConfig.coordinator;
-      }
-      if (options.theme !== undefined) {
-        pickerParams.theme = derive(options.theme) ??
-          context.globalConfig.theme;
-      }
-
+    async (denops, params, { signal }) => {
       const result = await denops.dispatch(
         "fall",
-        "picker:start",
-        [],
-        context.screen,
-        pickerParams,
+        "submatch",
+        params,
+        submatchParams,
         { signal },
       );
-
       if (result) {
         return true;
       }
     },
   );
 }
 
-/**
- * Retrieves the context from the parameters object.
- *
- * @param params - Parameters that may contain the hidden context for submatch.
- * @returns The extracted context.
- * @throws If the required context is not present.
- */
-function getContext<T extends Detail, A extends string>(
-  params: unknown,
-): Context<T, A> {
-  if (params && typeof params === "object" && "_submatchContext" in params) {
-    return params._submatchContext as Context<T, A>;
-  }
-  throw new Error(
-    "[fall] Invoke params doesn't have required hidden context for submatch",
-  );
-}
-
 /**
  * Default submatching actions with common matchers.
  */

deno.jsonc

@@ -114,6 +114,7 @@
     "@denops/std": "jsr:@denops/std@^7.3.0",
     "@denops/test": "jsr:@denops/test@^3.0.4",
     "@lambdalisue/systemopen": "jsr:@lambdalisue/systemopen@^1.0.0",
+    "@lambdalisue/unnullish": "jsr:@lambdalisue/unnullish@^1.0.2",
     "@std/assert": "jsr:@std/assert@^1.0.7",
     "@std/fs": "jsr:@std/fs@^1.0.5",
     "@std/jsonc": "jsr:@std/jsonc@^1.0.1",