From 0e9a648964f55902d0dbfb77fb4f80e5128cef6d Mon Sep 17 00:00:00 2001
From: ignaciolarranaga <ignaciolarranaga@gmail.com>
Date: Tue, 23 May 2023 10:35:44 -0300
Subject: [PATCH] Adding spanish internationalization.

---
 src/strings.ts | 301 +++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 253 insertions(+), 48 deletions(-)

diff --git a/src/strings.ts b/src/strings.ts
index 3f701c1..f212178 100644
--- a/src/strings.ts
+++ b/src/strings.ts
@@ -1,189 +1,384 @@
 /**
  * @fileoverview
  * Strings used by {@class Html5Qrcode} & {@class Html5QrcodeScanner}
- * 
+ *
  * @author mebjas <minhazav@gmail.com>
- * 
+ *
  * The word "QR Code" is registered trademark of DENSO WAVE INCORPORATED
  * http://www.denso-wave.com/qrcode/faqpatent-e.html
  */
 
+let locale = 'en';
+
+export function setLocale(newLocale: 'en' | 'es') {
+  locale = newLocale;
+}
+
 /**
  * Strings used in {@class Html5Qrcode}.
- * 
+ *
  * TODO(mebjas): Support internalization.
  */
 export class Html5QrcodeStrings {
 
     public static codeParseError(exception: any): string {
-        return `QR code parse error, error = ${exception}`;
+        switch (locale) {
+            case 'es':
+                return `Error de análisis de código QR, error = ${exception}`;
+            default:
+                return `QR code parse error, error = ${exception}`;
+        }
     }
 
     public static errorGettingUserMedia(error: any): string {
-        return `Error getting userMedia, error = ${error}`;
+        switch (locale) {
+            case 'es':
+                return `Error obteniendo userMedia, error = ${error}`;
+            default:
+                return `Error getting userMedia, error = ${error}`;
+        }
     }
 
     public static onlyDeviceSupportedError(): string {
-        return "The device doesn't support navigator.mediaDevices , only "
-        + "supported cameraIdOrConfig in this case is deviceId parameter "
-        + "(string).";
+        switch (locale) {
+            case 'es':
+                "El dispositivo no es compatible con navigator.mediaDevices, "
+                + "cameraIdOrConfig solo soporta el parámetro deviceId en este caso "
+                + "(string).";
+            default:
+                return "The device doesn't support navigator.mediaDevices , only "
+                + "supported cameraIdOrConfig in this case is deviceId parameter "
+                + "(string).";
+        }
+
     }
 
     public static cameraStreamingNotSupported(): string {
-        return "Camera streaming not supported by the browser.";
+        switch (locale) {
+            case 'es':
+                return "La transmisión de la cámara no es compatible con el navegador.";
+            default:
+                return "Camera streaming not supported by the browser.";
+        }
     }
 
     public static unableToQuerySupportedDevices(): string {
-        return "Unable to query supported devices, unknown error.";
+        switch (locale) {
+            case 'es':
+                return "No se pueden consultar los dispositivos compatibles, error desconocido.";
+            default:
+                return "Unable to query supported devices, unknown error.";
+        }
     }
 
     public static insecureContextCameraQueryError(): string {
-        return "Camera access is only supported in secure context like https "
-        + "or localhost.";
+        switch (locale) {
+            case 'es':
+                return "El acceso a la cámara solo se admite en un contexto seguro como https"
+                + "o localhost.";
+            default:
+                return "Camera access is only supported in secure context like https "
+                + "or localhost.";
+        }
     }
 
     public static scannerPaused(): string {
-        return "Scanner paused";
+        switch (locale) {
+            case 'es':
+                return "Escáner en pausa";
+            default:
+                return "Scanner paused";
+        }
     }
 }
 
 /**
  * Strings used in {@class Html5QrcodeScanner}.
- * 
+ *
  * TODO(mebjas): Support internalization.
  */
 export class Html5QrcodeScannerStrings {
 
     public static scanningStatus(): string {
-        return "Scanning";
+        switch (locale) {
+            case 'es':
+                return "Escaneando";
+            default:
+                return "Scanning";
+        }
     }
 
     public static idleStatus(): string {
-        return "Idle";
+        switch (locale) {
+            case 'es':
+                return "Inactiva";
+            default:
+                return "Idle";
+        }
     }
 
     public static errorStatus(): string {
-        return "Error";
+        switch (locale) {
+            case 'es':
+                return "Error";
+            default:
+                return "Error";
+        }
     }
 
     public static permissionStatus(): string {
-        return "Permission";
+        switch (locale) {
+            case 'es':
+                return "Permiso";
+            default:
+                return "Permission";
+        }
     }
 
     public static noCameraFoundErrorStatus(): string {
-        return "No Cameras";
+        switch (locale) {
+            case 'es':
+                return "Sin cámaras";
+            default:
+                return "No Cameras";
+        }
     }
 
     public static lastMatch(decodedText: string): string {
-        return `Last Match: ${decodedText}`;
+        switch (locale) {
+            case 'es':
+                return `Última coincidencia: ${decodedText}`;
+            default:
+                return `Last Match: ${decodedText}`;
+        }
     }
 
     public static codeScannerTitle(): string {
-        return "Code Scanner";
+        switch (locale) {
+            case 'es':
+                return "Escáner de Código";
+            default:
+                return "Code Scanner";
+        }
     }
 
     public static cameraPermissionTitle(): string {
-        return "Request Camera Permissions";
+        switch (locale) {
+            case 'es':
+                return "Solicitar permisos de cámara";
+            default:
+                return "Request Camera Permissions";
+        }
     }
 
     public static cameraPermissionRequesting(): string {
-        return "Requesting camera permissions...";
+        switch (locale) {
+            case 'es':
+                return "Solicitando permisos de cámara...";
+            default:
+                return "Requesting camera permissions...";
+        }
     }
 
     public static noCameraFound(): string {
-        return "No camera found";
+        switch (locale) {
+            case 'es':
+                return "No se encontró ninguna cámara";
+            default:
+                return "No camera found";
+        }
     }
 
     public static scanButtonStopScanningText(): string {
-        return "Stop Scanning";
+        switch (locale) {
+            case 'es':
+                return "Dejar de escanear";
+            default:
+                return "Stop Scanning";
+        }
     }
 
     public static scanButtonStartScanningText(): string {
-        return "Start Scanning";
+        switch (locale) {
+            case 'es':
+                return "Comenzar a escanear";
+            default:
+                return "Start Scanning";
+        }
     }
 
     public static torchOnButton(): string {
-        return "Switch On Torch";
+        switch (locale) {
+            case 'es':
+                return "Encender Torch";
+            default:
+                return "Switch On Torch";
+        }
     }
 
     public static torchOffButton(): string {
-        return "Switch Off Torch";
+        switch (locale) {
+            case 'es':
+                return "Apagar Torch";
+            default:
+                return "Switch Off Torch";
+        }
     }
 
     public static torchOnFailedMessage(): string {
-        return "Failed to turn on torch";
+        switch (locale) {
+            case 'es':
+                return "Error al encender torch";
+            default:
+                return "Failed to turn on torch";
+        }
     }
 
     public static torchOffFailedMessage(): string {
-        return "Failed to turn off torch";
+        switch (locale) {
+            case 'es':
+                return "Error al apagar torch";
+            default:
+                return "Failed to turn off torch";
+        }
     }
 
     public static scanButtonScanningStarting(): string {
-        return "Launching Camera...";
+        switch (locale) {
+            case 'es':
+                return "Iniciando la Cámara...";
+            default:
+                return "Launching Camera...";
+        }
     }
 
     /**
      * Text to show when camera scan is selected.
-     * 
+     *
      * This will be used to switch to file based scanning.
      */
     public static textIfCameraScanSelected(): string {
-        return "Scan an Image File";
+        switch (locale) {
+            case 'es':
+                return "Escanear un Archivo de Imagen";
+            default:
+                return "Scan an Image File";
+        }
     }
 
     /**
      * Text to show when file based scan is selected.
-     * 
+     *
      * This will be used to switch to camera based scanning.
      */
     public static textIfFileScanSelected(): string {
-        return "Scan using camera directly";
+        switch (locale) {
+            case 'es':
+                return "Escanear usando la cámara directamente";
+            default:
+                return "Scan using camera directly";
+        }
     }
 
     public static selectCamera(): string {
-        return "Select Camera";
+        switch (locale) {
+            case 'es':
+                return "Seleccionar Cámara";
+            default:
+                return "Select Camera";
+        }
     }
 
     public static fileSelectionChooseImage(): string {
-        return "Choose Image";
+        switch (locale) {
+            case 'es':
+                return "Elegir Imagen";
+            default:
+                return "Choose Image";
+        }
     }
 
     public static fileSelectionChooseAnother(): string {
-        return "Choose Another";
+        switch (locale) {
+            case 'es':
+                return "Elegir Otra";
+            default:
+                return "Choose Another";
+        }
     }
 
     public static fileSelectionNoImageSelected(): string {
-        return "No image choosen";
+        switch (locale) {
+            case 'es':
+                return "Ninguna imagen elegida";
+            default:
+                return "No image choosen";
+        }
     }
 
     /** Prefix to be given to anonymous cameras. */
     public static anonymousCameraPrefix(): string {
-        return "Anonymous Camera";
+        switch (locale) {
+            case 'es':
+                return "Cámara Anónima";
+            default:
+                return "Anonymous Camera";
+        }
     }
 
     public static dragAndDropMessage(): string {
-        return "Or drop an image to scan";
+        switch (locale) {
+            case 'es':
+                return "O elige una imagen para escanear";
+            default:
+                return "Or drop an image to scan";
+        }
     }
 
     public static dragAndDropMessageOnlyImages(): string {
-        return "Or drop an image to scan (other files not supported)";
+        switch (locale) {
+            case 'es':
+                return "O elige una imagen para escanear (no se admiten otros archivos)";
+            default:
+                return "Or drop an image to scan (other files not supported)";
+        }
     }
 
     /** Value for zoom. */
     public static zoom(): string {
-        return "zoom";
+        switch (locale) {
+            case 'es':
+                return "zoom";
+            default:
+                return "zoom";
+        }
     }
 
     public static loadingImage(): string {
-        return "Loading image...";
+        switch (locale) {
+            case 'es':
+                return "Cargando imagen...";
+            default:
+                return "Loading image...";
+        }
     }
 
     public static cameraScanAltText(): string {
-        return "Camera based scan";
+        switch (locale) {
+            case 'es':
+                return "Escaneo basado en cámara";
+            default:
+                return "Camera based scan";
+        }
     }
 
     public static fileScanAltText(): string {
-        return "Fule based scan";
+        switch (locale) {
+            case 'es':
+                return "Escaneo basado en Fule";
+            default:
+                return "Fule based scan";
+        }
     }
 }
 
@@ -191,10 +386,20 @@ export class Html5QrcodeScannerStrings {
 export class LibraryInfoStrings {
 
     public static poweredBy(): string {
-        return "Powered by ";
+        switch (locale) {
+            case 'es':
+                return "Desarrollado por ";
+            default:
+                return "Powered by ";
+        }
     }
 
     public static reportIssues(): string {
-        return "Report issues";
+        switch (locale) {
+            case 'es':
+                return "Informar problemas";
+            default:
+                return "Report issues";
+        }
     }
 }