feat: support multiple matchers

Author: lambdalisue

denops/fall/event.ts

@@ -21,6 +21,8 @@ export type Event =
   | { type: "move-cursor-at"; cursor: number | "$" }
   | { type: "select-item"; cursor?: number | "$"; method?: SelectMethod }
   | { type: "select-all-items"; method?: SelectMethod }
+  | { type: "switch-matcher"; amount: number; cycle?: boolean }
+  | { type: "switch-matcher-at"; index: number | "$" }
   | { type: "action-invoke"; name: string }
   | { type: "list-component-execute"; command: string }
   | { type: "preview-component-execute"; command: string }

denops/fall/main/event.ts

@@ -41,6 +41,16 @@ const isEventComplement = is.UnionOf([
     type: is.LiteralOf("select-all-items"),
     method: as.Optional(is.LiteralOneOf(["on", "off", "toggle"] as const)),
   }),
+  // Switch
+  is.ObjectOf({
+    type: is.LiteralOf("switch-matcher"),
+    amount: is.Number,
+    cycle: as.Optional(is.Boolean),
+  }),
+  is.ObjectOf({
+    type: is.LiteralOf("switch-matcher-at"),
+    index: is.UnionOf([is.Number, is.LiteralOf("$")]),
+  }),
   // Action
   is.ObjectOf({
     type: is.LiteralOf("action-invoke"),

denops/fall/picker.ts

@@ -101,8 +101,7 @@ export class Picker<T extends Detail> implements AsyncDisposable {
       new CollectProcessor(params.source),
     );
     this.#matchProcessor = this.#stack.use(
-      // TODO: Support multiple matchers
-      new MatchProcessor(params.matchers[0]),
+      new MatchProcessor(params.matchers),
     );
     this.#visualizeProcessor = this.#stack.use(
       // TODO: Support multiple sorters/renderers
@@ -359,6 +358,33 @@ export class Picker<T extends Detail> implements AsyncDisposable {
         this.#selectAll(event.method);
         this.#listComponent.selection = this.#selection;
         break;
+      case "switch-matcher": {
+        let index = this.#matchProcessor.matcherIndex + event.amount;
+        if (event.cycle) {
+          if (index < 0) {
+            index = this.#matchProcessor.matcherCount - 1;
+          } else if (index >= this.#matchProcessor.matcherCount) {
+            index = 0;
+          }
+        }
+        this.#matchProcessor.matcherIndex = index;
+        this.#matchProcessor.start(denops, {
+          items: this.#collectProcessor.items,
+          query: this.#inputComponent.cmdline,
+        }, {
+          restart: true,
+        });
+        break;
+      }
+      case "switch-matcher-at":
+        this.#matchProcessor.matcherIndex = event.index;
+        this.#matchProcessor.start(denops, {
+          items: this.#collectProcessor.items,
+          query: this.#inputComponent.cmdline,
+        }, {
+          restart: true,
+        });
+        break;
       case "action-invoke":
         accept(event.name);
         break;

denops/fall/processor/match.ts

@@ -19,7 +19,7 @@ export type MatchProcessorOptions = {
 };
 
 export class MatchProcessor<T extends Detail> {
-  #filter: Matcher<T>;
+  #matchers: Matcher<T>[];
   #interval: number;
   #threshold: number;
   #chunkSize: number;
@@ -28,21 +28,43 @@ export class MatchProcessor<T extends Detail> {
   #reserved?: () => void;
   #paused?: PromiseWithResolvers<void>;
   #items: IdItem<T>[] = [];
+  #matcherIndex = 0;
 
   constructor(
-    filter: Matcher<T>,
+    filters: Matcher<T>[],
     options: MatchProcessorOptions = {},
   ) {
-    this.#filter = filter;
+    this.#matchers = filters;
     this.#interval = options.interval ?? INTERVAL;
     this.#threshold = options.threshold ?? THRESHOLD;
     this.#chunkSize = options.chunkSize ?? CHUNK_SIZE;
   }
 
+  get #matcher(): Matcher<T> {
+    return this.#matchers[this.#matcherIndex];
+  }
+
   get items(): IdItem<T>[] {
     return this.#items;
   }
 
+  get matcherCount(): number {
+    return this.#matchers.length;
+  }
+
+  get matcherIndex(): number {
+    return this.#matcherIndex;
+  }
+
+  set matcherIndex(index: number | "$") {
+    if (index === "$" || index >= this.#matchers.length) {
+      index = this.#matchers.length - 1;
+    } else if (index < 0) {
+      index = 0;
+    }
+    this.#matcherIndex = index;
+  }
+
   start(
     denops: Denops,
     { items, query }: MatchParams<T>,
@@ -64,7 +86,7 @@ export class MatchProcessor<T extends Detail> {
       const iter = take(
         query === ""
           ? toAsyncIterable(items)
-          : this.#filter.match(denops, { items, query }, { signal }),
+          : this.#matcher.match(denops, { items, query }, { signal }),
         this.#threshold,
       );
       // Gradually update items when `items` is empty to improve latency

plugin/fall/mapping.vim

@@ -15,9 +15,16 @@ cnoremap <silent> <Plug>(fall-right) <Cmd>call fall#internal#dispatch(#{type: 'l
 cnoremap <silent> <Plug>(fall-left:scroll) <Cmd>call fall#internal#dispatch(#{type: 'list-component-execute', command: 'silent! normal! zH'})<CR>
 cnoremap <silent> <Plug>(fall-right:scroll) <Cmd>call fall#internal#dispatch(#{type: 'list-component-execute', command: 'silent! normal! zL'})<CR>
 
+" Select
 cnoremap <silent> <Plug>(fall-select) <Cmd>call fall#internal#dispatch(#{type: 'select-item'})<CR>
 cnoremap <silent> <Plug>(fall-select-all) <Cmd>call fall#internal#dispatch(#{type: 'select-all-items'})<CR>
 
+" Switch
+cnoremap <silent> <Plug>(fall-switch-matcher-first) <Cmd>call fall#internal#dispatch(#{type: 'switch-matcher-at', index: 0})<CR>
+cnoremap <silent> <Plug>(fall-switch-matcher-last) <Cmd>call fall#internal#dispatch(#{type: 'switch-matcher-at', index: '$'})<CR>
+cnoremap <silent> <Plug>(fall-switch-matcher-prev) <Cmd>call fall#internal#dispatch(#{type: 'switch-matcher', amount: -1, cycle: v:true})<CR>
+cnoremap <silent> <Plug>(fall-switch-matcher-next) <Cmd>call fall#internal#dispatch(#{type: 'switch-matcher', amount: 1, cycle: v:true})<CR>
+
 " Preview
 cnoremap <silent> <Plug>(fall-preview-first) <Cmd>call fall#internal#dispatch(#{type: 'preview-component-execute', command: 'silent! normal! gg'})<CR>
 cnoremap <silent> <Plug>(fall-preview-last) <Cmd>call fall#internal#dispatch(#{type: 'preview-component-execute', command: 'silent! normal! G'})<CR>
@@ -63,6 +70,8 @@ if !get(g:, 'fall_disable_default_mapping')
     cnoremap <nowait> <S-Right> <Plug>(fall-preview-right:scroll)
     " Action
     cnoremap <nowait> <Tab> <Plug>(fall-action-select)
+    " Switch
+    cnoremap <nowait> <F2> <Plug>(fall-switch-matcher-next)
   endfunction
 
   augroup fall_mapping_plugin