feat: show expected error message a bit lightly

Author: lambdalisue

denops/fall/error.ts

@@ -0,0 +1,50 @@
+import type { Denops } from "jsr:@denops/std@^7.3.2";
+import { AssertError } from "jsr:@core/unknownutil@^4.3.0/assert";
+
+/**
+ * Application error that is used to represent an expected error.
+ */
+export class ExpectedError extends Error {
+  constructor(message: string, public source?: unknown) {
+    super(message);
+  }
+}
+
+export async function handleError(
+  denops: Denops,
+  error: unknown,
+): Promise<void> {
+  if (error instanceof ExpectedError) {
+    await denops.cmd(
+      `redraw | echohl Error | echomsg '[fall] ${error.message}' | echohl None`,
+    );
+    return;
+  }
+  if (error instanceof AssertError) {
+    await denops.cmd(
+      `redraw | echohl Error | echomsg '[fall] ${error.message}' | echohl None`,
+    );
+    return;
+  }
+  console.error(error);
+}
+
+export function withHandleError<T, A extends unknown[]>(
+  denops: Denops,
+  fn: (...args: A) => T | Promise<T>,
+): (...args: A) => Promise<T | undefined> {
+  return async (...args: A): Promise<T | undefined> => {
+    try {
+      return await fn(...args);
+    } catch (e) {
+      // NOTE:
+      // This setTimeout is required in Neovim to show the error message
+      // properly. Otherwise, the error message is not shown maybe because
+      // the msgarea is hidden during the picker execution.
+      setTimeout(
+        () => handleError(denops, e).catch((err) => console.error(err)),
+        0,
+      );
+    }
+  };
+}

denops/fall/main/config.ts

@@ -6,21 +6,22 @@ import {
   loadUserConfig,
   recacheUserConfig,
 } from "../config.ts";
+import { withHandleError } from "../error.ts";
 
 export const main: Entrypoint = (denops) => {
   denops.dispatcher = {
     ...denops.dispatcher,
-    "config:edit": (options = {}) => {
+    "config:edit": withHandleError(denops, (options = {}) => {
       assert(options, isEditOptions);
       return editUserConfig(denops, options);
-    },
-    "config:reload": (options = {}) => {
+    }),
+    "config:reload": withHandleError(denops, (options = {}) => {
       assert(options, isReloadOptions);
       return loadUserConfig(denops, { verbose: options.verbose, reload: true });
-    },
-    "config:recache": () => {
+    }),
+    "config:recache": withHandleError(denops, () => {
       return recacheUserConfig(denops, { signal: denops.interrupted });
-    },
+    }),
   };
 };
 

denops/fall/main/event.ts

@@ -2,13 +2,14 @@ import type { Entrypoint } from "jsr:@denops/std@^7.3.2";
 import { as, ensure, is, type Predicate } from "jsr:@core/unknownutil@^4.3.0";
 
 import { dispatch, type Event } from "../event.ts";
+import { withHandleError } from "../error.ts";
 
 export const main: Entrypoint = (denops) => {
   denops.dispatcher = {
     ...denops.dispatcher,
-    "event:dispatch": (event) => {
+    "event:dispatch": withHandleError(denops, (event) => {
       dispatch(ensure(event, isEventComplement));
-    },
+    }),
   };
 };
 

denops/fall/main/picker.ts

@@ -20,6 +20,7 @@ import {
 import { action as buildActionSource } from "../extension/source/action.ts";
 import { Picker } from "../picker.ts";
 import type { SubmatchContext } from "./submatch.ts";
+import { ExpectedError, withHandleError } from "../error.ts";
 
 let zindex = 50;
 
@@ -32,29 +33,36 @@ export const main: Entrypoint = (denops) => {
       assert(options, isOptions);
       return startPicker(denops, args, itemPickerParams, options);
     },
-    "picker:command": async (args) => {
+    "picker:command": withHandleError(denops, async (args) => {
       await loadUserConfig(denops);
       // Split the command arguments
       const [name, ...sourceArgs] = ensure(args, isStringArray);
       // Load user config
       const itemPickerParams = getItemPickerParams(name);
       if (!itemPickerParams) {
-        throw new Error(`Config for picker "${name}" is not found`);
+        throw new ExpectedError(
+          `No item picker "${name}" is found. Available item pickers are: ${
+            listItemPickerNames().join(", ")
+          }`,
+        );
       }
       await startPicker(
         denops,
         sourceArgs,
         itemPickerParams,
         { signal: denops.interrupted },
       );
-    },
-    "picker:command:complete": async (arglead, cmdline, cursorpos) => {
-      await loadUserConfig(denops);
-      assert(arglead, is.String);
-      assert(cmdline, is.String);
-      assert(cursorpos, is.Number);
-      return listItemPickerNames().filter((name) => name.startsWith(arglead));
-    },
+    }),
+    "picker:command:complete": withHandleError(
+      denops,
+      async (arglead, cmdline, cursorpos) => {
+        await loadUserConfig(denops);
+        assert(arglead, is.String);
+        assert(cmdline, is.String);
+        assert(cursorpos, is.Number);
+        return listItemPickerNames().filter((name) => name.startsWith(arglead));
+      },
+    ),
     // TODO: Remove this API prior to release v1.0.0
     // DEPRECATED: Use "submatch:start" instead
     "picker:start": async (_args, _screen, params, options) => {
@@ -155,7 +163,13 @@ async function startPicker(
     // Execute the action
     const action = itemPickerParams.actions[actionName];
     if (!action) {
-      throw new Error(`Action "${actionName}" is not found`);
+      throw new ExpectedError(
+        `No action "${actionName}" is found. Available actions are: ${
+          Object.keys(itemPickerParams.actions).join(
+            ", ",
+          )
+        }`,
+      );
     }
     const actionParams = {
       // TODO: Drop the following attributes prior to release v1.0.0

denops/fall/main/submatch.ts

@@ -24,6 +24,7 @@ import {
   isTheme,
 } from "../util/predicate.ts";
 import { list as buildListSource } from "../extension/source/list.ts";
+import { withHandleError } from "../error.ts";
 
 export type SubmatchContext = InvokeParams<Detail> & {
   readonly _submatch: {
@@ -45,12 +46,12 @@ type SubmatchParams = {
 export const main: Entrypoint = (denops) => {
   denops.dispatcher = {
     ...denops.dispatcher,
-    "submatch": async (context, params, options) => {
+    "submatch": withHandleError(denops, async (context, params, options) => {
       assert(context, isSubmatchContext);
       assert(params, isSubmatchParams);
       assert(options, isOptions);
       return await submatchStart(denops, context, params, options);
-    },
+    }),
   };
 };