@kaiko.io/rescript-deser 3.1.0 → 3.1.2

package/lib/js/src/JSON.js

@@ -0,0 +1,627 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Curry = require("rescript/lib/js/curry.js");
+var Js_json = require("rescript/lib/js/js_json.js");
+var Prelude = require("@kaiko.io/rescript-prelude/lib/js/src/Prelude.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
+var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
+
+var FieldValue = {};
+
+var $$TypeError = /* @__PURE__ */Caml_exceptions.create("JSON.TypeError");
+
+function usingString(f, value) {
+  return Curry._1(f, value);
+}
+
+function usingInt(f, value) {
+  return Curry._1(f, value);
+}
+
+function usingFloat(f, value) {
+  return Curry._1(f, value);
+}
+
+function usingBoolean(f, value) {
+  return Curry._1(f, value);
+}
+
+function usingArray(f, value) {
+  return Curry._1(f, value);
+}
+
+function usingObject(f, value) {
+  return Curry._1(f, value);
+}
+
+function variadicInt(hint, fromJs) {
+  return {
+          TAG: /* Morphism */10,
+          _0: /* Int */2,
+          _1: (function (param) {
+              var internalValue = Curry._1(fromJs, param);
+              if (internalValue !== undefined) {
+                return Caml_option.valFromOption(internalValue);
+              }
+              throw {
+                    RE_EXN_ID: $$TypeError,
+                    _1: "This Int(" + String(param) + ") not a valid value here. Hint: " + hint + "",
+                    Error: new Error()
+                  };
+            })
+        };
+}
+
+function variadicString(hint, fromJs) {
+  return {
+          TAG: /* Morphism */10,
+          _0: /* String */1,
+          _1: (function (param) {
+              var internalValue = Curry._1(fromJs, param);
+              if (internalValue !== undefined) {
+                return Caml_option.valFromOption(internalValue);
+              }
+              throw {
+                    RE_EXN_ID: $$TypeError,
+                    _1: "This String(\"" + param + "\") not a valid value here. Hint: " + hint + "",
+                    Error: new Error()
+                  };
+            })
+        };
+}
+
+function toString(type_) {
+  if (typeof type_ === "number") {
+    switch (type_) {
+      case /* Any */0 :
+          return "Any";
+      case /* String */1 :
+          return "String";
+      case /* Int */2 :
+          return "Integer";
+      case /* Float */3 :
+          return "Float";
+      case /* Boolean */4 :
+          return "Boolean";
+      case /* Date */5 :
+      case /* Datetime */6 :
+          return "Date";
+      case /* Self */7 :
+          return "Self (recursive)";
+      
+    }
+  } else {
+    switch (type_.TAG | 0) {
+      case /* Literal */0 :
+          return "Literal: " + type_._0 + "";
+      case /* Array */1 :
+          return "Array of " + toString(type_._0);
+      case /* Tuple */2 :
+          return "Tuple of (" + Curry._2(Prelude.$$Array.map, type_._0, toString).join(", ") + ")";
+      case /* Object */3 :
+          var desc = Curry._2(Prelude.$$Array.map, type_._0, (function (param) {
+                    return "" + param[0] + ": " + toString(param[1]) + "";
+                  })).join(", ");
+          return "Object of {" + desc + "}";
+      case /* Optional */4 :
+      case /* OptionalWithDefault */5 :
+          return "Null of " + toString(type_._0);
+      case /* Mapping */6 :
+          return "Mapping of " + toString(type_._0) + "";
+      case /* Deserializer */7 :
+          return type_._0.name;
+      case /* Collection */8 :
+          return "Collection of " + type_._0.name;
+      case /* DefaultWhenInvalid */9 :
+          return "Protected " + toString(type_._0) + "";
+      case /* Morphism */10 :
+          return toString(type_._0) + " to apply a morphism";
+      
+    }
+  }
+}
+
+function _taggedToString(tagged) {
+  if (typeof tagged === "number") {
+    switch (tagged) {
+      case /* JSONFalse */0 :
+          return "Boolean(false)";
+      case /* JSONTrue */1 :
+          return "Boolean(true)";
+      case /* JSONNull */2 :
+          return "Null";
+      
+    }
+  } else {
+    switch (tagged.TAG | 0) {
+      case /* JSONString */0 :
+          return "String(\"" + tagged._0 + "\")";
+      case /* JSONNumber */1 :
+          return "Number(" + String(tagged._0) + ")";
+      case /* JSONObject */2 :
+          return "Object(" + Prelude.$$default(JSON.stringify(tagged._0), "...") + ")";
+      case /* JSONArray */3 :
+          return "Array(" + Prelude.$$default(JSON.stringify(tagged._0), "...") + ")";
+      
+    }
+  }
+}
+
+function extractValue(values, field, shape, self) {
+  var value = Curry._2(Prelude.Dict.get, values, field);
+  if (value !== undefined) {
+    return fromUntagged(Caml_option.valFromOption(value), shape, self);
+  }
+  if (typeof shape !== "number") {
+    switch (shape.TAG | 0) {
+      case /* OptionalWithDefault */5 :
+          return shape._1;
+      case /* Optional */4 :
+      case /* DefaultWhenInvalid */9 :
+          return fromUntagged(null, shape, self);
+      default:
+        
+    }
+  }
+  throw {
+        RE_EXN_ID: $$TypeError,
+        _1: "Missing non-optional field '" + field + "'",
+        Error: new Error()
+      };
+}
+
+function fromUntagged(untagged, _shape, self) {
+  while(true) {
+    var shape = _shape;
+    var match = Js_json.classify(untagged);
+    var exit = 0;
+    var s;
+    var f;
+    if (typeof shape === "number") {
+      switch (shape) {
+        case /* Any */0 :
+            return untagged;
+        case /* String */1 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONString */0) {
+                return match._0;
+              }
+              exit = 1;
+            }
+            break;
+        case /* Int */2 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONNumber */1) {
+                return match._0 | 0;
+              }
+              exit = 1;
+            }
+            break;
+        case /* Float */3 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONNumber */1) {
+                return match._0;
+              }
+              exit = 1;
+            }
+            break;
+        case /* Boolean */4 :
+            if (typeof match === "number") {
+              switch (match) {
+                case /* JSONFalse */0 :
+                    return false;
+                case /* JSONTrue */1 :
+                    return true;
+                case /* JSONNull */2 :
+                    exit = 1;
+                    break;
+                
+              }
+            } else {
+              exit = 1;
+            }
+            break;
+        case /* Date */5 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              switch (match.TAG | 0) {
+                case /* JSONString */0 :
+                    s = match._0;
+                    exit = 2;
+                    break;
+                case /* JSONNumber */1 :
+                    f = match._0;
+                    exit = 3;
+                    break;
+                default:
+                  exit = 1;
+              }
+            }
+            break;
+        case /* Datetime */6 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              switch (match.TAG | 0) {
+                case /* JSONString */0 :
+                    s = match._0;
+                    exit = 2;
+                    break;
+                case /* JSONNumber */1 :
+                    f = match._0;
+                    exit = 3;
+                    break;
+                default:
+                  exit = 1;
+              }
+            }
+            break;
+        case /* Self */7 :
+            _shape = self;
+            continue ;
+        
+      }
+    } else {
+      switch (shape.TAG | 0) {
+        case /* Literal */0 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONString */0) {
+                var text = match._0;
+                var expected = shape._0;
+                if (text === expected) {
+                  return text;
+                }
+                throw {
+                      RE_EXN_ID: $$TypeError,
+                      _1: "Expecting literal " + expected + ", got " + text + "",
+                      Error: new Error()
+                    };
+              }
+              exit = 1;
+            }
+            break;
+        case /* Array */1 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONArray */3) {
+                var shape$1 = shape._0;
+                return Curry._2(Prelude.$$Array.map, match._0, (function(shape$1){
+                          return function (item) {
+                            return fromUntagged(item, shape$1, self);
+                          }
+                          }(shape$1)));
+              }
+              exit = 1;
+            }
+            break;
+        case /* Tuple */2 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONArray */3) {
+                var items = match._0;
+                var bases = shape._0;
+                var lenbases = bases.length;
+                var lenitems = items.length;
+                if (lenbases === lenitems) {
+                  return Curry._3(Prelude.$$Array.zipBy, items, bases, (function (i, b) {
+                                return fromUntagged(i, b, self);
+                              }));
+                }
+                throw {
+                      RE_EXN_ID: $$TypeError,
+                      _1: "Expecting " + String(lenbases) + " items, got " + String(lenitems) + "",
+                      Error: new Error()
+                    };
+              }
+              exit = 1;
+            }
+            break;
+        case /* Object */3 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONObject */2) {
+                var values = match._0;
+                return Curry._1(Prelude.Dict.fromArray, Curry._2(Prelude.$$Array.map, shape._0, (function(values){
+                              return function (param) {
+                                var field = param[0];
+                                var value;
+                                try {
+                                  value = extractValue(values, field, param[1], self);
+                                }
+                                catch (raw_msg){
+                                  var msg = Caml_js_exceptions.internalToOCamlException(raw_msg);
+                                  if (msg.RE_EXN_ID === $$TypeError) {
+                                    throw {
+                                          RE_EXN_ID: $$TypeError,
+                                          _1: "Field \"" + field + "\": " + msg._1 + "",
+                                          Error: new Error()
+                                        };
+                                  }
+                                  throw msg;
+                                }
+                                return [
+                                        field,
+                                        value
+                                      ];
+                              }
+                              }(values))));
+              }
+              exit = 1;
+            }
+            break;
+        case /* Optional */4 :
+            var shape$2 = shape._0;
+            if (typeof match === "number") {
+              if (match >= 2) {
+                return undefined;
+              }
+              _shape = shape$2;
+              continue ;
+            }
+            _shape = shape$2;
+            continue ;
+        case /* OptionalWithDefault */5 :
+            var shape$3 = shape._0;
+            if (typeof match === "number") {
+              if (match >= 2) {
+                return shape._1;
+              }
+              _shape = shape$3;
+              continue ;
+            }
+            _shape = shape$3;
+            continue ;
+        case /* Mapping */6 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONObject */2) {
+                var f$1 = shape._0;
+                return Prelude.Dict.mapValues(match._0, (function(f$1){
+                          return function (v) {
+                            return fromUntagged(v, f$1, self);
+                          }
+                          }(f$1)));
+              }
+              exit = 1;
+            }
+            break;
+        case /* Deserializer */7 :
+            var res = Curry._1(shape._0.fromJSON, untagged);
+            if (res.TAG === /* Ok */0) {
+              return res._0;
+            }
+            throw {
+                  RE_EXN_ID: $$TypeError,
+                  _1: res._0,
+                  Error: new Error()
+                };
+        case /* Collection */8 :
+            if (typeof match === "number") {
+              exit = 1;
+            } else {
+              if (match.TAG === /* JSONArray */3) {
+                return Curry._2(Prelude.$$Array.map, Prelude.$$Array.keepSome(Curry._2(Prelude.$$Array.map, Curry._2(Prelude.$$Array.map, match._0, shape._0.fromJSON), Prelude.Result.warn)), (function (prim) {
+                              return prim;
+                            }));
+              }
+              exit = 1;
+            }
+            break;
+        case /* DefaultWhenInvalid */9 :
+            try {
+              return fromUntagged(untagged, shape._0, self);
+            }
+            catch (raw_msg){
+              var msg = Caml_js_exceptions.internalToOCamlException(raw_msg);
+              if (msg.RE_EXN_ID === $$TypeError) {
+                console.warn("Detected and ignore (with default): ", msg._1);
+                return shape._1;
+              }
+              throw msg;
+            }
+        case /* Morphism */10 :
+            return Curry._1(shape._1, fromUntagged(untagged, shape._0, self));
+        
+      }
+    }
+    switch (exit) {
+      case 1 :
+          throw {
+                RE_EXN_ID: $$TypeError,
+                _1: "Expected " + toString(shape) + ", but got " + _taggedToString(match) + " instead",
+                Error: new Error()
+              };
+      case 2 :
+          var r = new Date(s);
+          if (Number.isNaN(r.getDate())) {
+            throw {
+                  RE_EXN_ID: $$TypeError,
+                  _1: "Invalid date " + s + "",
+                  Error: new Error()
+                };
+          }
+          return r;
+      case 3 :
+          var r$1 = new Date(f);
+          if (Number.isNaN(r$1.getDate())) {
+            throw {
+                  RE_EXN_ID: $$TypeError,
+                  _1: "Invalid date " + f.toString() + "",
+                  Error: new Error()
+                };
+          }
+          return r$1;
+      
+    }
+  };
+}
+
+function checkFieldsSanity(name, _fields, _optional) {
+  while(true) {
+    var optional = _optional;
+    var fields = _fields;
+    var exit = 0;
+    if (typeof fields === "number") {
+      switch (fields) {
+        case /* Any */0 :
+        case /* Boolean */4 :
+        case /* Date */5 :
+        case /* Datetime */6 :
+            return {
+                    TAG: /* Ok */0,
+                    _0: undefined
+                  };
+        case /* Self */7 :
+            if (optional) {
+              return {
+                      TAG: /* Ok */0,
+                      _0: undefined
+                    };
+            } else {
+              return {
+                      TAG: /* Error */1,
+                      _0: "" + name + ": Trivial infinite recursion 'let fields = Self'"
+                    };
+            }
+        default:
+          return {
+                  TAG: /* Ok */0,
+                  _0: undefined
+                };
+      }
+    } else {
+      switch (fields.TAG | 0) {
+        case /* Tuple */2 :
+            return Curry._2(Prelude.ManyResults.map, Prelude.ManyResults.bailU(Curry._2(Prelude.$$Array.mapWithIndex, fields._0, (function(optional){
+                              return function (index, field, param) {
+                                return checkFieldsSanity("" + name + "[" + String(index) + "]", field, optional);
+                              }
+                              }(optional)))), (function (param) {
+                          
+                        }));
+        case /* Object */3 :
+            return Curry._2(Prelude.ManyResults.map, Prelude.ManyResults.bailU(Curry._2(Prelude.$$Array.map, fields._0, (function(optional){
+                              return function (param, param$1) {
+                                return checkFieldsSanity("" + name + "::" + param[0] + "", param[1], optional);
+                              }
+                              }(optional)))), (function (param) {
+                          
+                        }));
+        case /* Array */1 :
+        case /* Mapping */6 :
+            _optional = true;
+            _fields = fields._0;
+            continue ;
+        case /* Deserializer */7 :
+        case /* Collection */8 :
+            exit = 2;
+            break;
+        case /* Optional */4 :
+        case /* OptionalWithDefault */5 :
+        case /* DefaultWhenInvalid */9 :
+            exit = 1;
+            break;
+        case /* Morphism */10 :
+            return {
+                    TAG: /* Ok */0,
+                    _0: undefined
+                  };
+        default:
+          return {
+                  TAG: /* Ok */0,
+                  _0: undefined
+                };
+      }
+    }
+    switch (exit) {
+      case 1 :
+          _optional = true;
+          _fields = fields._0;
+          continue ;
+      case 2 :
+          var msg = Curry._1(fields._0.checkFieldsSanity, undefined);
+          if (msg.TAG === /* Ok */0) {
+            return {
+                    TAG: /* Ok */0,
+                    _0: undefined
+                  };
+          } else {
+            return {
+                    TAG: /* Error */1,
+                    _0: "" + name + "/ " + msg._0 + ""
+                  };
+          }
+      
+    }
+  };
+}
+
+var Field = {
+  usingString: usingString,
+  usingInt: usingInt,
+  usingFloat: usingFloat,
+  usingBoolean: usingBoolean,
+  usingArray: usingArray,
+  usingObject: usingObject,
+  variadicInt: variadicInt,
+  variadicString: variadicString,
+  toString: toString,
+  _taggedToString: _taggedToString,
+  extractValue: extractValue,
+  fromUntagged: fromUntagged,
+  checkFieldsSanity: checkFieldsSanity
+};
+
+function MakeDeserializer(S) {
+  var fields = S.fields;
+  var name = "Deserializer " + "JSON" + ", " + "File \"JSON.res\", line 321, characters 39-47" + "";
+  var checkFieldsSanity$1 = function (param) {
+    return checkFieldsSanity(name, fields, false);
+  };
+  var fromJSON = function (json) {
+    var res;
+    try {
+      res = fromUntagged(json, fields, fields);
+    }
+    catch (raw_e){
+      var e = Caml_js_exceptions.internalToOCamlException(raw_e);
+      if (e.RE_EXN_ID === $$TypeError) {
+        return {
+                TAG: /* Error */1,
+                _0: e._1
+              };
+      }
+      throw e;
+    }
+    return {
+            TAG: /* Ok */0,
+            _0: res
+          };
+  };
+  return {
+          name: name,
+          fromJSON: fromJSON,
+          checkFieldsSanity: checkFieldsSanity$1
+        };
+}
+
+exports.FieldValue = FieldValue;
+exports.$$TypeError = $$TypeError;
+exports.Field = Field;
+exports.MakeDeserializer = MakeDeserializer;
+/* No side effect */

package/lib/js/tests/QUnit.js

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */