feat: rewrite submatch feature

Author: lambdalisue

denops/fall/config.ts

@@ -210,23 +210,20 @@ export function getGlobalConfig(): Readonly<GlobalConfig> {
  * Get action picker params.
  */
 export function getActionPickerParams(): Readonly<
-  ActionPickerParams & GlobalConfig
+  ActionPickerParams
 > {
-  return {
-    ...getGlobalConfig(),
-    ...actionPickerParams,
-  };
+  return actionPickerParams;
 }
 
 /**
  * Get item picker params.
  */
 export function getItemPickerParams(
   name: string,
-): Readonly<ItemPickerParams & GlobalConfig> | undefined {
+): Readonly<ItemPickerParams> | undefined {
   const params = itemPickerParamsMap.get(name);
   if (params) {
-    return { ...getGlobalConfig(), ...params };
+    return params;
   }
   return undefined;
 }

denops/fall/main.ts

@@ -1,12 +1,15 @@
 import "./lib/polyfill.ts";
 
 import type { Entrypoint } from "jsr:@denops/std@^7.3.2";
+
 import { main as mainConfig } from "./main/config.ts";
 import { main as mainEvent } from "./main/event.ts";
 import { main as mainPicker } from "./main/picker.ts";
+import { main as mainSubmatch } from "./main/submatch.ts";
 
 export const main: Entrypoint = async (denops) => {
   await mainConfig(denops);
   await mainEvent(denops);
   await mainPicker(denops);
+  await mainSubmatch(denops);
 };

denops/fall/main/picker.ts

@@ -3,23 +3,35 @@ import { ensurePromise } from "jsr:@core/asyncutil@^1.2.0/ensure-promise";
 import { assert, ensure, is } from "jsr:@core/unknownutil@^4.3.0";
 import type { DetailUnit } from "jsr:@vim-fall/core@^0.2.1/item";
 
-import type { GlobalConfig, ItemPickerParams } from "../config.ts";
+import type { ItemPickerParams } from "../config.ts";
 import {
   getActionPickerParams,
   getGlobalConfig,
   getItemPickerParams,
   listItemPickerNames,
   loadUserConfig,
 } from "../config.ts";
-import { isOptions, isParams, isStringArray } from "../util/predicate.ts";
+import {
+  isGlobalConfig,
+  isItemPickerParams,
+  isOptions,
+  isStringArray,
+} from "../util/predicate.ts";
 import { action as buildActionSource } from "../extension/source/action.ts";
 import { Picker } from "../picker.ts";
+import type { SubmatchContext } from "./submatch.ts";
 
 let zindex = 50;
 
 export const main: Entrypoint = (denops) => {
   denops.dispatcher = {
     ...denops.dispatcher,
+    "picker": (args, itemPickerParams, options) => {
+      assert(args, isStringArray);
+      assert(itemPickerParams, isItemPickerParams);
+      assert(options, isOptions);
+      return startPicker(denops, args, itemPickerParams, options);
+    },
     "picker:command": async (args) => {
       await loadUserConfig(denops);
       // Split the command arguments
@@ -43,33 +55,50 @@ export const main: Entrypoint = (denops) => {
       assert(cursorpos, is.Number);
       return listItemPickerNames().filter((name) => name.startsWith(arglead));
     },
-    // _screen is not used
-    "picker:start": async (args, _screen, params, options) => {
-      await loadUserConfig(denops);
-      assert(args, isStringArray);
-      assert(params, isParams);
+    // TODO: Remove this API prior to release v1.0.0
+    // DEPRECATED: Use "submatch:start" instead
+    "picker:start": async (_args, _screen, params, options) => {
+      console.warn(
+        "The 'picker:start' is deprecated. Use 'submatch:start' instead.",
+        "It is probably caused by '@vim-fall/std/builtin/action/submatch' action.",
+      );
+      assert(
+        params,
+        is.IntersectionOf([
+          isGlobalConfig,
+          isItemPickerParams,
+        ]),
+      );
       assert(options, isOptions);
-      return await startPicker(denops, args, params, options);
+      return await startPicker(denops, [], params, options);
     },
   };
 };
 
 async function startPicker(
   denops: Denops,
   args: string[],
-  params: ItemPickerParams<DetailUnit, string> & GlobalConfig,
+  itemPickerParams: ItemPickerParams<DetailUnit, string>,
   { signal }: { signal?: AbortSignal } = {},
 ): Promise<void | true> {
   await using stack = new AsyncDisposableStack();
-  const itemPicker = stack.use(new Picker({ ...params, zindex }));
+  const globalConfig = getGlobalConfig();
+  const itemPicker = stack.use(
+    new Picker({
+      ...globalConfig,
+      ...itemPickerParams,
+      zindex,
+    }),
+  );
   zindex += Picker.ZINDEX_ALLOCATION;
   stack.defer(() => {
     zindex -= Picker.ZINDEX_ALLOCATION;
   });
   const actionPicker = stack.use(
     new Picker({
       name: "@action",
-      source: buildActionSource(params.actions),
+      source: buildActionSource(itemPickerParams.actions),
+      ...globalConfig,
       ...getActionPickerParams(),
       zindex,
     }),
@@ -120,27 +149,31 @@ async function startPicker(
       actionName = resultItem.action;
     } else {
       // Default action
-      actionName = params.defaultAction;
+      actionName = itemPickerParams.defaultAction;
     }
 
     // Execute the action
-    const action = params.actions[actionName];
+    const action = itemPickerParams.actions[actionName];
     if (!action) {
       throw new Error(`Action "${actionName}" is not found`);
     }
     const actionParams = {
-      // for 'submatch' action
+      // TODO: Drop the following attributes prior to release v1.0.0
+      // Attributes used before @vim-fall/[email protected]
       _submatchContext: {
-        globalConfig: getGlobalConfig(),
-        pickerParams: params,
-        // not used
-        screen: {
-          width: 0,
-          height: 0,
+        globalConfig,
+        pickerParams: {
+          ...globalConfig,
+          ...itemPickerParams,
         },
+        screen: { width: 0, height: 0 },
+      },
+      // Secret attribute for @vim-fall/std/builtin/action/submatch
+      _submatch: {
+        itemPickerParams,
       },
       ...resultItem,
-    };
+    } as const satisfies SubmatchContext & { _submatchContext: unknown };
     if (await ensurePromise(action.invoke(denops, actionParams, { signal }))) {
       // Picker should not be closed
       continue;

denops/fall/main/submatch.ts

@@ -0,0 +1,120 @@
+import type { Denops, Entrypoint } from "jsr:@denops/std@^7.3.2";
+import { as, assert, is, type Predicate } from "jsr:@core/unknownutil@^4.3.0";
+import type {
+  Coordinator,
+  Detail,
+  InvokeParams,
+  Matcher,
+  Previewer,
+  Renderer,
+  Sorter,
+  Theme,
+} from "jsr:@vim-fall/core@^0.2.1";
+
+import type { ItemPickerParams } from "../config.ts";
+import {
+  isAction,
+  isCoordinator,
+  isItemPickerParams,
+  isMatcher,
+  isOptions,
+  isPreviewer,
+  isRenderer,
+  isSorter,
+  isTheme,
+} from "../util/predicate.ts";
+import { list as buildListSource } from "../extension/source/list.ts";
+
+export type SubmatchContext = InvokeParams<Detail> & {
+  readonly _submatch: {
+    readonly itemPickerParams: ItemPickerParams<Detail, string>;
+  };
+};
+
+type SubmatchParams = {
+  readonly matchers: readonly [Matcher<Detail>, ...Matcher<Detail>[]];
+  readonly actions?: ItemPickerParams<Detail, string>["actions"];
+  readonly defaultAction?: string;
+  readonly sorters?: readonly Sorter<Detail>[] | null;
+  readonly renderers?: readonly Renderer<Detail>[] | null;
+  readonly previewers?: readonly Previewer<Detail>[] | null;
+  readonly coordinator?: Coordinator | null;
+  readonly theme?: Theme | null;
+};
+
+export const main: Entrypoint = (denops) => {
+  denops.dispatcher = {
+    ...denops.dispatcher,
+    "submatch": async (context, params, options) => {
+      assert(context, isSubmatchContext);
+      assert(params, isSubmatchParams);
+      assert(options, isOptions);
+      return await submatchStart(denops, context, params, options);
+    },
+  };
+};
+
+async function submatchStart(
+  denops: Denops,
+  context: SubmatchContext,
+  params: SubmatchParams,
+  options: { signal?: AbortSignal } = {},
+): Promise<void | true> {
+  const itemPickerParams = {
+    ...context._submatch.itemPickerParams,
+    source: buildListSource(context.selectedItems ?? context.filteredItems),
+  };
+  if (params.actions) {
+    itemPickerParams.actions = params.actions;
+  }
+  if (params.defaultAction) {
+    itemPickerParams.defaultAction = params.defaultAction;
+  }
+  if (params.sorters) {
+    itemPickerParams.sorters = params.sorters;
+  }
+  if (params.renderers) {
+    itemPickerParams.renderers = params.renderers;
+  }
+  if (params.previewers) {
+    itemPickerParams.previewers = params.previewers;
+  }
+  if (params.coordinator) {
+    itemPickerParams.coordinator = params.coordinator;
+  }
+  if (params.theme) {
+    itemPickerParams.theme = params.theme;
+  }
+  const result = await denops.dispatch(
+    denops.name,
+    "picker",
+    [],
+    itemPickerParams,
+    options,
+  );
+  if (result === true) {
+    return true;
+  }
+}
+
+const isSubmatchContext = is.ObjectOf({
+  item: as.Optional(is.Any),
+  selectedItems: as.Optional(is.ArrayOf(is.Any)),
+  filteredItems: is.ArrayOf(is.Any),
+  _submatch: is.ObjectOf({
+    itemPickerParams: isItemPickerParams,
+  }),
+}) satisfies Predicate<SubmatchContext>;
+
+const isSubmatchParams = is.ObjectOf({
+  matchers: is.ArrayOf(isMatcher) as Predicate<
+    [Matcher<Detail>, ...Matcher<Detail>[]]
+  >,
+  actions: as.Optional(is.RecordOf(isAction, is.String)),
+  defaultAction: as.Optional(is.String),
+  sorters: as.Optional(is.ArrayOf(isSorter)),
+  renderers: as.Optional(is.ArrayOf(isRenderer)),
+  previewers: as.Optional(is.ArrayOf(isPreviewer)),
+  coordinator: as.Optional(isCoordinator),
+  theme: as.Optional(isTheme),
+}) satisfies Predicate<SubmatchParams>;

denops/fall/util/predicate.ts

@@ -7,7 +7,6 @@ import type {
   Matcher,
   Previewer,
   Renderer,
-  Size,
   Sorter,
   Source,
   Theme,
@@ -21,11 +20,6 @@ export const isAbortSignal = is.InstanceOf(AbortSignal) as Predicate<
   AbortSignal
 >;
 
-export const isScreen = is.ObjectOf({
-  width: is.Number,
-  height: is.Number,
-}) satisfies Predicate<Size>;
-
 export const isTheme = is.ObjectOf({
   border: is.UniformTupleOf(8, is.String),
   divider: is.UniformTupleOf(6, is.String),
@@ -93,11 +87,6 @@ export const isItemPickerParams = is.ObjectOf({
   theme: as.Optional(isTheme),
 }) satisfies Predicate<ItemPickerParams<Detail, string>>;
 
-export const isParams = is.IntersectionOf([
-  isGlobalConfig,
-  isItemPickerParams,
-]);
-
 export const isOptions = is.ObjectOf({
   signal: as.Optional(isAbortSignal),
 });