wallet-core/packages/demobank-ui/src/utils.ts

/*
 This file is part of GNU Taler
 (C) 2022 Taler Systems S.A.

 GNU Taler is free software; you can redistribute it and/or modify it under the
 terms of the GNU General Public License as published by the Free Software
 Foundation; either version 3, or (at your option) any later version.

 GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

 You should have received a copy of the GNU General Public License along with
 GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */

import { HttpStatusCode, TranslatedString } from "@gnu-taler/taler-util";
import {
  ErrorType,
  HttpError,
  useTranslationContext,
} from "@gnu-taler/web-util/lib/index.browser";
import { ErrorMessage } from "./context/pageState.js";

/**
 * Validate (the number part of) an amount.  If needed,
 * replace comma with a dot.  Returns 'false' whenever
 * the input is invalid, the valid amount otherwise.
 */
const amountRegex = /^[0-9]+(.[0-9]+)?$/;
export function validateAmount(
  maybeAmount: string | undefined,
): string | undefined {
  if (!maybeAmount || !amountRegex.test(maybeAmount)) {
    return;
  }
  return maybeAmount;
}

/**
 * Extract IBAN from a Payto URI.
 */
export function getIbanFromPayto(url: string): string {
  const pathSplit = new URL(url).pathname.split("/");
  let lastIndex = pathSplit.length - 1;
  // Happens if the path ends with "/".
  if (pathSplit[lastIndex] === "") lastIndex--;
  const iban = pathSplit[lastIndex];
  return iban;
}

export function undefinedIfEmpty<T extends object>(obj: T): T | undefined {
  return Object.keys(obj).some((k) => (obj as any)[k] !== undefined)
    ? obj
    : undefined;
}

export type PartialButDefined<T> = {
  [P in keyof T]: T[P] | undefined;
};

export type WithIntermediate<Type extends object> = {
  [prop in keyof Type]: Type[prop] extends object
    ? WithIntermediate<Type[prop]>
    : Type[prop] | undefined;
};
export type RecursivePartial<T> = {
  [P in keyof T]?: T[P] extends (infer U)[]
    ? RecursivePartial<U>[]
    : T[P] extends object
    ? RecursivePartial<T[P]>
    : T[P];
};

export enum TanChannel {
  SMS = "sms",
  EMAIL = "email",
  FILE = "file",
}
export enum CashoutStatus {
  // The payment was initiated after a valid
  // TAN was received by the bank.
  CONFIRMED = "confirmed",

  // The cashout was created and now waits
  // for the TAN by the author.
  PENDING = "pending",
}

// export function partialWithObjects<T extends object>(obj: T | undefined, () => complete): WithIntermediate<T> {
//   const root = obj === undefined ? {} : obj;
//   return Object.entries(root).([key, value]) => {

//   })
//   return undefined as any
// }

/**
 * Craft headers with Authorization and Content-Type.
 */
// export function prepareHeaders(username?: string, password?: string): Headers {
//   const headers = new Headers();
//   if (username && password) {
//     headers.append(
//       "Authorization",
//       `Basic ${window.btoa(`${username}:${password}`)}`,
//     );
//   }
//   headers.append("Content-Type", "application/json");
//   return headers;
// }

export const PAGE_SIZE = 20;
export const MAX_RESULT_SIZE = PAGE_SIZE * 2 - 1;

export function buildRequestErrorMessage(
  i18n: ReturnType<typeof useTranslationContext>["i18n"],
  cause: HttpError<SandboxBackend.SandboxError>,
  specialCases: {
    onClientError?: (status: HttpStatusCode) => TranslatedString | undefined;
    onServerError?: (status: HttpStatusCode) => TranslatedString | undefined;
  } = {},
): ErrorMessage {
  let result: ErrorMessage;
  switch (cause.type) {
    case ErrorType.TIMEOUT: {
      result = {
        title: i18n.str`Request timeout`,
      };
      break;
    }
    case ErrorType.CLIENT: {
      const title =
        specialCases.onClientError && specialCases.onClientError(cause.status);
      result = {
        title: title ? title : i18n.str`The server didn't accept the request`,
        description: cause.payload.error.description,
        debug: JSON.stringify(cause),
      };
      break;
    }
    case ErrorType.SERVER: {
      const title =
        specialCases.onServerError && specialCases.onServerError(cause.status);
      result = {
        title: title
          ? title
          : i18n.str`The server had problems processing the request`,
        description: cause.payload.error.description,
        debug: JSON.stringify(cause),
      };
      break;
    }
    case ErrorType.UNEXPECTED: {
      result = {
        title: i18n.str`Unexpected error`,
        debug: JSON.stringify(cause),
      };
      break;
    }
  }
  return result;
}