taler-typescript-core

commit 27454177ef11d33afe7a2f02eb29efb3ebcca06c
parent f3060f724c1689c6ecd743bdda5ba3e1b4d0fafe
Author: Sebastian <sebasjm@taler-systems.com>
Date:   Mon,  1 Jun 2026 11:21:26 -0300

use the same error handler in all spa

Diffstat:
M
packages/web-util/src/hooks/errors.ts
 | 
64
++++++++++++++++++++++++++++++++++------------------------------
M
packages/web-util/src/hooks/useAsync.ts
 | 
6
+++++-
M
packages/web-util/src/hooks/useChallenge.ts
 | 
56
++++++++++++++++++++++++++------------------------------

3 files changed, 65 insertions(+), 61 deletions(-)
diff --git a/packages/web-util/src/hooks/errors.ts b/packages/web-util/src/hooks/errors.ts
@@ -1,37 +1,41 @@
-import { useEffect, useErrorBoundary } from "preact/hooks";
+import { useErrorBoundary } from "preact/hooks";
 import { useTranslationContext } from "../context/translation.js";
+import { useNotificationContext } from "../index.browser.js";
 
-export function useRenderErrorReport() {
+export function useRenderErrorReport(appInfo: {
+  version: string;
+  hash: string;
+}) {
   const { i18n } = useTranslationContext();
-  const [error] = useErrorBoundary();
-
-  useEffect(() => {
+  const { displayError } = useNotificationContext();
+  useErrorBoundary((error) => {
     if (error) {
-      if (error instanceof Error) {
-        // notifyException(i18n.str`Internal error, please report.`, error);
-      } else {
-        // notifyError(
-        //   i18n.str`Internal error, please report.`,
-        //   String(error) as TranslatedString,
-        // );
-      }
-      console.log(error);
+    	// const currentVNode = getCurrentVNode();
+
+      const description = i18n.str`The process runtime thrown an Error which was unexpected and not properly handled. To report click the copy button and create an issue in https://bugs.taler.net.`;
+      displayError(
+        i18n.str`Render error.`,
+        {
+          error: convert(error),
+          location: window.location.href,
+          appInfo,
+          when: new Date().toUTCString(),
+        },
+        description,
+      );
+      console.log(description);
+      console.log(JSON.stringify(error, Object.getOwnPropertyNames(error), 2));
     }
-  }, [error]);
+  });
 }
 
-//   useEffect(() => {
-//     if (error) {
-//       if (error instanceof Error) {
-//         console.log("Internal error, please report", error);
-//         notifyException(i18n.str`Internal error, please report.`, error);
-//       } else {
-//         console.log("Internal error, please report", error);
-//         notifyError(
-//           i18n.str`Internal error, please report.`,
-//           String(error) as TranslatedString,
-//         );
-//       }
-//       resetError();
-//     }
-//   }, [error]);
+function convert(error: any) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack?.split("\n"),
+    };
+  }
+  return error;
+}
diff --git a/packages/web-util/src/hooks/useAsync.ts b/packages/web-util/src/hooks/useAsync.ts
@@ -171,8 +171,12 @@ export function useLongPolling<Res>(
  * @param ms
  * @returns
  */
-export async function delayMs(ms: number): Promise<void> {
+export async function delayMs(ms: number, ct?:CancellationToken): Promise<void> {
+
   return new Promise((resolve, reject) => {
     setTimeout(() => resolve(), ms);
+    if (ct) {
+      ct.onCancelled(reject)
+    }
   });
 }
diff --git a/packages/web-util/src/hooks/useChallenge.ts b/packages/web-util/src/hooks/useChallenge.ts
@@ -24,7 +24,7 @@ import {
   ChallengeResponse,
 } from "@gnu-taler/taler-util";
 import { useState } from "preact/hooks";
-import { SafeHandlerTemplate } from "./useNotifications.js";
+import { SafeHandler } from "./useNotifications.js";
 
 /**
  * State of the current MFA operation and handler to manage
@@ -32,22 +32,17 @@ import { SafeHandlerTemplate } from "./useNotifications.js";
  *
  */
 export interface MfaState {
-  /**
-   * If a mfa has been started this will contain
-   * the challenge response.
-   */
-  pendingChallenge: ChallengeResponse | undefined;
-
   onChallengeRequired: (
     c: ChallengeResponse,
-    repeat?: SafeHandlerTemplate<[ids: string[]], any>,
+    repeat: SafeHandler<[ids: string[]], unknown>,
   ) => void;
 
   onChallengeRequiredWithInitial: (
     c: ChallengeResponse,
     initial: { request: Challenge; response: ChallengeRequestResponse },
-    repeat?: SafeHandlerTemplate<[ids: string[]], any>,
+    repeat: SafeHandler<[ids: string[]], unknown>,
   ) => void;
+
   /**
    * Cancel the current pending challenge.
    *
@@ -55,9 +50,17 @@ export interface MfaState {
    */
   doCancelChallenge: () => void;
 
-  repeatCall?: SafeHandlerTemplate<[string[]], any>;
-
-  initial?: { request: Challenge; response: ChallengeRequestResponse };
+  /**
+   * If a mfa has been started this will contain
+   * the challenge response.
+   */
+  pendingChallenge:
+    | undefined
+    | {
+        response: ChallengeResponse;
+        repeatCall: SafeHandler<[string[]], unknown>;
+        initial?: { request: Challenge; response: ChallengeRequestResponse };
+      };
 }
 
 /**
@@ -80,20 +83,14 @@ export interface MfaHandler {
 }
 
 /**
- * asd
- */
-type CallbackFactory<T extends any[], R> = (
-  h: MfaHandler,
-) => (...args: T) => Promise<R>;
-
-/**
+ *
  * @returns
  */
 export function useChallengeHandler(): MfaState {
   const [state, setState] = useState<{
-    challenge: ChallengeResponse;
+    response: ChallengeResponse;
+    repeatCall: SafeHandler<[string[]], unknown>;
     initial?: { request: Challenge; response: ChallengeRequestResponse };
-    repeat?: SafeHandlerTemplate<[string[]], any>;
   }>();
 
   function reset() {
@@ -101,25 +98,24 @@ export function useChallengeHandler(): MfaState {
   }
 
   function onChallengeRequired(
-    challenge: ChallengeResponse,
-    repeat?: SafeHandlerTemplate<[string[]], any>,
+    response: ChallengeResponse,
+    repeatCall: SafeHandler<[string[]], any>,
   ) {
-    setState({ challenge, initial: undefined, repeat });
+    setState({ response, initial: undefined, repeatCall });
   }
   function onChallengeRequiredWithInitial(
-    challenge: ChallengeResponse,
+    response: ChallengeResponse,
     initial: { request: Challenge; response: ChallengeRequestResponse },
-    repeat?: SafeHandlerTemplate<[string[]], any>,
+    repeatCall: SafeHandler<[string[]], any>,
   ) {
-    setState({ challenge, initial, repeat });
+    setState({ response, initial, repeatCall });
   }
 
   return {
     doCancelChallenge: reset,
     onChallengeRequired,
     onChallengeRequiredWithInitial,
-    pendingChallenge: state?.challenge,
-    repeatCall: state?.repeat,
-    initial: state?.initial,
+
+    pendingChallenge: state,
   };
 }