From beb5dee3a6435871fde288aa21af19594536db17 Mon Sep 17 00:00:00 2001
From: Salif Mehmed <mail@salif.eu>
Date: Sun, 17 Mar 2024 21:59:48 +0200
Subject: [PATCH] Do not panic

---
 index.html                                    |   2 +-
 index.js                                      |  45 ++--
 .../morse_code_translator.mjs                 | 249 ++++++++++--------
 src_gleam/gleam.toml                          |  15 +-
 src_gleam/src/morse_code_translator.gleam     | 170 ++++++++----
 5 files changed, 283 insertions(+), 198 deletions(-)

diff --git a/index.html b/index.html
index a875df4..c0a0fc2 100644
--- a/index.html
+++ b/index.html
@@ -42,7 +42,7 @@
             </td>
         </tr>
     </table>
-    <script type="module" src="./index.js"></script>
+    <script type="module" src="./index.js?v=1"></script>
     <style>
         #main_table {
             margin: auto;
diff --git a/index.js b/index.js
index 0a3e74c..d109386 100644
--- a/index.js
+++ b/index.js
@@ -20,14 +20,16 @@ function oninp(this_inp, skip_abc) {
     if (this_inp.str_dot === "abc" && this_inp.str_dash === "") {
         // first non abc textarea
         const t_inp = window.inputs[0]
-        try {
-            // TODO: language
-            t_inp.el.value = morse_code.encode(window.characters_dict.get("1"), this_inp.el.value,
-                new morse_code.EncodeOptions(t_inp.str_dot, t_inp.str_dash, t_inp.str_sp, t_inp.str_sep, false))
-        } catch (err) {
-            // panic from gleam
+        // TODO: language
+        const result = morse_code.encode(
+            window.characters_dict.get("1"), this_inp.el.value, new morse_code.EncodeOptions(
+                t_inp.str_dot, t_inp.str_dash, t_inp.str_sp, t_inp.str_sep, false))
+        // TODO: improve
+        if (result.isOk()) {
+            t_inp.el.value = result["0"]
+        } else {
             window.inputs.forEach(inp => {
-                inp.el.value = err
+                inp.el.value = result["0"].msg
             })
             return
         }
@@ -36,26 +38,22 @@ function oninp(this_inp, skip_abc) {
     } else {
         // skip because abc is input
         if (!skip_abc) {
-            try {
-                window.input_abc.el.value = morse_code.decode(window.characters_list.get("1"), this_inp.el.value, new morse_code.DecodeOptions(this_inp.str_dot,
-                    this_inp.str_dash, this_inp.str_sp, this_inp.str_sep, false))
-            }
-            catch (err) {
-                // panic from gleam
-                window.input_abc.el.value = err
-            }
+            window.input_abc.el.value = morse_code.decode_to_string(
+                window.characters_list.get("1"), this_inp.el.value, new morse_code.DecodeOptions(
+                    this_inp.str_dot, this_inp.str_dash, this_inp.str_sp, this_inp.str_sep, false))
+
         }
         window.inputs.forEach(inp => {
             // skip input object
             if (!(this_inp.str_dot === inp.str_dot && this_inp.str_dash === inp.str_dash &&
                 this_inp.str_sp === inp.str_sp && this_inp.str_sep === inp.str_sep)) {
-                try {
-                    inp.el.value = morse_code.convert(this_inp.el.value, new morse_code.ConvertOptions(this_inp.str_dot, inp.str_dot,
-                        this_inp.str_dash, inp.str_dash, this_inp.str_sp, inp.str_sp, this_inp.str_sep, inp.str_sep))
-                } catch (err) {
-                    // panic from gleam
-                    inp.el.value = err
-                }
+                inp.el.value = morse_code.convert_to_string(this_inp.el.value,
+                    new morse_code.ConvertOptions(
+                        this_inp.str_dot, inp.str_dot,
+                        this_inp.str_dash, inp.str_dash,
+                        this_inp.str_sp, inp.str_sp,
+                        this_inp.str_sep, inp.str_sep))
+
             }
         })
     }
@@ -68,7 +66,8 @@ function escapeHtml(unsafe) {
 
 function main_table_add_row(fn_oninput, options) {
     const new_row = window.main_table.insertRow(0)
-    new_row.insertCell(0).innerHTML = "<span>" + escapeHtml(options.str_dot + options.str_dash) + "</span>"
+    new_row.insertCell(0).innerHTML = "<span>" +
+        escapeHtml(options.str_dot + options.str_dash) + "</span>"
     const new_cell = new_row.insertCell(1)
     new_cell.style.width = "100%"
     const el_text_area = document.createElement("textarea")
diff --git a/src_gleam/build/dev/javascript/morse_code_translator/morse_code_translator.mjs b/src_gleam/build/dev/javascript/morse_code_translator/morse_code_translator.mjs
index 1f1762d..5700688 100644
--- a/src_gleam/build/dev/javascript/morse_code_translator/morse_code_translator.mjs
+++ b/src_gleam/build/dev/javascript/morse_code_translator/morse_code_translator.mjs
@@ -1,8 +1,16 @@
 import * as $dict from "../gleam_stdlib/gleam/dict.mjs";
 import * as $list from "../gleam_stdlib/gleam/list.mjs";
+import * as $result from "../gleam_stdlib/gleam/result.mjs";
 import * as $string from "../gleam_stdlib/gleam/string.mjs";
 import * as $ch from "./characters.mjs";
-import { CustomType as $CustomType, makeError, isEqual } from "./gleam.mjs";
+import { Ok, Error, CustomType as $CustomType, isEqual } from "./gleam.mjs";
+
+export class MorseCodeError extends $CustomType {
+  constructor(msg) {
+    super();
+    this.msg = msg;
+  }
+}
 
 export class EncodeOptions extends $CustomType {
   constructor(output_dot, output_dash, output_space, output_separator, is_uppercase_only) {
@@ -43,17 +51,17 @@ export class ConvertOptions extends $CustomType {
 export function encode(morse_code_dict, input, options) {
   let _pipe = input;
   let _pipe$1 = $string.to_graphemes(_pipe);
-  let _pipe$2 = $list.map(
+  let _pipe$2 = $list.try_map(
     _pipe$1,
     (g) => {
       if (g === " ") {
-        return options.output_space;
+        return new Ok(options.output_space);
       } else if (g === "\n") {
-        return options.output_space;
+        return new Ok(options.output_space);
       } else if (g === "\r") {
-        return options.output_space;
+        return new Ok(options.output_space);
       } else if (g === "\t") {
-        return options.output_space;
+        return new Ok(options.output_space);
       } else {
         let g$1 = (() => {
           let $ = options.is_uppercase_only;
@@ -63,140 +71,167 @@ export function encode(morse_code_dict, input, options) {
             return $string.uppercase(g);
           }
         })();
-        let mc_bools = $dict.get(morse_code_dict, g$1);
-        let mc_bools$1 = (() => {
-          if (mc_bools.isOk()) {
-            let value = mc_bools[0];
-            return value;
-          } else {
-            throw makeError(
-              "todo",
-              "morse_code_translator",
-              36,
-              "",
-              ("Invalid symbol: " + g$1),
-              {}
-            )
-          }
-        })();
-        let _pipe$2 = mc_bools$1;
-        let _pipe$3 = $list.map(
-          _pipe$2,
-          (b) => {
-            if (b) {
-              return options.output_dash;
-            } else {
-              return options.output_dot;
-            }
-          },
-        );
-        return $string.join(_pipe$3, "");
+        let $ = $dict.get(morse_code_dict, g$1);
+        if ($.isOk()) {
+          let bools = $[0];
+          let _pipe$2 = bools;
+          let _pipe$3 = $list.map(
+            _pipe$2,
+            (b) => {
+              if (b) {
+                return options.output_dash;
+              } else {
+                return options.output_dot;
+              }
+            },
+          );
+          let _pipe$4 = $string.join(_pipe$3, "");
+          return new Ok(_pipe$4);
+        } else {
+          return new Error(new MorseCodeError("Invalid symbol: " + g$1));
+        }
       }
     },
   );
-  return $string.join(_pipe$2, options.output_separator);
+  return $result.map(
+    _pipe$2,
+    (_capture) => { return $string.join(_capture, options.output_separator); },
+  );
+}
+
+export function encode_to_string(morse_code_dict, input, options) {
+  let $ = encode(morse_code_dict, input, options);
+  if ($.isOk()) {
+    let value = $[0];
+    return value;
+  } else {
+    let value = $[0];
+    return value.msg;
+  }
+}
+
+function list_value_find(values, desired_value) {
+  let key = (() => {
+    let _pipe = values;
+    return $list.find(
+      _pipe,
+      (k) => {
+        let v = k[1];
+        if (isEqual(v, desired_value)) {
+          return true;
+        } else {
+          return false;
+        }
+      },
+    );
+  })();
+  if (key.isOk()) {
+    let value = key[0];
+    return new Ok(value[0]);
+  } else {
+    return new Error(undefined);
+  }
 }
 
 export function decode(morse_code_list, input, options) {
   let _pipe = input;
   let _pipe$1 = $string.split(_pipe, options.input_separator);
-  let _pipe$2 = $list.map(
+  let _pipe$2 = $list.try_map(
     _pipe$1,
     (w) => {
       let $ = true;
       if (w === "") {
-        return "";
+        return new Ok("");
       } else if (w === options.input_space) {
-        return " ";
+        return new Ok(" ");
       } else {
-        let mc_bools = (() => {
-          let _pipe$2 = w;
-          let _pipe$3 = $string.to_graphemes(_pipe$2);
-          return $list.map(
-            _pipe$3,
-            (g) => {
-              let $1 = true;
-              if (g === options.input_dot) {
-                return false;
-              } else if (g === options.input_dash) {
-                return true;
-              } else {
-                throw makeError(
-                  "todo",
-                  "morse_code_translator",
-                  81,
-                  "",
-                  ("Invalid morse code symbol: " + g),
-                  {}
-                )
-              }
-            },
-          );
-        })();
-        let mc_found = (() => {
-          let _pipe$2 = morse_code_list;
-          return $list.find(
-            _pipe$2,
-            (k) => {
-              let v = k[1];
-              if (isEqual(v, mc_bools)) {
-                return true;
+        let _pipe$2 = w;
+        let _pipe$3 = $string.to_graphemes(_pipe$2);
+        let _pipe$4 = $list.try_map(
+          _pipe$3,
+          (g) => {
+            let $1 = true;
+            if (g === options.input_dot) {
+              return new Ok(false);
+            } else if (g === options.input_dash) {
+              return new Ok(true);
+            } else {
+              return new Error(
+                new MorseCodeError("Invalid morse code symbol: " + g),
+              );
+            }
+          },
+        );
+        return $result.try$(
+          _pipe$4,
+          (bools) => {
+            let $1 = list_value_find(morse_code_list, bools);
+            if ($1.isOk()) {
+              let value = $1[0];
+              let $2 = options.to_uppercase;
+              if ($2) {
+                return new Ok(value);
               } else {
-                return false;
+                return new Ok($string.lowercase(value));
               }
-            },
-          );
-        })();
-        if (mc_found.isOk()) {
-          let value = mc_found[0];
-          let $1 = options.to_uppercase;
-          if ($1) {
-            return value[0];
-          } else {
-            return $string.lowercase(value[0]);
-          }
-        } else {
-          throw makeError(
-            "todo",
-            "morse_code_translator",
-            99,
-            "",
-            ("Invalid symbol: " + w),
-            {}
-          )
-        }
+            } else {
+              return new Error(new MorseCodeError("Invalid symbol: " + w));
+            }
+          },
+        );
       }
     },
   );
-  return $string.join(_pipe$2, "");
+  return $result.map(
+    _pipe$2,
+    (_capture) => { return $string.join(_capture, ""); },
+  );
+}
+
+export function decode_to_string(morse_code_list, input, options) {
+  let $ = decode(morse_code_list, input, options);
+  if ($.isOk()) {
+    let value = $[0];
+    return value;
+  } else {
+    let value = $[0];
+    return value.msg;
+  }
 }
 
 export function convert(input, options) {
   let _pipe = input;
   let _pipe$1 = $string.to_graphemes(_pipe);
-  let _pipe$2 = $list.map(
+  let _pipe$2 = $list.try_map(
     _pipe$1,
     (g) => {
       let $ = true;
       if (g === options.input_separator) {
-        return options.output_separator;
+        return new Ok(options.output_separator);
       } else if (g === options.input_space) {
-        return options.output_space;
+        return new Ok(options.output_space);
       } else if (g === options.input_dot) {
-        return options.output_dot;
+        return new Ok(options.output_dot);
       } else if (g === options.input_dash) {
-        return options.output_dash;
+        return new Ok(options.output_dash);
       } else {
-        throw makeError(
-          "todo",
-          "morse_code_translator",
-          129,
-          "",
-          ("Invalid morse code symbol: " + g),
-          {}
-        )
+        return new Error(new MorseCodeError("Invalid morse code symbol: " + g));
       }
     },
   );
-  return $string.join(_pipe$2, "");
+  return $result.map(
+    _pipe$2,
+    (_capture) => { return $string.join(_capture, ""); },
+  );
+}
+
+export function convert_to_string(input, options) {
+  let $ = convert(input, options);
+  if ($.isOk()) {
+    let value = $[0];
+    return value;
+  } else {
+    let value = $[0];
+    return value.msg;
+  }
 }
diff --git a/src_gleam/gleam.toml b/src_gleam/gleam.toml
index 8b4f7f0..809fd0d 100644
--- a/src_gleam/gleam.toml
+++ b/src_gleam/gleam.toml
@@ -1,16 +1,13 @@
 name = "morse_code_translator"
 version = "1.0.0"
 
-# Fill out these fields if you intend to generate HTML documentation or publish
-# your project to the Hex package manager.
-#
-# description = ""
+description = "Morse Code Translator"
 licences = ["MIT"]
-# repository = { type = "github", user = "username", repo = "project" }
-# links = [{ title = "Website", href = "https://gleam.run" }]
-#
-# For a full reference of all the available options, you can have a look at
-# https://gleam.run/writing-gleam/gleam-toml/.
+links = [
+  {title = "Website", href = "https://salif.github.io/morse-code-translator"},
+  {title = "Codeberg", href = "https://codeberg.org/salif/morse-code-translator"},
+]
+repository = {type = "github", user = "salif", repo = "morse-code-translator"}
 
 target = "javascript"
 
diff --git a/src_gleam/src/morse_code_translator.gleam b/src_gleam/src/morse_code_translator.gleam
index 25a1387..5e31efe 100644
--- a/src_gleam/src/morse_code_translator.gleam
+++ b/src_gleam/src/morse_code_translator.gleam
@@ -1,8 +1,13 @@
 import gleam/dict
 import gleam/string
 import gleam/list
+import gleam/result
 import characters as ch
 
+pub type MorseCodeError {
+    MorseCodeError(msg: String)
+}
+
 pub type EncodeOptions {
     EncodeOptions(
         output_dot: String,
@@ -17,36 +22,46 @@ pub fn encode(
     morse_code_dict: ch.MorseCodeDict,
     input: String,
     options: EncodeOptions,
-) -> String {
+) -> Result(String, MorseCodeError) {
     input
     |> string.to_graphemes
-    |> list.map(fn(g: String) -> String {
+    |> list.try_map(fn(g: String) -> Result(String, MorseCodeError) {
         case g {
-            // if space, new line, tab
-            " " | "\n" | "\r" | "\t" -> options.output_space
+            " " | "\n" | "\r" | "\t" -> Ok(options.output_space)
             _ -> {
                 let g: String = case options.is_uppercase_only {
                     True -> g
                     False -> string.uppercase(g)
                 }
-                let mc_bools: Result(List(Bool), Nil) =
-                    dict.get(morse_code_dict, g)
-                let mc_bools = case mc_bools {
-                    Ok(value) -> value
-                    Error(_) -> panic as { "Invalid symbol: " <> g }
-                }
-                mc_bools
-                |> list.map(fn(b: Bool) -> String {
-                    case b {
-                        True -> options.output_dash
-                        False -> options.output_dot
+                case dict.get(morse_code_dict, g) {
+                    Ok(bools) -> {
+                        bools
+                        |> list.map(fn(b: Bool) -> String {
+                            case b {
+                                True -> options.output_dash
+                                False -> options.output_dot
+                            }
+                        })
+                        |> string.join("")
+                        |> Ok
                     }
-                })
-                |> string.join("")
+                    Error(_) -> Error(MorseCodeError("Invalid symbol: " <> g))
+                }
             }
         }
     })
-    |> string.join(options.output_separator)
+    |> result.map(string.join(_, options.output_separator))
+}
+
+pub fn encode_to_string(
+    morse_code_dict: ch.MorseCodeDict,
+    input: String,
+    options: EncodeOptions,
+) -> String {
+    case encode(morse_code_dict, input, options) {
+        Ok(value) -> value
+        Error(value) -> value.msg
+    }
 }
 
 pub type DecodeOptions {
@@ -63,45 +78,74 @@ pub fn decode(
     morse_code_list: ch.MorseCodeList,
     input: String,
     options: DecodeOptions,
-) -> String {
+) -> Result(String, MorseCodeError) {
     input
     |> string.split(options.input_separator)
-    |> list.map(fn(w: String) -> String {
+    |> list.try_map(fn(w: String) -> Result(String, MorseCodeError) {
         case True {
-            _ if w == "" -> ""
-            _ if w == options.input_space -> " "
+            _ if w == "" -> Ok("")
+            _ if w == options.input_space -> Ok(" ")
             _ -> {
-                let mc_bools: List(Bool) =
-                    w
-                    |> string.to_graphemes
-                    |> list.map(fn(g: String) -> Bool {
-                        case True {
-                            _ if g == options.input_dot -> False
-                            _ if g == options.input_dash -> True
-                            _ -> panic as { "Invalid morse code symbol: " <> g }
-                        }
-                    })
-                let mc_found: Result(#(String, List(Bool)), Nil) =
-                    morse_code_list
-                    |> list.find(fn(k: #(String, List(Bool))) -> Bool {
-                        let v: List(Bool) = k.1
-                        case v {
-                            _ if v == mc_bools -> True
-                            _ -> False
-                        }
-                    })
-                case mc_found {
-                    Ok(value) ->
-                        case options.to_uppercase {
-                            True -> value.0
-                            False -> string.lowercase(value.0)
-                        }
-                    Error(_) -> panic as { "Invalid symbol: " <> w }
-                }
+                w
+                |> string.to_graphemes
+                |> list.try_map(fn(g: String) -> Result(Bool, MorseCodeError) {
+                    case True {
+                        _ if g == options.input_dot -> Ok(False)
+                        _ if g == options.input_dash -> Ok(True)
+                        _ ->
+                            Error(MorseCodeError(
+                                "Invalid morse code symbol: " <> g,
+                            ))
+                    }
+                })
+                |> result.try(fn(bools: List(Bool)) -> Result(
+                    String,
+                    MorseCodeError,
+                ) {
+                    case list_value_find(morse_code_list, bools) {
+                        Ok(value) ->
+                            case options.to_uppercase {
+                                True -> Ok(value)
+                                False -> Ok(string.lowercase(value))
+                            }
+                        Error(_) ->
+                            Error(MorseCodeError("Invalid symbol: " <> w))
+                    }
+                })
             }
         }
     })
-    |> string.join("")
+    |> result.map(string.join(_, ""))
+}
+
+fn list_value_find(
+    in values: List(#(String, List(Bool))),
+    find desired_value: List(Bool),
+) -> Result(String, Nil) {
+    let key: Result(#(String, List(Bool)), Nil) =
+        values
+        |> list.find(fn(k: #(String, List(Bool))) -> Bool {
+            let v: List(Bool) = k.1
+            case v {
+                _ if v == desired_value -> True
+                _ -> False
+            }
+        })
+    case key {
+        Ok(value) -> Ok(value.0)
+        Error(_) -> Error(Nil)
+    }
+}
+
+pub fn decode_to_string(
+    morse_code_list: ch.MorseCodeList,
+    input: String,
+    options: DecodeOptions,
+) -> String {
+    case decode(morse_code_list, input, options) {
+        Ok(value) -> value
+        Error(value) -> value.msg
+    }
 }
 
 pub type ConvertOptions {
@@ -117,17 +161,27 @@ pub type ConvertOptions {
     )
 }
 
-pub fn convert(input: String, options: ConvertOptions) -> String {
+pub fn convert(
+    input: String,
+    options: ConvertOptions,
+) -> Result(String, MorseCodeError) {
     input
     |> string.to_graphemes
-    |> list.map(fn(g: String) -> String {
+    |> list.try_map(fn(g: String) -> Result(String, MorseCodeError) {
         case True {
-            _ if g == options.input_separator -> options.output_separator
-            _ if g == options.input_space -> options.output_space
-            _ if g == options.input_dot -> options.output_dot
-            _ if g == options.input_dash -> options.output_dash
-            _ -> panic as { "Invalid morse code symbol: " <> g }
+            _ if g == options.input_separator -> Ok(options.output_separator)
+            _ if g == options.input_space -> Ok(options.output_space)
+            _ if g == options.input_dot -> Ok(options.output_dot)
+            _ if g == options.input_dash -> Ok(options.output_dash)
+            _ -> Error(MorseCodeError("Invalid morse code symbol: " <> g))
         }
     })
-    |> string.join("")
+    |> result.map(string.join(_, ""))
+}
+
+pub fn convert_to_string(input: String, options: ConvertOptions) -> String {
+    case convert(input, options) {
+        Ok(value) -> value
+        Error(value) -> value.msg
+    }
 }