@kaiko.io/rescript-deser 4.0.0-rc.3 → 4.0.0-rc.4

package/lib/js/src/JSON.js

@@ -0,0 +1,649 @@
+// 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) {
+  return function (value) {
+    return f(value);
+  };
+}
+
+function usingInt(f) {
+  return function (value) {
+    return f(value);
+  };
+}
+
+function usingFloat(f) {
+  return function (value) {
+    return f(value);
+  };
+}
+
+function usingBoolean(f) {
+  return function (value) {
+    return f(value);
+  };
+}
+
+function usingArray(f) {
+  return function (value) {
+    return f(value);
+  };
+}
+
+function usingObject(f) {
+  return function (value) {
+    return f(value);
+  };
+}
+
+function variadicInt(hint, fromJs) {
+  return {
+          TAG: "Morphism",
+          _0: "Int",
+          _1: (function (value) {
+              var internalValue = fromJs(value);
+              if (internalValue !== undefined) {
+                return Caml_option.valFromOption(internalValue);
+              }
+              throw {
+                    RE_EXN_ID: $$TypeError,
+                    _1: "This Int(" + String(value) + ") not a valid value here. Hint: " + hint,
+                    Error: new Error()
+                  };
+            })
+        };
+}
+
+function variadicString(hint, fromJs) {
+  return {
+          TAG: "Morphism",
+          _0: "String",
+          _1: (function (value) {
+              var internalValue = fromJs(value);
+              if (internalValue !== undefined) {
+                return Caml_option.valFromOption(internalValue);
+              }
+              throw {
+                    RE_EXN_ID: $$TypeError,
+                    _1: "This String(\"" + value + "\") not a valid value here. Hint: " + hint,
+                    Error: new Error()
+                  };
+            })
+        };
+}
+
+function toString(type_) {
+  if (typeof type_ !== "object") {
+    switch (type_) {
+      case "Any" :
+          return "Any";
+      case "String" :
+          return "String";
+      case "Int" :
+          return "Integer";
+      case "Float" :
+          return "Float";
+      case "Boolean" :
+          return "Boolean";
+      case "Date" :
+      case "Datetime" :
+          return "Date";
+      case "Self" :
+          return "Self (recursive)";
+      
+    }
+  } else {
+    switch (type_.TAG) {
+      case "Literal" :
+          return "Literal: " + type_._0;
+      case "Array" :
+          return "Array of " + toString(type_._0);
+      case "Tuple" :
+          return "Tuple of (" + type_._0.map(toString).join(", ") + ")";
+      case "Object" :
+          var desc = type_._0.map(function (param) {
+                  return param[0] + ": " + toString(param[1]);
+                }).join(", ");
+          return "Object of {" + desc + "}";
+      case "Optional" :
+      case "OptionalWithDefault" :
+          return "Null of " + toString(type_._0);
+      case "Mapping" :
+          return "Mapping of " + toString(type_._0);
+      case "Deserializer" :
+          return type_._0.name;
+      case "Collection" :
+          return "Collection of " + type_._0.name;
+      case "DefaultWhenInvalid" :
+          return "Protected " + toString(type_._0);
+      case "Morphism" :
+          return toString(type_._0) + " to apply a morphism";
+      
+    }
+  }
+}
+
+function _taggedToString(tagged) {
+  if (typeof tagged !== "object") {
+    switch (tagged) {
+      case "JSONFalse" :
+          return "Boolean(false)";
+      case "JSONTrue" :
+          return "Boolean(true)";
+      case "JSONNull" :
+          return "Null";
+      
+    }
+  } else {
+    switch (tagged.TAG) {
+      case "JSONString" :
+          return "String(\"" + tagged._0 + "\")";
+      case "JSONNumber" :
+          return "Number(" + String(tagged._0) + ")";
+      case "JSONObject" :
+          return "Object(" + Prelude.default(JSON.stringify(tagged._0), "...") + ")";
+      case "JSONArray" :
+          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(value, shape, self);
+  }
+  if (typeof shape === "object") {
+    switch (shape.TAG) {
+      case "OptionalWithDefault" :
+          return shape._1;
+      case "Optional" :
+      case "DefaultWhenInvalid" :
+          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 !== "object") {
+      switch (shape) {
+        case "Any" :
+            return untagged;
+        case "String" :
+            if (typeof match !== "object") {
+              exit = 1;
+            } else {
+              if (match.TAG === "JSONString") {
+                return match._0;
+              }
+              exit = 1;
+            }
+            break;
+        case "Int" :
+            if (typeof match !== "object") {
+              exit = 1;
+            } else {
+              if (match.TAG === "JSONNumber") {
+                return match._0 | 0;
+              }
+              exit = 1;
+            }
+            break;
+        case "Float" :
+            if (typeof match !== "object") {
+              exit = 1;
+            } else {
+              if (match.TAG === "JSONNumber") {
+                return match._0;
+              }
+              exit = 1;
+            }
+            break;
+        case "Boolean" :
+            if (typeof match !== "object") {
+              switch (match) {
+                case "JSONFalse" :
+                    return false;
+                case "JSONTrue" :
+                    return true;
+                default:
+                  exit = 1;
+              }
+            } else {
+              exit = 1;
+            }
+            break;
+        case "Date" :
+            if (typeof match !== "object") {
+              exit = 1;
+            } else {
+              switch (match.TAG) {
+                case "JSONString" :
+                    s = match._0;
+                    exit = 2;
+                    break;
+                case "JSONNumber" :
+                    f = match._0;
+                    exit = 3;
+                    break;
+                default:
+                  exit = 1;
+              }
+            }
+            break;
+        case "Datetime" :
+            if (typeof match !== "object") {
+              exit = 1;
+            } else {
+              switch (match.TAG) {
+                case "JSONString" :
+                    s = match._0;
+                    exit = 2;
+                    break;
+                case "JSONNumber" :
+                    f = match._0;
+                    exit = 3;
+                    break;
+                default:
+                  exit = 1;
+              }
+            }
+            break;
+        case "Self" :
+            _shape = self;
+            continue ;
+        
+      }
+    } else {
+      switch (shape.TAG) {
+        case "Literal" :
+            if (typeof match !== "object") {
+              exit = 1;
+            } else {
+              if (match.TAG === "JSONString") {
+                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" :
+            if (typeof match !== "object") {
+              exit = 1;
+            } else {
+              if (match.TAG === "JSONArray") {
+                var shape$1 = shape._0;
+                return match._0.map((function(shape$1){
+                          return function (item) {
+                            return fromUntagged(item, shape$1, self);
+                          }
+                          }(shape$1)));
+              }
+              exit = 1;
+            }
+            break;
+        case "Tuple" :
+            if (typeof match !== "object") {
+              exit = 1;
+            } else {
+              if (match.TAG === "JSONArray") {
+                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" :
+            if (typeof match !== "object") {
+              exit = 1;
+            } else {
+              if (match.TAG === "JSONObject") {
+                var values = match._0;
+                return Curry._1(Prelude.Dict.fromArray, shape._0.map((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" :
+            var shape$2 = shape._0;
+            if (typeof match !== "object") {
+              if (match === "JSONNull") {
+                return undefined;
+              }
+              _shape = shape$2;
+              continue ;
+            } else {
+              _shape = shape$2;
+              continue ;
+            }
+        case "OptionalWithDefault" :
+            var shape$3 = shape._0;
+            if (typeof match !== "object") {
+              if (match === "JSONNull") {
+                return shape._1;
+              }
+              _shape = shape$3;
+              continue ;
+            } else {
+              _shape = shape$3;
+              continue ;
+            }
+        case "Mapping" :
+            if (typeof match !== "object") {
+              exit = 1;
+            } else {
+              if (match.TAG === "JSONObject") {
+                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" :
+            var res = shape._0.fromJSON(untagged);
+            if (res.TAG === "Ok") {
+              return res._0;
+            }
+            throw {
+                  RE_EXN_ID: $$TypeError,
+                  _1: res._0,
+                  Error: new Error()
+                };
+        case "Collection" :
+            if (typeof match !== "object") {
+              exit = 1;
+            } else {
+              if (match.TAG === "JSONArray") {
+                return Prelude.$$Array.keepSome(match._0.map((function(shape){
+                                  return function (param) {
+                                    return Curry._1(shape._0.fromJSON, param);
+                                  }
+                                  }(shape))).map(Prelude.Result.warn)).map(function (prim) {
+                            return prim;
+                          });
+              }
+              exit = 1;
+            }
+            break;
+        case "DefaultWhenInvalid" :
+            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" :
+            return 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 !== "object") {
+      switch (fields) {
+        case "Any" :
+        case "Boolean" :
+        case "Date" :
+        case "Datetime" :
+            return {
+                    TAG: "Ok",
+                    _0: undefined
+                  };
+        case "Self" :
+            if (optional) {
+              return {
+                      TAG: "Ok",
+                      _0: undefined
+                    };
+            } else {
+              return {
+                      TAG: "Error",
+                      _0: name + ": Trivial infinite recursion 'let fields = Self'"
+                    };
+            }
+        default:
+          return {
+                  TAG: "Ok",
+                  _0: undefined
+                };
+      }
+    } else {
+      switch (fields.TAG) {
+        case "Tuple" :
+            return Curry._2(Prelude.ManyResults.map, Prelude.ManyResults.bailU(fields._0.map((function(optional){
+                              return function (field, index) {
+                                return function () {
+                                  return checkFieldsSanity(name + "[" + String(index) + "]", field, optional);
+                                };
+                              }
+                              }(optional)))), (function (param) {
+                          
+                        }));
+        case "Object" :
+            return Curry._2(Prelude.ManyResults.map, Prelude.ManyResults.bailU(fields._0.map((function(optional){
+                              return function (param) {
+                                var field = param[1];
+                                var fieldName = param[0];
+                                return function () {
+                                  return checkFieldsSanity(name + "::" + fieldName, field, optional);
+                                };
+                              }
+                              }(optional)))), (function (param) {
+                          
+                        }));
+        case "Array" :
+        case "Mapping" :
+            _optional = true;
+            _fields = fields._0;
+            continue ;
+        case "Deserializer" :
+        case "Collection" :
+            exit = 2;
+            break;
+        case "Optional" :
+        case "OptionalWithDefault" :
+        case "DefaultWhenInvalid" :
+            exit = 1;
+            break;
+        case "Morphism" :
+            return {
+                    TAG: "Ok",
+                    _0: undefined
+                  };
+        default:
+          return {
+                  TAG: "Ok",
+                  _0: undefined
+                };
+      }
+    }
+    switch (exit) {
+      case 1 :
+          _optional = true;
+          _fields = fields._0;
+          continue ;
+      case 2 :
+          var msg = fields._0.checkFieldsSanity();
+          if (msg.TAG === "Ok") {
+            return {
+                    TAG: "Ok",
+                    _0: undefined
+                  };
+          } else {
+            return {
+                    TAG: "Error",
+                    _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 320, characters 39-47";
+  var checkFieldsSanity$1 = function () {
+    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",
+                _0: e._1
+              };
+      }
+      throw e;
+    }
+    return {
+            TAG: "Ok",
+            _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. */