💥 Multiple matchers, sorters, renderers, and previewers

Switchable:
- matcher
- sorter
- renderer

Stackable:
- previewer

Author: lambdalisue

denops/@fall/builtin/action/submatch.ts

@@ -9,8 +9,10 @@ import { list } from "../source/list.ts";
 import { type Action, defineAction } from "../../action.ts";
 import {
   type Derivable,
+  type DerivableArray,
   type DerivableMap,
   derive,
+  deriveArray,
   deriveMap,
 } from "../../util/derivable.ts";
 import { fzf } from "../matcher/fzf.ts";
@@ -20,38 +22,44 @@ import { regexp } from "../matcher/regexp.ts";
 type Options<T, A extends string> = {
   actions?: DerivableMap<Actions<T, A>>;
   defaultAction?: A;
-  sorter?: Derivable<Sorter<T>> | null;
-  renderer?: Derivable<Renderer<T>> | null;
-  previewer?: Derivable<Previewer<T>> | null;
+  sorters?: DerivableArray<Sorter<T>[]> | null;
+  renderers?: DerivableArray<Renderer<T>[]> | null;
+  previewers?: DerivableArray<Previewer<T>[]> | null;
   coordinator?: Derivable<Coordinator> | null;
   theme?: Derivable<Theme> | null;
 };
 
 export function submatch<T, A extends string>(
-  matcher: Derivable<Matcher<T>>,
+  matchers: DerivableArray<[Matcher<T>, ...Matcher<T>[]]>,
   options: Options<T, A> = {},
 ): Action<T> {
   return defineAction<T>(
     async (denops, { selectedItems, filteredItems, context }, { signal }) => {
       const params: ItemPickerParams<T, string> & GlobalConfig = {
         ...context.pickerParams,
         source: list(selectedItems ?? filteredItems),
-        matcher: derive(matcher),
+        matchers: deriveArray(matchers),
       };
       if (options.actions) {
         params.actions = deriveMap(params.actions);
       }
       if (options.defaultAction) {
         params.defaultAction = options.defaultAction;
       }
-      if (options.sorter !== undefined) {
-        params.sorter = derive(options.sorter) ?? undefined;
+      if (options.sorters !== undefined) {
+        params.sorters = options.sorters
+          ? deriveArray(options.sorters)
+          : undefined;
       }
-      if (options.renderer !== undefined) {
-        params.renderer = derive(options.renderer) ?? undefined;
+      if (options.renderers !== undefined) {
+        params.renderers = options.renderers
+          ? deriveArray(options.renderers)
+          : undefined;
       }
-      if (options.previewer !== undefined) {
-        params.previewer = derive(options.previewer) ?? undefined;
+      if (options.previewers !== undefined) {
+        params.previewers = options.previewers
+          ? deriveArray(options.previewers)
+          : undefined;
       }
       if (options.coordinator !== undefined) {
         params.coordinator = derive(options.coordinator) ??
@@ -80,7 +88,7 @@ export const defaultSubmatchActions: {
   "sub:substring": Action<unknown>;
   "sub:regexp": Action<unknown>;
 } = {
-  "sub:fzf": submatch(fzf),
-  "sub:substring": submatch(substring),
-  "sub:regexp": submatch(regexp),
+  "sub:fzf": submatch([fzf]),
+  "sub:substring": submatch([substring]),
+  "sub:regexp": submatch([regexp]),
 };

denops/@fall/config.ts

@@ -9,7 +9,11 @@ import type { Sorter } from "./sorter.ts";
 import type { Renderer } from "./renderer.ts";
 import type { Previewer } from "./previewer.ts";
 import type { Action } from "./action.ts";
-import type { Derivable, DerivableMap } from "./util/derivable.ts";
+import type {
+  Derivable,
+  DerivableArray,
+  DerivableMap,
+} from "./util/derivable.ts";
 
 export type Actions<T, A extends string> =
   & Record<string, Action<T>>
@@ -18,21 +22,21 @@ export type Actions<T, A extends string> =
 export type ItemPickerParams<T, A extends string> = {
   name: string;
   source: Source<T>;
-  matcher: Matcher<NoInfer<T>>;
   actions: Actions<T, NoInfer<A>>;
   defaultAction: A;
-  sorter?: Sorter<NoInfer<T>>;
-  renderer?: Renderer<NoInfer<T>>;
-  previewer?: Previewer<NoInfer<T>>;
+  matchers: [Matcher<NoInfer<T>>, ...Matcher<NoInfer<T>>[]];
+  sorters?: Sorter<NoInfer<T>>[];
+  renderers?: Renderer<NoInfer<T>>[];
+  previewers?: Previewer<NoInfer<T>>[];
   coordinator?: Coordinator;
   theme?: Theme;
 };
 
 export type ActionPickerParams = {
-  matcher: Matcher<Action<unknown>>;
-  sorter?: Sorter<Action<unknown>>;
-  renderer?: Renderer<Action<unknown>>;
-  previewer?: Previewer<Action<unknown>>;
+  matchers: [Matcher<Action<unknown>>, ...Matcher<Action<unknown>>[]];
+  sorters?: Sorter<Action<unknown>>[];
+  renderers?: Renderer<Action<unknown>>[];
+  previewers?: Previewer<Action<unknown>>[];
   coordinator?: Coordinator;
   theme?: Theme;
 };
@@ -49,12 +53,12 @@ export type DefineItemPickerFromSource = <T, A extends string>(
   name: string,
   source: Derivable<Source<T>>,
   params: {
-    matcher: Derivable<Matcher<NoInfer<T>>>;
     actions: DerivableMap<Actions<NoInfer<T>, NoInfer<A>>>;
     defaultAction: A;
-    sorter?: Derivable<Sorter<NoInfer<T>>>;
-    renderer?: Derivable<Renderer<NoInfer<T>>>;
-    previewer?: Derivable<Previewer<NoInfer<T>>>;
+    matchers: DerivableArray<[Matcher<NoInfer<T>>, ...Matcher<NoInfer<T>>[]]>;
+    sorters?: DerivableArray<Sorter<NoInfer<T>>[]>;
+    renderers?: DerivableArray<Renderer<NoInfer<T>>[]>;
+    previewers?: DerivableArray<Previewer<NoInfer<T>>[]>;
     coordinator?: Derivable<Coordinator>;
     theme?: Derivable<Theme>;
   },
@@ -69,9 +73,9 @@ export type DefineItemPickerFromCurator = <T, A extends string>(
   params: {
     actions: DerivableMap<Actions<NoInfer<T>, NoInfer<A>>>;
     defaultAction: A;
-    sorter?: Derivable<Sorter<NoInfer<T>>>;
-    renderer?: Derivable<Renderer<NoInfer<T>>>;
-    previewer?: Derivable<Previewer<NoInfer<T>>>;
+    sorters?: DerivableArray<Sorter<NoInfer<T>>[]>;
+    renderers?: DerivableArray<Renderer<NoInfer<T>>[]>;
+    previewers?: DerivableArray<Previewer<NoInfer<T>>[]>;
     coordinator?: Derivable<Coordinator>;
     theme?: Derivable<Theme>;
   },
@@ -82,10 +86,12 @@ export type DefineItemPickerFromCurator = <T, A extends string>(
  */
 export type RefineActionPicker = (
   params: {
-    matcher?: Derivable<Matcher<Action<unknown>>>;
-    sorter?: Derivable<Sorter<Action<unknown>>>;
-    renderer?: Derivable<Renderer<Action<unknown>>>;
-    previewer?: Derivable<Previewer<Action<unknown>>>;
+    matchers: DerivableArray<
+      [Matcher<Action<unknown>>, ...Matcher<Action<unknown>>[]]
+    >;
+    sorters?: DerivableArray<Sorter<Action<unknown>>[]>;
+    renderers?: DerivableArray<Renderer<Action<unknown>>[]>;
+    previewers?: DerivableArray<Previewer<Action<unknown>>[]>;
     coordinator?: Derivable<Coordinator>;
     theme?: Derivable<Theme>;
   },

denops/fall/_assets/default.config.ts

@@ -28,7 +28,7 @@ export const main: Entrypoint = (
       builtin.modifier.relativePath,
     ),
     {
-      previewer: builtin.previewer.file,
+      previewers: [builtin.previewer.file],
       actions: {
         ...quickfixActions,
         ...builtin.action.defaultOpenActions,
@@ -48,7 +48,7 @@ export const main: Entrypoint = (
       builtin.modifier.relativePath,
     ),
     {
-      previewer: builtin.previewer.file,
+      previewers: [builtin.previewer.file],
       actions: {
         ...quickfixActions,
         ...builtin.action.defaultOpenActions,
@@ -68,7 +68,7 @@ export const main: Entrypoint = (
       builtin.modifier.relativePath,
     ),
     {
-      previewer: builtin.previewer.file,
+      previewers: [builtin.previewer.file],
       actions: {
         ...quickfixActions,
         ...builtin.action.defaultOpenActions,
@@ -99,12 +99,12 @@ export const main: Entrypoint = (
       builtin.modifier.relativePath,
     ),
     {
-      matcher: builtin.matcher.fzf,
-      renderer: composeRenderer(
+      matchers: [builtin.matcher.fzf],
+      renderers: [composeRenderer(
         builtin.renderer.smartPath,
         builtin.renderer.nerdfont,
-      ),
-      previewer: builtin.previewer.file,
+      )],
+      previewers: [builtin.previewer.file],
       actions: {
         ...quickfixActions,
         ...builtin.action.defaultOpenActions,
@@ -118,8 +118,8 @@ export const main: Entrypoint = (
   );
 
   defineItemPickerFromSource("line", builtin.source.line, {
-    matcher: builtin.matcher.fzf,
-    previewer: builtin.previewer.buffer,
+    matchers: [builtin.matcher.fzf],
+    previewers: [builtin.previewer.buffer],
     actions: {
       ...quickfixActions,
       ...builtin.action.defaultOpenActions,
@@ -135,8 +135,8 @@ export const main: Entrypoint = (
     "buffer",
     builtin.source.buffer({ filter: "bufloaded" }),
     {
-      matcher: builtin.matcher.fzf,
-      previewer: builtin.previewer.buffer,
+      matchers: [builtin.matcher.fzf],
+      previewers: [builtin.previewer.buffer],
       actions: {
         ...quickfixActions,
         ...builtin.action.defaultOpenActions,
@@ -150,8 +150,8 @@ export const main: Entrypoint = (
   );
 
   defineItemPickerFromSource("help", builtin.source.helptag, {
-    matcher: builtin.matcher.fzf,
-    previewer: builtin.previewer.helptag,
+    matchers: [builtin.matcher.fzf],
+    previewers: [builtin.previewer.helptag],
     actions: {
       ...builtin.action.defaultHelpActions,
       ...builtin.action.defaultEchoActions,

denops/fall/config/action_picker.ts

@@ -7,10 +7,10 @@ import { getGlobalConfig } from "./global_config.ts";
 
 import { modern as modernLayout } from "../../@fall/builtin/coordinator/modern.ts";
 import { fzf as fzfMatcher } from "../../@fall/builtin/matcher/fzf.ts";
-import { derive } from "../../@fall/util/derivable.ts";
+import { derive, deriveArray } from "../../@fall/util/derivable.ts";
 
 const actionPickerParams: ActionPickerParams = {
-  matcher: fzfMatcher(),
+  matchers: [fzfMatcher()],
   coordinator: modernLayout({
     widthRatio: 0.4,
     heightRatio: 0.4,
@@ -27,17 +27,17 @@ export function getActionPickerParams(): Readonly<
 }
 
 export const refineActionPicker: RefineActionPicker = (params) => {
-  if (params.matcher) {
-    actionPickerParams.matcher = derive(params.matcher);
+  if (params.matchers) {
+    actionPickerParams.matchers = deriveArray(params.matchers);
   }
-  if (params.sorter) {
-    actionPickerParams.sorter = derive(params.sorter);
+  if (params.sorters) {
+    actionPickerParams.sorters = deriveArray(params.sorters);
   }
-  if (params.renderer) {
-    actionPickerParams.renderer = derive(params.renderer);
+  if (params.renderers) {
+    actionPickerParams.renderers = deriveArray(params.renderers);
   }
-  if (params.previewer) {
-    actionPickerParams.previewer = derive(params.previewer);
+  if (params.previewers) {
+    actionPickerParams.previewers = deriveArray(params.previewers);
   }
   if (params.coordinator) {
     actionPickerParams.coordinator = derive(params.coordinator);

denops/fall/config/item_picker.ts

@@ -9,7 +9,7 @@ import type {
   GlobalConfig,
   ItemPickerParams,
 } from "../../@fall/config.ts";
-import { derive, deriveMap } from "../../@fall/util/derivable.ts";
+import { derive, deriveArray, deriveMap } from "../../@fall/util/derivable.ts";
 import { getGlobalConfig } from "./global_config.ts";
 
 type Actions = ItemPickerParams<unknown, string>["actions"];
@@ -41,11 +41,16 @@ export const defineItemPickerFromSource: DefineItemPickerFromSource = (
   if (itemPickerParamsMap.has(name)) {
     throw new Error(`Item picker "${name}" is already defined.`);
   }
-  const derivedParams = {
-    ...deriveMap(params),
+  const derivedParams = omitUndefinedAttributes({
     actions: deriveMap(params.actions) as Actions,
     defaultAction: params.defaultAction,
-  };
+    matchers: deriveArray(params.matchers),
+    sorters: params.sorters ? deriveArray(params.sorters) : undefined,
+    renderers: params.renderers ? deriveArray(params.renderers) : undefined,
+    previewers: params.previewers ? deriveArray(params.previewers) : undefined,
+    coordinator: derive(params.coordinator),
+    theme: derive(params.theme),
+  });
   itemPickerParamsMap.set(name, {
     ...derivedParams,
     name,
@@ -62,16 +67,20 @@ export const defineItemPickerFromCurator: DefineItemPickerFromCurator = (
     throw new Error(`Item picker "${name}" is already defined.`);
   }
   const source = new CuratorSourceMatcher(derive(curator));
-  const derivedParams = {
-    ...deriveMap(params),
+  const derivedParams = omitUndefinedAttributes({
     actions: deriveMap(params.actions) as Actions,
     defaultAction: params.defaultAction,
-  };
+    sorters: params.sorters ? deriveArray(params.sorters) : undefined,
+    renderers: params.renderers ? deriveArray(params.renderers) : undefined,
+    previewers: params.previewers ? deriveArray(params.previewers) : undefined,
+    coordinator: derive(params.coordinator),
+    theme: derive(params.theme),
+  });
   itemPickerParamsMap.set(name, {
     ...derivedParams,
     name,
     source,
-    matcher: source,
+    matchers: [source],
   });
 };
 
@@ -107,3 +116,14 @@ class CuratorSourceMatcher<T> implements Source<T>, Matcher<T> {
     yield* this.#curator.curate(denops, curatorParams, options);
   }
 }
+
+function omitUndefinedAttributes<
+  M extends Record<PropertyKey, unknown>,
+  R extends { [K in keyof M]: M[K] extends undefined ? never : M[K] },
+>(
+  map: M,
+): R {
+  return Object.fromEntries(
+    Object.entries(map).filter(([, v]) => v !== undefined),
+  ) as R;
+}

denops/fall/main/picker.ts

@@ -181,12 +181,12 @@ const isScreen = is.ObjectOf({
 const isParams = is.ObjectOf({
   name: is.String,
   source: is.Any,
-  matcher: is.Any,
   actions: is.Any,
   defaultAction: is.String,
-  sorter: as.Optional(is.Any),
-  renderer: as.Optional(is.Any),
-  previewer: as.Optional(is.Any),
+  matchers: is.Any,
+  sorters: as.Optional(is.Any),
+  renderers: as.Optional(is.Any),
+  previewers: as.Optional(is.Any),
   coordinator: is.Any,
   theme: is.Any,
 }) satisfies Predicate<ItemPickerParams<unknown, string> & GlobalConfig>;